/* This file is part of the KDE project
 Copyright (C) 2010 Dag Andersen <danders@get2net.dk>

 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Library General Public
 License as published by the Free Software Foundation; either
 version 2 of the License, or (at your option) any later version.

 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 Library General Public License for more details.

 You should have received a copy of the GNU Library General Public License
 along with this library; see the file COPYING.LIB.  If not, write to
 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 Boston, MA 02110-1301, USA.
*/

#include "KPlatoXmlLoaderBase.h"

#include "kptlocale.h"
#include "kptxmlloaderobject.h"
#include "kptnode.h"
#include "kptproject.h"
#include "kpttask.h"
#include "kptcalendar.h"
#include "kptschedule.h"
#include "kptrelation.h"
#include "kptresource.h"
#include "kptaccount.h"
#include "kptappointment.h"

#include <KoXmlReader.h>

#include <KLocalizedString>

#include <QTimeZone>


using namespace KPlato;

KPlatoXmlLoaderBase::KPlatoXmlLoaderBase()
{
}

bool KPlatoXmlLoaderBase::load( Project *project, const KoXmlElement &element, XMLLoaderObject &status )
{
    debugPlanXml<<"project";
    // load locale first
    KoXmlNode n = element.firstChild();
    for ( ; ! n.isNull(); n = n.nextSibling() ) {
        if ( ! n.isElement() ) {
            continue;
        }
        KoXmlElement e = n.toElement();
        if ( e.tagName() == "locale" ) {
            Locale *l = project->locale();
            l->setCurrencySymbol( e.attribute( "currency-symbol", l->currencySymbol() ) );
            //NOTE: decimalplaces missing
        }
    }
    QList<Calendar*> cals;
    QString s;
    bool ok = false;
    project->setName( element.attribute( "name" ) );
    project->removeId( project->id() );
    project->setId( element.attribute( "id" ) );
    project->registerNodeId( project );
    project->setLeader( element.attribute( "leader" ) );
    project->setDescription( element.attribute( "description" ) );
    QTimeZone tz( element.attribute( "timezone" ).toLatin1() );

    if ( tz.isValid() ) {
        project->setTimeZone( tz );
    } else warnPlanXml<<"No timezone specified, using default (local)";
    status.setProjectTimeZone( project->timeZone() );

    // Allow for both numeric and text
    s = element.attribute( "scheduling", "0" );
    project->setConstraint( ( Node::ConstraintType ) ( s.toInt( &ok ) ) );
    if ( ! ok )
        project->setConstraint( s );
    if ( project->constraint() != Node::MustStartOn && project->constraint() != Node::MustFinishOn ) {
        errorPlanXml << "Illegal constraint: " << project->constraintToString();
        project->setConstraint( Node::MustStartOn );
    }
    s = element.attribute( "start-time" );
    if ( ! s.isEmpty() ) {
        project->setConstraintStartTime( DateTime::fromString( s, project->timeZone() ) );
    }
    s = element.attribute( "end-time" );
    if ( ! s.isEmpty() ) {
        project->setConstraintEndTime( DateTime::fromString( s, project->timeZone() ) );
    }
    // Load the project children
    // Do calendars first, they only reference other calendars
    //debugPlanXml<<"Calendars--->";
    n = element.firstChild();
    for ( ; ! n.isNull(); n = n.nextSibling() ) {
        if ( ! n.isElement() ) {
            continue;
        }
        KoXmlElement e = n.toElement();
        if ( e.tagName() == "calendar" ) {
            // Load the calendar.
            // Referenced by resources
            Calendar * child = new Calendar();
            child->setProject( project );
            if ( load( child, e, status ) ) {
                cals.append( child ); // temporary, reorder later
            } else {
                // TODO: Complain about this
                errorPlanXml << "Failed to load calendar";
                delete child;
            }
        } else if ( e.tagName() == "standard-worktime" ) {
            // Load standard worktime
            StandardWorktime * child = new StandardWorktime();
            if ( load( child, e, status ) ) {
                project->setStandardWorktime( child );
            } else {
                errorPlanXml << "Failed to load standard worktime";
                delete child;
            }
        }
    }
    // calendars references calendars in arbritary saved order
    bool added = false;
    do {
        added = false;
        QList<Calendar*> lst;
        while ( !cals.isEmpty() ) {
            Calendar *c = cals.takeFirst();
            if ( c->parentId().isEmpty() ) {
                project->addCalendar( c, status.baseCalendar() ); // handle pre 0.6 version
                added = true;
                //debugPlanXml<<"added to project:"<<c->name();
            } else {
                Calendar *par = project->calendar( c->parentId() );
                if ( par ) {
                    project->addCalendar( c, par );
                    added = true;
                    //debugPlanXml<<"added:"<<c->name()<<" to parent:"<<par->name();
                } else {
                    lst.append( c ); // treat later
                    //debugPlanXml<<"treat later:"<<c->name();
                }
            }
        }
        cals = lst;
    } while ( added );
    if ( ! cals.isEmpty() ) {
        errorPlanXml<<"All calendars not saved!";
    }
    //debugPlanXml<<"Calendars<---";
    // Resource groups and resources, can reference calendars
    n = element.firstChild();
    for ( ; ! n.isNull(); n = n.nextSibling() ) {
        if ( ! n.isElement() ) {
            continue;
        }
        KoXmlElement e = n.toElement();
        if ( e.tagName() == "resource-group" ) {
            // Load the resources
            // References calendars
            ResourceGroup * child = new ResourceGroup();
            if ( load( child, e, status ) ) {
                project->addResourceGroup( child );
            } else {
                // TODO: Complain about this
                delete child;
            }
        }
    }
    // The main stuff
    n = element.firstChild();
    for ( ; ! n.isNull(); n = n.nextSibling() ) {
        if ( ! n.isElement() ) {
            continue;
        }
        KoXmlElement e = n.toElement();
        if ( e.tagName() == "project" ) {
            //debugPlanXml<<"Sub project--->";
/*                // Load the subproject
            Project * child = new Project( this );
            if ( child->load( e ) ) {
                if ( !addTask( child, this ) ) {
                    delete child; // TODO: Complain about this
                }
            } else {
                // TODO: Complain about this
                delete child;
            }*/
        } else if ( e.tagName() == "task" ) {
            //debugPlanXml<<"Task--->";
            // Load the task (and resourcerequests).
            // Depends on resources already loaded
            Task *child = new Task( project );
            if ( load( child, e, status ) ) {
                if ( ! project->addTask( child, project ) ) {
                    delete child; // TODO: Complain about this
                }
            } else {
                // TODO: Complain about this
                delete child;
            }
        }
    }
    // These go last
    n = element.firstChild();
    for ( ; ! n.isNull(); n = n.nextSibling() ) {
        debugPlanXml<<n.isElement();
        if ( ! n.isElement() ) {
            continue;
        }
        KoXmlElement e = n.toElement();
        if ( e.tagName() == "accounts" ) {
            //debugPlanXml<<"Accounts--->";
            // Load accounts
            // References tasks
            if ( ! load( project->accounts(), e, status ) ) {
                errorPlanXml << "Failed to load accounts";
            }
        } else if ( e.tagName() == "relation" ) {
            //debugPlanXml<<"Relation--->";
            // Load the relation
            // References tasks
            Relation * child = new Relation();
            if ( ! load( child, e, status ) ) {
                // TODO: Complain about this
                errorPlanXml << "Failed to load relation";
                delete child;
            }
            //debugPlanXml<<"Relation<---";
        } else if ( e.tagName() == "schedules" ) {
            debugPlanXml<<"Project schedules & task appointments--->";
            // References tasks and resources
            KoXmlNode sn = e.firstChild();
            for ( ; ! sn.isNull(); sn = sn.nextSibling() ) {
                if ( ! sn.isElement() ) {
                    continue;
                }
                KoXmlElement el = sn.toElement();
                //debugPlanXml<<el.tagName()<<" Version="<<status.version();
                ScheduleManager *sm = 0;
                bool add = false;
                if ( status.version() <= "0.5" ) {
                    if ( el.tagName() == "schedule" ) {
                        sm = project->findScheduleManagerByName( el.attribute( "name" ) );
                        if ( sm == 0 ) {
                            sm = new ScheduleManager( *project, el.attribute( "name" ) );
                            add = true;
                        }
                    }
                } else if ( el.tagName() == "plan" ) {
                    sm = new ScheduleManager( *project );
                    add = true;
                }
                if ( sm ) {
                    if ( load( sm, el, status ) ) {
                        if ( add )
                            project->addScheduleManager( sm );
                    } else {
                        errorPlanXml << "Failed to load schedule manager";
                        delete sm;
                    }
                } else {
                    debugPlanXml<<"No schedule manager ?!";
                }
            }
            debugPlanXml<<"Project schedules & task appointments<---";
        } else if ( e.tagName() == "resource-teams" ) {
            //debugPlanXml<<"Resource teams--->";
            // References other resources
            KoXmlNode tn = e.firstChild();
            for ( ; ! tn.isNull(); tn = tn.nextSibling() ) {
                if ( ! tn.isElement() ) {
                    continue;
                }
                KoXmlElement el = tn.toElement();
                if ( el.tagName() == "team" ) {
                    Resource *r = project->findResource( el.attribute( "team-id" ) );
                    Resource *tm = project->findResource( el.attribute( "member-id" ) );
                    if ( r == 0 || tm == 0 ) {
                        errorPlanXml<<"resource-teams: cannot find resources";
                        continue;
                    }
                    if ( r == tm ) {
                        errorPlanXml<<"resource-teams: a team cannot be a member of itself";
                        continue;
                    }
                    r->addTeamMemberId( tm->id() );
                } else {
                    errorPlanXml<<"resource-teams: unhandled tag"<<el.tagName();
                }
            }
            //debugPlanXml<<"Resource teams<---";
        } else if ( e.tagName() == "wbs-definition" ) {
            load( project->wbsDefinition(), e, status );
        } else if ( e.tagName() == "locale" ) {
            // handled earlier
        } else if ( e.tagName() == "resource-group" ) {
            // handled earlier
        } else if ( e.tagName() == "calendar" ) {
            // handled earlier
        } else if ( e.tagName() == "standard-worktime" ) {
            // handled earlier
        } else if ( e.tagName() == "project" ) {
            // handled earlier
        } else if ( e.tagName() == "task" ) {
            // handled earlier
        } else {
            warnPlanXml<<"Unhandled tag:"<<e.tagName();
        }
    }
    // set schedule parent
    foreach ( Schedule *s, project->schedules() ) {
        project->setParentSchedule( s );
    }

    debugPlanXml<<"Project loaded:"<<project<<project->name()<<project->allNodes();
    return true;
}

bool KPlatoXmlLoaderBase::load( Task *task, const KoXmlElement &element, XMLLoaderObject &status )
{
    debugPlanXml<<"task";
    QString s;
    bool ok = false;
    task->setId( element.attribute("id") );

    task->setName( element.attribute("name") );
    task->setLeader( element.attribute("leader") );
    task->setDescription( element.attribute("description") );
    //debugPlanXml<<m_name<<": id="<<m_id;

    // Allow for both numeric and text
    QString constraint = element.attribute("scheduling","0");
    task->setConstraint( (Node::ConstraintType)constraint.toInt(&ok) );
    if ( ! ok ) {
        task->setConstraint( constraint );
    }
    s = element.attribute("constraint-starttime");
    if ( ! s.isEmpty() ) {
        task->setConstraintStartTime( DateTime::fromString( s, status.projectTimeZone() ) );
    }
    s = element.attribute("constraint-endtime");
    if ( ! s.isEmpty() ) {
        task->setConstraintEndTime( DateTime::fromString( s, status.projectTimeZone() ) );
    }
    task->setStartupCost( element.attribute("startup-cost", "0.0").toDouble() );
    task->setShutdownCost( element.attribute("shutdown-cost", "0.0").toDouble() );

    // Load the task children
    KoXmlNode n = element.firstChild();
    for ( ; ! n.isNull(); n = n.nextSibling() ) {
        if ( ! n.isElement() ) {
            continue;
        }
        KoXmlElement e = n.toElement();
        if (e.tagName() == "project") {
            // Load the subproject
/*                Project *child = new Project(this, status);
            if (child->load(e)) {
                if (!project.addSubTask(child, this)) {
                    delete child;  // TODO: Complain about this
                }
            } else {
                // TODO: Complain about this
                delete child;
            }*/
        } else if (e.tagName() == "task") {
            // Load the task
            Task *child = new Task( task );
            if ( load( child, e, status) ) {
                if ( ! status.project().addSubTask( child, task ) ) {
                    delete child;  // TODO: Complain about this
                }
            } else {
                // TODO: Complain about this
                delete child;
            }
        } else if ( e.tagName() == "resource" ) {
            // tasks don't have resources
        } else if (e.tagName() == "estimate" || ( /*status.version() < "0.6" &&*/ e.tagName() == "effort" ) ) {
            //  Load the estimate
            load( task->estimate(), e, status);
        } else if ( e.tagName() == "resourcegroup-request" ) {
            // Load the resource request
            // Handle multiple requests to same group gracefully (Not really allowed)
            ResourceGroupRequest *r = task->requests().findGroupRequestById( e.attribute( "group-id" ) );
            if ( r ) {
                warnPlanXml<<"Multiple requests to same group, loading into existing group";
                if ( ! load( r, e, status ) ) {
                    errorPlanXml<<"Failed to load resource request";
                }
            } else {
                r = new ResourceGroupRequest();
                if ( load( r, e, status ) ) {
                    task->addRequest(r);
                } else {
                    errorPlanXml<<"Failed to load resource request";
                    delete r;
                }
            }
        } else if ( e.tagName() == "workpackage" ) {
            load( task->workPackage(), e, status );
        } else if ( e.tagName() == "progress" ) {
            load( task->completion(), e, status );
        } else if ( e.tagName() == "schedules" ) {
            KoXmlNode n = e.firstChild();
            for ( ; ! n.isNull(); n = n.nextSibling() ) {
                if ( ! n.isElement() ) {
                    continue;
                }
                KoXmlElement el = n.toElement();
                if ( el.tagName() == "schedule" ) {
                    NodeSchedule *sch = new NodeSchedule();
                    if ( loadNodeSchedule( sch, el, status ) ) {
                        sch->setNode( task );
                        task->addSchedule( sch );
                    } else {
                        errorPlanXml<<"Failed to load schedule";
                        delete sch;
                    }
                }
            }
        } else if (e.tagName() == "documents") {
            load( task->documents(), e, status );
        } else if ( e.tagName() == "workpackage-log" ) {
            KoXmlNode n = e.firstChild();
            for ( ; ! n.isNull(); n = n.nextSibling() ) {
                if ( ! n.isElement() ) {
                    continue;
                }
                KoXmlElement el = n.toElement();
                if ( el.tagName() == "workpackage" ) {
                    WorkPackage *wp = new WorkPackage( task );
                    if ( loadWpLog( wp, el, status ) ) {
                        task->addWorkPackage( wp );
                    } else {
                        errorPlanXml<<"Failed to load logged workpackage";
                        delete wp;
                    }
                }
            }
        }
    }
    //debugPlanXml<<m_name<<" loaded";
    return true;
}

bool KPlatoXmlLoaderBase::load( Calendar *calendar, const KoXmlElement &element, XMLLoaderObject &status )
{
    debugPlanXml<<"calendar"<<element.text();
    //bool ok;
    calendar->setId( element.attribute( "id" ) );
    calendar->setParentId( element.attribute( "parent" ) );
    calendar->setName( element.attribute( "name","" ) );
    QTimeZone tz( element.attribute( "timezone" ).toLatin1() );
    if ( tz.isValid() ) {
        calendar->setTimeZone( tz );
    } else warnPlanXml<<"No timezone specified, use default (local)";
    bool dc = (bool)element.attribute( "default","0" ).toInt();
    if ( dc ) {
        status.project().setDefaultCalendar( calendar );
    }
    KoXmlNode n = element.firstChild();
    for ( ; ! n.isNull(); n = n.nextSibling() ) {
        if ( ! n.isElement() ) {
            continue;
        }
        KoXmlElement e = n.toElement();
        if (e.tagName() == "weekday") {
            if ( ! load( calendar->weekdays(), e, status ) ) {
                return false;
            }
        }
        if ( e.tagName() == "day" ) {
            CalendarDay *day = new CalendarDay();
            if ( load( day, e, status ) ) {
                if ( ! day->date().isValid() ) {
                    delete day;
                    errorPlanXml<<calendar->name()<<": Failed to load calendarDay - Invalid date";
                } else {
                    CalendarDay *d = calendar->findDay( day->date() );
                    if ( d ) {
                        // already exists, keep the new
                        delete calendar->takeDay(d);
                        warnPlanXml<<calendar->name()<<" Load calendarDay - Date already exists";
                    }
                    calendar->addDay( day );
                }
            } else {
                delete day;
                errorPlanXml<<"Failed to load calendarDay";
                return true; // don't throw away the whole calendar
            }
        }
    }
    return true;
}

bool KPlatoXmlLoaderBase::load( CalendarDay *day, const KoXmlElement &element, XMLLoaderObject &status )
{
    debugPlanXml<<"day";
    bool ok=false;
    day->setState( QString( element.attribute( "state", "-1" ) ).toInt( &ok ) );
    if ( day->state() < 0 ) {
        return false;
    }
    //debugPlanXml<<" state="<<m_state;
    QString s = element.attribute( "date" );
    if ( ! s.isEmpty() ) {
        day->setDate( QDate::fromString( s, Qt::ISODate ) );
        if ( ! day->date().isValid() ) {
            day->setDate( QDate::fromString( s ) );
        }
    }
    day->clearIntervals();
    KoXmlNode n = element.firstChild();
    for ( ; ! n.isNull(); n = n.nextSibling() ) {
        if ( ! n.isElement() ) {
            continue;
        }
        KoXmlElement e = n.toElement();
        if ( e.tagName() == "interval" ) {
            //debugPlanXml<<"Interval start="<<e.attribute("start")<<" end="<<e.attribute("end");
            QString st = e.attribute("start");
            if (st.isEmpty() ) {
                errorPlanXml<<"Empty interval";
                continue;
            }
            QTime start = QTime::fromString( st );
            int length = 0;
            if ( status.version() <= "0.6.1" ) {
                QString en = e.attribute( "end" );
                if ( en.isEmpty() ) {
                    errorPlanXml<<"Invalid interval end";
                    continue;
                }
                QTime end = QTime::fromString( en );
                length = start.msecsTo( end );
            } else {
                length = e.attribute("length", "0").toInt();
            }
            if ( length <= 0 ) {
                errorPlanXml<<"Invalid interval length";
                continue;
            }
            day->addInterval( new TimeInterval( start, length ) );
        }
    }
    return true;
}

bool KPlatoXmlLoaderBase::load( CalendarWeekdays *weekdays, const KoXmlElement& element, XMLLoaderObject& status)
{
    debugPlanXml<<"weekdays";
    bool ok;
    int dayNo = QString( element.attribute( "day","-1" ) ).toInt( &ok );
    if (dayNo < 0 || dayNo > 6) {
        errorPlanXml<<"Illegal weekday: "<<dayNo;
        return true; // we continue anyway
    }
    CalendarDay *day = weekdays->weekday( dayNo + 1 );
    if ( day == 0 ) {
        errorPlanXml<<"No weekday: "<<dayNo;
        return false;
    }
    if ( ! load( day, element, status ) ) {
        day->setState( CalendarDay::None );
    }
    return true;

}

bool KPlatoXmlLoaderBase::load( StandardWorktime *swt, const KoXmlElement &element, XMLLoaderObject &status )
{
    debugPlanXml<<"swt";
    swt->setYear( Duration::fromString( element.attribute( "year" ), Duration::Format_Hour ) );
    swt->setMonth( Duration::fromString( element.attribute( "month" ), Duration::Format_Hour ) );
    swt->setWeek( Duration::fromString( element.attribute( "week" ), Duration::Format_Hour ) );
    swt->setDay( Duration::fromString( element.attribute( "day" ), Duration::Format_Hour ) );

    KoXmlNode n = element.firstChild();
    for ( ; ! n.isNull(); n = n.nextSibling() ) {
        if ( ! n.isElement() ) {
            continue;
        }
        KoXmlElement e = n.toElement();
        if ( e.tagName() == "calendar" ) {
            // pre 0.6 version stored base calendar in standard worktime
            if ( status.version() >= "0.6" ) {
                warnPlanXml<<"Old format, calendar in standard worktime";
                warnPlanXml<<"Tries to load anyway";
            }
            // try to load anyway
            Calendar *calendar = new Calendar;
            if ( load( calendar, e, status ) ) {
                status.project().addCalendar( calendar );
                calendar->setDefault( true );
                status.project().setDefaultCalendar( calendar ); // hmmm
                status.setBaseCalendar( calendar );
            } else {
                delete calendar;
                errorPlanXml<<"Failed to load calendar";
            }
        }
    }
    return true;
}

bool KPlatoXmlLoaderBase::load( Relation *relation, const KoXmlElement &element, XMLLoaderObject &status )
{
    debugPlanXml<<"relation";
    relation->setParent( status.project().findNode( element.attribute( "parent-id" ) ) );
    if (relation->parent() == 0) {
        warnPlanXml<<"Parent node == 0, cannot find id:"<<element.attribute( "parent-id" );
        return false;
    }
    relation->setChild( status.project().findNode( element.attribute( "child-id" ) ) );
    if ( relation->child() == 0 ) {
        warnPlanXml<<"Child node == 0, cannot find id:"<<element.attribute( "child-id" );
        return false;
    }
    if ( relation->child() == relation->parent() ) {
        warnPlanXml<<"Parent node == child node";
        return false;
    }
    if ( ! relation->parent()->legalToLink( relation->child() ) ) {
        warnPlanXml<<"Realation is not legal:"<<relation->parent()->name()<<"->"<<relation->child()->name();
        return false;
    }
    relation->setType( element.attribute("type") );

    relation->setLag( Duration::fromString( element.attribute( "lag" ) ) );

    if ( ! relation->parent()->addDependChildNode( relation ) ) {
        errorPlanXml<<"Failed to add relation: Child="<<relation->child()->name()<<" parent="<<relation->parent()->name();
        return false;
    }
    if ( ! relation->child()->addDependParentNode( relation ) ) {
        relation->parent()->takeDependChildNode( relation );
        errorPlanXml<<"Failed to add relation: Child="<<relation->child()->name()<<" parent="<<relation->parent()->name();
        return false;
    }
    //debugPlanXml<<"Added relation: Child="<<relation->child()->name()<<" parent="<<relation->parent()->name();
    return true;
}

bool KPlatoXmlLoaderBase::load( ResourceGroup *rg, const KoXmlElement &element, XMLLoaderObject &status )
{
    debugPlanXml<<"resource-group";
    rg->setId( element.attribute( "id" ) );
    rg->setName( element.attribute( "name" ) );
    rg->setType( element.attribute( "type" ) );

    KoXmlNode n = element.firstChild();
    for ( ; ! n.isNull(); n = n.nextSibling() ) {
        if ( ! n.isElement() ) {
            continue;
        }
        KoXmlElement e = n.toElement();
        if (e.tagName() == "resource") {
            // Load the resource
            Resource *child = new Resource();
            if ( load( child, e, status ) ) {
                status.project().addResource( rg, child );
            } else {
                // TODO: Complain about this
                delete child;
            }
        }
    }
    return true;
}

bool KPlatoXmlLoaderBase::load( Resource *resource, const KoXmlElement &element, XMLLoaderObject &status )
{
    debugPlanXml<<"resource";
    const Locale *locale = status.project().locale();
    QString s;
    resource->setId( element.attribute( "id" ) );
    resource->setName( element.attribute( "name" ) );
    resource->setInitials( element.attribute( "initials" ) );
    resource->setEmail( element.attribute( "email" ) );
    resource->setType( element.attribute( "type" ) );
    resource->setCalendar( status.project().findCalendar( element.attribute( "calendar-id" ) ) );
    resource->setUnits( element.attribute( "units", "100" ).toInt() );
    s = element.attribute( "available-from" );
    if ( ! s.isEmpty() ) {
        resource->setAvailableFrom( DateTime::fromString( s, status.projectTimeZone() ) );
    }
    s = element.attribute( "available-until" );
    if ( ! s.isEmpty() ) {
        resource->setAvailableUntil( DateTime::fromString( s, status.projectTimeZone() ) );
    }
    resource->setNormalRate( locale->readMoney( element.attribute( "normal-rate" ) ) );
    resource->setOvertimeRate( locale->readMoney( element.attribute( "overtime-rate" ) ) );
    resource->setAccount( status.project().accounts().findAccount( element.attribute( "account" ) ) );

    KoXmlElement e;
    KoXmlElement parent = element.namedItem( "required-resources" ).toElement();
    forEachElement( e, parent ) {
        if (e.nodeName() == "resource") {
            QString id = e.attribute( "id" );
            if ( id.isEmpty() ) {
                warnPlanXml<<"Missing resource id";
                continue;
            }
            resource->addRequiredId( id );
        }
    }
    parent = element.namedItem( "external-appointments" ).toElement();
    forEachElement( e, parent ) {
        if ( e.nodeName() == "project" ) {
            QString id = e.attribute( "id" );
            if ( id.isEmpty() ) {
                errorPlanXml<<"Missing project id";
                continue;
            }
            resource->clearExternalAppointments( id ); // in case...
            AppointmentIntervalList lst;
            load( lst, e, status );
            Appointment *a = new Appointment();
            a->setIntervals( lst );
            a->setAuxcilliaryInfo( e.attribute( "name", "Unknown" ) );
            resource->addExternalAppointment( id, a );
        }
    }
    return true;
}

bool KPlatoXmlLoaderBase::load( Accounts &accounts, const KoXmlElement &element, XMLLoaderObject &status )
{
    debugPlanXml<<"accounts";
    KoXmlNode n = element.firstChild();
    for ( ; ! n.isNull(); n = n.nextSibling() ) {
        if ( ! n.isElement() ) {
            continue;
        }
        KoXmlElement e = n.toElement();
        if (e.tagName() == "account") {
            Account *child = new Account();
            if ( load( child, e, status ) ) {
                accounts.insert( child );
            } else {
                // TODO: Complain about this
                warnPlanXml<<"Loading failed";
                delete child;
            }
        }
    }
    if (element.hasAttribute("default-account")) {
        accounts.setDefaultAccount( accounts.findAccount( element.attribute( "default-account" ) ) );
        if ( accounts.defaultAccount() == 0) {
            warnPlanXml<<"Could not find default account.";
        }
    }
    return true;
}

bool KPlatoXmlLoaderBase::load(Account* account, const KoXmlElement& element, XMLLoaderObject& status)
{
    debugPlanXml<<"account";
    account->setName( element.attribute( "name" ) );
    account->setDescription( element.attribute( "description" ) );
    KoXmlNode n = element.firstChild();
    for ( ; ! n.isNull(); n = n.nextSibling() ) {
        if ( ! n.isElement() ) {
            continue;
        }
        KoXmlElement e = n.toElement();
        if (e.tagName() == "costplace") {
            Account::CostPlace *child = new Account::CostPlace( account );
            if ( load( child, e, status ) ) {
                account->append( child );
            } else {
                delete child;
            }
        } else if ( e.tagName() == "account" ) {
            Account *child = new Account();
            if ( load( child, e, status ) ) {
                account->insert( child );
            } else {
                // TODO: Complain about this
                warnPlanXml<<"Loading failed";
                delete child;
            }
        }
    }
    return true;
}

bool KPlatoXmlLoaderBase::load(Account::CostPlace* cp, const KoXmlElement& element, XMLLoaderObject& status)
{
    debugPlanXml<<"cost-place";
    cp->setObjectId( element.attribute( "object-id" ) );
    if ( cp->objectId().isEmpty() ) {
        // check old format
        cp->setObjectId( element.attribute( "node-id" ) );
        if ( cp->objectId().isEmpty() ) {
            errorPlanXml<<"No object id";
            return false;
        }
    }
    cp->setNode( status.project().findNode( cp->objectId() ) );
    if ( cp->node() == 0) {
        cp->setResource( status.project().findResource( cp->objectId() ) );
        if ( cp->resource() == 0 ) {
            errorPlanXml<<"Cannot find object with id: "<<cp->objectId();
            return false;
        }
    }
    bool on = (bool)(element.attribute("running-cost").toInt());
    if ( on ) cp->setRunning( on );
    on = (bool)(element.attribute("startup-cost").toInt());
    if ( on ) cp->setStartup( on );
    on = (bool)(element.attribute("shutdown-cost").toInt());
    if ( on ) cp->setShutdown( on );
    return true;
}

bool KPlatoXmlLoaderBase::load( ScheduleManager *manager, const KoXmlElement &element, XMLLoaderObject &status )
{
    debugPlanXml<<"schedule-manager";
    MainSchedule *sch = 0;
    if ( status.version() <= "0.5" ) {
        manager->setUsePert( false );
        MainSchedule *sch = loadMainSchedule( manager, element, status );
        if ( sch && sch->type() == Schedule::Expected ) {
            sch->setManager( manager );
            manager->setExpected( sch );
        } else {
            delete sch;
        }
        return true;
    }
    manager->setName( element.attribute( "name" ) );
    manager->setManagerId( element.attribute( "id" ) );
    manager->setUsePert( element.attribute( "distribution" ).toInt() == 1 );
    manager->setAllowOverbooking( (bool)( element.attribute( "overbooking" ).toInt() ) );
    manager->setCheckExternalAppointments( (bool)( element.attribute( "check-external-appointments" ).toInt() ) );
    manager->setSchedulingDirection( (bool)(element.attribute( "scheduling-direction" ).toInt() ) );
    manager->setBaselined( (bool)( element.attribute( "baselined" ).toInt() ) );
    manager->setSchedulerPluginId( element.attribute( "scheduler-plugin-id" ) );
    manager->setRecalculate( (bool)( element.attribute( "recalculate" ).toInt() ) );
    manager->setRecalculateFrom( DateTime::fromString( element.attribute( "recalculate-from" ), status.projectTimeZone() ) );
    KoXmlNode n = element.firstChild();
    for ( ; ! n.isNull(); n = n.nextSibling() ) {
        if ( ! n.isElement() ) {
            continue;
        }
        KoXmlElement e = n.toElement();
        //debugPlanXml<<e.tagName();
        if ( e.tagName() == "schedule" ) {
            sch = loadMainSchedule( manager, e, status );
            if ( sch && sch->type() == Schedule::Expected ) {
                sch->setManager( manager );
                manager->setExpected( sch ); break;
            } else {
                delete sch;
            }
        } else if ( e.tagName() == "plan" ) {
            ScheduleManager *sm = new ScheduleManager( status.project() );
            if ( load( sm, e, status ) ) {
                status.project().addScheduleManager( sm, manager );
            } else {
                errorPlanXml<<"Failed to load schedule manager";
                delete sm;
            }
        }
    }
    return true;
}

bool KPlatoXmlLoaderBase::load( Schedule *schedule, const KoXmlElement& element, XMLLoaderObject& /*status*/ )
{
    debugPlanXml<<"schedule";
    schedule->setName( element.attribute( "name" ) );
    schedule->setType( element.attribute( "type" ) );
    schedule->setId( element.attribute( "id" ).toLong() );

    return true;
}

MainSchedule* KPlatoXmlLoaderBase::loadMainSchedule( ScheduleManager* /*manager*/, const KoXmlElement& element, XMLLoaderObject& status )
{
    debugPlanXml<<"main-schedule";
    MainSchedule *sch = new MainSchedule();
    if ( loadMainSchedule( sch, element, status ) ) {
        status.project().addSchedule( sch );
        sch->setNode( &(status.project()) );
        status.project().setParentSchedule( sch );
        // If it's here, it's scheduled!
        sch->setScheduled( true );
    } else {
        errorPlanXml << "Failed to load schedule";
        delete sch;
        sch = 0;
    }
    return sch;
}

bool KPlatoXmlLoaderBase::loadMainSchedule( MainSchedule *ms, const KoXmlElement &element, XMLLoaderObject &status )
{
    debugPlanXml;
    QString s;
    load( ms, element, status );

    s = element.attribute( "start" );
    if ( !s.isEmpty() ) {
        ms->startTime = DateTime::fromString( s, status.projectTimeZone() );
    }
    s = element.attribute( "end" );
    if ( !s.isEmpty() ) {
        ms->endTime = DateTime::fromString( s, status.projectTimeZone() );
    }
    ms->duration = Duration::fromString( element.attribute( "duration" ) );
    ms->constraintError = element.attribute( "scheduling-conflict", "0" ).toInt();

    KoXmlNode n = element.firstChild();
    for ( ; ! n.isNull(); n = n.nextSibling() ) {
        if ( ! n.isElement() ) {
            continue;
        }
        KoXmlElement el = n.toElement();
        if ( el.tagName() == "appointment" ) {
            // Load the appointments.
            // Resources and tasks must already be loaded
            Appointment * child = new Appointment();
            if ( ! load( child, el, status, *ms ) ) {
                // TODO: Complain about this
                errorPlanXml << "Failed to load appointment" << endl;
                delete child;
            }
        } else if ( el.tagName() == "criticalpath-list" ) {
            // Tasks must already be loaded
            for ( KoXmlNode n1 = el.firstChild(); ! n1.isNull(); n1 = n1.nextSibling() ) {
                if ( ! n1.isElement() ) {
                    continue;
                }
                KoXmlElement e1 = n1.toElement();
                if ( e1.tagName() != "criticalpath" ) {
                    continue;
                }
                QList<Node*> lst;
                for ( KoXmlNode n2 = e1.firstChild(); ! n2.isNull(); n2 = n2.nextSibling() ) {
                    if ( ! n2.isElement() ) {
                        continue;
                    }
                    KoXmlElement e2 = n2.toElement();
                    if ( e2.tagName() != "node" ) {
                        continue;
                    }
                    QString s = e2.attribute( "id" );
                    Node *node = status.project().findNode( s );
                    if ( node ) {
                        lst.append( node );
                    } else {
                        errorPlanXml<<"Failed to find node id="<<s;
                    }
                }
                ms->m_pathlists.append( lst );
            }
            ms->criticalPathListCached = true;
        }
    }
    return true;
}

bool KPlatoXmlLoaderBase::loadNodeSchedule(NodeSchedule* schedule, const KoXmlElement &element, XMLLoaderObject& status)
{
    debugPlanXml<<"node-schedule";
    QString s;
    load( schedule, element, status );
    s = element.attribute( "earlystart" );
    if ( s.isEmpty() ) { // try version < 0.6
        s = element.attribute( "earlieststart" );
    }
    if ( ! s.isEmpty() ) {
        schedule->earlyStart = DateTime::fromString( s, status.projectTimeZone() );
    }
    s = element.attribute( "latefinish" );
    if ( s.isEmpty() ) { // try version < 0.6
        s = element.attribute( "latestfinish" );
    }
    if ( ! s.isEmpty() ) {
        schedule->lateFinish = DateTime::fromString( s, status.projectTimeZone() );
    }
    s = element.attribute( "latestart" );
    if ( ! s.isEmpty() ) {
        schedule->lateStart = DateTime::fromString( s, status.projectTimeZone() );
    }
    s = element.attribute( "earlyfinish" );
    if ( ! s.isEmpty() ) {
        schedule->earlyFinish = DateTime::fromString( s, status.projectTimeZone() );
    }
    s = element.attribute( "start" );
    if ( ! s.isEmpty() )
        schedule->startTime = DateTime::fromString( s, status.projectTimeZone() );
    s = element.attribute( "end" );
    if ( !s.isEmpty() )
        schedule->endTime = DateTime::fromString( s, status.projectTimeZone() );
    s = element.attribute( "start-work" );
    if ( !s.isEmpty() )
        schedule->workStartTime = DateTime::fromString( s, status.projectTimeZone() );
    s = element.attribute( "end-work" );
    if ( !s.isEmpty() )
        schedule->workEndTime = DateTime::fromString( s, status.projectTimeZone() );
    schedule->duration = Duration::fromString( element.attribute( "duration" ) );

    schedule->inCriticalPath = element.attribute( "in-critical-path", "0" ).toInt();
    schedule->resourceError = element.attribute( "resource-error", "0" ).toInt();
    schedule->resourceOverbooked = element.attribute( "resource-overbooked", "0" ).toInt();
    schedule->resourceNotAvailable = element.attribute( "resource-not-available", "0" ).toInt();
    schedule->constraintError = element.attribute( "scheduling-conflict", "0" ).toInt();
    schedule->notScheduled = element.attribute( "not-scheduled", "1" ).toInt();

    schedule->positiveFloat = Duration::fromString( element.attribute( "positive-float" ) );
    schedule->negativeFloat = Duration::fromString( element.attribute( "negative-float" ) );
    schedule->freeFloat = Duration::fromString( element.attribute( "free-float" ) );

    return true;
}

bool KPlatoXmlLoaderBase::load( WBSDefinition &def, const KoXmlElement &element, XMLLoaderObject &/*status*/ )
{
    debugPlanXml<<"wbs-def";
    def.setProjectCode( element.attribute( "project-code" ) );
    def.setProjectSeparator( element.attribute( "project-separator" ) );
    def.setLevelsDefEnabled( (bool)element.attribute( "levels-enabled", "0" ).toInt() );
    KoXmlNode n = element.firstChild();
    for ( ; ! n.isNull(); n = n.nextSibling() ) {
        if ( ! n.isElement() ) {
            continue;
        }
        KoXmlElement e = n.toElement();
        if ( e.tagName() == "default" ) {
            def.defaultDef().code = e.attribute( "code", "Number" );
            def.defaultDef().separator = e.attribute( "separator", "." );
        } else if (e.tagName() == "levels") {
            KoXmlNode n = e.firstChild();
            for ( ; ! n.isNull(); n = n.nextSibling() ) {
                if ( ! n.isElement() ) {
                    continue;
                }
                KoXmlElement el = n.toElement();
                WBSDefinition::CodeDef d;
                d.code = el.attribute( "code" );
                d.separator = el.attribute( "separator" );
                int lvl = el.attribute( "level", "-1" ).toInt();
                if ( lvl >= 0 ) {
                    def.setLevelsDef( lvl, d );
                } else errorPlanXml<<"Invalid levels definition";
            }
        }
    }
    return true;
}

bool KPlatoXmlLoaderBase::load( Documents &documents, const KoXmlElement &element, XMLLoaderObject &status )
{
    debugPlanXml<<"documents";
    KoXmlNode n = element.firstChild();
    for ( ; ! n.isNull(); n = n.nextSibling() ) {
        if ( ! n.isElement() ) {
            continue;
        }
        KoXmlElement e = n.toElement();
        if (e.tagName() == "document") {
            Document *doc = new Document();
            if ( ! load( doc, e, status ) ) {
                warnPlanXml<<"Failed to load document";
                status.addMsg( XMLLoaderObject::Errors, "Failed to load document" );
                delete doc;
            } else {
                documents.addDocument( doc );
                status.addMsg( i18n( "Document loaded, URL=%1",  doc->url().url() ) );
            }
        }
    }
    return true;
}

bool KPlatoXmlLoaderBase::load( Document *document, const KoXmlElement &element, XMLLoaderObject &status )
{
    debugPlanXml<<"document";
    Q_UNUSED(status);
    document->setUrl( QUrl( element.attribute( "url" ) ) );
    document->setType( ( Document::Type )( element.attribute( "type" ).toInt() ) );
    document->setStatus( element.attribute( "status" ) );
    document->setSendAs( ( Document::SendAs )( element.attribute( "sendas" ).toInt() ) );
    return true;
}

bool KPlatoXmlLoaderBase::load( Estimate* estimate, const KoXmlElement& element, XMLLoaderObject& status )
{
    debugPlanXml<<"estimate";
    estimate->setType( element.attribute( "type") );
    estimate->setRisktype( element.attribute( "risk" ) );
    if ( status.version() <= "0.6" ) {
        estimate->setUnit( ( Duration::Unit )( element.attribute( "display-unit", QString().number( Duration::Unit_h ) ).toInt()) );
        QList<qint64> s = status.project().standardWorktime()->scales();
        estimate->setExpectedEstimate( Estimate::scale( Duration::fromString( element.attribute("expected" ) ), estimate->unit(), s ) );
        estimate->setOptimisticEstimate( Estimate::scale(  Duration::fromString( element.attribute("optimistic" ) ), estimate->unit(), s ) );
        estimate->setPessimisticEstimate( Estimate::scale( Duration::fromString( element.attribute("pessimistic") ), estimate->unit(), s ) );
    } else {
        if ( status.version() <= "0.6.2" ) {
            // 0 pos in unit is now Unit_Y, so add 3 to get the correct new unit
            estimate->setUnit( ( Duration::Unit )( element.attribute( "unit", QString().number( Duration::Unit_ms - 3 ) ).toInt() + 3 ) );
        } else {
            estimate->setUnit( Duration::unitFromString( element.attribute( "unit" ) ) );
        }
        estimate->setExpectedEstimate( element.attribute( "expected", "0.0" ).toDouble() );
        estimate->setOptimisticEstimate( element.attribute( "optimistic", "0.0" ).toDouble() );
        estimate->setPessimisticEstimate( element.attribute( "pessimistic", "0.0" ).toDouble() );

        estimate->setCalendar( status.project().findCalendar( element.attribute("calendar-id" ) ) );
    }
    return true;
}

bool KPlatoXmlLoaderBase::load( ResourceGroupRequest* gr, const KoXmlElement& element, XMLLoaderObject& status )
{
    debugPlanXml<<"resourcegroup-request";
    gr->setGroup( status.project().findResourceGroup(element.attribute("group-id")) );
    if ( gr->group() == 0 ) {
        errorPlanXml<<"The referenced resource group does not exist: group id="<<element.attribute("group-id");
        return false;
    }
    gr->group()->registerRequest( gr );


    KoXmlNode n = element.firstChild();
    for ( ; ! n.isNull(); n = n.nextSibling() ) {
        if ( ! n.isElement() ) {
            continue;
        }
        KoXmlElement e = n.toElement();
        if (e.tagName() == "resource-request") {
            ResourceRequest *r = new ResourceRequest();
            if ( load( r, e, status ) ) {
                gr->addResourceRequest( r );
            } else {
                errorPlanXml<<"Failed to load resource request";
                delete r;
            }
        }
    }
    // meaning of m_units changed
    int x = element.attribute("units").toInt() -gr->count();
    gr->setUnits( x > 0 ? x : 0 );

    return true;
}

bool KPlatoXmlLoaderBase::load( ResourceRequest *rr, const KoXmlElement& element, XMLLoaderObject& status)
{
    debugPlanXml<<"resource-request";
    rr->setResource( status.project().resource(element.attribute("resource-id")) );
    if (rr->resource() == 0) {
        warnPlanXml<<"The referenced resource does not exist: resource id="<<element.attribute("resource-id");
        return false;
    }
    rr->setUnits( element.attribute("units").toInt() );

    KoXmlElement parent = element.namedItem( "required-resources" ).toElement();
    KoXmlElement e;
    QList<Resource*> required;
    forEachElement( e, parent ) {
        if (e.nodeName() == "resource") {
            QString id = e.attribute( "id" );
            if ( id.isEmpty() ) {
                errorPlanXml<<"Missing project id";
                continue;
            }
            Resource *r = status.project().resource(id);
            if (r == 0) {
                warnPlanXml<<"The referenced resource does not exist: resource id="<<element.attribute("resource-id");
            } else {
                if ( r != rr->resource() ) {
                    required << r;
                }
            }
        }
    }
    rr->setRequiredResources( required );
    return true;

}

bool KPlatoXmlLoaderBase::load( WorkPackage &wp, const KoXmlElement& element, XMLLoaderObject& status )
{
    debugPlanXml<<"workpackage";
    Q_UNUSED(status);
    wp.setOwnerName( element.attribute( "owner" ) );
    wp.setOwnerId( element.attribute( "owner-id" ) );
    return true;
}

bool KPlatoXmlLoaderBase::loadWpLog( WorkPackage *wp, KoXmlElement& element, XMLLoaderObject& status )
{
    debugPlanXml<<"wplog";
    wp->setOwnerName( element.attribute( "owner" ) );
    wp->setOwnerId( element.attribute( "owner-id" ) );
    wp->setTransmitionStatus( wp->transmitionStatusFromString( element.attribute( "status" ) ) );
    wp->setTransmitionTime( DateTime( QDateTime::fromString( element.attribute( "time" ), Qt::ISODate ) ) );
    return load( wp->completion(), element, status );
}

bool KPlatoXmlLoaderBase::load( Completion &completion, const KoXmlElement& element, XMLLoaderObject& status )
{
    debugPlanXml<<"completion";
    QString s;
    completion.setStarted( (bool)element.attribute("started", "0").toInt() );
    completion.setFinished( (bool)element.attribute("finished", "0").toInt() );
    s = element.attribute("startTime");
    if (!s.isEmpty()) {
        completion.setStartTime( DateTime::fromString(s, status.projectTimeZone()) );
    }
    s = element.attribute("finishTime");
    if (!s.isEmpty()) {
        completion.setFinishTime( DateTime::fromString(s, status.projectTimeZone() ) );
    }
    completion.setEntrymode( element.attribute( "entrymode" ) );
    if (status.version() < "0.6") {
        if ( completion.isStarted() ) {
            Completion::Entry *entry = new Completion::Entry( element.attribute("percent-finished", "0").toInt(), Duration::fromString(element.attribute("remaining-effort")),  Duration::fromString(element.attribute("performed-effort")) );
            entry->note = element.attribute("note");
            QDate date = completion.startTime().date();
            if ( completion.isFinished() ) {
                date = completion.finishTime().date();
            }
            // almost the best we can do ;)
            completion.addEntry( date, entry );
        }
    } else {
        KoXmlElement e;
        forEachElement(e, element) {
                if (e.tagName() == "completion-entry") {
                    QDate date;
                    s = e.attribute("date");
                    if ( !s.isEmpty() ) {
                        date = QDate::fromString( s, Qt::ISODate );
                    }
                    if ( !date.isValid() ) {
                        warnPlanXml<<"Invalid date: "<<date<<s;
                        continue;
                    }
                    Completion::Entry *entry = new Completion::Entry( e.attribute("percent-finished", "0").toInt(), Duration::fromString(e.attribute("remaining-effort")),  Duration::fromString(e.attribute("performed-effort")) );
                    completion.addEntry( date, entry );
                } else if (e.tagName() == "used-effort") {
                    KoXmlElement el;
                    forEachElement(el, e) {
                            if (el.tagName() == "resource") {
                                QString id = el.attribute( "id" );
                                Resource *r = status.project().resource( id );
                                if ( r == 0 ) {
                                    warnPlanXml<<"Cannot find resource, id="<<id;
                                    continue;
                                }
                                Completion::UsedEffort *ue = new Completion::UsedEffort();
                                completion.addUsedEffort( r, ue );
                                load( ue, el, status );
                            }
                    }
                }
        }
    }
    return true;
}

bool KPlatoXmlLoaderBase::load( Completion::UsedEffort* ue, const KoXmlElement& element, XMLLoaderObject& /*status*/)
{
    debugPlanXml<<"used-effort";
    KoXmlElement e;
    forEachElement(e, element) {
        if (e.tagName() == "actual-effort") {
            QDate date = QDate::fromString( e.attribute("date"), Qt::ISODate );
            if ( date.isValid() ) {
                Completion::UsedEffort::ActualEffort a;
                a.setNormalEffort( Duration::fromString( e.attribute( "normal-effort" ) ) );
                a.setOvertimeEffort( Duration::fromString( e.attribute( "overtime-effort" ) ) );
                ue->setEffort( date, a );
            }
        }
    }
    return true;
}

bool KPlatoXmlLoaderBase::load( Appointment *appointment, const KoXmlElement& element, XMLLoaderObject& status, Schedule &sch )
{
    debugPlanXml<<"appointment";
    Node *node = status.project().findNode(element.attribute("task-id"));
    if (node == 0) {
        errorPlanXml<<"The referenced task does not exists: "<<element.attribute("task-id");
        return false;
    }
    Resource *res = status.project().resource(element.attribute("resource-id"));
    if (res == 0) {
        errorPlanXml<<"The referenced resource does not exists: resource id="<<element.attribute("resource-id");
        return false;
    }
    if (!res->addAppointment( appointment, sch ) ) {
        errorPlanXml<<"Failed to add appointment to resource: "<<res->name();
        return false;
    }
    if ( ! node->addAppointment( appointment, sch ) ) {
        errorPlanXml<<"Failed to add appointment to node: "<<node->name();
        appointment->resource()->takeAppointment( appointment );
        return false;
    }
    //debugPlanXml<<"res="<<m_resource<<" node="<<m_node;
    AppointmentIntervalList lst = appointment->intervals();
    load( lst, element, status );
    if ( lst.isEmpty() ) {
        errorPlanXml<<"Appointment interval list is empty (added anyway): "<<node->name()<<res->name();
        return false;
    }
    appointment->setIntervals( lst );
    return true;
}

bool KPlatoXmlLoaderBase::load(AppointmentIntervalList& lst, const KoXmlElement& element, XMLLoaderObject& status)
{
    debugPlanXml<<"appointment-interval-list";
    KoXmlElement e;
    forEachElement(e, element) {
        if (e.tagName() == "interval") {
            AppointmentInterval a;
            if ( load( a, e, status ) ) {
                lst.add(a);
            } else {
                errorPlanXml<<"Could not load interval";
            }
        }
    }
    return true;
}

bool KPlatoXmlLoaderBase::load(AppointmentInterval& interval, const KoXmlElement& element, XMLLoaderObject& status)
{
    bool ok;
    QString s = element.attribute("start");
    if (!s.isEmpty()) {
        interval.setStartTime( DateTime::fromString(s, status.projectTimeZone()) );
    }
    s = element.attribute("end");
    if (!s.isEmpty()) {
        interval.setEndTime( DateTime::fromString(s, status.projectTimeZone()) );
    }
    double l = element.attribute("load", "100").toDouble(&ok);
    if (ok) {
        interval.setLoad( l );
    }
    debugPlanXml<<"interval:"<<interval;
    return interval.isValid();
}
