Name

global.PlannedTaskCommonHelper

Description

No description available

Script

var PlannedTaskCommonHelper = Class.create();
PlannedTaskCommonHelper.prototype = {
  initialize: function() {
  },

  /**
   * This method, takes current value and sets
   * percent_complete, work_end, work_start, work_duration
   * as required. not a pure function
   * @param {GlideRecord} current 
   */
  setActualWorkStartValue: function(current){
      var stateUtil = new PlannedTaskStateUtil(current);
      var stateBucket = stateUtil.getBucketForState(current.state);
      var defaultWorkState = stateUtil.getDefaultWorkState();
      gs.log("_setActualWorkStartValue: current.state=" + current.state + " defaultWorkState=" + defaultWorkState+ " stateBucket "+stateBucket);
      var task = { 
                  planned_start_date: current.getDisplayValue('start_date'),
                  planned_end_date: current.getDisplayValue('end_date'),
                  actual_start_date: current.getDisplayValue('work_start'),
                  actual_end_date: current.getDisplayValue('work_end'),
                  planned_duration: current.getValue('duration'),
                  actual_duration: current.getValue('work_duration'),
                  schedule_id: current.top_task.schedule
                 };
      
      if (stateBucket == PlannedTaskStateUtil.WORK_IN_PROGRESS) {
          var dates = this._deriveWIPDates(task);
          current.setDisplayValue('work_start', dates.actual_start_date);
          if(!previous.active && current.percent_complete == 100)
             current.percent_complete = 0;
          current.work_end = ""; //clear actual end in case of restarting/opening task	
          current.work_duration="";
      } else if(!stateUtil.isStateInactive(current.state)) {
         current.work_start = "";
         current.work_end = ""; //clear actual end in case of restarting/opening task	
         current.work_duration="";
         current.percent_complete = 0;
      }
  },

  /**
   * 
   * @param {GlideRecord} current 
   */
  getCloseDataOnInactive: function(current){
      var task = { 
        planned_start_date: JSUtil.nil(current.getValue('start_date')) ? null : current.start_date.getGlideObject(),
        planned_end_date: JSUtil.nil(current.getValue('end_date')) ? null : current.end_date.getGlideObject(),
        actual_start_date: JSUtil.nil(current.getValue('work_start')) ? null : current.work_start.getGlideObject(),
        actual_end_date: JSUtil.nil(current.getValue('work_end')) ? null : current.work_end.getGlideObject(),
        planned_duration: JSUtil.nil(current.getValue('duration')) ? null : current.duration.getGlideObject(),
        actual_duration: JSUtil.nil(current.getValue('work_duration')) ? null : current.work_duration.getGlideObject(),
        schedule_id: current.top_task.schedule
      };
      var dates = this.deriveClosedDates(task);
      var result= {};
      if ( dates.status == 'success' ) {
         result.status = dates.status;
         result.work_start = dates.actual_start_date.getValue();
         result.work_end = dates.actual_end_date.getValue();
      }
      else {
        // current.setAbortAction(true);
        // gs.addErrorMessage(dates.message);
        result.status =  dates.status;
        result.message = dates.message;
      }
      return result;

  },

  /**
   * 
   * @param {GlideRecord} current 
   */
  validateActualDatesWRTState: function(current){
    var  stateUtil = new PlannedTaskStateUtil(current);
    var stateBucket = stateUtil.getBucketForState(current.state);
    var isAbortAction = false;
    switch(stateBucket){
      case PlannedTaskStateUtil.PENDING_STATES:
      case PlannedTaskStateUtil.OPEN_STATES:
        if(!current.work_start.nil() || !current.work_end.nil())
          isAbortAction = true;
        break;
      case PlannedTaskStateUtil.WORK_IN_PROGRESS:
        if(current.work_start.nil() || !current.work_end.nil())
          isAbortAction = true;
        break;
      case PlannedTaskStateUtil.CLOSE_STATES:
        if(current.work_start.nil() || current.work_end.nil())
          isAbortAction = true;
        break;
      default:
        if(JSUtil.nil(stateBucket))
         isAbortAction = true;
        else
         isAbortAction = false;
    }

    return isAbortAction;
  },

  //todo: duplicate code in ProjectTaskActualDates from pm_v3
  _deriveWIPDates: function(task) {
  	if ( JSUtil.notNil(task.actual_start_date) ) 
  		return this._sendSuccess(task.actual_start_date, "" ,"");
  	else
  		return this._sendSuccess(task.planned_start_date, "","");
  },

  deriveClosedDates: function(task){
    var task_duration = task.actual_duration || task.planned_duration;
    var ptGlobalAPi = new PTGlobalAPI();
    if ( this._isActualEndDateGiven(task) ) {
      if ( this._isActualStartDateGiven(task) ){
          if((task.allow_dates_outside_schedule == 'true') || (task.allow_dates_outside_schedule == "1"))
            var resp = this.recalculateDurationForOutsideSchedule(task.actual_start_date, task.actual_end_date);
          else {
            var resp =  ptGlobalAPi.calculateDuration(task.actual_start_date.getDisplayValueInternal(), task.actual_end_date.getDisplayValueInternal(), task.schedule_id);
            resp = new JSON().decode(resp);
          }
          
          return this._sendSuccess(task.actual_start_date, task.actual_end_date, resp.duration);
      }
      else {
       
        var resp = ptGlobalAPi.RecalculateStartDateFromAbsoluteDurationPerSchedule(task.actual_end_date, task_duration, task.schedule_id);
        resp = new JSON().decode(resp);
        if ( resp.status == 'success' ) {
          var asd = new GlideDateTime();
          asd.setDisplayValue(resp.date);
          return this._sendSuccess(asd, task.actual_end_date, task_duration);
        }	
        else
          return this._sendError(resp.message);
      }
    }
    else {
      if ( this._isActualStartDateGiven(task) ) {
        var resp = ptGlobalAPi.calculateEndDate(task.actual_start_date.getDisplayValueInternal(), task_duration.getValue(), task.schedule_id);				
        resp = new JSON().decode(resp);
        if ( resp.status == 'success' ) {
          var actualEndDate = new GlideDateTime();
          actualEndDate.setDisplayValue(resp.date);
          return this._sendSuccess(task.actual_start_date, actualEndDate, task_duration);
        }
        else
          return this._sendError(resp.message);
      }
      else {
        return this._sendSuccess(task.planned_start_date, task.planned_end_date, task_duration);
      }
    }
  },

  _isActualEndDateGiven: function(task) {
    return JSUtil.notNil(task.actual_end_date);
  },

  _isActualStartDateGiven: function(task) {
    return JSUtil.notNil(task.actual_start_date);
  },
  
  recalculateDurationForOutsideSchedule : function(startDate,endDate){
    var start_date = new GlideDateTime(startDate);
    var end_date = new GlideDateTime(endDate);
    var dur = new GlideDuration(0);
    var diffInMilliSecs = end_date.getNumericValue() - start_date.getNumericValue();
    dur.addSeconds(diffInMilliSecs/1000);
    var resp = {};
    var maxDuration = parseInt(gs.getProperty("com.snc.project.task.max_task_duration", "3650"));
    if ( dur.getDayPart() > maxDuration ) {
      resp.status = 'error';
      resp.message = 'Invalid period';
    }
    else {
      resp.status = 'success';
      resp.duration = dur.getValue();
    }		
    return resp;
  },

  //todo: duplicate code in ProjectTaskActualDates from pm_v3
  _sendSuccess: function(asd, aed , ad) {
    var payload = {};
    payload.actual_start_date = asd;
    payload.actual_end_date = aed;
    payload.actual_duration = ad;
    payload.status = 'success';
    return payload;
  },
  
  _sendError: function(msg) {
    return { status: 'error', message: msg };
  },

  type: 'PlannedTaskCommonHelper'
};

Sys ID

afe7e53a53531010fbf6ddeeff7b126e

Offical Documentation

Official Docs: