public void updateUserStoryWhenUpdateIssue() {
   if (this.issue.getIssueId() != null) {
     updateIssue();
     UserStory userStoryOfIssue = this.issue.getUserStory();
     if (userStoryOfIssue != null) {
       // Update status userstory
       boolean updateStatusUs = false;
       UserStory.StatusType status =
           userStoryService.findStatusOfUserStoryBySprintAndUserStory(
               userStoryOfIssue, this.sprint);
       if (userStoryOfIssue.getStatus().compareTo(status) != 0) {
         updateStatusUs = true;
       }
       userStoryOfIssue.setPriority(PriorityType.valueOf(issue.getPriority()));
       userStoryOfIssue.setStatus(status);
       userStoryOfIssue.setName(this.issue.getSubject());
       userStoryOfIssue.setDescription(this.issue.getDescription());
       userStoryOfIssue.setNote(this.issue.getNote());
       if (userStoryService.update(userStoryOfIssue)) {
         userStoryService.updateAllIssueOfUserStoryHaveTheSameContent(userStoryOfIssue);
         // update kanbanissue status belong to userstory
         if (!sprintService.isPastSprint(issue.getSprint()) && updateStatusUs) {
           kanbanIssueService.updateAllKanbanIssueByUserStoryStatusOfTeam(
               userStoryOfIssue, sprint.getTeam());
         }
       }
     }
   }
   // Reset issueList and issue value
   resetIssueForm();
   resetIssueValue();
   resetAttachmentList();
   refreshIssueListTable();
 }
 public void selectTeam(long selectedTeamId) {
   teamId = selectedTeamId;
   sprints = sprintService.findSprintsByTeamId(teamId);
   try {
     selectSprint(sprints.get(0).getSprintId());
   } catch (Exception e) {
     LOGGER.warn(e);
     selectSprint(0);
   }
 }
 public void verifyTeamId() {
   try {
     boolean isContain = false;
     for (Team t : teams) {
       if (t.getTeamId() == teamId) {
         isContain = true;
         break;
       }
     }
     if (!isContain) {
       selectTeam(teams.get(0).getTeamId());
     } else {
       sprints = sprintService.findSprintsByTeamId(teamId);
     }
   } catch (Exception e) {
     LOGGER.warn(e);
     selectTeam(0);
   }
 }
 /** Delete an issue and delete its all attachment */
 public void deleteIssue() {
   Issue issueTemp = this.issue;
   try {
     this.attachmentListByIssue = this.attachmentService.findAttachmentByIssue(this.issue);
     if (this.attachmentListByIssue != null) {
       for (Attachment att : this.attachmentListByIssue) {
         this.attachmentService.deleteFile(
             att.getDiskFilename(),
             this.projectService.findProjectOfIssue(this.issue).getProjectId());
         this.attachmentService.delete(att);
       }
     }
     List<History> historyOfIssue = new ArrayList<History>();
     historyOfIssue = historyService.findHistoryByContainer("Issue", this.issue.getIssueId());
     for (History history : historyOfIssue) {
       historyService.delete(history);
     }
     Issue issueParent = issueTemp.getParent();
     this.issueService.deleteIssue(this.issue);
     // delete kanban issue if has the same subject with issue
     // check exist kanban issue by content and userstory
     // check last sprint of team
     Sprint lastSprint = sprintService.findLastSprintByTeamId(teamId);
     if (lastSprint != null
         && lastSprint.getSprintId().compareTo(issueTemp.getSprint().getSprintId()) == 0) {
       kanbanIssueService.deleteKanbanIssueByIssueId(issueTemp.getIssueId());
     }
     if (issueParent != null) {
       issueService.updateStatusOfIssueParent(issueParent);
     }
     resetIssueForm();
     resetIssueValue();
     this.issueList.remove(issueTemp);
     this.filteredIssues = new ArrayList<Issue>(this.issueList);
     this.selectedIssues = new ArrayList<Issue>();
     resetAttachmentList();
   } catch (Exception a) {
     a.printStackTrace();
     logger.error("delete issue unsuccessful", a);
   }
 }
 public boolean isPastSprint(Sprint sprint) {
   return sprintService.isPastSprint(sprint);
 }
  @SuppressWarnings("static-access")
  public void updateIssue() {
    try {
      // String typeFormatPoint = ""; TODO Knight check to use or delete
      // typeFormatPoint = this.issueService.checkingPointFormat(estimatePoint); TODO Knight check
      // to use or delete

      String remainPoint = this.issue.getRemain();
      String estimatePoint = this.issue.getEstimate();
      estimatePoint = this.issueService.checkingEstimatePoint(estimatePoint);
      remainPoint = this.issueService.checkingRemainPoint(remainPoint);

      if ((this.issue.getStatus() != null)
          && (this.issue.getStatus().getType() == Status.StatusType.START)) {
        remainPoint = estimatePoint;
      }

      issueService.updatePointRemain(remainPoint, this.issue.getIssueId());
      this.issue.setRemain(remainPoint);
      this.issue.setEstimate(estimatePoint);
      this.issue.setPointFormat("1"); // alway set default format is DT

      // Remove Control Characters
      this.issue.setSubject(this.issue.getSubject().replaceAll("\\p{Cntrl}", ""));
      this.issue.setNote(this.issue.getNote().replaceAll("\\p{Cntrl}", ""));
      this.issue.setDescription(this.issue.getDescription().trim().replaceAll("\\p{Cntrl}", ""));
      this.issueService.updateIssue(this.issue);
      // check last sprint of team
      Sprint lastSprint = sprintService.findLastSprintByTeamId(teamId);

      if (lastSprint != null
          && lastSprint.getSprintId().compareTo(issue.getSprint().getSprintId()) == 0) {
        // update kanban issue if exist
        kanbanIssueService.updateKanbanIssueByIssueId(issue.getIssueId());
      }

      if (this.issue.getParent() != null) {
        issueService.updateStatusOfIssueParent(this.issue.getParent());
        // check update status us when sprint is valid time
        if (!sprintService.isPastSprint(issue.getSprint())) {
          // Update status userstory
          UserStory userStory = userStoryService.findUserStoryByIssue(this.issue);
          UserStory.StatusType status =
              userStoryService.findStatusOfUserStoryBySprintAndUserStory(userStory, this.sprint);

          if (userStory.getStatus().compareTo(status) != 0) {
            userStory.setStatus(status);
            userStoryService.update(userStory);
            // update kanbanissue status belong to userstory
            kanbanIssueService.updateAllKanbanIssueByUserStoryStatusOfTeam(
                userStory, sprint.getTeam());
          }
        }
      }

      updateRemainPointPerDay(this.issue);

      JSFUtils.addCallBackParam("edited", true);
      JSFUtils.addSuccessMessage("msgs", this.utils.getMessage("myagile.UpdateSuccess", null));
    } catch (Exception e) {
      JSFUtils.addWarningMessage("msgs", this.utils.getMessage("myagile.UpdateUnsuccess", null));
    }
  }
  @SuppressWarnings("static-access")
  public void saveIssue() {
    // update userstory
    try {
      String estimatePoint = this.issue.getEstimate().trim();
      // this.issue.setPointFormat(this.issueService.checkingPointFormat(estimatePoint));
      this.issue.setPointFormat("1"); // default DT format
      estimatePoint = this.issueService.checkingEstimatePoint(estimatePoint);
      this.issue.setEstimate(estimatePoint);
      this.issue.setRemain(estimatePoint);

      // Remove Control Characters
      this.issue.setSubject(this.issue.getSubject().replaceAll("\\p{Cntrl}", ""));
      this.issue.setNote(this.issue.getNote().replaceAll("\\p{Cntrl}", ""));
      this.issue.setDescription(this.issue.getDescription().trim().replaceAll("\\p{Cntrl}", ""));

      if (this.issueService.saveIssue(this.issue)) {
        // check last sprint of team
        Sprint lastSprint = sprintService.findLastSprintByTeamId(teamId);
        if (lastSprint != null
            && lastSprint.getSprintId().compareTo(issue.getSprint().getSprintId()) == 0) {
          // check exist kanban issue by content and userstory
          if (!kanbanIssueService.existKanbanIssueByUserStoryAndSubject(
              this.issue.getParent().getUserStory(), this.issue.getSubject())) {
            // add new kanban issue
            KanbanIssue addKanbanIssue = new KanbanIssue();
            addKanbanIssue.setUserStory(this.issue.getParent().getUserStory());
            addKanbanIssue.setSubject(this.issue.getSubject());
            addKanbanIssue.setDescription(this.issue.getDescription());
            addKanbanIssue.setNote(this.issue.getNote());
            addKanbanIssue.setColumnDone(false);
            addKanbanIssue.setRemain(this.issue.getRemain());
            addKanbanIssue.setEstimate(this.issue.getEstimate());
            addKanbanIssue.setPointFormat("1");
            addKanbanIssue.setType("Task");
            addKanbanIssue.setIsSubIssue(false);
            addKanbanIssue.setTeam(issue.getSprint().getTeam());
            addKanbanIssue.setIssueOfLastSprint(issue.getIssueId());
            kanbanIssueService.saveKanbanIssue(addKanbanIssue);
          }
        }
      }
      issueService.updateStatusOfIssueParent(this.issue.getParent());

      // check update status us when sprint is valid time
      if (!sprintService.isPastSprint(issue.getSprint())) {
        // Update status userstory
        UserStory userStory = this.userStoryService.findUserStoryByIssue(this.issue);
        UserStory.StatusType status = this.userStoryService.findStatusOfUserStory(userStory);
        if (userStory.getStatus().compareTo(status) != 0) {
          userStory.setStatus(status);
          this.userStoryService.update(userStory);
          // update kanbanissue status belong to userstory
          kanbanIssueService.updateAllKanbanIssueByUserStoryStatusOfTeam(
              userStory, sprint.getTeam());
        }
      }

      addAttachment();
      // insert into point remain
      updateRemainPointPerDay(this.issue);
      JSFUtils.addCallBackParam("save", true);
      JSFUtils.addSuccessMessage("msgs", this.utils.getMessage("myagile.SaveSuccess", null));
    } catch (Exception e) {
      JSFUtils.addWarningMessage("msgs", this.utils.getMessage("myagile.SaveUnsucces", null));
    }
  }