F:/KPlato/koffice/kplato/kptresource.h

Aller à la documentation de ce fichier.

/* 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 <qdom.h>
#include <QHash>
#include <QString>
#include <QList>

#include <kdebug.h>

class QTime;

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 };

    QString id() const { return m_id; }
    bool setId( QString id );
    void generateId();

    Project *project() { return m_project; }

    void setName( QString n ) {m_name = n;}
    const QString &name() const { return m_name;}
    void setType( Type type ) { m_type = type; }
    //void setType(const QString &type);
    Type type() const { return m_type; }

    void addResource( Resource*, Risk* );
    void insertResource( unsigned int index, Resource *resource );
    void deleteResource( Resource *resource );
    Resource *takeResource( Resource *resource );
    void deleteResource( int );

    Resource* getResource( int );
    Risk* getRisk( int );

    QList<Resource> availableResources( const DateTime start, const Duration duration, int num );
    void addRequiredResource( ResourceGroup* );
    ResourceGroup* getRequiredResource( int );
    void deleteRequiredResource( int );
    int numResources() const { return m_resources.count(); }
    QList<Resource*> &resources() { return m_resources; }

    bool load( QDomElement &element );
    void save( QDomElement &element ) const;

    void initiateCalculation( Schedule &sch );

    void addNode( 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 )
    {
        int i = m_requests.indexOf( request );
        if ( i != -1 )
            m_requests.removeAt( i );
    }
    const QList<ResourceGroupRequest*> &requests() const
    { return m_requests; }

    ResourceGroup *findId() const { return findId( m_id ); }
    ResourceGroup *findId( const QString &id ) const;
    bool removeId() { return removeId( m_id ); }
    bool removeId( const QString &id );
    void insertId( const QString &id );

    Appointment appointmentIntervals() const;

#ifndef NDEBUG

    void printDebug( QString ident );
#endif

private:
    Project *m_project;
    QString m_id;   // unique id
    QString m_name;
    QList<Resource*> m_resources;
    QList<Risk*> m_risks;
    QList<ResourceGroup*> m_requires;

    QList<Node*> m_nodes; //The nodes that want resources from us

    Calendar *m_defaultCalendar;
    Type m_type;

    QList<ResourceGroupRequest*> m_requests;

};

class Resource
{
public:

    Resource( Project *project );
    Resource( Resource *resource );
    virtual ~Resource();

    QString id() const { return m_id; }
    bool setId( QString id );
    void generateId();

    enum Type { Type_Work, Type_Material };
    void setType( Type type ) { m_type = type; }
    void setType( const QString &type );
    Type type() const { return m_type; }
    QString typeToString() const;

    void setName( QString n ) {m_name = n;}
    const QString &name() const { return m_name;}

    void setInitials( QString initials ) {m_initials = initials;}
    const QString &initials() const { return m_initials;}

    void setEmail( QString email ) {m_email = email;}
    const QString &email() const { return m_email;}

    void copy( Resource *resource );

    void setAvailableFrom( const QDateTime &af ) {m_availableFrom = af;}
    const DateTime &availableFrom() const { return m_availableFrom;}
    void setAvailableUntil( const QDateTime au ) {m_availableUntil = au;}
    const DateTime &availableUntil() const { return m_availableUntil;}

    void addWorkingHour( QTime from, QTime until );
    QList<QTime*> workingHours() { return m_workingHours; }

    DateTime getFirstAvailableTime( DateTime after = DateTime() );
    DateTime getBestAvailableTime( Duration duration );
    DateTime getBestAvailableTime( const DateTime after, const Duration duration );

    bool load( QDomElement &element );
    void save( QDomElement &element ) const;

    QList<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 QDate &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 QString id ) const;
    void setCalendar( Calendar *calendar ) { m_calendar = calendar; }

    void registerRequest( ResourceRequest *request )
    { m_requests.append( request ); }
    void unregisterRequest( ResourceRequest *request )
    {
        int i = m_requests.indexOf( request );
        if ( i != -1 )
            m_requests.removeAt( i );
    }
    const QList<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 QString &id ) const;
    bool removeId() { return removeId( m_id ); }
    bool removeId( const QString &id );
    void insertId( const QString &id );

    Calendar *findCalendar( const QString &id ) const;

    Appointment appointmentIntervals() const;
    Duration plannedEffort( const QDate &date ) const;

    void setCurrentSchedule( Schedule *schedule ) { m_currentSchedule = schedule; }
    void setCurrentSchedule( long id ) { m_currentSchedule = findSchedule( id ); }
    Schedule *currentSchedule() const { return m_currentSchedule; }

    QHash<long, Schedule*> &schedules() { return m_schedules; }
    Schedule *findSchedule( long id )
    {
        if ( m_schedules.contains( id ) )
            return m_schedules[ id ];
        return 0;
    }
    void deleteSchedule( Schedule *schedule );
    void takeSchedule( const Schedule *schedule );
    void addSchedule( Schedule *schedule );
    ResourceSchedule *createSchedule( QString name, int type, long id );
    ResourceSchedule *createSchedule( Schedule *parent );

protected:
    void makeAppointment( Schedule *node, const DateTime &from, const DateTime &end );

private:
    Project *m_project;
    QHash<long, Schedule*> m_schedules;
    QString m_id; // unique id
    QString m_name;
    QString m_initials;
    QString m_email;
    DateTime m_availableFrom;
    DateTime m_availableUntil;
    QList<QTime*> m_workingHours;

    int m_units; // avalable units in percent

    Type m_type;

    struct Cost
    {
        double normalRate;
        double overtimeRate;
        double fixed ;
    }
    cost;
    
    Calendar *m_calendar;
    QList<ResourceRequest*>
    m_requests;
    
    Schedule *m_currentSchedule;

#ifndef NDEBUG
public:
    void printDebug( QString 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( QDomElement &element, Project &project );
    void save( QDomElement &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( QString 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; }
    QList<ResourceRequest*> &resourceRequests() { return m_resourceRequests; }
    void addResourceRequest( ResourceRequest *request );
    void deleteResourceRequest( ResourceRequest *request )
    {
        int i = m_resourceRequests.indexOf( request );
        if ( i != -1 )
            m_resourceRequests.removeAt( i );
        delete request;
    }

    ResourceRequest *takeResourceRequest( ResourceRequest *request );
    ResourceRequest *find( Resource *resource );

    bool load( QDomElement &element, Project &project );
    void save( QDomElement &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;

    QList<ResourceRequest*> m_resourceRequests;
    DateTime m_start;
    Duration m_duration;

#ifndef NDEBUG
public:
    void printDebug( QString ident );
#endif
};

class ResourceRequestCollection
{
public:
    ResourceRequestCollection( Task &task );
    ~ResourceRequestCollection();

    const QList<ResourceGroupRequest*> &requests() const { return m_requests; }
    void addRequest( ResourceGroupRequest *request )
    {
        m_requests.append( request );
        request->setParent( this );
    }
    void deleteRequest( ResourceGroupRequest *request )
    {
        int i = m_requests.indexOf( request );
        if ( i != -1 )
            m_requests.removeAt( i );
        delete request;
    }

    void takeRequest( ResourceGroupRequest *request )
    {
        int i = m_requests.indexOf( request );
        if ( i != -1 )
            m_requests.removeAt( i );
    }

    ResourceGroupRequest *find( ResourceGroup *resource ) const;
    ResourceRequest *find( Resource *resource ) const;
    bool isEmpty() const;

    //bool load(QDomElement &element, Project &project);
    void save( QDomElement &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;
    QList<ResourceGroupRequest*> m_requests;

#ifndef NDEBUG
public:
    void printDebug( QString ident );
#endif
};

}  //KPlato namespace

#endif

---