StaticDataLookupImpl.java

package com.tradecloud.repository.utils;

import com.tradecloud.common.base.HibernateUtils;
import com.tradecloud.common.externalreference.IntegratedSystem;
import com.tradecloud.domain.agent.Agent;
import com.tradecloud.domain.agent.OrganisationalUnitAgent;
import com.tradecloud.domain.common.Currency;
import com.tradecloud.domain.common.Incoterm;
import com.tradecloud.domain.container.ContainerType;
import com.tradecloud.domain.costing.CostDefinition;
import com.tradecloud.domain.costing.CostLineTemplate;
import com.tradecloud.domain.item.*;
import com.tradecloud.domain.model.organisationalunit.OrganisationalUnit;
import com.tradecloud.domain.model.organisationalunit.OrganisationalUnitTier;
import com.tradecloud.domain.model.payment.*;
import com.tradecloud.domain.party.Bank;
import com.tradecloud.domain.party.ServiceProvider;
import com.tradecloud.domain.party.base.Contact;
import com.tradecloud.domain.place.*;
import com.tradecloud.domain.supplier.OrganisationalUnitSupplier;
import com.tradecloud.domain.supplier.Supplier;
import com.tradecloud.domain.utils.StaticDataLookup;
import com.tradecloud.repository.GeneralRepository;
import com.tradecloud.repository.OrganisationalUnitRepository;
import com.tradecloud.repository.ProductRepository;
import com.tradecloud.repository.company.CompanyRepository;
import com.tradecloud.repository.company.OrganisationalUnitSupplierRepository;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * @author Ronan Static Data Lookup utility class
 */
@Component
@Transactional(readOnly = true)
public class StaticDataLookupImpl implements StaticDataLookup {

    Logger log = Logger.getLogger(StaticDataLookupImpl.class);

    @Autowired
    private GeneralRepository generalRepository;

    @Autowired
    private OrganisationalUnitRepository organisationalUnitRepository;

    @Autowired
    private OrganisationalUnitSupplierRepository organisationalUnitSupplierRepository;

    @Autowired
    ProductRepository productRepository;

    @Autowired
    CompanyRepository companyRepository;

    @Override
    public AgentCommissionBasedOn lookupAgentCommissionBasedOn(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.retrieve(AgentCommissionBasedOn.class, code));
    }

    @Override
    public PaymentMethod lookupPaymentMethod(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.retrieve(PaymentMethod.class, code));
    }

    @Override
    public PaymentTerm lookupPaymentTerm(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.retrieve(PaymentTerm.class, code));
    }

    @Override
    public Currency lookupCurrency(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.retrieve(Currency.class, code));
    }

    @Override
    public Incoterm lookupIncoterm(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.retrieve(Incoterm.class, code));
    }

    @Override
    public ActualPaymentBasis lookupActualPaymentBasis(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.retrieve(ActualPaymentBasis.class, code));
    }

    @Override
    public EstimatedPaymentBasis lookupEstimatedPaymentBasis(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.retrieve(EstimatedPaymentBasis.class, code));
    }

    @Override
    public ContainerType lookupContainerType(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.retrieve(ContainerType.class, code));
    }

    @Override
    public Country lookupCountry(String code) {
        Country retrieve = generalRepository.retrieve(Country.class, code);
        return HibernateUtils.initializeAndUnproxy(retrieve);
    }

    @Override
    public City lookupCity(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.retrieve(City.class, code));
    }

    @Override
    public ItemCategory lookupItemCategory(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.retrieve(ItemCategory.class, code));
    }

    @Override
    public BaseCategory lookupBaseCategory(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.retrieve(BaseCategory.class, code));
    }

    @Override
    public OrganisationalUnit lookupOrganisationalUnit(String code) {
        return organisationalUnitRepository.retrieve(code);
    }

    public List<OrganisationalUnitSupplier> lookupAllOrganisationalUnitSuppliers() {
        return organisationalUnitSupplierRepository.findAll();
    }

    /**
     * Looks up a ServiceProvider.
     */
    public ServiceProvider lookupServiceProvider() {
        List<ServiceProvider> serviceProviders = generalRepository.findAll(ServiceProvider.class);

        for (ServiceProvider serviceProvider : serviceProviders) {
            return serviceProvider;
        }
        return null;
    }

    /**
     * Looks up a service provider by name.
     */
    @Override
    public ServiceProvider lookupServiceProvider(String name) {
        List<ServiceProvider> serviceProviders = generalRepository.findAll(ServiceProvider.class);

        for (ServiceProvider serviceProvider : serviceProviders) {
            if (serviceProvider.getName().equalsIgnoreCase(name)) {
                return serviceProvider;
            }
        }
        return null;
    }

    /**
     * Looks up an org unit supplier.
     */
    @Override
    public OrganisationalUnitSupplier lookupOrgUnitSupplier() {
        List<OrganisationalUnitSupplier> suppliers = generalRepository.findAll(OrganisationalUnitSupplier.class);

        for (OrganisationalUnitSupplier supplier : suppliers) {
            return supplier;
        }
        return null;
    }

    /**
     * Looks up a supplier.
     */
    public Supplier lookupSupplier() {
        List<Supplier> suppliers = generalRepository.findAll(Supplier.class);

        for (Supplier supplier : suppliers) {
            return supplier;
        }
        return null;
    }


    /**
     * Looks up a supplier by name.
     */
    @Override
    public OrganisationalUnitSupplier lookupOrganisationalUnitSupplier(String name) {
        List<OrganisationalUnitSupplier> suppliers = generalRepository.findAll(OrganisationalUnitSupplier.class);

        for (OrganisationalUnitSupplier supplier : suppliers) {
            if (supplier.getName().equalsIgnoreCase(name)) {
                return supplier;
            }
        }
        return null;
    }

    @Override
    public OrganisationalUnitAgent lookupOrganisationalUnitAgent(String name) {
        List<OrganisationalUnitAgent> agents = generalRepository.findAll(OrganisationalUnitAgent.class);

        for (OrganisationalUnitAgent agent : agents) {
            if (agent.getName().equalsIgnoreCase(name)) {
                return agent;
            }
        }
        return null;
    }

    /**
     * Looks up a supplier by name.
     */
    @Override
    public Supplier lookupSupplier(String name) {
        List<Supplier> suppliers = generalRepository.findAll(Supplier.class);

        for (Supplier supplier : suppliers) {
            if (supplier.getName().equalsIgnoreCase(name)) {
                log.debug("Found supplier with name:" + name);
                return supplier;
            }
        }
        log.debug("No supplier found with name:" + name);
        return null;
    }

    @Override
    public Agent lookupAgent(String name) {
        List<Agent> agents = generalRepository.findAll(Agent.class);

        for (Agent agent : agents) {
            if (agent.getName().equalsIgnoreCase(name)) {
                log.debug("Found agent with name:" + name);
                return agent;
            }
        }
        log.debug("No agent found with name:" + name);
        return null;
    }

    @Override
    public NamedPlace lookupNamedPlace(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.retrieve(NamedPlace.class, code));
    }

    @Override
    public UnitType lookupUnitType(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.retrieve(UnitType.class, code));
    }

    @Override
    public PackageType lookupPackageType(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.retrieve(PackageType.class, code));
    }

    @Override
    public VolumeUnitOfMeasure lookupVolumeUnitOfMeasure(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.retrieve(VolumeUnitOfMeasure.class, code));
    }

    @Override
    public WeightUnitOfMeasure lookupWeightUnitOfMeasure(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.retrieve(WeightUnitOfMeasure.class, code));
    }

    @Override
    public Depot lookupDepot(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.retrieve(Depot.class, code));
    }

    @Override
    public Warehouse lookupWarehouse(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.retrieve(Warehouse.class, code));
    }

    @Override
    public CostLineTemplate lookupCostLineTemplate(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.retrieve(CostLineTemplate.class, code));
    }

    @Override
    public CostDefinition lookupCostDefinition(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.retrieve(CostDefinition.class, code));
    }

    @Override
    public PlaceOfLoading lookupPlaceOfLoading(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.retrieve(PlaceOfLoading.class, code));
    }

    @Override
    public PlaceOfDischarge lookupPlaceOfDischarge(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.retrieve(PlaceOfDischarge.class, code));
    }

    @Override
    public PlaceOfExpiry lookupPlaceOfExpiry(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.retrieve(PlaceOfExpiry.class, code));
    }

    @Override
    public FinalDestination lookupFinalDestination(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.retrieve(FinalDestination.class, code));
    }

    @Override
    public OrganisationalUnitTier lookupOrganisationalUnitTierByName(String name) {
        List<OrganisationalUnitTier> tiers = generalRepository.findAll(OrganisationalUnitTier.class);
        for (OrganisationalUnitTier tier : tiers) {
            if (tier.getName().equalsIgnoreCase(name)) {
                return HibernateUtils.initializeAndUnproxy(tier);
            }
        }
        return null;
    }

    public Product lookupProduct(String productCode) {
        return HibernateUtils.initializeAndUnproxy(productRepository.retrieve(productCode));
    }

    @Override
    public Contact lookupContactByEmail(String email) {
        for (Contact contact : generalRepository.findAll(Contact.class)) {
            if (contact.getEmail().equals(email)) {
                return HibernateUtils.initializeAndUnproxy(contact);
            }
        }
        return null;
    }

    @Override
    public Bank lookupBank(String name) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.findByName(Bank.class, name));
    }

    @Override
    public Bank lookupBankByCode(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.findByCode(Bank.class, code));
    }

    @Override
    public IntegratedSystem lookupIntegratedSystem(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.findByCode(IntegratedSystem.class, code));
    }

    @Override
    public PlaceOfCustom lookupPlaceOfCustomsEntry(String code) {
        return HibernateUtils.initializeAndUnproxy(generalRepository.retrieve(PlaceOfCustom.class, code));
    }
}