The contents of this file are subject to the Common Public Attribution License

Version 1.0 (the "License"); you may not use this file except in compliance with

the License. You may obtain a copy of the License at

http://www.projity.com/license . The License is based on the Mozilla Public

License Version 1.1 but Sections 14 and 15 have been added to cover use of

software over a computer network and provide for limited attribution for the

Original Developer. In addition, Exhibit A has been modified to be consistent

with Exhibit B.

Software distributed under the License is distributed on an "AS IS" basis,

WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the

specific language governing rights and limitations under the License. The

Original Code is OpenProj. The Original Developer is the Initial Developer and

is Projity, Inc. All portions of the code written by Projity are Copyright (c)

2006, 2007. All Rights Reserved. Contributors Projity, Inc.

Alternatively, the contents of this file may be used under the terms of the

Projity End-User License Agreeement (the Projity License), in which case the

provisions of the Projity License are applicable instead of those above. If you

wish to allow use of your version of this file only under the terms of the

Projity License and not to allow others to use your version of this file under

the CPAL, indicate your decision by deleting the provisions above and replace

them with the notice and other provisions required by the Projity  License. If

you do not delete the provisions above, a recipient may use your version of this

file under either the CPAL or the Projity License.

[NOTE: The text of this license may differ slightly from the text of the notices

in Exhibits A and B of the license at http://www.projity.com/license. You should

use the latest text at http://www.projity.com/license for your modifications.

You may not remove this license text from the source files.]

Attribution Information: Attribution Copyright Notice: Copyright � 2006, 2007

Projity, Inc. Attribution Phrase (not exceeding 10 words): Powered by OpenProj,

an open source solution from Projity. Attribution URL: http://www.projity.com

Graphic Image as provided in the Covered Code as file:  openproj_logo.png with

alternatives listed on http://www.projity.com/logo

Display of Attribution Information is required in Larger Works which are defined

in the CPAL as a work which combines Covered Code or portions thereof with code

not governed by the terms of the CPAL. However, in addition to the other notice

obligations, all copies of the Covered Code in Executable and Source Code form

distributed must, as a form of attribution of the original author, include on

each user interface screen the "OpenProj" logo visible to all users.  The

OpenProj logo should be located horizontally aligned with the menu bar and left

justified on the top left of the screen adjacent to the File menu.  The logo

must be at least 100 x 25 pixels.  When users click on the "OpenProj" logo it

must direct them back to http://www.projity.com.

*/

* Project class

*/

  static final long serialVersionUID = 17283790404932L;

  private long statusDate = 0;

  private String manager="";

  private transient HasKeyImpl hasKey;

  private String notes="";

  private transient LinkedList tasks = new LinkedList();

  private transient ResourcePool resourcePool = null;

  //private transient Schedule schedule = null; //used?

  private transient SchedulingAlgorithm schedulingAlgorithm = null;

  private transient boolean initialized = false;

  private transient ScheduleEventManager scheduleEventManager = new ScheduleEventManager();

  private transient MultipleTransactionManager multipleTransactionManager = new MultipleTransactionManager();

  private transient ObjectEventManager objectEventManager = new ObjectEventManager();

  private transient ObjectSelectionEventManager objectSelectionEventManager = new ObjectSelectionEventManager();

  private transient int taskIdCounter = 0;

  private transient boolean isGroupDirty = false;

  private transient boolean isDirty = false;

  private transient boolean readOnly = false;

  private transient SubprojectHandler subprojectHandler;

  public transient static Project lastDeserialized = null;

  long start;

  long end;

  long duration;

  boolean forward = true;

  int priority = 500;

  long currentDate = 0;

  private Map extraFields = null;

  private double risk = 0.0D;

  private double netPresentValue = 0.0D;

  private int benefit = 0;

  transient int projectStatus = ProjectStatus.PLANNING; // exposed in database

  transient int projectType = ProjectType.OTHER; // exposed in database

  transient int expenseType = ExpenseType.NONE;// exposed in database

  transient String group;// exposed in database

  transient String division;// exposed in database

  private transient boolean openedAsSubproject = false;

  private transient Hyperlink documentFolderUrl = null;

  private transient long earliestStartingTask = 0L; // used for subprojects

  private transient long latestFinishingTask = 0L; // used for subprojects

  private static Project dummy = null;

  private transient NodeModel taskModel = null;

  private transient NodeModel resourceModel = null;

  private transient Object taskCache = null;

  private transient Object resourceCache = null;

  private transient List<Task> repaired = null;

  private transient Date creationDate,lastModificationDate;

  public NodeModel getTaskModel() {

    if (taskModel == null)

      taskModel=NodeModelFactory.createTaskModel(this);

    return taskModel;

  }

  public NodeModel getResourceModel() {

    if (resourceModel == null)

      resourceModel=NodeModelFactory.createResourceModel(this);

    return resourceModel;

  }

  public Object getResourceCache() {

    return resourceCache;

  }

  public void setResourceCache(Object resourceCache) {

    this.resourceCache = resourceCache;

  }

  public Object getTaskCache() {

    return taskCache;

  }

  public void setTaskCache(Object taskCache) {

    this.taskCache = taskCache;

  }

  private Project(boolean local) {

    super();

    // get the appropriate subproject handler

    initSubprojectHandler();

    hasKey =new HasKeyImpl(local,this);

    setWorkCalendar(CalendarService.getInstance().getDefaultInstance());

    start = CalendarOption.getInstance().makeValidStart(DateTime.midnightToday(), true);

    start = getEffectiveWorkCalendar().adjustInsideCalendar(start,false);

    end = start;

    calendarOption = CalendarOption.getDefaultInstance();

  }

  private Project(ResourcePool resourcePool,DataFactoryUndoController undo) {

    this(resourcePool.isLocal());

    this.resourcePool = resourcePool;

    undoController=undo;

  }

  public void dispose() {

    System.out.println("disposing project " + this);

  }

  public static Project getDummy() {

    if (dummy == null)

      dummy = new Project(true);

    return dummy;

  }

  public static Project createProject(ResourcePool resourcePool,DataFactoryUndoController undo) {

    Project project=new Project(resourcePool,undo);

    project.initializeProject();

    project.setUndoController(undo); //undo not properly initialized in new Project(resourcePool,undo)

    return project;

  }

  public void initializeOutlines(){

    int count=Settings.numHierarchies();

    for (int i=0;i<count;i++){

      NodeModel model=taskOutlines.getOutline(i);

      if (model==null) continue;

      if (model instanceof AssignmentNodeModel){

        AssignmentNodeModel aModel=(AssignmentNodeModel)model;

        aModel.setContainsLeftObjects(true);

        aModel.setDocument(this);

      }

      model.setUndoController(undoController);

    }

    initializeDefaultOutline();

  }

  public void disconnectOutlines(){

    int count=Settings.numHierarchies();

    for (int i=0;i<count;i++){

      NodeModel model=taskOutlines.getOutline(i);

      if (model instanceof AssignmentNodeModel){

        AssignmentNodeModel aModel=(AssignmentNodeModel)model;

        aModel.setDocument(null); //remove ObjectListener

      }

    }

    disconnectDefaultOutline();

  }

  public long getStartConstraint() {

    long result;

      long constraint = getReferringSubprojectTaskDependencyDate();

       if (constraint > getStart())

         result = getEffectiveWorkCalendar().adjustInsideCalendar(constraint,false);

       else

         result = getStart();

       return result;

  }

  public void initialize(final boolean subproject,boolean updateDistribution) {

      initialized = true;

      repairTasks();

      if (!subproject)

        schedulingAlgorithm.initialize(this);

      if (getStart() == 0L) {

        System.out.println("no start so using earliest");

        SwingUtilities.invokeLater(new Runnable(){

        public void run() {

          recalculate();

            setStart(getEarliestStartingTaskOrStart());

        }});

      }

      initializeDefaultOutline();

      if (TimesheetOption.getInstance().isAutomaticallyIntegrateTimecardData())

        applyTimesheet(TimesheetOption.getInstance().getTimesheetFieldArray());

      setAllTasksAsUnchangedFromPersisted(false);

      if (updateDistribution) updateDistributionMap();

  }

* This will set the start and end date of a project to the earliest starting task and the latest finishing

* Its purpose is for use in handling subprojects, when we'd like the subproject's external constraints to determine its start and end, and also

* have it the subproject show up with correct start and end dates when shown upopened in another project

*

*/

  void setEarliestAndLatestDatesFromSchedule() {

    Iterator i = tasks.iterator();

    long s = Long.MAX_VALUE;

    long e = 0;

    while (i.hasNext()) {

      Task t = (Task)i.next();

      if (t.isExternal() || t.getOwningProject() != this)

        continue;

      s = Math.min(s,t.getStart());

      e = Math.max(e,t.getEnd());

    }

    if (s != Long.MAX_VALUE)

      earliestStartingTask = s;

    else

      earliestStartingTask = getStart();

    if (e != 0 )

      latestFinishingTask = e;

    else

      latestFinishingTask = getEnd();

  }

  public void initializeProject(){

    setSchedulingAlgorithm(new CriticalPath(this));

    /**TODO fix calendar handling  should be created by factory*/

    initializeOutlines();

  }

  public void disconnect(){

      disconnectOutlines();

      removeObjectListener(getSchedulingAlgorithm());

      schedulingAlgorithm = null; // help with gc

  }

  private void initializeDefaultOutline() {

    taskOutlines.getDefaultOutline().getHierarchy().addHierarchyListener(this);

  }

  private void disconnectDefaultOutline() {

    taskOutlines.getDefaultOutline().getHierarchy().removeHierarchyListener(this);

  }

  public NormalTask newNormalTaskInstance() {

    return newNormalTaskInstance(true);

  }

  public void initializeId(Task task) {

    long id = ++taskIdCounter;

    task.setId(id); //starts at 1TODO check for duplicates -

    //task.setUniqueId(id); //TODO use a GUID generator

  }

  public NormalTask newNormalTaskInstance(boolean userCreated) {

    NormalTask newOne = new NormalTask(this);

    add(newOne);

    initializeId(newOne);

    if (userCreated)

      objectEventManager.fireCreateEvent(this,newOne);

    return newOne;

  }

  public void setLocalParent(Task child, Task parent) {

    Node childNode = getTaskModel().search(child);

    Node parentNode = parent == null ? null : getTaskModel().search(parent);

    setLocalParent(childNode,parentNode);

  }

  public void setLocalParent(Node childNode, Node parentNode) {

    Task child = (Task) childNode.getImpl();

    Task parent = (Task) (parentNode == null ? null : parentNode.getImpl());

    if (child.getWbsParentTask() == parent)

      return;

    Node oldParentNode = getTaskModel().search(child.getWbsParentTask());

    if (oldParentNode != null)

      oldParentNode.getChildren().remove(childNode);

    ArrayList temp = new ArrayList();

    temp.add(childNode);

    getTaskModel().move(parentNode, temp, -1,NodeModel.NORMAL);

    setDefaultRelationship(parentNode,childNode);

  }

  public Node createLocalTaskNode(Node parentNode) {

    NormalTask task=new NormalTask(this);

    Node childNode = NodeFactory.getInstance().createNode(task); // get a node for this task

    connectTask(task);

    addToDefaultOutline(parentNode,childNode);

    getSchedulingAlgorithm().addObject(task);

    return childNode;

  }

//    //TODO this does not copy fields correctly

//    NormalTask newOne = (NormalTask) from.clone();

//    add(newOne);

//    initializeId(newOne);

//    newOne.setWbsParent(from.getWbsParentTask());

//    Node node = NodeFactory.getInstance().createNode(newOne);

//    getTaskModel().addBefore(getTaskModel().search(from),node,NodeModel.NORMAL);

//    objectEventManager.fireCreateEvent(this,newOne);

//    return newOne;

//

//  }

  /**

   * Used when creating a task on spreadsheet that may not be valid

   * @return

   */

  public NormalTask newStandaloneNormalTaskInstance() {

    NormalTask newOne = new NormalTask(this);

    newOne.getCurrentSchedule().setStart(getWorkCalendar().adjustInsideCalendar(newOne.getCurrentSchedule().getStart(),false));

    initializeId(newOne);

    return newOne;

  }

  public NormalTask createScriptedTask() {

    NormalTask task = newStandaloneNormalTaskInstance();

    connectTask(task); // put task in project list

    taskOutlines.addToAll(task, null); // update all node models

    task.markTaskAsNeedingRecalculation();

    updateScheduling(this, task, ObjectEvent.CREATE);

    return task;

  }

   public void connectTask(Task task) {

     if (!isOpenedAsSubproject() || !tasks.contains(task)) // tasks were being added twice.

       add(task);

    if (task.getOwningProject() == null)

      task.setOwningProject(this);

    if (task.getProjectId() == 0) {

      task.setProjectId(getUniqueId());

    }

    Project masterProject = (Project) task.getMasterDocument();

    if (masterProject == this) {

      task.setProject(this);

        // initially, the task has no predecessors or successors, so signify that it is both a starting point and an ending point

      if (task.getSuccessorList().size() == 0)

        addEndSentinelDependency(task);

      if (task.getPredecessorList().size() == 0)

        addStartSentinelDependency(task);

    } else {

      masterProject.add(task);

      task.setProject(masterProject);

    }

  }

  /**

   * @return Returns the statusDate.

   */

  public long getStatusDate() {

    if (statusDate == 0) // if date not set, then use last instant of this day incude all of today

      return workCalendar.adjustInsideCalendar(DateTime.midnightTomorrow() -1,true);

    return statusDate;

  }

  /**

   * @param statusDate The statusDate to set.

   */

  public void setStatusDate(long statusDate) {

    statusDate = DateTime.midnightNextDay(statusDate) -1; // last instant of today

    statusDate = workCalendar.adjustInsideCalendar(statusDate, true);

    this.statusDate = statusDate;

  }

  public final int getPriority() {

    return priority;

  }

  public final void setPriority(int priority) {

    this.priority = priority;

  }

  public void add(Task task) {

    tasks.add(task);

  }

  /**

   * @return Returns the tasks.

   */

  public LinkedList getTasks() {

    return tasks;

  }

//    return new CollectionVisitor(visitor,filter) {

//      protected Collection getCollection(Object arg0) {

//        return ((Project)arg0).getTasks();

//      }

//    };

//  }

//

//  public int testCount() {

//    ReflectionPredicate taskPredicate;

//    try {

//      taskPredicate = ReflectionPredicate.getInstance(NormalTask.class.getMethod("isVirtual",null));

//      Closure t = Project.forAllTasks(NormalTask.forAllAssignments(PrintString.INSTANCE),taskPredicate);

//      t.execute(this);

//    } catch (SecurityException e) {

//      // TODO Auto-generated catch block

//      e.printStackTrace();

//    } catch (NoSuchMethodException e) {

//      // TODO Auto-generated catch block

//      e.printStackTrace();

//    }

//    return 0;

//  }

  /**

   * @return Returns the resourcePool.

   */

  public ResourcePool getResourcePool() {

    return resourcePool;

  }

    public void setResourcePool(ResourcePool resourcePool) {

        this.resourcePool = resourcePool;

    }

  /* (non-Javadoc)

   * @see com.projity.grouping.core.Node#accept(com.projity.grouping.core.NodeVisitor)

   */

  public void accept(NodeVisitor visitor) {

    visitor.execute(this);

  }

  /* (non-Javadoc)

   * @see com.projity.grouping.core.Node#getType()

   */

  public Class getType() throws NodeException {

    return getClass();

  }

  /* (non-Javadoc)

   * @see com.projity.grouping.core.Node#isVirtual()

   */

  public boolean isVirtual() {

    return false;

  }

  /* (non-Javadoc)

   * @see com.projity.grouping.core.Node#setVirtual(boolean)

   */

  public void setVirtual(boolean virtual) {

  }

  private transient OutlineCollection taskOutlines = new OutlineCollectionImpl(Settings.numHierarchies(),this);

  public NodeModel getTaskOutline() {

    return taskOutlines.getOutline();

  }

  public NodeModel getTaskOutline(int outlineNumber) {

    return taskOutlines.getOutline(outlineNumber);

  }

  public void addToDefaultOutline(Node parentNode, Node childNode) {

    taskOutlines.addToDefaultOutline(parentNode,childNode);

    if (parentNode == null)

      return;

    setDefaultRelationship(parentNode,childNode);

  }

  public void addToDefaultOutline(Node parentNode, Node childNode, int position,boolean event) {

    taskOutlines.addToDefaultOutline(parentNode,childNode,position,event);

    if (parentNode == null||childNode.isVoid())

      return;

    setDefaultRelationship(parentNode,childNode);

  }

  public OutlineCollection getTaskOutlines() {

    return taskOutlines;

  }

  private void setDefaultRelationship(Node parentNode, Node childNode) {

    Task childTask = (Task)childNode.getImpl();

    if (parentNode == null) {

      childTask.setWbsParent(null);

    } else {

      Task parentTask = (Task)parentNode.getImpl();

      childTask.setWbsParent(parentTask);

      if (parentTask != null)

        parentTask.setWbsChildrenNodes(taskOutlines.getDefaultOutline().getHierarchy().getChildren(parentNode));

    }

  }

  public long getStart() {

    return start;

  }

  public long getEnd() {

    return end;

  }

  /**

   * @return

   */

  public long getDuration() {

    return getEffectiveWorkCalendar().compare(end,start,false);

  }

  WorkCalendar workCalendar = null;

  /**

   * @return

   */

  public WorkCalendar getWorkCalendar() {

    return workCalendar;