/*
* This file is part of LibrePlan
*
* Copyright (C) 2013 St. Antoniusziekenhuis
*
* 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.importers;
import static org.libreplan.web.I18nHelper._;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Map;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.joda.time.LocalDate;
import org.libreplan.business.advance.bootstrap.PredefinedAdvancedTypes;
import org.libreplan.business.advance.entities.AdvanceMeasurement;
import org.libreplan.business.advance.entities.AdvanceType;
import org.libreplan.business.advance.entities.DirectAdvanceAssignment;
import org.libreplan.business.advance.exceptions.DuplicateAdvanceAssignmentForOrderElementException;
import org.libreplan.business.advance.exceptions.DuplicateValueTrueReportGlobalAdvanceException;
import org.libreplan.business.common.IAdHocTransactionService;
import org.libreplan.business.common.IOnTransaction;
import org.libreplan.business.common.daos.IConnectorDAO;
import org.libreplan.business.common.entities.Connector;
import org.libreplan.business.common.entities.ConnectorException;
import org.libreplan.business.common.entities.PredefinedConnectorProperties;
import org.libreplan.business.common.entities.PredefinedConnectors;
import org.libreplan.business.orders.daos.IOrderSyncInfoDAO;
import org.libreplan.business.orders.entities.HoursGroup;
import org.libreplan.business.orders.entities.Order;
import org.libreplan.business.orders.entities.OrderElement;
import org.libreplan.business.orders.entities.OrderLine;
import org.libreplan.business.orders.entities.OrderSyncInfo;
import org.libreplan.business.workingday.EffortDuration;
import org.libreplan.importers.jira.IssueDTO;
import org.libreplan.importers.jira.StatusDTO;
import org.libreplan.importers.jira.TimeTrackingDTO;
import org.libreplan.importers.jira.WorkLogDTO;
import org.libreplan.importers.jira.WorkLogItemDTO;
import org.libreplan.web.orders.IOrderModel;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
/**
* Implementation of Synchronize order elements with jira issues
*
* @author Miciele Ghiorghis <m.ghiorghis@antoniusziekenhuis.nl>
*/
@Component
@Scope(BeanDefinition.SCOPE_PROTOTYPE)
public class JiraOrderElementSynchronizer implements IJiraOrderElementSynchronizer {
private static final Log LOG = LogFactory
.getLog(JiraOrderElementSynchronizer.class);
private SynchronizationInfo synchronizationInfo;
@Autowired
private IConnectorDAO connectorDAO;
@Autowired
private IOrderSyncInfoDAO orderSyncInfoDAO;
@Autowired
private IAdHocTransactionService adHocTransactionService;
@Autowired
private IOrderModel orderModel;
@Autowired
private IJiraTimesheetSynchronizer jiraTimesheetSynchronizer;
@Override
@Transactional(readOnly = true)
public List<String> getAllJiraLabels() throws ConnectorException {
Connector connector = getJiraConnector();
if (connector == null) {
throw new ConnectorException(_("JIRA connector not found"));
}
String jiraLabels = connector.getPropertiesAsMap().get(
PredefinedConnectorProperties.JIRA_LABELS);
String labels;
try {
new URL(jiraLabels);
labels = JiraRESTClient.getAllLables(jiraLabels);
} catch (MalformedURLException e) {
labels = jiraLabels;
}
return Arrays.asList(StringUtils.split(labels, ","));
}
@Override
@Transactional(readOnly = true)
public List<IssueDTO> getJiraIssues(String label) throws ConnectorException {
Connector connector = getJiraConnector();
if (connector == null) {
throw new ConnectorException(_("JIRA connector not found"));
}
if (!connector.areConnectionValuesValid()) {
throw new ConnectorException(
_("Connection values of JIRA connector are invalid"));
}
return getJiraIssues(label, connector);
}
/**
* Gets all jira issues for the specified <code>label</code>
*
* @param label
* the search criteria
* @param connector
* where to read the configuration parameters
* @return a list of {@link IssueDTO}
*/
private List<IssueDTO> getJiraIssues(String label, Connector connector) {
Map<String, String> properties = connector.getPropertiesAsMap();
String url = properties.get(PredefinedConnectorProperties.SERVER_URL);
String username = properties
.get(PredefinedConnectorProperties.USERNAME);
String password = properties
.get(PredefinedConnectorProperties.PASSWORD);
String path = JiraRESTClient.PATH_SEARCH;
String query = "labels=" + label;
List<IssueDTO> issues = JiraRESTClient.getIssues(url, username, password,
path, query);
return issues;
}
@Override
@Transactional(readOnly = true)
public void syncOrderElementsWithJiraIssues(List<IssueDTO> issues, Order order) {
synchronizationInfo = new SynchronizationInfo(_(
"Synchronization order {0}", order.getName()));
for (IssueDTO issue : issues) {
String code = PredefinedConnectorProperties.JIRA_CODE_PREFIX
+ order.getCode() + "-"
+ issue.getKey();
String name = issue.getFields().getSummary();
OrderLine orderLine = syncOrderLine(order, code, name);
if (orderLine == null) {
synchronizationInfo.addFailedReason(_(
"Order-element for \"{0}\" issue not found",
issue.getKey()));
continue;
}
EffortDuration loggedHours = getLoggedHours(issue.getFields()
.getTimetracking());
EffortDuration estimatedHours = getEstimatedHours(issue.getFields()
.getTimetracking(), loggedHours);
if (estimatedHours.isZero()) {
synchronizationInfo.addFailedReason(_(
"Estimated time for \"{0}\" issue is 0",
issue.getKey()));
continue;
}
syncHoursGroup(orderLine, code, estimatedHours.getHours());
syncProgressMeasurement(orderLine, issue, estimatedHours,
loggedHours);
}
}
/**
* Synchronize orderline
*
* check if orderLine is already exist for the given <code>order</code> If
* it is, update <code>OrderLine.name</code> with the specified parameter
* <code>name</code> (jira's name could be changed). If not, create new
* {@link OrderLine} and add to {@link Order}
*
* @param order
* an existing order
* @param code
* unique code for orderLine
* @param name
* name for the orderLine to be added or updated
*/
private OrderLine syncOrderLine(Order order, String code,
String name) {
OrderElement orderElement = order.getOrderElement(code);
if (orderElement != null && !orderElement.isLeaf()) {
return null;
}
OrderLine orderLine = (OrderLine) orderElement;
if (orderLine == null) {
orderLine = OrderLine.create();
orderLine.setCode(code);
order.add(orderLine);
}
orderLine.setName(name);
return orderLine;
}
/**
* Synchronize hoursgroup
*
* Check if hoursGroup already exist for the given <code>orderLine</code>.
* If it is, update <code>HoursGroup.workingHours</code> with the specified
* parameter <code>workingHours</code>. If not, create new
* {@link HoursGroup} and add to the {@link OrderLine}
*
* @param orderLine
* an existing orderline
* @param code
* unique code for hoursgroup
* @param workingHours
* the working hours(jira's timetracking)
*/
private void syncHoursGroup(OrderLine orderLine, String code,
Integer workingHours) {
HoursGroup hoursGroup = orderLine.getHoursGroup(code);
if (hoursGroup == null) {
hoursGroup = HoursGroup.create(orderLine);
hoursGroup.setCode(code);
orderLine.addHoursGroup(hoursGroup);
}
hoursGroup.setWorkingHours(workingHours);
}
/**
* Synchronize progress assignment and measurement
*
* @param orderLine
* an exist orderLine
* @param issue
* jira's issue to synchronize with progress assignment and
* measurement
*/
private void syncProgressMeasurement(OrderLine orderLine, IssueDTO issue,
EffortDuration estimatedHours, EffortDuration loggedHours) {
WorkLogDTO workLog = issue.getFields().getWorklog();
if (workLog == null) {
synchronizationInfo.addFailedReason(_(
"No worklogs found for \"{0}\" issue", issue.getKey()));
return;
}
List<WorkLogItemDTO> workLogItems = workLog.getWorklogs();
if (workLogItems.isEmpty()) {
synchronizationInfo.addFailedReason(_(
"No worklog items found for \"{0}\" issue",
issue.getKey()));
return;
}
BigDecimal percentage;
// if status is closed, the progress percentage is 100% regardless the
// loggedHours and estimatedHours
if (isIssueClosed(issue.getFields().getStatus())) {
percentage = new BigDecimal(100);
} else {
percentage = loggedHours.dividedByAndResultAsBigDecimal(
estimatedHours).multiply(new BigDecimal(100));
}
LocalDate latestWorkLogDate = LocalDate
.fromDateFields(getTheLatestWorkLoggedDate(workLogItems));
updateOrCreateProgressAssignmentAndMeasurement(orderLine,
percentage, latestWorkLogDate);
}
/**
* Get the estimated seconds from
* {@link TimeTrackingDTO#getRemainingEstimateSeconds()} plus logged hours or
* {@link TimeTrackingDTO#getOriginalEstimateSeconds()} and convert it to
* {@link EffortDuration}
*
* @param timeTracking
* where the estimated time to get from
* @param loggedHours
* hours already logged
* @return estimatedHours
*/
private EffortDuration getEstimatedHours(TimeTrackingDTO timeTracking,
EffortDuration loggedHours) {
if (timeTracking == null) {
return EffortDuration.zero();
}
Integer timeestimate = timeTracking.getRemainingEstimateSeconds();
if (timeestimate != null && timeestimate > 0) {
return EffortDuration.seconds(timeestimate).plus(loggedHours);
}
Integer timeoriginalestimate = timeTracking
.getOriginalEstimateSeconds();
if (timeoriginalestimate != null) {
return EffortDuration.seconds(timeoriginalestimate);
}
return EffortDuration.zero();
}
/**
* Get the time spent in seconds from
* {@link TimeTrackingDTO#getTimeSpentSeconds()} and convert it to
* {@link EffortDuration}
*
* @param timeTracking
* where the timespent to get from
* @return timespent in hous
*/
private EffortDuration getLoggedHours(TimeTrackingDTO timeTracking) {
if (timeTracking == null) {
return EffortDuration.zero();
}
Integer timespentInSec = timeTracking.getTimeSpentSeconds();
if (timespentInSec != null && timespentInSec > 0) {
return EffortDuration.seconds(timespentInSec);
}
return EffortDuration.zero();
}
/**
* updates {@link DirectAdvanceAssignment} and {@link AdvanceMeasurement} if
* they already exist, otherwise create new one
*
* @param orderElement
* an existing orderElement
* @param percentage
* percentage for advanced measurement
* @param latestWorkLogDate
* date for advanced measurement
*/
private void updateOrCreateProgressAssignmentAndMeasurement(
OrderElement orderElement, BigDecimal percentage,
LocalDate latestWorkLogDate) {
AdvanceType advanceType = PredefinedAdvancedTypes.PERCENTAGE.getType();
DirectAdvanceAssignment directAdvanceAssignment = orderElement
.getDirectAdvanceAssignmentByType(advanceType);
if (directAdvanceAssignment == null) {
directAdvanceAssignment = DirectAdvanceAssignment.create(false,
new BigDecimal(100).setScale(2));
directAdvanceAssignment.setAdvanceType(advanceType);
try {
orderElement.addAdvanceAssignment(directAdvanceAssignment);
} catch (DuplicateValueTrueReportGlobalAdvanceException e) {
// This couldn't happen as it has just created the
// directAdvanceAssignment with false as reportGlobalAdvance
throw new RuntimeException(e);
} catch (DuplicateAdvanceAssignmentForOrderElementException e) {
// This could happen if a parent or child of the current
// OrderElement has an advance of type PERCENTAGE
synchronizationInfo
.addFailedReason(_(
"Duplicate value AdvanceAssignment for order element of \"{0}\"",
orderElement.getCode()));
return;
}
}
AdvanceMeasurement advanceMeasurement = directAdvanceAssignment
.getAdvanceMeasurementAtExactDate(latestWorkLogDate);
if (advanceMeasurement == null) {
advanceMeasurement = AdvanceMeasurement.create();
advanceMeasurement.setDate(latestWorkLogDate);
directAdvanceAssignment.addAdvanceMeasurements(advanceMeasurement);
}
advanceMeasurement.setValue(percentage
.setScale(2, RoundingMode.HALF_UP));
DirectAdvanceAssignment spreadAdvanceAssignment = orderElement
.getReportGlobalAdvanceAssignment();
if (spreadAdvanceAssignment != null) {
spreadAdvanceAssignment.setReportGlobalAdvance(false);
}
directAdvanceAssignment.setReportGlobalAdvance(true);
}
/**
* check if issue is closed
*
* @param status
* the status of the issue
* @return true if status is Closed
*/
private boolean isIssueClosed(StatusDTO status) {
if (status == null) {
return false;
}
return status.getName().equals("Closed");
}
/**
* Loop through all <code>workLogItems</code> and get the latest date
*
* @param workLogItems
* list of workLogItems
* @return latest date
*/
private Date getTheLatestWorkLoggedDate(List<WorkLogItemDTO> workLogItems) {
List<Date> dates = new ArrayList<Date>();
for (WorkLogItemDTO workLogItem : workLogItems) {
if (workLogItem.getStarted() != null) {
dates.add(workLogItem.getStarted());
}
}
return Collections.max(dates);
}
@Override
public SynchronizationInfo getSynchronizationInfo() {
return synchronizationInfo;
}
/**
* returns JIRA connector
*/
private Connector getJiraConnector() {
return connectorDAO.findUniqueByName(PredefinedConnectors.JIRA
.getName());
}
@Override
@Transactional
public void saveSyncInfo(final String key, final Order order) {
adHocTransactionService
.runOnAnotherTransaction(new IOnTransaction<Void>() {
@Override
public Void execute() {
OrderSyncInfo orderSyncInfo = orderSyncInfoDAO
.findByKeyOrderAndConnectorName(key, order,
PredefinedConnectors.JIRA.getName());
if (orderSyncInfo == null) {
orderSyncInfo = OrderSyncInfo.create(key, order,
PredefinedConnectors.JIRA.getName());
}
orderSyncInfo.setLastSyncDate(new Date());
orderSyncInfoDAO.save(orderSyncInfo);
return null;
}
});
}
@Override
@Transactional(readOnly = true)
public OrderSyncInfo getOrderLastSyncInfo(Order order) {
return orderSyncInfoDAO.findLastSynchronizedInfoByOrderAndConnectorName(
order, PredefinedConnectors.JIRA.getName());
}
@Override
@Transactional
public List<SynchronizationInfo> syncOrderElementsWithJiraIssues() throws ConnectorException {
Connector connector = getJiraConnector();
if (connector == null) {
throw new ConnectorException(_("JIRA connector not found"));
}
if (!connector.areConnectionValuesValid()) {
throw new ConnectorException(
_("Connection values of JIRA connector are invalid"));
}
List<OrderSyncInfo> orderSyncInfos = orderSyncInfoDAO
.findByConnectorName(PredefinedConnectors.JIRA.getName());
synchronizationInfo = new SynchronizationInfo(_("Synchronization"));
List<SynchronizationInfo> syncInfos = new ArrayList<SynchronizationInfo>();
if (orderSyncInfos == null || orderSyncInfos.isEmpty()) {
LOG.warn("No items found in 'OrderSyncInfo' to synchronize with JIRA issues");
synchronizationInfo
.addFailedReason(_("No items found in 'OrderSyncInfo' to synchronize with JIRA issues"));
syncInfos.add(synchronizationInfo);
return syncInfos;
}
for (OrderSyncInfo orderSyncInfo : orderSyncInfos) {
Order order = orderSyncInfo.getOrder();
LOG.info("Synchronizing '" + order.getName() + "'");
synchronizationInfo = new SynchronizationInfo(_(
"Synchronization order {0}", order.getName()));
List<IssueDTO> issueDTOs = getJiraIssues(orderSyncInfo.getKey(),
connector);
if (issueDTOs == null || issueDTOs.isEmpty()) {
LOG.warn("No JIRA issues found for '" + orderSyncInfo.getKey()
+ "'");
synchronizationInfo.addFailedReason(_(
"No JIRA issues found for key {0}",
orderSyncInfo.getKey()));
syncInfos.add(synchronizationInfo);
continue;
}
orderModel.initEdit(order, null);
syncOrderElementsWithJiraIssues(issueDTOs, order);
if (!synchronizationInfo.isSuccessful()) {
syncInfos.add(synchronizationInfo);
continue;
}
orderModel.save(false);
saveSyncInfo(orderSyncInfo.getKey(), order);
jiraTimesheetSynchronizer.syncJiraTimesheetWithJiraIssues(
issueDTOs, order);
if (!synchronizationInfo.isSuccessful()) {
syncInfos.add(synchronizationInfo);
}
}
return syncInfos;
}
}