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

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

Disable recurring schedule when completing or moving a task to trash.
File size: 19.7 KB
Line 
1/*
2* Provides a service for the Task domain class.
3*
4*/
5class TaskService {
6
7    boolean transactional = false
8
9    def dateUtilService
10    def personService
11
12    /*
13    * Determines and returns a possible parent list
14    * @taskInstance The task to use when determining the possible parent list.
15    * @returns A list of the possible parents.
16    */
17    def possibleParentList(taskInstance) {
18        def criteria = taskInstance.createCriteria()
19        def possibleParentList = criteria {
20            and {
21                notEqual('trash', true)
22                notEqual('id', taskInstance.id)
23                taskInstance.subTasks.each() { notEqual('id', it.id) }
24                }
25        }
26    }
27
28    /*
29    * Creates a new task with the given params.
30    * @params The params to use when creating the new task.
31    * @returns A map containing result.error=true (if any error) and result.taskInstance.
32    */
33    def create(params) {
34        Task.withTransaction { status ->
35            def result = [:]
36            // Default status to "not started" if not supplied.
37            params.taskStatus = params.taskStatus ?: TaskStatus.get(1)
38            def taskInstance = new Task(params)
39            result.taskInstance = taskInstance
40
41            if(result.taskInstance.parentTask?.trash) {
42                status.setRollbackOnly()
43                result.taskInstance.errors.rejectValue("parentTask", "task.operationNotPermittedOnTaskInTrash")
44                result.error = true
45                return result
46            }
47
48            if(taskInstance.save()) {
49                def taskModification = new TaskModification(person: personService.currentUser(),
50                                                        taskModificationType: TaskModificationType.get(1),
51                                                        task: taskInstance)
52
53                if(!taskModification.save()) {
54                    status.setRollbackOnly()
55                    taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
56                    result.error = true
57                    return result
58                }
59
60                // If we get here all went well.
61                return result
62            }
63            else {
64                result.error = true
65                return result
66            }
67
68        } //end withTransaction
69    } // end create()
70
71    /*
72    * Creates a subTask copying attributes from the parentTask unless otherwise specified.
73    * @param parentTask The parent task to get attributes from, also set as the parent.
74    * @param params Overrides the parent task values if specified.
75    * @returns A map containing result.error=true (if any error) and result.taskInstance.
76    */
77    def createSubTask(parentTask, params = [:]) {
78
79        def result = [:]
80
81        //Make our new Task a subTask and set the required properites.
82        def p = [:]
83        p.parentTask = parentTask
84        p.description = params.description ?: parentTask.description
85        p.comment = params.comment ?: parentTask.comment
86
87        p.taskGroup = params.taskGroup ?: parentTask.taskGroup
88        p.taskStatus = TaskStatus.get(1) // A new subTask must always be "Not Started".
89        p.taskPriority = parentTask.taskPriority
90        p.taskType = params.taskType ?: parentTask.taskType
91        p.leadPerson = params.leadPerson ?: parentTask.leadPerson
92        p.primaryAsset = params.primaryAsset ?: parentTask.primaryAsset
93
94        p.targetStartDate = params.targetStartDate ?: parentTask.targetStartDate
95        p.targetCompletionDate = params.targetCompletionDate ?: parentTask.targetCompletionDate
96
97                    //Set the assignedPersons
98//                     taskInstance.assignedPersons.each() {
99//
100//                     def assignedPerson = new AssignedPerson(person: it.person,
101//                                                                                             task: subTaskInstance,
102//                                                                                             estimatedHour: it.estimatedHour,
103//                                                                                             estimatedMinute: it.estimatedMinute).save()
104//                     }
105
106        result = create(p)
107
108    } // end createSubTask()
109
110    /*
111    * Creates a new task entry.
112    * @params The params to use when creating the new entry.
113    * @returns A map containing result.error=true (if any error), result.entryInstance and result.taskId.
114    */
115    def createEntry(params) {
116        Task.withTransaction { status ->
117            def result = [:]
118            result.entryInstance = new Entry(params)
119            result.entryInstance.enteredBy = personService.currentUser()
120
121            if(result.entryInstance.validate()) {
122                def taskInstance = Task.lock(result.entryInstance.task.id)
123                result.taskId = result.entryInstance.task.id
124
125                if(!taskInstance) {
126                    status.setRollbackOnly()
127                    result.entryInstance.errors.rejectValue('task', "entry.task.notFound")
128                    result.error = true
129                    return result
130                }
131
132                if(taskInstance.taskStatus.id == 3) {
133                    status.setRollbackOnly()
134                    result.entryInstance.errors.rejectValue('task', "task.operationNotPermittedOnCompleteTask")
135                    result.error = true
136                    return result
137                }
138
139                // If task status is "Not Started" and entry type is "Work Done" then we create the started modification and set the status.
140                if(taskInstance.taskStatus.id == 1 && result.entryInstance.entryType.id == 2) {
141
142                    // Create the "Started" task modification, this provides the "Actual started date".
143                    def taskModification = new TaskModification(person: personService.currentUser(),
144                                                            taskModificationType: TaskModificationType.get(2),
145                                                            task: taskInstance)
146
147                    if(!taskModification.save()) {
148                        status.setRollbackOnly()
149                        taskInstance.errors.rejectValue("task", "entry.task.failedToSaveTaskModification")
150                        result.error = true
151                        return result
152                    }
153
154                    // Set task status to "In progress".
155                    taskInstance.taskStatus = TaskStatus.get(2)
156
157                    if(!taskInstance.save()) {
158                        status.setRollbackOnly()
159                        result.entryInstance.errors.rejectValue("task", "entry.task.failedToSave")
160                        result.error = true
161                        return result
162                    }
163                }
164
165                if(!result.entryInstance.save()) {
166                    status.setRollbackOnly()
167                    result.error = true
168                    return result
169                }
170
171                // All went well if we get to here.
172                return result
173            }
174            else {
175                result.error = true
176                return result
177            }
178
179        } //end withTransaction
180    } // end create()
181
182    def update(params) {
183        Task.withTransaction { status ->
184            def result = [:]
185            result.taskInstance = Task.get(params.id)
186            if(result.taskInstance) {
187
188                // Optimistic locking check.
189                if(params.version) {
190                    def version = params.version.toLong()
191                    if(result.taskInstance.version > version) {
192                        status.setRollbackOnly()
193                        result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
194                        result.error = true
195                        return result
196                    }
197                }
198
199                result.taskInstance.properties = params
200
201                if(result.taskInstance.save()) {
202                    def taskModification = new TaskModification(person:personService.currentUser(),
203                                                            taskModificationType: TaskModificationType.get(3),
204                                                            task: result.taskInstance)
205                    if(taskModification.save()) {
206                        // All went well.
207                        return result
208                    }
209                    else {
210                        status.setRollbackOnly()
211                        result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
212                        result.error = true
213                        return result
214                    }
215                }
216            }
217            // Something failed.
218            status.setRollbackOnly()
219            result.error = true
220            return result
221
222        } //end withTransaction
223    }  // end update()
224
225    def complete(params) {
226        Task.withTransaction { status ->
227            def result = [:]
228            result.taskInstance = Task.get(params.id)
229            if(result.taskInstance) {
230
231                // Optimistic locking check.
232                if(params.version) {
233                    def version = params.version.toLong()
234                    if(result.taskInstance.version > version) {
235                        status.setRollbackOnly()
236                        result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
237                        result.error = true
238                        return result
239                    }
240                }
241
242                result.taskInstance.taskStatus = TaskStatus.get(3)
243
244                if(result.taskInstance.save()) {
245
246                    result.taskInstance.taskRecurringSchedule?.enabled = false
247
248                    def taskModification = new TaskModification(person:personService.currentUser(),
249                                                            taskModificationType: TaskModificationType.get(4),
250                                                            task: result.taskInstance)
251
252                    if(taskModification.save()) {
253                        // All went well.
254                        return result
255                    }
256                    else {
257                        status.setRollbackOnly()
258                        result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
259                        result.error = true
260                        return result
261                    }
262                }
263            }
264            // Something failed.
265            status.setRollbackOnly()
266            result.error = true
267            return result
268
269        } //end withTransaction
270    }  // end complete()
271
272    def reopen(params) {
273        Task.withTransaction { status ->
274            def result = [:]
275            result.taskInstance = Task.get(params.id)
276            if(result.taskInstance) {
277
278                // Optimistic locking check.
279                if(params.version) {
280                    def version = params.version.toLong()
281                    if(result.taskInstance.version > version) {
282                        status.setRollbackOnly()
283                        result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
284                        result.error = true
285                        return result
286                    }
287                }
288
289                result.taskInstance.taskStatus = TaskStatus.get(2)
290
291                if(result.taskInstance.save()) {
292                    def taskModification = new TaskModification(person:personService.currentUser(),
293                                                            taskModificationType: TaskModificationType.get(5),
294                                                            task: result.taskInstance)
295                    if(taskModification.save()) {
296                        // All went well.
297                        return result
298                    }
299                    else {
300                        status.setRollbackOnly()
301                        result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
302                        result.error = true
303                        return result
304                    }
305                }
306            }
307            // Something failed.
308            status.setRollbackOnly()
309            result.error = true
310            return result
311
312        } //end withTransaction
313    }  // end reopen()
314
315    def trash(params) {
316        Task.withTransaction { status ->
317            def result = [:]
318            result.taskInstance = Task.get(params.id)
319            if(result.taskInstance) {
320
321                // Optimistic locking check.
322                if(params.version) {
323                    def version = params.version.toLong()
324                    if(result.taskInstance.version > version) {
325                        status.setRollbackOnly()
326                        result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
327                        result.error = true
328                        return result
329                    }
330                }
331
332                result.taskInstance.trash = true
333
334                if(result.taskInstance.save()) {
335
336                    result.taskInstance.taskRecurringSchedule?.enabled = false
337
338                    def taskModification = new TaskModification(person:personService.currentUser(),
339                                                            taskModificationType: TaskModificationType.get(6),
340                                                            task: result.taskInstance)
341                    if(taskModification.save()) {
342                        // All went well.
343                        return result
344                    }
345                    else {
346                        status.setRollbackOnly()
347                        result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
348                        result.error = true
349                        return result
350                    }
351                }
352            }
353            // Something failed.
354            status.setRollbackOnly()
355            result.error = true
356            return result
357
358        } //end withTransaction
359    }  // end trash()
360
361    def restore(params) {
362        Task.withTransaction { status ->
363            def result = [:]
364            result.taskInstance = Task.get(params.id)
365            if(result.taskInstance) {
366
367                // Optimistic locking check.
368                if(params.version) {
369                    def version = params.version.toLong()
370                    if(result.taskInstance.version > version) {
371                        status.setRollbackOnly()
372                        result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
373                        result.error = true
374                        return result
375                    }
376                }
377
378                result.taskInstance.trash = false
379
380                if(result.taskInstance.save()) {
381                    def taskModification = new TaskModification(person:personService.currentUser(),
382                                                            taskModificationType: TaskModificationType.get(7),
383                                                            task: result.taskInstance)
384                    if(taskModification.save()) {
385                        // All went well.
386                        return result
387                    }
388                    else {
389                        status.setRollbackOnly()
390                        result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
391                        result.error = true
392                        return result
393                    }
394                }
395            }
396            // Something failed.
397            status.setRollbackOnly()
398            result.error = true
399            return result
400
401        } //end withTransaction
402    }  // end restore()
403
404    def approve(params) {
405        Task.withTransaction { status ->
406            def result = [:]
407            result.taskInstance = Task.get(params.id)
408            if(result.taskInstance) {
409
410                // Optimistic locking check.
411                if(params.version) {
412                    def version = params.version.toLong()
413                    if(result.taskInstance.version > version) {
414                        status.setRollbackOnly()
415                        result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
416                        result.error = true
417                        return result
418                    }
419                }
420
421                result.taskInstance.approved = true
422
423                if(result.taskInstance.save()) {
424                    def taskModification = new TaskModification(person:personService.currentUser(),
425                                                            taskModificationType: TaskModificationType.get(8),
426                                                            task: result.taskInstance)
427                    if(taskModification.save()) {
428                        // All went well.
429                        return result
430                    }
431                    else {
432                        status.setRollbackOnly()
433                        result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
434                        result.error = true
435                        return result
436                    }
437                }
438            }
439            // Something failed.
440            status.setRollbackOnly()
441            result.error = true
442            return result
443
444        } //end withTransaction
445    }  // end approve()
446
447    def renegeApproval(params) {
448        Task.withTransaction { status ->
449            def result = [:]
450            result.taskInstance = Task.get(params.id)
451            if(result.taskInstance) {
452
453                // Optimistic locking check.
454                if(params.version) {
455                    def version = params.version.toLong()
456                    if(result.taskInstance.version > version) {
457                        status.setRollbackOnly()
458                        result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
459                        result.error = true
460                        return result
461                    }
462                }
463
464                result.taskInstance.approved = false
465
466                if(result.taskInstance.save()) {
467                    def taskModification = new TaskModification(person:personService.currentUser(),
468                                                            taskModificationType: TaskModificationType.get(9),
469                                                            task: result.taskInstance)
470                    if(taskModification.save()) {
471                        // All went well.
472                        return result
473                    }
474                    else {
475                        status.setRollbackOnly()
476                        result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
477                        result.error = true
478                        return result
479                    }
480                }
481            }
482            // Something failed.
483            status.setRollbackOnly()
484            result.error = true
485            return result
486
487        } //end withTransaction
488    }  // end renegeApproval()
489
490} // end TaskService
Note: See TracBrowser for help on using the repository browser.