Name
global.PlanningConsoleProcessor
Description
PlanningConsoleProcessor for all get requests from the planning console.
Script
var PlanningConsoleProcessor = Class.create();
PlanningConsoleProcessor.prototype = {
initialize: function(gRequest) {
this.gRequest = gRequest;
this.planningConsoleServer = new PlanningConsoleServer();
},
json: function() {
return new JSON();
},
consoleId: function() {
return this.gRequest.getParameter('sysparm_console_id');
},
teamspaceTable: function() {
return this.gRequest.getParameter('sysparm_teamspace_table');
},
pageLimit: function() {
return 30;
},
getMembersInfo: function(memberIds) {
var profiles = new PPMUserProfiles();
var mems = profiles.getProfiles(memberIds);
return mems;
},
consoleMembers: function() {
try {
AccessHelper.checkPermission('planned_task_custom_console', 'read', this.consoleId());
var memberIds = [];
var ptc = new PlannedTaskCustomConsole(this.consoleId());
var members = ptc.members();
while (members.next()) {
memberIds.push(members.getValue('user'));
}
var memberInfo = this.getMembersInfo(memberIds);
return new JSON().encode(memberInfo);
} catch (err) {
return this.json().encode([]);
}
},
addMemberToConsole: function() {
try {
AccessHelper.checkPermission('planned_task_custom_console', 'create', this.consoleId());
var memberIds = [];
var ptc = new PlannedTaskCustomConsole(this.consoleId());
var userSysId = this.gRequest.getParameter('sysparm_user_id');
gs.print("addMemberToConsole -> " + userSysId);
if (!ptc.memberExists(userSysId)) {
var userId = ptc.addMember(userSysId);
var members = ptc.members();
while (members.next()) {
memberIds.push(members.getValue('user'));
}
return this.json().encode({
status: true,
message: gs.getMessage('Member added'),
user_id: userId,
members: this.getMembersInfo(memberIds)
});
}
gs.print("addMemberToConsole -> Member Exists");
return this.json().encode({
status: false,
message: gs.getMessage('Member exists')
});
} catch (err) {
return this.json().encode({
status: 'error',
message: gs.getMessage('Access denied'),
members: []
});
}
},
removeMemberFromConsole: function() {
try {
AccessHelper.checkPermission('planned_task_custom_console', 'delete', this.consoleId());
var ptc = new PlannedTaskCustomConsole(this.consoleId());
var status = ptc.removeMember(this.gRequest.getParameter('sysparm_user_id'));
if (status)
return this.json().encode({
status: status,
message: gs.getMessage('Member removed')
});
else
return this.json().encode({
status: status,
message: gs.getMessage('Member not removed')
});
} catch (err) {
return this.json().encode({
status: 'error',
message: gs.getMessage('Access denied')
});
}
},
planningConsoleEntityId: function(entity, sys_class_name, entityId) {
var planning_console_entity_id = "";
if (entity == PmFieldConstants.ENTITY_PORTFOLIO) {
var portfolioGr = new GlideRecord(sys_class_name);
if (!entityId || entityId == '') {
return "";
} else if (portfolioGr.get(entityId)) {
//gs.info("Retrieving Valid Portfolio Id");
return entityId;
}
return "";
} else {
var projectGr = new GlideRecord(sys_class_name);
if (!entityId || entityId == '') {
//gs.info("Retrieving the Default Planning Console Id");
planning_console_entity_id = gs.getUser().getPreference(PmFieldConstants.PLANNING_CONSOLE_ENTITY_ID);
if (!projectGr.get(planning_console_entity_id)) {
planning_console_entity_id = "";
gs.getUser().setPreference(PmFieldConstants.PLANNING_CONSOLE_ENTITY_ID, planning_console_entity_id);
gs.getUser().setPreference(PmFieldConstants.PLANNING_CONSOLE_SYS_CLASS_NAME, PmFieldConstants.SYS_CLASS_NAME_PROJECT);
return planning_console_entity_id;
}
return planning_console_entity_id;
} else if (projectGr.get(entityId)) {
//gs.info("Retrieving Valid Task Id");
gs.getUser().savePreference(PmFieldConstants.PLANNING_CONSOLE_ENTITY_ID, projectGr.top_task);
gs.getUser().setPreference(PmFieldConstants.PLANNING_CONSOLE_SYS_CLASS_NAME, sys_class_name);
planning_console_entity_id = projectGr.top_task;
return planning_console_entity_id;
} else {
gs.getUser().setPreference(PmFieldConstants.PLANNING_CONSOLE_ENTITY_ID, "");
gs.getUser().setPreference(PmFieldConstants.PLANNING_CONSOLE_SYS_CLASS_NAME, PmFieldConstants.SYS_CLASS_NAME_PROJECT);
return "";
}
}
//gs.info("Invalid Planning Console Id");
},
planningConsoleBaselineId: function(projectId, baselineId) {
var baselineGr = new GlideRecord(PmTableConstants.BASELINE);
baselineGr.addQuery('top_task', projectId);
baselineGr.addQuery('sys_id', baselineId);
baselineGr.query();
if (baselineGr.getRowCount() > 0) {
baselineGr.next();
return baselineGr.sys_id;
} else {
return "";
}
},
sysId: function() {
return this.gRequest.getParameter('sysparm_sys_id');
},
entity: function() {
return this.gRequest.getParameter('sysparm_entity');
},
sysClassName: function() {
return this.gRequest.getParameter('sysparm_sys_class_name');
},
context: function() {
var context = this.planningConsoleServer.getCorrectContext(this.entity(), this.gRequest.getParameter('sysparm_context'));
return context;
},
fiscalYearId: function() {
return this.gRequest.getParameter('sysparm_fiscal_year_id');
},
page: function() {
return this.gRequest.getParameter('sysparm_page');
},
term: function() {
return this.gRequest.getParameter('sysparm_term');
},
getParam: function(name) {
return this.gRequest.getParameter(name);
},
criticalPath: function() {
var criticalPath = false;
var value = this.gRequest.getParameter('sysparm_critical_path');
if (JSUtil.notNil(value) && value == 'true')
criticalPath = true;
return criticalPath;
},
portfolioRecord: function(sysId) {
var gr = new GlideRecord(SNC.PPMConfig.getPortfolioTable(this.sysClassName()));
gr.get(sysId);
return gr;
},
mergeData: function(prjData, dmnData) {
var projectData = JSON.parse(prjData);
var projectTasks = projectData.tasks;
var prjLength = projectTasks.length;
var demandData = JSON.parse(dmnData);
var demandTasks = demandData.tasks;
var dmnLength = demandTasks.length;
if (prjLength > 0) {
if (dmnLength > 0) {
for (var i = 0; i < dmnLength; i++) {
projectTasks.push(demandTasks[i]);
}
projectData.summary['total_demands_cost'] = demandData.summary['total_demands_cost'];
projectData.summary['total_demands'] = demandData.summary['total_demands'];
} else {
projectData.summary['total_demands_cost'] = 0;
projectData.summary['total_demands'] = 0;
}
return projectData;
} else {
demandData.summary['total_projects_cost'] = 0;
demandData.summary['total_projects'] = 0;
return demandData;
}
},
portalGanttData: function() {
//gs.info(this.type, 'Into ganttData ');
var entity = this.entity();
var sysClassName = this.sysClassName();
var sysId = this.sysId();
var criticalPath = this.criticalPath();
var teamSpaceEntity = this.teamspaceTable();
var planningConsoleServer = this.planningConsoleServer;
if (JSUtil.notNil(this.consoleId()) && this.consoleId() != '') {
var projectData = '';
var demandData = '';
var finalData = '';
var api = new SNC.PlannedTaskAPI();
var p = new PortalBoard(this.consoleId());
var matchingRecords = p.matchingRecordIds();
var matchingRecordIds = planningConsoleServer.filterDuplicates(matchingRecords);
var readRecordIds = [];
for (var i = 0; i < matchingRecordIds.length; i++) {
readRecordIds.push(matchingRecordIds[i]);
}
var baseTable = GlideDBObjectManager.get().getBase(p.table());
if (p.tableInstanceOf('planned_task'))
baseTable = 'planned_task';
if (baseTable == 'task')
baseTable = p.table();
projectData = api.portalGanttData(baseTable, p.table(), readRecordIds, teamSpaceEntity); // change it later to readRecordIds
matchingRecords = p.matchingTable2RecordIds();
if (matchingRecords.length > 0) {
for (var i = 0; i < matchingRecords.length; i++)
matchingRecordIds.push(matchingRecords[i].sys_id);
readRecordIds = [];
for (i = 0; i < matchingRecordIds.length; i++) {
readRecordIds.push(matchingRecordIds[i]);
}
var baseTable2 = GlideDBObjectManager.get().getBase(p.table2());
if (baseTable2 == 'task')
baseTable2 = p.table2();
demandData = api.portalGanttData(baseTable2, p.table2(), matchingRecordIds, teamSpaceEntity); // change it later to readRecordIds
finalData = JSON.stringify(this.mergeData(projectData, demandData));
} else
finalData = projectData;
return finalData;
}
},
ganttData: function() {
//gs.info(this.type, 'Into ganttData ');
var planningConsoleServer = this.planningConsoleServer,
ganttDataStr;
if (JSUtil.notNil(this.consoleId()) && this.consoleId() != '')
ganttDataStr = planningConsoleServer.fetchMultiTaskGanttData(this.consoleId());
else {
ganttDataStr = planningConsoleServer.fetchTaskGanttData(this.entity(), this.sysClassName(), this.sysId(),
this.criticalPath(), this.context(), this.fiscalYearId());
}
return ganttDataStr;
},
metadata: function(g_request) {
PPMDebug.log('PlanningConsoleProcessor.metadata: ' + this.sysClassName() + " | " + this.sysId() +
" | " + this.context() + " | " + this.fiscalYearId() + " | " + this.consoleId());
var planningConsoleServer = this.planningConsoleServer,
metadata,
metadataStr;
metadata = planningConsoleServer.fetchMetadata(this.entity(), this.sysClassName(), this.sysId(),
this.consoleId(), this.context(), this.fiscalYearId());
metadataStr = this.json().encode(metadata);
return metadataStr;
},
baselines: function() {
try {
AccessHelper.checkPermission('planned_task_baseline', 'read');
var projectId = this.gRequest.getParameter('sysparm_project_id');
var project = new PmProject();
project.get(projectId);
var baselines = project.baselines();
return this.json().encode(baselines);
} catch (err) {
return this.json().encode({
status: 'error'
});
}
},
baselineItems: function() {
var baselineId = this.gRequest.getParameter('sysparm_baseline_id');
var baseline = new PmBaseline();
baseline.get(baselineId);
return this.json().encode(baseline.baselineItems());
},
choiceList: function() {
var table = this.gRequest.getParameter("sysparm_sys_task_type"),
choices = [],
cl = null,
gr = null,
field = this.gRequest.getParameter('sysparm_field_name'),
choice = '',
containsText = this.gRequest.getParameter('sysparm_contains_text');
var data;
if (field == 'assigned_to') {
var taskId = this.gRequest.getParameter('sysparm_sys_task_id');
data = this.entityUsers(table, taskId, containsText);
} else {
//gs.info("choiceList -> table: " + table + " ; field: " + field);
var tableHeirarchy = new GlideDBObjectManager.getTables(table);
for (var i = 0; i < tableHeirarchy.size(); i++) {
cl = new GlideSysChoice(tableHeirarchy.get(i), field);
gr = cl.getChoices();
gr.addQuery('inactive', 'false');
gr.query();
while (gr.next()) {
choice = gr.getDisplayValue();
if (choice.toLowerCase().indexOf(containsText.toLowerCase()) >= 0) {
choices.push({
id: gr.getValue("value"),
text: choice
});
}
}
if ((gr.getRowCount() > 0 && JSUtil.notNil(choices)) || gr.getRowCount() == 0)
break;
}
data = {
"items": choices,
"total": gr.getRowCount()
};
}
return this.json().encode(data);
},
entityUsers: function(className, taskId, searchString) {
var api = new PlanningConsoleAssignedToUsers();
var page = parseInt(this.page());
var users = api.getUsers(className, taskId, searchString, page);
var data = {
"items": users.data,
"total": users.total
};
return data;
},
//Uncommented this method to support select2 in gantt chart for Release and Product
entityList: function() {
var entity = this.entity();
var sysId = this.sysId();
var sysClassName = this.sysClassName();
return this[entity + 's'](sysClassName);
},
/*projects: function(sysClassName) {
var className = sysClassName;
if( !className )
className = SNC.PPMConfig.getProjectTable(this.sysClassName());
return this.doQuery(className);
},*/
configTable: function(sysClassName) {
if (JSUtil.notNil(sysClassName)) {
var gr = new GlideRecord(sysClassName);
if (gr.instanceOf("pm_project")) {
return SNC.PPMConfig.getProjectTable(sysClassName);
} else if (gr.instanceOf("pm_program")) {
return SNC.PPMConfig.getProgramTable(sysClassName);
} else if (gr.instanceOf("pm_portfolio")) {
return SNC.PPMConfig.getPortfolioTable(sysClassName);
} else if (gr.instanceOf("rm_release")) {
return 'rm_release';
} else if (gr.instanceOf("rm_product")) {
return 'rm_product';
}
}
return SNC.PPMConfig.getProjectTable(sysClassName);
},
doQuery: function(sysClassName, textField) {
var page = parseInt(this.page());
var term = this.term();
var items = [];
var configTable = this.configTable(sysClassName);
var gr = new GlideRecord(configTable);
gr.addQuery("sys_class_name", configTable);
if (JSUtil.nil(textField))
textField = 'short_description';
gr.chooseWindow((page - 1) * this.pageLimit(), page * this.pageLimit());
if (JSUtil.notNil(term))
gr.addQuery(textField, 'CONTAINS', term);
gr.query();
while (gr.next()) {
items.push({
id: gr.getValue('sys_id'),
text: gr.getValue(textField)
});
}
var data = {};
data.items = items;
data.total = gr.getRowCount();
return this.json().encode(data);
},
/* programs: function(sysClassName) {
var programs = [];
//gs.info("Programs List for: " + sysClassName);
var className = sysClassName;
if( !className )
className = SNC.PPMConfig.getProgramTable(this.sysClassName());
return this.doQuery(className);
},*/
/*portfolios: function(sysClassName) {
var portfolios = [];
//gs.info("Portfolios List for: " + sysClassName);
var className = sysClassName;
if( !className )
className = SNC.PPMConfig.getPortfolioTable(this.sysClassName());
return this.doQuery(className, 'name');
},*/
releases: function(sysClassName) {
var releases = [];
var className = "rm_release";
return this.doQuery(className);
},
products: function(sysClassName) {
var products = [];
var className = "rm_product";
return this.doQuery(className);
},
customs: function() {
//TODO fix for pagination
var customConsoles = [];
var data = {};
var gr = new GlideRecord('planned_task_custom_console');
gr.addActiveQuery();
gr.addQuery('owner', gs.getUser().getID());
gr.query();
while (gr.next()) {
customConsoles.push({
id: gr.getValue('sys_id'),
text: gr.getValue('name')
});
}
data.items = customConsoles;
data.total = gr.getRowCount();
return this.json().encode(data);
},
livefeed: function(projectRecord) {
var livefeedAction = new GlideappLiveFeedUIAction();
return livefeedAction.getGroupID(projectRecord.getValue('sys_class_name'), projectRecord.getValue('sys_id'));
},
getLevels: function() {
var sysId = this.sysId(),
sysClassName = this.sysClassName(),
planningConsoleServer = this.planningConsoleServer,
project,
level,
levelObj,
levelStr;
project = planningConsoleServer.fetchProjectRecord(sysClassName, sysId);
level = planningConsoleServer.fetchMaxLevel(project.getValue('sys_id'));
levelObj = {
level: level
};
levelStr = this.json().encode(levelObj);
return levelStr;
},
permissions: function() {
var planningConsoleServer = this.planningConsoleServer,
permissions,
permissionsStr;
permissions = planningConsoleServer.fetchPermissions(this.entity(), this.sysId(), this.consoleId(), this.context());
permissionsStr = this.json().encode(permissions);
return permissionsStr;
},
applyTemplate: function() {
var sysId = this.sysId();
var startDate = this.gRequest.getParameter('sysparm_start_date');
var templateId = this.gRequest.getParameter('sysparm_template_id');
var plannedTaskAPI = new SNC.PlannedTaskAPI();
var jsonData = plannedTaskAPI.applyTemplate(sysId, templateId, startDate);
if (!startDate)
startDate = "";
new ProjectPortfolioUtils().refreshProjectByProjectId(sysId, this.sysClassName());
return jsonData;
},
createNewProject: function() {
var sys_class_name = this.sysClassName();
var short_description = this.gRequest.getParameter('sysparm_short_description');
var start_date = this.gRequest.getParameter('sysparm_start_date');
var template = this.gRequest.getParameter('sysparm_template');
var project = new GlideRecord(sys_class_name);
project.setValue('short_description', short_description);
if (start_date) {
var startDate = new GlideDateTime();
startDate.setDisplayValue(start_date);
project.setValue('start_date', startDate.getNumericValue());
}
var project_id = project.insert();
if (project_id && template && start_date) {
var plannedTaskAPI = new SNC.PlannedTaskAPI();
var data = plannedTaskAPI.applyTemplate(project_id, template, start_date);
if (data && data.status != 'error') {
new ProjectPortfolioUtils().refreshProjectByProjectId(project_id, this.sysClassName());
return this.json().encode({
result: {
sys_id: project_id
}
});
}
} else {
return this.json().encode({
result: {
sys_id: project_id
}
});
}
},
copyPartialProject: function() {
try {
var sys_class_name = this.sysClassName();
AccessHelper.checkPermission(sys_class_name, 'create');
var projectId = this.gRequest.getParameter('sysparm_project_id');
var plannedTaskId = this.gRequest.getParameter('sysparm_task_id');
var newName = this.gRequest.getParameter('sysparm_new_name');
var treeHandler = null;
var projectGr = null;
var ancestors = null;
var isAncestor = false;
var plannedTaskGr = null;
var projectMgmtApi = null;
var response = {
status: 'success',
message: '',
result: {}
};
if (plannedTaskId && newName) {
treeHandler = new SNC.NestedIntervalUtilities("planned_task");
projectGr = new GlideRecord('planned_task');
projectGr.get(projectId);
//Check that the copied project is not an ancestor of the new parent
ancestors = treeHandler.getAncestors(projectGr);
while (ancestors.next()) {
if (ancestors.sys_id == plannedTaskId) {
isAncestor = true;
break;
}
}
if (!isAncestor) {
plannedTaskGr = new GlideRecord('planned_task');
plannedTaskGr.get(plannedTaskId);
projectMgmtApi = new SNC.PlannedTaskAPI();
var result = projectMgmtApi.copyTask(plannedTaskId, projectId, newName);
if (result == projectId) {
response.result.sys_id = projectId;
} else {
response.status = 'error';
}
} else {
//Error/Info message notification
response.status = 'error';
}
return this.json().encode(response);
}
} catch (err) {
return this.json().encode({
status: 'error',
message: gs.getMessage("Access denied")
});
}
},
copyProject: function() {
try {
var sys_class_name = this.sysClassName();
AccessHelper.checkPermission(sys_class_name, 'create');
var projectId = this.gRequest.getParameter('sysparm_project_id');
var newName = this.gRequest.getParameter('sysparm_new_name');
var projectStartDate = this.gRequest.getParameter('sysparm_start_date');
var projectMgmtApi = new SNC.PlannedTaskAPI();
var resetFields = new Array();
var defaultFields = {};
var response = {
status: 'success',
message: '',
result: {}
};
projectStartDate = (projectStartDate) ? projectStartDate : '';
if (JSUtil.notNil(projectStartDate)) {
var projectDate = new GlideDateTime();
projectDate.setDisplayValue(projectStartDate);
projectStartDate = projectDate.getDisplayValueInternal();
}
var newSysId = projectMgmtApi.copyProject(projectId, projectStartDate, newName, resetFields, defaultFields);
if (newSysId) {
response.result.sys_id = newSysId;
} else {
response.status = 'error';
}
return this.json().encode(response);
} catch (err) {
return this.json().encode({
status: 'error',
message: gs.getMessage("Access denied")
});
}
},
moveProject: function() {
try {
var sys_class_name = this.sysClassName();
AccessHelper.checkPermission(sys_class_name, 'update');
var projectId = this.gRequest.getParameter('sysparm_project_id');
var projectStartDate = this.gRequest.getParameter('sysparm_start_date');
var moveAllTasks = this.gRequest.getParameter('sysparm_move_all_tasks');
var response = {
status: 'success',
message: '',
result: {}
};
var gr = new GlideRecord(sys_class_name);
gr.get(projectId);
//User sets display value, we need to set it to internal value
var projectDate = new GlideDateTime();
projectDate.setDisplayValue(projectStartDate);
if (moveAllTasks == "true") {
gs.getSession().putProperty("ppm.move_all_tasks.regardless_of_constraint", "true");
} else {
gs.getSession().putProperty("ppm.move_all_tasks.regardless_of_constraint", "false");
}
var scheduleUtil = new SNC.PTScheduleAPI().getSchedule(gr.getValue("schedule"), GlideSession.get().getTimeZoneName());
var pmDate = scheduleUtil.convertDateIfNotInSchedule(projectDate);
gr.setDisplayValue('start_date', '' + pmDate.getDisplayValue());
gr.update();
PTGlobalAPI.moveResourceAssignments(projectId);
return this.json().encode(response);
} catch (err) {
return this.json().encode({
status: 'error',
message: gs.getMessage("Access denied")
});
}
},
createTasks: function() {
try {
var taskId = this.gRequest.getParameter('sysparm_task_id');
var tableName = this.gRequest.getParameter('sysparm_sys_class_name');
var projectTaskTable = SNC.PPMConfig.getProjectTaskTable(tableName);
AccessHelper.checkPermission(projectTaskTable, 'create');
var quantity = parseInt(this.gRequest.getParameter('sysparm_quantity'), 10);
var createRelationship = (this.gRequest.getParameter('sysparm_create_relationship') == 'true') ? true : false;
var plannedStartDate = this.gRequest.getParameter('sysparm_planned_start_date');
var plannedTaskApi = new PlannedTask();
var response = {
status: 'success',
message: '',
result: {}
};
if (JSUtil.notNil(plannedStartDate)) {
var gd = new GlideDateTime();
gd.setDisplayValue(plannedStartDate);
if (gd.isValid())
plannedStartDate = gd.getDisplayValueInternal();
}
var newSysId = plannedTaskApi.createTasks(taskId, tableName, quantity, createRelationship, plannedStartDate);
if (taskId == newSysId) {
response.result.sys_id = newSysId;
} else {
response.status = 'error';
}
return this.json().encode(response);
} catch (err) {
return this.json().encode({
status: 'error',
message: gs.getMessage("Access denied")
});
}
},
getReferenceValues: function() {
var max = this.gRequest.getParameter("sysparm_max");
var sysId = this.gRequest.getParameter("sysparm_sys_id");
var table = this.gRequest.getParameter("sysparm_table");
var column = this.gRequest.getParameter("sysparm_column");
var term = this.gRequest.getParameter("sysparm_term");
var page = this.gRequest.getParameter("sysparm_page");
gs.print(" Into PlanningConsoleProcessor.getReferenceValues -> " + table + " | " + column + " | " + sysId + " | " +
term + " | " + page + " | " + max);
var api = new SNC.PlannedTaskAPI();
var referenceValues = api.getReferenceValue(table, column, sysId,
term, page, max);
return referenceValues;
},
updateTimeConstraint: function() {
var sysClassName = this.gRequest.getParameter('sysparm_sys_class_name');
var sysId = this.gRequest.getParameter('sysparm_sys_id');
var time_constraint = this.gRequest.getParameter('sysparm_time_constraint');
var gr = new GlideRecord(sysClassName);
gr.get(sysId);
gr.setValue("time_constraint", time_constraint);
gr.update();
return this.json().encode({
status: true,
full_reload: true
});
},
allowDatesOutsideSchedule: function() {
try {
var sysClassName = this.gRequest.getParameter('sysparm_sys_class_name');
var sysId = this.gRequest.getParameter('sysparm_sys_id');
AccessHelper.checkPermission(sysClassName, 'write', sysId);
var allow_dates_outside_schedule = this.gRequest.getParameter('sysparm_allow_dates_outside_schedule');
var gr = new GlideRecord(sysClassName);
gr.get(sysId);
gr.setValue("allow_dates_outside_schedule", allow_dates_outside_schedule == "true" ? 1 : 0);
gr.update();
return this.json().encode({
status: true,
full_reload: true
});
} catch (err) {
return this.json().encode({
status: 'error',
message: gs.getMessage("Access denied")
});
}
},
_addDateTimeFormats: function(result) {
result.dateFormat = gs.getDateFormat();
result.dateTimeFormat = gs.getDateTimeFormat();
return result;
},
getSchedule: function() {
var sysClass = this.sysClassName(),
sysId = this.sysId();
PPMDebug.log('PlanningConsoleProcessor.getSchedule: ' + sysClass + " | " + sysId);
var planningConsoleServer = this.planningConsoleServer,
scheduleId = this.getParam('sysparm_schedule_id'),
isScheduleId = !!scheduleId,
scheduleStr;
if (isScheduleId) {
var scheduleTimezone = this.getParam('sysparm_timezone'),
startYear = this.getParam('sysparm_start_year'),
endYear = this.getParam('sysparm_end_year'),
forward = this.getParam('sysparm_forward');
scheduleStr = planningConsoleServer.fetchSchedule(sysClass, sysId, scheduleId, scheduleTimezone, startYear, endYear, forward);
} else
scheduleStr = planningConsoleServer.fetchSchedule(sysClass, sysId);
return scheduleStr;
},
getScheduleForDuration: function() {
var sysClass = this.sysClassName(),
sysId = this.sysId();
PPMDebug.log('PlanningConsoleProcessor.getScheduleForDuration: ' + sysClass + " | " + sysId);
var plannedTaskApi = new SNC.PlannedTaskAPI(),
planningConsoleServer = this.planningConsoleServer,
scheduleId = this.getParam('sysparm_schedule_id'),
isScheduleId = !!scheduleId,
scheduleStr;
if (isScheduleId) {
var scheduleTimezone = this.getParam('sysparm_timezone'),
startYear = this.getParam('sysparm_start_year'),
displayDurationInternal = this.getParam('sysparm_display_duration_internal'),
duration,
startDate,
endDate,
endYear;
startDate = new GlideDateTime();
startDate.setYearLocalTime(startYear);
duration = new GlideDuration(displayDurationInternal);
endDate = plannedTaskApi.calculateEndDate(startDate.getDisplayValueInternal(), displayDurationInternal, scheduleId);
endYear = endDate.getYearLocalTime();
scheduleStr = planningConsoleServer.fetchSchedule(sysClass, sysId, scheduleId, scheduleTimezone, startYear, endYear, true);
} else
scheduleStr = planningConsoleServer.fetchSchedule(sysClass, sysId);
return scheduleStr;
},
convertToMilestone: function() {
var sysClass = this.sysClassName();
var sysId = this.sysId();
var gr = new GlideRecord(sysClass);
gr.get(sysId);
gr.setValue("milestone", "true");
gr.setValue("duration", "1970-01-01 00:00:00");
gr.update();
var data = {
status: true,
full_reload: true,
message: gs.getMessage("The task has been converted to a milestone")
};
gs.flushMessages();
return this.json().encode(data);
},
getExternalRelations: function() {
var incomingRelations = [],
outgoingRelations = [];
var sysClass = this.sysClassName();
var sysId = this.sysId();
PPMDebug.log('PlanningConsoleProcessor.getExternalRelations: ' + sysClass + " | " + sysId);
var gr = new GlideRecord(sysClass);
gr.get(sysId);
var relationDBService = new PlannedTaskRelationDBService();
var incomingExternalRelations = relationDBService.incomingExternalRelations(sysId);
PPMDebug.log('PlanningConsoleProcessor.incomingExternalRelations - size: ' + incomingExternalRelations.length);
var outgoingExternalRelations = relationDBService.outgoingExternalRelations(sysId);
PPMDebug.log('PlanningConsoleProcessor.outgoingExternalRelations - size: ' + outgoingExternalRelations.length);
// Aggregate the relations
for (var i = 0; i < incomingExternalRelations.length; i++) {
this.addToRelations(incomingRelations, incomingExternalRelations[i], 'in');
}
for (var i = 0; i < outgoingExternalRelations.length; i++) {
this.addToRelations(outgoingRelations, outgoingExternalRelations[i], 'out');
}
return this.json().encode({
'in': incomingRelations,
'out': outgoingRelations,
'number': gr.getValue('number'),
'short_description': gr.getValue('short_description')
});
},
addToRelations: function(relationsArray, relation, boundType) {
var projectSysId, projectNumber, projectName, taskSysId, taskNumber, taskName;
if (boundType == 'in') {
projectSysId = relation.parent_top_task;
projectNumber = relation.parent_top_task_number;
projectName = relation.parent_top_task_short_description;
taskSysId = relation.parent;
taskNumber = relation.parent_number;
taskName = relation.parent_short_description;
} else {
projectSysId = relation.child_top_task;
projectNumber = relation.child_top_task_number;
projectName = relation.child_top_task_short_description;
taskSysId = relation.child;
taskNumber = relation.child_number;
taskName = relation.child_short_description;
}
var taskRelation = {
project_sys_id: projectSysId,
project_number: projectNumber,
project_name: projectName,
task_sys_id: taskSysId,
task_number: taskNumber,
task_name: taskName,
isPendingNotification: relation.isPendingNotification
};
if (relationsArray.length == 0 || !this.getExstingExternalRelation(relationsArray, projectSysId)) {
var uniqueRelation = {};
uniqueRelation['project_sys_id'] = projectSysId;
uniqueRelation['project_number'] = projectNumber;
uniqueRelation['project_name'] = projectName;
uniqueRelation.relations = [taskRelation];
relationsArray.push(uniqueRelation);
} else {
var existingRelation = this.getExstingExternalRelation(relationsArray, projectSysId);
existingRelation.relations.push(taskRelation);
}
PPMDebug.log("relationsArray -> " + (new JSON()).encode(relationsArray));
},
getExstingExternalRelation: function(relationsArray, projectSysId) {
for (var i = 0; i < relationsArray.length; i++) {
if (projectSysId == relationsArray[i]['project_sys_id'])
return relationsArray[i];
}
},
getNotifications: function() {
var planningConsoleServer = this.planningConsoleServer,
sysClass = this.sysClassName(),
sysId = this.sysId(),
notifications,
notificationsStr;
notifications = planningConsoleServer.fetchNotifications(sysClass, sysId);
notificationsStr = this.json().encode(notifications);
return notificationsStr;
},
isProjectCurrencyView: function() {
var taskId = this.gRequest.getParameter("sysparm_sys_id");
return new ProjectCurrencyUtil().isStatusReportViewProjectCurrency(taskId);
},
type: 'PlanningConsoleProcessor'
};
Sys ID
f22024629f323100598a5bb0657fcf92