Changeset 479


Ignore:
Timestamp:
Apr 12, 2010, 12:00:04 PM (10 years ago)
Author:
gav
Message:

Improvements to task search logic, especially 'my' tasks.

Location:
trunk/grails-app
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/grails-app/services/TaskSearchService.groovy

    r476 r479  
     1import grails.orm.PagedResultList
     2
    13/**
    24* Service class that encapsulates the business logic for Task searches.
     
    111113    } // getQuickSearch
    112114
     115    /**
     116    * Get all tasks that are not in the trash, by default today's tasks.
     117    * @param params The request params.
     118    * @param dayAdjustment The number of days to adjust from today, defaults to 0.
     119    */
    113120    def getTodays(params, dayAdjustment=0) {
    114121        params.max = Math.min(params?.max?.toInteger() ?: 10, paramsMax)
     
    122129            sort: params.sort,
    123130            order: params.order) {
    124                 ge("targetStartDate", dateUtilService.today+dayAdjustment)
    125131                lt("targetStartDate", dateUtilService.tomorrow+dayAdjustment)
    126                 eq("trash", false)
    127             }
    128     }
    129 
     132                ge("targetCompletionDate", dateUtilService.today+dayAdjustment)
     133                eq("trash", false)
     134            }
     135    }
     136
     137    /**
     138    * Get current user's tasks, by default today's tasks.
     139    * "Approved tasks where I am the lead or have been assigned"
     140    * @param params The request params.
     141    * @param dayAdjustment The number of days to adjust from today, defaults to 0.
     142    */
    130143    def getMyTodays(params, dayAdjustment=0) {
     144        def paginateParams = [:]
     145        paginateParams.max = Math.min(params?.max?.toInteger() ?: 10, paramsMax)
     146        paginateParams.offset = params?.offset?.toInteger() ?: 0
     147
     148        def sort = "task." + (params?.sort ?: "attentionFlag")
     149        def order = params?.order == "asc" ? "asc" : "desc"
     150        def orderBy = " order by " + sort + ' ' + order
     151
     152        def namedParams = [:]
     153        namedParams.currentUser = authService.currentUser
     154        namedParams.startOfDay = dateUtilService.today+dayAdjustment
     155        namedParams.startOfNextDay = dateUtilService.tomorrow+dayAdjustment
     156
     157        def baseQuery = "from Task as task \
     158                                        left join task.assignedPersons as assignedPersonOfTask \
     159                                        left join assignedPersonOfTask.person as assignedPerson \
     160                                        left join task.assignedGroups as assignedGroupOfTask \
     161                                        left join assignedGroupOfTask.personGroup as personGroup \
     162                                        left join personGroup.persons as assignedPersonViaGroup \
     163                                        where (task.trash = false \
     164                                                    and task.approved = true \
     165                                                    and ( \
     166                                                            task.targetStartDate < :startOfNextDay \
     167                                                            and task.targetCompletionDate >= :startOfDay \
     168                                                        ) \
     169                                                    and ( \
     170                                                            task.leadPerson = :currentUser \
     171                                                            or assignedPerson = :currentUser \
     172                                                            or assignedPersonViaGroup = :currentUser \
     173                                                            ) \
     174                                                    )"
     175
     176        def searchQuery = "select distinct task " + baseQuery + orderBy
     177        def list = Task.executeQuery(searchQuery, namedParams, paginateParams)
     178
     179        def countQuery = "select count(distinct task) as taskCount " + baseQuery
     180        def totalCount = Task.executeQuery(countQuery, namedParams)[0].toInteger()
     181
     182        def taskInstanceList = new PagedResultList(list, totalCount)
     183        return taskInstanceList
     184    } // getMyTodays
     185
     186    /**
     187    * Get all tasks that are not in the trash, during the past week.
     188    * @param params The request params.
     189    */
     190    def getPastWeek(params) {
    131191        params.max = Math.min(params?.max?.toInteger() ?: 10, paramsMax)
    132192        params.offset = params?.offset?.toInteger() ?: 0
     
    134194        params.order = params?.order ?: "desc"
    135195
    136         def currentUser = authService.currentUser
    137 
    138196        def taskInstanceList = Task.createCriteria().list(
    139197            max: params.max,
     
    141199            sort: params.sort,
    142200            order: params.order) {
    143                 ge("targetStartDate", dateUtilService.today+dayAdjustment)
    144                 lt("targetStartDate", dateUtilService.tomorrow+dayAdjustment)
    145                 eq("trash", false)
    146                 eq("approved", true)
    147                 or {
    148                     eq("leadPerson", currentUser)
    149                     assignedPersons {
    150                         eq("person", currentUser)
    151                     }
    152                     assignedGroups {
    153                         currentUser.personGroups.each() {
    154                             eq("personGroup", it)
    155                         }
    156                     } // assignedGroups
    157                 } // or
    158             } // criteria
     201                lt("targetStartDate", dateUtilService.tomorrow)
     202                ge("targetCompletionDate", dateUtilService.oneWeekAgo)
     203                eq("trash", false)
     204            }
     205    }
     206
     207    /**
     208    * Get current user's tasks in the past week.
     209    * "Approved tasks where I am the lead or have been assigned"
     210    * @param params The request params.
     211    */
     212    def getMyPastWeek(params) {
     213        def paginateParams = [:]
     214        paginateParams.max = Math.min(params?.max?.toInteger() ?: 10, paramsMax)
     215        paginateParams.offset = params?.offset?.toInteger() ?: 0
     216
     217        def sort = "task." + (params?.sort ?: "attentionFlag")
     218        def order = params?.order == "asc" ? "asc" : "desc"
     219        def orderBy = " order by " + sort + ' ' + order
     220
     221        def namedParams = [:]
     222        namedParams.currentUser = authService.currentUser
     223        namedParams.startOfDay = dateUtilService.oneWeekAgo
     224        namedParams.startOfNextDay = dateUtilService.tomorrow
     225
     226        def baseQuery = "from Task as task \
     227                                        left join task.assignedPersons as assignedPersonOfTask \
     228                                        left join assignedPersonOfTask.person as assignedPerson \
     229                                        left join task.assignedGroups as assignedGroupOfTask \
     230                                        left join assignedGroupOfTask.personGroup as personGroup \
     231                                        left join personGroup.persons as assignedPersonViaGroup \
     232                                        where (task.trash = false \
     233                                                    and task.approved = true \
     234                                                    and ( \
     235                                                            task.targetStartDate < :startOfNextDay \
     236                                                            and task.targetCompletionDate >= :startOfDay \
     237                                                        ) \
     238                                                    and ( \
     239                                                            task.leadPerson = :currentUser \
     240                                                            or assignedPerson = :currentUser \
     241                                                            or assignedPersonViaGroup = :currentUser \
     242                                                            ) \
     243                                                    )"
     244
     245        def searchQuery = "select distinct task " + baseQuery + orderBy
     246        def list = Task.executeQuery(searchQuery, namedParams, paginateParams)
     247
     248        def countQuery = "select count(distinct task) as taskCount " + baseQuery
     249        def totalCount = Task.executeQuery(countQuery, namedParams)[0].toInteger()
     250
     251        def taskInstanceList = new PagedResultList(list, totalCount)
     252        return taskInstanceList
    159253    } // getMyTodays
    160254
    161     def getPastWeek(params) {
    162         params.max = Math.min(params?.max?.toInteger() ?: 10, paramsMax)
    163         params.offset = params?.offset?.toInteger() ?: 0
    164         params.sort = params?.sort ?: "attentionFlag"
    165         params.order = params?.order ?: "desc"
    166 
    167         def taskInstanceList = Task.createCriteria().list(
    168             max: params.max,
    169             offset: params.offset,
    170             sort: params.sort,
    171             order: params.order) {
    172                 ge("targetStartDate", dateUtilService.oneWeekAgo)
    173                 lt("targetStartDate", dateUtilService.tomorrow)
    174                 eq("trash", false)
    175             }
    176     }
    177 
    178     def getMyPastWeek(params) {
    179         params.max = Math.min(params?.max?.toInteger() ?: 10, paramsMax)
    180         params.offset = params?.offset?.toInteger() ?: 0
    181         params.sort = params?.sort ?: "attentionFlag"
    182         params.order = params?.order ?: "desc"
    183 
    184         def currentUser = authService.currentUser
    185 
    186         def taskInstanceList = Task.createCriteria().list(
    187             max: params.max,
    188             offset: params.offset,
    189             sort: params.sort,
    190             order: params.order) {
    191                 ge("targetStartDate", dateUtilService.oneWeekAgo)
    192                 lt("targetStartDate", dateUtilService.tomorrow)
    193                 eq("trash", false)
    194                 eq("approved", true)
    195                 or {
    196                     eq("leadPerson", currentUser)
    197                     assignedPersons {
    198                         eq("person", currentUser)
    199                     }
    200                     assignedGroups {
    201                         currentUser.personGroups.each() {
    202                             eq("personGroup", it)
    203                         }
    204                     } // assignedGroups
    205                 } // or
    206             } // criteria
    207     } // getMyPastWeek
    208 
     255    /**
     256    * "Tasks with budget status of Planned, in the past week."
     257    * @param params The request params.
     258    */
    209259    def getBudgetPlanned(params) {
    210260        params.max = Math.min(params?.max?.toInteger() ?: 10, paramsMax)
     
    219269            order: params.order) {
    220270                eq("taskBudgetStatus", TaskBudgetStatus.read(2))
    221                 ge("targetStartDate", dateUtilService.oneWeekAgo)
    222271                lt("targetStartDate", dateUtilService.tomorrow)
    223                 eq("trash", false)
    224             }
    225     }
    226 
     272                ge("targetCompletionDate", dateUtilService.oneWeekAgo)
     273                eq("trash", false)
     274            }
     275    }
     276
     277    /**
     278    * "Tasks with budget status of Unplanned, in the past week."
     279    * @param params The request params.
     280    */
    227281    def getBudgetUnplanned(params) {
    228282        params.max = Math.min(params?.max?.toInteger() ?: 10, paramsMax)
     
    237291            order: params.order) {
    238292                eq("taskBudgetStatus", TaskBudgetStatus.read(1))
    239                 ge("targetStartDate", dateUtilService.oneWeekAgo)
    240293                lt("targetStartDate", dateUtilService.tomorrow)
    241                 eq("trash", false)
    242             }
    243     }
    244 
     294                ge("targetCompletionDate", dateUtilService.oneWeekAgo)
     295                eq("trash", false)
     296            }
     297    }
     298
     299    /**
     300    * "Tasks in the past week and two weeks ahead."
     301    * @param params The request params.
     302    */
    245303    def getPlannersRange(params) {
    246304        params.max = Math.min(params?.max?.toInteger() ?: 10, paramsMax)
  • trunk/grails-app/views/taskDetailed/_quickSearchPane.gsp

    r476 r479  
    1515                                        params="[quickSearch: 'myTodays']">
    1616                                        Today
    17                         </g:link>
     17                        </g:link> - Approved tasks where I am the lead or have been assigned.
    1818                        <br />
    1919                        <g:link controller="taskDetailed"
     
    4646                                        params="[quickSearch: 'todays']">
    4747                                        Today
    48                         </g:link>
     48                        </g:link> - All tasks that are not in the trash.
    4949                        <br />
    5050                        <g:link controller="taskDetailed"
     
    7070                                        params="[quickSearch: 'plannersRange']">
    7171                                        Planners Range
    72                         </g:link>
     72                        </g:link> - Tasks in the past week and two weeks ahead.
    7373                    </td>
    7474                </tr>
     
    8383                                        params="[quickSearch: 'budgetPlanned']">
    8484                                        Planned Tasks
    85                         </g:link>
     85                        </g:link> - Task with budget status of Planned, in the past week.
    8686                        <br />
    8787                        <g:link controller="taskDetailed"
Note: See TracChangeset for help on using the changeset viewer.