| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| import java.util.* |
| import java.lang.* |
| import org.apache.ofbiz.base.util.* |
| import org.apache.ofbiz.entity.* |
| import org.apache.ofbiz.base.util.Debug |
| import org.apache.ofbiz.base.util.UtilMisc |
| import org.apache.ofbiz.base.util.UtilValidate |
| import org.apache.ofbiz.base.util.UtilDateTime |
| import org.apache.ofbiz.entity.util.* |
| import org.apache.ofbiz.entity.condition.* |
| import org.apache.ofbiz.webapp.website.WebSiteWorker |
| import java.sql.Timestamp |
| |
| uiLabelMap = UtilProperties.getResourceBundleMap("scrumUiLabels", locale) |
| partyId = parameters.partyId |
| if (!partyId) { |
| partyId = parameters.userLogin.partyId |
| } |
| |
| // show the requested timesheet, otherwise the current , if not exist create |
| timesheet = null |
| timesheetId = parameters.timesheetId |
| if (timesheetId) { |
| timesheet = from("Timesheet").where("timesheetId", timesheetId).queryOne() |
| partyId = timesheet.partyId // use the party from this timesheet |
| } else { |
| // make sure because of timezone changes, not a duplicate timesheet is created |
| midweek = UtilDateTime.addDaysToTimestamp(UtilDateTime.getWeekStart(UtilDateTime.nowTimestamp()),3) |
| entryExprs = EntityCondition.makeCondition([ |
| EntityCondition.makeCondition("fromDate", EntityComparisonOperator.LESS_THAN, midweek), |
| EntityCondition.makeCondition("thruDate", EntityComparisonOperator.GREATER_THAN, midweek), |
| EntityCondition.makeCondition("partyId", EntityComparisonOperator.EQUALS, partyId) |
| ], EntityOperator.AND) |
| entryIterator = from("Timesheet").where(entryExprs).queryIterator() |
| timesheet = entryIterator.next() |
| entryIterator.close() |
| if (timesheet == null) { |
| result = runService('createProjectTimesheet', ["userLogin" : parameters.userLogin, "partyId" : partyId]) |
| if (result && result.timesheetId) { |
| timesheet = from("Timesheet").where("timesheetId", result.timesheetId).queryOne() |
| } |
| } |
| } |
| if (!timesheet) return |
| context.timesheet = timesheet |
| context.weekNumber = UtilDateTime.weekNumber(timesheet.fromDate) |
| |
| // get the user names |
| context.partyNameView = from("PartyNameView").where("partyId", partyId).queryOne() |
| // get the default rate for this person |
| rateTypes = from("PartyRate").where("partyId", partyId, "defaultRate", "Y").filterByDate().queryList() |
| if (rateTypes) { |
| context.defaultRateTypeId = rateTypes[0].rateTypeId |
| } |
| |
| entries = [] |
| entry = ["timesheetId" : timesheet.timesheetId] |
| leaveEntry = ["timesheetId" : timesheet.timesheetId] |
| taskTotal = 0.00 |
| planTotal = 0.00 |
| leaveTaskTotal = 0.00 |
| leavePlanTotal = 0.00 |
| day0Total = 0.00; day1Total=0.00; day2Total=0.00; day3Total=0.00; day4Total=0.00; day5Total=0.00; day6Total=0.00 |
| pDay0Total = 0.00; pDay1Total=0.00; pDay2Total=0.00; pDay3Total=0.00; pDay4Total=0.00; pDay5Total=0.00; pDay6Total=0.00 |
| pHours = 0.00 |
| timeEntry = null |
| lastTimeEntry = null |
| emplLeaveEntry = null |
| lastEmplLeaveEntry = null |
| |
| // retrieve work effort data when the workeffortId has changed. |
| void retrieveWorkEffortData() { |
| // get the planned number of hours |
| entryWorkEffort = lastTimeEntry.getRelatedOne("WorkEffort", false) |
| if (entryWorkEffort) { |
| plannedHours = entryWorkEffort.getRelated("WorkEffortSkillStandard", null, null, false) |
| pHours = 0.00 |
| plannedHours.each { plannedHour -> |
| if (plannedHour.estimatedDuration) { |
| pHours += plannedHour.estimatedDuration |
| } |
| } |
| estimatedHour = 0.00 |
| |
| estimatedMilliSeconds = entryWorkEffort.estimatedMilliSeconds |
| if (estimatedMilliSeconds > 0) |
| estimatedHour = estimatedMilliSeconds/3600000 |
| entry.plannedHours = estimatedHour |
| //entry.plannedHours = pHours |
| planHours = 0.0 |
| planHours = lastTimeEntry.planHours |
| lastTimeEntryOfTasks = from("TimeEntry").where("workEffortId", lastTimeEntry.workEffortId, "partyId", partyId).orderBy("-fromDate").queryList() |
| if (lastTimeEntryOfTasks.size() != 0) lastTimeEntry = lastTimeEntryOfTasks[0] |
| if (planHours < 1) { |
| planHours = estimatedHour |
| } |
| entry.planHours = lastTimeEntry.planHours |
| actualHours = entryWorkEffort.getRelated("TimeEntry", null, null, false) |
| aHours = 0.00 |
| actualHours.each { actualHour -> |
| if (actualHour.hours) { |
| aHours += actualHour.hours |
| } |
| } |
| entry.actualHours = aHours |
| // get party assignment data to be able to set the task to complete |
| workEffortPartyAssigns = EntityUtil.filterByDate(entryWorkEffort.getRelated("WorkEffortPartyAssignment", ["partyId" : partyId], null, false)) |
| if (workEffortPartyAssigns) { |
| workEffortPartyAssign = workEffortPartyAssigns[0] |
| entry.fromDate = workEffortPartyAssign.getTimestamp("fromDate") |
| entry.roleTypeId = workEffortPartyAssign.roleTypeId |
| if ("SCAS_COMPLETED".equals(workEffortPartyAssign.statusId)) { |
| entry.checkComplete = "Y" |
| |
| } |
| } else { |
| if ("STS_COMPLETED".equals(entryWorkEffort.currentStatusId)) { |
| entry.checkComplete = "Y" |
| } |
| } |
| |
| // get project/phase information |
| entry.workEffortId = entryWorkEffort.workEffortId |
| entry.workEffortName = entryWorkEffort.workEffortName |
| result = runService('getProjectInfoFromTask', ["userLogin" : parameters.userLogin,"taskId" : entryWorkEffort.workEffortId]) |
| entry.phaseId = result.phaseId |
| entry.phaseName = result.phaseName |
| entry.projectId = result.projectId |
| entry.projectName = result.projectName |
| entry.taskWbsId = result.taskWbsId |
| |
| } |
| entry.acualTotal = taskTotal |
| entry.planTotal = planTotal |
| //Drop Down Lists |
| if (entry.checkComplete != "Y") { |
| if (aHours > 0.00) |
| entries.add(entry) |
| } else { |
| entries.add(entry) |
| } |
| // start new entry |
| taskTotal = 0.00 |
| planTotal = 0.00 |
| entry = ["timesheetId" : timesheet.timesheetId] |
| } |
| |
| timeEntries = timesheet.getRelated("TimeEntry", null, ["workEffortId", "rateTypeId", "fromDate"], false) |
| te = timeEntries.iterator() |
| while (te.hasNext()) { |
| // only fill lastTimeEntry when not the first time |
| if (timeEntry!=void) { |
| lastTimeEntry = timeEntry |
| } |
| timeEntry = te.next() |
| |
| if (lastTimeEntry && |
| (!lastTimeEntry.workEffortId.equals(timeEntry.workEffortId) || |
| !lastTimeEntry.rateTypeId.equals(timeEntry.rateTypeId))) { |
| retrieveWorkEffortData() |
| } |
| if (timeEntry.hours) { |
| dayNumber = "d" + (timeEntry.fromDate.getTime() - timesheet.fromDate.getTime()) / (24*60*60*1000) |
| hours = timeEntry.hours.doubleValue() |
| entry.put(String.valueOf(dayNumber), hours) |
| if (dayNumber.equals("d0")) day0Total += hours |
| if (dayNumber.equals("d1")) day1Total += hours |
| if (dayNumber.equals("d2")) day2Total += hours |
| if (dayNumber.equals("d3")) day3Total += hours |
| if (dayNumber.equals("d4")) day4Total += hours |
| if (dayNumber.equals("d5")) day5Total += hours |
| if (dayNumber.equals("d6")) day6Total += hours |
| taskTotal += hours |
| } |
| if (timeEntry.planHours) { |
| dayNumber = "pd" + (timeEntry.fromDate.getTime() - timesheet.fromDate.getTime()) / (24*60*60*1000) |
| planHours = timeEntry.planHours.doubleValue() |
| entry.put(String.valueOf(dayNumber), planHours) |
| if (dayNumber.equals("pd0")) pDay0Total += planHours |
| if (dayNumber.equals("pd1")) pDay1Total += planHours |
| if (dayNumber.equals("pd2")) pDay2Total += planHours |
| if (dayNumber.equals("pd3")) pDay3Total += planHours |
| if (dayNumber.equals("pd4")) pDay4Total += planHours |
| if (dayNumber.equals("pd5")) pDay5Total += planHours |
| if (dayNumber.equals("pd6")) pDay6Total += planHours |
| planTotal += planHours |
| |
| } |
| entry.rateTypeId = timeEntry.rateTypeId |
| } |
| //retrieve Empl Leave data. |
| void retrieveEmplLeaveData() { |
| if (lastEmplLeaveEntry) { |
| //service get Hours |
| result = runService('getPartyLeaveHoursForDate', |
| ["userLogin": parameters.userLogin, "partyId": lastEmplLeaveEntry.partyId, "leaveTypeId": lastEmplLeaveEntry.leaveTypeId, "fromDate": lastEmplLeaveEntry.fromDate]) |
| if (result.hours) { |
| leaveEntry.plannedHours = result.hours |
| leaveEntry.planHours = result.hours |
| } |
| if (lastEmplLeaveEntry.leaveStatus == "LEAVE_APPROVED") { |
| leaveEntry.checkComplete = "Y" |
| } |
| leaveEntry.partyId = lastEmplLeaveEntry.partyId |
| leaveEntry.leaveTypeId = lastEmplLeaveEntry.leaveTypeId |
| leaveEntry.leavefromDate = lastEmplLeaveEntry.fromDate |
| leaveEntry.leavethruDate = lastEmplLeaveEntry.thruDate |
| leaveEntry.description = lastEmplLeaveEntry.description |
| } |
| leaveEntry.acualTotal = leaveTaskTotal |
| leaveEntry.planHours = leavePlanTotal |
| leaveEntry.actualHours = leaveTaskTotal |
| //Drop Down Lists |
| entries.add(leaveEntry) |
| // start new leaveEntry |
| leaveTaskTotal = 0.00 |
| leavePlanTotal = 0.00 |
| leaveEntry = ["timesheetId" : timesheet.timesheetId] |
| } |
| |
| // define condition |
| leaveExprs = [] |
| leaveExprs.add(EntityCondition.makeCondition("fromDate", EntityOperator.GREATER_THAN_EQUAL_TO, timesheet.fromDate)) |
| leaveExprs.add(EntityCondition.makeCondition("fromDate", EntityOperator.LESS_THAN_EQUAL_TO, timesheet.thruDate)) |
| leaveExprs.add(EntityCondition.makeCondition("partyId", EntityOperator.EQUALS, partyId)) |
| emplLeave = from("EmplLeave").where(leaveExprs).cursorScrollInsensitive().distinct().queryIterator() |
| |
| while ((emplLeaveMap = emplLeave.next())) { |
| if (emplLeaveEntry!=void) { |
| lastEmplLeaveEntry = emplLeaveEntry |
| } |
| |
| emplLeaveEntry = emplLeaveMap |
| |
| if (lastEmplLeaveEntry && ( |
| !lastEmplLeaveEntry.leaveTypeId.equals(emplLeaveEntry.leaveTypeId) || |
| !lastEmplLeaveEntry.partyId.equals(emplLeaveEntry.partyId))) { |
| retrieveEmplLeaveData() |
| } |
| resultHours = runService('getPartyLeaveHoursForDate', |
| ["userLogin": parameters.userLogin, "partyId": emplLeaveEntry.partyId, "leaveTypeId": emplLeaveEntry.leaveTypeId, "fromDate": emplLeaveEntry.fromDate]) |
| |
| if (resultHours.hours) { |
| leaveDayNumber = "d" + (emplLeaveEntry.fromDate.getTime() - timesheet.fromDate.getTime()) / (24*60*60*1000) |
| resultHours = runService('getPartyLeaveHoursForDate', |
| ["userLogin": parameters.userLogin, "partyId": emplLeaveEntry.partyId, "leaveTypeId": emplLeaveEntry.leaveTypeId, "fromDate": emplLeaveEntry.fromDate]) |
| leaveHours = resultHours.hours.doubleValue() |
| leaveEntry.put(String.valueOf(leaveDayNumber), leaveHours) |
| if (leaveDayNumber.equals("d0")) day0Total += leaveHours |
| if (leaveDayNumber.equals("d1")) day1Total += leaveHours |
| if (leaveDayNumber.equals("d2")) day2Total += leaveHours |
| if (leaveDayNumber.equals("d3")) day3Total += leaveHours |
| if (leaveDayNumber.equals("d4")) day4Total += leaveHours |
| if (leaveDayNumber.equals("d5")) day5Total += leaveHours |
| if (leaveDayNumber.equals("d6")) day6Total += leaveHours |
| leaveTaskTotal += leaveHours |
| } |
| if (resultHours.hours) { |
| leavePlanDay = "pd" + (emplLeaveEntry.fromDate.getTime() - timesheet.fromDate.getTime()) / (24*60*60*1000) |
| resultPlanHours = runService('getPartyLeaveHoursForDate', |
| ["userLogin": parameters.userLogin, "partyId": emplLeaveEntry.partyId, "leaveTypeId": emplLeaveEntry.leaveTypeId, "fromDate": emplLeaveEntry.fromDate]) |
| leavePlanHours = resultPlanHours.hours.doubleValue() |
| leaveEntry.put(String.valueOf(leavePlanDay), leavePlanHours) |
| if (leavePlanDay.equals("pd0")) pDay0Total += leavePlanHours |
| if (leavePlanDay.equals("pd1")) pDay1Total += leavePlanHours |
| if (leavePlanDay.equals("pd2")) pDay2Total += leavePlanHours |
| if (leavePlanDay.equals("pd3")) pDay3Total += leavePlanHours |
| if (leavePlanDay.equals("pd4")) pDay4Total += leavePlanHours |
| if (leavePlanDay.equals("pd5")) pDay5Total += leavePlanHours |
| if (leavePlanDay.equals("pd6")) pDay6Total += leavePlanHours |
| leavePlanTotal += leavePlanHours |
| } |
| leaveEntry.rateTypeId = "STANDARD" |
| } |
| emplLeave.close() |
| |
| if (timeEntry) { |
| lastTimeEntry = timeEntry |
| retrieveWorkEffortData() |
| } |
| if (emplLeaveEntry) { |
| lastEmplLeaveEntry = emplLeaveEntry |
| retrieveEmplLeaveData() |
| } |
| |
| // add empty lines if timesheet not completed |
| if (!timesheet.statusId.equals("TIMESHEET_COMPLETED")) { |
| for (c=0; c < 3; c++) { // add empty lines |
| entries.add(["timesheetId" : timesheet.timesheetId]) |
| } |
| } |
| |
| // add the totals line if at least one entry |
| if (timeEntry || emplLeaveEntry) { |
| entry = ["timesheetId" : timesheet.timesheetId] |
| entry.d0 = day0Total |
| entry.d1 = day1Total |
| entry.d2 = day2Total |
| entry.d3 = day3Total |
| entry.d4 = day4Total |
| entry.d5 = day5Total |
| entry.d6 = day6Total |
| entry.pd0 = pDay0Total |
| entry.pd1 = pDay1Total |
| entry.pd2 = pDay2Total |
| entry.pd3 = pDay3Total |
| entry.pd4 = pDay4Total |
| entry.pd5 = pDay5Total |
| entry.pd6 = pDay6Total |
| entry.phaseName = uiLabelMap.ScrumTotals |
| entry.workEffortId = "Totals" |
| entry.total = day0Total + day1Total + day2Total + day3Total + day4Total + day5Total + day6Total |
| entries.add(entry) |
| } |
| context.timeEntries = entries |
| // get all timesheets of this user, including the planned hours |
| timesheetsDb = from("Timesheet").where("partyId", partyId).orderBy("fromDate DESC").queryList() |
| timesheets = new LinkedList() |
| timesheetsDb.each { timesheetDb -> |
| //get hours from EmplLeave |
| findOpts = new EntityFindOptions(true, EntityFindOptions.TYPE_SCROLL_INSENSITIVE, EntityFindOptions.CONCUR_READ_ONLY, true) |
| leaveExprsList = [] |
| leaveExprsList.add(EntityCondition.makeCondition("fromDate", EntityOperator.GREATER_THAN_EQUAL_TO, timesheetDb.fromDate)) |
| leaveExprsList.add(EntityCondition.makeCondition("fromDate", EntityOperator.LESS_THAN_EQUAL_TO, timesheetDb.thruDate)) |
| leaveExprsList.add(EntityCondition.makeCondition("partyId", EntityOperator.EQUALS, partyId)) |
| emplLeaveList = from("EmplLeave").where(leaveExprsList).cursorScrollInsensitive().distinct().queryIterator() |
| leaveHours = 0.00 |
| |
| while ((emplLeaveMap = emplLeaveList.next())) { |
| emplLeaveEntry = emplLeaveMap |
| resultHour = runService('getPartyLeaveHoursForDate', |
| ["userLogin": parameters.userLogin, "partyId": emplLeaveEntry.partyId, "leaveTypeId": emplLeaveEntry.leaveTypeId, "fromDate": emplLeaveEntry.fromDate]) |
| if (resultHour) { |
| leaveActualHours = resultHour.hours.doubleValue() |
| leaveHours += leaveActualHours |
| } |
| } |
| //get hours from TimeEntry |
| timesheet = [:] |
| timesheet.putAll(timesheetDb) |
| entries = timesheetDb.getRelated("TimeEntry", null, null, false) |
| hours = 0.00 |
| entries.each { timeEntry -> |
| if (timeEntry.hours) { |
| hours += timeEntry.hours.doubleValue() |
| } |
| } |
| timesheet.weekNumber = UtilDateTime.weekNumber(timesheetDb.fromDate) |
| timesheet.hours = hours + leaveHours |
| timesheets.add(timesheet) |
| emplLeaveList.close() |
| } |
| context.timesheets = timesheets |
| |
| // get existing task that no assign |
| taskList=[] |
| projectSprintBacklogAndTaskList = [] |
| backlogIndexList = [] |
| projectAndTaskList = from("ProjectSprintBacklogAndTask").where("sprintTypeId" : "SCRUM_SPRINT","taskCurrentStatusId" : "STS_CREATED").orderBy("projectName ASC","taskActualStartDate DESC").queryList() |
| projectAndTaskList.each { projectAndTaskMap -> |
| userLoginId = userLogin.partyId |
| sprintId = projectAndTaskMap.sprintId |
| workEffortList = from("WorkEffortAndProduct").where("workEffortId", projectAndTaskMap.projectId).queryList() |
| backlogIndexList.add(workEffortList[0].productId) |
| |
| partyAssignmentSprintList = from("WorkEffortPartyAssignment").where("workEffortId", sprintId, "partyId", userLoginId).queryList() |
| partyAssignmentSprintMap = partyAssignmentSprintList[0] |
| // if this userLoginId is a member of sprint |
| if (partyAssignmentSprintMap) { |
| workEffortId = projectAndTaskMap.taskId |
| partyAssignmentTaskList = from("WorkEffortPartyAssignment").where("workEffortId", workEffortId).queryList() |
| partyAssignmentTaskMap = partyAssignmentTaskList[0] |
| // if the task do not assigned |
| if (partyAssignmentTaskMap) { |
| custRequestTypeId = projectAndTaskMap.custRequestTypeId |
| backlogStatusId = projectAndTaskMap.backlogStatusId |
| if (custRequestTypeId.equals("RF_SCRUM_MEETINGS") && backlogStatusId.equals("CRQ_REVIEWED")) { |
| projectSprintBacklogAndTaskList.add(projectAndTaskMap) |
| } |
| } else { |
| projectSprintBacklogAndTaskList.add(0,projectAndTaskMap) |
| } |
| } |
| } |
| |
| // for unplanned taks. |
| unplanList=[] |
| if (backlogIndexList) { |
| backlogIndex = new HashSet(backlogIndexList) |
| custRequestList = from("CustRequest").where("custRequestTypeId", "RF_UNPLAN_BACKLOG","statusId", "CRQ_REVIEWED").orderBy("custRequestDate DESC").queryList() |
| if (custRequestList) { |
| custRequestList.each { custRequestMap -> |
| custRequestItemList = custRequestMap.getRelated("CustRequestItem", null, null, false) |
| custRequestItem = |
| productOut = custRequestItemList[0].productId |
| product = from("Product").where("productId", productOut).queryOne() |
| backlogIndex.each { backlogProduct -> |
| productId = backlogProduct |
| if (productId.equals(productOut)) { |
| custRequestWorkEffortList = from("CustRequestWorkEffort").where("custRequestId", custRequestItemList[0].custRequestId).queryList() |
| custRequestWorkEffortList.each { custRequestWorkEffortMap -> |
| partyAssignmentTaskList = from("WorkEffortPartyAssignment").where("workEffortId", custRequestWorkEffortMap.workEffortId).queryList() |
| partyAssignmentTaskMap = partyAssignmentTaskList[0] |
| // if the task do not assigned |
| if (!partyAssignmentTaskMap) { |
| result = [:] |
| workEffortMap = from("WorkEffort").where("workEffortId", custRequestWorkEffortMap.workEffortId).queryOne() |
| result.description = custRequestMap.description |
| result.productName = product.internalName |
| result.taskId = workEffortMap.workEffortId |
| result.taskName = workEffortMap.workEffortName |
| result.custRequestTypeId = custRequestMap.custRequestTypeId |
| result.taskTypeId = workEffortMap.workEffortTypeId |
| unplanList.add(result) |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| projectSprintBacklogAndTaskList = UtilMisc.sortMaps(projectSprintBacklogAndTaskList, ["projectName","sprintName","-taskTypeId","custRequestId"]) |
| projectSprintBacklogAndTaskList.each { projectSprintBacklogAndTaskMap -> |
| blTypeId = projectSprintBacklogAndTaskMap.custRequestTypeId |
| if (blTypeId == "RF_SCRUM_MEETINGS"){ |
| taskList.add(projectSprintBacklogAndTaskMap) |
| } |
| } |
| projectSprintBacklogAndTaskList = UtilMisc.sortMaps(projectSprintBacklogAndTaskList, ["-projectName","sprintName","-taskTypeId","custRequestId"]) |
| projectSprintBacklogAndTaskList.each { projectSprintBacklogAndTaskMap -> |
| blTypeId = projectSprintBacklogAndTaskMap.custRequestTypeId |
| if (blTypeId == "RF_PROD_BACKLOG"){ |
| taskList.add(0,projectSprintBacklogAndTaskMap) |
| } |
| } |
| unplanList = UtilMisc.sortMaps(unplanList,["-productName","-taskTypeId","custRequestId"]) |
| unplanList.each { unplanMap-> |
| taskList.add(0,unplanMap) |
| } |
| context.taskList = taskList |
| |
| // notification context |
| webSiteId = WebSiteWorker.getWebSiteId(request) |
| context.webSiteId = webSiteId |
