kptresource.h

/* This file is part of the KDE project
   Copyright (C) 2001 Thomas Zander zander@kde.org
   Copyright (C) 2004, 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; 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.
*/
 
#ifndef KPTRESOURCE_H
#define KPTRESOURCE_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 ResourceSchedule;
class Schedule;

 
/* IDEA; lets create a resourceGroup that has the intelligence to import PIM schedules
 *  from the kroupware project and use the schedules to use the factory pattern to build
 *  Resources (probably a derived class) which returns values on getFirstAvailableTime
 *  and friends based on the schedules we got from the PIM projects.
 *  (Thomas Zander mrt-2003 by suggestion of Shaheed)
 */
class ResourceGroup {
    public:
          ResourceGroup(Project *project);
          ~ResourceGroup();
 
          enum Type { Type_Work, Type_Material };
          
          TQString id() const { return m_id; }
          bool setId(TQString id);
          void generateId();
          
          Project *project() { return m_project; }
          
          void setName(TQString n) {m_name=n;}
          const TQString &name() const {return m_name;}
          void setType(Type type) { m_type = type; }
          //void setType(const TQString &type);
          Type type() const { return m_type; }

          void addResource(Resource*, Risk*);
          void insertResource( unsigned int index, Resource *resource );
          void removeResource( Resource *resource );
          Resource *takeResource( Resource *resource );
          void removeResource(int);
 
          Resource* getResource(int);
          Risk* getRisk(int);

          TQPtrList<Resource> availableResources(const DateTime start, const Duration duration, int num);
          void addRequiredResource(ResourceGroup*);
          ResourceGroup* getRequiredResource(int);
          void removeRequiredResource(int);
          int numResources() const { return m_resources.count(); }
          TQPtrList<Resource> &resources() { return m_resources; }
 
          bool load(TQDomElement &element);
          void save(TQDomElement &element) const;
 
          void initiateCalculation(Schedule &sch);
 
          void addNode(const Node *node) { m_nodes.append(node); }
          void clearNodes() { m_nodes.clear(); }
 
          Calendar *defaultCalendar() { return m_defaultCalendar; }
 
          int units();
        
          void registerRequest(ResourceGroupRequest *request)
            { m_requests.append(request); }
          void unregisterRequest(ResourceGroupRequest *request)
            { m_requests.removeRef(request); }
          const TQPtrList<ResourceGroupRequest> &requests() const
            { return m_requests; }
 
          ResourceGroup *findId() const { return findId(m_id); }
          ResourceGroup *findId(const TQString &id) const;
          bool removeId() { return removeId(m_id); }
          bool removeId(const TQString &id);
          void insertId(const TQString &id);
 
          Appointment appointmentIntervals() const;
 
#ifndef NDEBUG
        void printDebug(TQString ident);
#endif
 
    private:
        Project  *m_project;
        TQString m_id;   // unique id
        TQString m_name;
        TQPtrList<Resource> m_resources;
        TQPtrList<Risk> m_risks;
        TQPtrList<ResourceGroup> m_requires;
 
        TQPtrList<Node> m_nodes; //The nodes that want resources from us
 
        Calendar *m_defaultCalendar;
        Type m_type;
        
        TQPtrList<ResourceGroupRequest> m_requests;
        
};

 
class Resource {
public:
 
    Resource(Project *project);
    Resource(Resource *resource);
    virtual ~Resource();
 
    TQString id() const { return m_id; }
    bool setId(TQString id);
    void generateId();
 
    enum Type { Type_Work, Type_Material };
    void setType(Type type) { m_type = type; }
    void setType(const TQString &type);
    Type type() const { return m_type; }
    TQString typeToString() const;
 
    void setName(TQString n) {m_name=n;}
    const TQString &name() const {return m_name;}
 
    void setInitials(TQString initials) {m_initials=initials;}
    const TQString &initials() const {return m_initials;}
 
    void setEmail(TQString email) {m_email=email;}
    const TQString &email() const {return m_email;}
 
    void copy(Resource *resource);

    void setAvailableFrom(const TQDateTime &af) {m_availableFrom=af;}
    const DateTime &availableFrom() const {return m_availableFrom;}
    void setAvailableUntil(const TQDateTime au) {m_availableUntil=au;}
    const DateTime &availableUntil() const {return m_availableUntil;}
 
    void addWorkingHour(TQTime from, TQTime until);
    TQPtrList<TQTime> workingHours() { return m_workingHours; }
 
    DateTime getFirstAvailableTime(DateTime after = DateTime());
    DateTime getBestAvailableTime(Duration duration);
    DateTime getBestAvailableTime(const DateTime after, const Duration duration);
 
    bool load(TQDomElement &element);
    void save(TQDomElement &element) const;

    TQPtrList<Appointment> appointments();
    
    Appointment *findAppointment(Node *node);
    virtual bool addAppointment(Appointment *appointment);
    virtual bool addAppointment(Appointment *appointment, Schedule &main);
    virtual void addAppointment(Schedule *node, DateTime &start, DateTime &end, double load=100);
    
    void initiateCalculation(Schedule &sch);
    bool isAvailable(Task *task);
    void makeAppointment(Schedule *schedule);
 
    bool isOverbooked() const;
    bool isOverbooked(const TQDate &date) const;
    bool isOverbooked(const DateTime &start, const DateTime &end) const;
 
    double normalRate() const { return cost.normalRate; }
    void setNormalRate(double rate) { cost.normalRate = rate; }
    double overtimeRate() const { return cost.overtimeRate; }
    void setOvertimeRate(double rate) { cost.overtimeRate = rate; }
    double fixedCost() const { return cost.fixed; }
    void setFixedCost(double value) { cost.fixed = value; }

    int units() const { return m_units; }
    void setUnits(int units) { m_units = units; }
 
    Project *project() const { return m_project; }

    Calendar *calendar(bool local=false) const;
    Calendar *calendar(const TQString id) const;
    void setCalendar(Calendar *calendar) { m_calendar = calendar; }

    void registerRequest(const ResourceRequest *request)
        { m_requests.append(request); }
    void unregisterRequest(const ResourceRequest *request)
        { m_requests.removeRef(request); }
    const TQPtrList<ResourceRequest> &requests() const
        { return m_requests; }
        
    Duration effort(const DateTime &start, const Duration &duration, bool backward, bool *ok=0) const;

    DateTime availableAfter(const DateTime &time, const DateTime limit=DateTime(), bool checkAppointments=false) const;
    DateTime availableBefore(const DateTime &time, const DateTime limit=DateTime(), bool checkAppointments=false) const;
 
    Resource *findId() const { return findId(m_id); }
    Resource *findId(const TQString &id) const;
    bool removeId() { return removeId(m_id); }
    bool removeId(const TQString &id);
    void insertId(const TQString &id);
 
    Calendar *findCalendar(const TQString &id) const;
 
    Appointment appointmentIntervals() const;
    Duration plannedEffort(const TQDate &date) const;
 
    void setCurrentSchedule(Schedule *schedule) { m_currentSchedule = schedule; }
    void setCurrentSchedule(long id) { m_currentSchedule = findSchedule(id); }
    Schedule *currentSchedule() const { return m_currentSchedule; }
    
    TQIntDict<Schedule> &schedules() { return m_schedules; }
    Schedule *findSchedule(long id) { return m_schedules[id]; }
    void removeSchedule(Schedule *schedule);
    void takeSchedule(const Schedule *schedule);
    void addSchedule(Schedule *schedule);
    ResourceSchedule *createSchedule(TQString name, int type, long id);
    ResourceSchedule *createSchedule(Schedule *parent);
    
protected:
    void makeAppointment(Schedule *node, const DateTime &from, const DateTime &end);
    
private:
    Project *m_project;
    TQIntDict<Schedule> m_schedules;
    TQString m_id; // unique id
    TQString m_name;
    TQString m_initials;
    TQString m_email;
    DateTime m_availableFrom;
    DateTime m_availableUntil;
    TQPtrList<TQTime> m_workingHours;
 
    int m_units; // avalable units in percent
 
    Type m_type;
 
    struct Cost {
        double normalRate;
        double overtimeRate;
        double fixed;
    } cost;
 
    Calendar *m_calendar;
    TQPtrList<ResourceRequest> m_requests;
    
    Schedule *m_currentSchedule;
    
public:
#ifndef NDEBUG
        void printDebug(TQString ident);
#endif
};
 

class Risk {
    public:
 
        enum RiskType {
            NONE=0,
            LOW=1,
            HIGH=2
        };
 
        Risk(Node *n, Resource *r, RiskType rt=NONE);
        ~Risk();
 
        RiskType riskType() { return m_riskType; }
 
        Node *node() { return m_node; }
        Resource *resource() { return m_resource; }
 
    private:
        Node *m_node;
        Resource *m_resource;
        RiskType m_riskType;
};
 
class ResourceRequest {
    public:
        ResourceRequest(Resource *resource=0, int units = 1);
 
        ~ResourceRequest();
 
        ResourceGroupRequest *parent() const { return m_parent; }
        void setParent(ResourceGroupRequest *parent) { m_parent = parent; }
        
        Resource *resource() const { return m_resource; }
        void setResource(Resource* resource) { m_resource = resource; }
        
        bool load(TQDomElement &element, Project &project);
        void save(TQDomElement &element) const;

        int units() const;
        
        int workUnits() const;
                
        void registerRequest() { if (m_resource) m_resource->registerRequest(this); }
        void unregisterRequest() { if (m_resource) m_resource->unregisterRequest(this); }
 
        void makeAppointment(Schedule *schedule) { 
            if (m_resource) 
                m_resource->makeAppointment(schedule);
        }
        Task *task() const;
    
    private:
        Resource *m_resource;
        int m_units;
        ResourceGroupRequest *m_parent;
 
#ifndef NDEBUG
public:
        void printDebug(TQString ident);
#endif
};
 
class ResourceGroupRequest {
    public:
        ResourceGroupRequest(ResourceGroup *group=0, int units=0);
        ~ResourceGroupRequest();
 
        void setParent(ResourceRequestCollection *parent) { m_parent = parent;}
        ResourceRequestCollection *parent() const { return m_parent; }
        
        ResourceGroup *group() const { return m_group; }
        TQPtrList<ResourceRequest> &resourceRequests() { return m_resourceRequests; }
        void addResourceRequest(ResourceRequest *request);
        void removeResourceRequest(ResourceRequest *request) { m_resourceRequests.removeRef(request); }
        ResourceRequest *takeResourceRequest(ResourceRequest *request);
        ResourceRequest *find(Resource *resource) const;
 
        bool load(TQDomElement &element, Project &project);
        void save(TQDomElement &element) const;

        int units() const;
    
        int workUnits() const;
    
        Duration effort(const DateTime &time, const Duration &duration, bool backward, bool *ok=0) const;
        
        int numDays(const DateTime &time, bool backward) const;
        
        Duration duration(const DateTime &start, const Duration &effort, bool backward=false);
        
        DateTime availableAfter(const DateTime &time);
        DateTime availableBefore(const DateTime &time);
        
        void makeAppointments(Schedule *schedule);
            
        void reserve(const DateTime &start, const Duration &duration);
 
        bool isEmpty() const;
        
        Task *task() const;
        
    private:
        ResourceGroup *m_group;
        int m_units;
        ResourceRequestCollection *m_parent;
        
        TQPtrList<ResourceRequest> m_resourceRequests;
        DateTime m_start;
        Duration m_duration;
 
#ifndef NDEBUG
public:
        void printDebug(TQString ident);
#endif
};
 
class ResourceRequestCollection {
public:
    ResourceRequestCollection(Task &task);
    ~ResourceRequestCollection();
 
    const TQPtrList<ResourceGroupRequest> &requests() const { return m_requests; }
    void addRequest(ResourceGroupRequest *request) {                 
        m_requests.append(request);
        request->setParent(this);
    }
    void removeRequest(ResourceGroupRequest *request) { m_requests.removeRef(request); }
    void takeRequest(ResourceGroupRequest *request) { m_requests.take(m_requests.findRef(request)); }
    ResourceGroupRequest *find(ResourceGroup *resource) const;
    ResourceRequest *find(Resource *resource) const;
    bool isEmpty() const;
    
    //bool load(TQDomElement &element, Project &project);
    void save(TQDomElement &element) const;
 
    void clear() { m_requests.clear(); }
    
    int units() const;
    
    int workUnits() const;
    
    Duration duration(const DateTime &time, const Duration &effort, bool backward=false);
    
    DateTime availableAfter(const DateTime &time);
    DateTime availableBefore(const DateTime &time);
    
    void makeAppointments(Schedule *schedule);
    void reserve(const DateTime &start, const Duration &duration);
 
    Task &task() const { return m_task; }
    
protected:
    struct Interval {
        DateTime start;
        DateTime end;
        Duration effort;
    };
    
 
private:
    Task &m_task;
    TQPtrList<ResourceGroupRequest> m_requests;
 
#ifndef NDEBUG
public:
        void printDebug(TQString ident);
#endif
};
 
}  //KPlato namespace
 
#endif