Ignore:
Timestamp:
Feb 28, 2010, 7:13:47 PM (14 years ago)
Author:
gav
Message:

Add attentionFlag to Task domain along with views and logic to suite.
Add entry type 'cause', refactor as required.
Refactor task types.
Move createBreakin to createImmediateCallout.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/grails-app/services/TaskService.groovy

    r395 r418  
    3131    * Creates a new task with the given params.
    3232    * @param params The params to use when creating the new task.
    33     * @returns A map containing result.error=true (if any error) and result.taskInstance.
     33    * @returns A map containing result.error (if any error) and result.taskInstance.
    3434    */
    3535    def save(params) {
    3636        Task.withTransaction { status ->
    3737            def result = [:]
     38
     39            def fail = { Map m ->
     40                status.setRollbackOnly()
     41                if(result.taskInstance && m.field)
     42                    result.taskInstance.errors.rejectValue(m.field, m.code)
     43                result.error = [ code: m.code, args: ["Task", params.id] ]
     44                return result
     45            }
     46
    3847            // Default status to "not started" if not supplied.
    3948            params.taskStatus = params.taskStatus ?: TaskStatus.get(1)
    4049
    4150            // Set budgetStatus.
    42             if(params.taskType?.id?.toLong() == 1) // Unscheduled Breakin.
     51            if(params.taskType?.id?.toLong() == 1 || params.taskType?.id?.toLong() == 2) // Immediate Callout or Unsheduled Breakin.
    4352                params.taskBudgetStatus = params.taskBudgetStatus ?: TaskBudgetStatus.get(1) // Unplanned.
    4453            else
    … …  
    4857            result.taskInstance = taskInstance
    4958
    50             if(result.taskInstance.parentTask?.trash) {
    51                 status.setRollbackOnly()
    52                 result.taskInstance.errors.rejectValue("parentTask", "task.operationNotPermittedOnTaskInTrash")
    53                 result.error = true
    54                 return result
    55             }
    56 
    57             if(taskInstance.save()) {
    58                 def taskModification = new TaskModification(person: authService.currentUser,
    59                                                         taskModificationType: TaskModificationType.get(1),
    60                                                         task: taskInstance)
    61 
    62                 if(!taskModification.save()) {
    63                     status.setRollbackOnly()
    64                     taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
    65                     result.error = true
    66                     return result
     59            if(result.taskInstance.parentTask?.trash)
     60                return fail(field:"parentTask", code:"task.operationNotPermittedOnTaskInTrash")
     61
     62            if(result.taskInstance.hasErrors() || !result.taskInstance.save())
     63                return fail(code:"default.create.failure")
     64
     65            def taskModification = new TaskModification(person: authService.currentUser,
     66                                                taskModificationType: TaskModificationType.get(1),
     67                                                task: taskInstance)
     68
     69            if(taskModification.hasErrors() || !taskModification.save())
     70                return fail(field:"taskModifications", code:"task.modifications.failedToSave")
     71
     72            //Add the assignedGroups, provided by a new ArrayList(task.assignedGroups)
     73            if(params.assignedGroups) {
     74                def assignedGroupsResult
     75                def assignedGroupParams = [:]
     76                params.assignedGroups.each() {
     77
     78                    assignedGroupParams = [personGroup: it.personGroup,
     79                                                                task: taskInstance,
     80                                                                estimatedHour: it.estimatedHour,
     81                                                                estimatedMinute: it.estimatedMinute]
     82
     83                    assignedGroupsResult = assignedGroupService.save(assignedGroupParams)
     84
     85                    if(assignedGroupsResult.error)
     86                        return fail(field:"assignedGroups", code:"task.assignedGroups.failedToSave")
     87
    6788                }
    68 
    69                 //Add the assignedGroups, provided by a new ArrayList(task.assignedGroups)
    70                 if(params.assignedGroups) {
    71                     def assignedGroupsResult
    72                     def assignedGroupParams = [:]
    73                     params.assignedGroups.each() {
    74 
    75                         assignedGroupParams = [personGroup: it.personGroup,
    76                                                                     task: taskInstance,
    77                                                                     estimatedHour: it.estimatedHour,
    78                                                                     estimatedMinute: it.estimatedMinute]
    79 
    80                         assignedGroupsResult = assignedGroupService.save(assignedGroupParams)
    81 
    82                         if(assignedGroupsResult.error) {
    83                             status.setRollbackOnly()
    84                             taskInstance.errors.rejectValue("assignedGroups", "task.assignedGroups.failedToSave")
    85                             result.error = true
    86                             return result
    87                         }
    88 
    89                     }
     89            }
     90
     91            //Add the assignedPersons, provided by a new ArrayList(task.assignedPersons)
     92            if(params.assignedPersons) {
     93                def assignedPersonsResult
     94                def assignedPersonsParams = [:]
     95                params.assignedPersons.each() {
     96
     97                    assignedPersonsParams = [person: it.person,
     98                                                                task: taskInstance,
     99                                                                estimatedHour: it.estimatedHour,
     100                                                                estimatedMinute: it.estimatedMinute]
     101
     102                    assignedPersonsResult = assignedPersonService.save(assignedPersonsParams)
     103
     104                    if(assignedPersonsResult.error)
     105                        return fail(field:"assignedPersons", code:"task.assignedPersons.failedToSave")
     106
    90107                }
    91 
    92                 //Add the assignedPersons, provided by a new ArrayList(task.assignedPersons)
    93                 if(params.assignedPersons) {
    94                     def assignedPersonsResult
    95                     def assignedPersonsParams = [:]
    96                     params.assignedPersons.each() {
    97 
    98                         assignedPersonsParams = [person: it.person,
    99                                                                     task: taskInstance,
    100                                                                     estimatedHour: it.estimatedHour,
    101                                                                     estimatedMinute: it.estimatedMinute]
    102 
    103                         assignedPersonsResult = assignedPersonService.save(assignedPersonsParams)
    104 
    105                         if(assignedPersonsResult.error) {
    106                             status.setRollbackOnly()
    107                             taskInstance.errors.rejectValue("assignedPersons", "task.assignedPersons.failedToSave")
    108                             result.error = true
    109                             return result
    110                         }
    111 
    112                     }
    113                 }
    114 
    115                 // Success.
    116                 return result
    117             }
    118             else {
    119                 result.error = true
    120                 return result
    121             }
     108            }
     109
     110            // Success.
     111            return result
    122112
    123113        } //end withTransaction
    … …  
    210200
    211201            // If task status is "Not Started" and entry type is "Work Done" then we create the started modification and set the status.
    212             if(taskInstance.taskStatus.id == 1 && result.entryInstance.entryType.id == 2) {
     202            if(taskInstance.taskStatus.id == 1 && result.entryInstance.entryType.id == 3) {
    213203
    214204                // Create the "Started" task modification, this provides the "Actual Started Date".
    … …  
    239229    * Updates an existing task.
    240230    * @param params The params to update for task with id of params.id.
    241     * @returns A map containing result.error=true (if any error) and result.taskInstance (if available).
     231    * @returns A map containing result.error (if any error) and result.taskInstance (if available).
    242232    */
    243233    def update(params) {
    … …  
    245235            def result = [:]
    246236
    247             def fail = { Object[] args ->
    248                 status.setRollbackOnly()
    249                 if(args.size() == 2) result.taskInstance.errors.rejectValue(args[0], args[1])
    250                 result.error = true
     237            def fail = { Map m ->
     238                status.setRollbackOnly()
     239                if(result.taskInstance && m.field)
     240                    result.taskInstance.errors.rejectValue(m.field, m.code)
     241                result.error = [ code: m.code, args: ["Task", params.id] ]
    251242                return result
    252243            }
    … …  
    259250            // Optimistic locking check.
    260251            if(params.version) {
    261                 def version = params.version.toLong()
    262                 if(result.taskInstance.version > version)
    263                     return fail("version", "default.optimistic.locking.failure")
     252                if(result.taskInstance.version > params.version.toLong())
     253                    return fail(field:"version", code:"default.optimistic.locking.failure")
    264254            }
    265255
    … …  
    267257
    268258            if(result.taskInstance.hasErrors() || !result.taskInstance.save())
    269                 return fail()
     259                return fail(code:"default.update.failure")
    270260
    271261            def taskModification = new TaskModification(person:authService.currentUser,
    … …  
    273263                                                    task: result.taskInstance)
    274264
    275             if(!taskModification.save())
    276                 return fail("taskModifications", "task.modifications.failedToSave")
    277 
    278             // If we get here all went well.
     265            if(taskModification.hasErrors() || !taskModification.save())
     266                return fail(code:"task.modifications.failedToSave")
     267
     268            // Success.
    279269            return result
    280270
    … …  
    285275    * Completes an existing task.
    286276    * @param params The params for task with id of params.id.
    287     * @returns A map containing result.error=true (if any error) and result.taskInstance.
     277    * @returns A map containing result.error (if any error) and result.taskInstance (if available).
    288278    */
    289279    def complete(params) {
    290280        Task.withTransaction { status ->
    291281            def result = [:]
    292             result.taskInstance = Task.get(params.id)
    293             if(result.taskInstance) {
    294 
    295                 // Optimistic locking check.
    296                 if(params.version) {
    297                     def version = params.version.toLong()
    298                     if(result.taskInstance.version > version) {
    299                         status.setRollbackOnly()
    300                         result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
    301                         result.error = true
    302                         return result
    303                     }
    304                 }
    305 
    306                 result.taskInstance.taskStatus = TaskStatus.get(3)
    307                 result.taskInstance.taskRecurringSchedule?.enabled = false
    308 
    309                 if(result.taskInstance.save()) {
    310                     def taskModification = new TaskModification(person:authService.currentUser,
    311                                                             taskModificationType: TaskModificationType.get(4),
    312                                                             task: result.taskInstance)
    313 
    314                     if(taskModification.save()) {
    315                         // All went well.
    316                         return result
    317                     }
    318                     else {
    319                         status.setRollbackOnly()
    320                         result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
    321                         result.error = true
    322                         return result
    323                     }
    324                 }
    325             }
    326             // Something failed.
    327             status.setRollbackOnly()
    328             result.error = true
     282
     283            def fail = { Map m ->
     284                status.setRollbackOnly()
     285                if(result.taskInstance && m.field)
     286                    result.taskInstance.errors.rejectValue(m.field, m.code)
     287                result.error = [ code: m.code, args: ["Task", params.id] ]
     288                return result
     289            }
     290
     291            result.taskInstance = Task.get(params.id)
     292
     293            if(!result.taskInstance)
     294                return fail(code:"default.not.found")
     295
     296            // Optimistic locking check.
     297            if(params.version) {
     298                if(result.taskInstance.version > params.version.toLong())
     299                    return fail(field:"version", code:"default.optimistic.locking.failure")
     300            }
     301
     302            result.taskInstance.taskStatus = TaskStatus.get(3)
     303            result.taskInstance.attentionFlag = false
     304            result.taskInstance.taskRecurringSchedule?.enabled = false
     305
     306            if(result.taskInstance.hasErrors() || !result.taskInstance.save())
     307                return fail(code:"default.update.failure")
     308
     309            def taskModification = new TaskModification(person:authService.currentUser,
     310                                                    taskModificationType: TaskModificationType.get(4),
     311                                                    task: result.taskInstance)
     312
     313
     314            if(taskModification.hasErrors() || !taskModification.save())
     315                return fail(code:"task.modifications.failedToSave")
     316
     317            // Success.
    329318            return result
    330319
    331320        } //end withTransaction
    332321    }  // end complete()
     322
     323    /**
     324    * Sets the attentionFlag on an existing task.
     325    * @param params The params for task with id of params.id.
     326    * @returns A map containing result.error (if any error) and result.taskInstance (if available).
     327    */
     328    def setAttentionFlag(params) {
     329        Task.withTransaction { status ->
     330            def result = [:]
     331
     332            def fail = { Map m ->
     333                status.setRollbackOnly()
     334                if(result.taskInstance && m.field)
     335                    result.taskInstance.errors.rejectValue(m.field, m.code)
     336                result.error = [ code: m.code, args: ["Task", params.id] ]
     337                return result
     338            }
     339
     340            result.taskInstance = Task.get(params.id)
     341
     342            if(!result.taskInstance)
     343                return fail(code:"default.not.found")
     344
     345            // Optimistic locking check.
     346            if(params.version) {
     347                if(result.taskInstance.version > params.version.toLong())
     348                    return fail(field:"version", code:"default.optimistic.locking.failure")
     349            }
     350
     351            result.taskInstance.attentionFlag = true
     352
     353            if(result.taskInstance.hasErrors() || !result.taskInstance.save())
     354                return fail(code:"default.update.failure")
     355
     356            def taskModification = new TaskModification(person:authService.currentUser,
     357                                                    taskModificationType: TaskModificationType.get(12),
     358                                                    task: result.taskInstance)
     359
     360            if(taskModification.hasErrors() || !taskModification.save())
     361                return fail(code:"task.modifications.failedToSave")
     362
     363            // Success.
     364            return result
     365
     366        } //end withTransaction
     367    }  // end flag()
     368
     369    /**
     370    * Clears the attentionFlag on an existing task.
     371    * @param params The params for task with id of params.id.
     372    * @returns A map containing result.error (if any error) and result.taskInstance (if available).
     373    */
     374    def clearAttentionFlag(params) {
     375        Task.withTransaction { status ->
     376            def result = [:]
     377
     378            def fail = { Map m ->
     379                status.setRollbackOnly()
     380                if(result.taskInstance && m.field)
     381                    result.taskInstance.errors.rejectValue(m.field, m.code)
     382                result.error = [ code: m.code, args: ["Task", params.id] ]
     383                return result
     384            }
     385
     386            result.taskInstance = Task.get(params.id)
     387
     388            if(!result.taskInstance)
     389                return fail(code:"default.not.found")
     390
     391            // Optimistic locking check.
     392            if(params.version) {
     393                if(result.taskInstance.version > params.version.toLong())
     394                    return fail(field:"version", code:"default.optimistic.locking.failure")
     395            }
     396
     397            result.taskInstance.attentionFlag = false
     398
     399            if(result.taskInstance.hasErrors() || !result.taskInstance.save())
     400                return fail(code:"default.update.failure")
     401
     402            def taskModification = new TaskModification(person:authService.currentUser,
     403                                                    taskModificationType: TaskModificationType.get(13),
     404                                                    task: result.taskInstance)
     405
     406            if(taskModification.hasErrors() || !taskModification.save())
     407                return fail(code:"task.modifications.failedToSave")
     408
     409            // Success.
     410            return result
     411
     412        } //end withTransaction
     413    }  // end clearFlag()
    333414
    334415    /**
    335416    * Reopens an existing task.
    336417    * @param params The params for task with id of params.id.
    337     * @returns A map containing result.error=true (if any error) and result.taskInstance.
     418    * @returns A map containing result.error (if any error) and result.taskInstance (if available).
    338419    */
    339420    def reopen(params) {
    340421        Task.withTransaction { status ->
    341422            def result = [:]
    342             result.taskInstance = Task.get(params.id)
    343             if(result.taskInstance) {
    344 
    345                 // Optimistic locking check.
    346                 if(params.version) {
    347                     def version = params.version.toLong()
    348                     if(result.taskInstance.version > version) {
    349                         status.setRollbackOnly()
    350                         result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
    351                         result.error = true
    352                         return result
    353                     }
    354                 }
    355 
    356                 result.taskInstance.taskStatus = TaskStatus.get(2)
    357 
    358                 if(result.taskInstance.save()) {
    359                     def taskModification = new TaskModification(person:authService.currentUser,
    360                                                             taskModificationType: TaskModificationType.get(5),
    361                                                             task: result.taskInstance)
    362                     if(taskModification.save()) {
    363                         // All went well.
    364                         return result
    365                     }
    366                     else {
    367                         status.setRollbackOnly()
    368                         result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
    369                         result.error = true
    370                         return result
    371                     }
    372                 }
    373             }
    374             // Something failed.
    375             status.setRollbackOnly()
    376             result.error = true
     423
     424            def fail = { Map m ->
     425                status.setRollbackOnly()
     426                if(result.taskInstance && m.field)
     427                    result.taskInstance.errors.rejectValue(m.field, m.code)
     428                result.error = [ code: m.code, args: ["Task", params.id] ]
     429                return result
     430            }
     431
     432            result.taskInstance = Task.get(params.id)
     433
     434            if(!result.taskInstance)
     435                return fail(code:"default.not.found")
     436
     437            // Optimistic locking check.
     438            if(params.version) {
     439                if(result.taskInstance.version > params.version.toLong())
     440                    return fail(field:"version", code:"default.optimistic.locking.failure")
     441            }
     442
     443            result.taskInstance.taskStatus = TaskStatus.get(2)
     444
     445            if(result.taskInstance.hasErrors() || !result.taskInstance.save())
     446                return fail(code:"default.update.failure")
     447
     448            def taskModification = new TaskModification(person:authService.currentUser,
     449                                                    taskModificationType: TaskModificationType.get(5),
     450                                                    task: result.taskInstance)
     451
     452            if(taskModification.hasErrors() || !taskModification.save())
     453                return fail(code:"task.modifications.failedToSave")
     454
     455            // Success.
    377456            return result
    378457
    … …  
    383462    * Move a task to the trash.
    384463    * @param params The params for task with id of params.id.
    385     * @returns A map containing result.error=true (if any error) and result.taskInstance.
     464    * @returns A map containing result.error (if any error) and result.taskInstance (if available).
    386465    */
    387466    def trash(params) {
    388467        Task.withTransaction { status ->
    389468            def result = [:]
    390             result.taskInstance = Task.get(params.id)
    391             if(result.taskInstance) {
    392 
    393                 // Optimistic locking check.
    394                 if(params.version) {
    395                     def version = params.version.toLong()
    396                     if(result.taskInstance.version > version) {
    397                         status.setRollbackOnly()
    398                         result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
    399                         result.error = true
    400                         return result
    401                     }
    402                 }
    403 
    404                 result.taskInstance.trash = true
    405                 result.taskInstance.taskRecurringSchedule?.enabled = false
    406 
    407                 if(result.taskInstance.save()) {
    408                     def taskModification = new TaskModification(person:authService.currentUser,
    409                                                             taskModificationType: TaskModificationType.get(6),
    410                                                             task: result.taskInstance)
    411                     if(taskModification.save()) {
    412                         // All went well.
    413                         return result
    414                     }
    415                     else {
    416                         status.setRollbackOnly()
    417                         result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
    418                         result.error = true
    419                         return result
    420                     }
    421                 }
    422             }
    423             // Something failed.
    424             status.setRollbackOnly()
    425             result.error = true
     469
     470            def fail = { Map m ->
     471                status.setRollbackOnly()
     472                if(result.taskInstance && m.field)
     473                    result.taskInstance.errors.rejectValue(m.field, m.code)
     474                result.error = [ code: m.code, args: ["Task", params.id] ]
     475                return result
     476            }
     477
     478            result.taskInstance = Task.get(params.id)
     479
     480            if(!result.taskInstance)
     481                return fail(code:"default.not.found")
     482
     483            // Optimistic locking check.
     484            if(params.version) {
     485                if(result.taskInstance.version > params.version.toLong())
     486                    return fail(field:"version", code:"default.optimistic.locking.failure")
     487            }
     488
     489            result.taskInstance.trash = true
     490            result.taskInstance.attentionFlag = false
     491            result.taskInstance.taskRecurringSchedule?.enabled = false
     492
     493            if(result.taskInstance.hasErrors() || !result.taskInstance.save())
     494                return fail(code:"default.update.failure")
     495
     496            def taskModification = new TaskModification(person:authService.currentUser,
     497                                                    taskModificationType: TaskModificationType.get(6),
     498                                                    task: result.taskInstance)
     499
     500            if(taskModification.hasErrors() || !taskModification.save())
     501                return fail(code:"task.modifications.failedToSave")
     502
     503            // Success.
    426504            return result
    427505
    … …  
    432510    * Restore a task from the trash.
    433511    * @param params The params for task with id of params.id.
    434     * @returns A map containing result.error=true (if any error) and result.taskInstance.
     512    * @returns A map containing result.error (if any error) and result.taskInstance (if available).
    435513    */
    436514    def restore(params) {
    437515        Task.withTransaction { status ->
    438516            def result = [:]
    439             result.taskInstance = Task.get(params.id)
    440             if(result.taskInstance) {
    441 
    442                 // Optimistic locking check.
    443                 if(params.version) {
    444                     def version = params.version.toLong()
    445                     if(result.taskInstance.version > version) {
    446                         status.setRollbackOnly()
    447                         result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
    448                         result.error = true
    449                         return result
    450                     }
    451                 }
    452 
    453                 result.taskInstance.trash = false
    454 
    455                 if(result.taskInstance.save()) {
    456                     def taskModification = new TaskModification(person:authService.currentUser,
    457                                                             taskModificationType: TaskModificationType.get(7),
    458                                                             task: result.taskInstance)
    459                     if(taskModification.save()) {
    460                         // All went well.
    461                         return result
    462                     }
    463                     else {
    464                         status.setRollbackOnly()
    465                         result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
    466                         result.error = true
    467                         return result
    468                     }
    469                 }
    470             }
    471             // Something failed.
    472             status.setRollbackOnly()
    473             result.error = true
     517
     518            def fail = { Map m ->
     519                status.setRollbackOnly()
     520                if(result.taskInstance && m.field)
     521                    result.taskInstance.errors.rejectValue(m.field, m.code)
     522                result.error = [ code: m.code, args: ["Task", params.id] ]
     523                return result
     524            }
     525
     526            result.taskInstance = Task.get(params.id)
     527
     528            if(!result.taskInstance)
     529                return fail(code:"default.not.found")
     530
     531            // Optimistic locking check.
     532            if(params.version) {
     533                if(result.taskInstance.version > params.version.toLong())
     534                    return fail(field:"version", code:"default.optimistic.locking.failure")
     535            }
     536
     537            result.taskInstance.trash = false
     538
     539            if(result.taskInstance.hasErrors() || !result.taskInstance.save())
     540                return fail(code:"default.update.failure")
     541
     542            def taskModification = new TaskModification(person:authService.currentUser,
     543                                                    taskModificationType: TaskModificationType.get(7),
     544                                                    task: result.taskInstance)
     545
     546            if(taskModification.hasErrors() || !taskModification.save())
     547                return fail(code:"task.modifications.failedToSave")
     548
     549            // Success.
    474550            return result
    475551
    … …  
    480556    * Approve a task.
    481557    * @param params The params for task with id of params.id.
    482     * @returns A map containing result.error=true (if any error) and result.taskInstance.
     558    * @returns A map containing result.error (if any error) and result.taskInstance (if available).
    483559    */
    484560    def approve(params) {
    485561        Task.withTransaction { status ->
    486562            def result = [:]
    487             result.taskInstance = Task.get(params.id)
    488             if(result.taskInstance) {
    489 
    490                 // Optimistic locking check.
    491                 if(params.version) {
    492                     def version = params.version.toLong()
    493                     if(result.taskInstance.version > version) {
    494                         status.setRollbackOnly()
    495                         result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
    496                         result.error = true
    497                         return result
    498                     }
    499                 }
    500 
    501                 result.taskInstance.approved = true
    502 
    503                 if(result.taskInstance.save()) {
    504                     def taskModification = new TaskModification(person:authService.currentUser,
    505                                                             taskModificationType: TaskModificationType.get(8),
    506                                                             task: result.taskInstance)
    507                     if(taskModification.save()) {
    508                         // All went well.
    509                         return result
    510                     }
    511                     else {
    512                         status.setRollbackOnly()
    513                         result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
    514                         result.error = true
    515                         return result
    516                     }
    517                 }
    518             }
    519             // Something failed.
    520             status.setRollbackOnly()
    521             result.error = true
     563
     564            def fail = { Map m ->
     565                status.setRollbackOnly()
     566                if(result.taskInstance && m.field)
     567                    result.taskInstance.errors.rejectValue(m.field, m.code)
     568                result.error = [ code: m.code, args: ["Task", params.id] ]
     569                return result
     570            }
     571
     572            result.taskInstance = Task.get(params.id)
     573
     574            if(!result.taskInstance)
     575                return fail(code:"default.not.found")
     576
     577            // Optimistic locking check.
     578            if(params.version) {
     579                if(result.taskInstance.version > params.version.toLong())
     580                    return fail(field:"version", code:"default.optimistic.locking.failure")
     581            }
     582
     583            result.taskInstance.approved = true
     584
     585            if(result.taskInstance.hasErrors() || !result.taskInstance.save())
     586                return fail(code:"default.update.failure")
     587
     588            def taskModification = new TaskModification(person:authService.currentUser,
     589                                                    taskModificationType: TaskModificationType.get(8),
     590                                                    task: result.taskInstance)
     591
     592            if(taskModification.hasErrors() || !taskModification.save())
     593                return fail(code:"task.modifications.failedToSave")
     594
     595            // Success.
    522596            return result
    523597
    … …  
    528602    * Remove a previously given approval from a task.
    529603    * @param params The params for task with id of params.id.
    530     * @returns A map containing result.error=true (if any error) and result.taskInstance.
     604    * @returns A map containing result.error (if any error) and result.taskInstance (if available).
    531605    */
    532606    def renegeApproval(params) {
    533607        Task.withTransaction { status ->
    534608            def result = [:]
    535             result.taskInstance = Task.get(params.id)
    536             if(result.taskInstance) {
    537 
    538                 // Optimistic locking check.
    539                 if(params.version) {
    540                     def version = params.version.toLong()
    541                     if(result.taskInstance.version > version) {
    542                         status.setRollbackOnly()
    543                         result.taskInstance.errors.rejectValue("version", "task.optimistic.locking.failure", "Another user has updated this Task while you were editing.")
    544                         result.error = true
    545                         return result
    546                     }
    547                 }
    548 
    549                 result.taskInstance.approved = false
    550 
    551                 if(result.taskInstance.save()) {
    552                     def taskModification = new TaskModification(person:authService.currentUser,
    553                                                             taskModificationType: TaskModificationType.get(9),
    554                                                             task: result.taskInstance)
    555                     if(taskModification.save()) {
    556                         // All went well.
    557                         return result
    558                     }
    559                     else {
    560                         status.setRollbackOnly()
    561                         result.taskInstance.errors.rejectValue("taskModifications", "task.modifications.failedToSave")
    562                         result.error = true
    563                         return result
    564                     }
    565                 }
    566             }
    567             // Something failed.
    568             status.setRollbackOnly()
    569             result.error = true
     609
     610            def fail = { Map m ->
     611                status.setRollbackOnly()
     612                if(result.taskInstance && m.field)
     613                    result.taskInstance.errors.rejectValue(m.field, m.code)
     614                result.error = [ code: m.code, args: ["Task", params.id] ]
     615                return result
     616            }
     617
     618            result.taskInstance = Task.get(params.id)
     619
     620            if(!result.taskInstance)
     621                return fail(code:"default.not.found")
     622
     623            // Optimistic locking check.
     624            if(params.version) {
     625                if(result.taskInstance.version > params.version.toLong())
     626                    return fail(field:"version", code:"default.optimistic.locking.failure")
     627            }
     628
     629            result.taskInstance.approved = false
     630
     631            if(result.taskInstance.hasErrors() || !result.taskInstance.save())
     632                return fail(code:"default.update.failure")
     633
     634            def taskModification = new TaskModification(person:authService.currentUser,
     635                                                    taskModificationType: TaskModificationType.get(9),
     636                                                    task: result.taskInstance)
     637
     638            if(taskModification.hasErrors() || !taskModification.save())
     639                return fail(code:"task.modifications.failedToSave")
     640
     641            // Success.
    570642            return result
    571643
    … …  
    574646
    575647    /**
    576     * Creates a new breakin task with the given params.
     648    * Creates a new immediate callout task with the given params.
    577649    * @param params The params to use when creating the new task.
    578     * @returns A map containing result.error=true (if any error) and result.taskInstance.
    579     */
    580     def saveBreakin(params) {
     650    * @returns A map containing result.error (if any error) and result.taskInstance.
     651    */
     652    def saveImmediateCallout(params) {
    581653        Task.withTransaction { status ->
    582654            def result = [:]
    … …  
    596668            result.taskInstance = new Task(params)
    597669
    598             // Always for a breakin.
    599             result.taskInstance.taskType = TaskType.get(1) // Unscheduled Breakin.
     670            // Always for an immediate callout.
     671            result.taskInstance.taskType = TaskType.get(1) // Immediate Callout.
    600672            result.taskInstance.taskBudgetStatus = TaskBudgetStatus.get(1) // Unplanned.
    601673            result.taskInstance.taskPriority = TaskPriority.get(4) // Immediate.
    … …  
    624696            result.entryFaultInstance = faultResult.entryInstance
    625697
     698            def causeParams = [task: result.taskInstance,
     699                                            entryType: EntryType.get(2),
     700                                            comment: params.entryCause.comment]
     701            def causeResult = saveEntry(causeParams)
     702            result.entryCauseInstance = causeResult.entryInstance
     703
    626704            def workDoneParams = [task: result.taskInstance,
    627                                                     entryType: EntryType.get(2),
     705                                                    entryType: EntryType.get(3),
    628706                                                    comment: params.entryWorkDone.comment,
    629707                                                    durationHour: params.entryWorkDone.durationHour,
    … …  
    635713                return result
    636714
     715            if(causeResult.error)
     716                return fail(code: "default.create.failure")
     717
    637718            if(faultResult.error)
    638719                return fail(code: "default.create.failure")
    … …  
    645726
    646727        } //end withTransaction
    647     } // end saveBreakin()
     728    } // end saveImmediateCallout()
    648729
    649730} // end TaskService
Note: See TracChangeset for help on using the changeset viewer.