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

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

Refactor TaskSearchService and associated messages.
File size: 16.5 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                                        where (task.trash = false \
207                                                    and task.approved = true \
208                                                    and ( \
209                                                            task.targetStartDate < :endDate \
210                                                            and task.targetCompletionDate >= :startDate \
211                                                        ) \
212                                                    and ( \
213                                                            task.leadPerson = :person \
214                                                            or assignedPerson = :person \
215                                                            or assignedPersonViaGroup = :person \
216                                                            ) \
217                                                    )"
218
219        def searchQuery = "select distinct task " + baseQuery + orderBy
220        def list = Task.executeQuery(searchQuery, namedParams, paginateParams)
221
222        def countQuery = "select count(distinct task) as taskCount " + baseQuery
223        def totalCount = Task.executeQuery(countQuery, namedParams)[0].toInteger()
224
225        def taskInstanceList = new PagedResultList(list, totalCount)
226        return taskInstanceList
227    } // getPersonsTasks()
228
229    /**
230    * Get tasks by budget status, by default planned in the last week.
231    * @param params The request params.
232    * @param budgetStatus Defaults to planned.
233    * @param startDate The start date to get tasks for, defaults to the start of today and is inclusive (greater than or equal to).
234    * @param endDate The end date to get tasks for, defaults to the start of tomorrow and is exclusive (less than).
235    */
236    def getBudgetTasks(params, budgetStatus=null, startDate=null, endDate=null) {
237        params.max = Math.min(params?.max?.toInteger() ?: 10, paramsMax)
238        params.offset = params?.offset?.toInteger() ?: 0
239        params.sort = params?.sort ?: "targetStartDate"
240        params.order = params?.order ?: "asc"
241
242        budgetStatus = budgetStatus ?: TaskBudgetStatus.read(2) // Planned.
243        startDate = startDate ?: dateUtilService.today
244        endDate = endDate ?: dateUtilService.tomorrow
245
246        def taskInstanceList = Task.createCriteria().list(
247            max: params.max,
248            offset: params.offset,
249            sort: params.sort,
250            order: params.order) {
251                eq("taskBudgetStatus", budgetStatus)
252                lt("targetStartDate", dateUtilService.tomorrow)
253                ge("targetCompletionDate", dateUtilService.oneWeekAgo)
254                eq("trash", false)
255            } // createCriteria
256    } // getBudgetTasks()
257
258    /**
259    * Get work done by person and date.
260    * A person ID and date may be specified in params otherwise the current user and today are used.
261    * @param params The request params.
262    * @returns A map containing entries, totalEntries, startOfDay, person, totalHours, totalMinutes.
263    */
264    def getWorkDone(params, locale) {
265        def result = [:]
266        result.person = params.person?.id ? Person.get(params.person.id.toInteger()) : authService.currentUser
267
268        if(params.date_year && params.date_month && params.date_day)
269            result.startOfDay = dateUtilService.makeDate(params.date_year, params.date_month, params.date_day)
270        else
271            result.startOfDay = dateUtilService.today
272
273        result.startOfNextDay = result.startOfDay + 1
274
275        def formattedStartOfDay = g.formatDate(format: "EEE, dd-MMM-yyyy", date: result.startOfDay)
276
277        def getMessage = { Map m ->
278            messageSource.getMessage(m.code, m.args == null ? null : m.args.toArray(), locale)
279        }
280
281        result.entries = Entry.createCriteria().list() {
282            eq("enteredBy", result.person)
283            ge("dateDone", result.startOfDay)
284            lt("dateDone", result.startOfNextDay)
285            entryType {
286                eq("id", 3L)
287            }
288        } // createCriteria
289
290        result.totalEntries = result.entries.size()
291
292        if(result.totalEntries > 0)
293            result.message = getMessage(code:"task.search.text.work.done.message",
294                                                                args:[result.person, formattedStartOfDay])
295        else
296            result.message = getMessage(code:"task.search.text.work.done.none.found",
297                                                                args:[result.person, formattedStartOfDay])
298
299        result.totalHours = 0
300        result.totalMinutes = 0
301        result.entries.each() {
302            result.totalMinutes += (it.durationHour*60) + it.durationMinute
303        }
304        result.totalHours = (result.totalMinutes / 60).toInteger()
305        result.totalMinutes = result.totalMinutes % 60
306
307        return result
308    } // getWorkDone()
309
310} // end class
Note: See TracBrowser for help on using the repository browser.