/*
* This program is part of the OpenLMIS logistics management information system platform software.
* Copyright © 2013 VillageReach
*
* This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
* You should have received a copy of the GNU Affero General Public License along with this program. If not, see http://www.gnu.org/licenses. For additional information contact info@OpenLMIS.org.
*/
package org.openlmis.rnr.repository.mapper;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.Predicate;
import org.joda.time.DateTime;
import org.junit.Before;
import org.junit.Test;
import org.junit.experimental.categories.Category;
import org.junit.runner.RunWith;
import org.openlmis.core.builder.*;
import org.openlmis.core.domain.*;
import org.openlmis.core.query.QueryExecutor;
import org.openlmis.core.repository.mapper.*;
import org.openlmis.db.categories.IntegrationTests;
import org.openlmis.rnr.builder.RnrLineItemBuilder;
import org.openlmis.rnr.domain.*;
import org.openlmis.rnr.service.RequisitionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.transaction.TransactionConfiguration;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.sql.SQLException;
import java.util.*;
import static com.natpryce.makeiteasy.MakeItEasy.*;
import static java.util.Arrays.asList;
import static org.hamcrest.CoreMatchers.*;
import static org.joda.time.DateTime.now;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.openlmis.core.builder.FacilityBuilder.FACILITY_CODE;
import static org.openlmis.core.builder.FacilityBuilder.defaultFacility;
import static org.openlmis.core.builder.FacilityBuilder.name;
import static org.openlmis.core.builder.ProcessingPeriodBuilder.*;
import static org.openlmis.core.builder.ProcessingScheduleBuilder.defaultProcessingSchedule;
import static org.openlmis.core.builder.ProgramBuilder.programCode;
import static org.openlmis.core.builder.ProgramBuilder.programName;
import static org.openlmis.core.builder.SupplyLineBuilder.defaultSupplyLine;
import static org.openlmis.core.builder.UserBuilder.active;
import static org.openlmis.core.builder.UserBuilder.defaultUser;
import static org.openlmis.core.domain.RightName.CONVERT_TO_ORDER;
import static org.openlmis.core.domain.RightType.FULFILLMENT;
import static org.openlmis.rnr.builder.RnrLineItemBuilder.*;
import static org.openlmis.rnr.domain.RnrStatus.*;
@Category(IntegrationTests.class)
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:test-applicationContext-requisition.xml")
@TransactionConfiguration(defaultRollback = true, transactionManager = "openLmisTransactionManager")
@Transactional
public class RequisitionMapperIT {
public static final Long MODIFIED_BY = 1L;
public static final Long USER_ID = 2L;
@Autowired
LossesAndAdjustmentsMapper lossesAndAdjustmentsMapper;
@Autowired
SupervisoryNodeMapper supervisoryNodeMapper;
@Autowired
SupplyLineMapper supplyLineMapper;
@Autowired
RequisitionStatusChangeMapper requisitionStatusChangeMapper;
private Facility facility;
private ProcessingSchedule processingSchedule;
private ProcessingPeriod processingPeriod1;
private ProcessingPeriod processingPeriod2;
private ProcessingPeriod processingPeriod3;
private Program program;
@Autowired
private UserMapper userMapper;
@Autowired
private RoleRightsMapper roleRightsMapper;
@Autowired
private QueryExecutor queryExecutor;
@Autowired
private FacilityMapper facilityMapper;
@Autowired
private RequisitionMapper mapper;
@Autowired
private RnrLineItemMapper lineItemMapper;
@Autowired
private ProcessingPeriodMapper processingPeriodMapper;
@Autowired
private ProcessingScheduleMapper processingScheduleMapper;
@Autowired
private ProductMapper productMapper;
@Autowired
private ProgramProductMapper programProductMapper;
@Autowired
private FacilityApprovedProductMapper facilityApprovedProductMapper;
@Autowired
private ProgramMapper programMapper;
@Autowired
private CommentMapper commentMapper;
@Autowired
private ProductCategoryMapper productCategoryMapper;
private SupervisoryNode supervisoryNode;
private Role role;
private Date modifiedDate;
private ProductCategory productCategory;
@Autowired
private SignatureMapper signatureMapper;
@Before
public void setUp() {
facility = make(a(defaultFacility));
facilityMapper.insert(facility);
processingSchedule = make(a(defaultProcessingSchedule));
processingScheduleMapper.insert(processingSchedule);
insertProgram();
Date periodStartDate = new Date();
Date periodEndDate = new Date();
processingPeriod1 = insertPeriod("Period 1", processingSchedule, periodStartDate, periodEndDate);
processingPeriod2 = insertPeriod("Period 2", processingSchedule, periodStartDate, periodEndDate);
processingPeriod3 = insertPeriod("Period 3", processingSchedule, periodStartDate, periodEndDate);
supervisoryNode = insertSupervisoryNode("N1");
insertSupplyLine(facility, supervisoryNode);
role = insertRole();
modifiedDate = new Date();
productCategory = new ProductCategory("C1", "Category 1", 1);
productCategoryMapper.insert(productCategory);
}
@Test
public void shouldSetRequisitionId() {
Rnr requisition = insertRequisition(processingPeriod1, program, INITIATED, false, facility, supervisoryNode, modifiedDate);
assertThat(requisition.getId(), is(notNullValue()));
}
@Test
public void shouldGetRequisitionById() {
Rnr requisition = new Rnr(new Facility(facility.getId()), new Program(program.getId()), processingPeriod1, false, MODIFIED_BY, 1L);
requisition.setAllocatedBudget(new BigDecimal(123.45));
requisition.setStatus(INITIATED);
requisition.setId(1L);
String submitterText = "submitter";
Signature submitterSignature = new Signature(Signature.Type.SUBMITTER, submitterText);
String approverText = "approver";
Signature approverSignature = new Signature(Signature.Type.APPROVER, approverText);
ArrayList<Signature> rnrSignatures = new ArrayList<>();
rnrSignatures.add(submitterSignature);
rnrSignatures.add(approverSignature);
requisition.setRnrSignatures(rnrSignatures);
signatureMapper.insertSignature(submitterSignature);
signatureMapper.insertSignature(approverSignature);
mapper.insert(requisition);
mapper.insertRnrSignature(requisition, submitterSignature);
mapper.insertRnrSignature(requisition, approverSignature);
Product product = insertProduct(true, "P1");
RnrLineItem fullSupplyLineItem = make(a(defaultRnrLineItem, with(fullSupply, true), with(productCode, product.getCode())));
RnrLineItem nonFullSupplyLineItem = make(a(defaultRnrLineItem, with(fullSupply, false), with(productCode, product.getCode())));
fullSupplyLineItem.setRnrId(requisition.getId());
nonFullSupplyLineItem.setRnrId(requisition.getId());
lineItemMapper.insert(fullSupplyLineItem, Collections.EMPTY_LIST.toString());
lineItemMapper.insert(nonFullSupplyLineItem, Collections.EMPTY_LIST.toString());
ProgramProduct programProduct = new ProgramProduct(program, product, 1, true);
programProduct.setProductCategory(productCategory);
programProductMapper.insert(programProduct);
User author = new User();
author.setId(1L);
Comment comment = new Comment(requisition.getId(), author, "A comment", null);
commentMapper.insert(comment);
updateSupplyingDepotForRequisition(requisition);
Rnr fetchedRequisition = mapper.getById(requisition.getId());
assertThat(fetchedRequisition.getId(), is(requisition.getId()));
assertThat(fetchedRequisition.getProgram().getId(), is(equalTo(program.getId())));
assertThat(fetchedRequisition.getFacility().getId(), is(equalTo(facility.getId())));
assertThat(fetchedRequisition.getPeriod().getId(), is(equalTo(processingPeriod1.getId())));
assertThat(fetchedRequisition.getModifiedBy(), is(equalTo(MODIFIED_BY)));
assertThat(fetchedRequisition.getStatus(), is(equalTo(INITIATED)));
assertThat(fetchedRequisition.getFullSupplyLineItems().size(), is(1));
assertThat(fetchedRequisition.getNonFullSupplyLineItems().size(), is(1));
assertThat(fetchedRequisition.getAllocatedBudget(), is(new BigDecimal(123.45).setScale(2, RoundingMode.FLOOR)));
assertThat(fetchedRequisition.getRnrSignatures().size(), is(2));
assertThat(fetchedRequisition.getRnrSignatures().get(0).getType(), is(Signature.Type.SUBMITTER));
assertThat(fetchedRequisition.getRnrSignatures().get(0).getText(), is(submitterText));
assertThat(fetchedRequisition.getRnrSignatures().get(1).getType(), is(Signature.Type.APPROVER));
assertThat(fetchedRequisition.getRnrSignatures().get(1).getText(), is(approverText));
}
@Test
public void shouldGetRequisitionsByFacilityAndProgram() {
String facilityCode = "F10";
String programCode = "MMIA";
Facility queryFacility = new Facility(facility.getId());
queryFacility.setCode(facilityCode);
Program queryProgram = new Program(program.getId());
queryProgram.setCode(programCode);
Rnr requisition = new Rnr(queryFacility, queryProgram, processingPeriod1, false, MODIFIED_BY, 4L);
requisition.setAllocatedBudget(new BigDecimal(123.45));
requisition.setStatus(INITIATED);
mapper.insert(requisition);
List<Rnr> rnrList = mapper.getRequisitionsWithLineItemsByFacility(queryFacility);
assertThat(rnrList.size(), is(1));
Facility anotherFacility = new Facility(122L);
facility.setCode(FACILITY_CODE);
rnrList = mapper.getRequisitionsWithLineItemsByFacility(anotherFacility);
assertThat(rnrList.size(), is(0));
}
@Test
public void shouldUpdateRequisition() {
Rnr requisition = insertRequisition(processingPeriod1, program, INITIATED, false, facility, supervisoryNode, modifiedDate);
requisition.setModifiedBy(USER_ID);
Date submittedDate = new Date();
requisition.setSubmittedDate(submittedDate);
requisition.setSupervisoryNodeId(supervisoryNode.getId());
requisition.setSupplyingDepot(facility);
mapper.update(requisition);
Rnr updatedRequisition = mapper.getById(requisition.getId());
assertThat(updatedRequisition.getId(), is(requisition.getId()));
assertThat(updatedRequisition.getSupervisoryNodeId(), is(requisition.getSupervisoryNodeId()));
assertThat(updatedRequisition.getModifiedBy(), is(equalTo(USER_ID)));
}
@Test
public void shouldUpdateClientSubmittedTime() {
Rnr requisition = insertRequisition(processingPeriod1, program, INITIATED, false, facility, supervisoryNode, modifiedDate);
Date clientSubmittedTime = new Date();
requisition.setClientSubmittedTime(clientSubmittedTime);
mapper.updateClientFields(requisition);
Rnr updatedRequisition = mapper.getById(requisition.getId());
assertThat(updatedRequisition.getId(), is(requisition.getId()));
assertThat(updatedRequisition.getClientSubmittedTime(), is(clientSubmittedTime));
}
@Test
public void shouldUpdateClientSubmittedNotes() throws Exception {
Rnr requisition = insertRequisition(processingPeriod1, program, INITIATED, false, facility, supervisoryNode, modifiedDate);
requisition.setClientSubmittedNotes("xyz");
mapper.updateClientFields(requisition);
Rnr updatedRequisition = mapper.getById(requisition.getId());
assertThat(updatedRequisition.getId(), is(requisition.getId()));
assertEquals("xyz", updatedRequisition.getClientSubmittedNotes());
}
@Test
public void shouldReturnRequisitionWithLineItemsByFacilityProgramAndPeriod() {
Product fullSupplyProduct = insertProduct(true, "P1");
Product nonFullSupplyProduct = insertProduct(false, "P2");
ProgramProduct fullSupplyProgramProduct = insertProgramProductWithProductCategory(fullSupplyProduct, program);
ProgramProduct nonFullSupplyProgramProduct = insertProgramProductWithProductCategory(nonFullSupplyProduct, program);
FacilityTypeApprovedProduct fullSupplyFacilityTypeApprovedProduct = insertFacilityApprovedProduct(fullSupplyProgramProduct);
FacilityTypeApprovedProduct nonFullSupplyFacilityTypeApprovedProduct = insertFacilityApprovedProduct(nonFullSupplyProgramProduct);
Rnr requisition = insertRequisition(processingPeriod1, program, INITIATED, false, facility, supervisoryNode, modifiedDate);
insertRequisition(processingPeriod2, program, INITIATED, false, facility, supervisoryNode, modifiedDate);
insertRnrLineItem(requisition, fullSupplyFacilityTypeApprovedProduct);
insertRnrLineItem(requisition, nonFullSupplyFacilityTypeApprovedProduct);
Rnr returnedRequisition = mapper.getRequisitionWithLineItems(facility, new Program(program.getId()), processingPeriod1);
assertThat(returnedRequisition.getId(), is(requisition.getId()));
assertThat(returnedRequisition.getFacility().getId(), is(facility.getId()));
assertThat(returnedRequisition.getProgram().getId(), is(program.getId()));
assertThat(returnedRequisition.getPeriod().getId(), is(processingPeriod1.getId()));
assertThat(returnedRequisition.getFullSupplyLineItems().size(), is(1));
assertThat(returnedRequisition.getNonFullSupplyLineItems().size(), is(1));
}
@Test
public void shouldReturnRequisitionWithoutLineItemsByFacilityProgramAndPeriod() {
Product fullSupplyProduct = insertProduct(true, "P1");
Product nonFullSupplyProduct = insertProduct(false, "P2");
ProgramProduct fullSupplyProgramProduct = insertProgramProductWithProductCategory(fullSupplyProduct, program);
ProgramProduct nonFullSupplyProgramProduct = insertProgramProductWithProductCategory(nonFullSupplyProduct, program);
FacilityTypeApprovedProduct fullSupplyFacilityTypeApprovedProduct = insertFacilityApprovedProduct(fullSupplyProgramProduct);
FacilityTypeApprovedProduct nonFullSupplyFacilityTypeApprovedProduct = insertFacilityApprovedProduct(nonFullSupplyProgramProduct);
Rnr requisition = insertRequisition(processingPeriod1, program, INITIATED, false, facility, supervisoryNode, modifiedDate);
insertRequisition(processingPeriod2, program, INITIATED, false, facility, supervisoryNode, modifiedDate);
insertRnrLineItem(requisition, fullSupplyFacilityTypeApprovedProduct);
insertRnrLineItem(requisition, nonFullSupplyFacilityTypeApprovedProduct);
Rnr returnedRequisition = mapper.getRequisitionWithoutLineItems(facility.getId(), program.getId(), processingPeriod1.getId());
assertThat(returnedRequisition.getId(), is(requisition.getId()));
assertThat(returnedRequisition.getFacility().getId(), is(facility.getId()));
assertThat(returnedRequisition.getProgram().getId(), is(program.getId()));
assertThat(returnedRequisition.getPeriod().getId(), is(processingPeriod1.getId()));
assertThat(returnedRequisition.getFullSupplyLineItems().size(), is(0));
assertThat(returnedRequisition.getNonFullSupplyLineItems().size(), is(0));
}
@Test
public void shouldGetOnlyRegularRequisitions() throws Exception {
Rnr regularRnr = insertRequisition(processingPeriod1, program, INITIATED, false, facility, supervisoryNode, modifiedDate);
insertRequisition(processingPeriod1, program, INITIATED, true, facility, supervisoryNode, modifiedDate);
Rnr regularRequisition = mapper.getRegularRequisitionWithLineItems(facility, program, processingPeriod1);
assertThat(regularRequisition.getId(), is(regularRnr.getId()));
}
@Test
public void shouldPopulateLineItemsWhenGettingRnrById() throws Exception {
Rnr requisition = insertRequisition(processingPeriod1, program, INITIATED, false, facility, supervisoryNode, modifiedDate);
Product product = insertProduct(true, "P1");
ProgramProduct programProduct = insertProgramProductWithProductCategory(product, program);
FacilityTypeApprovedProduct facilityTypeApprovedProduct = insertFacilityApprovedProduct(programProduct);
RnrLineItem item1 = insertRnrLineItem(requisition, facilityTypeApprovedProduct);
lossesAndAdjustmentsMapper.insert(item1, RnrLineItemBuilder.ONE_LOSS);
Rnr returnedRequisition = mapper.getById(requisition.getId());
assertThat(returnedRequisition.getFullSupplyLineItems().size(), is(1));
final RnrLineItem item = returnedRequisition.getFullSupplyLineItems().get(0);
assertThat(item.getLossesAndAdjustments().size(), is(1));
assertThat(returnedRequisition.getFacility().getId(), is(requisition.getFacility().getId()));
assertThat(returnedRequisition.getStatus(), is(requisition.getStatus()));
assertThat(returnedRequisition.getId(), is(requisition.getId()));
}
@Test
public void shouldNotGetInitiatedRequisitionsForFacilitiesAndPrograms() throws Exception {
Rnr requisition = insertRequisition(processingPeriod1, program, INITIATED, false, facility, supervisoryNode, modifiedDate);
requisition.setSupervisoryNodeId(supervisoryNode.getId());
mapper.update(requisition);
List<Rnr> requisitions = mapper.getAuthorizedRequisitions(null);
assertThat(requisitions.size(), is(0));
}
@Test
public void shouldGetRequisitionsInSubmittedStateForRoleAssignment() throws Exception {
Rnr requisition = insertRequisition(processingPeriod1, program, AUTHORIZED, true, facility, supervisoryNode, modifiedDate);
requisition.setSupervisoryNodeId(supervisoryNode.getId());
mapper.update(requisition);
RoleAssignment roleAssignment = new RoleAssignment(USER_ID, 1L, program.getId(), supervisoryNode);
List<Rnr> requisitions = mapper.getAuthorizedRequisitions(roleAssignment);
Rnr rnr = requisitions.get(0);
assertThat(requisitions.size(), is(1));
assertThat(rnr.getFacility().getId(), is(facility.getId()));
assertThat(rnr.getProgram().getId(), is(program.getId()));
assertThat(rnr.getPeriod().getId(), is(processingPeriod1.getId()));
assertThat(rnr.getId(), is(requisition.getId()));
assertThat(rnr.getModifiedDate(), is(notNullValue()));
assertTrue(rnr.isEmergency());
}
@Test
public void shouldGetTheLastRegularRequisitionToEnterThePostSubmitFlow() throws Exception {
DateTime date1 = now();
DateTime date2 = date1.plusMonths(1);
ProcessingPeriod processingPeriod4 = make(a(defaultProcessingPeriod,
with(scheduleId, processingSchedule.getId()),
with(ProcessingPeriodBuilder.name, "Period4")));
processingPeriod4.setStartDate(new Date());
processingPeriodMapper.insert(processingPeriod4);
Rnr rnr1 = insertRequisition(processingPeriod1, program, AUTHORIZED, false, facility, supervisoryNode, modifiedDate);
rnr1.setSubmittedDate(date1.toDate());
mapper.update(rnr1);
Rnr rnr2 = insertRequisition(processingPeriod4, program, APPROVED, false, facility, supervisoryNode, modifiedDate);
rnr2.setSubmittedDate(date2.toDate());
mapper.update(rnr2);
insertRequisition(processingPeriod3, program, INITIATED, false, facility, supervisoryNode, modifiedDate);
Rnr lastRequisitionToEnterThePostSubmitFlow = mapper.getLastRegularRequisitionToEnterThePostSubmitFlow(facility.getId(), program.getId());
assertThat(lastRequisitionToEnterThePostSubmitFlow.getId(), is(rnr2.getId()));
}
@Test
public void shouldNotGetEmergencyRequisitionsForPostSubmitFlow() throws Exception {
insertRequisition(processingPeriod1, program, INITIATED, false, facility, supervisoryNode, modifiedDate);
insertRequisition(processingPeriod1, program, AUTHORIZED, true, facility, supervisoryNode, modifiedDate);
Rnr lastRequisition = mapper.getLastRegularRequisitionToEnterThePostSubmitFlow(facility.getId(), program.getId());
assertThat(lastRequisition, is(nullValue()));
}
@Test
public void shouldGetLastRegularRequisitionForFacilityAndProgram() throws Exception {
Rnr expectedRnr = insertRequisition(processingPeriod1, program, INITIATED, false, facility, supervisoryNode, modifiedDate);
Rnr lastRequisition = mapper.getLastRegularRequisition(facility, program);
assertThat(lastRequisition.getStatus(), is(expectedRnr.getStatus()));
assertThat(lastRequisition.getPeriod().getId(), is(processingPeriod1.getId()));
}
@Test
public void shouldGetApprovedRequisitionsForCriteriaAndPageNumberWhenSearchingByFacilityCode() throws SQLException {
Long userId = insertUser();
insertRoleForApprovedRequisitions(facility.getId(), userId);
Rnr requisition1 = insertRequisition(processingPeriod1, program, SUBMITTED, true, facility, supervisoryNode, modifiedDate);
Rnr requisition2 = insertRequisition(processingPeriod2, program, SUBMITTED, false, facility, supervisoryNode, modifiedDate);
Rnr requisition3 = insertRequisition(processingPeriod3, program, SUBMITTED, false, facility, supervisoryNode, modifiedDate);
approve(requisition1, requisition2, requisition3);
String searchType = RequisitionService.SEARCH_FACILITY_CODE;
Integer pageNumber = 1;
Integer pageSize = 2;
String sortDirection = "asc";
String sortBy = "submittedDate";
List<Rnr> requisitions = mapper.getApprovedRequisitionsForCriteriaAndPageNumber(searchType, "F10", pageNumber,
pageSize, userId, CONVERT_TO_ORDER, sortBy, sortDirection);
assertThat(requisitions.size(), is(2));
populateProgramValuesForComparison(requisition1, 0, requisitions);
populateProgramValuesForComparison(requisition2, 1, requisitions);
assertThat(requisitions.get(0), is(requisition1));
assertThat(requisitions.get(1), is(requisition2));
}
@Test
public void shouldGetApprovedRequisitionsForCriteriaAndPageNumberWhenSearchingByFacilityName() throws SQLException {
Long userId = insertUser();
insertRoleForApprovedRequisitions(facility.getId(), userId);
Rnr requisition1 = insertRequisition(processingPeriod1, program, SUBMITTED, false, facility, supervisoryNode, modifiedDate);
Rnr requisition2 = insertRequisition(processingPeriod2, program, SUBMITTED, false, facility, supervisoryNode, modifiedDate);
Rnr requisition3 = insertRequisition(processingPeriod3, program, SUBMITTED, false, facility, supervisoryNode, modifiedDate);
approve(requisition1, requisition2, requisition3);
String searchType = RequisitionService.SEARCH_FACILITY_NAME;
Integer pageNumber = 1;
Integer pageSize = 2;
String sortDirection = "asc";
String sortBy = "submittedDate";
List<Rnr> requisitions = mapper.getApprovedRequisitionsForCriteriaAndPageNumber(searchType, "Apollo", pageNumber,
pageSize, userId, CONVERT_TO_ORDER, sortBy, sortDirection);
assertThat(requisitions.size(), is(2));
populateProgramValuesForComparison(requisition1, 0, requisitions);
populateProgramValuesForComparison(requisition2, 1, requisitions);
assertThat(requisitions.get(0), is(requisition1));
assertThat(requisitions.get(1), is(requisition2));
}
@Test
public void shouldGetApprovedRequisitionsForCriteriaAndPageNumberWhenSearchingBySupplyDepotName() throws SQLException {
Long userId = insertUser();
insertRoleForApprovedRequisitions(facility.getId(), userId);
Rnr requisition1 = insertRequisition(processingPeriod1, program, SUBMITTED, false, facility, supervisoryNode, modifiedDate);
Rnr requisition2 = insertRequisition(processingPeriod2, program, SUBMITTED, false, facility, supervisoryNode, modifiedDate);
Rnr requisition3 = insertRequisition(processingPeriod3, program, SUBMITTED, false, facility, supervisoryNode, modifiedDate);
approve(requisition1, requisition2, requisition3);
String searchType = RequisitionService.SEARCH_SUPPLYING_DEPOT_NAME;
Integer pageNumber = 1;
Integer pageSize = 2;
String sortDirection = "asc";
String sortBy = "submittedDate";
List<Rnr> requisitions = mapper.getApprovedRequisitionsForCriteriaAndPageNumber(searchType, "apollo", pageNumber,
pageSize, userId, CONVERT_TO_ORDER, sortBy, sortDirection);
assertThat(requisitions.size(), is(2));
populateProgramValuesForComparison(requisition1, 0, requisitions);
populateProgramValuesForComparison(requisition2, 1, requisitions);
assertThat(requisitions.get(0), is(requisition1));
assertThat(requisitions.get(1), is(requisition2));
}
@Test
public void shouldGetApprovedRequisitionsForCriteriaAndPageNumberWhenSearchingByProgramName() throws SQLException {
Long userId = insertUser();
insertRoleForApprovedRequisitions(facility.getId(), userId);
Rnr requisition1 = insertRequisition(processingPeriod1, program, SUBMITTED, false, facility, supervisoryNode, modifiedDate);
Rnr requisition2 = insertRequisition(processingPeriod2, program, SUBMITTED, false, facility, supervisoryNode, modifiedDate);
Rnr requisition3 = insertRequisition(processingPeriod3, program, SUBMITTED, false, facility, supervisoryNode, modifiedDate);
approve(requisition1, requisition2, requisition3);
String searchType = RequisitionService.SEARCH_PROGRAM_NAME;
Integer pageNumber = 1;
Integer pageSize = 2;
String sortDirection = "asc";
String sortBy = "submittedDate";
List<Rnr> requisitions = mapper.getApprovedRequisitionsForCriteriaAndPageNumber(searchType, "Yellow", pageNumber,
pageSize, userId, CONVERT_TO_ORDER, sortBy, sortDirection);
assertThat(requisitions.size(), is(2));
populateProgramValuesForComparison(requisition1, 0, requisitions);
populateProgramValuesForComparison(requisition2, 1, requisitions);
assertThat(requisitions.get(0), is(requisition1));
assertThat(requisitions.get(1), is(requisition2));
}
@Test
public void shouldGetRequisitionsForViewByFacilityProgramAndPeriodIds() throws Exception {
String commaSeparatedPeriodIds = "{" + processingPeriod1.getId() + "," + processingPeriod2.getId() + "," + processingPeriod3.getId() + "}";
insertRequisition(processingPeriod1, program, AUTHORIZED, false, facility, supervisoryNode, modifiedDate);
insertRequisition(processingPeriod2, program, APPROVED, false, facility, supervisoryNode, modifiedDate);
insertRequisition(processingPeriod3, program, SUBMITTED, false, facility, supervisoryNode, modifiedDate);
List<Rnr> result = mapper.getPostSubmitRequisitions(facility, program, commaSeparatedPeriodIds);
assertThat(result.size(), is(2));
}
@Test
public void shouldOnlyLoadEmergencyRequisitionDataForGivenQuery() throws Exception {
Rnr initiatedRequisition = insertRequisition(processingPeriod1, program, INITIATED, true, facility, supervisoryNode, modifiedDate);
Rnr submittedRequisition = insertRequisition(processingPeriod1, program, SUBMITTED, true, facility, supervisoryNode, modifiedDate);
List<Rnr> actualRequisitions =
mapper.getInitiatedOrSubmittedEmergencyRequisitions(facility.getId(), program.getId());
assertContainsRequisition(actualRequisitions, initiatedRequisition);
assertContainsRequisition(actualRequisitions, submittedRequisition);
}
private void assertContainsRequisition(List<Rnr> actualRequisitions, final Rnr expectedRequisition) {
assertTrue(CollectionUtils.exists(actualRequisitions, new Predicate() {
@Override
public boolean evaluate(Object o) {
Rnr requisition = (Rnr) o;
return requisition.getStatus().equals(expectedRequisition.getStatus()) && requisition.getId().equals(expectedRequisition.getId());
}
}));
}
@Test
public void shouldGetApprovedRequisitionsInAscOrderOfProgramName() throws SQLException {
Long userId = insertUser();
insertRoleForApprovedRequisitions(facility.getId(), userId);
Program program1 = make(a(ProgramBuilder.defaultProgram, with(programCode, "YF"), with(programName, "Yellow fever")));
programMapper.insert(program1);
Program program2 = make(a(ProgramBuilder.defaultProgram, with(programCode, "GF"), with(programName, "Green fever")));
programMapper.insert(program2);
Rnr requisition1 = insertRequisition(processingPeriod1, program1, SUBMITTED, false, facility, supervisoryNode, modifiedDate);
Rnr requisition2 = insertRequisition(processingPeriod3, program2, SUBMITTED, false, facility, supervisoryNode, modifiedDate);
approve(requisition1, requisition2);
Integer pageNumber = 1;
Integer pageSize = 2;
String sortDirection = "asc";
String sortBy = "programName";
List<Rnr> requisitions = mapper.getApprovedRequisitionsForCriteriaAndPageNumber("", "", pageNumber,
pageSize, userId, CONVERT_TO_ORDER, sortBy, sortDirection);
assertThat(requisitions.size(), is(2));
assertThat(requisitions.get(0).getProgram().getId(), is(requisition2.getProgram().getId()));
assertThat(requisitions.get(1).getProgram().getId(), is(requisition1.getProgram().getId()));
}
@Test
public void shouldGetApprovedRequisitionsInAscOrderOfFacilityName() throws SQLException {
Long userId = insertUser();
insertRoleForApprovedRequisitions(facility.getId(), userId);
Facility facility1 = make(a(FacilityBuilder.defaultFacility, with(name, "village pharmacy"), with(FacilityBuilder.code, "VP")));
facilityMapper.insert(facility1);
Facility facility2 = make(a(FacilityBuilder.defaultFacility, with(name, "central hospital"), with(FacilityBuilder.code, "CH")));
facilityMapper.insert(facility2);
Rnr requisition1 = insertRequisition(processingPeriod1, program, SUBMITTED, false, facility1, supervisoryNode, modifiedDate);
Rnr requisition2 = insertRequisition(processingPeriod3, program, SUBMITTED, false, facility2, supervisoryNode, modifiedDate);
approve(requisition1, requisition2);
Integer pageNumber = 1;
Integer pageSize = 2;
String sortDirection = "asc";
String sortBy = "facilityName";
List<Rnr> requisitions = mapper.getApprovedRequisitionsForCriteriaAndPageNumber("", "", pageNumber,
pageSize, userId, CONVERT_TO_ORDER, sortBy, sortDirection);
assertThat(requisitions.size(), is(2));
assertThat(requisitions.get(0).getFacility().getId(), is(requisition2.getFacility().getId()));
assertThat(requisitions.get(1).getFacility().getId(), is(requisition1.getFacility().getId()));
}
@Test
public void shouldGetApprovedRequisitionsInAscOrderOfFacilityCode() throws SQLException {
Long userId = insertUser();
insertRoleForApprovedRequisitions(facility.getId(), userId);
Facility facility1 = make(a(FacilityBuilder.defaultFacility, with(name, "village pharmacy"), with(FacilityBuilder.code, "VP")));
facilityMapper.insert(facility1);
Facility facility2 = make(a(FacilityBuilder.defaultFacility, with(name, "central hospital"), with(FacilityBuilder.code, "CH")));
facilityMapper.insert(facility2);
Rnr requisition1 = insertRequisition(processingPeriod1, program, SUBMITTED, false, facility1, supervisoryNode, modifiedDate);
Rnr requisition2 = insertRequisition(processingPeriod3, program, SUBMITTED, false, facility2, supervisoryNode, modifiedDate);
approve(requisition1, requisition2);
Integer pageNumber = 1;
Integer pageSize = 2;
String sortDirection = "asc";
String sortBy = "facilityCode";
List<Rnr> requisitions = mapper.getApprovedRequisitionsForCriteriaAndPageNumber("", "", pageNumber,
pageSize, userId, CONVERT_TO_ORDER, sortBy, sortDirection);
assertThat(requisitions.size(), is(2));
assertThat(requisitions.get(0).getFacility().getId(), is(requisition2.getFacility().getId()));
assertThat(requisitions.get(1).getFacility().getId(), is(requisition1.getFacility().getId()));
}
@Test
public void shouldGetApprovedRequisitionsInAscOrderOfSupplyingDepotName() throws SQLException {
Facility facility1 = make(a(FacilityBuilder.defaultFacility, with(name, "village pharmacy"), with(FacilityBuilder.code, "VP")));
facilityMapper.insert(facility1);
Facility facility2 = make(a(FacilityBuilder.defaultFacility, with(name, "central hospital"), with(FacilityBuilder.code, "CH")));
facilityMapper.insert(facility2);
Long userId = insertUser();
insertRoleForApprovedRequisitions(facility1.getId(), userId);
insertRoleForApprovedRequisitions(facility2.getId(), userId);
SupervisoryNode supervisoryNode1 = insertSupervisoryNode("N2");
SupervisoryNode supervisoryNode2 = insertSupervisoryNode("N3");
insertSupplyLine(facility1, supervisoryNode1);
insertSupplyLine(facility2, supervisoryNode2);
Rnr requisition1 = insertRequisition(processingPeriod1, program, SUBMITTED, false, facility1, supervisoryNode1, modifiedDate);
Rnr requisition2 = insertRequisition(processingPeriod3, program, SUBMITTED, false, facility2, supervisoryNode2, modifiedDate);
approve(requisition1, requisition2);
Integer pageNumber = 1;
Integer pageSize = 2;
String sortDirection = "asc";
String sortBy = "supplyingDepotName";
List<Rnr> requisitions = mapper.getApprovedRequisitionsForCriteriaAndPageNumber("", "", pageNumber,
pageSize, userId, CONVERT_TO_ORDER, sortBy, sortDirection);
assertThat(requisitions.size(), is(2));
assertThat(requisitions.get(0).getFacility().getId(), is(requisition2.getFacility().getId()));
assertThat(requisitions.get(1).getFacility().getId(), is(requisition1.getFacility().getId()));
}
@Test
public void shouldGetApprovedRequisitionsInAscOrderOfModifiedDate() throws SQLException {
Long userId = insertUser();
insertRoleForApprovedRequisitions(facility.getId(), userId);
Date date1 = new Date();
Rnr requisition1 = insertRequisition(processingPeriod1, program, SUBMITTED, false, facility, supervisoryNode, date1);
Calendar calendar = Calendar.getInstance();
calendar.add(calendar.DAY_OF_MONTH, 1);
Date date2 = calendar.getTime();
Rnr requisition2 = insertRequisition(processingPeriod2, program, SUBMITTED, false, facility, supervisoryNode, date2);
approve(requisition1, requisition2);
Integer pageNumber = 1;
Integer pageSize = 2;
String sortDirection = "asc";
String sortBy = "modifiedDate";
List<Rnr> requisitions = mapper.getApprovedRequisitionsForCriteriaAndPageNumber("", "", pageNumber,
pageSize, userId, CONVERT_TO_ORDER, sortBy, sortDirection);
assertThat(requisitions.size(), is(2));
assertThat(requisitions.get(0).getId(), is(requisition1.getId()));
assertThat(requisitions.get(1).getId(), is(requisition2.getId()));
}
@Test
public void shouldGetApprovedRequisitionsInAscOrderOfEmergency() throws SQLException {
Long userId = insertUser();
insertRoleForApprovedRequisitions(facility.getId(), userId);
Rnr requisition1 = insertRequisition(processingPeriod1, program, SUBMITTED, true, facility, supervisoryNode, modifiedDate);
Rnr requisition2 = insertRequisition(processingPeriod2, program, SUBMITTED, false, facility, supervisoryNode, modifiedDate);
Rnr requisition3 = insertRequisition(processingPeriod3, program, SUBMITTED, true, facility, supervisoryNode, modifiedDate);
approve(requisition1, requisition2, requisition3);
Integer pageNumber = 1;
Integer pageSize = 2;
String sortDirection = "asc";
String sortBy = "emergency";
List<Rnr> requisitions = mapper.getApprovedRequisitionsForCriteriaAndPageNumber("", "", pageNumber,
pageSize, userId, CONVERT_TO_ORDER, sortBy, sortDirection);
assertThat(requisitions.size(), is(2));
assertThat(requisitions.get(0).getId(), is(requisition2.getId()));
assertThat(requisitions.get(1).getId(), is(requisition1.getId()));
}
@Test
public void shouldGetApprovedRequisitionsInAscOrderOfPeriodStartDate() throws SQLException {
Long userId = insertUser();
insertRoleForApprovedRequisitions(facility.getId(), userId);
ProcessingSchedule processingSchedule1 = make(a(defaultProcessingSchedule, with(ProcessingScheduleBuilder.code, "PS1")));
processingScheduleMapper.insert(processingSchedule1);
ProcessingSchedule processingSchedule2 = make(a(defaultProcessingSchedule, with(ProcessingScheduleBuilder.code, "PS2")));
processingScheduleMapper.insert(processingSchedule2);
Date periodStartDate1 = new Date();
Calendar calendar = Calendar.getInstance();
calendar.add(calendar.DAY_OF_MONTH, 1);
Date periodStartDate2 = calendar.getTime();
ProcessingPeriod processingPeriod4 = insertPeriod("period4", processingSchedule1, periodStartDate1, new Date());
ProcessingPeriod processingPeriod5 = insertPeriod("period5", processingSchedule2, periodStartDate2, new Date());
Rnr requisition1 = insertRequisition(processingPeriod4, program, SUBMITTED, true, facility, supervisoryNode, modifiedDate);
Rnr requisition2 = insertRequisition(processingPeriod5, program, SUBMITTED, false, facility, supervisoryNode, modifiedDate);
approve(requisition1, requisition2);
Integer pageNumber = 1;
Integer pageSize = 2;
String sortDirection = "asc";
String sortBy = "periodStartDate";
List<Rnr> requisitions = mapper.getApprovedRequisitionsForCriteriaAndPageNumber("", "", pageNumber,
pageSize, userId, CONVERT_TO_ORDER, sortBy, sortDirection);
assertThat(requisitions.size(), is(2));
assertThat(requisitions.get(0).getId(), is(requisition1.getId()));
assertThat(requisitions.get(1).getId(), is(requisition2.getId()));
}
@Test
public void shouldGetApprovedRequisitionsInAscOrderOfPeriodEndDate() throws SQLException {
Long userId = insertUser();
insertRoleForApprovedRequisitions(facility.getId(), userId);
ProcessingSchedule processingSchedule1 = make(a(defaultProcessingSchedule, with(ProcessingScheduleBuilder.code, "PS1")));
processingScheduleMapper.insert(processingSchedule1);
ProcessingSchedule processingSchedule2 = make(a(defaultProcessingSchedule, with(ProcessingScheduleBuilder.code, "PS2")));
processingScheduleMapper.insert(processingSchedule2);
Date periodEndDate1 = new Date();
Calendar calendar = Calendar.getInstance();
calendar.add(calendar.DAY_OF_MONTH, 1);
Date periodEndDate2 = calendar.getTime();
ProcessingPeriod processingPeriod4 = insertPeriod("period4", processingSchedule1, new Date(), periodEndDate1);
ProcessingPeriod processingPeriod5 = insertPeriod("period5", processingSchedule2, new Date(), periodEndDate2);
Rnr requisition1 = insertRequisition(processingPeriod4, program, SUBMITTED, true, facility, supervisoryNode, modifiedDate);
Rnr requisition2 = insertRequisition(processingPeriod5, program, SUBMITTED, false, facility, supervisoryNode, modifiedDate);
approve(requisition1, requisition2);
Integer pageNumber = 1;
Integer pageSize = 2;
String sortDirection = "asc";
String sortBy = "periodEndDate";
List<Rnr> requisitions = mapper.getApprovedRequisitionsForCriteriaAndPageNumber("", "", pageNumber,
pageSize, userId, CONVERT_TO_ORDER, sortBy, sortDirection);
assertThat(requisitions.size(), is(2));
assertThat(requisitions.get(0).getId(), is(requisition1.getId()));
assertThat(requisitions.get(1).getId(), is(requisition2.getId()));
}
@Test
public void shouldGetLWRequisitionById() {
Rnr requisition = insertRequisition(processingPeriod1, program, INITIATED, false, facility, supervisoryNode, modifiedDate);
Product product = insertProduct(true, "P1");
RnrLineItem fullSupplyLineItem = make(a(defaultRnrLineItem, with(fullSupply, true), with(productCode, product.getCode())));
RnrLineItem nonFullSupplyLineItem = make(a(defaultRnrLineItem, with(fullSupply, false), with(productCode, product.getCode())));
fullSupplyLineItem.setRnrId(requisition.getId());
nonFullSupplyLineItem.setRnrId(requisition.getId());
lineItemMapper.insert(fullSupplyLineItem, null);
lineItemMapper.insert(nonFullSupplyLineItem, null);
User author = new User();
author.setId(1L);
Comment comment = new Comment(requisition.getId(), author, "A comment", null);
commentMapper.insert(comment);
Rnr fetchedRequisition = mapper.getLWById(requisition.getId());
assertThat(fetchedRequisition.getId(), is(requisition.getId()));
assertThat(fetchedRequisition.getProgram().getId(), is(equalTo(program.getId())));
assertThat(fetchedRequisition.getFacility().getId(), is(equalTo(facility.getId())));
assertThat(fetchedRequisition.getPeriod().getId(), is(equalTo(processingPeriod1.getId())));
assertThat(fetchedRequisition.getModifiedBy(), is(equalTo(MODIFIED_BY)));
assertThat(fetchedRequisition.getStatus(), is(equalTo(INITIATED)));
assertThat(fetchedRequisition.getFullSupplyLineItems().size(), is(0));
assertThat(fetchedRequisition.getNonFullSupplyLineItems().size(), is(0));
assertThat(fetchedRequisition.getRegimenLineItems().size(), is(0));
}
@Test
public void shouldGetFacilityIdGivenARnrId() throws Exception {
Rnr requisition = insertRequisition(processingPeriod1, program, INITIATED, false, facility, supervisoryNode, modifiedDate);
assertThat(mapper.getFacilityId(requisition.getId()), is(requisition.getFacility().getId()));
}
@Test
public void shouldGetProgramIdGivenRnrId() throws Exception {
Rnr requisition = insertRequisition(processingPeriod1, program, INITIATED, false, facility, supervisoryNode, modifiedDate);
assertThat(mapper.getProgramId(requisition.getId()), is(requisition.getProgram().getId()));
}
@Test
public void shouldInsertRnrSignatures() throws Exception {
Rnr requisition = insertRequisition(processingPeriod1, program, INITIATED, false, facility, supervisoryNode, modifiedDate);
Signature submitterSignature = new Signature(Signature.Type.SUBMITTER, "Mystique");
signatureMapper.insertSignature(submitterSignature);
mapper.insertRnrSignature(requisition, submitterSignature);
List<Signature> dbRnrSignatures = mapper.getRnrSignaturesByRnrId(requisition.getId());
assertThat(dbRnrSignatures.size(), is(1));
assertThat(dbRnrSignatures.get(0).getText(), is("Mystique"));
}
@Test
public void shouldReturnSignaturesInRequisitions() {
Rnr requisition = insertRequisition(processingPeriod1, program, INITIATED, false, facility, supervisoryNode, modifiedDate);
Signature submitterSignature = new Signature(Signature.Type.SUBMITTER, "Mystique");
signatureMapper.insertSignature(submitterSignature);
mapper.insertRnrSignature(requisition, submitterSignature);
List<Rnr> rnrs = mapper.getRequisitionsWithLineItemsByFacility(facility);
List<Signature> rnrSignatures = rnrs.get(0).getRnrSignatures();
assertThat(rnrSignatures.size(), is(1));
assertThat(rnrSignatures.get(0).getText(), is("Mystique"));
}
private void insertRoleForApprovedRequisitions(Long facilityId, Long userId) throws SQLException {
queryExecutor.executeUpdate("INSERT INTO fulfillment_role_assignments (userId,facilityId,roleId) values (?,?,?)", userId, facilityId, role.getId());
}
private Role insertRole() {
Right right1 = new Right(CONVERT_TO_ORDER, FULFILLMENT);
Right right2 = new Right(RightName.VIEW_ORDER, FULFILLMENT);
Role role = new Role("r1", "random description", asList(right1,right2));
Long roleId = Long.valueOf(roleRightsMapper.insertRole(role));
role.setId(roleId);
for (Right right : role.getRights()) {
roleRightsMapper.createRoleRight(role, right.getName());
}
return role;
}
private Long insertUser() {
Long userId = 1l;
User someUser = make(a(defaultUser, with(UserBuilder.facilityId, facility.getId()), with(active, true)));
userMapper.insert(someUser);
return userId;
}
private void populateProgramValuesForComparison(Rnr requisition, int index, List<Rnr> requisitions) {
requisition.setSubmittedDate(requisitions.get(index).getSubmittedDate());
requisition.setProgram(requisitions.get(index).getProgram());
requisition.setSupplyingDepot(requisitions.get(index).getSupplyingDepot());
requisition.setSupervisoryNodeId(requisitions.get(index).getSupervisoryNodeId());
}
private Rnr insertRequisition(ProcessingPeriod period, Program program, RnrStatus status, Boolean emergency, Facility facility, SupervisoryNode supervisoryNode, Date modifiedDate) {
Rnr rnr = new Rnr(new Facility(facility.getId()), new Program(program.getId()), new ProcessingPeriod(period.getId()), emergency, MODIFIED_BY, 1L);
rnr.setStatus(status);
rnr.setEmergency(emergency);
rnr.setModifiedDate(modifiedDate);
rnr.setSubmittedDate(new Date(111111L));
rnr.setProgram(program);
rnr.setSupplyingDepot(facility);
mapper.insert(rnr);
requisitionStatusChangeMapper.insert(new RequisitionStatusChange(rnr));
rnr.setSupervisoryNodeId(supervisoryNode.getId());
mapper.update(rnr);
return rnr;
}
private RnrLineItem insertRnrLineItem(Rnr rnr, FacilityTypeApprovedProduct facilityTypeApprovedProduct) {
RnrLineItem item = new RnrLineItem(rnr.getId(), facilityTypeApprovedProduct, 1L, 1L);
lineItemMapper.insert(item, Collections.EMPTY_LIST.toString());
return item;
}
private FacilityTypeApprovedProduct insertFacilityApprovedProduct(ProgramProduct programProduct) {
FacilityTypeApprovedProduct facilityTypeApprovedProduct = make(a(FacilityApprovedProductBuilder.defaultFacilityApprovedProduct));
facilityTypeApprovedProduct.setProgramProduct(programProduct);
facilityApprovedProductMapper.insert(facilityTypeApprovedProduct);
return facilityTypeApprovedProduct;
}
private ProgramProduct insertProgramProductWithProductCategory(Product product, Program program) {
ProgramProduct programProduct = new ProgramProduct(program, product, 30, true, new Money("12.5000"));
programProduct.setProductCategory(productCategory);
programProduct.setFullSupply(product.getFullSupply());
programProductMapper.insert(programProduct);
return programProduct;
}
private void insertProgram() {
program = make(a(ProgramBuilder.defaultProgram));
programMapper.insert(program);
}
private Product insertProduct(boolean isFullSupply, String productCode) {
Product product = make(a(ProductBuilder.defaultProduct, with(ProductBuilder.code, productCode), with(ProductBuilder.fullSupply, isFullSupply)));
productMapper.insert(product);
return product;
}
private ProcessingPeriod insertPeriod(String name, ProcessingSchedule processingSchedule, Date periodStartDate, Date periodEndDate) {
ProcessingPeriod processingPeriod = make(a(defaultProcessingPeriod,
with(scheduleId, processingSchedule.getId()), with(startDate, periodStartDate), with(endDate, periodEndDate),
with(ProcessingPeriodBuilder.name, name)));
processingPeriodMapper.insert(processingPeriod);
return processingPeriod;
}
private SupervisoryNode insertSupervisoryNode(String code) {
supervisoryNode = make(a(SupervisoryNodeBuilder.defaultSupervisoryNode, with(SupervisoryNodeBuilder.code, code)));
supervisoryNode.setFacility(facility);
supervisoryNodeMapper.insert(supervisoryNode);
return supervisoryNode;
}
private void insertSupplyLine(Facility facility, SupervisoryNode supervisoryNode) {
SupplyLine supplyLine = make(a(defaultSupplyLine, with(SupplyLineBuilder.facility, facility),
with(SupplyLineBuilder.supervisoryNode, supervisoryNode), with(SupplyLineBuilder.program, program)));
supplyLineMapper.insert(supplyLine);
}
private void updateSupplyingDepotForRequisition(Rnr requisition) {
requisition.setSupplyingDepot(facility);
mapper.update(requisition);
}
private void approve(Rnr... requisitions) {
for (Rnr requisition : requisitions) {
requisition.setStatus(APPROVED);
mapper.update(requisition);
}
}
}