340 lines
17 KiB
JavaScript
340 lines
17 KiB
JavaScript
"use strict";
|
|
(function () {
|
|
'use strict';
|
|
angular.module('templateModule')
|
|
.factory('ticketTemplateModel', ['ticketTemplateService', 'categoriesService', '$log', 'metadataModel',
|
|
function (ticketTemplateService, categoriesService, $log, metadataModel) {
|
|
var self = {}, incidentMetadata = null, workorderMetadata = null, changeMetadata = null, releaseMetadata = null;
|
|
self.selectedIncidentTemplateTier = [];
|
|
self.defaultIncidentTemplateTier = '';
|
|
/**
|
|
* Public functions
|
|
*/
|
|
self.getTemplatesForSmartRecorder = function (params) {
|
|
return ticketTemplateService.getTemplatesForSmartRecorder(params).then(function (templates) {
|
|
return processSmartRecorderTemplates(templates);
|
|
});
|
|
};
|
|
self.getIncidentTemplateList = function (searchQuery, companyName, metadata) {
|
|
incidentMetadata = metadata;
|
|
return ticketTemplateService.getIncidentTemplateList(searchQuery, companyName)
|
|
.then(processIncidentTemplateList)
|
|
.catch(function () {
|
|
$log.error('Error getting incident template list.');
|
|
});
|
|
};
|
|
self.getIncidentTemplateListByCategory = function (params, metadata) {
|
|
incidentMetadata = metadata;
|
|
return ticketTemplateService.getIncidentTemplateListByCategory(params)
|
|
.then(processIncidentTemplateList)
|
|
.catch(function () {
|
|
$log.error('Error getting incident template list by category.');
|
|
});
|
|
};
|
|
self.getIncidentTemplateTierOptions = function (tier) {
|
|
var dependsParam = {}, dependency = {};
|
|
if (self.selectedIncidentTemplateTier[0] !== self.defaultIncidentTemplateTier) {
|
|
dependsParam = {
|
|
templateCategoryTier1: self.selectedIncidentTemplateTier[0]
|
|
};
|
|
dependency = {
|
|
depends: dependsParam
|
|
};
|
|
}
|
|
if (self.selectedIncidentTemplateTier[1] !== self.defaultIncidentTemplateTier) {
|
|
dependsParam.templateCategoryTier2 = self.selectedIncidentTemplateTier[1];
|
|
}
|
|
return ticketTemplateService.getIncidentTemplateTierOptions(tier + 1, dependency).then(function (response) {
|
|
return response[0].items[0];
|
|
});
|
|
};
|
|
self.getAllWorkorderTemplateList = function (metadata, company) {
|
|
workorderMetadata = metadata;
|
|
return ticketTemplateService.getAllWorkorderTemplateList(company)
|
|
.then(processWorkorderTemplateList)
|
|
.catch(function () {
|
|
$log.error('Error getting workorder template list.');
|
|
});
|
|
};
|
|
self.getWorkorderTemplateList = function (params, metadata) {
|
|
workorderMetadata = metadata;
|
|
return ticketTemplateService.getWorkorderTemplateList(params.searchText, params.companyName)
|
|
.then(processWorkorderTemplateList)
|
|
.catch(function () {
|
|
$log.error('Error getting workorder template list.');
|
|
});
|
|
};
|
|
self.getServicerequestTemplateList = function (searchQuery, companyName, customerId) {
|
|
return ticketTemplateService.getServicerequestTemplateList(searchQuery, companyName, customerId)
|
|
.then(processServicerequestTemplateList)
|
|
.catch(function () {
|
|
$log.error('Error getting service request template list.');
|
|
});
|
|
};
|
|
self.getServicerequestDynamicOptions = function (params, onSuccess) {
|
|
var queryParams = { srdId: params[0], questionId: params[1] };
|
|
if (typeof params[2] !== 'undefined' && typeof params[3] !== 'undefined') {
|
|
var questions = params[2], relatedQuestions = params[3];
|
|
_.each(questions, function (question) {
|
|
if (relatedQuestions.indexOf(question.id) !== -1 && question.id !== params[1]) {
|
|
if (question.format === 'DATE_TIME') {
|
|
question.answer = processTimeAnswer(question.answer.time, question.answer.date) + '';
|
|
}
|
|
if (question.format === 'DATE_ONLY') {
|
|
question.answer = moment(question.answer).unix() + '';
|
|
}
|
|
if (question.format === 'TIME_ONLY') {
|
|
question.answer = processTimeAnswer(question.answer) + '';
|
|
}
|
|
if (typeof question.answer === 'undefined' || question.answer === null) {
|
|
question.answer = '';
|
|
}
|
|
queryParams[question.id] = question.answer;
|
|
}
|
|
});
|
|
}
|
|
return ticketTemplateService.getServicerequestDynamicOptions(queryParams)
|
|
.then(onSuccess)
|
|
.catch(function () {
|
|
$log.error('Error getting service request dynamic options.');
|
|
});
|
|
};
|
|
self.processDynamicQuestions = function (srdId, questions) {
|
|
_.each(questions, function (question) {
|
|
// if (question.visibility) {
|
|
if (true) {
|
|
if (question.format === 'QUERY_MENU' || question.format === 'DYNAMIC_MENU') {
|
|
var params = [srdId, question.id];
|
|
if (question.format === 'DYNAMIC_MENU') {
|
|
params = [srdId, question.id, questions, question.relatedQuestions];
|
|
}
|
|
self.getServicerequestDynamicOptions(params, function (response) {
|
|
question.options = response.objects;
|
|
});
|
|
}
|
|
}
|
|
});
|
|
};
|
|
self.updateDynamicQuestions = function (question, questions) {
|
|
if (question.format === 'DYNAMIC_MENU') {
|
|
if (question.dataLoading) {
|
|
return;
|
|
}
|
|
question.options = [];
|
|
question.dataLoading = true;
|
|
var params = [question.srdIdForNullCheck, question.id, questions, question.relatedQuestions];
|
|
self.getServicerequestDynamicOptions(params, function (response) {
|
|
question.options = response.objects;
|
|
}).finally(function () {
|
|
question.dataLoading = false;
|
|
});
|
|
}
|
|
};
|
|
self.getTaskTemplateMetadata = function () {
|
|
return ticketTemplateService.getTaskTemplateMetadata().then(function (response) {
|
|
return response[0].items[0].types;
|
|
});
|
|
};
|
|
self.getTaskGroupPreview = function (groupId) {
|
|
return ticketTemplateService.getTaskGroupPreview(groupId).then(function (response) {
|
|
return response[0].items[0];
|
|
});
|
|
};
|
|
self.getChangeTemplateList = function (searchQuery, companyName, metadata) {
|
|
changeMetadata = metadata;
|
|
return ticketTemplateService.getChangeTemplateList(searchQuery, companyName).then(function (response) {
|
|
var templateList = response.objects;
|
|
var data = _.map(templateList, function (item) {
|
|
return parseChangeTemplateItem(item);
|
|
});
|
|
return { items: data, exceedsChunkSize: response.exceedsChunkSize };
|
|
});
|
|
};
|
|
self.getReleaseTemplateList = function (searchQuery, companyName, metadata) {
|
|
releaseMetadata = metadata;
|
|
return ticketTemplateService.getReleaseTemplateList(searchQuery, companyName).then(function (response) {
|
|
var templateList = response.objects;
|
|
var data = _.map(templateList, function (item) {
|
|
return parseReleaseTemplateItem(item);
|
|
});
|
|
return { items: data, exceedsChunkSize: response.exceedsChunkSize };
|
|
});
|
|
};
|
|
self.getAllActivityTemplateList = function (company) {
|
|
return ticketTemplateService.getAllActivityTemplateList(company)
|
|
.then(processActivityTemplateList)
|
|
.catch(function () {
|
|
$log.error('Error getting activity template list.');
|
|
});
|
|
};
|
|
self.getActivityTemplateList = function (params) {
|
|
return ticketTemplateService.getActivityTemplateList(params.searchText, params.companyName)
|
|
.then(processActivityTemplateList)
|
|
.catch(function () {
|
|
$log.error('Error getting activity template list.');
|
|
});
|
|
};
|
|
self.getTaskTemplateList = function (term, companyName) {
|
|
return ticketTemplateService.getTaskTemplateList(term, companyName);
|
|
};
|
|
/**
|
|
* Private functions
|
|
*/
|
|
function processSmartRecorderTemplates(templates) {
|
|
return metadataModel.getMetadataByTypes([EntityVO.TYPE_INCIDENT, EntityVO.TYPE_WORKORDER]).then(function (metadataResponse) {
|
|
var incidentMetadata = metadataResponse[0], workorderMetadata = metadataResponse[1];
|
|
_.forEach(templates, function (template) {
|
|
if (template.type === 'incidenttemplate') {
|
|
// backend has inconsistent naming for Template Type. Smart search rest call returns as 'incidenttemplate',
|
|
// while string search rest call returns as 'incidentTemplate'.
|
|
// We will set them to the same name here so that it won't cause issue on share component
|
|
template.type = 'incidentTemplate';
|
|
var allCategories = template.templateObject && template.templateObject.categorizations.concat(template.templateObject.resCategorizations);
|
|
template.allCategories = categoriesService.populateCategories(allCategories, incidentMetadata);
|
|
}
|
|
else if (template.type === 'workordertemplate' || template.type === 'workOrderTemplate') {
|
|
// same for workorder template type name. See comments above
|
|
template.type = 'workorderTemplate';
|
|
template.allCategories = categoriesService.populateCategories(template.templateObject.categorizations, workorderMetadata);
|
|
}
|
|
});
|
|
return templates;
|
|
});
|
|
}
|
|
/**
|
|
* Process incident template list data from server.
|
|
*
|
|
* @param {Array} data
|
|
*/
|
|
function processIncidentTemplateList(data) {
|
|
var items = data && data.objects || [];
|
|
if (!items.length) {
|
|
$log.warn('Incient template list returned from server is empty or malformed.');
|
|
}
|
|
self.incidentTemplateList = _.map(items, function (item) {
|
|
return parseIncidentTemplateItem(item);
|
|
});
|
|
$log.debug('Incident template list loaded:');
|
|
$log.debug(self.incidentTemplateList);
|
|
}
|
|
/**
|
|
* Process service request template list data from server.
|
|
*
|
|
* @param {Array} data
|
|
*/
|
|
function processServicerequestTemplateList(data) {
|
|
var items = data && data.objects || [];
|
|
if (!items.length) {
|
|
$log.warn('Service request template list returned from server is empty or malformed.');
|
|
}
|
|
self.servicerequestTemplateList = _.map(items, function (item) {
|
|
return parseServicerequestTemplateItem(item);
|
|
});
|
|
$log.debug('Service request template list loaded:');
|
|
$log.debug(self.servicerequestTemplateList);
|
|
}
|
|
/**
|
|
* Transform raw data into incident template item.
|
|
*
|
|
* @param {Object} data
|
|
* @returns {IncidentTemplateVO} incident template item
|
|
*/
|
|
function parseIncidentTemplateItem(data) {
|
|
var incidentTemplateItem = new IncidentTemplateVO().build(data), allCategories = incidentTemplateItem.categorizations.concat(incidentTemplateItem.resCategorizations);
|
|
incidentTemplateItem.allCategories = categoriesService.populateCategories(allCategories, incidentMetadata);
|
|
return incidentTemplateItem;
|
|
}
|
|
/**
|
|
* Process workorder template list data from server.
|
|
*
|
|
* @param {Array} data
|
|
*/
|
|
function processWorkorderTemplateList(data) {
|
|
var items = data && data.objects || [];
|
|
if (!items.length) {
|
|
$log.warn('workorder template list returned from server is empty or malformed.');
|
|
}
|
|
self.workorderTemplateList = _.map(items, function (item) {
|
|
return parseWorkorderTemplateItem(item);
|
|
});
|
|
$log.debug('workorder template list loaded:');
|
|
$log.debug(self.workorderTemplateList);
|
|
}
|
|
/**
|
|
* Transform raw data into workorder template item.
|
|
*
|
|
* @param {Object} data
|
|
* @returns {WorkorderTemplateVO} workorder template item
|
|
*/
|
|
function parseWorkorderTemplateItem(data) {
|
|
var templateItem = new WorkorderTemplateVO().build(data);
|
|
templateItem.allCategories = categoriesService.populateCategories(templateItem.categorizations, workorderMetadata);
|
|
return templateItem;
|
|
}
|
|
/**
|
|
* Process Activity template list data from server.
|
|
*
|
|
* @param {Array} data
|
|
*/
|
|
function processActivityTemplateList(data) {
|
|
var items = data && data.objects || [];
|
|
if (!items.length) {
|
|
$log.warn('Activity template list returned from server is empty or malformed.');
|
|
}
|
|
self.activityTemplateList = _.map(items, function (item) {
|
|
return parseActivityTemplateItem(item);
|
|
});
|
|
$log.debug('Activity template list loaded:');
|
|
$log.debug(self.activityTemplateList);
|
|
}
|
|
/**
|
|
* Transform raw data into Activity template item.
|
|
*
|
|
* @param {Object} data
|
|
* @returns {ActivityTemplateVO} Activity template item
|
|
*/
|
|
function parseActivityTemplateItem(data) {
|
|
return new ActivityTemplateVO().build(data);
|
|
}
|
|
/**
|
|
* Transform raw data into service request template item.
|
|
*
|
|
* @param {Object} data
|
|
* @returns {ServicerequestTemplateVO} service request template item
|
|
*/
|
|
function parseServicerequestTemplateItem(data) {
|
|
var servicerequestTemplateItem = new ServicerequestTemplateVO().build(data);
|
|
return servicerequestTemplateItem;
|
|
}
|
|
function processTimeAnswer(value, date) {
|
|
if (value) {
|
|
var result = moment(value);
|
|
if (date) {
|
|
result = moment(date)
|
|
.hour(result.hour())
|
|
.minute(result.minute());
|
|
}
|
|
return result.unix();
|
|
}
|
|
return null;
|
|
}
|
|
/**
|
|
* Transform raw data into change template item.
|
|
*
|
|
* @param {Object} data
|
|
* @returns {ChangeTemplateVO} change template item
|
|
*/
|
|
function parseChangeTemplateItem(data) {
|
|
var changeTemplateItem = new ChangeTemplateVO().build(data);
|
|
changeTemplateItem.allCategories = categoriesService.populateCategories(changeTemplateItem.categorizations, changeMetadata);
|
|
return changeTemplateItem;
|
|
}
|
|
function parseReleaseTemplateItem(data) {
|
|
var releaseTemplateItem = new ReleaseTemplateVO().build(data);
|
|
releaseTemplateItem.allCategories = categoriesService.populateCategories(releaseTemplateItem.categorizations, releaseMetadata);
|
|
return releaseTemplateItem;
|
|
}
|
|
return self;
|
|
}]);
|
|
}());
|