private void validateActionAtEnd(Artifact actionArt) throws OseeCoreException {
    resultData.log("\nValidating End...");
    // Ensure event service is connected
    if (!OseeEventManager.isEventManagerConnected()) {
      resultData.logError("Remote Event Service is not connected");
      return;
    }
    resultData.log("Remote Event Service connected");

    // Validate values
    TeamWorkFlowArtifact teamArt = ActionManager.getFirstTeam(actionArt);
    testEquals(
        "Description",
        "description 4",
        teamArt.getSoleAttributeValue(AtsAttributeTypes.Description, null));
    testEquals("Change Type", ChangeType.Support, ChangeTypeUtil.getChangeType(teamArt));
    testEquals(
        "Priority", "3", teamArt.getSoleAttributeValue(AtsAttributeTypes.PriorityType, null));
    testEquals(
        "Validation Required",
        "false",
        String.valueOf(teamArt.getSoleAttributeValue(AtsAttributeTypes.ValidationRequired, null)));

    IAtsVersion verArt = AtsVersionService.get().getTargetedVersion(teamArt);
    String expectedTargetedVersion;
    if (verArt != null) {
      expectedTargetedVersion = verArt.toString();
    } else {
      expectedTargetedVersion = "not set";
    }
    testEquals("Targeted Version", expectedTargetedVersion, "2.5.7");
    testEquals("State", TeamState.Analyze.getName(), teamArt.getStateMgr().getCurrentStateName());
  }
예제 #2
0
 @Override
 public IAtsVersion store(IAtsVersion version, IAtsTeamDefinition teamDef) {
   Conditions.checkNotNull(version, "version");
   Conditions.checkNotNull(teamDef, "teamDef");
   Conditions.checkNotNull(teamDef.getStoreObject(), "teamDef storeObject");
   IAtsVersion result = version;
   if (version.getStoreObject() == null) {
     Artifact verArt = cacheProvider.get().getArtifact(version);
     if (verArt == null) {
       AtsChangeSet changes = new AtsChangeSet("Create " + version);
       VersionArtifactWriter writer = new VersionArtifactWriter();
       verArt = writer.store(version, cacheProvider.get(), changes);
       changes.relate(teamDef, AtsRelationTypes.TeamDefinitionToVersion_Version, verArt);
       version.setStoreObject(verArt);
       changes.execute();
     }
   }
   return result;
 }
예제 #3
0
 private IAtsTeamWorkflow setTargetedVersionLink(IAtsTeamWorkflow teamWf, IAtsVersion version)
     throws OseeCoreException {
   Artifact versionArt =
       ArtifactQuery.checkArtifactFromId(version.getGuid(), AtsUtilCore.getAtsBranch());
   if (versionArt != null) {
     TeamWorkFlowArtifact teamArt = TeamWorkFlowManager.getTeamWorkflowArt(teamWf);
     if (teamArt != null) {
       teamArt.setRelations(
           AtsRelationTypes.TeamWorkflowTargetedForVersion_Version,
           Collections.singleton(versionArt));
       return teamArt;
     } else {
       throw new OseeStateException(
           "Team Workflow artifact does not exist [%s]", teamWf.toStringWithId());
     }
   } else {
     throw new OseeStateException(
         "Version artifact does not exist [%s]", version.toStringWithId());
   }
 }
예제 #4
0
 private IAtsVersion getSelectedVersionArtifact() throws OseeCoreException {
   if (versionCombo == null) {
     return null;
   }
   String versionStr = versionCombo.get();
   if (!Strings.isValid(versionStr)) {
     return null;
   }
   Collection<IAtsTeamDefinition> teamDefs = getSelectedTeamDefinitions();
   if (teamDefs.size() > 0) {
     IAtsTeamDefinition teamDefHoldingVersions =
         teamDefs.iterator().next().getTeamDefinitionHoldingVersions();
     if (teamDefHoldingVersions == null) {
       return null;
     }
     for (IAtsVersion versionArtifact :
         teamDefHoldingVersions.getVersions(VersionReleaseType.Both, VersionLockedType.Both)) {
       if (versionArtifact.getName().equals(versionStr)) {
         return versionArtifact;
       }
     }
   }
   return null;
 }
예제 #5
0
 @Override
 public void setTeamDefinition(IAtsVersion version, IAtsTeamDefinition teamDef)
     throws OseeCoreException {
   Artifact verArt =
       ArtifactQuery.getArtifactFromId(version.getGuid(), AtsUtilCore.getAtsBranch());
   if (verArt == null) {
     throw new OseeStateException("Version [%s] does not exist.", version);
   }
   Artifact teamDefArt =
       ArtifactQuery.getArtifactFromId(teamDef.getGuid(), AtsUtilCore.getAtsBranch());
   if (teamDefArt == null) {
     throw new OseeStateException("Team Definition [%s] does not exist.", teamDef);
   }
   if (!verArt
       .getRelatedArtifacts(AtsRelationTypes.TeamDefinitionToVersion_TeamDefinition)
       .contains(teamDefArt)) {
     verArt.addRelation(AtsRelationTypes.TeamDefinitionToVersion_TeamDefinition, teamDefArt);
   }
 }
예제 #6
0
  @Override
  public Collection<? extends Artifact> getTaskEditorTaskArtifacts() throws OseeCoreException {
    List<Artifact> workflows = new ArrayList<Artifact>();
    Collection<IAtsTeamDefinition> teamDefs = getSelectedTeamDefinitions();
    IAtsVersion verArt = getSelectedVersionArtifact();
    Collection<Artifact> groups = getSelectedGroups();
    IAtsUser user = getSelectedUser();
    boolean includeCompleted = isIncludeCompletedCheckbox();
    boolean includeCancelled = isIncludeCancelledCheckbox();

    // If user selected, handle that case separately cause it's faster to start with assigned
    if (user != null) {
      Set<TaskArtifact> userTaskArts = getUserAssignedTaskArtifacts();
      if (includeCompleted || includeCancelled) {
        // If include cancelled or completed, need to perform extra search
        // Note: Don't need to do this for Originator, Subscribed or Favorites, cause it does
        // completed canceled in it's own searches
        userTaskArts.addAll(
            Collections.castMatching(
                TaskArtifact.class,
                ArtifactQuery.getArtifactListFromTypeAndAttribute(
                    AtsArtifactTypes.Task,
                    AtsAttributeTypes.State,
                    "<" + user.getUserId() + ">",
                    AtsUtilCore.getAtsBranch(),
                    QueryOption.CONTAINS_MATCH_OPTIONS)));
      }
      Set<TaskArtifact> removeTaskArts = new HashSet<TaskArtifact>();
      for (TaskArtifact taskArt : userTaskArts) {
        if (verArt != null
            && !verArt.equals(
                AtsClientService.get()
                    .getVersionService()
                    .getTargetedVersion(taskArt.getParentTeamWorkflow()))) {
          removeTaskArts.add(taskArt);
        }
        if (!teamDefs.isEmpty()
            && !teamDefs.contains(taskArt.getParentTeamWorkflow().getTeamDefinition())) {
          removeTaskArts.add(taskArt);
        }
      }
      userTaskArts.removeAll(removeTaskArts);
      return filterByCompletedAndStateAndSelectedUser(userTaskArts);
    } // If version specified, get workflows from targeted relation
    if (verArt != null) {
      Collection<IAtsTeamWorkflow> targetedForTeamWorkflows =
          AtsClientService.get().getVersionService().getTargetedForTeamWorkflows(verArt);
      Collection<Artifact> workflowArts = Collections.castAll(targetedForTeamWorkflows);
      for (Artifact art : workflowArts) {
        if (teamDefs.isEmpty()) {
          workflows.add(art);
        }
        // Filter by team def if specified
        else if (teamDefs.contains(((TeamWorkFlowArtifact) art).getTeamDefinition())) {
          workflows.add(art);
        }
      }
    }
    // Else, get workflows from teamdefs
    else if (teamDefs.size() > 0) {
      //         ElapsedTime time = new ElapsedTime("Task Search - Load Team Workflows by Team
      // Defs");
      TeamWorldSearchItem teamWorldSearchItem =
          new TeamWorldSearchItem(
              "",
              teamDefs,
              includeCompleted,
              includeCancelled,
              false,
              false,
              null,
              null,
              ReleasedOption.Both,
              null);
      workflows.addAll(teamWorldSearchItem.performSearchGetResults(false, SearchType.Search));
      //         time.end();
    } else if (groups.size() > 0) {
      Set<TaskArtifact> taskArts = new HashSet<TaskArtifact>();
      for (Artifact groupArt : groups) {
        for (Artifact art :
            groupArt.getRelatedArtifacts(CoreRelationTypes.Universal_Grouping__Members)) {
          if (art.isOfType(AtsArtifactTypes.Task)) {
            taskArts.add((TaskArtifact) art);
          } else if (art instanceof AbstractTaskableArtifact) {
            taskArts.addAll(((AbstractTaskableArtifact) art).getTaskArtifacts());
          }
        }
      }
      return filterByCompletedAndStateAndSelectedUser(taskArts);
    }

    //      ElapsedTime time = new ElapsedTime("Task Search - Bulk Load related tasks");
    // Bulk load tasks related to workflows
    Collection<Artifact> artifacts =
        RelationManager.getRelatedArtifacts(workflows, 1, AtsRelationTypes.TeamWfToTask_Task);
    //      time.end();

    // Apply the remaining criteria
    //      time = new ElapsedTime("Task Search - Filter by remaining criteria");
    Collection<TaskArtifact> tasks = filterByCompletedAndStateAndSelectedUser(artifacts);
    //      time.end();

    return tasks;
  }