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

Last change on this file since 635 was 631, checked in by gav, 14 years ago

Check for authorisation on recurring tasks.

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