Name
global.PlannedTask
Description
No description available
Script
var PlannedTask = Class.create();
PlannedTask.prototype = {
initialize: function(gr) {
PPMDebug.log('PT Constructor ' + gr.getValue('sys_id'));
this.gr = gr;
},
isShadowTask: function() {
return JSUtil.notNil(this.gr.getValue('orig_sys_id'));
},
getValue: function(col) {
PPMDebug.log('getValue of ' + col);
return this.gr.getValue(col);
},
deleteRecord: function(workflow) {
this.gr.setWorkflow(workflow);
this.gr.deleteRecord();
},
hasMoreThanOneIncomingRelation: function() {
var gr = new GlideRecord('planned_task_rel_planned_task');
gr.addQuery('child', this.gr.getValue('sys_id'));
gr.query();
return gr.getRowCount() > 1;
},
hasMoreThanOneOutgoingRelation: function() {
var gr = new GlideRecord('planned_task_rel_planned_task');
gr.addQuery('parent', this.gr.getValue('sys_id'));
gr.query();
return gr.getRowCount() > 1;
},
maxWbsOrder: function(parentGr) {
var ga = new GlideAggregate('planned_task');
ga.addAggregate("MAX", 'wbs_order');
ga.addQuery('parent', parentGr.getValue("sys_id"));
ga.setGroup(false);
ga.query();
if (ga.next())
return ga.getAggregate("MAX", 'wbs_order');
return '0';
},
createTasks: function(taskId, tableName, quantity, createRelationship, plannedStartDate) {
PPMDebug.log("Into PlannedTask.createTasks -> " + taskId + " | " + tableName + " | " +
quantity + " | " + createRelationship + " | " + plannedStartDate);
var tasks = [];
var startDate = null;
var parentTask = new GlideRecord('planned_task');
parentTask.get(taskId);
this.updateParentTaskToASAPIfItsSNLTOrStartOn(parentTask);
parentTask.get(taskId);
var maxWbsOrderUnderParent = this.maxWbsOrder(parentTask);
PPMDebug.log("Into PlannedTask.createTasks - maxWbsOrderUnderParent -> " + maxWbsOrderUnderParent);
var maxWbsOrder = JSUtil.notNil(maxWbsOrderUnderParent) ? parseInt(maxWbsOrderUnderParent) : 0;
var parentWbs = parentTask.getValue("wbs");
var domainId = parentTask.getValue("sys_domain");
var parentTaskStartDate = new GlideDateTime(parentTask.getValue("start_date"));
var isStartOn = false;
var projCurrency;
if (parentTask.instanceOf('pm_project') || parentTask.instanceOf('pm_project_task')) {
var projectGr = new GlideRecord(tableName);
projectGr.get(taskId);
projCurrency = projectGr.getValue('project_currency');
}
PPMDebug.log("Into PlannedTask.createTasks - parentTaskStartDate -> " + parentTaskStartDate +
" | plannedStartDate -> " + plannedStartDate);
if (plannedStartDate) {
startDate = new GlideDateTime();
startDate.setDisplayValueInternal(plannedStartDate);
if (!startDate.isValid()) {
startDate = parentTask.start_date.getGlideObject();
}
} else {
startDate = parentTask.start_date.getGlideObject();
}
// If the Parent Task is Pending/Open - Allow startOn
var plannedTaskStateUtil = new PlannedTaskStateUtil(parentTask);
var stateBucket = plannedTaskStateUtil.getBucketForState(parentTask.state);
if (stateBucket == PlannedTaskStateUtil.PENDING_STATES ||
stateBucket == PlannedTaskStateUtil.OPEN_STATES) {
isStartOn = parentTaskStartDate.compareTo(startDate) != 0;
if (parentTask.top_task.calculation_type == "manual")
isStartOn = true;
} else if (parentTask.top_task.calculation_type == "manual") {
isStartOn = true;
}
var projectTaskTable = SNC.PPMConfig.getProjectTaskTable(tableName);
var isDSPluginActive = typeof global.DataSeparatorGlobalUtil !== "undefined" && global.DataSeparatorGlobalUtil.isDataSeparatorPluginActive();
// Else default reset the dates - parent start date
PPMDebug.log("Into PlannedTask.createTasks - isStartOn -> " + isStartOn);
for (var i = 0; i < quantity; i++) {
var newTask = new GlideRecord(projectTaskTable);
var wbsOrder = String(maxWbsOrder + i + 1);
newTask.short_description = 'Auto created task ' + (i + 1);
if (createRelationship) {
if (isStartOn) {
if (parentTask.top_task.calculation_type == "manual" || i == 0) {
newTask.time_constraint = "start_on";
} else
newTask.time_constraint = "asap";
} else
newTask.time_constraint = "asap";
} else {
if (isStartOn) {
newTask.time_constraint = "start_on";
} else
newTask.time_constraint = "asap";
}
if (newTask.time_constraint != "asap")
newTask.constraint_date = startDate;
if (JSUtil.notNil(projCurrency))
newTask.project_currency = projCurrency;
newTask.start_date = startDate;
newTask.end_date.getGlideObject().setNumericValue(startDate.getNumericValue() + 86400000);
newTask.duration.setDateNumericValue(86400000);
newTask.schedule_start_date = newTask.start_date;
newTask.schedule_end_date = newTask.end_date;
newTask.parent = parentTask.sys_id;
newTask.state = -5;
newTask.sys_domain = domainId;
newTask.wbs_order = wbsOrder;
newTask.wbs = JSUtil.notNil(parentWbs) ? parentWbs + "." + wbsOrder : wbsOrder;
PPMDebug.log(newTask.short_description + " -> " + newTask.wbs + " | " + newTask.wbs_order + " | " + newTask.time_constraint + " | " +
newTask.start_date + " | " + newTask.end_date + " | " + newTask.duration);
this.updateAttribute(parentTask, newTask, ['top_task', 'top_program', 'top_portfolio', 'sub_tree_root']);
if(isDSPluginActive && projectGr.data_separation_groups)
newTask.data_separation_groups = projectGr.data_separation_groups;
newTask.setWorkflow(false);
tasks[i] = newTask.insert();
}
if (tasks.length > 1 && createRelationship) {
for (var i = 0; i < tasks.length - 1; i++) {
var relationRecord = new GlideRecord(PmTableConstants.PLANNED_TASK_REL);
relationRecord.parent = tasks[i];
relationRecord.child = tasks[i + 1];
relationRecord.type = "33a57d3d0a0a0b7b00819e4d4402fb14"; // Predecessor Of :: Successor Of
relationRecord.sub_type = "fs";
relationRecord.sys_domain = domainId;
relationRecord.parent_top_task = parentTask.getValue("top_task");
relationRecord.child_top_task = parentTask.getValue("top_task");
relationRecord.setWorkflow(false);
relationRecord.insert();
}
}
if (parentTask.getValue("rollup") != '1') {
parentTask.setValue("rollup", 1);
parentTask.setWorkflow(false);
parentTask.update();
}
if (tasks[0]) {
this.updateParentState(projectTaskTable, tasks[0]);
this.rollupPercentComplete(projectTaskTable, tasks[0]);
}
var api = new SNC.PlannedTaskAPI();
api.recalculateWithDirtyTasks(parentTask.getValue("top_task"), tasks.join(','));
return taskId;
},
updateParentTaskToASAPIfItsSNLTOrStartOn: function(parentTask) {
PPMDebug.log('into updateParentTaskToASAPIfItsSNLTOrStartOn');
var timeConstraint = parentTask.getValue('time_constraint');
var isSNLT = JSUtil.notNil(timeConstraint) && timeConstraint === 'snlt';
var canChangeStartOnParent = this._canChangeStartOnParentToASAP(parentTask);
if (isSNLT || canChangeStartOnParent) {
var refreshedTask = new GlideRecord('planned_task');
refreshedTask.get(parentTask.getValue('sys_id'));
refreshedTask.setValue('time_constraint', 'asap');
refreshedTask.update();
}
},
_canChangeStartOnParentToASAP: function(parentTask) {
PPMDebug.log('into _canChangeStartOnParentToASAP, evaluating ' + parentTask.getUniqueValue());
var timeConstraint = parentTask.getValue('time_constraint');
var isStartOn = JSUtil.notNil(timeConstraint) && timeConstraint === 'start_on';
var hasChildren = parentTask.getValue('roll_up') === 'false';
var parentCannotBeStartOnBehavior = PlannedTaskUtilsV2.getParentStartOnBehavior(parentTask);
var isAutomaticProject = parentTask.top_task.calculation_type == "automatic";
return isStartOn && parentCannotBeStartOnBehavior && !hasChildren && isAutomaticProject;
},
updateAttribute: function(parentTask, newTask, columns) {
for (var i = 0; i < columns.length; i++) {
if (JSUtil.notNil(parentTask.getValue(columns[i]))) {
newTask.setValue(columns[i], parentTask.getValue(columns[i]));
}
}
},
updateParentState: function(table, taskId) {
PPMDebug.log("Into PlannedTask.updateParentState -> " + table + " | " + taskId);
// load the first task and set the parent state accordingly
var task = new GlideRecord(table);
if (task.get(taskId)) {
// PlannedTaskUtilsV2.setParentState(task, false); // not updating the immediate parent
PlannedTask.setOrigSysId(taskId);
var parent = new GlideRecord("planned_task");
if (!parent.get(task.parent))
return;
var siblings = function() {
var gr = new GlideRecord('planned_task');
gr.addQuery('parent', task.parent);
gr.addNullQuery('orig_sys_id');
gr.addQuery('sys_id', '!=', task.sys_id);
gr.query();
return gr;
};
var stateUtil = new PlannedTaskStateManagement(task, parent, siblings);
var state = stateUtil.manageStateChange(false);
PPMDebug.log("Into PlannedTask.updateParentState: Parent State -> " + state);
if (state != parent.getValue('state')) {
parent.setValue('state', state);
parent.update();
}
PlannedTask.resetOrigSysId(taskId);
}
},
rollupPercentComplete: function(projectTaskTable, taskId) {
PPMDebug.log("Into PlannedTask.rollupPercentComplete -> " + projectTaskTable + " | " + taskId);
// load the first task and rollup percent complete
var task = new GlideRecord(projectTaskTable);
if (!task.get(taskId))
return;
var parent = new GlideRecord("planned_task");
if (!parent.get(task.parent))
return;
var rollupAPI = new RollupAPI();
rollupAPI.rollup(task, 'percent_complete', true);
},
type: 'PlannedTask'
};
// Check origSysId in global context
PlannedTask.setOrigSysId = function(taskId) {
// Set the origSysId to current stop trigger parent changes
if (typeof origSysId == 'undefined' || origSysId == null) {
if (JSUtil.notNil(taskId))
origSysId = taskId;
}
}
PlannedTask.resetOrigSysId = function(taskId) {
// Reset the origSysId to current stop trigger parent changes
if (typeof origSysId !== 'undefined' && origSysId !== null) {
if (origSysId == taskId)
origSysId = null;
}
}Sys ID
acfea0e30bc32200acc30e7363673a08