Merge pull request #457 from ncats/ep_extensions3

DBClassificationsCodeProcessor and SetAccessCodeProcessor

Author: ChemMitch

gsrs-module-substances-core/src/main/java/gsrs/module/substance/processors/DBClassificationsCodeProcessor.java

@@ -0,0 +1,120 @@
+package gsrs.module.substance.processors;
+
+import gsrs.springUtils.StaticContextAccessor;
+import ix.core.EntityProcessor;
+import ix.ginas.models.v1.Code;
+import ix.ginas.models.v1.Reference;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.util.HashMap;
+import java.util.Map;
+import javax.sql.DataSource;
+
+import lombok.extern.slf4j.Slf4j;
+
+import org.springframework.boot.jdbc.DataSourceBuilder;
+
+/**
+ * This EntityProcessor will create a Classifications comments string
+ * for the Code using Database as the source
+ *
+ * @author Egor Puzanov
+ */
+
+ @Slf4j
+public class DBClassificationsCodeProcessor implements EntityProcessor<Code> {
+
+    private DataSource datasource = StaticContextAccessor.getBean(DataSource.class);
+    private String codeSystem;
+    private String query;
+
+    public DBClassificationsCodeProcessor() {
+        this(new HashMap<String, Object>());
+    }
+
+    public DBClassificationsCodeProcessor(Map<String, Object> m) {
+        if (m.containsKey("dataSourceQualifier")) {
+            setDataSourceQualifier((String) m.get("dataSourceQualifier"));
+        }
+        if (m.get("datasource") instanceof Map) {
+            @SuppressWarnings("unchecked")
+            Map<String, String> dsconfig = (Map<String, String>) m.get("datasource");
+            setDatasource(dsconfig);
+        }
+        if (m.containsKey("codeSystem")) {
+            setCodeSystem((String) m.get("codeSystem"));
+        }
+        if (m.containsKey("query")) {
+            setQuery((String) m.get("query"));
+        }
+    }
+
+    public void setDataSourceQualifier(String dataSourceQualifier) {
+        this.datasource = StaticContextAccessor.getBeanQualified(DataSource.class, dataSourceQualifier);
+    }
+
+    public void setDatasource(Map<String, String> dsconfig) {
+        this.datasource = DataSourceBuilder.create()
+            .url((String)dsconfig.get("url"))
+            .username((String)dsconfig.get("username"))
+            .password((String)dsconfig.get("password"))
+            .build();
+    }
+
+    public void setCodeSystem(String codeSystem) {
+        this.codeSystem = codeSystem;
+    }
+
+    public void setQuery(String query) {
+        this.query = query;
+    }
+
+    @Override
+    public void prePersist(Code obj) throws EntityProcessor.FailProcessingException {
+        if (codeSystem.equals(obj.codeSystem) && obj.code != null && !obj.code.isEmpty()) {
+            try (Connection c = datasource.getConnection()) {
+                try (PreparedStatement s = c.prepareStatement(query)) {
+                    s.setString(1, obj.getCode());
+                    try (ResultSet rs = s.executeQuery()) {
+                        while (rs.next()) {
+                            String value = rs.getString(1);
+                            if (value != null && value.contains("|") && !value.equals(obj.comments)) {
+                                obj.comments = value;
+                                value = rs.getString(2);
+                                if (value != null && value.startsWith("http") && !value.equals(obj.url)) {
+                                   obj.url = value;
+                                }
+                                value = rs.getString(3);
+                                if (value != null && !value.isEmpty() && obj.getReferences().size() == 0) {
+                                    Reference r = new Reference();
+                                    r.docType = value;
+                                    value = rs.getString(4);
+                                    if (value != null && !value.isEmpty()) {
+                                        r.citation = value;
+                                        obj.addReference(r, obj.getOwner());
+                                    }
+                                }
+                            }
+                            break;
+                        }
+                    }
+                }
+            } catch (Exception ex) {
+                log.error(ex.toString());
+            } finally {
+            }
+        }
+    }
+
+    @Override
+    public void preUpdate(Code obj) throws EntityProcessor.FailProcessingException {
+        prePersist(obj);
+    }
+
+    @Override
+    public Class<Code> getEntityClass() {
+        return Code.class;
+    }
+}

gsrs-module-substances-core/src/main/java/gsrs/module/substance/processors/SetAccessCodeProcessor.java

@@ -0,0 +1,98 @@
+package gsrs.module.substance.processors;
+
+import gov.nih.ncats.common.util.CachedSupplier;
+import gsrs.services.GroupService;
+
+import ix.core.EntityProcessor;
+import ix.core.models.Group;
+import ix.ginas.models.v1.Code;
+
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.springframework.beans.factory.annotation.Autowired;
+
+/**
+ *
+ * @author Egor Puzanov
+ */
+
+public class SetAccessCodeProcessor implements EntityProcessor<Code>{
+
+    private CachedSupplier<Void> initializer = CachedSupplier.runOnceInitializer(this::addGroupsIfNeeded);
+
+    @Autowired
+    private GroupService groupService;
+
+    private final Map<String, Map<Object, Object>> with;
+    private final Map<String, Set<Group>> codeSystemAccess = new HashMap<String, Set<Group>>();
+    private final Set<Group> defaultAccess = new LinkedHashSet<Group>();
+
+    public SetAccessCodeProcessor(Map<String, Map<Object, Object>> with){
+        this.with = with;
+    }
+
+    public SetAccessCodeProcessor(){
+        this(new HashMap<String, Map<Object, Object>>());
+    }
+
+    public void setCodeSystemAccess(Map<Object, Object> o) {
+        this.with.put("codeSystemAccess", o);
+    }
+
+    public Map<String, Set<Group>> getCodeSystemAccess() {
+        return this.codeSystemAccess;
+    }
+
+    public void setDefaultAccess(String o) {
+        setDefaultAccess(new HashMap<Object, Object>());
+    }
+
+    public void setDefaultAccess(Map<Object, Object> o) {
+        this.with.put("defaultAccess", o);
+    }
+
+    public Set<Group> getDefaultAccess() {
+        return this.defaultAccess;
+    }
+
+    public void addGroupsIfNeeded(){
+        defaultAccess.addAll(parseAccess(with.get("defaultAccess")));
+
+        for (Map.Entry<Object, Object> e : with.getOrDefault("codeSystemAccess", new HashMap<Object, Object>()).entrySet()) {
+            codeSystemAccess.put(String.valueOf(e.getKey()), parseAccess(e.getValue()));
+        }
+    }
+
+    private Set<Group> parseAccess(Object accessObj) {
+        Set<Group> access = new LinkedHashSet<Group>();
+        if (accessObj instanceof Map) {
+            @SuppressWarnings("unchecked")
+            Map<Object, Object> accessMap = (Map<Object, Object>) accessObj;
+            for (Object groupName : accessMap.values()) {
+                access.add(groupService.registerIfAbsent(String.valueOf(groupName)));
+            }
+        }
+        return access;
+    }
+
+    @Override
+    public void initialize() throws EntityProcessor.FailProcessingException{
+        initializer.getSync();
+    }
+
+    @Override
+    public void prePersist(Code obj) throws EntityProcessor.FailProcessingException {
+        Set<Group> access = codeSystemAccess.getOrDefault(obj.codeSystem, defaultAccess);
+        if(!access.equals(obj.getAccess())){
+            obj.setAccess(access);
+        }
+    }
+
+    @Override
+    public Class<Code> getEntityClass() {
+        return Code.class;
+    }
+}