You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
337 lines
9.1 KiB
337 lines
9.1 KiB
/*
|
|
This file is part of the kolab resource - the implementation of the
|
|
Kolab storage format. See www.kolab.org for documentation on this.
|
|
|
|
Copyright (c) 2004 Bo Thorsen <bo@sonofthor.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.
|
|
|
|
In addition, as a special exception, the copyright holders give
|
|
permission to link the code of this program with any edition of
|
|
the Qt library by Trolltech AS, Norway (or with modified versions
|
|
of Qt that use the same license as Qt), and distribute linked
|
|
combinations including the two. You must obey the GNU General
|
|
Public License in all respects for all of the code used other than
|
|
Qt. If you modify this file, you may extend this exception to
|
|
your version of the file, but you are not obligated to do so. If
|
|
you do not wish to do so, delete this exception statement from
|
|
your version.
|
|
*/
|
|
|
|
#include "task.h"
|
|
|
|
#include <libkcal/todo.h>
|
|
#include <kdebug.h>
|
|
|
|
using namespace Kolab;
|
|
|
|
|
|
KCal::Todo* Task::xmlToTask( const TQString& xml, const TQString& tz, KCal::ResourceKolab *res,
|
|
const TQString& subResource, Q_UINT32 sernum )
|
|
{
|
|
Task task( res, subResource, sernum, tz );
|
|
task.load( xml );
|
|
KCal::Todo* todo = new KCal::Todo();
|
|
task.saveTo( todo );
|
|
return todo;
|
|
}
|
|
|
|
TQString Task::taskToXML( KCal::Todo* todo, const TQString& tz )
|
|
{
|
|
Task task( 0, TQString::null, 0, tz, todo );
|
|
return task.saveXML();
|
|
}
|
|
|
|
Task::Task( KCal::ResourceKolab *res, const TQString &subResource, Q_UINT32 sernum,
|
|
const TQString& tz, KCal::Todo* task )
|
|
: Incidence( res, subResource, sernum, tz ),
|
|
mPriority( 5 ), mPercentCompleted( 0 ),
|
|
mStatus( KCal::Incidence::StatusNone ),
|
|
mHasStartDate( false ), mHasDueDate( false ),
|
|
mHasCompletedDate( false )
|
|
{
|
|
if ( task )
|
|
setFields( task );
|
|
}
|
|
|
|
Task::~Task()
|
|
{
|
|
}
|
|
|
|
void Task::setPriority( int priority )
|
|
{
|
|
mPriority = priority;
|
|
}
|
|
|
|
int Task::priority() const
|
|
{
|
|
return mPriority;
|
|
}
|
|
|
|
void Task::setPercentCompleted( int percent )
|
|
{
|
|
mPercentCompleted = percent;
|
|
}
|
|
|
|
int Task::percentCompleted() const
|
|
{
|
|
return mPercentCompleted;
|
|
}
|
|
|
|
void Task::setStatus( KCal::Incidence::Status status )
|
|
{
|
|
mStatus = status;
|
|
}
|
|
|
|
KCal::Incidence::Status Task::status() const
|
|
{
|
|
return mStatus;
|
|
}
|
|
|
|
void Task::setParent( const TQString& parentUid )
|
|
{
|
|
mParent = parentUid;
|
|
}
|
|
|
|
TQString Task::parent() const
|
|
{
|
|
return mParent;
|
|
}
|
|
|
|
void Task::setDueDate( const TQDateTime& date )
|
|
{
|
|
mDueDate = date;
|
|
mHasDueDate = true;
|
|
}
|
|
|
|
TQDateTime Task::dueDate() const
|
|
{
|
|
return mDueDate;
|
|
}
|
|
|
|
void Task::setHasStartDate( bool v )
|
|
{
|
|
mHasStartDate = v;
|
|
}
|
|
|
|
bool Task::hasStartDate() const
|
|
{
|
|
return mHasStartDate;
|
|
}
|
|
|
|
bool Task::hasDueDate() const
|
|
{
|
|
return mHasDueDate;
|
|
}
|
|
|
|
void Task::setCompletedDate( const TQDateTime& date )
|
|
{
|
|
mCompletedDate = date;
|
|
mHasCompletedDate = true;
|
|
}
|
|
|
|
TQDateTime Task::completedDate() const
|
|
{
|
|
return mCompletedDate;
|
|
}
|
|
|
|
bool Task::hasCompletedDate() const
|
|
{
|
|
return mHasCompletedDate;
|
|
}
|
|
|
|
bool Task::loadAttribute( TQDomElement& element )
|
|
{
|
|
TQString tagName = element.tagName();
|
|
|
|
if ( tagName == "priority" ) {
|
|
bool ok;
|
|
int priority = element.text().toInt( &ok );
|
|
if ( !ok || priority < 0 || priority > 9 )
|
|
priority = 5;
|
|
setPriority( priority );
|
|
} else if ( tagName == "completed" ) {
|
|
bool ok;
|
|
int percent = element.text().toInt( &ok );
|
|
if ( !ok || percent < 0 || percent > 100 )
|
|
percent = 0;
|
|
setPercentCompleted( percent );
|
|
} else if ( tagName == "status" ) {
|
|
if ( element.text() == "in-progress" )
|
|
setStatus( KCal::Incidence::StatusInProcess );
|
|
else if ( element.text() == "completed" )
|
|
setStatus( KCal::Incidence::StatusCompleted );
|
|
else if ( element.text() == "waiting-on-someone-else" )
|
|
setStatus( KCal::Incidence::StatusNeedsAction );
|
|
else if ( element.text() == "deferred" )
|
|
// Guessing a status here
|
|
setStatus( KCal::Incidence::StatusCanceled );
|
|
else
|
|
// Default
|
|
setStatus( KCal::Incidence::StatusNone );
|
|
} else if ( tagName == "due-date" )
|
|
setDueDate( stringToDateTime( element.text() ) );
|
|
else if ( tagName == "parent" )
|
|
setParent( element.text() );
|
|
else if ( tagName == "x-completed-date" )
|
|
setCompletedDate( stringToDateTime( element.text() ) );
|
|
else if ( tagName == "start-date" ) {
|
|
setHasStartDate( true );
|
|
setStartDate( element.text() );
|
|
} else
|
|
return Incidence::loadAttribute( element );
|
|
|
|
// We handled this
|
|
return true;
|
|
}
|
|
|
|
bool Task::saveAttributes( TQDomElement& element ) const
|
|
{
|
|
// Save the base class elements
|
|
Incidence::saveAttributes( element );
|
|
|
|
writeString( element, "priority", TQString::number( priority() ) );
|
|
writeString( element, "completed", TQString::number( percentCompleted() ) );
|
|
|
|
switch( status() ) {
|
|
case KCal::Incidence::StatusInProcess:
|
|
writeString( element, "status", "in-progress" );
|
|
break;
|
|
case KCal::Incidence::StatusCompleted:
|
|
writeString( element, "status", "completed" );
|
|
break;
|
|
case KCal::Incidence::StatusNeedsAction:
|
|
writeString( element, "status", "waiting-on-someone-else" );
|
|
break;
|
|
case KCal::Incidence::StatusCanceled:
|
|
writeString( element, "status", "deferred" );
|
|
break;
|
|
case KCal::Incidence::StatusNone:
|
|
writeString( element, "status", "not-started" );
|
|
break;
|
|
case KCal::Incidence::StatusTentative:
|
|
case KCal::Incidence::StatusConfirmed:
|
|
case KCal::Incidence::StatusDraft:
|
|
case KCal::Incidence::StatusFinal:
|
|
case KCal::Incidence::StatusX:
|
|
// All of these are saved as StatusNone.
|
|
writeString( element, "status", "not-started" );
|
|
break;
|
|
}
|
|
|
|
if ( hasDueDate() )
|
|
writeString( element, "due-date", dateTimeToString( dueDate() ) );
|
|
|
|
if ( !parent().isNull() )
|
|
writeString( element, "parent", parent() );
|
|
|
|
if ( hasCompletedDate() && percentCompleted() == 100)
|
|
writeString( element, "x-completed-date", dateTimeToString( completedDate() ) );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool Task::loadXML( const TQDomDocument& document )
|
|
{
|
|
TQDomElement top = document.documentElement();
|
|
|
|
if ( top.tagName() != "task" ) {
|
|
qWarning( "XML error: Top tag was %s instead of the expected task",
|
|
top.tagName().ascii() );
|
|
return false;
|
|
}
|
|
setHasStartDate( false ); // todo's don't necessarily have one
|
|
|
|
for ( TQDomNode n = top.firstChild(); !n.isNull(); n = n.nextSibling() ) {
|
|
if ( n.isComment() )
|
|
continue;
|
|
if ( n.isElement() ) {
|
|
TQDomElement e = n.toElement();
|
|
if ( !loadAttribute( e ) )
|
|
// TODO: Unhandled tag - save for later storage
|
|
kdDebug() << "Warning: Unhandled tag " << e.tagName() << endl;
|
|
} else
|
|
kdDebug() << "Node is not a comment or an element???" << endl;
|
|
}
|
|
|
|
loadAttachments();
|
|
return true;
|
|
}
|
|
|
|
TQString Task::saveXML() const
|
|
{
|
|
TQDomDocument document = domTree();
|
|
TQDomElement element = document.createElement( "task" );
|
|
element.setAttribute( "version", "1.0" );
|
|
saveAttributes( element );
|
|
if ( !hasStartDate() ) {
|
|
// events and journals always have a start date, but tasks don't.
|
|
// Remove the entry done by the inherited save above, because we
|
|
// don't have one.
|
|
TQDomNodeList l = element.elementsByTagName( "start-date" );
|
|
Q_ASSERT( l.count() == 1 );
|
|
element.removeChild( l.item( 0 ) );
|
|
}
|
|
document.appendChild( element );
|
|
return document.toString();
|
|
}
|
|
|
|
void Task::setFields( const KCal::Todo* task )
|
|
{
|
|
Incidence::setFields( task );
|
|
|
|
setPriority( task->priority() );
|
|
setPercentCompleted( task->percentComplete() );
|
|
setStatus( task->status() );
|
|
setHasStartDate( task->hasStartDate() );
|
|
|
|
if ( task->hasDueDate() )
|
|
setDueDate( localToUTC( task->dtDue() ) );
|
|
else
|
|
mHasDueDate = false;
|
|
if ( task->relatedTo() )
|
|
setParent( task->relatedTo()->uid() );
|
|
else if ( !task->relatedToUid().isEmpty() )
|
|
setParent( task->relatedToUid() );
|
|
else
|
|
setParent( TQString::null );
|
|
|
|
if ( task->hasCompletedDate() && task->percentComplete() == 100 )
|
|
setCompletedDate( localToUTC( task->completed() ) );
|
|
else
|
|
mHasCompletedDate = false;
|
|
}
|
|
|
|
void Task::saveTo( KCal::Todo* task )
|
|
{
|
|
Incidence::saveTo( task );
|
|
|
|
task->setPriority( priority() );
|
|
task->setPercentComplete( percentCompleted() );
|
|
task->setStatus( status() );
|
|
task->setHasStartDate( hasStartDate() );
|
|
task->setHasDueDate( hasDueDate() );
|
|
if ( hasDueDate() )
|
|
task->setDtDue( utcToLocal( dueDate() ) );
|
|
|
|
if ( !parent().isNull() )
|
|
task->setRelatedToUid( parent() );
|
|
|
|
if ( hasCompletedDate() && task->percentComplete() == 100 )
|
|
task->setCompleted( utcToLocal( mCompletedDate ) );
|
|
}
|