kptappointment.h

/* This file is part of the KDE project
   Copyright (C) 2005 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;
   version 2 of the License.
 
   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.
*/
 
#ifndef KPTAPPOINTMENT_H
#define KPTAPPOINTMENT_H
 
#include "kptduration.h"
#include "kptdatetime.h"
 
#include <tqdom.h>
#include <tqintdict.h>
#include <tqstring.h>
#include <tqptrlist.h>
 
#include <kdebug.h>
 
class TQTime;
 
namespace KPlato
{
 
class Risk;
class Effort;
class Appointment;
class Task;
class Node;
class Project;
class Resource;
class ResourceRequest;
class ResourceGroupRequest;
class Calendar;
class ResourceRequestCollection;
class EffortCostMap;
class Schedule;
 
 
 
class AppointmentInterval {
public:
    AppointmentInterval();
    AppointmentInterval(const AppointmentInterval &AppointmentInterval);
    AppointmentInterval(const DateTime &start, const DateTime end, double load=100);
    ~AppointmentInterval();
    
    void set(DateTime &start, DateTime &end, double load=100);
    void set(DateTime &start, Duration &duration, double load=100);
    
    Duration effort() const { return (m_end - m_start) * m_load / 100; }
    Duration effort(const DateTime &start, const DateTime end) const;
    Duration effort(const DateTime &time, bool upto) const;
    
    bool loadXML(TQDomElement &element);
    void saveXML(TQDomElement &element) const;
    
    const DateTime &startTime() const { return m_start; }
    void setStartTime(const DateTime &time) { m_start = time; }
    const DateTime &endTime() const { return m_end; }
    void setEndTime(const DateTime &time) { m_end = time; }
    double load() const { return m_load; }
    void setLoad(double load) { m_load = load; }
    
    bool isValid() const;
    AppointmentInterval firstInterval(const AppointmentInterval &interval, const DateTime &from) const;
 
private:
    DateTime m_start;
    DateTime m_end;
    double m_load; //percent
};
 
 
class AppointmentIntervalList : public TQPtrList<AppointmentInterval> {
protected:
    int compareItems(TQPtrCollection::Item item1, TQPtrCollection::Item item2) {
        AppointmentInterval *i1 = static_cast<AppointmentInterval*>(item1);
        AppointmentInterval *i2 = static_cast<AppointmentInterval*>(item2);
        if (i1->startTime() < i2->startTime()) {
            return -1;
        }
        if (i1->startTime() > i2->startTime()) {
            return 1;
        }
        if (i1->endTime() < i2->endTime()) {
            return -1;
        }
        if (i1->endTime() > i2->endTime()) {
            return 1;
        }
        return 0;
    }
};
typedef TQPtrListIterator<AppointmentInterval> AppointmentIntervalListIterator;
 
class Appointment {
public:
    Appointment();
    Appointment(Schedule *resource, Schedule *node, DateTime start, DateTime end, double load);
    Appointment(Schedule *resource, Schedule *node, DateTime start, Duration duration, double load);
    ~Appointment();
 
    // get/set member values.
    Schedule *node() const { return m_node; }
    void setNode(Schedule *n) { m_node = n; }
 
    Schedule *resource() const { return m_resource; }
    void setResource(Schedule *r) { m_resource = r; }
 
    DateTime startTime() const;
    DateTime endTime() const;
    double maxLoad() const;
    
    const Duration &repeatInterval() const {return m_repeatInterval;}
    void setRepeatInterval(Duration ri) {m_repeatInterval=ri;}
 
    int repeatCount() const { return m_repeatCount; }
    void setRepeatCount(int rc) { m_repeatCount=rc; }
 
    void deleteAppointmentFromRepeatList(DateTime time);
    void addAppointmentToRepeatList(DateTime time);
 
    bool isBusy(const DateTime &start, const DateTime &end);
 
    bool attach();
    void detach();
    
    void addInterval(AppointmentInterval *a);
    void addInterval(AppointmentInterval &a) 
        { addInterval(new AppointmentInterval(a)); }
    void addInterval(const DateTime &start, const DateTime &end, double load=100);
    void addInterval(const DateTime &start, const Duration &duration, double load=100);
    
    const AppointmentIntervalList &intervals() const { return m_intervals; }
 
    bool loadXML(TQDomElement &element, Project &project, Schedule &sch);
    void saveXML(TQDomElement &element) const;
 
    EffortCostMap plannedPrDay(const TQDate& start, const TQDate& end) const;
    
    Duration effort(const DateTime &start, const DateTime &end) const;
    Duration effort(const DateTime &start, const Duration &duration) const;
    Duration effortFrom(const DateTime &time) const;
    
    Duration plannedEffort() const;
    Duration plannedEffort(const TQDate &date) const;
    Duration plannedEffortTo(const TQDate &date) const;
 
    Duration actualEffort() const;
    Duration actualEffort(const TQDate &date) const;
    Duration actualEffortTo(const TQDate &date) const;
 
    double plannedCost();
    double plannedCost(const TQDate &date);
    double plannedCostTo(const TQDate &date);
 
    double actualCost();
    double actualCost(const TQDate &date);
    double actualCostTo(const TQDate &date);
 
    Appointment &operator=(const Appointment &app);
    Appointment &operator+=(const Appointment &app);
    Appointment operator+(const Appointment &app);
    
    void addActualEffort(TQDate date, Duration effort, bool overtime=false);
    
private:
    Schedule *m_node;
    Schedule *m_resource;
    
    Duration m_repeatInterval;
    int m_repeatCount;
    TQPtrList<Duration> m_extraRepeats;
    TQPtrList<Duration> m_skipRepeats;
 
    AppointmentIntervalList m_intervals;
    
    class UsedEffortItem {
    public:
        UsedEffortItem(TQDate date, Duration effort, bool overtime=false);
        TQDate date();
        Duration effort();
        bool isOvertime();
    private:
        TQDate m_date;
        Duration m_effort;
        bool m_overtime;
    };
    class UsedEffort : TQPtrList<UsedEffortItem> {
    public:
        UsedEffort();
        ~UsedEffort() {}
        void inSort(TQDate date, Duration effort, bool overtime=false);
        Duration usedEffort(bool includeOvertime=true) const;
        Duration usedEffort(const TQDate &date, bool includeOvertime=true) const;
        Duration usedEffortTo(const TQDate &date, bool includeOvertime=true) const;
        Duration usedOvertime() const;
        Duration usedOvertime(const TQDate &date) const;
        Duration usedOvertimeTo(const TQDate &date) const;
        bool load(TQDomElement &element);
        void save(TQDomElement &element) const;
    
    protected:
        int compareItems(TQPtrCollection::Item item1, TQPtrCollection::Item item2);
    };
    
    UsedEffort m_actualEffort;
 
#ifndef NDEBUG
public:
        void printDebug(TQString ident);
#endif
};
 
 
}  //KPlato namespace
 
#endif