959 lines
57 KiB
JavaScript
959 lines
57 KiB
JavaScript
"use strict";
|
|
(function () {
|
|
'use strict';
|
|
angular.module('changeModule')
|
|
.directive('changeTasks', ['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/change/change-tasks.html',
|
|
scope: {
|
|
ticket: '=',
|
|
relationCounters: '=',
|
|
tasksDisabled: '='
|
|
},
|
|
link: function (scope, element) {
|
|
scope.userModel = userModel;
|
|
var ticket = scope.ticket, originalTasks = [], state = {
|
|
loadingTaskResources: !ticket.isDraft,
|
|
itemsLimit: 4,
|
|
phaseItemsLimit: [],
|
|
processing: false,
|
|
showing: false
|
|
};
|
|
scope.showPhaseFilter = false;
|
|
scope.relations = relationModel.cache;
|
|
initAlertForDirty();
|
|
scope.$watch('relations', function () {
|
|
scope.relatedTasks = _.sortBy(_.filter(_.cloneDeep(scope.relations[ticket.id]), { type: EntityVO.TYPE_TASK }), function (rel) {
|
|
return rel.realObject.phaseGuid;
|
|
}) || [];
|
|
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 = 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.ticket.taskPhaseId) {
|
|
scope.relatedTasksCopy = _.cloneDeep(scope.relatedTasks);
|
|
runPhaseCheck();
|
|
}
|
|
if (scope.relationCounters) {
|
|
scope.relationCounters.tasks = scope.relatedTasks.length;
|
|
}
|
|
}, 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) {
|
|
var dragDropAllowed = true;
|
|
_.forEach(tasks, function (task) {
|
|
if (task.length) {
|
|
dragDropAllowed = isTaskStagedOrClosedCancelled(task);
|
|
}
|
|
else if (task.realObject.status.value !== 'Staged' && task.realObject.status.reason !== 'Cancelled' && task.realObject.status.value !== 'Pending') {
|
|
dragDropAllowed = false;
|
|
}
|
|
});
|
|
return dragDropAllowed;
|
|
}
|
|
scope.parentSortableOptions = {
|
|
placeholder: 'profile-relation__item-task-container',
|
|
connectWith: '.profile-relation__task-container',
|
|
cancel: ":input,.locked,.profile-relation__group-title",
|
|
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) {
|
|
closedItem = false;
|
|
}
|
|
if (activeTask.length === 0 && isTaskStagedOrClosedCancelled(ui.item.sortable.droptargetModel)) {
|
|
closedItem = false;
|
|
}
|
|
var phaseItem = null;
|
|
if (scope.ticket.taskPhaseId) {
|
|
var sourceGuid = ui.item.sortable.model.length ? ui.item.sortable.model[0].realObject.phaseGuid
|
|
: ui.item.sortable.model.realObject.phaseGuid;
|
|
phaseItem = _.find(ui.item.sortable.droptargetModel, function (task) {
|
|
if (task.length) {
|
|
task = task[0];
|
|
}
|
|
return sourceGuid !== task.realObject.phaseGuid;
|
|
});
|
|
}
|
|
if ((closedItem || phaseItem) && !state.showing) {
|
|
state.showing = true;
|
|
$timeout(function () {
|
|
scope.draftNotificationInstance = systemAlertService.warning({
|
|
text: closedItem ? $filter('i18n')('ticket.relatedTasks.closed.label')
|
|
: $filter('i18n')('ticket.relatedTasks.phaseChange.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) {
|
|
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);
|
|
}
|
|
});
|
|
if (scope.ticket.taskPhaseId) {
|
|
if (scope.currentTaskPhase.guid === 'All') {
|
|
_.forEach(scope.relatedTasks, function (relatedTask, idx) {
|
|
if (relatedTask.length) {
|
|
relatedTask = relatedTask[0];
|
|
}
|
|
_.forEach(tasks, function (phaseTask) {
|
|
if (relatedTask.id === (phaseTask.length ? phaseTask[0].id : phaseTask.id)) {
|
|
scope.relatedTasks[idx] = phaseTask;
|
|
}
|
|
});
|
|
});
|
|
}
|
|
else {
|
|
scope.relatedTasks = tasks;
|
|
}
|
|
populatePhaseTasks();
|
|
}
|
|
else {
|
|
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;
|
|
}
|
|
});
|
|
if (scope.ticket.taskPhaseId) {
|
|
populatePhaseTasks();
|
|
}
|
|
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);
|
|
var activeList = getActiveDetails(relatedTasks);
|
|
_.forEach(activeList, function (val) {
|
|
if (task.realObject.mainSequence < val) {
|
|
task.realObject.mainSequence = val;
|
|
return false;
|
|
}
|
|
});
|
|
var activeTask = _.find(relatedTasks, function (relatedTask) {
|
|
if (relatedTask.length) {
|
|
relatedTask = relatedTask[0];
|
|
}
|
|
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;
|
|
if (scope.ticket.taskPhaseId) {
|
|
populatePhaseTasks();
|
|
}
|
|
}, 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;
|
|
if (scope.ticket.taskPhaseId) {
|
|
populatePhaseTasks();
|
|
}
|
|
}, 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();
|
|
if (scope.ticket.taskPhaseId) {
|
|
populatePhaseTasks();
|
|
}
|
|
}, 2000);
|
|
scope.dirty = true;
|
|
function resetFocusToChildTask() {
|
|
$timeout(function () {
|
|
var elem = element.find('#' + taskGroupChildTaskID);
|
|
elem[0].focus();
|
|
});
|
|
}
|
|
}
|
|
else {
|
|
scope.dirty = false;
|
|
}
|
|
};
|
|
scope.setFocus = function (event) {
|
|
scope.focusTarget = event.target;
|
|
scope.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 = tasks;
|
|
if (scope.showPhaseFilter) {
|
|
populatePhaseTasks();
|
|
}
|
|
}).catch(function (error) {
|
|
systemAlertService.error({
|
|
text: error.data.error,
|
|
clear: false
|
|
});
|
|
}).finally(function () {
|
|
state.processing = false;
|
|
scope.dirty = false;
|
|
});
|
|
}
|
|
};
|
|
scope.onRevertClick = function () {
|
|
if (scope.ticket.taskPhaseId) {
|
|
scope.dirty = false;
|
|
scope.filterTasksByPhase(scope.currentTaskPhase);
|
|
if (scope.currentTaskPhase.guid !== 'All') {
|
|
scope.phaseTaskGroups = scope.relatedTasks;
|
|
}
|
|
}
|
|
else {
|
|
scope.dirty = false;
|
|
scope.relatedTasks = angular.copy(originalTasks);
|
|
}
|
|
};
|
|
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();
|
|
});
|
|
}
|
|
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);
|
|
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.getURLforTaskFlow = function () {
|
|
state.processing = true;
|
|
var urlId = ticket.id;
|
|
var jsonREST = {
|
|
"rootRequestId": ticket.displayId,
|
|
"taskParentType": ticket.type,
|
|
"summary": ticket.summary
|
|
};
|
|
if (scope.currentTaskPhase && scope.currentTaskPhase.guid && scope.currentTaskPhase.name && scope.currentTaskPhase.guid !== 'All') {
|
|
angular.extend(jsonREST, { "phaseName": scope.currentTaskPhase.name, "phaseGUID": scope.currentTaskPhase.guid });
|
|
}
|
|
ticketModel.getURLforTaskFlow(urlId, jsonREST).finally(function () {
|
|
state.processing = false;
|
|
});
|
|
};
|
|
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();
|
|
});
|
|
}
|
|
//Task phases
|
|
scope.filterTasksByPhase = function (phase) {
|
|
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: {
|
|
phase: phase
|
|
}
|
|
},
|
|
{
|
|
text: i18nService.getLocalizedString('common.notification.dirty.button2')
|
|
}
|
|
]
|
|
});
|
|
modalInstance.result.then(function (data) {
|
|
if (!_.isEmpty(data)) {
|
|
scope.dirty = false;
|
|
filterTasks(data.phase);
|
|
}
|
|
});
|
|
}
|
|
else {
|
|
filterTasks(phase);
|
|
}
|
|
};
|
|
scope.navigateToPerson = function (event, id) {
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
$state.go('person', { id: $filter('escape')(id) });
|
|
};
|
|
function filterTasks(phase) {
|
|
scope.currentTaskPhase = phase;
|
|
if (phase && phase.guid === 'All') {
|
|
scope.relatedTasks = _.cloneDeep(scope.relatedTasksCopy);
|
|
populatePhaseTasks();
|
|
return;
|
|
}
|
|
scope.relatedTasks = _.filter(_.cloneDeep(scope.relatedTasksCopy), function (task) {
|
|
return (task.realObject && task.realObject.phaseGuid === scope.currentTaskPhase.guid)
|
|
|| (task[0] && task[0].realObject.phaseGuid === scope.currentTaskPhase.guid);
|
|
});
|
|
}
|
|
function runPhaseCheck() {
|
|
//We should show phases filter only if it's enabled. Currently this is the only viable option to find it is checking scope.ticket.taskPhaseId
|
|
/*var taskWithPhaseId = _.find(scope.relatedTasks, function(task) {
|
|
return task.realObject.phaseGuid;
|
|
});*/
|
|
ticketModel.getTaskPhases(scope.ticket.company.name, true)
|
|
.then(function (response) {
|
|
try {
|
|
var allPhasesFilter = _.find(scope.allTaskPhases, { guid: 'All' });
|
|
if (!allPhasesFilter) {
|
|
response.unshift({
|
|
name: $filter('i18n')('resourceSlice.task.phaseFilter.allTaskPhases.label'),
|
|
guid: 'All'
|
|
});
|
|
}
|
|
}
|
|
catch (e) {
|
|
}
|
|
scope.showPhaseFilter = true;
|
|
//Defect SW00488529 fix
|
|
scope.allTaskPhases = _.uniqBy(response, 'guid');
|
|
scope.currentTaskPhase = _.find(scope.allTaskPhases, { guid: scope.ticket.taskPhaseId });
|
|
scope.ticket.taskPhaseName = scope.currentTaskPhase.name;
|
|
scope.filterTasksByPhase(scope.currentTaskPhase);
|
|
});
|
|
}
|
|
function populatePhaseTasks() {
|
|
scope.phaseTaskGroups = [];
|
|
_.forEach(scope.allTaskPhases, function (phase) {
|
|
var tasks = _.filter(scope.relatedTasks, function (task) {
|
|
return task.length ? task[0].realObject.phaseGuid === phase.guid
|
|
: task.realObject.phaseGuid === phase.guid;
|
|
});
|
|
if (tasks.length) {
|
|
tasks.sort(function (task1, task2) {
|
|
return (task1.length ? task1[0].realObject.mainSequence : task1.realObject.mainSequence)
|
|
- (task2.length ? task2[0].realObject.mainSequence : task2.realObject.mainSequence);
|
|
});
|
|
scope.phaseTaskGroups.push(tasks);
|
|
state.phaseItemsLimit.push(_.clone(state.itemsLimit));
|
|
}
|
|
});
|
|
}
|
|
function refreshRelations() {
|
|
state.processing = true;
|
|
relationModel.refreshRelations(ticket.id, ticket.type).finally(function () {
|
|
state.processing = false;
|
|
});
|
|
}
|
|
scope.state = state;
|
|
}
|
|
};
|
|
}]);
|
|
}());
|