public static void replaceTask(JobPlan object, ObjectBroker Objbroker) throws IOException {
    String[] Patterns = consistencyUtils.getUpdatePattern(ProcessSpecificCLI.U_REPTASK);
    String OldValue = Patterns[0];
    String NewValue = Patterns[1];

    Iterator<JobPlanTask> TaskIt = object.taskIterator();
    while (TaskIt.hasNext()) {
      JobPlanTask oriTask = TaskIt.next();
      if (oriTask.getTaskName().contains(OldValue)) {

        String NewTaskName = oriTask.getTaskName().replace(OldValue, NewValue);
        // make sure its a valid object?

        boolean NewTaskexists = true;
        List<SearchResultItem> items = Objbroker.searches.searchObject(NewTaskName);
        if (items.isEmpty()) {
          System.out.println(
              " -- Error: Trying to replace with non-existant task: "
                  + NewTaskName
                  + " (Hint: Pattern for replacement may be incorrect?)");
          NewTaskexists = false;
        }
        if (NewTaskexists) {
          JobPlanTask jptask = Objbroker.jobPlans.getTaskFromName(NewTaskName);
          // [ Origin Task Type | Origin Task Name | Origin Task position ] => [ New Task Type | New
          // Task Name | New Task position ]
          System.out.println(
              "\t ++ UPDATE: Replace Task from JobPlan : "
                  + " [ "
                  + oriTask.getType()
                  + " | "
                  + oriTask.getTaskName()
                  + " | {"
                  + oriTask.getX()
                  + ","
                  + oriTask.getY()
                  + "} ] => "
                  + " [ "
                  + jptask.getType()
                  + " | "
                  + jptask.getTaskName()
                  + " | {"
                  + oriTask.getX()
                  + ","
                  + oriTask.getY()
                  + "} ]");
          object.replaceTask(oriTask, jptask);
        }
      }
    }
  }
 public static void addTask(JobPlan object, ObjectBroker Objbroker) throws IOException {
   List<SearchResultItem> items =
       Objbroker.searches.searchExecutableObjects(ProcessSpecificCLI.U_ADDTASK);
   if (items.isEmpty()) {
     System.out.println(" %% No Task Found Matching Pattern: " + ProcessSpecificCLI.U_ADDTASK);
   } else {
     for (int g = 0; g < items.size(); g++) {
       JobPlanTask jptask = Objbroker.jobPlans.getTaskFromName(items.get(g).getName());
       jptask.setX(g + 1);
       jptask.setY(2);
       System.out.println(
           "\t ++ UPDATE: Add Task to JobPlan: [ "
               + jptask.getTaskName()
               + " | "
               + jptask.getType()
               + " | {"
               + jptask.getX()
               + ","
               + jptask.getY()
               + "} ]");
       object.addTask(jptask);
       object.format();
     }
   }
 }
  public static void removeTask(WorkflowLoop object, ObjectBroker Objbroker) {
    Iterator<JobPlanTask> TaskIt = object.iterator();
    ArrayList<JobPlanTask> TasksToRemove = new ArrayList<JobPlanTask>();

    while (TaskIt.hasNext()) {
      JobPlanTask task = TaskIt.next();
      try {
        if (task.getTaskName().matches(ProcessSpecificCLI.U_REMTASK)) {
          System.out.println(
              "\t ++ UPDATE: Remove Task from JobPlan: [ "
                  + task.getTaskName()
                  + " | "
                  + task.getType()
                  + " | {"
                  + task.getX()
                  + ","
                  + task.getY()
                  + "} ]");
          TasksToRemove.add(task);
          // object.removeTask(task);
        }
      } catch (PatternSyntaxException e) {
        System.out.println(
            " -- Internal Error. The Regular Expression Used for one of the Filters is invalid - See Error Below: "
                + e.getDescription());
        System.out.println("\t\t" + e.toString());
        System.out.println(
            " %% HINT: '*' and '+' are NOT valid Regular Expressions on their own. '*' marks '0 or more' and '+' marks '1 or more', but you need to specify a preceeding character or string");
        System.out.println(
            " %% HINT: Ex: invalid expressions: '*ABC*', '*.123', '+DEF'. Valid expressions: '.*ABC.*', '.*.123', '.+DEF' ");

        System.exit(999);
      }
    }
    // seems like the for loop below could have been included in the while loop above? it cant
    // because it creates a problem of concurrence of requests (due to the fact that the removeTask
    // method uses also an iterator!!)
    for (int j = 0; j < TasksToRemove.size(); j++) {
      object.removeTask(TasksToRemove.get(j));
    }
  }
 public static void delTaskDepLatest(JobPlan object, ObjectBroker Objbroker) {
   ArrayList<JobPlanTask> selectedTasks = GetMatchingTaskList(object, Objbroker);
   for (int i = 0; i < selectedTasks.size(); i++) {
     JobPlanTask jptask = selectedTasks.get(i);
     jptask.dependencies().setAtTheLatest(false);
     System.out.println(
         "\t ++ UPDATE: Remove Latest Option on Task Dependency: [ {"
             + jptask.getTaskName()
             + "("
             + jptask.getLnr()
             + ") | "
             + jptask.getType()
             + " | {"
             + jptask.getX()
             + ","
             + jptask.getY()
             + "} ]");
   }
 }
  public static void addTaskAtPosition(JobPlan object, ObjectBroker Objbroker) throws IOException {

    String[] RawVals = ProcessSpecificCLI.U_ADDTASKATPOSITION.split(","); // splits ["TASK","1","2"]
    String TaskName = RawVals[0].replace("[", "");
    String PosX = RawVals[1];
    int iPosX = Integer.parseInt(PosX);
    String PosY = RawVals[2].replace("]", "");
    int iPosY = Integer.parseInt(PosY);
    System.out.println(" ++ Adding Task: " + TaskName + " at: [" + iPosX + "," + iPosY + "]");
    JobPlanTask jptask = Objbroker.jobPlans.getTaskFromName(TaskName);
    jptask.setX(iPosX);
    jptask.setY(iPosY);
    System.out.println(
        "\t ++ UPDATE: Add Task to JobPlan: [ "
            + jptask.getTaskName()
            + " | "
            + jptask.getType()
            + " | {"
            + jptask.getX()
            + ","
            + jptask.getY()
            + "} ]");
    object.addTask(jptask);
  }
  public static ArrayList<JobPlanTask> GetMatchingTaskList(JobPlan object, ObjectBroker Objbroker) {
    // contains the list of tasks to modify in currently processing workflow
    ArrayList<JobPlanTask> selectedTasks = new ArrayList<JobPlanTask>();
    String TaskNameFilter = ProcessSpecificCLI.F_TASKNAME;
    String TaskNumberFilter = ProcessSpecificCLI.F_TASKNUMBER;

    if (ProcessSpecificCLI.F_TASKNAME == null || ProcessSpecificCLI.F_TASKNAME.equals("")) {
      TaskNameFilter = ".*";
    }
    if (ProcessSpecificCLI.F_TASKNUMBER == null || ProcessSpecificCLI.F_TASKNUMBER.equals("")) {
      TaskNumberFilter = ".*";
    }

    Iterator<JobPlanTask> iter = object.taskIterator();
    while (iter.hasNext()) {
      JobPlanTask jpt = iter.next();
      if (jpt.getTaskName().matches(TaskNameFilter)) {
        if (Integer.toString(jpt.getLnr()).matches(TaskNumberFilter)) {
          selectedTasks.add(jpt);
        }
      }
    }
    return selectedTasks;
  }
  public static void CopyTaskPreConditions(WorkflowIF object, ObjectBroker Objbroker)
      throws IOException {
    // contains the list of tasks to modify in currently processing workflow
    ArrayList<JobPlanTask> selectedTasks = new ArrayList<JobPlanTask>();
    String TaskFilter = ProcessSpecificCLI.L_F_TASKNAME;
    if (ProcessSpecificCLI.F_TASKNAME.equals("")) {
      TaskFilter = ".*";
    }
    Iterator<JobPlanTask> FalseIter = object.falseTasksIterator();
    while (FalseIter.hasNext()) {
      JobPlanTask jpt = FalseIter.next();
      if (jpt.getTaskName().matches(TaskFilter)) {
        selectedTasks.add(jpt);
      }
    }
    Iterator<JobPlanTask> TrueIter = object.falseTasksIterator();
    while (TrueIter.hasNext()) {
      JobPlanTask jpt = TrueIter.next();
      if (jpt.getTaskName().matches(TaskFilter)) {
        selectedTasks.add(jpt);
      }
    }
    // at this point, we know which tasks to update in the current workflow..
    String[] Patterns =
        consistencyUtils.getUpdatePattern(ProcessSpecificCLI.U_COPY_TASK_PRECONDITIONS);
    String JobNameToCopy = Patterns[0];
    String WorkflowNameToCopy = Patterns[1];
    // MISSING: check for the existence of both ... eventually ?

    // getting the actual task to copy from.
    UC4Object wrkObj = Objbroker.common.openObject(WorkflowNameToCopy, true);
    boolean WorkflowAndTaskOriginFound = true;
    if (wrkObj == null) {
      System.out.println(
          "\t -- Error. Workflow used as origin could not be found: " + WorkflowNameToCopy);
      WorkflowAndTaskOriginFound = false; // Workflow doesnt exist
    }

    if (WorkflowAndTaskOriginFound) {
      JobPlan OriJPlan = Objbroker.jobPlans.getJobPlanFromObject(wrkObj);
      JobPlanTask jptOrigin = Objbroker.jobPlans.getTaskFromNameAndJobPlan(OriJPlan, JobNameToCopy);
      if (jptOrigin == null) {
        System.out.println(
            "\t -- Error. Workflow used as origin was found, but a corrsponding task for the following object cound not be found: "
                + JobNameToCopy);
        WorkflowAndTaskOriginFound = false; // task doesnt exist
      }
      if (WorkflowAndTaskOriginFound) {
        // getting all preconditions in an array
        ArrayList<ConditionOrAction> AllActionsToCopy = new ArrayList<ConditionOrAction>();
        Iterator<ConditionOrAction> AllActionsIter = jptOrigin.preConditions().iterator();
        while (AllActionsIter.hasNext()) {
          ConditionOrAction CoA = AllActionsIter.next();
          AllActionsToCopy.add(CoA);
        }

        // Now, for each selected Tasks we copy over all preconditions
        for (int y = 0; y < selectedTasks.size(); y++) {
          System.out.println(
              "\t ++ UPDATE: Task Marked for PreCondition Copy - [Task Destination] <= [Task Source]: "
                  + "[ "
                  + selectedTasks.get(y).getTaskName()
                  + ":"
                  + object.getName()
                  + " ] <= [ "
                  + JobNameToCopy
                  + ":"
                  + WorkflowNameToCopy
                  + " ]");
          selectedTasks.get(y).preConditions().clear();
          for (int t = 0; t < AllActionsToCopy.size(); t++) {
            selectedTasks.get(y).preConditions().add(AllActionsToCopy.get(t));
          }
        }
      }
    }
  }
  public static void addDependency(JobPlan object, ObjectBroker Objbroker) throws IOException {

    // format can be ["TASKNAME","PREDECESSORNAME","STATUS"] or:
    // ["TASKNAME(4)","PREDECESSORNAME","STATUS"] or: ["TASKNAME","PREDECESSORNAME(5)","STATUS"]
    // => the task number isnt mandatory but is useful when the same job exists as several tasks
    // within one same WF

    // Getting the task Name and Task Number (if passed)
    String[] RawVals = ProcessSpecificCLI.U_ADDDEPENDENCY.split(",");
    String TaskName = RawVals[0].replace("[", "");
    String SanitizedTaskName = "";
    int TaskNameNumber = -1;
    String SanitizedPredecessorTaskName = "";
    int PredecessorTaskNameNumber = -1;
    if (TaskName.contains("(") && TaskName.contains(")")) {
      SanitizedTaskName = TaskName.split("\\(")[0];
      TaskNameNumber = Integer.parseInt(TaskName.split("\\(")[1].replace(")", ""));
    } else {
      SanitizedTaskName = TaskName;
    }

    // Getting the Predecessor task Name and Task Number (if passed)
    String TaskPredecessor = RawVals[1];
    String TaskStatus = RawVals[2].replace("]", "");

    if (TaskPredecessor.contains("(") && TaskPredecessor.contains(")")) {
      SanitizedPredecessorTaskName = TaskPredecessor.split("\\(")[0];
      PredecessorTaskNameNumber =
          Integer.parseInt(TaskPredecessor.split("\\(")[1].replace(")", ""));
    } else {
      SanitizedPredecessorTaskName = TaskPredecessor;
    }

    // Getting the task state.. no control here :(
    TaskState tState = new TaskState(TaskStatus);

    // handling the case where the Task Name is END (end of WF)
    ArrayList<JobPlanTask> TaskList = new ArrayList<JobPlanTask>();
    if (SanitizedTaskName.equalsIgnoreCase("END")) {
      TaskList.add(object.getEndTask());
    } else {
      TaskList = Objbroker.jobPlans.getTasksFromNameAndJobPlan(object, SanitizedTaskName);
    }

    // handling the case where the Predecessor Task Name is START (start of WF)
    ArrayList<JobPlanTask> PredecessorTaskList = new ArrayList<JobPlanTask>();
    if (SanitizedPredecessorTaskName.equalsIgnoreCase("START")) {
      PredecessorTaskList.add(object.getStartTask());
    } else {
      PredecessorTaskList =
          Objbroker.jobPlans.getTasksFromNameAndJobPlan(object, SanitizedPredecessorTaskName);
    }

    // For each task found
    for (int h = 0; h < TaskList.size(); h++) {
      JobPlanTask jptask = TaskList.get(h);
      // for each predecessor found
      for (int k = 0; k < PredecessorTaskList.size(); k++) {
        JobPlanTask jppredecessortask = PredecessorTaskList.get(k);
        // only create a dependency if: eithere there is no task number specified or.. if they
        // match.
        if ((TaskNameNumber == -1 || jptask.getLnr() == TaskNameNumber)
            && (PredecessorTaskNameNumber == -1
                || jppredecessortask.getLnr() == PredecessorTaskNameNumber)) {
          System.out.println(
              "\t ++ UPDATE: Adding Dependency to: "
                  + jptask.getTaskName()
                  + "("
                  + jptask.getLnr()
                  + ")"
                  + " on: "
                  + jppredecessortask.getTaskName()
                  + "("
                  + jppredecessortask.getLnr()
                  + ")"
                  + " in Status: "
                  + tState
                  + "");
          jptask.dependencies().addDependency(jppredecessortask, tState);
        }
      }
    }
  }