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

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

Change is* in Task to just 'active', 'scheduled' and 'approved'.
Regenerate non detailed controller and views.
Adjust detailed controller, views and services to suite.
Add support for task actions 'approve', 'complete', 'trash' and their counter parts.
Default task status to "not started" when creating a new task.
File size: 14.0 KB
Line 
1class TaskService {
2
3    boolean transactional = false
4
5    def dateUtilService
6    def authenticateService
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            // Get person in a safe way to avoid a null userDomain during bootstrap.
17            def userDomain = authenticateService.userDomain()
18            def person = userDomain ? Person.get(userDomain.id) : Person.get(1)
19
20            if(taskInstance.save()) {
21                def taskModification = new TaskModification(person:person,
22                                                        taskModificationType: TaskModificationType.get(1),
23                                                        task: taskInstance)
24
25                if(!taskModification.save()) {
26                    status.setRollbackOnly()
27                    taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
28                    result.error = true
29                    return result
30                }
31
32                return result
33            }
34            else {
35                result.error = true
36                return result
37            }
38
39        } //end withTransaction
40    } // end create()
41
42    def start() {
43        //TaskModificationType.get(2)
44    }  // end start()
45
46    def update(params) {
47        Task.withTransaction { status ->
48            def result = [:]
49            result.taskInstance = Task.get(params.id)
50            if(result.taskInstance) {
51
52                // Optimistic locking check.
53                if(params.version) {
54                    def version = params.version.toLong()
55                    if(result.taskInstance.version > version) {
56                        status.setRollbackOnly()
57                        result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
58                        result.error = true
59                        return result
60                    }
61                }
62
63                result.taskInstance.properties = params
64
65                if(result.taskInstance.save()) {
66                    def taskModification = new TaskModification(person:Person.get(authenticateService.userDomain().id),
67                                                            taskModificationType: TaskModificationType.get(3),
68                                                            task: result.taskInstance)
69                    if(taskModification.save()) {
70                        // All went well.
71                        return result
72                    }
73                    else {
74                        status.setRollbackOnly()
75                        result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
76                        result.error = true
77                        return result
78                    }
79                }
80            }
81            // Something failed.
82            status.setRollbackOnly()
83            result.error = true
84            return result
85
86        } //end withTransaction
87    }  // end update()
88
89    def complete(params) {
90        Task.withTransaction { status ->
91            def result = [:]
92            result.taskInstance = Task.get(params.id)
93            if(result.taskInstance) {
94
95                // Optimistic locking check.
96                if(params.version) {
97                    def version = params.version.toLong()
98                    if(result.taskInstance.version > version) {
99                        status.setRollbackOnly()
100                        result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
101                        result.error = true
102                        return result
103                    }
104                }
105
106                result.taskInstance.taskStatus = TaskStatus.get(3)
107
108                if(result.taskInstance.save()) {
109                    def taskModification = new TaskModification(person:Person.get(authenticateService.userDomain().id),
110                                                            taskModificationType: TaskModificationType.get(4),
111                                                            task: result.taskInstance)
112                    if(taskModification.save()) {
113                        // All went well.
114                        return result
115                    }
116                    else {
117                        status.setRollbackOnly()
118                        result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
119                        result.error = true
120                        return result
121                    }
122                }
123            }
124            // Something failed.
125            status.setRollbackOnly()
126            result.error = true
127            return result
128
129        } //end withTransaction
130    }  // end complete()
131
132    def reopen(params) {
133        Task.withTransaction { status ->
134            def result = [:]
135            result.taskInstance = Task.get(params.id)
136            if(result.taskInstance) {
137
138                // Optimistic locking check.
139                if(params.version) {
140                    def version = params.version.toLong()
141                    if(result.taskInstance.version > version) {
142                        status.setRollbackOnly()
143                        result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
144                        result.error = true
145                        return result
146                    }
147                }
148
149                result.taskInstance.taskStatus = TaskStatus.get(2)
150
151                if(result.taskInstance.save()) {
152                    def taskModification = new TaskModification(person:Person.get(authenticateService.userDomain().id),
153                                                            taskModificationType: TaskModificationType.get(5),
154                                                            task: result.taskInstance)
155                    if(taskModification.save()) {
156                        // All went well.
157                        return result
158                    }
159                    else {
160                        status.setRollbackOnly()
161                        result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
162                        result.error = true
163                        return result
164                    }
165                }
166            }
167            // Something failed.
168            status.setRollbackOnly()
169            result.error = true
170            return result
171
172        } //end withTransaction
173    }  // end reopen()
174
175    def trash(params) {
176        Task.withTransaction { status ->
177            def result = [:]
178            result.taskInstance = Task.get(params.id)
179            if(result.taskInstance) {
180
181                // Optimistic locking check.
182                if(params.version) {
183                    def version = params.version.toLong()
184                    if(result.taskInstance.version > version) {
185                        status.setRollbackOnly()
186                        result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
187                        result.error = true
188                        return result
189                    }
190                }
191
192                result.taskInstance.trash = true
193
194                if(result.taskInstance.save()) {
195                    def taskModification = new TaskModification(person:Person.get(authenticateService.userDomain().id),
196                                                            taskModificationType: TaskModificationType.get(6),
197                                                            task: result.taskInstance)
198                    if(taskModification.save()) {
199                        // All went well.
200                        return result
201                    }
202                    else {
203                        status.setRollbackOnly()
204                        result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
205                        result.error = true
206                        return result
207                    }
208                }
209            }
210            // Something failed.
211            status.setRollbackOnly()
212            result.error = true
213            return result
214
215        } //end withTransaction
216    }  // end trash()
217
218    def restore(params) {
219        Task.withTransaction { status ->
220            def result = [:]
221            result.taskInstance = Task.get(params.id)
222            if(result.taskInstance) {
223
224                // Optimistic locking check.
225                if(params.version) {
226                    def version = params.version.toLong()
227                    if(result.taskInstance.version > version) {
228                        status.setRollbackOnly()
229                        result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
230                        result.error = true
231                        return result
232                    }
233                }
234
235                result.taskInstance.trash = false
236
237                if(result.taskInstance.save()) {
238                    def taskModification = new TaskModification(person:Person.get(authenticateService.userDomain().id),
239                                                            taskModificationType: TaskModificationType.get(7),
240                                                            task: result.taskInstance)
241                    if(taskModification.save()) {
242                        // All went well.
243                        return result
244                    }
245                    else {
246                        status.setRollbackOnly()
247                        result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
248                        result.error = true
249                        return result
250                    }
251                }
252            }
253            // Something failed.
254            status.setRollbackOnly()
255            result.error = true
256            return result
257
258        } //end withTransaction
259    }  // end restore()
260
261    def approve(params) {
262        Task.withTransaction { status ->
263            def result = [:]
264            result.taskInstance = Task.get(params.id)
265            if(result.taskInstance) {
266
267                // Optimistic locking check.
268                if(params.version) {
269                    def version = params.version.toLong()
270                    if(result.taskInstance.version > version) {
271                        status.setRollbackOnly()
272                        result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
273                        result.error = true
274                        return result
275                    }
276                }
277
278                result.taskInstance.approved = true
279
280                if(result.taskInstance.save()) {
281                    def taskModification = new TaskModification(person:Person.get(authenticateService.userDomain().id),
282                                                            taskModificationType: TaskModificationType.get(8),
283                                                            task: result.taskInstance)
284                    if(taskModification.save()) {
285                        // All went well.
286                        return result
287                    }
288                    else {
289                        status.setRollbackOnly()
290                        result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
291                        result.error = true
292                        return result
293                    }
294                }
295            }
296            // Something failed.
297            status.setRollbackOnly()
298            result.error = true
299            return result
300
301        } //end withTransaction
302    }  // end approve()
303
304    def renegeApproval(params) {
305        Task.withTransaction { status ->
306            def result = [:]
307            result.taskInstance = Task.get(params.id)
308            if(result.taskInstance) {
309
310                // Optimistic locking check.
311                if(params.version) {
312                    def version = params.version.toLong()
313                    if(result.taskInstance.version > version) {
314                        status.setRollbackOnly()
315                        result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
316                        result.error = true
317                        return result
318                    }
319                }
320
321                result.taskInstance.approved = false
322
323                if(result.taskInstance.save()) {
324                    def taskModification = new TaskModification(person:Person.get(authenticateService.userDomain().id),
325                                                            taskModificationType: TaskModificationType.get(9),
326                                                            task: result.taskInstance)
327                    if(taskModification.save()) {
328                        // All went well.
329                        return result
330                    }
331                    else {
332                        status.setRollbackOnly()
333                        result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
334                        result.error = true
335                        return result
336                    }
337                }
338            }
339            // Something failed.
340            status.setRollbackOnly()
341            result.error = true
342            return result
343
344        } //end withTransaction
345    }  // end renegeApproval()
346
347} // end TaskService
Note: See TracBrowser for help on using the repository browser.