// check from the backlogId if the associated product is accessible for the current user
 private boolean checkAccess(int backlogId) {
   Product product = (backlogBusiness.getParentProduct(backlogBusiness.retrieve(backlogId)));
   User user = SecurityUtil.getLoggedUser();
   Collection<Team> teams = user.getTeams();
   for (Iterator<Team> iter = teams.iterator(); iter.hasNext(); ) {
     Team team = (Team) iter.next();
     if (team.getProducts().contains(product)) {
       return false;
     }
   }
   return true;
 }
  public void moveItemToBacklog(BacklogItem item, Backlog backlog, boolean ignoreIterationGoal) {

    Backlog oldBacklog = item.getBacklog();
    oldBacklog.getBacklogItems().remove(item);
    item.setBacklog(backlog);
    backlog.getBacklogItems().add(item);
    historyBusiness.updateBacklogHistory(oldBacklog.getId());
    historyBusiness.updateBacklogHistory(backlog.getId());

    if (item.getIterationGoal() != null && !ignoreIterationGoal) {
      item.getIterationGoal().getBacklogItems().remove(item);
      item.setIterationGoal(null);
    }

    if (!backlogBusiness.isUnderSameProduct(oldBacklog, backlog)) {
      // remove only product themes
      Collection<BusinessTheme> removeThese = new ArrayList<BusinessTheme>();
      ;
      for (BusinessTheme theme : item.getBusinessThemes()) {
        if (!theme.isGlobal()) {
          removeThese.add(theme);
        }
      }
      for (BusinessTheme theme : removeThese) {
        item.getBusinessThemes().remove(theme);
      }
    }
  }
  /** {@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;
  }
 public void calculateProjectMetrics(Product product) {
   if (product != null && product.getProjects() != null && product.getProjects().size() > 0) {
     // ProjectData projectDataMap
     for (Project p : product.getProjects()) {
       ProjectMetrics metrics = new ProjectMetrics();
       metrics.setAssignees(backlogBusiness.getNumberOfAssignedUsers(p));
       if (p.getIterations() != null) {
         metrics.setNumberOfAllIterations(p.getIterations().size());
         int ongoingIters = 0;
         Date current = Calendar.getInstance().getTime();
         for (Iteration iter : p.getIterations()) {
           if (iter.getStartDate().getTime() < current.getTime()
               && iter.getEndDate().getTime() > current.getTime()) {
             ongoingIters++;
           }
         }
         metrics.setNumberOfOngoingIterations(ongoingIters);
       } else {
         metrics.setNumberOfAllIterations(0);
         metrics.setNumberOfOngoingIterations(0);
       }
       p.setMetrics(metrics);
     }
   }
 }
 public Map<User, Integer> getUnassignedWorkersMap(Project project) {
   Map<User, Integer> unassignedHasWork = new HashMap<User, Integer>();
   Collection<BacklogItem> blis = getBlisInProjectAndItsIterations(project);
   Collection<User> assignees = backlogBusiness.getUsers(project, true);
   Set<User> workers = new HashSet<User>();
   for (BacklogItem bli : blis) workers.addAll(bli.getResponsibles());
   for (User worker : workers) unassignedHasWork.put(worker, assignees.contains(worker) ? 0 : 1);
   return unassignedHasWork;
 }
  /** {@inheritDoc} */
  public List<User> getAssignableUsers(Project project) {
    Set<User> userSet = new HashSet<User>();

    // Add all assigned users
    userSet.addAll(backlogBusiness.getUsers(project, true));

    // Add all enabled users
    userSet.addAll(userBusiness.getEnabledUsers());

    // Add the users to a list
    List<User> userList = new ArrayList<User>(userSet);

    // Sort the list
    Collections.sort(userList, new UserComparator());

    return userList;
  }
  public BacklogItem storeBacklogItem(
      int backlogItemId,
      int backlogId,
      BacklogItem dataItem,
      Set<Integer> responsibles,
      int iterationGoalId)
      throws ObjectNotFoundException {
    BacklogItem item = null;
    if (backlogItemId > 0) {
      item = backlogItemDAO.get(backlogItemId);
      if (item == null) {
        throw new ObjectNotFoundException("backlogItem.notFound");
      }
    }
    Backlog backlog = backlogBusiness.getBacklog(backlogId);
    if (backlog == null) {
      throw new ObjectNotFoundException("backlog.notFound");
    }

    IterationGoal iterationGoal = null;
    if (iterationGoalId > 0 && backlog instanceof Iteration) {
      iterationGoal = iterationGoalDAO.get(iterationGoalId);
      if (iterationGoal == null) {
        throw new ObjectNotFoundException("iterationGoal.notFound");
      }
    }

    Set<User> responsibleUsers = new HashSet<User>();

    for (int userId : responsibles) {
      User responsible = userBusiness.getUser(userId);
      if (responsible != null) {
        responsibleUsers.add(responsible);
      }
    }

    return this.storeBacklogItem(item, backlog, dataItem, responsibleUsers, iterationGoal);
  }
  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);
  }