/** {@inheritDoc} * */
public void unrank(int projectId) {
Project project = projectDAO.get(projectId);
if (project != null) {
project.setRank(0);
projectDAO.store(project);
}
}
/** {@inheritDoc} */
public ProjectMetrics getProjectMetrics(Project proj) {
ProjectMetrics metrics = new ProjectMetrics();
metrics = projectDAO.getProjectBLIMetrics(proj);
if (metrics == null) {
metrics = new ProjectMetrics();
}
if (metrics.getTotalItems() > 0) {
metrics.setCompletedItems(projectDAO.getDoneBLIs(proj));
}
BacklogMetrics projMetrics = backlogBusiness.calculateLimitedBacklogMetrics(proj);
if (metrics.getEffortLeft() != null) {
metrics.getEffortLeft().add(projMetrics.getEffortLeft());
} else {
metrics.setEffortLeft(projMetrics.getEffortLeft());
}
if (metrics.getOriginalEstimate() != null) {
metrics.getOriginalEstimate().add(projMetrics.getOriginalEstimate());
} else {
metrics.setOriginalEstimate(projMetrics.getOriginalEstimate());
}
metrics.setTotalItems(metrics.getTotalItems() + projMetrics.getTotalItems());
if (metrics.getCompletedItems() != null) {
metrics.setCompletedItems(metrics.getCompletedItems() + projMetrics.getCompletedItems());
} else {
metrics.setCompletedItems(projMetrics.getCompletedItems());
}
if (metrics.getTotalItems() > 0) {
metrics.setPercentDone(
Math.round(
100.0f * (float) metrics.getCompletedItems() / (float) metrics.getTotalItems()));
}
return metrics;
}
/** {@inheritDoc} */
public void moveDown(int projectId) {
Project project = projectDAO.get(projectId);
if (project != null) {
Project upperRankedProject = projectDAO.findFirstUpperRankedOngoingProject(project);
if (upperRankedProject != null) {
int upperRank = upperRankedProject.getRank();
projectDAO.raiseRankBetween(upperRank + 1, null);
project.setRank(upperRank + 1);
projectDAO.store(project);
}
}
}
/** {@inheritDoc} */
public void moveUp(int projectId) {
Project project = projectDAO.get(projectId);
if (project != null) {
Project lowerRankedProject = projectDAO.findFirstLowerRankedOngoingProject(project);
if (lowerRankedProject != null) {
int lowerRank = lowerRankedProject.getRank();
projectDAO.raiseRankBetween(lowerRank, project.getRank());
project.setRank(lowerRank);
projectDAO.store(project);
}
}
}
/** {@inheritDoc} */
public void moveToBottom(int projectId) {
Project project = projectDAO.get(projectId);
if (project != null) {
List<Integer> result = projectDAO.findBiggestRank();
if (result.size() != 0) {
int lowestRank = (Integer) (result.get(0));
if (lowestRank != project.getRank() || lowestRank == 0) {
project.setRank(lowestRank + 1);
projectDAO.store(project);
}
}
}
}
/** {@inheritDoc} */
public void moveToTop(int projectId) {
Project project = projectDAO.get(projectId);
if (project != null && project.getRank() != 1) {
if (project.getRank() == 0) {
projectDAO.raiseRankBetween(1, null);
} else {
projectDAO.raiseRankBetween(1, project.getRank());
}
project.setRank(1);
projectDAO.store(project);
}
}
/** {@inheritDoc} */
public Map<BusinessTheme, AFTime> formatThemeBindings(Project proj) {
Map<BusinessTheme, Collection<BacklogThemeBinding>> tmp =
new HashMap<BusinessTheme, Collection<BacklogThemeBinding>>();
if (proj.getIterations().size() > 0) {
List<BacklogThemeBinding> bindings = projectDAO.getProjectThemeData(proj);
// iteration themes
for (BacklogThemeBinding bind : bindings) {
if (tmp.get(bind.getBusinessTheme()) == null) {
tmp.put(bind.getBusinessTheme(), new ArrayList<BacklogThemeBinding>());
}
tmp.get(bind.getBusinessTheme()).add(bind);
}
}
// project themes
if (proj.getBusinessThemeBindings() != null) {
for (BacklogThemeBinding bind : proj.getBusinessThemeBindings()) {
if (tmp.get(bind.getBusinessTheme()) == null) {
tmp.put(bind.getBusinessTheme(), new ArrayList<BacklogThemeBinding>());
}
tmp.get(bind.getBusinessTheme()).add(bind);
}
}
Map<BusinessTheme, AFTime> ret = new HashMap<BusinessTheme, AFTime>();
// format
for (BusinessTheme theme : tmp.keySet()) {
AFTime sum = new AFTime(0);
for (BacklogThemeBinding bin : tmp.get(theme)) {
sum.add(bin.getBoundEffort());
}
ret.put(theme, sum);
}
return ret;
}
public int countByProjectType(int projectTypeId) {
return projectDAO.countByProjectType(projectTypeId);
}
public int count() {
return projectDAO.count();
}
/** {@inheritDoc} */
public Collection<Project> getOngoingUnrankedProjects() {
return projectDAO.getOngoingUnrankedProjects();
}
/** {@inheritDoc} */
public Collection<Project> getAll() {
return projectDAO.getAll();
}
private void fillProjectPortfolioData(ProjectPortfolioData data) {
HashMap<Project, String> userDataMap = new HashMap<Project, String>();
HashMap<Project, Integer> unassignedUserDataMap = new HashMap<Project, Integer>();
HashMap<Project, String> summaryLoadLeftMap = new HashMap<Project, String>();
HashMap<String, String> loadLeftData = new HashMap<String, String>();
HashMap<String, String> userOverheads = new HashMap<String, String>();
HashMap<String, String> totalUserOverheads = new HashMap<String, String>();
HashMap<String, Integer> unassignedUsersMap = new HashMap<String, Integer>();
Map<Project, List<User>> assignmentMap = new HashMap<Project, List<User>>(0);
Map<Project, List<User>> nonAssignmentMap = new HashMap<Project, List<User>>(0);
Set<String> keySet = new HashSet<String>();
Map<String, Integer> unassignedBlisMap = new HashMap<String, Integer>();
Collection<Project> projects = projectDAO.getOngoingProjects();
// Go trough all projects and bli:s
for (Project pro : projects) {
int assignedUsers = backlogBusiness.getNumberOfAssignedUsers(pro);
int unestimatedBlis = 0;
AFTime ongoingBliLoadLeft = new AFTime(0);
Set<User> allUsers = new HashSet<User>(this.backlogBusiness.getUsers(pro, true));
HashSet<User> projectAssignments =
new HashSet<User>(this.backlogBusiness.getUsers(pro, true));
List<User> nonAssignedUsers = new ArrayList<User>();
/*
* ArrayList<User> assignments = new ArrayList<User>(
* this.backlogBusiness.getUsers(pro, true));
*/
Collection<BacklogItem> blis = getBlisInProjectAndItsIterations(pro);
// Get overheads for users in this project
for (Assignment ass : pro.getAssignments()) {
if (ass.getDeltaOverhead() != null) {
userOverheads.put(
pro.getId() + "-" + ass.getUser().getId(), ass.getDeltaOverhead().toString());
AFTime total = new AFTime(0);
if (pro.getDefaultOverhead() != null) {
total.add(pro.getDefaultOverhead());
}
total.add(ass.getDeltaOverhead());
totalUserOverheads.put(pro.getId() + "-" + ass.getUser().getId(), total.toString());
} else {
if (pro.getDefaultOverhead() != null) {
totalUserOverheads.put(
pro.getId() + "-" + ass.getUser().getId(), pro.getDefaultOverhead().toString());
} else {
totalUserOverheads.put(pro.getId() + "-" + ass.getUser().getId(), "");
}
}
}
for (BacklogItem bli : blis) {
if (bli.getResponsibles() != null) {
ArrayList<User> responsibles = new ArrayList<User>(bli.getResponsibles());
if (bli.getEffortLeft() == null) {
unestimatedBlis++;
allUsers.addAll(bli.getResponsibles());
} else if (bli.getEffortLeft().getTime() != 0) {
ongoingBliLoadLeft.add(bli.getEffortLeft());
allUsers.addAll(bli.getResponsibles());
}
for (User resp : responsibles) {
keySet.add(pro.getId() + "-" + resp.getId());
// Calculate and add effort from bli to user(s) assigned
// Uses projectID-UserId as map key
String effortForUsr = loadLeftData.get(pro.getId() + "-" + resp.getId());
if (effortForUsr != null) {
AFTime usrLoadLeft = new AFTime(effortForUsr);
if (bli.getEffortLeft() != null) {
// Add effort to this user: (bli effort / number
// of people assigned)
AFTime newEffort = new AFTime(bli.getEffortLeft().getTime() / responsibles.size());
usrLoadLeft.add(newEffort);
loadLeftData.put(pro.getId() + "-" + resp.getId(), usrLoadLeft.toString());
}
} else { // no effort for user, create one
if (bli.getEffortLeft() != null) {
AFTime t = new AFTime(bli.getEffortLeft().getTime() / responsibles.size());
loadLeftData.put(pro.getId() + "-" + resp.getId(), t.toString());
}
}
// Check whether user is responsible for a bli in the
// project but is currently not assigned to it
if (!projectAssignments.contains(resp) && bli.getEffortLeft() == null) {
unassignedUsersMap.put(pro.getId() + "-" + resp.getId(), 1);
if (!nonAssignedUsers.contains(resp)) {
nonAssignedUsers.add(resp);
}
} else if (!projectAssignments.contains(resp) && bli.getEffortLeft().getTime() != 0) {
unassignedUsersMap.put(pro.getId() + "-" + resp.getId(), 1);
if (!nonAssignedUsers.contains(resp)) {
nonAssignedUsers.add(resp);
}
}
if (bli.getEffortLeft() == null) {
int numberOfUnestimatedBlis = 1;
if (unassignedBlisMap.get(pro.getId() + "-" + resp.getId()) != null) {
numberOfUnestimatedBlis =
unassignedBlisMap.get(pro.getId() + "-" + resp.getId()) + 1;
}
unassignedBlisMap.put(pro.getId() + "-" + resp.getId(), numberOfUnestimatedBlis);
}
}
}
}
int unassignedUsers = allUsers.size() - assignedUsers;
String userDataString = "" + assignedUsers;
EffortSumData loadData = new EffortSumData();
loadData.setEffortHours(ongoingBliLoadLeft);
loadData.setNonEstimatedItems(unestimatedBlis);
String loadLeftString = loadData.toString();
summaryLoadLeftMap.put(pro, loadLeftString);
userDataMap.put(pro, userDataString);
unassignedUserDataMap.put(pro, unassignedUsers);
assignmentMap.put(pro, new ArrayList<User>(this.backlogBusiness.getUsers(pro, true)));
nonAssignmentMap.put(pro, nonAssignedUsers);
}
for (String key : keySet) {
String value = loadLeftData.get(key);
// Fetch aftime-value and non-estimated items to a
// EffortSumData-object to get correct output string.
AFTime aftimeValue = new AFTime(0);
if (value != null) aftimeValue = new AFTime(value);
int userUnestimatedBlis = 0;
if (unassignedBlisMap.get(key) != null) userUnestimatedBlis += unassignedBlisMap.get(key);
EffortSumData sumData = new EffortSumData();
sumData.setEffortHours(aftimeValue);
sumData.setNonEstimatedItems(userUnestimatedBlis);
value = sumData.toString();
loadLeftData.put(key, value);
}
data.setUnassignedUsers(unassignedUsersMap);
data.setAssignedUsers(assignmentMap);
data.setSummaryUserData(userDataMap);
data.setSummaryUnassignedUserData(unassignedUserDataMap);
data.setSummaryLoadLeftData(summaryLoadLeftMap);
data.setLoadLefts(loadLeftData);
data.setUserOverheads(userOverheads);
data.setTotalUserOverheads(totalUserOverheads);
data.setNonAssignedUsers(nonAssignmentMap);
}