source: trunk/grails-app/services/TaskService.groovy @ 816

Last change on this file since 816 was 816, checked in by gav, 8 years ago

Add check to prevent changing a tasks primaryAsset if maintenanceActions have been created.

File size: 41.9 KB
Line 
1import grails.util.Environment
2
3/**
4* Provides a service class for the Task domain class.
5*
6*/
7class TaskService {
8
9    boolean transactional = false
10
11    def authService
12    def dateUtilService
13    def authenticateService
14    def assignedGroupService
15    def assignedPersonService
16
17    /**
18    * Determines and returns a possible parent list for a task.
19    * @todo Create and use another method that limits the results to say the latest 20 or 100 tasks?
20    * @param taskInstance The task to use when determining the possible parent list.
21    * @returns A list of the possible parents.
22    */
23    def possibleParentList(taskInstance) {
24        def criteria = taskInstance.createCriteria()
25        def possibleParentList = criteria {
26            and {
27                notEqual('trash', true)
28                notEqual('id', taskInstance.id)
29                taskInstance.subTasks.each() { notEqual('id', it.id) }
30                }
31        }
32    }
33
34    /**
35    * Determines and returns a list of possible task types for scheduled tasks.
36    * @returns A list of the possible task types.
37    */
38    def getScheduledTaskTypes() {
39        def criteria = TaskType.createCriteria()
40        def scheduledTaskTypes = criteria {
41            and {
42                eq('isActive', true)
43                gt('id', 2L)
44                }
45        }
46    }
47
48    /**
49    * Determines and returns a list of parentPM tasks for an asset.
50    * @param asset The asset to get parentPM tasks for.
51    * @returns A list of the possible task types.
52    */
53    def getParentPMs(asset) {
54        def parentPMs = Task.withCriteria {
55                                                eq("primaryAsset", asset)
56                                                taskType {
57                                                    idEq(6L)
58                                                }
59                                                maxResults(1000)
60                                        }
61    }
62
63    /**
64    * Determines and returns a list of possible task priorites for Scheduled tasks.
65    * @returns A list of the possible task priorites.
66    */
67    def getScheduledTaskPriorities() {
68        def criteria = TaskPriority.createCriteria()
69        def scheduledTaskPriorities = [:]
70        scheduledTaskPriorities.list = criteria {
71            and {
72                eq('isActive', true)
73                gt('id', 1L)
74                }
75        }
76        scheduledTaskPriorities.default = scheduledTaskPriorities.list.find { it.id == 4L } //  1-Normal.
77        return scheduledTaskPriorities
78    }
79
80    /**
81    * Determines and returns a list of possible task priorites for Unscheduled tasks.
82    * @returns A map containing a list of the possible task priorites and the default priority.
83    */
84    def getUnscheduledTaskPriorities() {
85        def criteria = TaskPriority.createCriteria()
86        def unscheduledTaskPriorities = [:]
87        unscheduledTaskPriorities.list = criteria {
88            and {
89                eq('isActive', true)
90                lt('id', 5L)
91                ne('id', 1L)
92            }
93        }
94        unscheduledTaskPriorities.default = unscheduledTaskPriorities.list.find { it.id == 3L } // 2-High.
95        return unscheduledTaskPriorities
96    }
97
98    /**
99    * Creates a new task with the given params.
100    * @param params The params to use when creating the new task.
101    * @returns A map containing result.error (if any error) and result.taskInstance.
102    */
103    def save(params) {
104        Task.withTransaction { status ->
105            def result = [:]
106
107            def fail = { Map m ->
108                status.setRollbackOnly()
109                if(result.taskInstance && m.field)
110                    result.taskInstance.errors.rejectValue(m.field, m.code)
111                result.error = [ code: m.code, args: ["Task", params.id] ]
112                return result
113            }
114
115            def taskInstance = new Task(params)
116            result.taskInstance = taskInstance
117
118            // Set taskStatus if not supplied.
119            if(!params.taskStatus)
120                taskInstance.taskStatus = TaskStatus.read(1) // Not Started
121
122            // Set budgetStatus if not supplied.
123            if(!params.taskBudgetStatus) {
124                if(taskInstance.taskType?.id == 1 || taskInstance.taskType?.id == 2) // Immediate Callout or Unsheduled Breakin.
125                    taskInstance.taskBudgetStatus = TaskBudgetStatus.read(1) // Unplanned.
126                else
127                    taskInstance.taskBudgetStatus = TaskBudgetStatus.read(2) // Planned.
128            }
129
130            if(result.taskInstance.parentTask?.trash)
131                return fail(field:"parentTask", code:"task.operationNotPermittedOnTaskInTrash")
132
133            if(result.taskInstance.hasErrors() || !result.taskInstance.save())
134                return fail(code:"default.create.failure")
135
136            def taskModification = new TaskModification(person: authService.currentUser,
137                                                taskModificationType: TaskModificationType.get(1),
138                                                task: taskInstance)
139
140            if(taskModification.hasErrors() || !taskModification.save())
141                return fail(field:"taskModifications", code:"task.modifications.failedToSave")
142
143            //Add the assignedGroups, provided by a new ArrayList(task.assignedGroups)
144            if(params.assignedGroups) {
145                def assignedGroupsResult
146                def assignedGroupParams = [:]
147                params.assignedGroups.each() {
148
149                    assignedGroupParams = [personGroup: it.personGroup,
150                                                                task: taskInstance,
151                                                                estimatedHour: it.estimatedHour,
152                                                                estimatedMinute: it.estimatedMinute]
153
154                    assignedGroupsResult = assignedGroupService.save(assignedGroupParams)
155
156                    if(assignedGroupsResult.error)
157                        return fail(field:"assignedGroups", code:"task.assignedGroups.failedToSave")
158
159                }
160            }
161
162            //Add the assignedPersons, provided by a new ArrayList(task.assignedPersons)
163            if(params.assignedPersons) {
164                def assignedPersonsResult
165                def assignedPersonsParams = [:]
166                params.assignedPersons.each() {
167
168                    assignedPersonsParams = [person: it.person,
169                                                                task: taskInstance,
170                                                                estimatedHour: it.estimatedHour,
171                                                                estimatedMinute: it.estimatedMinute]
172
173                    assignedPersonsResult = assignedPersonService.save(assignedPersonsParams)
174
175                    if(assignedPersonsResult.error)
176                        return fail(field:"assignedPersons", code:"task.assignedPersons.failedToSave")
177
178                }
179            }
180
181            // Success.
182            return result
183
184        } //end withTransaction
185    } // end save()
186
187    /**
188    * Creates a subTask copying sane attributes from the parentTask unless otherwise specified in params.
189    * The targetStartDate and targetCompletionDate default to today since that is the sane thing to do.
190    * The taskProcedureRevision is only assigned to the sub task if supplied in params.
191    * The assignedPersons and assignedGroups are only added to the sub task if supplied in params.
192    * The positiveFault property is never set on the subTask.
193    * Collections in params must be supplied as new ArrayList's.
194    * This method is not intended to be a copyTask method.
195    * There should be no reason to copy tasks, recurrence can be used to create similar tasks.
196    * @param parentTask The parent task to get attributes from, also set as the parent.
197    * @param params Overrides the parent task values if specified.
198    * @returns A map containing result.error=true (if any error) and result.taskInstance.
199    */
200    def createSubTask(parentTask, params = [:]) {
201
202        def result = [:]
203
204        //Make our new Task a subTask and set the required properties.
205        def p = [:]
206        p.parentTask = parentTask
207        p.description = params.description ?: parentTask.description
208        p.comment = params.comment ?: parentTask.comment
209        p.targetStartDate = params.targetStartDate ?: dateUtilService.today
210        p.targetCompletionDate = params.targetCompletionDate ?: dateUtilService.today
211
212        p.safetyRequirement = params.safetyRequirement ?: parentTask.safetyRequirement
213        p.regulatoryRequirement = params.regulatoryRequirement ?: parentTask.regulatoryRequirement
214        p.mandatoryRequirement = params.mandatoryRequirement ?: parentTask.mandatoryRequirement
215
216        p.taskGroup = params.taskGroup ?: parentTask.taskGroup
217        p.taskStatus = TaskStatus.get(1) // A new subTask must always be "Not Started".
218        p.taskPriority = parentTask.taskPriority
219
220        p.taskType = params.taskType ?: parentTask.taskType
221         // Convert "Parent PM" tasks to "Preventative Maintenance" tasks.
222        if(p.taskType.id == 6)
223            p.taskType = TaskType.get(4)
224
225        p.leadPerson = params.leadPerson ?: parentTask.leadPerson
226        p.primaryAsset = params.primaryAsset ?: parentTask.primaryAsset
227        p.associatedAssets = params.associatedAssets ?: new ArrayList(parentTask.associatedAssets) // Collection.
228
229        // Supplied by recurring tasks.
230        if(params.taskProcedureRevision) p.taskProcedureRevision = params.taskProcedureRevision
231        if(params.assignedGroups) p.assignedGroups = params.assignedGroups // Collection.
232        if(params.assignedPersons) p.assignedPersons = params.assignedPersons // Collection.
233
234        // trash: A new subTask must always have trash=false, which is already the domain class default.
235
236        // These would be considered copying, hence not done.
237        // taskRecurringSchedule, entries, taskModifications, subTasks, inventoryMovements.
238
239        // Create the sub task and return the result.
240        result = save(p)
241
242        // Approve.
243        if(!result.error && parentTask.approved) {
244            p = [:]
245            p.id = result.taskInstance.id
246            approve(p)
247        }
248
249        // Success.
250        return result
251
252    } // end createSubTask()
253
254    /**
255    * In production tasks are NEVER deleted, only the trash flag is set!
256    * However during testing it may be required to delete a task and that
257    * is why this method exists.
258    */
259    def delete(params) {
260        Task.withTransaction { status ->
261            def result = [:]
262
263            def fail = { Map m ->
264                status.setRollbackOnly()
265                if(result.taskInstance && m.field)
266                    result.taskInstance.errors.rejectValue(m.field, m.code)
267                result.error = [ code: m.code, args: ["Task", params.id] ]
268                return result
269            }
270
271            if(Environment.current == Environment.PRODUCTION)
272                return fail(code:"task.delete.failure.production")
273
274            result.taskInstance = Task.get(params.id)
275
276            if(!result.taskInstance)
277                return fail(code:"default.not.found")
278
279            // Handle taskModifications.
280            def taskModifications = TaskModification.findAllByTask(result.taskInstance)
281            taskModifications.each() {
282                result.taskInstance.removeFromTaskModifications(it)
283                it.delete()
284            }
285
286            // Handle assignedPersons.
287            def taskAssignedPersons = AssignedPerson.findAllByTask(result.taskInstance)
288            taskAssignedPersons.each() {
289                result.taskInstance.removeFromAssignedPersons(it)
290                it.delete()
291            }
292
293            // Handle assignedGroups.
294            def taskAssignedGroups = AssignedGroup.findAllByTask(result.taskInstance)
295            taskAssignedGroups.each() {
296                result.taskInstance.removeFromAssignedGroups(it)
297                it.delete()
298            }
299
300            if(result.error)
301                return result
302
303            try {
304                result.taskInstance.delete(flush:true)
305                return result //Success.
306            }
307            catch(org.springframework.dao.DataIntegrityViolationException e) {
308                return fail(code:"default.delete.failure")
309            }
310
311        } // end withTransaction
312    } // delete()
313
314    /**
315    * Creates a new task entry.
316    * @param params The params to use when creating the new entry.
317    * @returns A map containing result.error=true (if any error), result.entryInstance and result.taskId.
318    */
319    def saveEntry(params) {
320        Task.withTransaction { status ->
321            def result = [:]
322
323            def fail = { Map m ->
324                status.setRollbackOnly()
325                if(result.taskInstance && m.field)
326                    result.taskInstance.errors.rejectValue(m.field, m.code)
327                result.error = [ code: m.code, args: ["Entry", params.id] ]
328                return result
329            }
330
331            result.entryInstance = new Entry(params)
332            result.entryInstance.enteredBy = authService.currentUser
333
334            def taskInstance
335            if(result.entryInstance.task?.id) {
336                result.taskId = result.entryInstance.task.id
337                taskInstance = Task.lock(result.entryInstance.task.id)
338            }
339
340            if(!taskInstance)
341                return fail(field:"task", code:"task.notFound")
342
343            if(result.entryInstance.hasErrors() || !result.entryInstance.save())
344                return fail(code:"default.create.failure")
345
346            if(taskInstance.taskStatus.id == 3)
347                return fail(field:"task", code:"task.operationNotPermittedOnCompleteTask")
348
349            // Check for authorisation on recurring tasks.
350            if(taskInstance.taskRecurringSchedule) {
351                if(!authenticateService.ifAnyGranted('ROLE_AppAdmin,ROLE_Manager,ROLE_TaskManager'))
352                    return fail(field:"task", code:"task.operationNotPermittedOnRecurringTaskWithoutAuth")
353            }
354
355            // If task status is "Not Started" and entry type is "Work Done" and time has been booked.
356            // Then we create the started modification and set task status.
357            if(taskInstance.taskStatus.id == 1 && result.entryInstance.entryType.id == 3
358                && (result.entryInstance.durationHour + result.entryInstance.durationMinute > 0)) {
359
360                // Create the "Started" task modification, this provides the "Actual Started Date".
361                def taskModification = new TaskModification(person: authService.currentUser,
362                                                        taskModificationType: TaskModificationType.read(2),
363                                                        task: taskInstance)
364
365                if(taskModification.hasErrors() || !taskModification.save())
366                    return fail(field:"task", code:"task.modifications.failedToSave")
367
368                // Set task status to "In Progress".
369                taskInstance.taskStatus = TaskStatus.read(2)
370
371                if(taskInstance.hasErrors() || !taskInstance.save())
372                    return fail(field:"task", code:"task.failedToSave")
373            }
374
375            // Success.
376            return result
377
378        } // end withTransaction
379    } // end saveEntry()
380
381    /**
382    * Updates an existing task.
383    * @param params The params to update for task with id of params.id.
384    * @returns A map containing result.error (if any error) and result.taskInstance (if available).
385    */
386    def update(params) {
387        Task.withTransaction { status ->
388            def result = [:]
389
390            def fail = { Map m ->
391                status.setRollbackOnly()
392                if(result.taskInstance && m.field)
393                    result.taskInstance.errors.rejectValue(m.field, m.code)
394                result.error = [ code: m.code, args: ["Task", params.id] ]
395                return result
396            }
397
398            result.taskInstance = Task.get(params.id)
399
400            if(!result.taskInstance)
401                return fail('id', "task.notFound")
402
403            // Optimistic locking check.
404            if(params.version) {
405                if(result.taskInstance.version > params.version.toLong())
406                    return fail(field:"version", code:"default.optimistic.locking.failure")
407            }
408
409            // Check for authorisation on recurring tasks.
410            if(result.taskInstance.taskRecurringSchedule) {
411                if(!authenticateService.ifAnyGranted('ROLE_AppAdmin,ROLE_Manager,ROLE_TaskManager'))
412                    return fail(field:"taskRecurringSchedule", code:"task.operationNotPermittedOnRecurringTaskWithoutAuth")
413            }
414
415            result.taskInstance.properties = params
416
417            if(result.taskInstance.taskProcedureRevision?.maintenanceActions && result.taskInstance.isDirty('primaryAsset'))
418                return fail(field:'primaryAsset', code:"tast.operationNotPermittedToChangeAssetWithMaintenanceActions")
419
420            if(result.taskInstance.hasErrors() || !result.taskInstance.save())
421                return fail(code:"default.update.failure")
422
423            def taskModification = new TaskModification(person:authService.currentUser,
424                                                    taskModificationType: TaskModificationType.get(3),
425                                                    task: result.taskInstance)
426
427            if(taskModification.hasErrors() || !taskModification.save())
428                return fail(code:"task.modifications.failedToSave")
429
430            // Success.
431            return result
432
433        } //end withTransaction
434    }  // end update()
435
436    /**
437    * Completes an existing task.
438    * @param params The params for task with id of params.id.
439    * @returns A map containing result.error (if any error) and result.taskInstance (if available).
440    */
441    def complete(params) {
442        Task.withTransaction { status ->
443            def result = [:]
444
445            def fail = { Map m ->
446                status.setRollbackOnly()
447                if(result.taskInstance && m.field)
448                    result.taskInstance.errors.rejectValue(m.field, m.code)
449                result.error = [ code: m.code, args: ["Task", params.id] ]
450                return result
451            }
452
453            result.taskInstance = Task.get(params.id)
454
455            if(!result.taskInstance)
456                return fail(code:"default.not.found")
457
458            // Optimistic locking check.
459            if(params.version) {
460                if(result.taskInstance.version > params.version.toLong())
461                    return fail(field:"version", code:"default.optimistic.locking.failure")
462            }
463
464            // Check for authorisation on recurring tasks.
465            if(result.taskInstance.taskRecurringSchedule) {
466                if(!authenticateService.ifAnyGranted('ROLE_AppAdmin,ROLE_Manager,ROLE_TaskManager'))
467                    return fail(field:"taskRecurringSchedule", code:"task.operationNotPermittedOnRecurringTaskWithoutAuth")
468            }
469
470            result.taskInstance.taskStatus = TaskStatus.get(3)
471            result.taskInstance.attentionFlag = false
472            result.taskInstance.taskRecurringSchedule?.enabled = false
473
474            if(result.taskInstance.hasErrors() || !result.taskInstance.save())
475                return fail(code:"default.update.failure")
476
477            def taskModification = new TaskModification(person:authService.currentUser,
478                                                    taskModificationType: TaskModificationType.get(4),
479                                                    task: result.taskInstance)
480
481
482            if(taskModification.hasErrors() || !taskModification.save())
483                return fail(code:"task.modifications.failedToSave")
484
485            // Success.
486            return result
487
488        } //end withTransaction
489    }  // end complete()
490
491    /**
492    * Sets the attentionFlag on an existing task.
493    * @param params The params for task with id of params.id.
494    * @returns A map containing result.error (if any error) and result.taskInstance (if available).
495    */
496    def setAttentionFlag(params) {
497        Task.withTransaction { status ->
498            def result = [:]
499
500            def fail = { Map m ->
501                status.setRollbackOnly()
502                if(result.taskInstance && m.field)
503                    result.taskInstance.errors.rejectValue(m.field, m.code)
504                result.error = [ code: m.code, args: ["Task", params.id] ]
505                return result
506            }
507
508            result.taskInstance = Task.get(params.id)
509
510            if(!result.taskInstance)
511                return fail(code:"default.not.found")
512
513            // Optimistic locking check.
514            if(params.version) {
515                if(result.taskInstance.version > params.version.toLong())
516                    return fail(field:"version", code:"default.optimistic.locking.failure")
517            }
518
519            // Check for authorisation on recurring tasks.
520            if(result.taskInstance.taskRecurringSchedule) {
521                if(!authenticateService.ifAnyGranted('ROLE_AppAdmin,ROLE_Manager,ROLE_TaskManager'))
522                    return fail(field:"taskRecurringSchedule", code:"task.operationNotPermittedOnRecurringTaskWithoutAuth")
523            }
524
525            result.taskInstance.attentionFlag = true
526
527            if(result.taskInstance.hasErrors() || !result.taskInstance.save())
528                return fail(code:"default.update.failure")
529
530            def taskModification = new TaskModification(person:authService.currentUser,
531                                                    taskModificationType: TaskModificationType.get(12),
532                                                    task: result.taskInstance)
533
534            if(taskModification.hasErrors() || !taskModification.save())
535                return fail(code:"task.modifications.failedToSave")
536
537            // Success.
538            return result
539
540        } //end withTransaction
541    }  // end flag()
542
543    /**
544    * Clears the attentionFlag on an existing task.
545    * @param params The params for task with id of params.id.
546    * @returns A map containing result.error (if any error) and result.taskInstance (if available).
547    */
548    def clearAttentionFlag(params) {
549        Task.withTransaction { status ->
550            def result = [:]
551
552            def fail = { Map m ->
553                status.setRollbackOnly()
554                if(result.taskInstance && m.field)
555                    result.taskInstance.errors.rejectValue(m.field, m.code)
556                result.error = [ code: m.code, args: ["Task", params.id] ]
557                return result
558            }
559
560            result.taskInstance = Task.get(params.id)
561
562            if(!result.taskInstance)
563                return fail(code:"default.not.found")
564
565            // Optimistic locking check.
566            if(params.version) {
567                if(result.taskInstance.version > params.version.toLong())
568                    return fail(field:"version", code:"default.optimistic.locking.failure")
569            }
570
571            // Check for authorisation on recurring tasks.
572            if(result.taskInstance.taskRecurringSchedule) {
573                if(!authenticateService.ifAnyGranted('ROLE_AppAdmin,ROLE_Manager,ROLE_TaskManager'))
574                    return fail(field:"taskRecurringSchedule", code:"task.operationNotPermittedOnRecurringTaskWithoutAuth")
575            }
576
577            result.taskInstance.attentionFlag = false
578
579            if(result.taskInstance.hasErrors() || !result.taskInstance.save())
580                return fail(code:"default.update.failure")
581
582            def taskModification = new TaskModification(person:authService.currentUser,
583                                                    taskModificationType: TaskModificationType.get(13),
584                                                    task: result.taskInstance)
585
586            if(taskModification.hasErrors() || !taskModification.save())
587                return fail(code:"task.modifications.failedToSave")
588
589            // Success.
590            return result
591
592        } //end withTransaction
593    }  // end clearFlag()
594
595    /**
596    * Reopens an existing task.
597    * @param params The params for task with id of params.id.
598    * @returns A map containing result.error (if any error) and result.taskInstance (if available).
599    */
600    def reopen(params) {
601        Task.withTransaction { status ->
602            def result = [:]
603
604            def fail = { Map m ->
605                status.setRollbackOnly()
606                if(result.taskInstance && m.field)
607                    result.taskInstance.errors.rejectValue(m.field, m.code)
608                result.error = [ code: m.code, args: ["Task", params.id] ]
609                return result
610            }
611
612            result.taskInstance = Task.get(params.id)
613
614            if(!result.taskInstance)
615                return fail(code:"default.not.found")
616
617            // Optimistic locking check.
618            if(params.version) {
619                if(result.taskInstance.version > params.version.toLong())
620                    return fail(field:"version", code:"default.optimistic.locking.failure")
621            }
622
623            // Check for authorisation on recurring tasks.
624            if(result.taskInstance.taskRecurringSchedule) {
625                if(!authenticateService.ifAnyGranted('ROLE_AppAdmin,ROLE_Manager,ROLE_TaskManager'))
626                    return fail(field:"taskRecurringSchedule", code:"task.operationNotPermittedOnRecurringTaskWithoutAuth")
627            }
628
629            def isInProgress = false
630            result.taskInstance.entries.each() {
631                if(it.entryType.id == 3 && (it.durationHour + it.durationMinute > 0) )
632                    isInProgress = true
633            }
634
635            if(isInProgress)
636                result.taskInstance.taskStatus = TaskStatus.read(2) // In Progress
637            else
638                result.taskInstance.taskStatus = TaskStatus.read(1) // Not Started
639
640            if(result.taskInstance.hasErrors() || !result.taskInstance.save())
641                return fail(code:"default.update.failure")
642
643            def taskModification = new TaskModification(person:authService.currentUser,
644                                                    taskModificationType: TaskModificationType.get(5),
645                                                    task: result.taskInstance)
646
647            if(taskModification.hasErrors() || !taskModification.save())
648                return fail(code:"task.modifications.failedToSave")
649
650            // Success.
651            return result
652
653        } //end withTransaction
654    }  // end reopen()
655
656    /**
657    * Move a task to the trash.
658    * @param params The params for task with id of params.id.
659    * @returns A map containing result.error (if any error) and result.taskInstance (if available).
660    */
661    def trash(params) {
662        Task.withTransaction { status ->
663            def result = [:]
664
665            def fail = { Map m ->
666                status.setRollbackOnly()
667                if(result.taskInstance && m.field)
668                    result.taskInstance.errors.rejectValue(m.field, m.code)
669                result.error = [ code: m.code, args: ["Task", params.id] ]
670                return result
671            }
672
673            result.taskInstance = Task.get(params.id)
674
675            if(!result.taskInstance)
676                return fail(code:"default.not.found")
677
678            // Optimistic locking check.
679            if(params.version) {
680                if(result.taskInstance.version > params.version.toLong())
681                    return fail(field:"version", code:"default.optimistic.locking.failure")
682            }
683
684            // Check for authorisation on recurring tasks.
685            if(result.taskInstance.taskRecurringSchedule) {
686                if(!authenticateService.ifAnyGranted('ROLE_AppAdmin,ROLE_Manager,ROLE_TaskManager'))
687                    return fail(field:"taskRecurringSchedule", code:"task.operationNotPermittedOnRecurringTaskWithoutAuth")
688            }
689
690            // Check for authorisation on tasks having subTasks.
691            if(result.taskInstance.subTasks) {
692                if(!authenticateService.ifAnyGranted('ROLE_AppAdmin,ROLE_Manager,ROLE_TaskManager'))
693                    return fail(field:"subTasks", code:"task.operationNotPermittedOnTaskHavingSubTasksWithoutAuth")
694            }
695
696            // Check for taskProcedureRevision using this task as linkedTask.
697            if(result.taskInstance.taskProcedureRevision?.linkedTask?.id == result.taskInstance.id) {
698                if(!authenticateService.ifAnyGranted('ROLE_AppAdmin,ROLE_Manager,ROLE_TaskManager'))
699                    return fail(field:"taskProcedureRevision", code:"task.operationNotPermittedOnTaskLinkedToProcedureWithoutAuth")
700            }
701
702            // Check for Parent PM task type.
703            if(result.taskInstance.taskType.id == 6)
704                return fail(field:"taskType", code:"task.operationNotPermittedOnParentPmTask")
705
706            result.taskInstance.trash = true
707            result.taskInstance.attentionFlag = false
708            result.taskInstance.taskRecurringSchedule?.enabled = false
709            result.taskInstance.subTasks.each {
710                it.parentTask = null
711            }
712
713            if(result.taskInstance.hasErrors() || !result.taskInstance.save())
714                return fail(code:"default.update.failure")
715
716            def taskModification = new TaskModification(person:authService.currentUser,
717                                                    taskModificationType: TaskModificationType.get(6),
718                                                    task: result.taskInstance)
719
720            if(taskModification.hasErrors() || !taskModification.save())
721                return fail(code:"task.modifications.failedToSave")
722
723            // Success.
724            return result
725
726        } //end withTransaction
727    }  // end trash()
728
729    /**
730    * Restore a task from the trash.
731    * @param params The params for task with id of params.id.
732    * @returns A map containing result.error (if any error) and result.taskInstance (if available).
733    */
734    def restore(params) {
735        Task.withTransaction { status ->
736            def result = [:]
737
738            def fail = { Map m ->
739                status.setRollbackOnly()
740                if(result.taskInstance && m.field)
741                    result.taskInstance.errors.rejectValue(m.field, m.code)
742                result.error = [ code: m.code, args: ["Task", params.id] ]
743                return result
744            }
745
746            result.taskInstance = Task.get(params.id)
747
748            if(!result.taskInstance)
749                return fail(code:"default.not.found")
750
751            // Optimistic locking check.
752            if(params.version) {
753                if(result.taskInstance.version > params.version.toLong())
754                    return fail(field:"version", code:"default.optimistic.locking.failure")
755            }
756
757            // Check for authorisation on recurring tasks.
758            if(result.taskInstance.taskRecurringSchedule) {
759                if(!authenticateService.ifAnyGranted('ROLE_AppAdmin,ROLE_Manager,ROLE_TaskManager'))
760                    return fail(field:"taskRecurringSchedule", code:"task.operationNotPermittedOnRecurringTaskWithoutAuth")
761            }
762
763            result.taskInstance.trash = false
764
765            if(result.taskInstance.hasErrors() || !result.taskInstance.save())
766                return fail(code:"default.update.failure")
767
768            def taskModification = new TaskModification(person:authService.currentUser,
769                                                    taskModificationType: TaskModificationType.get(7),
770                                                    task: result.taskInstance)
771
772            if(taskModification.hasErrors() || !taskModification.save())
773                return fail(code:"task.modifications.failedToSave")
774
775            // Success.
776            return result
777
778        } //end withTransaction
779    }  // end restore()
780
781    /**
782    * Approve a task.
783    * @param params The params for task with id of params.id.
784    * @returns A map containing result.error (if any error) and result.taskInstance (if available).
785    */
786    def approve(params) {
787        Task.withTransaction { status ->
788            def result = [:]
789
790            def fail = { Map m ->
791                status.setRollbackOnly()
792                if(result.taskInstance && m.field)
793                    result.taskInstance.errors.rejectValue(m.field, m.code)
794                result.error = [ code: m.code, args: ["Task", params.id] ]
795                return result
796            }
797
798            result.taskInstance = Task.get(params.id)
799
800            if(!result.taskInstance)
801                return fail(code:"default.not.found")
802
803            // Optimistic locking check.
804            if(params.version) {
805                if(result.taskInstance.version > params.version.toLong())
806                    return fail(field:"version", code:"default.optimistic.locking.failure")
807            }
808
809            // Check for authorisation on recurring tasks.
810            if(result.taskInstance.taskRecurringSchedule) {
811                if(!authenticateService.ifAnyGranted('ROLE_AppAdmin,ROLE_Manager,ROLE_TaskManager'))
812                    return fail(field:"taskRecurringSchedule", code:"task.operationNotPermittedOnRecurringTaskWithoutAuth")
813            }
814
815            result.taskInstance.approved = true
816
817            if(result.taskInstance.hasErrors() || !result.taskInstance.save())
818                return fail(code:"default.update.failure")
819
820            def taskModification = new TaskModification(person:authService.currentUser,
821                                                    taskModificationType: TaskModificationType.get(8),
822                                                    task: result.taskInstance)
823
824            if(taskModification.hasErrors() || !taskModification.save())
825                return fail(code:"task.modifications.failedToSave")
826
827            // Success.
828            return result
829
830        } //end withTransaction
831    }  // end approve()
832
833    /**
834    * Remove a previously given approval from a task.
835    * @param params The params for task with id of params.id.
836    * @returns A map containing result.error (if any error) and result.taskInstance (if available).
837    */
838    def renegeApproval(params) {
839        Task.withTransaction { status ->
840            def result = [:]
841
842            def fail = { Map m ->
843                status.setRollbackOnly()
844                if(result.taskInstance && m.field)
845                    result.taskInstance.errors.rejectValue(m.field, m.code)
846                result.error = [ code: m.code, args: ["Task", params.id] ]
847                return result
848            }
849
850            result.taskInstance = Task.get(params.id)
851
852            if(!result.taskInstance)
853                return fail(code:"default.not.found")
854
855            // Optimistic locking check.
856            if(params.version) {
857                if(result.taskInstance.version > params.version.toLong())
858                    return fail(field:"version", code:"default.optimistic.locking.failure")
859            }
860
861            // Check for authorisation on recurring tasks.
862            if(result.taskInstance.taskRecurringSchedule) {
863                if(!authenticateService.ifAnyGranted('ROLE_AppAdmin,ROLE_Manager,ROLE_TaskManager'))
864                    return fail(field:"taskRecurringSchedule", code:"task.operationNotPermittedOnRecurringTaskWithoutAuth")
865            }
866
867            result.taskInstance.approved = false
868
869            if(result.taskInstance.hasErrors() || !result.taskInstance.save())
870                return fail(code:"default.update.failure")
871
872            def taskModification = new TaskModification(person:authService.currentUser,
873                                                    taskModificationType: TaskModificationType.get(9),
874                                                    task: result.taskInstance)
875
876            if(taskModification.hasErrors() || !taskModification.save())
877                return fail(code:"task.modifications.failedToSave")
878
879            // Success.
880            return result
881
882        } //end withTransaction
883    }  // end renegeApproval()
884
885    /**
886    * Creates a new unscheduled breakin task with the given params.
887    * @param params The params to use when creating the new task.
888    * @returns A map containing result.error (if any error) and result.taskInstance.
889    */
890    def saveUnscheduled(params) {
891        Task.withTransaction { status ->
892            def result = [:]
893
894            def fail = { Map m ->
895                status.setRollbackOnly()
896                if(result.taskInstance && m.field)
897                    result.taskInstance.errors.rejectValue(m.field, m.code)
898                result.error = [ code: m.code, args: ["Task", params.id] ]
899                return result
900            }
901
902            // If not supplied.
903            if(!params.taskStatus)
904                params.taskStatus = TaskStatus.get(1) // Not Started.
905
906            result.taskInstance = new Task(params)
907
908            // Always for an unscheduled breakin..
909            result.taskInstance.taskType = TaskType.get(2) // Unscheduled Breakin.
910            result.taskInstance.taskBudgetStatus = TaskBudgetStatus.get(1) // Unplanned.
911
912            if(result.taskInstance.hasErrors() || !result.taskInstance.save())
913                fail(code:"default.create.failure")
914
915            if(!result.error) {
916                def taskModification = new TaskModification(person: authService.currentUser,
917                                                                taskModificationType: TaskModificationType.get(1), // Created.
918                                                                task: result.taskInstance)
919
920                if(taskModification.hasErrors() || !taskModification.save())
921                    fail(field:"taskModifications", code:"task.modifications.failedToSave")
922            }
923
924            // Success.
925            return result
926
927        } //end withTransaction
928    } // end saveUnscheduled()
929
930    /**
931    * Creates a new immediate callout task with the given params.
932    * @param params The params to use when creating the new task.
933    * @returns A map containing result.error (if any error) and result.taskInstance.
934    */
935    def saveImmediateCallout(params) {
936        Task.withTransaction { status ->
937            def result = [:]
938
939            def fail = { Map m ->
940                status.setRollbackOnly()
941                if(result.taskInstance && m.field)
942                    result.taskInstance.errors.rejectValue(m.field, m.code)
943                result.error = [ code: m.code, args: ["Task", params.id] ]
944                return result
945            }
946
947            // If not supplied.
948            if(!params.taskStatus)
949                params.taskStatus = TaskStatus.get(1) // Not Started.
950
951            result.taskInstance = new Task(params)
952
953            // Always for an immediate callout.
954            result.taskInstance.taskType = TaskType.get(1) // Immediate Callout.
955            result.taskInstance.taskBudgetStatus = TaskBudgetStatus.get(1) // Unplanned.
956            result.taskInstance.taskPriority = TaskPriority.get(1) // Immediate.
957            result.taskInstance.taskGroup = TaskGroup.get(1) // Engineering Activites.
958            result.taskInstance.approved = true
959            result.taskInstance.leadPerson = authService.currentUser
960            result.taskInstance.targetCompletionDate = result.taskInstance.targetStartDate
961
962            if(result.taskInstance.hasErrors() || !result.taskInstance.save())
963                fail(code:"default.create.failure")
964
965            if(!result.error) {
966                def taskModification = new TaskModification(person: authService.currentUser,
967                                                                taskModificationType: TaskModificationType.get(1), // Created.
968                                                                task: result.taskInstance)
969
970                if(taskModification.hasErrors() || !taskModification.save())
971                    fail(field:"taskModifications", code:"task.modifications.failedToSave")
972            }
973
974            def productionReference
975            if(params.entryFault.productionReference.id.isLong())
976                productionReference = ProductionReference.get(params.entryFault.productionReference.id.toLong())
977
978            def faultParams = [task: result.taskInstance,
979                                            entryType: EntryType.get(1),
980                                            comment: params.entryFault.comment,
981                                            dateDone: result.taskInstance.targetStartDate,
982                                            productionReference: productionReference,
983                                            durationHour: params.entryFault.durationHour,
984                                            durationMinute: params.entryFault.durationMinute]
985            def faultResult = saveEntry(faultParams)
986            result.entryFaultInstance = faultResult.entryInstance
987
988            def causeParams = [task: result.taskInstance,
989                                            entryType: EntryType.get(2),
990                                            dateDone: result.taskInstance.targetStartDate,
991                                            comment: params.entryCause.comment]
992            def causeResult = saveEntry(causeParams)
993            result.entryCauseInstance = causeResult.entryInstance
994
995            def workDoneParams = [task: result.taskInstance,
996                                                    entryType: EntryType.get(3),
997                                                    comment: params.entryWorkDone.comment,
998                                            dateDone: result.taskInstance.targetStartDate,
999                                                    durationHour: params.entryWorkDone.durationHour,
1000                                                    durationMinute: params.entryWorkDone.durationMinute]
1001            def workDoneResult = saveEntry(workDoneParams)
1002            result.entryWorkDoneInstance = workDoneResult.entryInstance
1003
1004            if(result.error)
1005                return result
1006
1007            if(causeResult.error)
1008                return fail(code: "default.create.failure")
1009
1010            if(faultResult.error)
1011                return fail(code: "default.create.failure")
1012
1013            if(workDoneResult.error)
1014                return fail(code: "default.create.failure")
1015
1016            // Success.
1017            return result
1018
1019        } //end withTransaction
1020    } // end saveImmediateCallout()
1021
1022} // end TaskService
Note: See TracBrowser for help on using the repository browser.