Name
global.PTGlobalAPI
Description
Planned Task Global API
Script
var PTGlobalAPI = Class.create();
PTGlobalAPI.convertDateTimeZone = function( /* GlideDateTime */ dateTime, /*String*/ timeZone, isValue) {
var tz = Packages.java.util.TimeZone.getTimeZone(timeZone);
var gdt = new GlideDateTime();
gdt.setTZ(tz);
if (isValue)
gdt.setValue(dateTime);
else
gdt.setDisplayValue(dateTime);
return gdt;
};
PTGlobalAPI.convertDateTimeZoneFrom_To = function(glideDateTime, from, to) {
var gsdt = new GlideScheduleDateTime(glideDateTime);
var displayValue = gsdt.convertTimeZone(from, to);
var offset = PTGlobalAPI.getDSTOffset(displayValue, to, false);
var gdt = new GlideDateTime();
gdt.setDisplayValue(displayValue);
if (offset) {
gdt.add(-offset);
}
return gdt;
};
PTGlobalAPI.getDSTOffset = function( /* GlideDateTime */ dateTime, /*String*/ timeZone, isValue) {
var gdt = PTGlobalAPI.convertDateTimeZone(dateTime, timeZone, isValue);
if (gdt.isDST()) {
return gdt.getDSTOffset();
}
return null;
};
PTGlobalAPI.convertDateTimeZoneAndFormat = function( /* String */ dateTime, fromTimeZone, toTimeZone, fromFormat, toFormat) {
var sdf = new Packages.java.text.SimpleDateFormat(fromFormat);
var fromTZ = Packages.java.util.TimeZone.getTimeZone(fromTimeZone);
sdf.setTimeZone(fromTZ);
var toSDF = new Packages.java.text.SimpleDateFormat(toFormat);
var toTZ = Packages.java.util.TimeZone.getTimeZone(toTimeZone);
toSDF.setTimeZone(toTZ);
return (toSDF.format(sdf.parse(dateTime)));
};
PTGlobalAPI.getProjectTaskTable = function(parentTable) {
return SNC.PPMConfig.getProjectTaskTable(parentTable);
};
PTGlobalAPI.getNumber = function(sysClassName) {
return GlideNumberManager.getNumber(sysClassName);
};
PTGlobalAPI.enableMoveAllTasksRegardlessOfConstraintSessionProperty = function() {
gs.getSession().putProperty("ppm.move_all_tasks.regardless_of_constraint", "true");
};
PTGlobalAPI.disableMoveAllTasksRegardlessOfConstraintSessionProperty = function() {
gs.getSession().putProperty("ppm.move_all_tasks.regardless_of_constraint", "false");
};
PTGlobalAPI.getProjectTaskFieldDefaultValues = function( /* string */ tableName, /* array */ fields) {
var fieldDefaultValues = {};
var tableGr = new GlideRecord(tableName);
if (!tableGr.isValid() || !tableGr.canRead() || !tableGr.instanceOf('pm_project_task'))
return null;
for (var i = 0; i < fields.length; i++) {
if (tableGr.isValidField(fields[i])) {
var elementDefaultValue = tableGr.getElement(fields[i]).getED().getDefault();
if (JSUtil.notNil(elementDefaultValue))
fieldDefaultValues[fields[i]] = elementDefaultValue;
}
}
return fieldDefaultValues;
};
PTGlobalAPI.getProjectTaskDefaultValueFields = function() {
var tableDescriptor = new GlideTableDescriptor("pm_project_task");
var fields = tableDescriptor.getActiveFieldNames();
var columns = [];
for (var i = 0; i < fields.size(); i++) {
var colName = fields.get(i);
var elementDescriptor = tableDescriptor.getElementDescriptor(colName);
if (JSUtil.notNil(elementDescriptor.getDefault()))
columns.push(colName);
}
return columns;
};
PTGlobalAPI.populateDefaultValues = function(task, defaultColumnValues) {
if (task.sys_class_name && task.sys_class_name.contains('project_task')) {
for (var key in defaultColumnValues) {
if (JSUtil.nil(task[key])) {
if (defaultColumnValues[key].startsWith('javascript')) {
var defaultValue = GlideEvaluator.evaluateString(defaultColumnValues[key]);
if (JSUtil.notNil(defaultValue))
task[key] = processDefaultValue(defaultValue);
} else
task[key] = defaultColumnValues[key];
}
}
}
};
function processDefaultValue(value){
if(value == true) return 'true';
if(value == false) return 'false';
return value;
}
//this is to check for teamspace projects from scoped app
PTGlobalAPI.isProject = function(className) {
var gr = new GlideRecord(className);
return gr.instanceOf('pm_project');
};
PTGlobalAPI.isProjectTask = function(className) {
var gr = new GlideRecord(className);
return gr.instanceOf('pm_project_task');
};
PTGlobalAPI.flushMessages = function() {
gs.flushMessages();
};
PTGlobalAPI.moveResourceAssignments = function(projectId) {
if (GlidePluginManager.isActive('sn_plng_att_core')) {
var resourceAssignmentMoveSI = new sn_plng_att_core.ResourceAssignmentMoveSNC();
if (resourceAssignmentMoveSI.canShowRealignResourceAssignmentLink(projectId)) {
resourceAssignmentMoveSI.moveResourceAssignmentsInTaskHirarchy(projectId);
}
}
};
PTGlobalAPI.prototype = {
initialize: function() {},
fullRecalculate: function(sys_id) {
return new SNC.PlannedTaskAPI().fullRecalculate(sys_id);
},
recalculateDeferredTask: function(sys_id) {
return new SNC.PlannedTaskAPI().recalculateDeferredTask(sys_id);
},
initializeTask: function(gr) {
var plannedTaskAPI = new SNC.PlannedTaskAPI();
return plannedTaskAPI.initializeTask(gr);
},
calculateStartDate: function( /*GlideDateTime*/ endDate, /*GlideDuration*/ duration, scheduleId) {
var resp = JSON.parse(new SNC.PlannedTaskAPI().calculateStartDate(endDate, duration, scheduleId));
if (resp.status == 'success') {
var gdt = new GlideDateTime();
gdt.setDisplayValue(resp.date);
return gdt;
}
return endDate;
},
getDescendants: function(gr, include) {
return new SNC.PlannedTaskAPI().getDescendants(gr, include);
},
/**
* Method is to resolve the issue of getting custom roles of scoped app
* Fix: get the scoped app custom role based on configured field and by passing suffix
*/
getScopedAppRole: function(roleSuffix, rolePrefixField) {
var role = roleSuffix;
var prefix = "it";
var config = new GlideRecord("pm_app_config");
config.query();
config.next();
var prefixFromConfig = config.getElement(rolePrefixField);
if (prefixFromConfig != null) {
prefix = prefixFromConfig;
}
role = prefix.concat("_" + role);
return role;
},
createRelation: function(params, stopWorkflow) {
if (gs.nil(params.child) || gs.nil(params.parent) || gs.nil(params.parent_top_task) || gs.nil(params.child_top_task))
return null;
var gr = new GlideRecord('planned_task_rel_planned_task');
gr.initialize();
gr.setValue('parent', params.parent);
gr.setValue('child', params.child);
gr.setValue('parent_top_task', params.parent_top_task);
gr.setValue('child_top_task', params.child_top_task);
gr.setValue('type', '33a57d3d0a0a0b7b00819e4d4402fb14');
gr.setValue('sub_type', 'fs');
gr.setValue('lag', params.lag);
if (stopWorkflow)
gr.setWorkflow(false);
return gr.insert();
},
removeUserRoles: function(userSysId, roles) {
if (gs.nil(userSysId)) {
gs.error("userSysId shouldn't be null");
return;
}
if (gs.nil(roles)) {
gs.error("roles shouldn't be null");
return;
}
var gr = new GlideRecord('sys_user_has_role');
gr.addQuery('role.name', 'IN', roles);
gr.addQuery('user', userSysId);
gr.query();
gr.deleteMultiple();
},
removeMembersFromGroup: function(groupId) {
if (gs.nil(groupId)) {
gs.error("groupId shouldn't be null");
return;
}
var gr = new GlideRecord('sys_user_grmember');
gr.addQuery('group', groupId);
gr.query();
gr.deleteMultiple();
},
removeGroupMembersById: function(groupMemberIds) {
if (gs.nil(groupMemberIds)) {
gs.error("groupMemberIds shouldn't be null");
return;
}
var groupMemberGR = new GlideRecord('sys_user_grmember');
groupMemberGR.addQuery('sys_id', 'IN', groupMemberIds.join(','));
groupMemberGR.query();
groupMemberGR.deleteMultiple();
},
updateMultipleDictionary: function(gr, changeMap) {
Object.keys(changeMap).forEach(function(key) {
gr.setValue(key, changeMap[key]);
});
gr.updateMultiple();
},
updateDictionary: function(gr, changeMap) {
Object.keys(changeMap).forEach(function(key) {
gr.setValue(key, changeMap[key]);
});
gr.update();
},
getEntityMetadata: function(sysClass, context) {
return new SNC.PlannedTaskAPI().entityMetadata(sysClass, context);
},
/**
*
* @param {string} sysId
*/
getTaskStartDate: function(sysId) {
return new SNC.PlannedTaskAPI().getTaskStartDate(sysId);
},
/**
*
* @param {string} startDate
* @param {string} duration
* @param {string} scheduleId
*/
calculateEndDate: function(startDate, duration, scheduleId) {
return new SNC.PlannedTaskAPI().calculateEndDate(startDate, duration, scheduleId);
},
/**
*
* @param {string} startDate - internalDisplayValue
* @param {string} endDate - internalDisplayValue
* @param {string} scheduleId
*/
calculateDuration: function(startDate, endDate, scheduleId) {
return new SNC.PlannedTaskAPI().calculateDuration(startDate, endDate, scheduleId);
},
/**
*
* @param {string} taskId
* @param {string} taskId - can be Planned Task, WorkPlan, WorkPlanTask
*/
getScheduleForTask: function(taskId, sysClassName) {
var gr = new GlideRecord(sysClassName);
if (gr.instanceOf('pm_project') || gr.instanceOf('pm_project_task')) {
return this.getScheduleForTaskId(taskId);
}
if (gr.instanceOf('sn_wp_work_plan') || gr.instanceOf('sn_wp_work_plan_task')) {
return this.getScheduleForWorkPlan(taskId);
}
PPMDebug.log('getScheduleForTaskId: ' + taskId);
return new SNC.PlannedTaskAPI().getScheduleForTaskId(taskId);
},
/**
*
* @param {string} taskId
*/
getScheduleForTaskId: function(taskId) {
PPMDebug.log('getScheduleForTaskId: ' + taskId);
return new SNC.PlannedTaskAPI().getScheduleForTaskId(taskId);
},
/**
*
* @param {string} taskId
*/
getScheduleForWorkPlan: function(taskId) {
PPMDebug.log('getScheduleForTaskId: ' + taskId);
return new SNC.PlannedTaskAPI().getScheduleForWorkPlan(taskId);
},
getSchedule: function(sysClassName, scheduleId, scheduleTimezone, startYear, endYear, forward) {
var gr = new GlideRecord(sysClassName);
if (gr.instanceOf('pm_project') || gr.instanceOf('pm_project_task')) {
return this.getProjectSchedule(scheduleId, scheduleTimezone, startYear, endYear, forward);
}
if (gr.instanceOf('sn_wp_work_plan') || gr.instanceOf('sn_wp_work_plan_task')) {
return this.getWorkPlanSchedule(scheduleId, scheduleTimezone, startYear, endYear, forward);
}
},
getProjectSchedule: function(scheduleId, scheduleTimezone, startYear, endYear, forward) {
PPMDebug.log('getProjectSchedule: ' + scheduleId);
return new SNC.PlannedTaskAPI().getSchedule(scheduleId, scheduleTimezone, startYear, endYear, forward);
},
getWorkPlanSchedule: function(scheduleId, scheduleTimezone, startYear, endYear, forward) {
PPMDebug.log('getWorkPlanSchedule: ' + scheduleId);
return new SNC.PlannedTaskAPI().getWorkPlanSchedule(scheduleId, scheduleTimezone, startYear, endYear, forward);
},
RecalculateStartDateFromAbsoluteDurationPerSchedule: function(endDate, duration, scheduleId) {
var durationActualValue = this.getDurationActual(endDate, duration, scheduleId);
var startDate = new SNC.PlannedTaskAPI().calculateStartDate(endDate, durationActualValue, scheduleId);
return startDate;
},
getConsoleConfig: function(sysClass, context) {
return new SNC.PlannedTaskAPI().gridEntityMetadata(sysClass, context);
},
/*New API for scenario Planning to fetch projects demands for multiple portfolios &
* String baseClasses - Fetch data for just requested classes and order e.g 'pm_project,dmn_demand' requirement to avoid programs &
* int recordLimit - Limit number of task fetched (OPTIONAL) "-1" to fetch all &
* String columns - Planning Console Display Column(jsonColumn) to fetch only requested column data(For ranking feature)(OPTIONAL) "" to fetch gantt data
*/
fetchGanttDataForMultipleSources: function(sysClassName, planningConsoleContext, sysIds, queryConstraintConditionsMap, recordLimit, columns, baseClasses) {
var queryConstraint = this.buildQueryConstraintObject(queryConstraintConditionsMap);
return new SNC.PlannedTaskAPI().getGanttDataForMultiSources(sysClassName, planningConsoleContext,
sysIds, queryConstraint, recordLimit, columns, baseClasses);
},
buildQueryConstraintObject: function(queryMap) {
var queryConstraint = new SNC.QueryConstraint();
for (var tableName in queryMap) {
queryConstraint.addNodeQueryCondition(tableName, queryMap[tableName]);
}
return queryConstraint;
},
fetchCurrencySymbols: function() {
var currencySymbol = new SNC.PlanningScriptable().getCurrencySymbol();
return JSON.parse(currencySymbol);
},
getScheduleId: function(taskSysId) {
if (JSUtil.nil(taskSysId)) {
return "";
}
var scheduleId = "";
var plannedTask = new GlideRecord("planned_task");
plannedTask.get(taskSysId);
var topTaskGr = plannedTask.top_task.getRefRecord();
var sysClassName = topTaskGr.getValue('sys_class_name');
var topTaskRecord = new GlideRecord(sysClassName);
if (topTaskRecord.get(plannedTask.top_task)) {
if (!JSUtil.nil(topTaskRecord.schedule)) {
scheduleId = topTaskRecord.schedule;
}
}
return scheduleId;
},
getHoursPerDay: function(startDate, scheduleSysId, taskSysId) {
if (JSUtil.nil(scheduleSysId)) {
if (JSUtil.nil(startDate)) {
var gr = new GlideRecord("planned_task");
if (!gr.get(taskSysId))
return 24;
startDate = gr.start_date;
}
scheduleSysId = this.getScheduleId(taskSysId);
}
var hoursPerDay = new SNC.PlannedTaskAPI().getHoursPerDay(startDate, scheduleSysId);
return hoursPerDay;
},
getDurationActual: function(endDate, taskDuration, scheduleId) {
if (JSUtil.nil(taskDuration))
return (new GlideDuration(0));
var numberOfDays = taskDuration.getDayPart();
var hr = parseFloat(this.getHoursPerDay(endDate, scheduleId));
var numberOfDaysperScheduleNumericValue = numberOfDays * hr * 3600 * 1000;
var dayDuration = new GlideDuration();
dayDuration.setValue(numberOfDays * 24 * 3600 * 1000);
var durationWithoutDate = taskDuration.subtract(dayDuration);
var durationActual = new GlideDuration(numberOfDaysperScheduleNumericValue);
durationActual = durationActual.add(durationWithoutDate);
return durationActual; //.getDurationValue();
},
getPlannedTaskExtentions: function(extention) {
return new GlideScriptedExtensionPoint().getExtensions(extention);
},
buildGlideRecord: function(gr, task, columns) {
var dateColumns = ['start', 'end'];
for (var i = 0; i < columns.length; i++) {
var column = columns[i];
if (JSUtil.nil(column.internalColumnName) || column.internalColumnName == 'dependency')
continue;
var field = task[column.name];
if (field && column.internalColumnName != 'sys_id') {
if (column.type == 'date_time' || column.type == 'date') {
var gdt;
if (column.type == 'date' && dateColumns.indexOf(column.internalColumnName) != -1)
gdt = new GlideDate();
else
gdt = new GlideDateTime();
if (column.isMillisecond)
gdt.setNumericValue(this._getFieldValue(field));
else if (column.isDisplay)
gdt.setDisplayValue(this._getFieldValue(field));
else
gdt.setDisplayValueInternal(this._getFieldValue(field));
if (column.type == 'date' && dateColumns.indexOf(column.internalColumnName) != -1)
gr.setValue(column.internalColumnName, gdt.getLocalDate());
else
gr.setValue(column.internalColumnName, gdt.getValue());
if (column.internalColumnName == 'start_date')
gr.setValue('schedule_start_date', gdt.getValue());
if (column.internalColumnName == 'end_date')
gr.setValue('schedule_end_date', gdt.getValue());
} else if (column.internalColumnName == 'duration' || column.internalColumnName == 'work_duration') {
gr.setValue(column.internalColumnName, this._getDurationValue(field));
} else
gr.setValue(column.internalColumnName, this._getFieldValue(field));
}
}
},
buildPlannedTaskRelationGR: function(relationGr, relation) {
relationGr.setValue("parent", relation.source);
relationGr.setValue("child", relation.target);
relationGr.setValue("sub_type", relation.type);
relationGr.setValue("parent_top_task", relation.parent_top_task);
relationGr.setValue("child_top_task", relation.child_top_task);
var lag = new GlideDuration(relation.lag + ' 00:00:00');
relationGr.setValue("lag", lag.getValue());
},
_getDurationValue: function(field) {
var value = this._getFieldValue(field);
if (!JSUtil.nil(value))
return value + ":00";
else
return '';
},
_getFieldValue: function(field) {
if (field.hasOwnProperty("value")) {
return field.value;
} else
return field;
},
addDaysToTimeZoneDateTime: function(dateTime, days, timeZone) {
return new SNC.PTScheduleAPI().addDaysToTimeZoneDateTime(dateTime, days, timeZone);
},
changeParent: function(gr, oldParentId, newParentId, enginePreferences) {
return new SNC.PlannedTaskAPI().changeParent(gr, oldParentId, newParentId, enginePreferences);
},
validateChangeParent: function(gr, oldParentId, newParentId) {
return new SNC.PlannedTaskAPI().validateChangeParent(gr, oldParentId, newParentId);
},
calculateEndDateInternal: function(startDateStr, durationStr, scheduleId) {
return new SNC.PlannedTaskAPI().calculateEndDateInternal(startDateStr, durationStr, scheduleId);
},
calculateDurationInternal: function(startDateStr, endDateStr, scheduleId) {
return new SNC.PlannedTaskAPI().calculateDurationInternal(startDateStr, endDateStr, scheduleId);
},
isTaskStartDateValidForProject: function(projectId, durationStr, startDateStr) {
return new SNC.PlannedTaskAPI().isTaskStartDateValidForProject(projectId, durationStr, startDateStr);
},
isRelationValid: function(projectId, gr) {
return new SNC.PlannedTaskAPI().isRelationValid(projectId, gr);
},
isHierarchyValid: function(projectId, gr) {
return new SNC.PlannedTaskAPI().isHierarchyValid(projectId, gr);
},
isParentValid: function(projectId, gr) {
return new SNC.PlannedTaskAPI().isParentValid(projectId, gr);
},
recalculateRelation: function(gr, topTask, operation, enginePreferences) {
return new SNC.PlannedTaskAPI().recalculateRelation(gr, topTask, operation, enginePreferences);
},
recalculateTask: function(gr, isSaveProject, dirtyTaskIds) {
return new SNC.PlannedTaskAPI().recalculateTask(gr, isSaveProject, dirtyTaskIds);
},
recalculateTaskWithPreviousGr: function(currentGr, isSaveProject, dirtyTaskIds, previousGr) {
return new SNC.PlannedTaskAPI().recalculateTaskWithPreviousGr(currentGr, isSaveProject, dirtyTaskIds, previousGr);
},
deleteTaskAndRecalculate: function(gr, isSaveProject) {
return new SNC.PlannedTaskAPI().deleteTaskAndRecalculate(gr, isSaveProject);
},
setConstraints: function(recalculationConstraint) {
return new SNC.PlannedTaskAPI().setConstraints(recalculationConstraint);
},
setEnginePreference: function(enginePreferences) {
return new SNC.PlannedTaskAPI().setEnginePreference(enginePreferences);
},
checkCycle: function(taskId) {
return new SNC.PlannedTaskAPI().checkCycle(taskId);
},
isInterProjectRelationValid: function(gr) {
return new SNC.PlannedTaskAPI().isInterProjectRelationValid(gr);
},
recalculateWithDirtyTasks: function(topTaskId, dirtyTaskIds) {
return new SNC.PlannedTaskAPI().recalculateWithDirtyTasks(topTaskId, dirtyTaskIds);
},
acceptNotification: function(entityId, sysClassName, notificationSysId) {
return new SNC.PlannedTaskAPI().acceptNotification(entityId, sysClassName, notificationSysId);
},
rejectNotification: function(notificationSysId) {
return new SNC.PlannedTaskAPI().rejectNotification(notificationSysId);
},
applyTemplate: function(projectId, templateId, startDate) {
return new SNC.PlannedTaskAPI().applyTemplate(projectId, templateId, startDate);
},
applyTemplateOnProject: function(templateId, projectId, startDate) {
return GlideProjectTemplate.apply(templateId, projectId, startDate);
},
validateWbs: function(projectId) {
return new SNC.PlannedTaskAPI().validateWbs(projectId);
},
getProjectTemplateTable: function(tableName) {
return SNC.PPMConfig.getTemplateTable(tableName);
},
interProjectRelationCallback: function(parentGr, childGr, relationId, interProjectDependencyType) {
return new SNC.PlannedTaskAPI().interProjectRelationCallback(parentGr, childGr, relationId, interProjectDependencyType);
},
setTranslatedMessages: function(msgs) {
return new SNC.PlannedTaskAPI().setTranslatedMessages(msgs);
},
convertDateIfNotInSchedule: function(projectDate, scheduleId, timeZone) {
var scheduleUtil = new SNC.PTScheduleAPI().getSchedule(scheduleId, timeZone);
return scheduleUtil.convertDateIfNotInSchedule(projectDate);
},
copyProject: function(projectId, projectStartDate, projectName, resetFields, defaultFields) {
return new SNC.PlannedTaskAPI().copyProject(projectId, projectStartDate, projectName, resetFields, defaultFields);
},
copyTask: function(taskId, parentId, shortDescription) {
return new SNC.PlannedTaskAPI().copyTask(taskId, parentId, shortDescription);
},
performWorkspaceAction: function(entityId, actionPayload, fireBrs) {
var api = new SNC.PlannedTaskAPI();
return api.performWorkspaceAction(entityId, actionPayload, fireBrs);
},
createRecord: function(table, fieldValueMap, workflowFlag, isSecure) {
if (!this._canAllowTheOperation(table))
return -1;
var gr = this._getGlideRecord(table, isSecure);
gr.initialize();
gr.setWorkflow(workflowFlag);
for (var field in fieldValueMap)
gr.setValue(field, fieldValueMap[field]);
return this._getResponse(gr.insert(), gr);
},
updateRecord: function(table, fieldValueMap, workflowFlag, isSecure, sysId) {
if (!this._canAllowTheOperation(table) || JSUtil.nil(sysId))
return -1;
var gr = this._getGlideRecord(table, isSecure);
gr.get(sysId);
gr.setWorkflow(workflowFlag);
for (var field in fieldValueMap)
gr.setValue(field, fieldValueMap[field]);
return this._getResponse(gr.update(), gr);
},
deleteRecord: function(sysId, table, workflowFlag, isSecure) {
if (!this._canAllowTheOperation(table) || JSUtil.nil(sysId))
return -1;
var gr = this._getGlideRecord(table, isSecure);
gr.get(sysId);
gr.setWorkflow(workflowFlag);
gr.deleteRecord();
return this._getResponse(sysId, gr);
},
deleteMultipleRecords: function(encodedQuery, table, workflowFlag, isSecure) {
if (!this._canAllowTheOperation(table) || JSUtil.nil(encodedQuery))
return -1;
var gr = this._getGlideRecord(table, isSecure);
gr.addEncodedQuery(encodedQuery);
gr.setWorkflow(workflowFlag);
gr.deleteMultiple();
return gr;
},
_getResponse: function(id, gr) {
return {
sysId: id,
glideRecord: gr
};
},
_canAllowTheOperation: function(table) {
var arr = ['resource_plan', 'resource_allocation', 'resource_allocation_daily'];
return (arr.indexOf(table) != -1);
},
_getGlideRecord: function(table, isSecure) {
var gr;
if (isSecure)
gr = new GlideRecordSecure(table);
else
gr = new GlideRecord(table);
return gr;
},
type: 'PTGlobalAPI'
};
Sys ID
56d28c5f0b101300ee540e7363673a4a