source: trunk/grails-app/services/TaskReportService.groovy @ 544

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

Improvements to Immediate Callout Report.
File size: 12.5 KB
Line 
1import grails.orm.PagedResultList
2
3/**
4* Service class that encapsulates the business logic for Task searches.
5*/
6class TaskReportService {
7
8    boolean transactional = false
9
10    def authService
11    def dateUtilService
12    def sessionFactory
13//     def messageSource
14
15    def g = new org.codehaus.groovy.grails.plugins.web.taglib.ApplicationTagLib()
16
17    def paramsMax = 100000
18
19    /**
20    * Selects and returns the reactive ratio.
21    * @param params The request params, may contain params to specify the search.
22    * @param locale The locale to use when generating result.message.
23    */
24    def getReactiveRatio(params, locale) {
25        def result = [:]
26
27        def namedParams = [:]
28        namedParams.startDate = params.startDate ?: dateUtilService.today
29        namedParams.endDate = params.endDate ?: dateUtilService.today
30        namedParams.endDate++ // Start of next day required.
31        namedParams.immediateCallout = TaskType.read(1)
32        namedParams.unscheduledBreakin = TaskType.read(2)
33        namedParams.preventativeMaintenance = TaskType.read(4)
34        namedParams.notStarted = TaskStatus.read(1)
35
36        result.taskQuery = "from Task as task \
37                                            where (task.trash = false \
38                                                        and task.taskStatus != :notStarted \
39                                                        and task.targetStartDate < :endDate \
40                                                        and task.targetStartDate >= :startDate \
41                                                        and ( \
42                                                            task.taskType = :immediateCallout \
43                                                            or task.taskType = :unscheduledBreakin \
44                                                            or task.taskType = :preventativeMaintenance \
45                                                        ) \
46                                            )"
47
48        result.taskQuery = "select distinct task " + result.taskQuery
49        result.taskList = Task.executeQuery(result.taskQuery, namedParams)
50        result.taskCount = result.taskList.size()
51
52        // Assets on Tasks Count.
53        result.totalAssetsOnTasksCount = 0
54        result.immediateCalloutCount = 0
55        result.unscheduledBreakinCount = 0
56        result.preventativeMaintenanceCount = 0
57
58        // Summary Of Calculations.
59        result.summaryOfCalculationMethod = 'HQL query: \n\n'
60        def tempStringArray = result.taskQuery.split('    ')
61        tempStringArray.each() {
62            if(it != '') result.summaryOfCalculationMethod += it +'\n'
63        }
64        result.summaryOfCalculationMethod += '\n'+'Calculations: '+'\n\n'
65
66        result.summaryOfCalculationMethod += 'totalAssetsOnTasksCount = A count of unique assets on each task. \n'
67        result.taskList.each() { task ->
68            if(task.primaryAsset) {
69                result.totalAssetsOnTasksCount++
70                if(task.taskType == namedParams.immediateCallout) result.immediateCalloutCount++
71                if(task.taskType == namedParams.unscheduledBreakin) result.unscheduledBreakinCount++
72                if(task.taskType == namedParams.preventativeMaintenance) result.preventativeMaintenanceCount++
73            }
74            task.associatedAssets.each() { associatedAsset ->
75                if(associatedAsset.id != task.primaryAsset?.id) {
76                    result.totalAssetsOnTasksCount++
77                    if(task.taskType == namedParams.immediateCallout) result.immediateCalloutCount++
78                    if(task.taskType == namedParams.unscheduledBreakin) result.unscheduledBreakinCount++
79                    if(task.taskType == namedParams.preventativeMaintenance) result.preventativeMaintenanceCount++
80                }
81            }
82        } // each() task
83
84        // Percentage of counts.
85        result.immediateCalloutPercentage = 0
86        result.totalPreventativePercentage = 0
87
88        result.summaryOfCalculationMethod += 'totalPreventativeCount = unscheduledBreakinCount + preventativeMaintenanceCount\n'
89        result.totalPreventativeCount = result.unscheduledBreakinCount + result.preventativeMaintenanceCount
90        try {
91            result.summaryOfCalculationMethod += 'immediateCalloutPercentage = (immediateCalloutCount / totalAssetsOnTasksCount)*100 \n'
92            result.summaryOfCalculationMethod += 'totalPreventativePercentage = (totalPreventativeCount / totalAssetsOnTasksCount)*100 \n'
93            result.immediateCalloutPercentage = (result.immediateCalloutCount / result.totalAssetsOnTasksCount)*100
94            result.totalPreventativePercentage = (result.totalPreventativeCount / result.totalAssetsOnTasksCount)*100
95        }
96        catch(ArithmeticException e) {
97            log.error "Could not calculate: Assets on Tasks Percentages: "+e
98        }
99
100        // Work Done.
101        result.immediateCalloutWorkDone = [total:0, hours:0, minutes:0, percentage:0]
102        result.unscheduledBreakinWorkDone = [total:0, hours:0, minutes:0]
103        result.preventativeMaintenanceWorkDone = [total:0, hours:0, minutes:0]
104        result.totalPreventativeWorkDone = [total:0, hours:0, minutes:0, percentage:0]
105        result.totalWorkDone = [total:0, hours:0, minutes:0]
106
107        result.taskList.each() { task ->
108            task.entries.each() { entry ->
109                // Has assets assigned and is Work Done.
110                if( (task.primaryAsset || task.associatedAssets) && entry.entryType.id == 3L ) {
111                        if(task.taskType == namedParams.immediateCallout)
112                            result.immediateCalloutWorkDone.total += (entry.durationHour*60) + entry.durationMinute
113                        if(task.taskType == namedParams.unscheduledBreakin)
114                            result.unscheduledBreakinWorkDone.total += (entry.durationHour*60) + entry.durationMinute
115                        if(task.taskType == namedParams.preventativeMaintenance)
116                            result.preventativeMaintenanceWorkDone.total += (entry.durationHour*60) + entry.durationMinute
117                }
118            } // each() entry
119        } // each() task
120
121        // Work Done hours and minutes.
122        result.immediateCalloutWorkDone.hours = (result.immediateCalloutWorkDone.total / 60).toInteger()
123        result.immediateCalloutWorkDone.minutes = result.immediateCalloutWorkDone.total % 60
124
125        result.unscheduledBreakinWorkDone.hours = (result.unscheduledBreakinWorkDone.total / 60).toInteger()
126        result.unscheduledBreakinWorkDone.minutes = result.unscheduledBreakinWorkDone.total % 60
127
128        result.preventativeMaintenanceWorkDone.hours = (result.preventativeMaintenanceWorkDone.total / 60).toInteger()
129        result.preventativeMaintenanceWorkDone.minutes = result.preventativeMaintenanceWorkDone.total % 60
130
131        // Work Done Totals.
132        result.totalPreventativeWorkDone.total = result.unscheduledBreakinWorkDone.total + result.preventativeMaintenanceWorkDone.total
133        result.totalPreventativeWorkDone.hours = (result.totalPreventativeWorkDone.total / 60).toInteger()
134        result.totalPreventativeWorkDone.minutes = result.totalPreventativeWorkDone.total % 60
135
136        result.totalWorkDone.total = result.immediateCalloutWorkDone.total + result.totalPreventativeWorkDone.total
137        result.totalWorkDone.hours = (result.totalWorkDone.total / 60).toInteger()
138        result.totalWorkDone.minutes = result.totalWorkDone.total % 60
139
140        // Work Done Percentages.
141        try {
142            result.immediateCalloutWorkDone.percentage = (result.immediateCalloutWorkDone.total / result.totalWorkDone.total)*100
143            result.totalPreventativeWorkDone.percentage = (result.totalPreventativeWorkDone.total / result.totalWorkDone.total)*100
144        }
145        catch(ArithmeticException e) {
146            log.error "Could not calculate: Work Done Percentages: "+e
147        }
148
149        // Success.
150        return result
151
152    } // getReactiveRatio
153
154    /**
155    * Selects and returns Immediate Callouts, grouped by Asset.
156    * @param params The request params, may contain params to specify the search.
157    * @param locale The locale to use when generating result.message.
158    */
159    def getImmediateCallouts(params, locale) {
160        def result = [:]
161
162        def namedParams = [:]
163        namedParams.startDate = params.startDate ?: dateUtilService.today
164        namedParams.endDatePlusOne = (params.endDate ?: dateUtilService.today)+1
165        namedParams.immediateCallout = TaskType.read(1)
166
167        result.taskQuery = "from Task as task \
168                                            where (task.trash = false \
169                                                        and task.targetStartDate < :endDatePlusOne \
170                                                        and task.targetStartDate >= :startDate \
171                                                        and task.taskType = :immediateCallout \
172                                                        ) \
173                                            )"
174
175        result.taskQuery = "select distinct task " + result.taskQuery
176        result.taskQueryList = Task.executeQuery(result.taskQuery, namedParams)
177        result.taskCount = result.taskQueryList.size()
178
179        // Assets on Tasks Count.
180        result.totalAssetsOnTasksCount = 0
181        result.totalDownTime = [total: 0, hours: 0, minutes:0]
182        result.assetList = []
183
184        // Task Details
185        result.taskList = []
186
187        // Add or update lists.
188        def addToLists = { asset, task ->
189
190            def downTime = 0
191            def faultEntries = Entry.findAllByTaskAndEntryType(task, EntryType.read(1))
192            def causeEntries = Entry.findAllByTaskAndEntryType(task, EntryType.read(2))
193            def workDoneEntries = Entry.findAllByTaskAndEntryType(task, EntryType.read(3))
194            def taskDetails = 'Task #'+task.id+' - '+task.description+'\n'
195            faultEntries.each(){
196                taskDetails += '    Faults: '+it.comment+' - '+it.enteredBy+', '+g.formatDate(format: "EEE, dd-MMM-yyyy", date: it.dateDone)+'.\n'
197            }
198            causeEntries.each(){
199                taskDetails += '    Causes: '+it.comment+' - '+it.enteredBy+', '+g.formatDate(format: "EEE, dd-MMM-yyyy", date: it.dateDone)+'.\n'
200            }
201            workDoneEntries.each(){
202                taskDetails += '    Work Done: '+it.comment+' - '+it.enteredBy+', '+g.formatDate(format: "EEE, dd-MMM-yyyy", date: it.dateDone)+'.\n'
203            }
204
205            faultEntries.each() { downTime += (it.durationHour*60 + it.durationMinute) }
206            result.totalDownTime.total += downTime
207
208            def assetDetails = result.assetList.find { it.id == asset.id }
209            if(assetDetails) {
210                assetDetails.immediateCalloutCount++
211                assetDetails.downTime += downTime
212                assetDetails.tasks += taskDetails
213            }
214            else {
215                assetDetails = [id: asset.id,
216                                            name: asset.name,
217                                            immediateCalloutCount: 1,
218                                            downTime: downTime,
219                                            tasks: taskDetails]
220
221                result.assetList << assetDetails
222            }
223        } // addAToLists
224
225        // Summary Of Calculations.
226        result.summaryOfCalculationMethod = 'HQL query: \n\n'
227        def tempStringArray = result.taskQuery.split('    ')
228        tempStringArray.each() {
229            if(it != '') result.summaryOfCalculationMethod += it +'\n'
230        }
231        result.summaryOfCalculationMethod += '\n'+'Calculations: '+'\n\n'
232
233        result.summaryOfCalculationMethod += 'totalAssetsOnTasksCount = A count of unique assets on each task. \n'
234        result.taskQueryList.each() { task ->
235            if(task.primaryAsset) {
236                result.totalAssetsOnTasksCount++
237                addToLists(task.primaryAsset, task)
238            }
239            task.associatedAssets.each() { associatedAsset ->
240                if(associatedAsset.id != task.primaryAsset?.id) {
241                    result.totalAssetsOnTasksCount++
242                    addToLists(associatedAsset, task)
243                }
244            }
245
246        } // each() task
247
248        // Sort assetList by callout count.
249        result.assetList.sort {a, b -> b.immediateCalloutCount.compareTo(a.immediateCalloutCount)}
250
251        // Calculate hours and minutes.
252        result.totalDownTime.hours = (result.totalDownTime.total / 60).toInteger()
253        result.totalDownTime.minutes = result.totalDownTime.total % 60
254
255        // Success.
256        return result
257
258    } // getImmediateCallouts()
259
260
261} // end class
Note: See TracBrowser for help on using the repository browser.