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

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

Adjust TaskSearchService.getPersonsTasks() so that if a person created it and is leadPerson then that task is returned.
Started on integration tests for TaskSearchService.
File size: 17.2 KB
Line 
1import grails.orm.PagedResultList
2
3/**
4* Service class that encapsulates the business logic for Task searches.
5*/
6class TaskSearchService {
7
8    boolean transactional = false
9
10    def authService
11    def dateUtilService
12    def messageSource
13
14    def g = new org.codehaus.groovy.grails.plugins.web.taglib.ApplicationTagLib()
15
16    def paramsMax = 100000
17
18    /**
19    * Selects and returns the correct search results based on the supplied quickSearch.
20    * @param params The request params, may contain params.quickSearch string to specify the search.
21    * @param locale The locale to use when generating result.message.
22    */
23    def getQuickSearch(params, locale) {
24        def result = [:]
25        result.quickSearch = params.quickSearch ?: "plannersRange"
26
27        def currentUser = authService.currentUser
28        def startOfToday = dateUtilService.today
29        def startOfYesterday = dateUtilService.yesterday
30        def startOfTomorrow = dateUtilService.tomorrow
31        def oneWeekAgo = dateUtilService.oneWeekAgo
32
33        def formattedStartOfToday = g.formatDate(format: "EEE, dd-MMM-yyyy", date: startOfToday)
34        def formattedStartOfYesterday = g.formatDate(format: "EEE, dd-MMM-yyyy", date: startOfYesterday)
35        def formattedStartOfTomorrow = g.formatDate(format: "EEE, dd-MMM-yyyy", date: startOfTomorrow)
36        def formattedOneWeekAgo = g.formatDate(format: "EEE, dd-MMM-yyyy", date: oneWeekAgo)
37
38        def getMessage = { Map m ->
39            messageSource.getMessage(m.code, m.args == null ? null : m.args.toArray(), locale)
40        }
41
42        switch (result.quickSearch) {
43            case "myTodays":
44                result.taskInstanceList = getPersonsTasks(params)
45                if(result.taskInstanceList.totalCount > 0)
46                    result.message = getMessage(code:"task.search.text.persons.tasks.message",
47                                                                    args:[currentUser, formattedStartOfToday])
48                else
49                    result.message = getMessage(code:"task.search.text.persons.tasks.none.found",
50                                                                    args:[currentUser, formattedStartOfToday])
51                break
52            case "myYesterdays":
53                result.taskInstanceList = getPersonsTasks(params, currentUser, startOfYesterday, startOfToday)
54                if(result.taskInstanceList.totalCount > 0)
55                    result.message = getMessage(code:"task.search.text.persons.tasks.message",
56                                                                    args:[currentUser, formattedStartOfYesterday])
57                else
58                    result.message = getMessage(code:"task.search.text.persons.tasks.none.found",
59                                                                    args:[currentUser, formattedStartOfYesterday])
60                break
61            case "myTomorrows":
62                result.taskInstanceList = getPersonsTasks(params, currentUser, startOfTomorrow, startOfTomorrow+1)
63                if(result.taskInstanceList.totalCount > 0)
64                    result.message = getMessage(code:"task.search.text.persons.tasks.message",
65                                                                    args:[currentUser, formattedStartOfTomorrow])
66                else
67                    result.message = getMessage(code:"task.search.text.persons.tasks.none.found",
68                                                                    args:[currentUser, formattedStartOfTomorrow])
69                break
70            case "myPastWeek":
71                result.taskInstanceList = getPersonsTasks(params, currentUser, oneWeekAgo, startOfTomorrow)
72                if(result.taskInstanceList.totalCount > 0)
73                    result.message = getMessage(code:"task.search.text.persons.tasks.between.message",
74                                                                    args:[currentUser, formattedOneWeekAgo, formattedStartOfToday])
75                else
76                    result.message = getMessage(code:"task.search.text.persons.tasks.between.none.found",
77                                                                    args:[currentUser, formattedOneWeekAgo, formattedStartOfToday])
78                break
79            case "todays":
80                result.taskInstanceList = getTasks(params)
81                if(result.taskInstanceList.totalCount > 0)
82                    result.message = getMessage(code:"task.search.text.all.tasks.message",
83                                                                    args:[formattedStartOfToday])
84                else
85                    result.message = getMessage(code:"task.search.text.all.tasks.none.found",
86                                                                    args:[formattedStartOfToday])
87                break
88            case "yesterdays":
89                result.taskInstanceList = getTasks(params, startOfYesterday, startOfToday)
90                if(result.taskInstanceList.totalCount > 0)
91                    result.message = getMessage(code:"task.search.text.all.tasks.message",
92                                                                    args:[formattedStartOfYesterday])
93                else
94                    result.message = getMessage(code:"task.search.text.all.tasks.none.found",
95                                                                    args:[formattedStartOfYesterday])
96                break
97            case "tomorrows":
98                result.taskInstanceList = getTasks(params, startOfTomorrow, startOfTomorrow+1)
99                if(result.taskInstanceList.totalCount > 0)
100                    result.message = getMessage(code:"task.search.text.all.tasks.message",
101                                                                    args:[formattedStartOfTomorrow])
102                else
103                    result.message = getMessage(code:"task.search.text.all.tasks.none.found",
104                                                                    args:[formattedStartOfTomorrow])
105                break
106            case "pastWeek":
107                result.taskInstanceList = getTasks(params, oneWeekAgo, startOfTomorrow)
108                if(result.taskInstanceList.totalCount > 0)
109                    result.message = getMessage(code:"task.search.text.all.tasks.between.message",
110                                                                    args:[formattedOneWeekAgo, formattedStartOfToday])
111                else
112                    result.message = getMessage(code:"task.search.text.all.tasks.between.none.found",
113                                                                    args:[formattedOneWeekAgo, formattedStartOfToday])
114                break
115            case "budgetUnplanned":
116                result.taskInstanceList = getBudgetTasks(params, TaskBudgetStatus.read(1), oneWeekAgo, startOfTomorrow)
117                if(result.taskInstanceList.totalCount > 0)
118                    result.message = getMessage(code:"task.search.text.budget.unplanned.message",
119                                                                    args:[formattedOneWeekAgo, formattedStartOfToday])
120                else
121                    result.message = getMessage(code:"task.search.text.budget.unplanned.none.found",
122                                                                    args:[formattedOneWeekAgo, formattedStartOfToday])
123                break
124            case "budgetPlanned":
125                result.taskInstanceList = getBudgetTasks(params, TaskBudgetStatus.read(2), oneWeekAgo, startOfTomorrow)
126                if(result.taskInstanceList.totalCount > 0)
127                    result.message = getMessage(code:"task.search.text.budget.planned.message",
128                                                                    args:[formattedOneWeekAgo, formattedStartOfToday])
129                else
130                    result.message = getMessage(code:"task.search.text.budget.planned.none.found",
131                                                                    args:[formattedOneWeekAgo, formattedStartOfToday])
132                break
133            default:
134                //case "plannersRange":
135                result.taskInstanceList = getTasks(params, oneWeekAgo, startOfToday+15)
136                if(result.taskInstanceList.totalCount > 0)
137                    result.message = getMessage(code:"task.search.text.all.tasks.between.message",
138                                                                    args:[formattedOneWeekAgo,
139                                                                            g.formatDate(format: "EEE, dd-MMM-yyyy", date: startOfToday+14)])
140                else
141                    result.message = getMessage(code:"task.search.text.all.tasks.between.none.found",
142                                                                    args:[formattedOneWeekAgo,
143                                                                            g.formatDate(format: "EEE, dd-MMM-yyyy", date: startOfToday+14)])
144                break
145        } // switch.
146
147        // Success.
148        return result
149
150    } // getQuickSearch
151
152    /**
153    * Get all tasks that are not in the trash bin, by default today's tasks.
154    * @param params The request params.
155    * @param startDate The start date to get tasks for, defaults to the start of today and is inclusive (greater than or equal to).
156    * @param endDate The end date to get tasks for, defaults to the start of tomorrow and is exclusive (less than).
157    */
158    def getTasks(params, startDate=null, endDate=null) {
159        params.max = Math.min(params?.max?.toInteger() ?: 10, paramsMax)
160        params.offset = params?.offset?.toInteger() ?: 0
161        params.sort = params?.sort ?: "attentionFlag"
162        params.order = params?.order ?: "desc"
163
164        startDate = startDate ?: dateUtilService.today
165        endDate = endDate ?: dateUtilService.tomorrow
166
167        def taskInstanceList = Task.createCriteria().list(
168            max: params.max,
169            offset: params.offset,
170            sort: params.sort, 
171            order: params.order) {
172                lt("targetStartDate", endDate)
173                ge("targetCompletionDate", startDate)
174                eq("trash", false)
175            } // createCriteria
176    } // getTasks()
177
178    /**
179    * Get a person's tasks, by default current user and today's tasks.
180    * "My tasks and approved tasks that I am assigned to"
181    * @param params The request params.
182    * @param person The person to get tasks for, defaults to current user.
183    * @param startDate The start date to get tasks for, defaults to the start of today and is inclusive (greater than or equal to).
184    * @param endDate The end date to get tasks for, defaults to the start of tomorrow and is exclusive (less than).
185    */
186    def getPersonsTasks(params, person=null, startDate=null, endDate=null) {
187        def paginateParams = [:]
188        paginateParams.max = Math.min(params?.max?.toInteger() ?: 10, paramsMax)
189        paginateParams.offset = params?.offset?.toInteger() ?: 0
190
191        def sort = "task." + (params?.sort ?: "attentionFlag")
192        def order = params?.order == "asc" ? "asc" : "desc"
193        def orderBy = " order by " + sort + ' ' + order
194
195        def namedParams = [:]
196        namedParams.person = person ?: authService.currentUser
197        namedParams.startDate = startDate ?: dateUtilService.today
198        namedParams.endDate = endDate ?: dateUtilService.tomorrow
199
200        def baseQuery = "from Task as task \
201                                        left join task.assignedPersons as assignedPersonOfTask \
202                                        left join assignedPersonOfTask.person as assignedPerson \
203                                        left join task.assignedGroups as assignedGroupOfTask \
204                                        left join assignedGroupOfTask.personGroup as personGroup \
205                                        left join personGroup.persons as assignedPersonViaGroup \
206                                        left join task.taskModifications as taskModification \
207                                        left join taskModification.person as createdBy \
208                                        left join taskModification.taskModificationType as taskModificationType \
209                                        where (task.trash = false \
210                                                    and task.targetStartDate < :endDate \
211                                                    and task.targetCompletionDate >= :startDate \
212                                                    and ( \
213                                                        (taskModificationType.id = 1 \
214                                                        and createdBy = :person \
215                                                        and task.leadPerson = :person) \
216                                                        or ( \
217                                                            task.approved = true \
218                                                            and ( \
219                                                                task.leadPerson = :person \
220                                                                or assignedPerson = :person \
221                                                                or assignedPersonViaGroup = :person \
222                                                            ) \
223                                                        ) \
224                                                    ) \
225                                        )"
226
227        def searchQuery = "select distinct task " + baseQuery + orderBy
228        def list = Task.executeQuery(searchQuery, namedParams, paginateParams)
229
230        def countQuery = "select count(distinct task) as taskCount " + baseQuery
231        def totalCount = Task.executeQuery(countQuery, namedParams)[0].toInteger()
232
233        def taskInstanceList = new PagedResultList(list, totalCount)
234        return taskInstanceList
235    } // getPersonsTasks()
236
237    /**
238    * Get tasks by budget status, by default planned in the last week.
239    * @param params The request params.
240    * @param budgetStatus Defaults to planned.
241    * @param startDate The start date to get tasks for, defaults to the start of today and is inclusive (greater than or equal to).
242    * @param endDate The end date to get tasks for, defaults to the start of tomorrow and is exclusive (less than).
243    */
244    def getBudgetTasks(params, budgetStatus=null, startDate=null, endDate=null) {
245        params.max = Math.min(params?.max?.toInteger() ?: 10, paramsMax)
246        params.offset = params?.offset?.toInteger() ?: 0
247        params.sort = params?.sort ?: "targetStartDate"
248        params.order = params?.order ?: "asc"
249
250        budgetStatus = budgetStatus ?: TaskBudgetStatus.read(2) // Planned.
251        startDate = startDate ?: dateUtilService.today
252        endDate = endDate ?: dateUtilService.tomorrow
253
254        def taskInstanceList = Task.createCriteria().list(
255            max: params.max,
256            offset: params.offset,
257            sort: params.sort,
258            order: params.order) {
259                eq("taskBudgetStatus", budgetStatus)
260                lt("targetStartDate", dateUtilService.tomorrow)
261                ge("targetCompletionDate", dateUtilService.oneWeekAgo)
262                eq("trash", false)
263            } // createCriteria
264    } // getBudgetTasks()
265
266    /**
267    * Get work done by person and date.
268    * A person ID and date may be specified in params otherwise the current user and today are used.
269    * @param params The request params.
270    * @returns A map containing entries, totalEntries, startOfDay, person, totalHours, totalMinutes.
271    */
272    def getWorkDone(params, locale) {
273        def result = [:]
274        result.person = params.person?.id ? Person.get(params.person.id.toInteger()) : authService.currentUser
275
276        if(params.date_year && params.date_month && params.date_day)
277            result.startOfDay = dateUtilService.makeDate(params.date_year, params.date_month, params.date_day)
278        else
279            result.startOfDay = dateUtilService.today
280
281        result.startOfNextDay = result.startOfDay + 1
282
283        def formattedStartOfDay = g.formatDate(format: "EEE, dd-MMM-yyyy", date: result.startOfDay)
284
285        def getMessage = { Map m ->
286            messageSource.getMessage(m.code, m.args == null ? null : m.args.toArray(), locale)
287        }
288
289        result.entries = Entry.createCriteria().list() {
290            eq("enteredBy", result.person)
291            ge("dateDone", result.startOfDay)
292            lt("dateDone", result.startOfNextDay)
293            entryType {
294                eq("id", 3L)
295            }
296        } // createCriteria
297
298        result.totalEntries = result.entries.size()
299
300        if(result.totalEntries > 0)
301            result.message = getMessage(code:"task.search.text.work.done.message",
302                                                                args:[result.person, formattedStartOfDay])
303        else
304            result.message = getMessage(code:"task.search.text.work.done.none.found",
305                                                                args:[result.person, formattedStartOfDay])
306
307        result.totalHours = 0
308        result.totalMinutes = 0
309        result.entries.each() {
310            result.totalMinutes += (it.durationHour*60) + it.durationMinute
311        }
312        result.totalHours = (result.totalMinutes / 60).toInteger()
313        result.totalMinutes = result.totalMinutes % 60
314
315        return result
316    } // getWorkDone()
317
318} // end class
Note: See TracBrowser for help on using the repository browser.