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

Offical Documentation

Official Docs: