TRUNK-5964: Hard-coded uuids for drug order type and test order type. (#4585)

Author: IamMujuziMoses

api/src/main/java/org/openmrs/api/OrderService.java

@@ -724,7 +724,35 @@ public Order discontinueOrder(Order orderToDiscontinue, String reasonNonCoded, D
 	 */
 	@Authorized(PrivilegeConstants.GET_ORDER_TYPES)
 	public OrderType getOrderTypeByConcept(Concept concept);
-	
+
+	/**
+	 * Get order types by java class name
+	 *
+	 * @param javaClassName the class name used to get the order types
+	 * @param includeRetired boolean flag for include retired or not   
+	 * @since 3.0.0
+	 * @return return the order types associated with given class name
+	 * <strong>Should</strong> find order types with the specified class name
+	 * <strong>Should</strong> get include retired order types if includeRetired is set to true
+	 */
+	@Authorized(PrivilegeConstants.GET_ORDER_TYPES)
+	public List<OrderType> getOrderTypesByClassName(String javaClassName, boolean includeRetired) throws APIException;
+
+	/**
+	 * Get order types by java class name
+	 * 
+	 * @param javaClassName the class name used to get the order types
+	 * @param includeSubclasses boolean flag for include subclasses or not
+	 * @param includeRetired boolean flag for include retired or not
+	 * @since 3.0.0
+	 * @return return the order types associated with given class name
+	 * <strong>Should</strong> find order types with the specified class name
+	 * <strong>Should</strong> get include order types subclasses if includeSubclasses is set to true
+	 * <strong>Should</strong> get include retired order types if includeRetired is set to true
+	 */
+	@Authorized(PrivilegeConstants.GET_ORDER_TYPES)
+	public List<OrderType> getOrderTypesByClassName(String javaClassName, boolean includeSubclasses, boolean includeRetired) throws APIException;
+
 	/**
 	 * Gets the possible drug routes, i.e the set members for the concept that matches the uuid
 	 * specified as the value for the global property

api/src/main/java/org/openmrs/api/db/OrderDAO.java

@@ -202,6 +202,11 @@ public List<OrderFrequency> getOrderFrequencies(String searchPhrase, Locale loca
 	 * @see org.openmrs.api.OrderService#getOrderTypeByConceptClass(org.openmrs.ConceptClass)
 	 */
 	public OrderType getOrderTypeByConceptClass(ConceptClass conceptClass);
+
+	/**
+	 * @see org.openmrs.api.OrderService#getOrderTypesByClassName(String, boolean)
+	 */
+	public List<OrderType> getOrderTypesByClassName(String javaClassName, boolean includeRetired) throws DAOException;
 
 	/**
 	 * @see org.openmrs.api.OrderService#saveOrderType(org.openmrs.OrderType)

api/src/main/java/org/openmrs/api/db/hibernate/HibernateOrderDAO.java

@@ -778,6 +778,31 @@ public OrderType getOrderTypeByConceptClass(ConceptClass conceptClass) {
 		    "from OrderType where :conceptClass in elements(conceptClasses)").setParameter("conceptClass", conceptClass)
 		        .uniqueResult();
 	}
+
+	/**
+	 * @see org.openmrs.api.OrderService#getOrderTypesByClassName(String, boolean)
+	 */
+	@Override
+	public List<OrderType> getOrderTypesByClassName(String javaClassName, boolean includeRetired) throws DAOException {
+		if (StringUtils.isBlank(javaClassName)) {
+			throw new APIException("javaClassName cannot be null");
+		}
+		
+		Session session = sessionFactory.getCurrentSession();
+		CriteriaBuilder cb = session.getCriteriaBuilder();
+		CriteriaQuery<OrderType> cq = cb.createQuery(OrderType.class);
+		Root<OrderType> root = cq.from(OrderType.class);
+
+		List<Predicate> predicates = new ArrayList<>();
+		if (!includeRetired) {
+			predicates.add(cb.isFalse(root.get("retired")));
+		}
+		predicates.add(cb.equal(root.get("javaClassName"), javaClassName));
+		
+		cq.where(predicates.toArray(new Predicate[]{}));
+		
+		return session.createQuery(cq).getResultList();
+	}
 
 	/**
 	 * @see org.openmrs.api.OrderService#saveOrderType(org.openmrs.OrderType)

api/src/main/java/org/openmrs/api/impl/OrderServiceImpl.java

@@ -270,13 +270,13 @@ private void ensureOrderTypeIsSet(Order order, OrderContext orderContext) {
 			orderType = getOrderTypeByConcept(order.getConcept());
 		}
 		if (orderType == null && order instanceof DrugOrder) {
-			orderType = Context.getOrderService().getOrderTypeByUuid(OrderType.DRUG_ORDER_TYPE_UUID);
+			orderType = getDefaultOrderType(DrugOrder.class, OrderType.DRUG_ORDER_TYPE_UUID);
 		}
 		if (orderType == null && order instanceof TestOrder) {
-			orderType = Context.getOrderService().getOrderTypeByUuid(OrderType.TEST_ORDER_TYPE_UUID);
+			orderType = getDefaultOrderType(TestOrder.class, OrderType.TEST_ORDER_TYPE_UUID);
 		}
 		if (orderType == null && order instanceof ReferralOrder) {
-			orderType = Context.getOrderService().getOrderTypeByUuid(OrderType.REFERRAL_ORDER_TYPE_UUID);
+			orderType = getDefaultOrderType(ReferralOrder.class, OrderType.REFERRAL_ORDER_TYPE_UUID);
 		}
 		if (orderType == null) {
 			throw new OrderEntryException("Order.type.cannot.determine");
@@ -312,10 +312,21 @@ private void failOnOrderTypeMismatch(Order order) {
 
 	private boolean areDrugOrdersOfSameOrderableAndOverlappingSchedule(Order firstOrder, Order secondOrder) {
 		return firstOrder.hasSameOrderableAs(secondOrder)
-		        && !OpenmrsUtil.nullSafeEquals(firstOrder.getPreviousOrder(), secondOrder)
-		        && OrderUtil.checkScheduleOverlap(firstOrder, secondOrder)
-		        && firstOrder.getOrderType().equals(
-		            Context.getOrderService().getOrderTypeByUuid(OrderType.DRUG_ORDER_TYPE_UUID));
+			&& !OpenmrsUtil.nullSafeEquals(firstOrder.getPreviousOrder(), secondOrder)
+			&& OrderUtil.checkScheduleOverlap(firstOrder, secondOrder)
+			&& firstOrder.getOrderType().equals(getDefaultOrderType(DrugOrder.class, OrderType.DRUG_ORDER_TYPE_UUID));
+	}
+
+	private OrderType getDefaultOrderType(Class<? extends Order> orderSubclass, String fallbackUuid) {
+		OrderType type = getOrderTypeByUuid(fallbackUuid);
+		
+		if (type == null) {
+			List<OrderType> types = getOrderTypesByClassName(orderSubclass.getName(), true, false);
+			if (types.size() == 1) {
+				type = types.get(0);
+			}
+		}
+		return type;
 	}
 
 	private boolean isDrugOrder(Order order) {
@@ -1061,6 +1072,47 @@ public OrderType getOrderTypeByConceptClass(ConceptClass conceptClass) {
 	public OrderType getOrderTypeByConcept(Concept concept) {
 		return Context.getOrderService().getOrderTypeByConceptClass(concept.getConceptClass());
 	}
+
+	/**
+	 * @see org.openmrs.api.OrderService#getOrderTypesByClassName(String, boolean)
+	 */
+	@Override
+	@Transactional(readOnly = true)
+	public List<OrderType> getOrderTypesByClassName(String javaClassName, boolean includeRetired) throws APIException {
+		return dao.getOrderTypesByClassName(javaClassName, includeRetired);
+	}
+	
+	/**
+	 * @see org.openmrs.api.OrderService#getOrderTypesByClassName(String, boolean, boolean)
+	 */
+	@Override
+	@Transactional(readOnly = true)
+	public List<OrderType> getOrderTypesByClassName(String javaClassName, boolean includeSubclasses, boolean includeRetired) throws APIException {
+		if (!StringUtils.hasText(javaClassName)) {
+			throw new APIException("javaClassName cannot be null");
+		}
+		
+		if (!includeSubclasses) {
+			return getOrderTypesByClassName(javaClassName, includeRetired);
+		}
+
+		Class<?> superClass;
+		try {
+			superClass = Context.loadClass(javaClassName);
+		} catch (ClassNotFoundException e) {
+			throw new APIException("Invalid javaClassName: " + javaClassName, e);
+		}
+
+		return getOrderTypes(includeRetired).stream()
+			.filter(ot -> {
+				try {
+					Class<?> c = Context.loadClass(ot.getJavaClassName());
+					return superClass.isAssignableFrom(c);
+				} catch (Exception ignore) {
+					return false;
+				}
+			}).toList();
+	}
 
 	/**
 	 * @see org.openmrs.api.OrderService#getDrugRoutes()

api/src/test/java/org/openmrs/api/OrderServiceTest.java

@@ -2762,6 +2762,53 @@ public void getOrderTypeByConcept_shouldGetOrderTypeMappedToTheGivenConcept() {
 		assertEquals(2, orderType.getOrderTypeId().intValue());
 	}
 
+	/**
+	 * @see org.openmrs.api.OrderService#getOrderTypesByClassName(String, boolean)
+	 */
+	@Test
+	public void getOrderTypesByClassName_shouldReturnOrderTypesForTheGivenJavaClassName() {
+		List<OrderType> drugOrderTypes = orderService.getOrderTypesByClassName(DrugOrder.class.getName(), false);
+
+		assertNotNull(drugOrderTypes);
+		assertEquals(1, drugOrderTypes.size());
+		assertEquals("Drug order", drugOrderTypes.get(0).getName());
+
+		List<OrderType> testOrderTypes = orderService.getOrderTypesByClassName(TestOrder.class.getName(), false);
+
+		assertNotNull(testOrderTypes);
+		assertEquals(2, testOrderTypes.size());
+		assertEquals("Test order", testOrderTypes.get(0).getName());
+	}
+
+	/**
+	 * @see org.openmrs.api.OrderService#getOrderTypesByClassName(String, boolean, boolean)
+	 */
+	@Test
+	public void getOrderTypesByClassName_shouldReturnOrderTypesForTestOrderAndItsSubclasses() {
+		// create and save a new OrderType for MyTestOrder
+		OrderType myTestOrderType = new OrderType();
+		myTestOrderType.setName("My Test Order");
+		myTestOrderType.setJavaClassName(MyTestOrder.class.getName());
+		Context.getOrderService().saveOrderType(myTestOrderType);
+		
+		List<OrderType> polymorphicTestOrderTypes = orderService.getOrderTypesByClassName(TestOrder.class.getName(), true, false);
+		
+		assertNotNull(polymorphicTestOrderTypes);
+
+		// should include the original TestOrder types + the new subclass
+		assertEquals(3, polymorphicTestOrderTypes.size());
+		assertTrue(polymorphicTestOrderTypes.stream()
+			.anyMatch(ot -> MyTestOrder.class.getName().equals(ot.getJavaClassName())));
+	}
+
+	/**
+	 * @see org.openmrs.api.OrderService#getOrderTypesByClassName(String, boolean)
+	 */
+	@Test
+	public void getOrderTypesByClassName_shouldThrowAPIExceptionForNullJavaClassName() {
+		assertThrows(APIException.class, () -> orderService.getOrderTypesByClassName(null, false));
+	}
+
 	/**
 	 * @see OrderService#saveOrder(org.openmrs.Order, OrderContext)
 	 */
@@ -4421,4 +4468,7 @@ private Date aMomentBefore(Date date) {
 	private Date truncateToSeconds(Date date) {
 		return DateUtils.truncate(date, Calendar.SECOND);
 	}
+
+	// Test-only subclass
+	public static class MyTestOrder extends TestOrder { }
 }