path: root/src/main/java/DNPM/DNPMHelper.java

package DNPM;

import ATCCodes.AtcCode;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import de.itc.onkostar.api.Disease;
import de.itc.onkostar.api.IOnkostarApi;
import de.itc.onkostar.api.Item;
import de.itc.onkostar.api.Procedure;
import de.itc.onkostar.api.analysis.AnalyzerRequirement;
import de.itc.onkostar.api.analysis.IProcedureAnalyzer;
import de.itc.onkostar.api.analysis.OnkostarPluginType;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.transform.Transformers;
import org.hibernate.type.StandardBasicTypes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.*;

public class DNPMHelper implements IProcedureAnalyzer {

    private static final Logger logger = LoggerFactory.getLogger(DNPMHelper.class);

    private final IOnkostarApi onkostarApi;

    public DNPMHelper(final IOnkostarApi onkostarApi) {
        this.onkostarApi = onkostarApi;
    }

    @Override
    public OnkostarPluginType getType() {
        // Typ des Plugins
        // Für das Interface IProcedureAnalyzer gültig sind ANALYZER und BACKEND_SERVICE
        return OnkostarPluginType.BACKEND_SERVICE;
    }

    @Override
    public String getVersion() {
        return "1";
    }

    @Override
    public String getName() {
        return "UMR DNPM";
    }

    @Override
    public String getDescription() {
        return "Methoden für DNPM-Formulare";
    }

    @Override
    public boolean isRelevantForDeletedProcedure() {
        return false;
    }

    @Override
    public boolean isSynchronous() {
        return true;
    }

    @Override
    public AnalyzerRequirement getRequirement() {
        return AnalyzerRequirement.PROCEDURE;
    }

    @Override
    public boolean isRelevantForAnalyzer(Procedure entry, Disease currentDisease) {
        // Plugin enthält nur Methoden für Formulare und soll nicht ausgeführt werden
        return false;
    }

    @Override
    public void analyze(Procedure entry, Disease currentDisease) {
        // wird nicht benötigt, da dass Plugin nicht ausgeführt wird
    }

    @SuppressWarnings("unchecked")
    public Object getVerweise(final Map<String, Object> input) {
        int ProcedureId = (int) input.get("ProcedureId");
        int PatientId = (int) input.get("PatientId");
        int value = 0;
        List<Map<String, String>> VerbundeneFormulare = new ArrayList<Map<String, String>>();

        try {
            SessionFactory sessionFactory = onkostarApi.getSessionFactory();
            Session session = sessionFactory.getCurrentSession();
            try {
                String sql = "SELECT prozedur.id AS procedure_id, prozedur.data_form_id, data_catalogue.name AS data_catalogue, data_catalogue_entry.name AS data_catalogue_entry, data_form.description AS formname, prozedur.beginndatum AS datum " +
                        "FROM prozedur " +
                        "LEFT JOIN data_form_data_catalogue ON data_form_data_catalogue.data_form_id = prozedur.data_form_id " +
                        "LEFT JOIN data_catalogue_entry ON data_catalogue_entry.data_catalogue_id = data_form_data_catalogue.data_catalogue_id " +
                        "LEFT JOIN data_catalogue ON data_catalogue.id = data_catalogue_entry.data_catalogue_id " +
                        "LEFT JOIN data_form ON data_form.id = prozedur.data_form_id " +
                        "WHERE patient_id = " + PatientId + " " +
                        "AND geloescht = 0 " +
                        "AND data_catalogue_entry.type = 'formReference' " +
                        "GROUP BY prozedur.id, prozedur.data_form_id, data_catalogue.name, data_catalogue_entry.name";

                SQLQuery query = session.createSQLQuery(sql)
                        .addScalar("procedure_id", StandardBasicTypes.INTEGER)
                        .addScalar("data_form_id", StandardBasicTypes.INTEGER)
                        .addScalar("data_catalogue", StandardBasicTypes.STRING)
                        .addScalar("data_catalogue_entry", StandardBasicTypes.STRING)
                        .addScalar("formname", StandardBasicTypes.STRING)
                        .addScalar("datum", StandardBasicTypes.DATE);

                query.setResultTransformer(Transformers.aliasToBean(VerweisVon.class));
                List<VerweisVon> result = query.list();
                try {
                    for (VerweisVon var : result) {
                        sql = var.getSQL();
                        query = session.createSQLQuery(sql)
                                .addScalar("value", StandardBasicTypes.INTEGER);
                        if (query.uniqueResult() != null) {
                            value = (Integer) query.uniqueResult();
                        }
                        if (value == ProcedureId) {
                            VerbundeneFormulare.add(Map.of("formular", var.getVerbundenesFormular()));
                            value = 0;
                        }
                    }
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            } catch (Exception e) {
                return null;
            }
        } catch (Exception e) {
            return null;
        }
        return VerbundeneFormulare;
    }

    public List<Map<String, String>> getSystemischeTherapienFromDiagnose(final Map<String, Object> input) {
        var diagnoseId = input.get("DiagnoseId");

        if (null == diagnoseId || Integer.parseInt(diagnoseId.toString()) == 0) {
            logger.error("Kein Parameter 'DiagnoseId' angegeben, gebe 'null' zurück");
            return null;
        }

        List<Map<String, String>> result = new ArrayList<>();
        for (Procedure Prozedur : onkostarApi.getProceduresForDiseaseByForm(Integer.parseInt(diagnoseId.toString()), "OS.Systemische Therapie")) {
            result.add(getProzedurwerte(Prozedur));
        }
        return result;
    }

    private static Map<String, String> getProzedurwerte(Procedure Prozedur) {
        List<String> wirkstoffListe = new ArrayList<>();
        // SubstanzenCodesListe enthält die Liste der SubstanzenCodes
        List<Map<String, String>> substanzenCodesListe = new ArrayList<>();

        // alle Werte der Prozedur auslesen
        Map<String, Item> alleWerte = Prozedur.getAllValues();
        // Prozedurwerte enthält nur die interessanten Werte
        Map<String, String> prozedurwerte = new HashMap<>();
        // alle Werte durchgehen und die interessanten übernehmen
        if (alleWerte.containsKey("Beendigung")) {
            prozedurwerte.put("Beendigung", alleWerte.get("Beendigung").getValue());
        }
        if (alleWerte.containsKey("Ergebnis")) {
            prozedurwerte.put("Ergebnis", alleWerte.get("Ergebnis").getValue());
        }
        if (alleWerte.containsKey("Beginn")) {
            prozedurwerte.put("Beginn", alleWerte.get("Beginn").getString());
        }
        if (alleWerte.containsKey("Ende")) {
            prozedurwerte.put("Ende", alleWerte.get("Ende").getString());
        }
        if (alleWerte.containsKey("SubstanzenList")) {
            List<Map<String, String>> substanzList = alleWerte.get("SubstanzenList").getValue();
            for (var substanz : substanzList) {
                var substanzCodes = getSubstanzCode(substanz);
                substanzenCodesListe.add(substanzCodes);
                wirkstoffListe.add(substanzCodes.get("substance"));
            }
        }

        prozedurwerte.put("Wirkstoffe", String.join(", ", wirkstoffListe));
        try {
            ObjectMapper mapper = new ObjectMapper();
            prozedurwerte.put("WirkstoffCodes", mapper.writeValueAsString(substanzenCodesListe));
        } catch (JsonProcessingException e) {
            logger.error("Kann 'WirkstoffCodes' nicht in JSON-String mappen", e);
        }

        return prozedurwerte;
    }

    private static Map<String, String> getSubstanzCode(Map<String, String> substanz) {
        Map<String, String> substanzCode = new HashMap<>();
        if (substanz.containsKey("Substanz")) {
            if (AtcCode.isAtcCode(substanz.get("Substanz"))) {
                substanzCode.put("system", "ATC");
            } else {
                substanzCode.put("system", "other");
            }
            substanzCode.put("code", substanz.get("Substanz"));

        }
        if (substanz.containsKey("Substanz_shortDescription")) {
            substanzCode.put("substance", substanz.get("Substanz_shortDescription"));
        }
        return substanzCode;
    }

    public Object getProzedurenFromDiagnose(final Map<String, Object> input) {
        String dataForm = (String) input.get("dataForm");
        int DiagnoseId = (int) input.get("DiagnoseId");
        int PatientId = (int) input.get("PatientId");
        // Prozedur, Feldname, Wert

        List<Object> Formulare = new ArrayList<Object>();
        String jsonStr = "";
        List<Procedure> Prozeduren = onkostarApi.getProceduresByPatientId(PatientId);
        for (Procedure Prozedur : Prozeduren) {
            // Formular gehört zur aktuellen Diagnose und hat den angegebenen Namen
            if (Prozedur.getDiseaseIds().contains(DiagnoseId) && Prozedur.getFormName().contains(dataForm)) {
                // alle Werte auslesen
                Map<String, Item> Werte = Prozedur.getAllValues();
                Map<String, Object> Values = new HashMap<>();
                for (Map.Entry<String, Item> WerteListe : Werte.entrySet()) {
                    Values.put(WerteListe.getKey(), WerteListe.getValue());
//          System.out.println(WerteListe.getKey() + ": " + WerteListe.getValue());
                }
                Map<String, Object> Formular = new HashMap<>();
                Formular.put("Formular", Prozedur.getFormName());
                Formular.put("Felder", Values);
                Formulare.add(Formular);
            }
        }
        ObjectMapper Obj = new ObjectMapper();
        try {
            jsonStr = Obj.writeValueAsString(Formulare);
        } catch (JsonProcessingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return jsonStr;
    }

    public Object getEmpfehlung(final Map<String, Object> input) {
        // Auslesen der Parameter aus 'input'
        int ProcedureID = (int) input.get("ProcedureID");

        String sql;
        try {
            SessionFactory sessionFactory = onkostarApi.getSessionFactory();
            Session session = sessionFactory.getCurrentSession();
            try {
                sql = "SELECT * FROM prozedur "
                        + "LEFT JOIN dk_mtb_einzelempfehlung em ON em.id = prozedur.id "
                        + "WHERE prozedur.hauptprozedur_id = " + ProcedureID + " AND prozedur.geloescht = 0 AND prozedur.data_form_id = 489 "
                        + "ORDER BY beginndatum";

                SQLQuery query = session.createSQLQuery(sql)
                        .addScalar("id", StandardBasicTypes.STRING)
                        .addScalar("genname", StandardBasicTypes.STRING)
                        .addScalar("geneid", StandardBasicTypes.STRING)
                        .addScalar("geneidlink", StandardBasicTypes.STRING)
                        .addScalar("empfehlung", StandardBasicTypes.STRING)
                        .addScalar("beginndatum", StandardBasicTypes.STRING);

                @SuppressWarnings("unchecked")
                List<String[]> rows = query.list();
                return rows;
            } catch (Exception e) {
                return null;
            }
        } catch (Exception e) {
            return null;
        }
    }

    public Object updateEmpfehlungPrio(final Map<String, Object> input) {
        // Auslesen der Parameter aus 'input'
        //int rid = (int) input.get("rid");
        Object rid = input.get("rid");
        Object strDate = input.get("bd");
        SQLQuery result = null;

        //String strD = strDate.toString();
        //String CompareDate = strD.substring(1, 11);

        //DateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd");

        String sql;

        try {
            sql = "UPDATE prozedur SET beginndatum = '" + strDate + "' WHERE id = '" + rid + "' ";
            result = onkostarApi.getSessionFactory().getCurrentSession().createSQLQuery(sql);
            result.executeUpdate();
            return true;

        } catch (Exception e) {
            return "Achtung: Ein Fehler ist aufgetreten, Änderung konnte nicht gespeichert werden!";
            //return null;
        }

    }
}