[713] | 1 | import net.kromhouts.HqlBuilder |
---|
[479] | 2 | import grails.orm.PagedResultList |
---|
[701] | 3 | import org.hibernate.FetchMode as FM |
---|
[479] | 4 | |
---|
[476] | 5 | /** |
---|
| 6 | * Service class that encapsulates the business logic for Task searches. |
---|
| 7 | */ |
---|
[143] | 8 | class TaskSearchService { |
---|
| 9 | |
---|
| 10 | boolean transactional = false |
---|
| 11 | |
---|
[476] | 12 | def authService |
---|
[143] | 13 | def dateUtilService |
---|
[476] | 14 | def messageSource |
---|
[143] | 15 | |
---|
[490] | 16 | def g = new org.codehaus.groovy.grails.plugins.web.taglib.ApplicationTagLib() |
---|
| 17 | |
---|
[476] | 18 | def paramsMax = 100000 |
---|
[260] | 19 | |
---|
[713] | 20 | // Be sure to update taskQuickSearchPane.js if quickSearchSelection is changed. |
---|
| 21 | def getQuickSearchSelection() { |
---|
| 22 | [ 'allTasks': g.message(code: 'task.search.text.all.tasks'), |
---|
| 23 | 'budgetPlanned': g.message(code: 'task.search.text.budget.planned'), |
---|
| 24 | 'budgetUnplanned': g.message(code: 'task.search.text.budget.unplanned'), |
---|
| 25 | 'personsImmediateCallouts': g.message(code: 'task.search.text.persons.immediate.callouts'), |
---|
| 26 | 'personsTasks': g.message(code: 'task.search.text.persons.tasks') |
---|
| 27 | ] |
---|
| 28 | } |
---|
| 29 | |
---|
[476] | 30 | /** |
---|
| 31 | * Selects and returns the correct search results based on the supplied quickSearch. |
---|
| 32 | * @param params The request params, may contain params.quickSearch string to specify the search. |
---|
| 33 | * @param locale The locale to use when generating result.message. |
---|
| 34 | */ |
---|
[713] | 35 | def getQuickSearch(params = [:], locale) { |
---|
[476] | 36 | def result = [:] |
---|
[713] | 37 | result.quickSearch = params.quickSearch ?: "personsTasks" |
---|
| 38 | if(params.person) |
---|
| 39 | result.person = Person.get(params.person.id.toLong()) |
---|
| 40 | else |
---|
| 41 | result.person = authService.currentUser |
---|
| 42 | result.startDate = params.startDate ?: dateUtilService.today |
---|
| 43 | result.endDate = params.endDate ?: dateUtilService.today |
---|
| 44 | // Auto swap date range. |
---|
| 45 | if(result.startDate > result.endDate) { |
---|
| 46 | def tempStartDate = result.startDate |
---|
| 47 | result.startDate = result.endDate |
---|
| 48 | result.endDate = tempStartDate |
---|
| 49 | } |
---|
| 50 | result.includeCompleted = params.includeCompleted = params.includeCompleted ? true:false |
---|
[503] | 51 | |
---|
[713] | 52 | def getMessage = { Map m -> |
---|
| 53 | messageSource.getMessage(m.code, m.args == null ? null : m.args.toArray(), locale) |
---|
| 54 | } |
---|
| 55 | |
---|
| 56 | def formatted = { Date d -> |
---|
| 57 | g.formatDate(format: "EEE, dd-MMM-yyyy", date: d) |
---|
| 58 | } |
---|
| 59 | |
---|
[503] | 60 | def startOfToday = dateUtilService.today |
---|
| 61 | def startOfYesterday = dateUtilService.yesterday |
---|
| 62 | def startOfTomorrow = dateUtilService.tomorrow |
---|
| 63 | def oneWeekAgo = dateUtilService.oneWeekAgo |
---|
[476] | 64 | |
---|
[713] | 65 | def formattedStartOfToday = formatted(startOfToday) |
---|
| 66 | def formattedStartOfYesterday = formatted(startOfYesterday) |
---|
| 67 | def formattedStartOfTomorrow = formatted(startOfTomorrow) |
---|
| 68 | def formattedOneWeekAgo = formatted(oneWeekAgo) |
---|
[503] | 69 | |
---|
[713] | 70 | def allTasks = { |
---|
| 71 | result.taskInstanceList = getTasks(params, result.startDate, result.endDate+1) |
---|
| 72 | if(result.taskInstanceList.totalCount > 0) { |
---|
| 73 | if(result.startDate == result.endDate) |
---|
| 74 | result.message = getMessage(code:"task.search.text.all.tasks.message", |
---|
| 75 | args:[ formatted(result.startDate) ]) |
---|
| 76 | else |
---|
| 77 | result.message = getMessage(code:"task.search.text.all.tasks.between.message", |
---|
| 78 | args:[ formatted(result.startDate), formatted(result.endDate) ]) |
---|
| 79 | } |
---|
| 80 | else { |
---|
| 81 | if(result.startDate == result.endDate) |
---|
| 82 | result.message = getMessage(code:"task.search.text.all.tasks.none.found", |
---|
| 83 | args:[ formatted(result.startDate) ]) |
---|
| 84 | else |
---|
| 85 | result.message = getMessage(code:"task.search.text.all.tasks.between.none.found", |
---|
| 86 | args:[ formatted(result.startDate), formatted(result.endDate) ]) |
---|
| 87 | } |
---|
| 88 | |
---|
[476] | 89 | } |
---|
| 90 | |
---|
[713] | 91 | def personsTasks = { |
---|
| 92 | result.taskInstanceList = getPersonsTasks(params, result.person, result.startDate, result.endDate+1) |
---|
| 93 | if(result.taskInstanceList.totalCount > 0) { |
---|
| 94 | if(result.startDate == result.endDate) |
---|
[503] | 95 | result.message = getMessage(code:"task.search.text.persons.tasks.message", |
---|
[713] | 96 | args:[ result.person, formatted(result.startDate) ]) |
---|
[476] | 97 | else |
---|
[713] | 98 | result.message = getMessage(code:"task.search.text.persons.tasks.between.message", |
---|
| 99 | args:[ result.person, formatted(result.startDate), formatted(result.endDate) ]) |
---|
| 100 | } |
---|
| 101 | else { |
---|
| 102 | if(result.startDate == result.endDate) |
---|
[503] | 103 | result.message = getMessage(code:"task.search.text.persons.tasks.none.found", |
---|
[713] | 104 | args:[ result.person, formatted(result.startDate) ]) |
---|
| 105 | else |
---|
| 106 | result.message = getMessage(code:"task.search.text.persons.tasks.between.none.found", |
---|
| 107 | args:[ result.person, formatted(result.startDate), formatted(result.endDate) ]) |
---|
| 108 | } |
---|
| 109 | |
---|
| 110 | } |
---|
| 111 | |
---|
| 112 | def personsImmediateCallouts = { |
---|
| 113 | result.taskInstanceList = getPersonsImmediateCallouts(params, result.person, result.startDate, result.endDate+1) |
---|
| 114 | if(result.taskInstanceList.totalCount > 0) { |
---|
| 115 | if(result.startDate == result.endDate) |
---|
| 116 | result.message = getMessage(code:"task.search.text.persons.immediate.callouts.message", |
---|
| 117 | args:[ result.person, formatted(result.startDate) ]) |
---|
| 118 | else |
---|
| 119 | result.message = getMessage(code:"task.search.text.persons.immediate.callouts.between.message", |
---|
| 120 | args:[ result.person, formatted(result.startDate), formatted(result.endDate) ]) |
---|
| 121 | } |
---|
| 122 | else { |
---|
| 123 | if(result.startDate == result.endDate) |
---|
| 124 | result.message = getMessage(code:"task.search.text.persons.immediate.callouts.none.found", |
---|
| 125 | args:[ result.person, formatted(result.startDate) ]) |
---|
| 126 | else |
---|
| 127 | result.message = getMessage(code:"task.search.text.persons.immediate.callouts.between.none.found", |
---|
| 128 | args:[ result.person, formatted(result.startDate), formatted(result.endDate) ]) |
---|
| 129 | } |
---|
| 130 | |
---|
| 131 | } |
---|
| 132 | |
---|
| 133 | switch (result.quickSearch) { |
---|
| 134 | case "myTodays": |
---|
| 135 | result.quickSearch = "personsTasks" |
---|
| 136 | result.startDate = startOfToday |
---|
| 137 | result.endDate = startOfToday |
---|
| 138 | personsTasks() |
---|
[476] | 139 | break |
---|
| 140 | case "myYesterdays": |
---|
[713] | 141 | result.quickSearch = "personsTasks" |
---|
| 142 | result.startDate = startOfYesterday |
---|
| 143 | result.endDate = startOfYesterday |
---|
| 144 | personsTasks() |
---|
[476] | 145 | break |
---|
| 146 | case "myTomorrows": |
---|
[713] | 147 | result.quickSearch = "personsTasks" |
---|
| 148 | result.startDate = startOfTomorrow |
---|
| 149 | result.endDate = startOfTomorrow |
---|
| 150 | personsTasks() |
---|
[476] | 151 | break |
---|
| 152 | case "myPastWeek": |
---|
[713] | 153 | result.quickSearch = "personsTasks" |
---|
| 154 | result.startDate = oneWeekAgo |
---|
| 155 | result.endDate = startOfToday |
---|
| 156 | personsTasks() |
---|
[476] | 157 | break |
---|
[713] | 158 | case "personsTasks": |
---|
| 159 | personsTasks() |
---|
| 160 | break |
---|
| 161 | case "personsImmediateCallouts": |
---|
| 162 | personsImmediateCallouts() |
---|
| 163 | break |
---|
[476] | 164 | case "todays": |
---|
[713] | 165 | result.quickSearch = "allTasks" |
---|
| 166 | result.startDate = startOfToday |
---|
| 167 | result.endDate = startOfToday |
---|
| 168 | allTasks() |
---|
[476] | 169 | break |
---|
| 170 | case "yesterdays": |
---|
[713] | 171 | result.quickSearch = "allTasks" |
---|
| 172 | result.startDate = startOfYesterday |
---|
| 173 | result.endDate = startOfToday |
---|
| 174 | allTasks() |
---|
[476] | 175 | break |
---|
| 176 | case "tomorrows": |
---|
[713] | 177 | result.quickSearch = "allTasks" |
---|
| 178 | result.startDate = startOfTomorrow |
---|
| 179 | result.endDate = startOfTomorrow+1 |
---|
| 180 | allTasks() |
---|
[476] | 181 | break |
---|
| 182 | case "pastWeek": |
---|
[713] | 183 | result.quickSearch = "allTasks" |
---|
| 184 | result.startDate = oneWeekAgo |
---|
| 185 | result.endDate = startOfTomorrow |
---|
| 186 | allTasks() |
---|
[476] | 187 | break |
---|
[713] | 188 | case "allTasks": |
---|
| 189 | allTasks() |
---|
| 190 | break |
---|
[476] | 191 | case "budgetUnplanned": |
---|
[713] | 192 | result.taskInstanceList = getBudgetTasks(params, TaskBudgetStatus.read(1), result.startDate, result.endDate+1) |
---|
| 193 | if(result.taskInstanceList.totalCount > 0) { |
---|
| 194 | if(result.startDate == result.endDate) |
---|
| 195 | result.message = getMessage(code:"task.search.text.budget.unplanned.message", |
---|
| 196 | args:[ formatted(result.startDate) ]) |
---|
| 197 | else |
---|
| 198 | result.message = getMessage(code:"task.search.text.budget.unplanned.between.message", |
---|
| 199 | args:[ formatted(result.startDate), formatted(result.endDate) ]) |
---|
| 200 | } |
---|
| 201 | else { |
---|
| 202 | if(result.startDate == result.endDate) |
---|
| 203 | result.message = getMessage(code:"task.search.text.budget.unplanned.none.found", |
---|
| 204 | args:[ formatted(result.startDate) ]) |
---|
| 205 | else |
---|
| 206 | result.message = getMessage(code:"task.search.text.budget.unplanned.between.none.found", |
---|
| 207 | args:[ formatted(result.startDate), formatted(result.endDate) ]) |
---|
| 208 | } |
---|
[476] | 209 | break |
---|
| 210 | case "budgetPlanned": |
---|
[713] | 211 | result.taskInstanceList = getBudgetTasks(params, TaskBudgetStatus.read(2), result.startDate, result.endDate+1) |
---|
| 212 | if(result.taskInstanceList.totalCount > 0) { |
---|
| 213 | if(result.startDate == result.endDate) |
---|
| 214 | result.message = getMessage(code:"task.search.text.budget.planned.message", |
---|
| 215 | args:[ formatted(result.startDate) ]) |
---|
| 216 | else |
---|
| 217 | result.message = getMessage(code:"task.search.text.budget.planned.between.message", |
---|
| 218 | args:[ formatted(result.startDate), formatted(result.endDate) ]) |
---|
| 219 | } |
---|
| 220 | else { |
---|
| 221 | if(result.startDate == result.endDate) |
---|
| 222 | result.message = getMessage(code:"task.search.text.budget.planned.none.found", |
---|
| 223 | args:[ formatted(result.startDate) ]) |
---|
| 224 | else |
---|
| 225 | result.message = getMessage(code:"task.search.text.budget.planned.between.none.found", |
---|
| 226 | args:[ formatted(result.startDate), formatted(result.endDate) ]) |
---|
| 227 | } |
---|
[476] | 228 | break |
---|
| 229 | default: |
---|
[503] | 230 | //case "plannersRange": |
---|
[713] | 231 | result.quickSearch = "allTasks" |
---|
| 232 | result.startDate = oneWeekAgo |
---|
| 233 | result.endDate = startOfToday+15 |
---|
| 234 | allTasks() |
---|
[476] | 235 | break |
---|
| 236 | } // switch. |
---|
| 237 | |
---|
| 238 | // Success. |
---|
| 239 | return result |
---|
| 240 | |
---|
| 241 | } // getQuickSearch |
---|
| 242 | |
---|
[479] | 243 | /** |
---|
[503] | 244 | * Get all tasks that are not in the trash bin, by default today's tasks. |
---|
[479] | 245 | * @param params The request params. |
---|
[503] | 246 | * @param startDate The start date to get tasks for, defaults to the start of today and is inclusive (greater than or equal to). |
---|
| 247 | * @param endDate The end date to get tasks for, defaults to the start of tomorrow and is exclusive (less than). |
---|
[479] | 248 | */ |
---|
[503] | 249 | def getTasks(params, startDate=null, endDate=null) { |
---|
[512] | 250 | def paginateParams = [:] |
---|
| 251 | paginateParams.max = Math.min(params?.max?.toInteger() ?: 10, paramsMax) |
---|
| 252 | paginateParams.offset = params?.offset?.toInteger() ?: 0 |
---|
[143] | 253 | |
---|
[582] | 254 | def orderBy = '' |
---|
| 255 | if(params.sort?.contains('.')) // protect against filterpane bug. |
---|
| 256 | params.sort = null |
---|
| 257 | if(params.sort && params.order) { |
---|
| 258 | def sort = "task." + params.sort |
---|
| 259 | def order = (params.order == "asc") ? "asc" : "desc" |
---|
| 260 | orderBy = " order by " + sort + ' ' + order |
---|
| 261 | } |
---|
| 262 | else |
---|
| 263 | orderBy = " order by task.taskStatus, task.taskPriority, task.targetStartDate" |
---|
[143] | 264 | |
---|
[512] | 265 | def namedParams = [:] |
---|
| 266 | namedParams.startDate = startDate ?: dateUtilService.today |
---|
| 267 | namedParams.endDate = endDate ?: dateUtilService.tomorrow |
---|
[144] | 268 | |
---|
[512] | 269 | def baseQuery = "from Task as task \ |
---|
| 270 | where (task.trash = false \ |
---|
| 271 | and task.targetStartDate < :endDate \ |
---|
| 272 | and task.targetCompletionDate >= :startDate \ |
---|
| 273 | )" |
---|
| 274 | |
---|
| 275 | def searchQuery = "select distinct task " + baseQuery + orderBy |
---|
| 276 | def list = Task.executeQuery(searchQuery, namedParams, paginateParams) |
---|
| 277 | |
---|
| 278 | def countQuery = "select count(distinct task) as taskCount " + baseQuery |
---|
| 279 | def totalCount = Task.executeQuery(countQuery, namedParams)[0].toInteger() |
---|
| 280 | |
---|
| 281 | def taskInstanceList = new PagedResultList(list, totalCount) |
---|
| 282 | return taskInstanceList |
---|
| 283 | } // getPTasks() |
---|
| 284 | |
---|
[479] | 285 | /** |
---|
[503] | 286 | * Get a person's tasks, by default current user and today's tasks. |
---|
| 287 | * "My tasks and approved tasks that I am assigned to" |
---|
[479] | 288 | * @param params The request params. |
---|
[503] | 289 | * @param person The person to get tasks for, defaults to current user. |
---|
| 290 | * @param startDate The start date to get tasks for, defaults to the start of today and is inclusive (greater than or equal to). |
---|
| 291 | * @param endDate The end date to get tasks for, defaults to the start of tomorrow and is exclusive (less than). |
---|
[479] | 292 | */ |
---|
[503] | 293 | def getPersonsTasks(params, person=null, startDate=null, endDate=null) { |
---|
[144] | 294 | |
---|
[713] | 295 | def max = Math.min(params?.max?.toInteger() ?: 10, paramsMax) |
---|
| 296 | def offset = params?.offset?.toInteger() ?: 0 |
---|
| 297 | |
---|
[582] | 298 | def orderBy = '' |
---|
| 299 | if(params.sort?.contains('.')) // protect against filterpane bug. |
---|
| 300 | params.sort = null |
---|
| 301 | if(params.sort && params.order) { |
---|
| 302 | def sort = "task." + params.sort |
---|
| 303 | def order = (params.order == "asc") ? "asc" : "desc" |
---|
[713] | 304 | orderBy = "by " + sort + ' ' + order |
---|
[582] | 305 | } |
---|
| 306 | else |
---|
[713] | 307 | orderBy = "by task.taskStatus, task.taskPriority, task.targetStartDate" |
---|
[476] | 308 | |
---|
[713] | 309 | def q = new HqlBuilder().query { |
---|
[165] | 310 | |
---|
[713] | 311 | select 'count(distinct task) as taskCount' |
---|
| 312 | from 'Task as task', |
---|
| 313 | 'left join task.assignedPersons as assignedPersonOfTask', |
---|
| 314 | 'left join assignedPersonOfTask.person as assignedPerson', |
---|
| 315 | 'left join task.assignedGroups as assignedGroupOfTask', |
---|
| 316 | 'left join assignedGroupOfTask.personGroup as personGroup', |
---|
| 317 | 'left join personGroup.persons as assignedPersonViaGroup', |
---|
| 318 | 'left join task.taskModifications as taskModification', |
---|
| 319 | 'left join taskModification.person as createdBy', |
---|
| 320 | 'left join taskModification.taskModificationType as taskModificationType' |
---|
| 321 | where 'task.trash = false' |
---|
| 322 | and 'task.targetStartDate < :endDate' |
---|
| 323 | and 'task.targetCompletionDate >= :startDate' |
---|
| 324 | if(!params.includeCompleted) { |
---|
| 325 | and 'task.taskStatus.id != 3' // Complete. |
---|
| 326 | } |
---|
| 327 | and { |
---|
| 328 | where '(taskModificationType.id = 1 and createdBy = :person and task.leadPerson = :person)' // Created. |
---|
| 329 | or '(task.approved = true and (task.leadPerson = :person or assignedPerson = :person or assignedPersonViaGroup = :person))' |
---|
| 330 | } |
---|
| 331 | } |
---|
[479] | 332 | |
---|
[713] | 333 | q.namedParams.person = person ?: authService.currentUser |
---|
| 334 | q.namedParams.startDate = startDate ?: dateUtilService.today |
---|
| 335 | q.namedParams.endDate = endDate ?: dateUtilService.tomorrow |
---|
[479] | 336 | |
---|
[713] | 337 | def totalCount = Task.executeQuery(q.query, q.namedParams)[0].toInteger() |
---|
[479] | 338 | |
---|
[713] | 339 | q.select = "distinct task" |
---|
| 340 | q.order = orderBy |
---|
| 341 | def list = Task.executeQuery(q.query, q.namedParams, q.paginateParams) |
---|
| 342 | |
---|
[479] | 343 | def taskInstanceList = new PagedResultList(list, totalCount) |
---|
| 344 | return taskInstanceList |
---|
[503] | 345 | } // getPersonsTasks() |
---|
[479] | 346 | |
---|
| 347 | /** |
---|
[713] | 348 | * Get a person's immediateCallout tasks, by default all users and today's tasks. |
---|
| 349 | * @param params The request params. |
---|
| 350 | * @param person The person to get tasks for, defaults to null and therefore all immediateCallouts. |
---|
| 351 | * @param startDate The start date to get tasks for, defaults to the start of today and is inclusive (greater than or equal to). |
---|
| 352 | * @param endDate The end date to get tasks for, defaults to the start of tomorrow and is exclusive (less than). |
---|
| 353 | */ |
---|
| 354 | def getPersonsImmediateCallouts(params, person=null, startDate=null, endDate=null) { |
---|
| 355 | |
---|
| 356 | def max = Math.min(params?.max?.toInteger() ?: 10, paramsMax) |
---|
| 357 | def offset = params?.offset?.toInteger() ?: 0 |
---|
| 358 | |
---|
| 359 | def orderBy = '' |
---|
| 360 | if(params.sort?.contains('.')) // protect against filterpane bug. |
---|
| 361 | params.sort = null |
---|
| 362 | if(params.sort && params.order) { |
---|
| 363 | def sort = "task." + params.sort |
---|
| 364 | def order = (params.order == "asc") ? "asc" : "desc" |
---|
| 365 | orderBy = "by " + sort + ' ' + order |
---|
| 366 | } |
---|
| 367 | else |
---|
| 368 | orderBy = "by task.taskStatus, task.taskPriority, task.targetStartDate" |
---|
| 369 | |
---|
| 370 | def q = new HqlBuilder().query { |
---|
| 371 | |
---|
| 372 | select 'count(distinct task) as taskCount' |
---|
| 373 | from 'Task as task', |
---|
| 374 | 'left join task.taskModifications as taskModification', |
---|
| 375 | 'left join taskModification.person as createdBy', |
---|
| 376 | 'left join taskModification.taskModificationType as taskModificationType' |
---|
| 377 | where 'task.taskType.id = 1' // Immediate Callout. |
---|
| 378 | and 'task.targetStartDate < :endDate' |
---|
| 379 | and 'task.targetCompletionDate >= :startDate' |
---|
| 380 | if(!params.includeCompleted) { |
---|
| 381 | and 'task.taskStatus.id != 3' // Complete. |
---|
| 382 | } |
---|
| 383 | if(person) { |
---|
| 384 | namedParams.person = person |
---|
| 385 | and '( (taskModificationType.id = 1 and createdBy = :person) or task.leadPerson = :person)' // Created or Lead Person. |
---|
| 386 | } |
---|
| 387 | and 'task.trash = false' |
---|
| 388 | } |
---|
| 389 | |
---|
| 390 | q.namedParams.startDate = startDate ?: dateUtilService.today |
---|
| 391 | q.namedParams.endDate = endDate ?: dateUtilService.tomorrow |
---|
| 392 | |
---|
| 393 | def totalCount = Task.executeQuery(q.query, q.namedParams)[0].toInteger() |
---|
| 394 | |
---|
| 395 | q.select = "distinct task" |
---|
| 396 | q.order = orderBy |
---|
| 397 | def list = Task.executeQuery(q.query, q.namedParams, q.paginateParams) |
---|
| 398 | |
---|
| 399 | def taskInstanceList = new PagedResultList(list, totalCount) |
---|
| 400 | return taskInstanceList |
---|
| 401 | } // getPersonsImmediateCallouts() |
---|
| 402 | |
---|
| 403 | /** |
---|
[503] | 404 | * Get tasks by budget status, by default planned in the last week. |
---|
[479] | 405 | * @param params The request params. |
---|
[503] | 406 | * @param budgetStatus Defaults to planned. |
---|
| 407 | * @param startDate The start date to get tasks for, defaults to the start of today and is inclusive (greater than or equal to). |
---|
| 408 | * @param endDate The end date to get tasks for, defaults to the start of tomorrow and is exclusive (less than). |
---|
[479] | 409 | */ |
---|
[529] | 410 | def getBudgetTasks(params, taskBudgetStatus=null, startDate=null, endDate=null) { |
---|
[524] | 411 | def paginateParams = [:] |
---|
| 412 | paginateParams.max = Math.min(params?.max?.toInteger() ?: 10, paramsMax) |
---|
| 413 | paginateParams.offset = params?.offset?.toInteger() ?: 0 |
---|
[165] | 414 | |
---|
[524] | 415 | def sort = "task." + (params?.sort ?: "targetStartDate") |
---|
| 416 | def order = params?.order == "desc" ? "desc" : "asc" |
---|
| 417 | def orderBy = " order by " + sort + ' ' + order |
---|
[165] | 418 | |
---|
[524] | 419 | def namedParams = [:] |
---|
[529] | 420 | namedParams.taskBudgetStatus = taskBudgetStatus ?: TaskBudgetStatus.read(2) // Planned. |
---|
[524] | 421 | namedParams.startDate = startDate ?: dateUtilService.today |
---|
[529] | 422 | namedParams.endDate = endDate ?: dateUtilService.tomorrow |
---|
[524] | 423 | |
---|
| 424 | def baseQuery = "from Task as task \ |
---|
| 425 | where (task.trash = false \ |
---|
[529] | 426 | and task.taskBudgetStatus = :taskBudgetStatus \ |
---|
[524] | 427 | and task.targetStartDate < :endDate \ |
---|
| 428 | and task.targetCompletionDate >= :startDate \ |
---|
| 429 | )" |
---|
| 430 | |
---|
| 431 | def searchQuery = "select distinct task " + baseQuery + orderBy |
---|
| 432 | def list = Task.executeQuery(searchQuery, namedParams, paginateParams) |
---|
| 433 | |
---|
| 434 | def countQuery = "select count(distinct task) as taskCount " + baseQuery |
---|
| 435 | def totalCount = Task.executeQuery(countQuery, namedParams)[0].toInteger() |
---|
| 436 | |
---|
| 437 | def taskInstanceList = new PagedResultList(list, totalCount) |
---|
| 438 | return taskInstanceList |
---|
[503] | 439 | } // getBudgetTasks() |
---|
[476] | 440 | |
---|
[479] | 441 | /** |
---|
[490] | 442 | * Get work done by person and date. |
---|
[503] | 443 | * A person ID and date may be specified in params otherwise the current user and today are used. |
---|
[490] | 444 | * @param params The request params. |
---|
| 445 | * @returns A map containing entries, totalEntries, startOfDay, person, totalHours, totalMinutes. |
---|
| 446 | */ |
---|
| 447 | def getWorkDone(params, locale) { |
---|
| 448 | def result = [:] |
---|
| 449 | result.person = params.person?.id ? Person.get(params.person.id.toInteger()) : authService.currentUser |
---|
| 450 | |
---|
| 451 | if(params.date_year && params.date_month && params.date_day) |
---|
| 452 | result.startOfDay = dateUtilService.makeDate(params.date_year, params.date_month, params.date_day) |
---|
| 453 | else |
---|
| 454 | result.startOfDay = dateUtilService.today |
---|
| 455 | |
---|
| 456 | result.startOfNextDay = result.startOfDay + 1 |
---|
| 457 | |
---|
| 458 | def formattedStartOfDay = g.formatDate(format: "EEE, dd-MMM-yyyy", date: result.startOfDay) |
---|
| 459 | |
---|
| 460 | def getMessage = { Map m -> |
---|
| 461 | messageSource.getMessage(m.code, m.args == null ? null : m.args.toArray(), locale) |
---|
| 462 | } |
---|
| 463 | |
---|
| 464 | result.entries = Entry.createCriteria().list() { |
---|
| 465 | eq("enteredBy", result.person) |
---|
| 466 | ge("dateDone", result.startOfDay) |
---|
| 467 | lt("dateDone", result.startOfNextDay) |
---|
| 468 | entryType { |
---|
| 469 | eq("id", 3L) |
---|
| 470 | } |
---|
| 471 | } // createCriteria |
---|
| 472 | |
---|
| 473 | result.totalEntries = result.entries.size() |
---|
| 474 | |
---|
| 475 | if(result.totalEntries > 0) |
---|
| 476 | result.message = getMessage(code:"task.search.text.work.done.message", |
---|
| 477 | args:[result.person, formattedStartOfDay]) |
---|
| 478 | else |
---|
| 479 | result.message = getMessage(code:"task.search.text.work.done.none.found", |
---|
| 480 | args:[result.person, formattedStartOfDay]) |
---|
| 481 | |
---|
| 482 | result.totalHours = 0 |
---|
| 483 | result.totalMinutes = 0 |
---|
| 484 | result.entries.each() { |
---|
| 485 | result.totalMinutes += (it.durationHour*60) + it.durationMinute |
---|
| 486 | } |
---|
| 487 | result.totalHours = (result.totalMinutes / 60).toInteger() |
---|
| 488 | result.totalMinutes = result.totalMinutes % 60 |
---|
| 489 | |
---|
| 490 | return result |
---|
[503] | 491 | } // getWorkDone() |
---|
[490] | 492 | |
---|
[701] | 493 | /** |
---|
| 494 | * Get work load by task group and date. |
---|
| 495 | * Group ID's and date range may be specified in params otherwise no group and today are used. |
---|
| 496 | * @param params The request params. |
---|
| 497 | * @returns A map containing the results. |
---|
| 498 | */ |
---|
| 499 | def getWorkLoad(params, locale) { |
---|
| 500 | def result = [:] |
---|
| 501 | def max = 1000 |
---|
| 502 | |
---|
| 503 | // TaskStatus.. |
---|
| 504 | result.taskStatusList = [] |
---|
| 505 | if(params.taskStatusList instanceof String) |
---|
| 506 | result.taskStatusList << TaskStatus.get(params.taskStatusList.toInteger()) |
---|
| 507 | else if(params.taskStatusList) |
---|
| 508 | result.taskStatusList = TaskStatus.getAll( params.taskStatusList.collect {it.toInteger()} ) |
---|
| 509 | |
---|
| 510 | // TaskGroups. |
---|
| 511 | result.taskGroups = [] |
---|
| 512 | if(params.taskGroups instanceof String) |
---|
| 513 | result.taskGroups << TaskGroup.get(params.taskGroups.toInteger()) |
---|
| 514 | else if(params.taskGroups) |
---|
| 515 | result.taskGroups = TaskGroup.getAll( params.taskGroups.collect {it.toInteger()} ) |
---|
| 516 | |
---|
| 517 | // Start Date. |
---|
| 518 | if(params.startDate_year && params.startDate_month && params.startDate_day) |
---|
| 519 | result.startDate = dateUtilService.makeDate(params.startDate_year, params.startDate_month, params.startDate_day) |
---|
| 520 | else |
---|
| 521 | result.startDate = dateUtilService.today |
---|
| 522 | |
---|
| 523 | // End Date. |
---|
| 524 | if(params.endDate_year && params.endDate_month && params.endDate_day) |
---|
| 525 | result.endDate = dateUtilService.makeDate(params.endDate_year, params.endDate_month, params.endDate_day) |
---|
| 526 | else |
---|
| 527 | result.endDate = result.startDate |
---|
| 528 | |
---|
| 529 | // Normalise date range. |
---|
| 530 | if(result.endDate < result.startDate) |
---|
| 531 | result.endDate = result.startDate |
---|
| 532 | |
---|
| 533 | def formattedStartDate = g.formatDate(format: "EEE, dd-MMM-yyyy", date: result.startDate) |
---|
| 534 | def formattedEndDate = g.formatDate(format: "EEE, dd-MMM-yyyy", date: result.endDate) |
---|
| 535 | |
---|
| 536 | def getMessage = { Map m -> |
---|
| 537 | messageSource.getMessage(m.code, m.args == null ? null : m.args.toArray(), locale) |
---|
| 538 | } |
---|
| 539 | |
---|
| 540 | result.tasks = new PagedResultList([], 0) |
---|
| 541 | |
---|
| 542 | if(result.taskGroups && result.taskStatusList) { |
---|
| 543 | |
---|
| 544 | result.tasks = Task.createCriteria().list(max: max) { |
---|
| 545 | eq("trash", false) |
---|
| 546 | lt("targetStartDate", result.endDate+1) |
---|
| 547 | ge("targetCompletionDate", result.startDate) |
---|
| 548 | inList("taskStatus", result.taskStatusList) |
---|
| 549 | inList("taskGroup", result.taskGroups) |
---|
| 550 | order("taskStatus", "asc") |
---|
| 551 | order("taskPriority", "asc") |
---|
| 552 | order("targetStartDate", "asc") |
---|
| 553 | fetchMode("assignedGroups", FM.EAGER) |
---|
| 554 | fetchMode("assignedGroups.personGroup", FM.EAGER) |
---|
| 555 | } // createCriteria |
---|
| 556 | |
---|
| 557 | } |
---|
| 558 | |
---|
| 559 | result.tasks.list.unique() |
---|
| 560 | result.totalHours = 0 |
---|
| 561 | result.totalMinutes = 0 |
---|
| 562 | result.workLoadGroups = [:] |
---|
| 563 | |
---|
| 564 | // Exit early! |
---|
| 565 | if(result.tasks.totalCount > result.tasks.size()) { |
---|
| 566 | result.errorMessage = getMessage(code:"task.search.text.work.load.too.many.results", |
---|
| 567 | args:[result.tasks.size(), result.tasks.totalCount]) |
---|
| 568 | return result |
---|
| 569 | } |
---|
| 570 | else if(result.tasks.size() > 0) |
---|
| 571 | result.message = getMessage(code:"task.search.text.work.load.message", |
---|
| 572 | args:[formattedStartDate, formattedEndDate]) |
---|
| 573 | else |
---|
| 574 | result.message = getMessage(code:"task.search.text.work.load.none.found", |
---|
| 575 | args:[formattedStartDate, formattedEndDate]) |
---|
| 576 | |
---|
| 577 | // Collect all assignedGroups. |
---|
| 578 | def assignedGroups = [] |
---|
| 579 | for(task in result.tasks) { |
---|
| 580 | for(assignedGroup in task.assignedGroups) { |
---|
| 581 | assignedGroups << assignedGroup |
---|
| 582 | } |
---|
| 583 | } |
---|
| 584 | |
---|
| 585 | // Calculate work load for each personGroup and minute totals. |
---|
| 586 | def tempHours = 0 |
---|
| 587 | def tempMinutes = 0 |
---|
| 588 | def personGroup |
---|
| 589 | for(assignedGroup in assignedGroups) { |
---|
| 590 | personGroup = assignedGroup.personGroup |
---|
| 591 | if(!result.workLoadGroups.containsKey(personGroup)) { |
---|
| 592 | result.workLoadGroups[personGroup] = [hours: 0, minutes: 0] |
---|
| 593 | } |
---|
| 594 | |
---|
| 595 | tempMinutes = (assignedGroup.estimatedHour*60) + assignedGroup.estimatedMinute |
---|
| 596 | result.totalMinutes += tempMinutes |
---|
| 597 | result.workLoadGroups[personGroup].minutes += tempMinutes |
---|
| 598 | } |
---|
| 599 | |
---|
| 600 | // Resolve totals and sort. |
---|
| 601 | result.workLoadGroups.each { workLoadGroup -> |
---|
| 602 | workLoadGroup.value.hours = (workLoadGroup.value.minutes / 60).toInteger() |
---|
| 603 | workLoadGroup.value.minutes = workLoadGroup.value.minutes % 60 |
---|
| 604 | } |
---|
| 605 | result.workLoadGroups = result.workLoadGroups.sort { p1, p2 -> p1.key.name.compareToIgnoreCase(p2.key.name) } |
---|
| 606 | result.totalHours = (result.totalMinutes / 60).toInteger() |
---|
| 607 | result.totalMinutes = result.totalMinutes % 60 |
---|
| 608 | |
---|
| 609 | // Success. |
---|
| 610 | return result |
---|
| 611 | } // getWorkLoad() |
---|
| 612 | |
---|
[490] | 613 | } // end class |
---|