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

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

Add createEntry to TaskService, automgically updates the task to "In progress" and creates the "Started" task modification.
File size: 16.3 KB
Line 
1class TaskService {
2
3    boolean transactional = false
4
5    def dateUtilService
6    def personService
7
8    def create(params) {
9        Task.withTransaction { status ->
10            def result = [:]
11            // Default status to "not started" if not supplied.
12            params.taskStatus = params.taskStatus ?: TaskStatus.get(1)
13            def taskInstance = new Task(params)
14            result.taskInstance = taskInstance
15
16            if(taskInstance.save()) {
17                def taskModification = new TaskModification(person: personService.currentUser(),
18                                                        taskModificationType: TaskModificationType.get(1),
19                                                        task: taskInstance)
20
21                if(!taskModification.save()) {
22                    status.setRollbackOnly()
23                    taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
24                    result.error = true
25                    return result
26                }
27
28                return result
29            }
30            else {
31                result.error = true
32                return result
33            }
34
35        } //end withTransaction
36    } // end create()
37
38    def createEntry(params) {
39        Task.withTransaction { status ->
40            def result = [:]
41            result.entryInstance = new Entry(params)
42            result.entryInstance.enteredBy = personService.currentUser()
43
44            if(result.entryInstance.validate()) {
45                def taskInstance = Task.lock(result.entryInstance.task.id)
46                result.taskId = result.entryInstance.task.id
47
48                if(!taskInstance) {
49                    status.setRollbackOnly()
50                    result.entryInstance.errors.rejectValue('task', "entry.task.notFound")
51                    result.error = true
52                    return result
53                }
54
55                if(taskInstance.taskStatus.id == 3) {
56                    status.setRollbackOnly()
57                    result.entryInstance.errors.rejectValue('task', "entry.task.taskIsComplete")
58                    result.error = true
59                    return result
60                }
61
62                // If task status is "Not Started" and entry type is "Work Done" then we create the started modification and set the status.
63                if(taskInstance.taskStatus.id == 1 && result.entryInstance.entryType.id == 2) {
64
65                    // Create the "Started" task modification, this provides the "Actual started date".
66                    def taskModification = new TaskModification(person: personService.currentUser(),
67                                                            taskModificationType: TaskModificationType.get(2),
68                                                            task: taskInstance)
69
70                    if(!taskModification.save()) {
71                        status.setRollbackOnly()
72                        taskInstance.errors.rejectValue("task", "entry.task.failedToSaveTaskModification")
73                        result.error = true
74                        return result
75                    }
76
77                    // Set task status to "In progress".
78                    taskInstance.taskStatus = TaskStatus.get(2)
79
80                    if(!taskInstance.save()) {
81                        status.setRollbackOnly()
82                        result.entryInstance.errors.rejectValue("task", "entry.task.failedToSave")
83                        result.error = true
84                        return result
85                    }
86                }
87
88                if(!result.entryInstance.save()) {
89                    status.setRollbackOnly()
90                    result.error = true
91                    return result
92                }
93
94                // All went well if we get to here.
95                return result
96            }
97            else {
98                result.error = true
99                return result
100            }
101
102        } //end withTransaction
103    } // end create()
104
105    def update(params) {
106        Task.withTransaction { status ->
107            def result = [:]
108            result.taskInstance = Task.get(params.id)
109            if(result.taskInstance) {
110
111                // Optimistic locking check.
112                if(params.version) {
113                    def version = params.version.toLong()
114                    if(result.taskInstance.version > version) {
115                        status.setRollbackOnly()
116                        result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
117                        result.error = true
118                        return result
119                    }
120                }
121
122                result.taskInstance.properties = params
123
124                if(result.taskInstance.save()) {
125                    def taskModification = new TaskModification(person:personService.currentUser(),
126                                                            taskModificationType: TaskModificationType.get(3),
127                                                            task: result.taskInstance)
128                    if(taskModification.save()) {
129                        // All went well.
130                        return result
131                    }
132                    else {
133                        status.setRollbackOnly()
134                        result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
135                        result.error = true
136                        return result
137                    }
138                }
139            }
140            // Something failed.
141            status.setRollbackOnly()
142            result.error = true
143            return result
144
145        } //end withTransaction
146    }  // end update()
147
148    def complete(params) {
149        Task.withTransaction { status ->
150            def result = [:]
151            result.taskInstance = Task.get(params.id)
152            if(result.taskInstance) {
153
154                // Optimistic locking check.
155                if(params.version) {
156                    def version = params.version.toLong()
157                    if(result.taskInstance.version > version) {
158                        status.setRollbackOnly()
159                        result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
160                        result.error = true
161                        return result
162                    }
163                }
164
165                result.taskInstance.taskStatus = TaskStatus.get(3)
166
167                if(result.taskInstance.save()) {
168                    def taskModification = new TaskModification(person:personService.currentUser(),
169                                                            taskModificationType: TaskModificationType.get(4),
170                                                            task: result.taskInstance)
171                    if(taskModification.save()) {
172                        // All went well.
173                        return result
174                    }
175                    else {
176                        status.setRollbackOnly()
177                        result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
178                        result.error = true
179                        return result
180                    }
181                }
182            }
183            // Something failed.
184            status.setRollbackOnly()
185            result.error = true
186            return result
187
188        } //end withTransaction
189    }  // end complete()
190
191    def reopen(params) {
192        Task.withTransaction { status ->
193            def result = [:]
194            result.taskInstance = Task.get(params.id)
195            if(result.taskInstance) {
196
197                // Optimistic locking check.
198                if(params.version) {
199                    def version = params.version.toLong()
200                    if(result.taskInstance.version > version) {
201                        status.setRollbackOnly()
202                        result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
203                        result.error = true
204                        return result
205                    }
206                }
207
208                result.taskInstance.taskStatus = TaskStatus.get(2)
209
210                if(result.taskInstance.save()) {
211                    def taskModification = new TaskModification(person:personService.currentUser(),
212                                                            taskModificationType: TaskModificationType.get(5),
213                                                            task: result.taskInstance)
214                    if(taskModification.save()) {
215                        // All went well.
216                        return result
217                    }
218                    else {
219                        status.setRollbackOnly()
220                        result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
221                        result.error = true
222                        return result
223                    }
224                }
225            }
226            // Something failed.
227            status.setRollbackOnly()
228            result.error = true
229            return result
230
231        } //end withTransaction
232    }  // end reopen()
233
234    def trash(params) {
235        Task.withTransaction { status ->
236            def result = [:]
237            result.taskInstance = Task.get(params.id)
238            if(result.taskInstance) {
239
240                // Optimistic locking check.
241                if(params.version) {
242                    def version = params.version.toLong()
243                    if(result.taskInstance.version > version) {
244                        status.setRollbackOnly()
245                        result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
246                        result.error = true
247                        return result
248                    }
249                }
250
251                result.taskInstance.trash = true
252
253                if(result.taskInstance.save()) {
254                    def taskModification = new TaskModification(person:personService.currentUser(),
255                                                            taskModificationType: TaskModificationType.get(6),
256                                                            task: result.taskInstance)
257                    if(taskModification.save()) {
258                        // All went well.
259                        return result
260                    }
261                    else {
262                        status.setRollbackOnly()
263                        result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
264                        result.error = true
265                        return result
266                    }
267                }
268            }
269            // Something failed.
270            status.setRollbackOnly()
271            result.error = true
272            return result
273
274        } //end withTransaction
275    }  // end trash()
276
277    def restore(params) {
278        Task.withTransaction { status ->
279            def result = [:]
280            result.taskInstance = Task.get(params.id)
281            if(result.taskInstance) {
282
283                // Optimistic locking check.
284                if(params.version) {
285                    def version = params.version.toLong()
286                    if(result.taskInstance.version > version) {
287                        status.setRollbackOnly()
288                        result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
289                        result.error = true
290                        return result
291                    }
292                }
293
294                result.taskInstance.trash = false
295
296                if(result.taskInstance.save()) {
297                    def taskModification = new TaskModification(person:personService.currentUser(),
298                                                            taskModificationType: TaskModificationType.get(7),
299                                                            task: result.taskInstance)
300                    if(taskModification.save()) {
301                        // All went well.
302                        return result
303                    }
304                    else {
305                        status.setRollbackOnly()
306                        result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
307                        result.error = true
308                        return result
309                    }
310                }
311            }
312            // Something failed.
313            status.setRollbackOnly()
314            result.error = true
315            return result
316
317        } //end withTransaction
318    }  // end restore()
319
320    def approve(params) {
321        Task.withTransaction { status ->
322            def result = [:]
323            result.taskInstance = Task.get(params.id)
324            if(result.taskInstance) {
325
326                // Optimistic locking check.
327                if(params.version) {
328                    def version = params.version.toLong()
329                    if(result.taskInstance.version > version) {
330                        status.setRollbackOnly()
331                        result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
332                        result.error = true
333                        return result
334                    }
335                }
336
337                result.taskInstance.approved = true
338
339                if(result.taskInstance.save()) {
340                    def taskModification = new TaskModification(person:personService.currentUser(),
341                                                            taskModificationType: TaskModificationType.get(8),
342                                                            task: result.taskInstance)
343                    if(taskModification.save()) {
344                        // All went well.
345                        return result
346                    }
347                    else {
348                        status.setRollbackOnly()
349                        result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
350                        result.error = true
351                        return result
352                    }
353                }
354            }
355            // Something failed.
356            status.setRollbackOnly()
357            result.error = true
358            return result
359
360        } //end withTransaction
361    }  // end approve()
362
363    def renegeApproval(params) {
364        Task.withTransaction { status ->
365            def result = [:]
366            result.taskInstance = Task.get(params.id)
367            if(result.taskInstance) {
368
369                // Optimistic locking check.
370                if(params.version) {
371                    def version = params.version.toLong()
372                    if(result.taskInstance.version > version) {
373                        status.setRollbackOnly()
374                        result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
375                        result.error = true
376                        return result
377                    }
378                }
379
380                result.taskInstance.approved = false
381
382                if(result.taskInstance.save()) {
383                    def taskModification = new TaskModification(person:personService.currentUser(),
384                                                            taskModificationType: TaskModificationType.get(9),
385                                                            task: result.taskInstance)
386                    if(taskModification.save()) {
387                        // All went well.
388                        return result
389                    }
390                    else {
391                        status.setRollbackOnly()
392                        result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
393                        result.error = true
394                        return result
395                    }
396                }
397            }
398            // Something failed.
399            status.setRollbackOnly()
400            result.error = true
401            return result
402
403        } //end withTransaction
404    }  // end renegeApproval()
405
406} // end TaskService
Note: See TracBrowser for help on using the repository browser.