881 lines
53 KiB
JavaScript
881 lines
53 KiB
JavaScript
"use strict";
|
|
(function () {
|
|
'use strict';
|
|
angular.module('ticketModule')
|
|
.directive('ticketTasks', ['ticketModel', 'relationModel', 'userModel', '$q', '$filter', '$modal', 'events', '$timeout',
|
|
'$state', 'i18nService', 'systemAlertService', 'objectValueMapperService', 'pwaModel',
|
|
function (ticketModel, relationModel, userModel, $q, $filter, $modal, events, $timeout, $state, i18nService, systemAlertService, objectValueMapperService, pwaModel) {
|
|
return {
|
|
restrict: 'E',
|
|
templateUrl: 'views/ticket/ticket-tasks.html',
|
|
scope: {
|
|
ticket: '=',
|
|
relationCounters: '=',
|
|
tasksDisabled: '='
|
|
},
|
|
link: function (scope, element) {
|
|
scope.userModel = {
|
|
isAccessibleUser: false
|
|
};
|
|
scope.itemsLimit = 4;
|
|
var ticket = scope.ticket, originalTasks = [], state = {
|
|
loadingTaskResources: !ticket.isDraft,
|
|
processing: false,
|
|
showing: false
|
|
};
|
|
scope.relations = relationModel.cache;
|
|
initAlertForDirty();
|
|
scope.$watch(function () {
|
|
return userModel.isAccessibleUser;
|
|
}, function (newValue) {
|
|
scope.userModel.isAccessibleUser = newValue;
|
|
});
|
|
function flattenArray() {
|
|
var flat = [];
|
|
for (var i = 0; i < arguments.length; i++) {
|
|
if (arguments[i] instanceof Array) {
|
|
flat.push.apply(flat, flattenArray.apply(this, arguments[i]));
|
|
}
|
|
else {
|
|
flat.push(arguments[i]);
|
|
}
|
|
}
|
|
return flat;
|
|
}
|
|
scope.$watch('relations', function () {
|
|
scope.relatedTasks = _.filter(_.cloneDeep(scope.relations[ticket.id]), { type: EntityVO.TYPE_TASK }) || [];
|
|
scope.originalTasks = _.cloneDeep(scope.relatedTasks);
|
|
//group tasks based on the taskGroupId
|
|
if (scope.relatedTasks.length) {
|
|
var childTasks = [], taskGroup = [];
|
|
_.forEach(scope.relatedTasks, function (item, idx, totalTasks) {
|
|
item.editable = false;
|
|
if (ticket.type !== EntityVO.TYPE_PROBLEM && ticket.type !== EntityVO.TYPE_KNOWNERROR) {
|
|
item.editable = ticket.accessMappings.relationsEditAllowed && ticket.accessMappings.tasksEditAllowed !== false
|
|
&& item.realObject.status.value === 'Staged' ? true : false;
|
|
}
|
|
if (item.realObject.taskGroupId) {
|
|
if (item.realObject.nestedTaskGroup) {
|
|
item.editable = false;
|
|
}
|
|
if (!item.realObject.taskGroupType) {
|
|
item.realObject.taskGroupType = item.realObject.sequence ? 'Sequencing' : 'Standard';
|
|
}
|
|
item.realObject.sequence = item.realObject.sequence ? item.realObject.sequence : 1;
|
|
item.realObject.childSequence = item.realObject.mainSequence + '.' + item.realObject.sequence;
|
|
var itemInTaskGroup = _.find(taskGroup, function (tg) {
|
|
return tg.realObject.taskGroupId === item.realObject.taskGroupId;
|
|
});
|
|
if (taskGroup.length === 0 || (taskGroup.length && itemInTaskGroup)) {
|
|
taskGroup.push(item);
|
|
}
|
|
else {
|
|
childTasks.push(taskGroup);
|
|
taskGroup = [];
|
|
taskGroup.push(item);
|
|
}
|
|
if (idx === totalTasks.length - 1) {
|
|
childTasks.push(taskGroup);
|
|
}
|
|
}
|
|
else {
|
|
if (taskGroup.length) {
|
|
childTasks.push(taskGroup);
|
|
taskGroup = [];
|
|
}
|
|
childTasks.push(item);
|
|
}
|
|
});
|
|
scope.relatedTasks = childTasks;
|
|
originalTasks = angular.copy(scope.relatedTasks);
|
|
}
|
|
if (scope.relationCounters) {
|
|
scope.relationCounters.tasks = flattenArray(scope.relatedTasks).length; // For the count of tasks if they are in groups.
|
|
}
|
|
}, true);
|
|
function checkAssignedTask(task, arr) {
|
|
if (task.realObject.status.value === 'Assigned') {
|
|
arr.push(task.realObject.mainSequence);
|
|
}
|
|
}
|
|
function getActiveDetails(tasks) {
|
|
var temp = [];
|
|
_.forEach(tasks, function (task) {
|
|
if (task.length) {
|
|
_.forEach(task, function (val) {
|
|
checkAssignedTask(val, temp);
|
|
});
|
|
}
|
|
else {
|
|
checkAssignedTask(task, temp);
|
|
}
|
|
});
|
|
return temp;
|
|
}
|
|
function isTaskStagedOrClosedCancelled(tasks, dropindex, index) {
|
|
var dragDropAllowed = true;
|
|
var taskIndex;
|
|
if (!isNaN(dropindex) && dropindex < index) {
|
|
for (taskIndex = dropindex; taskIndex < index; taskIndex++) {
|
|
if (tasks[taskIndex] && tasks[taskIndex].length) {
|
|
dragDropAllowed = isTaskStagedOrClosedCancelled(tasks[taskIndex], 0, tasks[taskIndex].length);
|
|
}
|
|
else if (tasks[taskIndex].realObject.status.value !== 'Staged' && tasks[taskIndex].realObject.status.reason !== 'Cancelled' && tasks[taskIndex].realObject.status.value !== 'Pending') {
|
|
dragDropAllowed = false;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
for (taskIndex = index; taskIndex < dropindex; taskIndex++) {
|
|
if (tasks[taskIndex] && tasks[taskIndex].length) {
|
|
dragDropAllowed = isTaskStagedOrClosedCancelled(tasks[taskIndex], 0, tasks[taskIndex].length);
|
|
}
|
|
else if (tasks[taskIndex].realObject.status.value !== 'Staged' && tasks[taskIndex].realObject.status.reason !== 'Cancelled' && tasks[taskIndex].realObject.status.value !== 'Pending') {
|
|
dragDropAllowed = false;
|
|
}
|
|
}
|
|
}
|
|
return dragDropAllowed;
|
|
}
|
|
scope.parentSortableOptions = {
|
|
placeholder: 'profile-relation__item-task-container',
|
|
connectWith: '.profile-relation__task-container',
|
|
cancel: ":input,.locked",
|
|
update: function (event, ui) {
|
|
state.showing = false;
|
|
var activeTask = getActiveDetails(ui.item.sortable.droptargetModel);
|
|
var belowItem = ui.item.sortable.droptargetModel[ui.item.sortable.dropindex];
|
|
var seqNum = 1;
|
|
if (belowItem.length) {
|
|
seqNum = belowItem[0].realObject.mainSequence;
|
|
}
|
|
else {
|
|
seqNum = belowItem.realObject.mainSequence;
|
|
}
|
|
var closedItem = true;
|
|
_.forEach(activeTask, function (val) {
|
|
if (seqNum >= val) {
|
|
closedItem = false;
|
|
return false;
|
|
}
|
|
});
|
|
if (activeTask.length === 0 &&
|
|
isTaskStagedOrClosedCancelled(ui.item.sortable.droptargetModel, ui.item.sortable.dropindex, ui.item.sortable.index)) {
|
|
closedItem = false;
|
|
}
|
|
if (closedItem && !state.showing) {
|
|
state.showing = true;
|
|
$timeout(function () {
|
|
scope.draftNotificationInstance = systemAlertService.warning({
|
|
text: $filter('i18n')('ticket.relatedTasks.closed.label'),
|
|
hide: 10000
|
|
});
|
|
scope.draftNotificationInstance.result
|
|
.finally(function () {
|
|
scope.draftNotificationInstance = null;
|
|
});
|
|
}, 500);
|
|
ui.item.sortable.cancel();
|
|
}
|
|
},
|
|
stop: function (event, ui) {
|
|
if (state.showing) {
|
|
return;
|
|
}
|
|
var tasks = _.cloneDeep(ui.item.sortable.sourceModel);
|
|
var activeTask = _.find(tasks, function (task, idx) {
|
|
if (task.length) {
|
|
task = task[0];
|
|
}
|
|
return ui.item.sortable.dropindex < idx
|
|
&& ui.item.sortable.model.id !== task.id
|
|
&& task.realObject.status.value === 'Assigned';
|
|
});
|
|
if (activeTask && activeTask.length) {
|
|
activeTask = activeTask[0];
|
|
}
|
|
var mainSequence = 1;
|
|
_.forEach(tasks, function (task, idx) {
|
|
var sameOrderFlag = false;
|
|
var nextTask = null;
|
|
if ((idx + 1) !== tasks.length) {
|
|
nextTask = tasks[idx + 1].length ? tasks[idx + 1][0] : tasks[idx + 1];
|
|
}
|
|
if (task.length) {
|
|
if (nextTask && task[0].realObject.mainSequence === nextTask.realObject.mainSequence
|
|
&& (ui.item.sortable.model.length ? ui.item.sortable.model[0].id : ui.item.sortable.model.id) !== nextTask.id) {
|
|
sameOrderFlag = true;
|
|
}
|
|
_.forEach(task, function (childTask, childIdx) {
|
|
if (ui.item.sortable.model.id === childTask.id && childTask.realObject.status.value !== 'Staged') {
|
|
childTask.realObject.status.value = 'Staged';
|
|
}
|
|
if (childTask.realObject.status.value === 'Staged') {
|
|
childTask.realObject.mainSequence = mainSequence;
|
|
if (activeTask && idx === ui.item.sortable.dropindex && (childIdx === 0
|
|
|| childTask.realObject.sequence === task[0].realObject.sequence)) {
|
|
childTask.realObject.mainSequence = activeTask.realObject.mainSequence;
|
|
//childTask.editable = false;
|
|
childTask.realObject.status.value = 'Pending';
|
|
}
|
|
childTask.realObject.childSequence = childTask.realObject.mainSequence + '.' + childTask.realObject.sequence;
|
|
}
|
|
});
|
|
mainSequence = sameOrderFlag ? task[0].realObject.mainSequence : (task[0].realObject.mainSequence + 1);
|
|
}
|
|
else {
|
|
if (nextTask && task.realObject.mainSequence === nextTask.realObject.mainSequence
|
|
&& (ui.item.sortable.model.length ? ui.item.sortable.model[0].id : ui.item.sortable.model.id) !== nextTask.id) {
|
|
sameOrderFlag = true;
|
|
}
|
|
if (ui.item.sortable.model.id === task.id && task.realObject.status.value !== 'Staged') {
|
|
task.realObject.status.value = 'Staged';
|
|
}
|
|
if (task.realObject.status.value === 'Staged') {
|
|
task.realObject.mainSequence = mainSequence;
|
|
if (activeTask && idx === ui.item.sortable.dropindex) {
|
|
task.realObject.mainSequence = activeTask.realObject.mainSequence;
|
|
//task.editable = false;
|
|
task.realObject.status.value = 'Pending';
|
|
}
|
|
}
|
|
mainSequence = sameOrderFlag ? task.realObject.mainSequence : (task.realObject.mainSequence + 1);
|
|
}
|
|
});
|
|
scope.relatedTasks = tasks;
|
|
scope.dirty = true;
|
|
}
|
|
};
|
|
scope.childSortableOptions = {
|
|
placeholder: 'profile-relation__item-task-child',
|
|
connectWith: '.profile-relation__task-group-container',
|
|
cancel: ":input,.locked",
|
|
update: function (event, ui) {
|
|
var closedItem = _.find(ui.item.sortable.sourceModel, function (task, idx) {
|
|
return ui.item.sortable.dropindex <= idx
|
|
&& ui.item.sortable.model.id !== task.id
|
|
&& (task.realObject.status.value === 'Closed'
|
|
|| task.realObject.status.value === 'Bypassed');
|
|
});
|
|
var invalidGroup = false;
|
|
if (ui.item.sortable.model.realObject.taskGroupId !== ui.item.sortable.droptargetModel[0].realObject.taskGroupId) {
|
|
invalidGroup = true;
|
|
}
|
|
if ((closedItem || invalidGroup) && !state.showing) {
|
|
state.showing = true;
|
|
$timeout(function () {
|
|
scope.draftNotificationInstance = systemAlertService.warning({
|
|
text: closedItem ? $filter('i18n')('ticket.relatedTasks.closed.label')
|
|
: $filter('i18n')('ticket.relatedTasks.groupChange.label'),
|
|
hide: 10000
|
|
});
|
|
scope.draftNotificationInstance.result
|
|
.finally(function () {
|
|
scope.draftNotificationInstance = null;
|
|
state.showing = false;
|
|
});
|
|
}, 500);
|
|
ui.item.sortable.cancel();
|
|
}
|
|
},
|
|
stop: function (event, ui) {
|
|
if (state.showing) {
|
|
return;
|
|
}
|
|
var tasks = _.cloneDeep(ui.item.sortable.sourceModel);
|
|
var activeTask = _.find(tasks, function (task, idx) {
|
|
return ui.item.sortable.dropindex < idx
|
|
&& ui.item.sortable.model.id !== task.id
|
|
&& task.realObject.status.value !== 'Staged';
|
|
});
|
|
var sourceIndex;
|
|
var sequence = 1;
|
|
_.forEach(tasks, function (task, idx) {
|
|
var sameOrderFlag = false;
|
|
var nextTask = null;
|
|
if ((idx + 1) !== tasks.length) {
|
|
nextTask = tasks[idx + 1];
|
|
}
|
|
if (nextTask && task.realObject.sequence === nextTask.realObject.sequence && ui.item.sortable.model.id !== nextTask.id) {
|
|
sameOrderFlag = true;
|
|
}
|
|
if (ui.item.sortable.model.id === task.id) {
|
|
sourceIndex = idx;
|
|
if (task.realObject.status.value !== 'Staged') {
|
|
task.realObject.status.value = 'Staged';
|
|
}
|
|
}
|
|
if (task.realObject.status.value === 'Staged') {
|
|
task.realObject.sequence = sequence;
|
|
if (activeTask && idx === ui.item.sortable.dropindex) {
|
|
task.realObject.sequence = activeTask.realObject.sequence;
|
|
//task.editable = false;
|
|
task.realObject.status.value = 'Pending';
|
|
}
|
|
task.realObject.childSequence = task.realObject.mainSequence + '.' + task.realObject.sequence;
|
|
}
|
|
sequence = sameOrderFlag ? task.realObject.sequence : (task.realObject.sequence + 1);
|
|
});
|
|
_.forEach(scope.relatedTasks, function (relatedTask, idx) {
|
|
if (relatedTask.length && relatedTask[sourceIndex] && relatedTask[sourceIndex].id === ui.item.sortable.model.id) {
|
|
scope.relatedTasks[idx] = tasks;
|
|
}
|
|
});
|
|
scope.dirty = true;
|
|
}
|
|
};
|
|
scope.updateTaskSequence = function (task) {
|
|
// Validate tasks
|
|
if (task.realObject.mainSequence <= 0 || isNaN(task.realObject.mainSequence) || _.isEmpty(task.realObject.mainSequence)) {
|
|
task.realObject.mainSequence = 1;
|
|
}
|
|
else {
|
|
task.realObject.mainSequence = parseInt(task.realObject.mainSequence);
|
|
}
|
|
if (task.realObject.status.value !== 'Staged') {
|
|
task.realObject.status.value = 'Staged';
|
|
}
|
|
var relatedTasks = angular.copy(scope.relatedTasks), allTasksClosed = true;
|
|
var closedTask = _.find(relatedTasks, function (relatedTask, count) {
|
|
if (relatedTask.length) {
|
|
var isClosed;
|
|
_.find(relatedTask, function (groupTask) {
|
|
if (task.realObject.mainSequence <= groupTask.realObject.mainSequence
|
|
&& (groupTask.realObject.status.value === 'Closed' || groupTask.realObject.status.value === 'Bypassed')) {
|
|
isClosed = true;
|
|
}
|
|
else {
|
|
isClosed = false;
|
|
}
|
|
});
|
|
return isClosed;
|
|
}
|
|
if (task.realObject.mainSequence <= relatedTask.realObject.mainSequence
|
|
&& (relatedTask.realObject.status.value === 'Closed' || relatedTask.realObject.status.value === 'Bypassed')) {
|
|
return true;
|
|
}
|
|
else {
|
|
allTasksClosed = false;
|
|
return false;
|
|
}
|
|
});
|
|
if (closedTask && allTasksClosed) {
|
|
task.realObject.mainSequence = closedTask.length ? closedTask[0].realObject.mainSequence + 1
|
|
: closedTask.realObject.mainSequence + 1;
|
|
}
|
|
var activeTask = _.find(relatedTasks, function (relatedTask) {
|
|
if (relatedTask.length) {
|
|
var isActive;
|
|
_.find(relatedTask, function (groupTask) {
|
|
if (task.realObject.mainSequence <= groupTask.realObject.mainSequence
|
|
&& groupTask.realObject.status.value !== 'Closed'
|
|
&& groupTask.realObject.status.value !== 'Bypassed'
|
|
&& groupTask.realObject.status.value !== 'Staged') {
|
|
isActive = true;
|
|
}
|
|
else {
|
|
isActive = false;
|
|
}
|
|
});
|
|
return isActive;
|
|
}
|
|
return task.realObject.mainSequence <= relatedTask.realObject.mainSequence
|
|
&& relatedTask.realObject.status.value !== 'Closed'
|
|
&& relatedTask.realObject.status.value !== 'Bypassed'
|
|
&& relatedTask.realObject.status.value !== 'Staged';
|
|
});
|
|
if (activeTask) {
|
|
//task.editable = false;
|
|
task.realObject.status.value = 'Pending';
|
|
task.realObject.mainSequence = activeTask.length ? activeTask[0].realObject.mainSequence
|
|
: activeTask.realObject.mainSequence;
|
|
}
|
|
var taskIndex = _.findIndex(relatedTasks, function (relatedTask) {
|
|
if (relatedTask.length) {
|
|
relatedTask = relatedTask[0];
|
|
}
|
|
return task.id === relatedTask.id;
|
|
});
|
|
relatedTasks[taskIndex] = task;
|
|
// Sort tasks
|
|
relatedTasks.sort(function (task1, task2) {
|
|
return (task1.length ? task1[0].realObject.mainSequence : task1.realObject.mainSequence)
|
|
- (task2.length ? task2[0].realObject.mainSequence : task2.realObject.mainSequence);
|
|
});
|
|
$timeout(function () {
|
|
scope.relatedTasks = relatedTasks;
|
|
}, 2000);
|
|
scope.dirty = true;
|
|
};
|
|
scope.updateParentSequence = function (tasks) {
|
|
// Validate tasks
|
|
if (tasks[0].realObject.mainSequence <= 0 || isNaN(tasks[0].realObject.mainSequence) || _.isEmpty(tasks[0].realObject.mainSequence)) {
|
|
tasks[0].realObject.mainSequence = 1;
|
|
}
|
|
else {
|
|
tasks[0].realObject.mainSequence = parseInt(tasks[0].realObject.mainSequence);
|
|
}
|
|
if (tasks[0].realObject.status.value !== 'Staged') {
|
|
tasks[0].realObject.status.value = 'Staged';
|
|
}
|
|
var relatedTasks = angular.copy(scope.relatedTasks);
|
|
var changeSeqNum = tasks[0].realObject.mainSequence;
|
|
var activeList = getActiveDetails(relatedTasks);
|
|
var setActiveMainSeq = false;
|
|
_.forEach(activeList, function (val) {
|
|
if (tasks[0].realObject.mainSequence <= val) {
|
|
changeSeqNum = val;
|
|
setActiveMainSeq = true;
|
|
return false;
|
|
}
|
|
});
|
|
//update all child task mainSequence
|
|
var i = 0;
|
|
while (i < tasks.length) {
|
|
tasks[i].realObject.mainSequence = changeSeqNum;
|
|
i++;
|
|
}
|
|
if (activeList && activeList.length && setActiveMainSeq) {
|
|
//tasks[0].editable = false;
|
|
tasks[0].realObject.status.value = 'Pending';
|
|
tasks[0].realObject.mainSequence = activeList[0];
|
|
}
|
|
// Update child tasks
|
|
var mainSequence = tasks[0].realObject.mainSequence;
|
|
var childSequence = mainSequence + '.' + tasks[0].realObject.sequence;
|
|
var status = tasks[0].realObject.status.value;
|
|
var editable = tasks[0].editable;
|
|
_.forEach(tasks, function (task) {
|
|
task.realObject.mainSequence = mainSequence;
|
|
task.realObject.childSequence = mainSequence + '.' + task.realObject.sequence;
|
|
if (childSequence === task.realObject.childSequence) {
|
|
task.realObject.status.value = status;
|
|
task.editable = editable;
|
|
}
|
|
});
|
|
var taskIndex = _.findIndex(relatedTasks, function (relatedTask) {
|
|
if (relatedTask.length) {
|
|
relatedTask = relatedTask[0];
|
|
}
|
|
return tasks[0].id === relatedTask.id;
|
|
});
|
|
relatedTasks[taskIndex] = tasks;
|
|
// Sort tasks
|
|
relatedTasks.sort(function (task1, task2) {
|
|
return (task1.length ? task1[0].realObject.mainSequence : task1.realObject.mainSequence)
|
|
- (task2.length ? task2[0].realObject.mainSequence : task2.realObject.mainSequence);
|
|
});
|
|
$timeout(function () {
|
|
scope.relatedTasks = relatedTasks;
|
|
}, 2000);
|
|
scope.dirty = true;
|
|
};
|
|
function revertTaskState(childTask, originalMainSeq) {
|
|
childTask.realObject.childSequence = originalMainSeq + '.' + childTask.realObject.sequence;
|
|
}
|
|
scope.updateChildSequence = function (tasks, childTask, taskGroupChildTaskID, originalMainSeq) {
|
|
var splitedTask = childTask.realObject.childSequence.split('.');
|
|
var mainSequencePart = splitedTask[0];
|
|
var sequencePart = splitedTask[1];
|
|
var dotCount = (childTask.realObject.childSequence.match(/\./g) || []).length;
|
|
// Validate tasks
|
|
if (!mainSequencePart || dotCount !== 1) {
|
|
//revert to original state
|
|
revertTaskState(childTask, originalMainSeq);
|
|
return;
|
|
}
|
|
if (sequencePart && dotCount === 1) {
|
|
childTask.realObject.mainSequence = originalMainSeq;
|
|
childTask.realObject.sequence = isNaN(sequencePart) || _.isEmpty(sequencePart) || sequencePart <= 0
|
|
? childTask.realObject.sequence : parseInt(sequencePart);
|
|
if (childTask.realObject.status.value !== 'Staged') {
|
|
childTask.realObject.status.value = 'Staged';
|
|
}
|
|
var closedTask = _.find(tasks, function (relatedTask) {
|
|
return childTask.realObject.sequence <= relatedTask.realObject.sequence
|
|
&& (relatedTask.realObject.status.value === 'Closed' || relatedTask.realObject.status.value === 'Bypassed');
|
|
});
|
|
if (closedTask) {
|
|
childTask.realObject.sequence = closedTask.realObject.sequence + 1;
|
|
}
|
|
var activeTask = _.find(tasks, function (relatedTask) {
|
|
return childTask.realObject.sequence <= relatedTask.realObject.sequence
|
|
&& relatedTask.realObject.status.value !== 'Closed'
|
|
&& relatedTask.realObject.status.value !== 'Bypassed'
|
|
&& relatedTask.realObject.status.value !== 'Staged';
|
|
});
|
|
if (activeTask) {
|
|
//childTask.editable = false;
|
|
childTask.realObject.status.value = 'Pending';
|
|
childTask.realObject.sequence = activeTask.realObject.sequence;
|
|
}
|
|
// Update child tasks
|
|
var mainSequence = childTask.realObject.mainSequence;
|
|
var childSequence = mainSequence + '.' + childTask.realObject.sequence;
|
|
var status = childTask.realObject.status.value;
|
|
_.forEach(tasks, function (task) {
|
|
task.realObject.mainSequence = mainSequence;
|
|
task.realObject.childSequence = mainSequence + '.' + task.realObject.sequence;
|
|
if (childSequence === task.realObject.childSequence) {
|
|
task.realObject.status.value = status;
|
|
}
|
|
});
|
|
// Sort tasks
|
|
var relatedTasks = angular.copy(scope.relatedTasks);
|
|
var taskIndex = _.findIndex(relatedTasks, function (relatedTask) {
|
|
if (relatedTask.length) {
|
|
relatedTask = relatedTask[0];
|
|
}
|
|
return tasks[0].id === relatedTask.id;
|
|
});
|
|
tasks = _.sortBy(angular.copy(tasks), 'realObject.sequence');
|
|
relatedTasks[taskIndex] = tasks;
|
|
relatedTasks.sort(function (task1, task2) {
|
|
return (task1.length ? task1[0].realObject.mainSequence : task1.realObject.mainSequence)
|
|
- (task2.length ? task2[0].realObject.mainSequence : task2.realObject.mainSequence);
|
|
});
|
|
$timeout(function () {
|
|
scope.relatedTasks = relatedTasks;
|
|
resetFocusToChildTask();
|
|
}, 2000);
|
|
scope.dirty = true;
|
|
function resetFocusToChildTask() {
|
|
$timeout(function () {
|
|
var elem = element.find('#' + taskGroupChildTaskID);
|
|
elem[0].focus();
|
|
});
|
|
}
|
|
}
|
|
else {
|
|
scope.dirty = false;
|
|
}
|
|
};
|
|
scope.setFocus = function (event) {
|
|
var focusTarget = event.target;
|
|
focusTarget.focus();
|
|
};
|
|
scope.onSaveClick = function () {
|
|
var tasks = [];
|
|
_.forEach(scope.relatedTasks, function (relatedTask) {
|
|
if (relatedTask.length) {
|
|
_.forEach(relatedTask, function (childTask) {
|
|
var originalTask = _.find(scope.originalTasks, function (relatedTaskCopy) {
|
|
return relatedTaskCopy.id === childTask.id;
|
|
});
|
|
if (originalTask.realObject.mainSequence !== childTask.realObject.mainSequence
|
|
|| originalTask.realObject.sequence !== childTask.realObject.sequence) {
|
|
var sequence = null;
|
|
if (childTask.realObject.taskGroupType === 'Sequencing'
|
|
&& originalTask.realObject.sequence !== childTask.realObject.sequence) {
|
|
sequence = childTask.realObject.sequence;
|
|
}
|
|
var task = {
|
|
parentId: childTask.parentId,
|
|
parentType: childTask.realObject.parentType,
|
|
parentName: childTask.realObject.parentName,
|
|
parentDisplayId: childTask.realObject.parentDisplayId,
|
|
company: childTask.realObject.company,
|
|
taskGroupId: childTask.realObject.taskGroupId,
|
|
mainSequence: childTask.realObject.mainSequence,
|
|
sequence: sequence,
|
|
id: childTask.id
|
|
};
|
|
tasks.push(task);
|
|
}
|
|
});
|
|
}
|
|
else {
|
|
var originalTask = _.find(scope.originalTasks, function (origTask) {
|
|
return origTask.id === relatedTask.id;
|
|
});
|
|
if (originalTask.realObject.mainSequence !== relatedTask.realObject.mainSequence) {
|
|
var task = {
|
|
parentId: relatedTask.parentId,
|
|
parentType: relatedTask.realObject.parentType,
|
|
parentName: relatedTask.realObject.parentName,
|
|
parentDisplayId: relatedTask.realObject.parentDisplayId,
|
|
company: relatedTask.realObject.company,
|
|
mainSequence: relatedTask.realObject.mainSequence,
|
|
sequence: relatedTask.realObject.mainSequence,
|
|
id: relatedTask.id
|
|
};
|
|
tasks.push(task);
|
|
}
|
|
}
|
|
});
|
|
if (tasks.length) {
|
|
state.processing = true;
|
|
relationModel.updateTaskSequence(tasks)
|
|
.then(function (results) {
|
|
var allCurrentRelatedTasks = angular.copy(_.flatten(scope.relatedTasks));
|
|
_.forEach(results, function (result) {
|
|
//find method returns referenced object
|
|
var task = _.find(allCurrentRelatedTasks, { 'id': result.responseObject.id });
|
|
if (result.statusInfo.type === 'Success' && result.responseObject.id === task.id) {
|
|
task.realObject.status.value = result.responseObject.status.value;
|
|
task.realObject.sequence = result.responseObject.sequence;
|
|
if (task.realObject.status.value !== 'Staged') {
|
|
task.editable = false;
|
|
}
|
|
}
|
|
});
|
|
scope.originalTasks = allCurrentRelatedTasks;
|
|
_.remove(relationModel.cache[ticket.id], { type: EntityVO.TYPE_TASK });
|
|
_.forEach(allCurrentRelatedTasks, function (item) {
|
|
relationModel.cache[ticket.id].push(new RelationItemVO().build(item));
|
|
});
|
|
}).catch(function (error) {
|
|
systemAlertService.error({
|
|
text: error.data.error,
|
|
clear: false
|
|
});
|
|
}).finally(function () {
|
|
state.processing = false;
|
|
scope.dirty = false;
|
|
});
|
|
}
|
|
};
|
|
scope.onRevertClick = function () {
|
|
scope.relatedTasks = angular.copy(originalTasks);
|
|
scope.dirty = false;
|
|
};
|
|
function initAlertForDirty() {
|
|
scope.$on('$stateChangeStart', function (event, toState, toParams) {
|
|
if (scope.dirty) {
|
|
event.preventDefault();
|
|
var modalInstance = systemAlertService.modal({
|
|
title: i18nService.getLocalizedString('common.notification.dirty.title'),
|
|
text: i18nService.getLocalizedString('common.notification.dirty.message'),
|
|
buttons: [
|
|
{
|
|
text: i18nService.getLocalizedString('common.notification.dirty.button1'),
|
|
data: {
|
|
stateName: toState.name,
|
|
stateParams: toParams
|
|
}
|
|
},
|
|
{
|
|
text: i18nService.getLocalizedString('common.notification.dirty.button2')
|
|
}
|
|
]
|
|
});
|
|
modalInstance.result.then(function (data) {
|
|
if (!_.isEmpty(data)) {
|
|
scope.dirty = false;
|
|
$state.transitionTo(data.stateName, data.stateParams);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
if (!ticket.isDraft) {
|
|
relationModel.getRelations(ticket.id, ticket.type).finally(function () {
|
|
state.loadingTaskResources = false;
|
|
});
|
|
}
|
|
scope.createBlankTask = function () {
|
|
if (scope.dirty) {
|
|
var modalInstance = systemAlertService.modal({
|
|
title: i18nService.getLocalizedString('common.notification.dirty.title'),
|
|
text: i18nService.getLocalizedString('common.notification.dirty.message'),
|
|
buttons: [
|
|
{
|
|
text: i18nService.getLocalizedString('common.notification.dirty.button1'),
|
|
data: true
|
|
},
|
|
{
|
|
text: i18nService.getLocalizedString('common.notification.dirty.button2'),
|
|
data: false
|
|
}
|
|
]
|
|
});
|
|
modalInstance.result.then(function (data) {
|
|
if (data) {
|
|
scope.dirty = false;
|
|
if (pwaModel.isPwaEnabled()) {
|
|
createBlankTaskPV();
|
|
}
|
|
else {
|
|
createBlankTask();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
else {
|
|
if (pwaModel.isPwaEnabled()) {
|
|
createBlankTaskPV();
|
|
}
|
|
else {
|
|
createBlankTask();
|
|
}
|
|
}
|
|
};
|
|
function createBlankTaskPV() {
|
|
pwaModel.taskFrom = 'Scratch';
|
|
ticketModel.taskParent = scope.ticket;
|
|
var modalInstance = $modal.open({
|
|
templateUrl: 'views/create/create-taskPV-v2.html',
|
|
controller: 'PwaTicketController',
|
|
windowClass: 'ticket__open-modal',
|
|
backdrop: false,
|
|
keyboard: false
|
|
});
|
|
modalInstance.result.then(function () {
|
|
refreshRelations();
|
|
element.find('button.profile-relation__add-relation-button').focus();
|
|
scope.$emit(events.TICKET_PROFILE_RESEND_EVENT, { eventName: events.REFRESH_ACTIVITY_FEED });
|
|
scope.$emit(events.RELATIONS_UPDATE_COMPLETE, true);
|
|
}, function () {
|
|
element.find('button.profile-relation__add-relation-button').focus();
|
|
});
|
|
var deregister = scope.$on(events.PWA_TASK_MODAL, function (event, data) {
|
|
if (data.taskCreated) {
|
|
modalInstance.close();
|
|
}
|
|
else {
|
|
modalInstance.dismiss();
|
|
}
|
|
deregister();
|
|
});
|
|
}
|
|
scope.getURLforTaskFlow = function () {
|
|
state.processing = true;
|
|
var urlId = ticket.id;
|
|
var jsonREST = {
|
|
"rootRequestId": ticket.displayId,
|
|
"taskParentType": ticket.type,
|
|
"summary": ticket.summary
|
|
};
|
|
ticketModel.getURLforTaskFlow(urlId, jsonREST).finally(function () {
|
|
state.processing = false;
|
|
});
|
|
};
|
|
function createBlankTask() {
|
|
ticketModel.taskParent = scope.ticket;
|
|
objectValueMapperService.shelveAsParent(scope.ticket.type);
|
|
var modalInstance = $modal.open({
|
|
templateUrl: 'views/create/create-task-v2.html',
|
|
controller: 'CreateTaskV2Controller',
|
|
windowClass: 'ticket__open-modal',
|
|
backdrop: false,
|
|
keyboard: false
|
|
});
|
|
modalInstance.result.then(function () {
|
|
objectValueMapperService.unshelveParent(scope.ticket.type); //parent ticket fields get cleared while creating task
|
|
refreshRelations();
|
|
element.find('button.profile-relation__add-relation-button').focus();
|
|
scope.$emit(events.TICKET_PROFILE_RESEND_EVENT, { eventName: events.REFRESH_ACTIVITY_FEED });
|
|
scope.$emit(events.RELATIONS_UPDATE_COMPLETE, true);
|
|
}, function () {
|
|
objectValueMapperService.unshelveParent(scope.ticket.type);
|
|
element.find('button.profile-relation__add-relation-button').focus();
|
|
});
|
|
}
|
|
scope.createTaskFromTemplate = function () {
|
|
if (scope.dirty) {
|
|
var modalInstance = systemAlertService.modal({
|
|
title: i18nService.getLocalizedString('common.notification.dirty.title'),
|
|
text: i18nService.getLocalizedString('common.notification.dirty.message'),
|
|
buttons: [
|
|
{
|
|
text: i18nService.getLocalizedString('common.notification.dirty.button1'),
|
|
data: true
|
|
},
|
|
{
|
|
text: i18nService.getLocalizedString('common.notification.dirty.button2'),
|
|
data: false
|
|
}
|
|
]
|
|
});
|
|
modalInstance.result.then(function (data) {
|
|
if (data) {
|
|
scope.dirty = false;
|
|
if (pwaModel.isPwaEnabled()) {
|
|
createTaskFromTemplatePV();
|
|
}
|
|
else {
|
|
createTaskFromTemplate();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
else {
|
|
if (pwaModel.isPwaEnabled()) {
|
|
createTaskFromTemplatePV();
|
|
}
|
|
else {
|
|
createTaskFromTemplate();
|
|
}
|
|
}
|
|
};
|
|
function createTaskFromTemplatePV() {
|
|
pwaModel.taskFrom = 'Template';
|
|
ticketModel.taskParent = scope.ticket;
|
|
var modalInstance = $modal.open({
|
|
templateUrl: 'views/create/create-taskPV-v2.html',
|
|
windowClass: 'action-blade',
|
|
controller: 'PwaTicketController',
|
|
backdrop: 'custom'
|
|
});
|
|
modalInstance.result.then(function () {
|
|
refreshRelations();
|
|
element.find('button.profile-relation__add-relation-button').focus();
|
|
scope.$emit(events.TICKET_PROFILE_RESEND_EVENT, { eventName: events.REFRESH_ACTIVITY_FEED });
|
|
}, function () {
|
|
element.find('button.profile-relation__add-relation-button').focus();
|
|
});
|
|
var deregister = scope.$on(events.PWA_TASK_MODAL, function (event, data) {
|
|
if (data.taskCreated) {
|
|
modalInstance.close();
|
|
}
|
|
else {
|
|
modalInstance.dismiss();
|
|
}
|
|
deregister();
|
|
});
|
|
}
|
|
function createTaskFromTemplate() {
|
|
ticketModel.taskParent = scope.ticket;
|
|
var modalInstance = $modal.open({
|
|
templateUrl: 'views/template/browse-task-template-action-blade.html',
|
|
windowClass: 'action-blade',
|
|
controller: 'BrowseTaskTemplateController',
|
|
backdrop: 'custom',
|
|
resolve: {
|
|
isFromBrowseTemplate: function () {
|
|
return false;
|
|
}
|
|
}
|
|
});
|
|
modalInstance.result.then(function () {
|
|
refreshRelations();
|
|
element.find('button.profile-relation__add-relation-button').focus();
|
|
scope.$emit(events.TICKET_PROFILE_RESEND_EVENT, { eventName: events.REFRESH_ACTIVITY_FEED });
|
|
}, function () {
|
|
element.find('button.profile-relation__add-relation-button').focus();
|
|
});
|
|
}
|
|
function refreshRelations() {
|
|
var draftRelationData;
|
|
if (scope.ticket.isDraft) {
|
|
draftRelationData = relationModel.cache[ticket.id];
|
|
}
|
|
state.processing = true;
|
|
relationModel.refreshRelations(ticket.id, ticket.type).finally(function () {
|
|
state.processing = false;
|
|
if (draftRelationData) {
|
|
_.forEach(draftRelationData, function (relationItem) {
|
|
var item = _.find(relationModel.cache[ticket.id], { id: relationItem.id });
|
|
if (!item) {
|
|
relationModel.cache[scope.ticket.id].push(relationItem);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
scope.state = state;
|
|
}
|
|
};
|
|
}]);
|
|
}());
|