org.openlmis.distribution.service.FacilityDistributionService.java Source code

Java tutorial

Introduction

Here is the source code for org.openlmis.distribution.service.FacilityDistributionService.java

Source

/*
 * 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.distribution.service;

import lombok.NoArgsConstructor;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.Predicate;
import org.apache.commons.collections.Transformer;
import org.openlmis.core.domain.Facility;
import org.openlmis.core.domain.Refrigerator;
import org.openlmis.core.exception.DataException;
import org.openlmis.core.service.FacilityService;
import org.openlmis.core.service.MessageService;
import org.openlmis.core.service.RefrigeratorService;
import org.openlmis.distribution.domain.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import static org.apache.commons.collections.CollectionUtils.collect;
import static org.apache.commons.collections.CollectionUtils.select;

/**
 * Exposes the services for handling FacilityDistribution entity.
 */

@Service
@NoArgsConstructor
public class FacilityDistributionService {

    @Autowired
    private FacilityService facilityService;

    @Autowired
    private RefrigeratorService refrigeratorService;

    @Autowired
    private EpiUseService epiUseService;

    @Autowired
    private FacilityVisitService facilityVisitService;

    @Autowired
    private DistributionRefrigeratorsService distributionRefrigeratorsService;

    @Autowired
    private EpiInventoryService epiInventoryService;

    @Autowired
    private MessageService messageService;

    @Autowired
    private VaccinationCoverageService vaccinationCoverageService;

    public Map<Long, FacilityDistribution> createFor(Distribution distribution) {
        Long deliveryZoneId = distribution.getDeliveryZone().getId();
        Long programId = distribution.getProgram().getId();

        Map<Long, FacilityDistribution> facilityDistributions = new HashMap<>();

        List<Facility> facilities = facilityService.getAllForDeliveryZoneAndProgram(deliveryZoneId, programId);
        if (facilities.size() == 0) {
            throw new DataException(messageService.message("message.no.facility.available",
                    distribution.getProgram().getName(), distribution.getDeliveryZone().getName()));
        }
        List<Refrigerator> distributionRefrigerators = refrigeratorService
                .getRefrigeratorsForADeliveryZoneAndProgram(deliveryZoneId, programId);
        List<TargetGroupProduct> targetGroupProducts = vaccinationCoverageService.getVaccinationProducts();
        List<TargetGroupProduct> childrenTargetGroupProducts = new ArrayList<>();
        List<TargetGroupProduct> adultTargetGroupProducts = new ArrayList<>();
        filterTargetGroupProducts(targetGroupProducts, childrenTargetGroupProducts, adultTargetGroupProducts);
        List<ProductVial> productVials = vaccinationCoverageService.getProductVials();
        List<ProductVial> childProductVials = new ArrayList<>();
        List<ProductVial> adultProductVials = new ArrayList<>();
        filterProductVials(productVials, childProductVials, adultProductVials);

        for (Facility facility : facilities) {
            facilityDistributions.put(facility.getId(),
                    createDistributionData(facility, distribution, distributionRefrigerators,
                            childrenTargetGroupProducts, adultTargetGroupProducts, childProductVials,
                            adultProductVials));
        }

        return facilityDistributions;
    }

    private void filterProductVials(List<ProductVial> productVials, List<ProductVial> childProductVials,
            List<ProductVial> adultProductVials) {
        CollectionUtils.select(productVials, new Predicate() {
            @Override
            public boolean evaluate(Object o) {
                return ((ProductVial) o).getChildCoverage();
            }
        }, childProductVials);
        CollectionUtils.selectRejected(productVials, new Predicate() {
            @Override
            public boolean evaluate(Object o) {
                return ((ProductVial) o).getChildCoverage();
            }
        }, adultProductVials);
    }

    private void filterTargetGroupProducts(List<TargetGroupProduct> targetGroupProducts,
            List<TargetGroupProduct> childrenTargetGroupProducts,
            List<TargetGroupProduct> adultTargetGroupProducts) {
        CollectionUtils.select(targetGroupProducts, new Predicate() {
            @Override
            public boolean evaluate(Object o) {
                return ((TargetGroupProduct) o).getChildCoverage();
            }
        }, childrenTargetGroupProducts);
        CollectionUtils.selectRejected(targetGroupProducts, new Predicate() {
            @Override
            public boolean evaluate(Object o) {
                return ((TargetGroupProduct) o).getChildCoverage();
            }
        }, adultTargetGroupProducts);
    }

    FacilityDistribution createDistributionData(final Facility facility, Distribution distribution,
            List<Refrigerator> refrigerators, List<TargetGroupProduct> childrenTargetGroupProducts,
            List<TargetGroupProduct> adultTargetGroupProducts, List<ProductVial> childProductVials,
            List<ProductVial> adultProductVials) {
        List<RefrigeratorReading> refrigeratorReadings = getRefrigeratorReadings(facility.getId(), refrigerators);

        FacilityVisit facilityVisit = new FacilityVisit(facility, distribution);
        facilityVisitService.save(facilityVisit);
        FacilityDistribution facilityDistribution = new FacilityDistribution(facilityVisit, facility, distribution,
                refrigeratorReadings, childrenTargetGroupProducts, adultTargetGroupProducts, childProductVials,
                adultProductVials);
        epiUseService.save(facilityDistribution.getEpiUse());
        epiInventoryService.save(facilityDistribution.getEpiInventory());
        vaccinationCoverageService.saveChildCoverage(facilityDistribution.getChildCoverage());
        vaccinationCoverageService.saveAdultCoverage(facilityDistribution.getAdultCoverage());
        return facilityDistribution;
    }

    public FacilityDistribution save(FacilityDistribution facilityDistribution) {
        facilityVisitService.save(facilityDistribution.getFacilityVisit());
        if (facilityDistribution.getFacilityVisit().getVisited()) {
            epiInventoryService.save(facilityDistribution.getEpiInventory());
            distributionRefrigeratorsService.save(facilityDistribution.getFacilityVisit().getFacilityId(),
                    facilityDistribution.getRefrigerators());
            epiUseService.save(facilityDistribution.getEpiUse());
        }
        vaccinationCoverageService.save(facilityDistribution);
        return facilityDistribution;
    }

    public FacilityDistribution setSynced(FacilityDistribution facilityDistribution) {
        facilityVisitService.setSynced(facilityDistribution.getFacilityVisit());
        return facilityDistribution;
    }

    private List<RefrigeratorReading> getRefrigeratorReadings(final Long facilityId,
            List<Refrigerator> refrigerators) {
        return (List<RefrigeratorReading>) collect(select(refrigerators, new Predicate() {
            @Override
            public boolean evaluate(Object o) {
                return ((Refrigerator) o).getFacilityId().equals(facilityId);
            }
        }), new Transformer() {
            @Override
            public Object transform(Object o) {
                return new RefrigeratorReading((Refrigerator) o);
            }
        });
    }

    public Map<Long, FacilityDistribution> get(Distribution distribution) {
        Map<Long, FacilityDistribution> facilityDistributions = new HashMap<>();

        List<FacilityVisit> unSyncedFacilities = facilityVisitService.getUnSyncedFacilities(distribution.getId());
        for (FacilityVisit facilityVisit : unSyncedFacilities) {
            facilityDistributions.put(facilityVisit.getFacilityId(),
                    getDistributionData(facilityVisit, distribution));
        }
        return facilityDistributions;
    }

    private FacilityDistribution getDistributionData(FacilityVisit facilityVisit, Distribution distribution) {
        EpiUse epiUse = epiUseService.getBy(facilityVisit.getId());

        List<Refrigerator> refrigerators = refrigeratorService.getRefrigeratorsForADeliveryZoneAndProgram(
                distribution.getDeliveryZone().getId(), distribution.getProgram().getId());
        DistributionRefrigerators distributionRefrigerators = new DistributionRefrigerators(
                getRefrigeratorReadings(facilityVisit.getFacilityId(), refrigerators));

        Facility facility = facilityService.getById(facilityVisit.getFacilityId());

        EpiInventory epiInventory = epiInventoryService.getBy(facilityVisit.getId());
        VaccinationFullCoverage coverage = vaccinationCoverageService.getFullCoverageBy(facilityVisit.getId());
        VaccinationChildCoverage childCoverage = vaccinationCoverageService
                .getChildCoverageBy(facilityVisit.getId());
        VaccinationAdultCoverage adultCoverage = vaccinationCoverageService
                .getAdultCoverageBy(facilityVisit.getId());

        FacilityDistribution facilityDistribution = new FacilityDistribution(facilityVisit, epiUse,
                distributionRefrigerators, epiInventory, coverage, childCoverage, adultCoverage);
        facilityDistribution.setFacility(facility);
        return facilityDistribution;
    }
}