How to use

Guide

in

se.cambio.cds.gdl.model

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;
}

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(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;
}

GDLDecisionModelBuilder(Collection<Guide> guides, ElementInstanceCollectionManager elementInstanceCollectionManager) {
  this.elementInstanceCollectionManager = elementInstanceCollectionManager;
  guideMap = new HashMap<>();
  for (Guide guide : guides) {
    guideMap.put(guide.getId(), guide);
  }
}

@Override
public Map<String, Object> getEntityObjectsMap() throws InternalErrorException {
  String lang = getLanguage();
  ReadableGuide readableGuide = guideImporter.importGuide(getEntity(), lang);
  Collection<String> htmlReadableRules = getHTMLReadableRules(readableGuide, lang);
  List<RuleLine> definitionRuleLines = readableGuide.getDefinitionRuleLines().getRuleLines();
  Collection<String> definitionsHtmlEhr = getHTMLRuleLines(getDefinitionRuleLinesByDomainId(definitionRuleLines, Domains.EHR_ID), lang);
  Collection<String> definitionsHtmlCds = getHTMLRuleLines(getDefinitionRuleLinesByDomainId(definitionRuleLines, Domains.CDS_ID), lang);
  Collection<String> definitionsHtmlAny = getHTMLRuleLines(getDefinitionRuleLinesByDomainId(definitionRuleLines, null), lang);
  Collection<String> preconditionsHtml = getHTMLRuleLines(readableGuide.getPreconditionRuleLines().getRuleLines(), lang);
  Collection<String> defaultActionsHtml = getHTMLRuleLines(readableGuide.getDefaultActions().getRuleLines(), lang);
  Map<String, Object> objectMap = new HashMap<>();
  objectMap.put("guide", getEntity());
  objectMap.put("guide_details", getEntity().getDescription().getDetails().get(lang));
  objectMap.put("guide_definitions_ehr", definitionsHtmlEhr);
  objectMap.put("guide_definitions_cds", definitionsHtmlCds);
  objectMap.put("guide_definitions_any", definitionsHtmlAny);
  objectMap.put("guide_preconditions", preconditionsHtml);
  objectMap.put("guide_default_actions", defaultActionsHtml);
  objectMap.put("guide_rules", htmlReadableRules);
  objectMap.put("guide_terms", getEntity().getOntology().getTermDefinitions().get(lang).getTerms());
  return objectMap;
}

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

private GeneratedElementInstanceCollection processGuide(Guide guide) {
  GeneratedElementInstanceCollection elementInstanceCollection = new GeneratedElementInstanceCollection(elementInstanceCollectionManager);
  GuideUtil.fillElementInstanceCollection(guide, elementInstanceCollection);
  allGuidesMap.put(guide.getId(), guide);
  elementInstanceCollectionByIdGuideMap.put(guide.getId(), elementInstanceCollection);
  return elementInstanceCollection;
}

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);
  }
}

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;
}

  public DecisionGraphPanel generateDecisionGraphPanel(Guide guide, String language) {
    Assert.notNull(guide, "Trying to generate decision graph panel on null guideline!");
    DecisionGraphPanel decisionGraphPanel = null;
    try {
      decisionGraphPanel =
          new DecisionGraphPanel(
              Collections.singleton(guide),
              true,
              language,
              archetypeManager,
              archetypeReferencesManager,
              elementInstanceCollectionManager);
    } catch (GraphRenderingException ex) {
      log.error("Error rendering graph panel for guideline: " + guide.getId(), ex);
    }
    return decisionGraphPanel;
  }
}

private static Set<CodePhrase> getResolvedCodePhrases(Collection<Guide> guides, CodePhrase predicateCodePhrase) {
  if (!"local".equals(predicateCodePhrase.getTerminologyId().getValue())) {
    return Collections.singleton(predicateCodePhrase);
  }
  Set<CodePhrase> codePhrases = new HashSet<>();
  if (guides != null) {
    for (Guide guide : guides) {
      if (guide.getOntology().getTermBindings() != null) {
        for (String terminologyId : guide.getOntology().getTermBindings().keySet()) {
          TermBinding termBinding = guide.getOntology().getTermBindings().get(terminologyId);
          if (termBinding != null) {
            Binding binding = termBinding.getBindings().get(predicateCodePhrase.getCodeString());
            if (binding != null && binding.getCodes() != null) {
              codePhrases.addAll(binding.getCodes());
            }
          }
        }
      }
    }
  } else {
    codePhrases.add(predicateCodePhrase);
  }
  return codePhrases;
}

private Map<RuleReference, ElementInstance> generateElementInstanceByRuleReferenceMap() {
  Map<RuleReference, ElementInstance> allElementInstancesByRuleReference = new HashMap<>();
  for (Guide guide : guideMap.values()) {
    if (guide.getDefinition() != null) {
      for (ArchetypeBinding archetypeBinding : guide.getDefinition().getArchetypeBindings().values()) {
        ArchetypeReference archetypeReference =
            GuideUtil.getGeneratedArchetypeReference(archetypeBinding, guide.getId());
        for (ElementInstance elementInstance : archetypeReference.getElementInstancesMap().values()) {
          if (elementInstance instanceof GeneratedElementInstance) {
            GeneratedElementInstance generatedElementInstance = (GeneratedElementInstance) elementInstance;
            for (RuleReference ruleReference : generatedElementInstance.getRuleReferences()) {
              allElementInstancesByRuleReference.put(ruleReference, elementInstance);
            }
          }
        }
      }
    }
  }
  return allElementInstancesByRuleReference;
}

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;
}

private GraphNode getRuleOrGuideNode(Guide guide, Rule rule) {
  if (GraphGranularity.GUIDE.equals(getGraphGranularity())) {
    GraphGranularity localGranularity = getGranularityForNodeLabel(guide.getId());
    if (GraphGranularity.GUIDE.equals(localGranularity)) {
      return guideNodesMap.get(guide);
    } else {
      return ruleNodesMap.get(rule);
    }
  } else {
    return ruleNodesMap.get(rule);
  }
}

private static DvCodedText getResolvedCodedText(DvCodedText dvCT, Guide guide) {
  CodePhrase cf = null;
  List<TermMapping> mappings = new ArrayList<>();
  if (guide.getOntology().getTermBindings() != null) {
    for (Map.Entry<String, TermBinding> entry : guide.getOntology().getTermBindings().entrySet()) {
      TermBinding termBinding = entry.getValue();
      if (termBinding != null) {
        Binding binding = termBinding.getBindings().get(dvCT.getDefiningCode().getCodeString());
        if (binding != null && binding.getCodes() != null && !binding.getCodes().isEmpty()) {
          cf = binding.getCodes().get(0);
          for (CodePhrase codePhrase : binding.getCodes()) {
            mappings.add(new TermMapping(codePhrase, Match.EQUIVALENT, null, null));
          }
        }
      }
    }
  }
  if (!mappings.isEmpty() && cf != null) {
    return new DvCodedText(dvCT.getValue(), mappings, null, null, null, null, cf, null);
  } else {
    return dvCT;
  }
}

private Map<String, Collection<GuideAssignmentExpression>> generateAllAssignmentsByElementIdMap() {
  Map<String, Collection<GuideAssignmentExpression>> allAssignmentsByElementId = new HashMap<>();
  for (Guide guide : guideMap.values()) {
    if (guide.getDefinition() != null) {
      for (Rule rule : guide.getDefinition().getRules().values()) {
        Collection<AssignmentExpression> simpleAssignmentsFromExpressionItems =
            getSimpleAssignmentsFromExpressionItems(rule.getThenStatements());
        for (AssignmentExpression assignmentExpression : simpleAssignmentsFromExpressionItems) {
          Variable variable = assignmentExpression.getVariable();
          RuleReference ruleReference = new RuleReference(guide.getId(), variable.getCode());
          ElementInstance elementInstance = getElementInstanceByRuleReferenceMap().get(ruleReference);
          if (elementInstance == null) {
            logger.warn("ElementInstance not found for " + ruleReference);
          } else {
            Collection<GuideAssignmentExpression> guideAssignmentExpression =
                allAssignmentsByElementId.computeIfAbsent(elementInstance.getId(), k -> new ArrayList<>());
            guideAssignmentExpression.add(new GuideAssignmentExpression(guide.getId(), assignmentExpression));
          }
        }
      }
    }
  }
  return allAssignmentsByElementId;
}

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;
}

private static DataValue getResolveDataValueIfNeeded(Map<String, Guide> guideMap, Calendar date, ElementInstance ei, Set<String> guideIds) {
  DataValue dv = ei.getDataValue();
  if (ei instanceof PredicateGeneratedElementInstance) {
    Set<String> localGuideIds = new HashSet<>();
    PredicateGeneratedElementInstance pgei = ((PredicateGeneratedElementInstance) ei);
    for (RuleReference ruleReference : pgei.getRuleReferences()) {
      Guide guide = guideMap.get(ruleReference.getGuideId());
      if (guide == null) {
        LoggerFactory.getLogger(ElementInstanceCollectionManager.class).warn("Null guideline for rule reference '" + ruleReference + "'");
      } else {
        localGuideIds.add(guide.getId());
      }
    }
    Collection<Guide> localGuides = new ArrayList<>();
    for (String guideId : localGuideIds) {
      Guide guide = guideMap.get(guideId);
      localGuides.add(guide);
    }
    if (pgei.getOperatorKind().equals(OperatorKind.IS_A)) {
      dv = ei.getDataValue();
    } else {
      dv = resolvePredicate(ei.getDataValue(), pgei.getOperatorKind(), localGuides, date);
    }
    guideIds.addAll(localGuideIds);
  }
  return dv;
}

private Map<String, Collection<GuideBinaryExpressionItem>> generateAllConditionsByElementIdMap() {
  Map<String, Collection<GuideBinaryExpressionItem>> allConditionsByElementId = new HashMap<>();
  for (Guide guide : guideMap.values()) {
    if (guide.getDefinition() != null) {
      for (Rule rule : guide.getDefinition().getRules().values()) {
        Collection<BinaryExpression> simpleConditionsFromExpressionItems =
            getSimpleConditionsFromExpressionItems(guide, rule);
        for (BinaryExpression binaryExpression : simpleConditionsFromExpressionItems) {
          if (binaryExpression.getLeft() instanceof Variable) {
            Variable variable = (Variable) binaryExpression.getLeft();
            RuleReference ruleReference = new RuleReference(guide.getId(), variable.getCode());
            ElementInstance elementInstance = getElementInstanceByRuleReferenceMap().get(ruleReference);
            if (elementInstance == null) {
              if (!OpenEHRConst.CURRENT_DATE_TIME_ID.equals(ruleReference.getGtCode())) {
                logger.warn("ElementInstance not found for " + ruleReference);
              }
            } else {
              Collection<GuideBinaryExpressionItem> guideBinaryExpressionItems =
                  allConditionsByElementId.computeIfAbsent(elementInstance.getId(), k -> new ArrayList<>());
              guideBinaryExpressionItems.add(new GuideBinaryExpressionItem(guide.getId(), binaryExpression));
            }
          }
        }
      }
    }
  }
  return allConditionsByElementId;
}

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;
}