How to use se.cambio.cds.gdl.model

@Override
public int compare(Rule o1, Rule o2) {
  return o2.getPriority() - o1.getPriority();
}

private String getArchetypeKey(ArchetypeBinding archetypeBinding) {
  return archetypeBinding.getDomain() + "|" + archetypeBinding.getArchetypeId() + archetypeBinding.getTemplateId();
}

public String getLanguage() {
  return termDefinition.getId();
}

private void bindExpressions(Guide guide) throws Exception {
  List<String> preConditions = guide.getDefinition().getPreConditions();
  List<ExpressionItem> preConditionExpressions = parseExpressions(preConditions);
  guide.getDefinition().setPreConditionExpressions(preConditionExpressions);
  List<String> defaultActions = guide.getDefinition().getDefaultActions();
  List<ExpressionItem> expressionItems = parseExpressions(defaultActions);
  List<AssignmentExpression> defaultActionExpressions = toAssignments(expressionItems);
  guide.getDefinition().setDefaultActionExpressions(defaultActionExpressions);
  GuideDefinition definition = guide.getDefinition();
  if (definition.getArchetypeBindings() != null) {
    Map<String, ArchetypeBinding> bindings = definition
        .getArchetypeBindings();
    for (ArchetypeBinding binding : bindings.values()) {
      List<ExpressionItem> predicateStatements = parseExpressions(binding.getPredicates());
      binding.setPredicateStatements(predicateStatements);
    }
    if (definition.getRules() != null) {
      Collection<Rule> rules = definition.getRules().values();
      for (Rule rule : rules) {
        List<ExpressionItem> whenStatements = parseExpressions(rule.getWhen());
        rule.setWhenStatements(whenStatements);
        List<ExpressionItem> thenExpressionItems = parseExpressions(rule.getThen());
        List<AssignmentExpression> thenStatements = toAssignments(thenExpressionItems);
        rule.setThenStatements(thenStatements);
      }
    }
  }
}

  public static Map<String, String> getGtCodeElementIdMap(Guide guide, String domainId) {
    Map<String, String> gtCodeElementIdMap = new HashMap<>();
    if (guide.getDefinition() == null || guide.getDefinition().getArchetypeBindings() == null) {
      return gtCodeElementIdMap;
    }
    for (ArchetypeBinding archetypeBinding : guide.getDefinition().getArchetypeBindings().values()) {
      if (domainId == null || archetypeBinding.getDomain() == null || domainId.equals(archetypeBinding.getDomain())) {
        for (ElementBinding elementBinding : archetypeBinding.getElements().values()) {
          gtCodeElementIdMap.put(elementBinding.getId(), archetypeBinding.getArchetypeId() + elementBinding.getPath());
        }
      }
    }
    return gtCodeElementIdMap;
  }
}

private void processRuleLines(Guide guide, Rule rule, GraphNode graphNode) throws InternalErrorException {
  for (ExpressionItem expressionItem : guide.getDefinition().getPreConditionExpressions()) {
    addExpressionNodes(guide.getId(), expressionItem, graphNode);
  }
  for (ExpressionItem expressionItem : rule.getWhenStatements()) {
    addExpressionNodes(guide.getId(), expressionItem, graphNode);
  }
  for (ExpressionItem expressionItem : rule.getThenStatements()) {
    addExpressionNodes(guide.getId(), expressionItem, graphNode);
  }
}

private void generateGTCodeMapForRules(Guide guide) {
  for (Rule rule : guide.getDefinition().getRules().values()) {
    FiredRuleInstantiationRuleLine frirl = new FiredRuleInstantiationRuleLine();
    frirl.setGTCode(rule.getId());
    frirl.setReadableGuide(readableGuide);
    gtCodeElementMap.put(rule.getId(), frirl);
  }
}

private Map<String, String> generateGtCodeToArchetypeMap(Guide guide) {
  Map<String, String> gtCodeToArchetypeKey = new HashMap<>();
  for (ArchetypeBinding archetypeBinding : guide.getDefinition().getArchetypeBindings().values()) {
    String archetypeKey = getArchetypeKey(archetypeBinding);
    for (ElementBinding elementBinding : archetypeBinding.getElements().values()) {
      gtCodeToArchetypeKey.put(elementBinding.getId(), archetypeKey);
    }
  }
  return gtCodeToArchetypeKey;
}

private void generateArchetypeNodes(Guide guide) {
  for (ArchetypeBinding archetypeBinding : guide.getDefinition().getArchetypeBindings().values()) {
    String archetypeKey = getArchetypeKey(archetypeBinding);
    String label = archetypeBinding.getDomain() + " | " + archetypeBinding.getArchetypeId();
    Color archetypeBindingColor = getArchetypeNodeColor(archetypeBinding);
    GraphNode archetypeNode = new GraphNodeBuilder()
        .setLabel(label)
        .setShape(GraphNode.Shape.RECTANGLE)
        .setFillColor(archetypeBindingColor)
        .createGraphNode();
    getArchetypeNodesMap().put(archetypeKey, archetypeNode);
  }
}

public static Set<String> getGTCodesInWrites(Guide guide) {
  Set<String> gtCodes = new HashSet<>();
  if (guide.getDefinition() == null || guide.getDefinition().getRules() == null) {
    return gtCodes;
  }
  //Rules
  for (Rule rule : guide.getDefinition().getRules().values()) {
    gtCodes.addAll(getGTCodesInWrites(rule));
  }
  return gtCodes;
}

public static Collection<ArchetypeReference> getArchetypeReferences(Guide guide, DateTime dateTime, boolean resolvePredicates) {
  Collection<ArchetypeReference> archetypeReferences = new ArrayList<>();
  Map<String, ArchetypeBinding> abs = guide.getDefinition().getArchetypeBindings();
  if (abs != null) {
    for (ArchetypeBinding archetypeBinding : abs.values()) {
      ArchetypeReference ar = getGeneratedArchetypeReference(archetypeBinding, guide.getId(), guide, dateTime, resolvePredicates);
      archetypeReferences.add(ar);
    }
  }
  return archetypeReferences;
}

private String getName(String gtCode) {
  Term term = getTermDefinition().getTerms().get(gtCode);
  if (term != null) {
    return term.getText();
  } else {
    log.error("Unknown term for gtCode='" + gtCode + "'");
    return "*UNKNOWN*";
  }
}

public static Set<String> getPreconditionGTCodesInReads(Guide guide) {
  Set<String> gtCodes = new HashSet<>();
  List<ExpressionItem> preConditionExpressions = guide.getDefinition().getPreConditionExpressions();
  if (preConditionExpressions != null) {
    for (ExpressionItem expressionItem : preConditionExpressions) {
      addGTCodesInReads(expressionItem, gtCodes);
    }
  }
  return gtCodes;
}

private static Collection<String> getDefaultActionGTCodesInReads(Guide guide) {
  Set<String> gtCodes = new HashSet<>();
  List<AssignmentExpression> defaultActionExpressions = guide.getDefinition().getDefaultActionExpressions();
  if (defaultActionExpressions != null) {
    for (ExpressionItem expressionItem : defaultActionExpressions) {
      addGTCodesInReads(expressionItem, gtCodes);
    }
  }
  return gtCodes;
}

public static TermDefinition getTermDefinition(Guide guide, String lang) {
  TermDefinition termDefinition = null;
  if (guide.getOntology() != null) {
    if (guide.getOntology().getTermDefinitions() != null) {
      termDefinition = guide.getOntology().getTermDefinitions().get(lang);
      if (termDefinition == null) {
        termDefinition = guide.getOntology().getTermDefinitions().get(lang);
      }
    }
  }
  if (termDefinition == null) {
    termDefinition = new TermDefinition();
    guide.getOntology().getTermDefinitions().put(lang, termDefinition);
  }
  return termDefinition;
}

public static Set<String> getGTCodesInWrites(Rule rule) {
  Set<String> gtCodes = new HashSet<>();
  if (rule.getThenStatements() != null) {
    for (ExpressionItem expressionItem : rule.getThenStatements()) {
      addGTCodesInWrites(expressionItem, gtCodes);
    }
  }
  return gtCodes;
}

public static void generatePredicateElements(
    ArchetypeBinding archetypeBinding, ArchetypeReference ar, String guideId, Guide guide, DateTime dateTime, boolean resolvePredicates) {
  if (archetypeBinding.getPredicateStatements() != null) {
    for (ExpressionItem expressionItem : archetypeBinding.getPredicateStatements()) {
      if (expressionItem instanceof BinaryExpression) {
        generatePredicateElementsForBinaryExpression(archetypeBinding, ar, guideId, guide, dateTime, resolvePredicates, (BinaryExpression) expressionItem);
      } else if (expressionItem instanceof UnaryExpression) {
        generatePredicateElementsForUnaryExpression(archetypeBinding, ar, guide, dateTime, resolvePredicates, (UnaryExpression) expressionItem);
      }
    }
  }
}

private Collection<BinaryExpression> getSimpleConditionsFromExpressionItems(Guide guide, Rule rule) {
  Collection<BinaryExpression> simpleConditionsExpressionItems = new ArrayList<>();
  for (ExpressionItem expressionItem : guide.getDefinition().getPreConditionExpressions()) {
    addSimpleConditionsFromExpressionItems(expressionItem, simpleConditionsExpressionItems);
  }
  for (ExpressionItem expressionItem : rule.getWhenStatements()) {
    addSimpleConditionsFromExpressionItems(expressionItem, simpleConditionsExpressionItems);
  }
  for (ExpressionItem expressionItem : rule.getThenStatements()) {
    addSimpleConditionsFromExpressionItems(expressionItem, simpleConditionsExpressionItems);
  }
  return simpleConditionsExpressionItems;
}

private static void addGtCodesForRules(Guide guide, Set<String> gtCodes) {
  for (Rule rule : guide.getDefinition().getRules().values()) {
    gtCodes.addAll(getGTCodesInReads(rule));
  }
}

public static Set<String> getGTCodesInReads(Guide guide) {
  Set<String> gtCodes = new HashSet<>();
  if (guide.getDefinition() == null || guide.getDefinition().getRules() == null) {
    return gtCodes;
  }
  addGtCodesForRules(guide, gtCodes);
  addGtCodesForPreconditions(guide, gtCodes);
  addGtCodesForDefaultActions(guide, gtCodes);
  return gtCodes;
}