source: trunk/grails-app/services/TaskSearchService.groovy @ 835

Last change on this file since 835 was 835, checked in by gav, 9 years ago

Fix missing max and offset in TaskSearchService for person's tasks.

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