Consolidate DrugMapper and OrderMapper versions

api/src/main/java/org/openmrs/module/emrapi/encounter/mapper/DefaultDrugMapper.java

@@ -1,16 +1,22 @@
 package org.openmrs.module.emrapi.encounter.mapper;
 
 import org.openmrs.Drug;
-import org.openmrs.annotation.OpenmrsProfile;
 import org.openmrs.module.emrapi.encounter.DrugMapper;
 import org.openmrs.module.emrapi.encounter.domain.EncounterTransaction;
 import org.springframework.stereotype.Component;
 
 @Component("drugMapper")
-@OpenmrsProfile(openmrsPlatformVersion = "1.9.*")
 public class DefaultDrugMapper implements DrugMapper {
+
     @Override
-    public EncounterTransaction.Drug map(Drug drug) {
-        return null;
+    public EncounterTransaction.Drug map(Drug drug){
+        EncounterTransaction.Drug encounterTransactionDrug = new EncounterTransaction.Drug();
+        encounterTransactionDrug.setName(drug.getDisplayName());
+        if (drug.getDosageForm() != null) {
+            encounterTransactionDrug.setForm(drug.getDosageForm().getName().getName());
+        }
+        encounterTransactionDrug.setStrength(drug.getStrength());
+        encounterTransactionDrug.setUuid(drug.getUuid());
+        return encounterTransactionDrug;
     }
 }

api/src/main/java/org/openmrs/module/emrapi/encounter/mapper/DefaultOrderMapper.java

@@ -13,36 +13,159 @@
  */
 package org.openmrs.module.emrapi.encounter.mapper;
 
+import org.apache.commons.lang3.StringUtils;
+import org.openmrs.Concept;
 import org.openmrs.DrugOrder;
 import org.openmrs.Encounter;
 import org.openmrs.Order;
-import org.openmrs.annotation.OpenmrsProfile;
+import org.openmrs.OrderGroup;
+import org.openmrs.api.db.hibernate.HibernateUtil;
+import org.openmrs.module.emrapi.CareSettingType;
+import org.openmrs.module.emrapi.encounter.ConceptMapper;
 import org.openmrs.module.emrapi.encounter.OrderMapper;
 import org.openmrs.module.emrapi.encounter.domain.EncounterTransaction;
 import org.springframework.stereotype.Component;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
 import java.util.List;
 
-@Component
-@OpenmrsProfile(openmrsPlatformVersion = "1.9.*")
-public class DefaultOrderMapper implements OrderMapper{
+@Component("orderMapper")
+public class DefaultOrderMapper implements OrderMapper {
+
+    private final ConceptMapper conceptMapper = new ConceptMapper();
+
     @Override
     public List<EncounterTransaction.DrugOrder> mapDrugOrders(Encounter encounter) {
-        return null;
+
+        List<EncounterTransaction.DrugOrder> orders = new ArrayList<EncounterTransaction.DrugOrder>();
+        for (Order order : encounter.getOrders()) {
+            order = HibernateUtil.getRealObjectFromProxy(order);
+            if (DrugOrder.class.equals(order.getClass())) {
+                orders.add(mapDrugOrder((DrugOrder) order));
+            }
+        }
+        sortByOrderNumber(orders);
+        return orders;
+    }
+
+    private void sortByOrderNumber(List<EncounterTransaction.DrugOrder> orders) {
+        Collections.sort(orders, new Comparator<EncounterTransaction.DrugOrder>() {
+            @Override
+            public int compare(EncounterTransaction.DrugOrder drugOrder1, EncounterTransaction.DrugOrder drugOrder2) {
+                return drugOrder1.getOrderNumber().compareTo(drugOrder2.getOrderNumber());
+            }
+        });
     }
 
     @Override
     public List<EncounterTransaction.Order> mapOrders(Encounter encounter) {
-        return null;
+        List<EncounterTransaction.Order> orders = new ArrayList<EncounterTransaction.Order>();
+        for (Order order : encounter.getOrders()) {
+            order = HibernateUtil.getRealObjectFromProxy(order);
+            if (Order.class.equals(order.getClass())) {
+                orders.add(mapOrder(order));
+            }
+        }
+        return orders;
     }
 
     @Override
     public EncounterTransaction.DrugOrder mapDrugOrder(DrugOrder openMRSDrugOrder) {
-        return null;
+        EncounterTransaction.DrugOrder drugOrder = new EncounterTransaction.DrugOrder();
+        drugOrder.setUuid(openMRSDrugOrder.getUuid());
+        if (openMRSDrugOrder.getCareSetting() != null) {
+            drugOrder.setCareSetting(CareSettingType.valueOf(openMRSDrugOrder.getCareSetting().getCareSettingType().toString()));
+        }
+        drugOrder.setAction(openMRSDrugOrder.getAction().name());
+        drugOrder.setOrderType(openMRSDrugOrder.getOrderType().getName());
+
+        Order previousOrder = openMRSDrugOrder.getPreviousOrder();
+        if (previousOrder != null && StringUtils.isNotBlank(previousOrder.getUuid())) {
+            drugOrder.setPreviousOrderUuid(previousOrder.getUuid());
+        }
+
+        drugOrder.setDrugNonCoded(openMRSDrugOrder.getDrugNonCoded());
+        if (openMRSDrugOrder.getDrug() != null){
+            EncounterTransaction.Drug encounterTransactionDrug = new DefaultDrugMapper().map(openMRSDrugOrder.getDrug());
+            drugOrder.setDrug(encounterTransactionDrug);
+        }
+
+        drugOrder.setDosingInstructionType(openMRSDrugOrder.getDosingType().getName());
+        drugOrder.setDuration(openMRSDrugOrder.getDuration());
+        drugOrder.setDurationUnits(getConceptName(openMRSDrugOrder.getDurationUnits()));
+
+        drugOrder.setConcept(conceptMapper.map(openMRSDrugOrder.getConcept()));
+        drugOrder.setScheduledDate(openMRSDrugOrder.getScheduledDate());
+        drugOrder.setDateActivated(openMRSDrugOrder.getDateActivated());
+        drugOrder.setEffectiveStartDate(openMRSDrugOrder.getEffectiveStartDate());
+        drugOrder.setAutoExpireDate(openMRSDrugOrder.getAutoExpireDate());
+        drugOrder.setEffectiveStopDate(openMRSDrugOrder.getEffectiveStopDate());
+
+        drugOrder.setDateStopped(openMRSDrugOrder.getDateStopped());
+
+        EncounterTransaction.DosingInstructions dosingInstructions = new EncounterTransaction.DosingInstructions();
+        dosingInstructions.setDose(openMRSDrugOrder.getDose());
+        dosingInstructions.setDoseUnits(getConceptName(openMRSDrugOrder.getDoseUnits()));
+        dosingInstructions.setRoute(getConceptName(openMRSDrugOrder.getRoute()));
+        dosingInstructions.setAsNeeded(openMRSDrugOrder.getAsNeeded());
+
+        if (openMRSDrugOrder.getFrequency() != null) {
+            dosingInstructions.setFrequency(openMRSDrugOrder.getFrequency().getName());
+        }
+        if (openMRSDrugOrder.getQuantity() != null) {
+            dosingInstructions.setQuantity(openMRSDrugOrder.getQuantity());
+        }
+        dosingInstructions.setQuantityUnits(getConceptName(openMRSDrugOrder.getQuantityUnits()));
+        dosingInstructions.setAdministrationInstructions(openMRSDrugOrder.getDosingInstructions());
+        drugOrder.setDosingInstructions(dosingInstructions);
+
+        drugOrder.setInstructions(openMRSDrugOrder.getInstructions());
+        drugOrder.setCommentToFulfiller(openMRSDrugOrder.getCommentToFulfiller());
+
+        drugOrder.setVoided(openMRSDrugOrder.getVoided());
+        drugOrder.setVoidReason(openMRSDrugOrder.getVoidReason());
+        drugOrder.setOrderNumber(openMRSDrugOrder.getOrderNumber());
+
+        drugOrder.setOrderReasonConcept(conceptMapper.map(openMRSDrugOrder.getOrderReason()));
+        drugOrder.setOrderReasonText(openMRSDrugOrder.getOrderReasonNonCoded());
+        OrderGroup openMRSOrderGroup = openMRSDrugOrder.getOrderGroup();
+        if(openMRSOrderGroup != null) {
+            EncounterTransaction.OrderGroup orderGroup = new EncounterTransaction.OrderGroup(openMRSOrderGroup.getUuid());
+            EncounterTransaction.OrderSet orderSet = new EncounterTransaction.OrderSet(openMRSOrderGroup.getOrderSet().getUuid());
+            orderGroup.setOrderSet(orderSet);
+            drugOrder.setOrderGroup(orderGroup);
+            drugOrder.setSortWeight(openMRSDrugOrder.getSortWeight());
+        }
+        return drugOrder;
     }
 
     @Override
     public EncounterTransaction.Order mapOrder(Order order) {
+        EncounterTransaction.Order emrOrder = new EncounterTransaction.Order();
+        emrOrder.setUuid(order.getUuid());
+        emrOrder.setConcept(conceptMapper.map(order.getConcept()));
+        emrOrder.setOrderType(order.getOrderType().getName());
+        emrOrder.setInstructions(order.getInstructions());
+        emrOrder.setDateCreated(order.getDateCreated());
+        emrOrder.setDateChanged(order.getDateChanged());
+        emrOrder.setDateStopped(order.getDateStopped());
+        emrOrder.setOrderNumber(order.getOrderNumber());
+        emrOrder.setCommentToFulfiller(order.getCommentToFulfiller());
+        emrOrder.setAction(order.getAction().name());
+        emrOrder.setUrgency(String.valueOf(order.getUrgency()));
+        Order previousOrder = order.getPreviousOrder();
+        if (previousOrder != null && StringUtils.isNotBlank(previousOrder.getUuid())) {
+            emrOrder.setPreviousOrderUuid(previousOrder.getUuid());
+        }
+        return emrOrder;
+    }
+
+    private String getConceptName(Concept concept) {
+        if (concept != null) {
+            return concept.getName().getName();
+        }
         return null;
     }
 }