コード例 #1
0
ファイル: Project.java プロジェクト: skatsman/kunagi
 public List<Task> getClaimedTasks(User user) {
   List<Task> tasks = new ArrayList<Task>();
   for (Requirement req : getRequirements()) {
     tasks.addAll(req.getClaimedTasks(user));
   }
   return tasks;
 }
コード例 #2
0
  private Widget createCardSlots() {
    TableBuilder tb = new TableBuilder();
    tb.setWidth(null);
    for (User user : getCurrentProject().getTeamMembers()) {
      boolean currentUser = user == getCurrentUser();
      RequirementEstimationVote vote = requirement.getEstimationVote(user);
      Float estimation = vote == null ? null : vote.getEstimatedWork();
      LOG.debug("Estimation:", user.getName(), "->", estimation);

      Widget card;
      if (estimation == null) {
        card = null;
      } else {
        ClickHandler clickHandler = null;
        String clickTooltip = null;
        if (requirement.isWorkEstimationVotingShowoff()) {
          clickHandler = new SelectEstimationClickHandler(estimation);
          clickTooltip =
              "Use this card as the estimation for this Story. Planning Poker will be closed.";
        } else if (currentUser) {
          clickHandler = new RemoveEstimationClickHandler();
          clickTooltip = "Remove this card from table.";
        }
        boolean visible = requirement.isWorkEstimationVotingShowoff();
        card = new PlanningPokerCardWidget(estimation, visible, clickHandler, clickTooltip);
      }

      tb.add(new PlanningPokerCardSlotWidget(user.getName(), card));
      tb.add(Gwt.createSpacer(5, 1));
    }
    return tb.createTable();
  }
コード例 #3
0
  @Override
  protected Widget onExtendedInitialization() {
    Requirement requirement = getObject();

    requirementWidget =
        new RequirementWidget(requirement, false, false, true, false, false, false, false);
    taskList = new BlockListWidget<Task>(TaskInRequirementBlock.FACTORY);
    taskList.setAutoSorter(requirement.getTasksOrderComparator());
    if (requirement.getProject().isTeamMember(getCurrentUser())) {
      taskList.setDndSorting(true);
      taskList.setMoveObserver(new MoveObserver());
    }
    createTaskButton = new ButtonWidget(new CreateTaskAction(requirement));
    changeHistoryWidget = new ChangeHistoryWidget(requirement);

    FlowPanel left = new FlowPanel();
    left.add(requirementWidget);
    left.add(taskList);
    left.add(Gwt.createDiv("CreateTaskButtonWrapper", createTaskButton));
    left.add(changeHistoryWidget);

    right = new FlowPanel();
    if (requirement.isDecidable() && requirement.getProject().isProductOwner(getCurrentUser())) {
      right.add(RequirementWidget.createActionsPanelForCompletedRequirement(requirement));
      right.add(Gwt.createSpacer(1, 10));
    }
    right.add(ScrumGwt.createEmoticonsAndComments(requirement));

    bodyWidget = TableBuilder.row(20, left, right);
    return bodyWidget;
  }
コード例 #4
0
ファイル: Requirement.java プロジェクト: lacimol/kunagi
 public static int sumBurnedWork(Iterable<Requirement> requirements) {
   int sum = 0;
   for (Requirement requirement : requirements) {
     sum += requirement.getBurnedWork();
   }
   return sum;
 }
コード例 #5
0
ファイル: Project.java プロジェクト: skatsman/kunagi
 public boolean deleteTask(Task task) {
   for (Requirement requirement : getRequirements()) {
     boolean b = requirement.getTasks().remove(task);
     if (b) return true;
   }
   return false;
 }
コード例 #6
0
ファイル: Project.java プロジェクト: skatsman/kunagi
 public List<Requirement> getRequirementsByThemes(Collection<String> themes) {
   List<Requirement> ret = new ArrayList<Requirement>();
   for (Requirement requirement : getRequirements()) {
     for (String theme : themes) {
       if (requirement.containsTheme(theme) && !ret.contains(requirement)) ret.add(requirement);
     }
   }
   return ret;
 }
コード例 #7
0
ファイル: Project.java プロジェクト: skatsman/kunagi
 public List<Requirement> getProductBacklogRequirements() {
   List<Requirement> ret = new ArrayList<Requirement>();
   for (Requirement requirement : getRequirements()) {
     if (requirement.isClosed()) continue;
     if (requirement.isInCurrentSprint()) continue;
     ret.add(requirement);
   }
   return ret;
 }
コード例 #8
0
ファイル: Task.java プロジェクト: h4ck4thon/kunagi
 @Override
 public void updateLocalModificationTime() {
   super.updateLocalModificationTime();
   try {
     Requirement requirement = getRequirement();
     if (requirement != null) requirement.updateLocalModificationTime();
   } catch (EntityDoesNotExistException ex) {
     return;
   }
 }
コード例 #9
0
 @Override
 protected void onExecute() {
   DateAndTime time = DateAndTime.now();
   for (int i = 0; i < COUNT; i++) {
     final Requirement req = new Requirement(getCurrentProject());
     req.setLabel("Generated Story " + time + " - #" + i);
     req.setDescription(longText());
     req.setTestDescription(longText());
     dao.createRequirement(req);
   }
 }
コード例 #10
0
ファイル: Project.java プロジェクト: skatsman/kunagi
 public List<String> getThemes() {
   Set<String> themes = new HashSet<String>();
   for (Requirement requirement : getRequirements()) {
     if (requirement.isClosed()) continue;
     themes.addAll(requirement.getThemes());
   }
   for (Issue issue : getIssues()) {
     if (issue.isClosed()) continue;
     themes.addAll(issue.getThemes());
   }
   List<String> ret = new ArrayList<String>(themes);
   Collections.sort(ret);
   return ret;
 }
コード例 #11
0
ファイル: Task.java プロジェクト: h4ck4thon/kunagi
 public String getLongLabel(boolean showOwner, boolean showRequirement) {
   StringBuilder sb = new StringBuilder();
   sb.append(getLabel());
   if (showOwner && isOwnerSet()) {
     sb.append(" (").append(getOwner().getName()).append(')');
   }
   if (showRequirement) {
     Requirement requirement = getRequirement();
     sb.append(" (")
         .append(requirement.getReference())
         .append(" ")
         .append(requirement.getLabel())
         .append(')');
   }
   return sb.toString();
 }
コード例 #12
0
 @Override
 protected void onUpdateHeader(BlockHeaderWidget header) {
   Requirement requirement = getObject();
   header.setDragHandle(requirement.getReference());
   Image statusImage = null;
   if (requirement.isRejected()) {
     statusImage = Img.bundle.reqRejected().createImage();
     statusImage.setTitle("Rejected.");
   } else if (requirement.isClosed()) {
     statusImage = Img.bundle.reqClosed().createImage();
     statusImage.setTitle("Accepted.");
   } else if (requirement.isTasksClosed()) {
     statusImage = Img.bundle.reqTasksClosed().createImage();
     statusImage.setTitle("All tasks done.");
   }
   statusIcon.setWidget(statusImage);
 }
コード例 #13
0
  @Override
  protected void onInitializationHeader(BlockHeaderWidget header) {
    Requirement requirement = getObject();

    decidableOnInitialization = requirement.isDecidable();

    statusIcon = header.addIconWrapper();
    header.addText(requirement.getLabelModel());
    header.addText(requirement.getThemesAsStringModel(), true, false);
    header.addText(requirement.getTaskStatusLabelModel(), true);
    header.appendCell(new EmoticonsWidget(requirement), null, true);
    header.addMenuAction(new RejectRequirementAction(requirement));
    header.addMenuAction(new FixRequirementAction(requirement));
    header.addMenuAction(new CloseRequirementAction(requirement));
    header.addMenuAction(new ReopenRequirementAction(requirement));
    header.addMenuAction(new RemoveRequirementFromSprintAction(requirement));
    header.addMenuAction(new ActivateChangeHistoryAction(requirement));
    header.addMenuAction(new CreateTaskAction(requirement));
  }
コード例 #14
0
  @Override
  protected Widget onInitialization() {
    list = new BlockListWidget<Task>(new TaskBlock.TaskBlockFactory(container), this.dropAction);
    list.setSelectionManager(container.getSelectionManager());
    list.setMinHeight(100);
    list.setAutoSorter(requirement.getTasksOrderComparator());
    if (requirement.getProject().isTeamMember(getCurrentUser())) {
      list.setDndSorting(createTaskButton);
      list.setMoveObserver(new MoveObserver());
    }

    FlowPanel panel = new FlowPanel();
    panel.add(list);
    if (createTaskButton)
      panel.add(
          Gwt.createDiv(
              "CreateTaskButtonWrapper",
              new ButtonWidget(new CreateTaskAction(requirement)).update()));

    return panel;
  }
コード例 #15
0
  private Widget createHandCards() {
    Project project = getCurrentProject();
    RequirementEstimationVote vote = requirement.getEstimationVote(getCurrentUser());
    Float voteValue = vote == null ? null : vote.getEstimatedWork();
    boolean showoff = requirement.isWorkEstimationVotingShowoff();

    TableBuilder tb = new TableBuilder();
    tb.setWidth(null);

    // ?-card
    PlanningPokerCardWidget qCard = null;
    if (!showoff && (voteValue == null || -1 != voteValue)) {
      qCard =
          new PlanningPokerCardWidget(
              -1, true, new SetEstimationClickHandler(-1), "Put this card on the table.");
    }
    tb.add(new PlanningPokerCardSlotWidget("I don't know.", qCard));
    tb.add(Gwt.createSpacer(5, 1));

    // value cards
    for (String value : Requirement.WORK_ESTIMATION_VALUES) {
      if (value.length() == 0) continue;
      float estimation = Float.parseFloat(value);
      PlanningPokerCardWidget card = null;
      if (!showoff && (voteValue == null || estimation != voteValue)) {
        card =
            new PlanningPokerCardWidget(
                estimation,
                true,
                new SetEstimationClickHandler(estimation),
                "Put this card on the table.");
      }
      tb.add(new PlanningPokerCardSlotWidget(value + " " + project.getEffortUnit(), card));
      tb.add(Gwt.createSpacer(5, 1));
    }

    return tb.createTable();
  }
コード例 #16
0
ファイル: TaskBlock.java プロジェクト: aaronzhang/kunagi
 @Override
 protected void onUpdateHeader(BlockHeaderWidget header) {
   Task task = getObject();
   header.setDragHandle(task.getReference());
   Image statusImage = null;
   if (task.isClosed()) {
     statusImage = Img.bundle.tskClosed().createImage();
     statusImage.setTitle("Closed.");
   } else if (task.isBlocked()) {
     statusImage = Img.bundle.tskBlocked().createImage();
     statusImage.setTitle("Blocked by " + task.getImpediment().getReferenceAndLabel() + ".");
   } else if (task.isOwnerSet()) {
     statusImage = Img.bundle.tskClaimed().createImage();
     statusImage.setTitle("Claimed by " + task.getOwner().getName() + ".");
   }
   statusIcon.setWidget(statusImage);
   if (requirementLabel != null) {
     Requirement req = task.getRequirement();
     requirementLabel.setText(req.getReference() + " " + req.getLabel());
   }
   if (ownerLabel != null)
     ownerLabel.setText(task.isOwnerSet() ? task.getOwner().getName() : null);
   header.setCenter(task.getLabel());
 }
コード例 #17
0
ファイル: Project.java プロジェクト: skatsman/kunagi
 public void updateRequirementsModificationTimes() {
   for (Requirement requirement : getRequirements()) {
     requirement.updateLocalModificationTime();
   }
 }
コード例 #18
0
ファイル: CreateTaskAction.java プロジェクト: hjimenez/kunagi
 @Override
 protected void onExecute() {
   Task task = requirement.createNewTask();
   Scope.get().getComponent(ProjectWorkspaceWidgets.class).showTask(task);
 }
コード例 #19
0
ファイル: Project.java プロジェクト: skatsman/kunagi
  /** @param relative The story, before which the new story should be placed. Optional. */
  public Requirement createNewRequirement(Requirement relative, boolean before, boolean split) {
    Requirement item = new Requirement(this);

    if (split) {
      String theme = relative.getLabel();
      List<String> themes = relative.getThemes();
      if (!themes.contains(theme)) themes.add(theme);

      relative.setThemes(themes);
      relative.setDirty(true);

      item.setEpic(relative);
      item.setThemes(themes);
      item.setDescription(relative.getDescription());
      item.setTestDescription(relative.getTestDescription());
      item.setQualitys(relative.getQualitys());
    }

    if (relative == null) {
      updateRequirementsOrder();
    } else {
      List<Requirement> requirements = getProductBacklogRequirements();
      requirements.remove(item);
      Collections.sort(requirements, getRequirementsOrderComparator());
      int idx = requirements.indexOf(relative);
      if (!before) idx++;
      requirements.add(idx, item);
      updateRequirementsOrder(requirements);
    }

    getDao().createRequirement(item);
    return item;
  }