Java tutorial
/* * This file is part of LibrePlan * * Copyright (C) 2012 Igalia, S.L. * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Affero General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Affero General Public License for more details. * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ package org.libreplan.web.users.dashboard; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import org.hibernate.NonUniqueResultException; import org.joda.time.LocalDate; import org.libreplan.business.calendars.entities.ResourceCalendar; import org.libreplan.business.common.daos.IConfigurationDAO; import org.libreplan.business.common.daos.IEntitySequenceDAO; import org.libreplan.business.common.entities.EntityNameEnum; import org.libreplan.business.common.entities.PersonalTimesheetsPeriodicityEnum; import org.libreplan.business.common.exceptions.InstanceNotFoundException; import org.libreplan.business.costcategories.entities.TypeOfWorkHours; import org.libreplan.business.orders.daos.IOrderDAO; import org.libreplan.business.orders.daos.ISumChargedEffortDAO; import org.libreplan.business.orders.entities.Order; import org.libreplan.business.orders.entities.OrderElement; import org.libreplan.business.planner.daos.IResourceAllocationDAO; import org.libreplan.business.planner.entities.SpecificResourceAllocation; import org.libreplan.business.resources.entities.Resource; import org.libreplan.business.resources.entities.Worker; import org.libreplan.business.scenarios.IScenarioManager; import org.libreplan.business.users.daos.IUserDAO; import org.libreplan.business.users.entities.User; import org.libreplan.business.workingday.EffortDuration; import org.libreplan.business.workingday.IntraDayDate.PartialDay; import org.libreplan.business.workreports.daos.IWorkReportDAO; import org.libreplan.business.workreports.daos.IWorkReportLineDAO; import org.libreplan.business.workreports.daos.IWorkReportTypeDAO; import org.libreplan.business.workreports.entities.PredefinedWorkReportTypes; import org.libreplan.business.workreports.entities.WorkReport; import org.libreplan.business.workreports.entities.WorkReportLine; import org.libreplan.business.workreports.entities.WorkReportType; import org.libreplan.web.UserUtil; import org.libreplan.web.calendars.BaseCalendarModel; import org.libreplan.web.common.Util; import org.libreplan.web.common.concurrentdetection.OnConcurrentModification; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.context.annotation.Scope; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; /** * Model for creation/edition of a personal timesheet * * @author Manuel Rego Casasnovas <mrego@igalia.com> */ @Service @Scope(BeanDefinition.SCOPE_PROTOTYPE) @OnConcurrentModification(goToPage = "/myaccount/userDashboard.zul") public class PersonalTimesheetModel implements IPersonalTimesheetModel { private User user; private LocalDate date; private LocalDate firstDay; private LocalDate lastDay; private List<OrderElement> orderElements; private WorkReport workReport; private Map<LocalDate, EffortDuration> capacityMap; private boolean modified; private Map<OrderElement, Set<LocalDate>> modifiedMap; private boolean currentUser; private boolean otherReports; private Map<Long, EffortDuration> otherEffortPerOrderElement; private Map<LocalDate, EffortDuration> otherEffortPerDay; private PersonalTimesheetsPeriodicityEnum periodicity; @Autowired private IResourceAllocationDAO resourceAllocationDAO; @Autowired private IScenarioManager scenarioManager; @Autowired private IWorkReportDAO workReportDAO; @Autowired private IWorkReportTypeDAO workReportTypeDAO; @Autowired private ISumChargedEffortDAO sumChargedEffortDAO; @Autowired private IConfigurationDAO configurationDAO; @Autowired private IOrderDAO orderDAO; @Autowired private IEntitySequenceDAO entitySequenceDAO; @Autowired private IUserDAO userDAO; @Autowired private IWorkReportLineDAO workReportLineDAO; @Override @Transactional(readOnly = true) public void initCreateOrEdit(LocalDate date) { currentUser = true; user = UserUtil.getUserFromSession(); if (!user.isBound()) { throw new RuntimeException("This page only can be used by users bound to a resource"); } initFields(date); } private void initFields(LocalDate date) { this.date = date; periodicity = getPersonalTimesheetsPeriodicity(); initDates(); initCapacityMap(); initWorkReport(); initOrderElements(); initOtherMaps(); modified = false; modifiedMap = new HashMap<OrderElement, Set<LocalDate>>(); } @Override @Transactional(readOnly = true) public void initCreateOrEdit(LocalDate date, Resource resource) { currentUser = false; try { user = userDAO.find(((Worker) resource).getUser().getId()); } catch (InstanceNotFoundException e) { throw new RuntimeException(e); } initFields(date); } private void initDates() { firstDay = periodicity.getStart(date); lastDay = periodicity.getEnd(date); } private void initCapacityMap() { forceLoad(getWorker().getCalendar()); capacityMap = new HashMap<LocalDate, EffortDuration>(); for (LocalDate day = firstDay; day.compareTo(lastDay) <= 0; day = day.plusDays(1)) { capacityMap.put(day, getWorker().getCalendar().getCapacityOn(PartialDay.wholeDay(day))); } } private void forceLoad(ResourceCalendar calendar) { BaseCalendarModel.forceLoadBaseCalendar(calendar); } private void initWorkReport() { // Get work report representing this personal timesheet workReport = workReportDAO.getPersonalTimesheetWorkReport(user.getWorker(), date, periodicity); if (workReport == null) { // If it doesn't exist yet create a new one workReport = WorkReport.create(getPersonalTimesheetsWorkReportType()); workReport.setCode(entitySequenceDAO.getNextEntityCodeWithoutTransaction(EntityNameEnum.WORK_REPORT)); workReport.setCodeAutogenerated(true); workReport.setResource(user.getWorker()); } else { forceLoad(workReport.getWorkReportLines()); } forceLoad(workReport.getWorkReportType()); } private void forceLoad(Set<WorkReportLine> workReportLines) { for (WorkReportLine line : workReportLines) { line.getOrderElement().getName(); } } private WorkReportType getPersonalTimesheetsWorkReportType() { try { WorkReportType workReportType = workReportTypeDAO .findUniqueByName(PredefinedWorkReportTypes.PERSONAL_TIMESHEETS.getName()); return workReportType; } catch (NonUniqueResultException e) { throw new RuntimeException(e); } catch (InstanceNotFoundException e) { throw new RuntimeException(e); } } private void forceLoad(WorkReportType workReportType) { workReportType.getLineFields().size(); workReportType.getWorkReportLabelTypeAssignments().size(); workReportType.getHeadingFields().size(); } private void initOrderElements() { List<SpecificResourceAllocation> resourceAllocations = resourceAllocationDAO .findSpecificAllocationsRelatedTo(scenarioManager.getCurrent(), UserDashboardUtil.getBoundResourceAsList(user), firstDay, lastDay); orderElements = new ArrayList<OrderElement>(); for (SpecificResourceAllocation each : resourceAllocations) { OrderElement orderElement = each.getTask().getOrderElement(); forceLoad(orderElement); orderElements.add(orderElement); } for (WorkReportLine each : workReport.getWorkReportLines()) { OrderElement orderElement = each.getOrderElement(); if (isNotInOrderElements(orderElement)) { forceLoad(orderElement); orderElements.add(orderElement); } } } private boolean isNotInOrderElements(OrderElement orderElement) { return !Util.contains(orderElements, orderElement); } private void forceLoad(OrderElement orderElement) { orderElement.getName(); if (orderElement.getParent() != null) { forceLoad(orderElement.getParent()); } } private void initOtherMaps() { List<WorkReportLine> workReportLines = workReportLineDAO.findByResourceFilteredByDateNotInWorkReport( getWorker(), firstDay.toDateTimeAtStartOfDay().toDate(), lastDay.toDateTimeAtStartOfDay().toDate(), workReport.isNewObject() ? null : workReport); otherReports = !workReportLines.isEmpty(); otherEffortPerOrderElement = new HashMap<Long, EffortDuration>(); otherEffortPerDay = new HashMap<LocalDate, EffortDuration>(); for (WorkReportLine line : workReportLines) { OrderElement orderElement = line.getOrderElement(); EffortDuration effort = line.getEffort(); LocalDate date = LocalDate.fromDateFields(line.getDate()); initMapKey(otherEffortPerOrderElement, orderElement.getId()); increaseMap(otherEffortPerOrderElement, orderElement.getId(), effort); initMapKey(otherEffortPerDay, date); increaseMap(otherEffortPerDay, date, effort); if (isNotInOrderElements(orderElement)) { forceLoad(orderElement); orderElements.add(orderElement); } } } private void initMapKey(Map<Long, EffortDuration> map, Long key) { if (map.get(key) == null) { map.put(key, EffortDuration.zero()); } } private void increaseMap(Map<Long, EffortDuration> map, Long key, EffortDuration valueToIncrease) { map.put(key, map.get(key).plus(valueToIncrease)); } private void initMapKey(Map<LocalDate, EffortDuration> map, LocalDate key) { if (map.get(key) == null) { map.put(key, EffortDuration.zero()); } } private void increaseMap(Map<LocalDate, EffortDuration> map, LocalDate key, EffortDuration valueToIncrease) { map.put(key, map.get(key).plus(valueToIncrease)); } @Override public LocalDate getDate() { return date; } @Override public LocalDate getFirstDay() { return firstDay; } @Override public LocalDate getLastDate() { return lastDay; } @Override public Worker getWorker() { return user.getWorker(); } @Override @Transactional(readOnly = true) public List<OrderElement> getOrderElements() { Collections.sort(orderElements, new Comparator<OrderElement>() { @Override public int compare(OrderElement o1, OrderElement o2) { Order order1 = getOrder(o1); Order order2 = getOrder(o2); int compareOrderName = order1.getName().compareTo(order2.getName()); if (compareOrderName != 0) { return compareOrderName; } return o1.getName().compareTo(o2.getName()); } }); return orderElements; } @Override public EffortDuration getEffortDuration(OrderElement orderElement, LocalDate date) { WorkReportLine workReportLine = getWorkReportLine(orderElement, date); if (workReportLine == null) { return null; } return workReportLine.getEffort(); } private WorkReportLine getWorkReportLine(OrderElement orderElement, LocalDate date) { for (WorkReportLine line : workReport.getWorkReportLines()) { if (line.getOrderElement().getId().equals(orderElement.getId()) && LocalDate.fromDateFields(line.getDate()).equals(date)) { return line; } } return null; } @Override @Transactional(readOnly = true) public void setEffortDuration(OrderElement orderElement, LocalDate date, EffortDuration effortDuration) { WorkReportLine workReportLine = getOrCreateWorkReportLine(orderElement, date); workReportLine.setEffort(effortDuration); modified = true; markAsModified(orderElement, date); } private WorkReportLine getOrCreateWorkReportLine(OrderElement orderElement, LocalDate date) { WorkReportLine workReportLine = getWorkReportLine(orderElement, date); if (workReportLine == null) { workReportLine = createWorkReportLine(orderElement, date); workReport.addWorkReportLine(workReportLine); } return workReportLine; } private void markAsModified(OrderElement orderElement, LocalDate date) { if (modifiedMap.get(orderElement) == null) { modifiedMap.put(orderElement, new HashSet<LocalDate>()); } modifiedMap.get(orderElement).add(date); } private WorkReportLine createWorkReportLine(OrderElement orderElement, LocalDate date) { WorkReportLine workReportLine = WorkReportLine.create(workReport); workReportLine.setCodeAutogenerated(true); workReportLine.setOrderElement(orderElement); workReportLine.setDate(date.toDateTimeAtStartOfDay().toDate()); workReportLine.setTypeOfWorkHours(getTypeOfWorkHours()); workReportLine.setEffort(EffortDuration.zero()); return workReportLine; } private TypeOfWorkHours getTypeOfWorkHours() { return configurationDAO.getConfiguration().getPersonalTimesheetsTypeOfWorkHours(); } @Override @Transactional public void save() { if (workReport.getWorkReportLines().isEmpty() && workReport.isNewObject()) { // Do nothing. // A new work report if it doesn't have work report lines is not // saved as it will not be possible to find it later with // WorkReportDAO.getPersonalTimesheetWorkReport() method. } else { Set<WorkReportLine> deletedWorkReportLinesSet = removeWorkReportLinesWithEffortZero(); Set<OrderElement> orderElements = sumChargedEffortDAO.getOrderElementsToRecalculateTimsheetDates( workReport.getWorkReportLines(), deletedWorkReportLinesSet); sumChargedEffortDAO .updateRelatedSumChargedEffortWithDeletedWorkReportLineSet(deletedWorkReportLinesSet); sumChargedEffortDAO.updateRelatedSumChargedEffortWithWorkReportLineSet(workReport.getWorkReportLines()); workReport.generateWorkReportLineCodes( entitySequenceDAO.getNumberOfDigitsCode(EntityNameEnum.WORK_REPORT)); workReportDAO.save(workReport); sumChargedEffortDAO.recalculateTimesheetData(orderElements); if (workReport.getWorkReportLines().isEmpty()) { try { workReportDAO.remove(workReport.getId()); } catch (InstanceNotFoundException e) { throw new RuntimeException(e); } } } resetModifiedFields(); } private Set<WorkReportLine> removeWorkReportLinesWithEffortZero() { Set<WorkReportLine> toRemove = new HashSet<WorkReportLine>(); for (WorkReportLine line : workReport.getWorkReportLines()) { if (line.getEffort().isZero()) { toRemove.add(line); } } for (WorkReportLine line : toRemove) { workReport.removeWorkReportLine(line); } return toRemove; } private void resetModifiedFields() { modified = false; modifiedMap = new HashMap<OrderElement, Set<LocalDate>>(); } @Override public void cancel() { user = null; date = null; orderElements = null; workReport = null; resetModifiedFields(); } @Override public EffortDuration getEffortDuration(OrderElement orderElement) { EffortDuration result = EffortDuration.zero(); for (WorkReportLine line : workReport.getWorkReportLines()) { if (line.getOrderElement().equals(orderElement)) { result = result.plus(line.getEffort()); } } return result; } @Override public EffortDuration getEffortDuration(LocalDate date) { EffortDuration result = EffortDuration.zero(); for (WorkReportLine line : workReport.getWorkReportLines()) { if (LocalDate.fromDateFields(line.getDate()).equals(date)) { result = result.plus(line.getEffort()); } } return result; } @Override public EffortDuration getTotalEffortDuration() { return workReport.getTotalEffortDuration(); } @Override public EffortDuration getResourceCapacity(LocalDate date) { return capacityMap.get(date); } @Override public void addOrderElement(OrderElement orderElement) { if (isNotInOrderElements(orderElement)) { orderElements.add(orderElement); } } @Override @Transactional(readOnly = true) public Order getOrder(OrderElement orderElement) { return orderDAO.loadOrderAvoidingProxyFor(orderElement); } @Override public boolean isModified() { return modified; } @Override @Transactional(readOnly = true) public boolean isFirstPeriod() { LocalDate activationDate = getWorker().getCalendar().getFistCalendarAvailability().getStartDate(); return firstDay.equals(periodicity.getStart(activationDate)); } @Override @Transactional(readOnly = true) public boolean isLastPeriod() { return firstDay.equals(periodicity.getStart(new LocalDate().plusMonths(1))); } @Override public boolean wasModified(OrderElement orderElement, LocalDate date) { Set<LocalDate> dates = modifiedMap.get(orderElement); return (dates != null) && dates.contains(date); } @Override public boolean isCurrentUser() { return currentUser; } @Override public boolean hasOtherReports() { return otherReports; } @Override public EffortDuration getOtherEffortDuration(OrderElement orderElement) { EffortDuration effort = otherEffortPerOrderElement.get(orderElement.getId()); return effort == null ? EffortDuration.zero() : effort; } @Override public EffortDuration getOtherEffortDuration(LocalDate date) { EffortDuration effort = otherEffortPerDay.get(date); return effort == null ? EffortDuration.zero() : effort; } @Override public EffortDuration getTotalOtherEffortDuration() { EffortDuration result = EffortDuration.zero(); for (EffortDuration effort : otherEffortPerOrderElement.values()) { result = result.plus(effort); } return result; } @Override @Transactional(readOnly = true) public PersonalTimesheetsPeriodicityEnum getPersonalTimesheetsPeriodicity() { return configurationDAO.getConfiguration().getPersonalTimesheetsPeriodicity(); } @Override public String getTimesheetString() { return PersonalTimesheetDTO.toString(periodicity, date); } @Override public LocalDate getPrevious() { return periodicity.previous(date); } @Override public LocalDate getNext() { return periodicity.next(date); } @Override public Boolean isFinished(OrderElement orderElement, LocalDate date) { WorkReportLine workReportLine = getWorkReportLine(orderElement, date); if (workReportLine == null) { return false; } return workReportLine.isFinished(); } @Override public void setFinished(OrderElement orderElement, LocalDate date, Boolean finished) { WorkReportLine workReportLine = getOrCreateWorkReportLine(orderElement, date); workReportLine.setFinished(finished); modified = true; markAsModified(orderElement, date); } @Override public Boolean isFinished(OrderElement orderElement) { if (workReport.isFinished(orderElement)) { return true; } List<WorkReportLine> lines = workReportLineDAO .findFinishedByOrderElementNotInWorkReportAnotherTransaction(orderElement, workReport); return !lines.isEmpty(); } }