CostingStructureMatcher.java

package com.tradecloud.domain.costing.clean;

import com.tradecloud.domain.base.utils.ObjectUtil;
import com.tradecloud.domain.container.Container;
import com.tradecloud.domain.container.ContainerUsage;
import com.tradecloud.domain.document.invoice.ActualConsignment;
import com.tradecloud.domain.document.invoice.ActualLineItem;
import com.tradecloud.domain.document.invoice.ActualOrder;
import com.tradecloud.domain.document.invoice.CostsInvoice;
import com.tradecloud.domain.item.LineItem;
import com.tradecloud.domain.model.ordermanagement.Consignment;
import com.tradecloud.domain.model.ordermanagement.Order;
import com.tradecloud.domain.settlement.PlannedSettlementOrder;
import com.tradecloud.domain.shipment.Shipment;
import org.apache.commons.lang3.builder.EqualsBuilder;

import java.math.BigDecimal;
import java.util.List;
import java.util.Set;

/**
 * I have moved methods from Order, Consignment, Shipment to here. They are of
 * the form Order.match(ActualOrder)
 *
 * @author jon
 */
public class CostingStructureMatcher {

    public static boolean match(Costed estimate, Costed actual) {
        if (estimate instanceof CostedLineItem && actual instanceof ActualLineItem)
            return match((CostedLineItem) estimate, (ActualLineItem) actual);
        if (estimate instanceof CostedOrder && actual instanceof ActualOrder)
            return match((CostedOrder) estimate, (ActualOrder) actual);
        if (estimate instanceof CostedConsignment && actual instanceof ActualConsignment)
            return match((CostedConsignment) estimate, (ActualConsignment) actual);

        return false;
    }

    public static boolean match(CostedLineItem costedLineItem, ActualLineItem actualLineItem) {
        Long estimateItemId = costedLineItem.getLineItem().getId();
        Long actualItemId = actualLineItem.getOriginalId();
        return estimateItemId.equals(actualItemId);
    }

    public static boolean match(CostedOrder costedOrder, ActualOrder actualOrder) {
        String estimateNumber = costedOrder.getNumber();
        String actualNumber = actualOrder.getNumber();

        return estimateNumber.equals(actualNumber);
    }

    public static boolean match(CostedConsignment costedConsignment, ActualConsignment actualConsignment) {
        String estimateNumber = costedConsignment.getNumber();
        String actualNumber = actualConsignment.getNumber();

        return estimateNumber.equals(actualNumber);
    }

    // From LineItem
    public static boolean match(LineItem lineItem, CostedLineItem costedLineItem) {
        return matchLineItemAndCostingItem(lineItem, costedLineItem);
    }

    public static boolean match(LineItem lineItem, ActualLineItem actualLineItem) {
        if (actualLineItem.getOriginalId() != null) {
            return lineItem.getId().equals(actualLineItem.getOriginalId());
        } else {
            return matchLineItemAndCostingItem(lineItem, actualLineItem);
        }
    }

    private static boolean matchLineItemAndCostingItem(LineItem lineItem, CostingItem costingItem) {
        if (ObjectUtil.allNotNull(costingItem.getCode(), costingItem.getOrganisation())) {
            return new EqualsBuilder().append(lineItem.getCode(), costingItem.getCode()).
                    append(lineItem.getOrganisationalUnit().getCode(), costingItem.getOrganisation()).isEquals();
        } else {
            return new EqualsBuilder().append(lineItem.getCode(), costingItem.getCode()).isEquals();
        }
    }

    public static boolean match(PlannedSettlementOrder plannedSettlementOrder, ActualOrder actualOrder) {
        return plannedSettlementOrder.getReference().equals(actualOrder.getReference());
    }

    // From order
    public static boolean match(Order order, CostedOrder costedOrder) {
        /*return this.orderReference.equals(costedOrder.getReference()) && this.number.equals(costedOrder.getNumber());
         Commented out because of TCA-133
         */
        return order.getNumber().equals(costedOrder.getNumber());
    }

    public static boolean match(Order order, ActualOrder actualOrder) {
        /*return this.orderReference.equals(costedOrder.getReference()) && this.number.equals(actualOrder.getNumber());
         Commented out because of TCA-133
         */
        return order.getNumber().equals(actualOrder.getNumber());
    }

    public static boolean match(Order order, Costed costed) {
        if (costed instanceof ActualOrder) {
            return match(order, (ActualOrder) costed);
        } else if (costed instanceof CostedOrder) {
            return match(order, (CostedOrder) costed);
        }
        return false;
    }

    public static LineItem getLineItem(Order order, CostedLineItem costedLineItem) {
        for (LineItem lineItem : order.getLineItems()) {
            if (match(lineItem, costedLineItem)) {
                return lineItem;
            }
        }
        return null;
    }

    public static LineItem getLineItem(Order order, ActualLineItem actualLineItem) {
        for (LineItem lineItem : order.getLineItems()) {
            if (match(lineItem, actualLineItem)) {
                return lineItem;
            }
        }
        return null;
    }

    // From consignment
    public static boolean match(Consignment consignment, ActualConsignment actualConsignment) {
        return consignment.getReference().equals(actualConsignment.getReference()) && consignment.getNumber().equals(actualConsignment.getNumber());
    }

    public static Order getOrder(Consignment consignment, CostedOrder costedOrder) {
        for (Order order : consignment.getOrders()) {
            if (match(order, costedOrder)) {
                return order;
            }
        }
        return null;
    }

    public static Order getOrder(Consignment consignment, ActualOrder actualOrder) {
        for (Order order : consignment.getOrders()) {
            if (match(order, actualOrder)) {
                return order;
            }
        }

        return null;
    }

    public static Order getOrder(Shipment shipment, ActualOrder actualOrder) {
        Set<Consignment> consignments = shipment.getConsignments();
        for (Consignment consignment : consignments) {
            Order order = getOrder(consignment, actualOrder);
            if (order != null) {
                return order;

            }

        }

        return null;
    }

    // From shipment
    public static boolean match(Shipment shipment, ActualShipment actualShipment) {
        return shipment.getReference().equals(actualShipment.getReference()) && shipment.getNumber().equals(actualShipment.getNumber());
    }

    // From container
    public static BigDecimal getNumberAtDepot(Container container, CostedOrder costedOrder) {

        for (ContainerUsage containerUsage : container.getContainerUsages()) {
            if (match(containerUsage.getOrder(), costedOrder)) {
                return containerUsage.getNumberAtClearingDepot();
            }
        }
        return BigDecimal.ZERO;
    }

    public static BigDecimal getNumberAtPOD(Container container, CostedOrder costedOrder) {

        for (ContainerUsage containerUsage : container.getContainerUsages()) {
            if (match(containerUsage.getOrder(), costedOrder)) {
                return containerUsage.getNumberAtPOD();
            }
        }
        return BigDecimal.ZERO;
    }

    public static ActualOrder getActualOrder(CostsInvoice costsInvoice, Order order) {
        return getActualOrder(order, costsInvoice.getActualConsignmentList());
    }

    public static ActualOrder getActualOrder(ActualShipment actualShipment, Order order) {
        return getActualOrder(order, actualShipment.getActualConsignmentList());
    }

    private static ActualOrder getActualOrder(Order order, List<ActualConsignment> actualConsignmentList) {
        for (ActualConsignment actualConsignment : actualConsignmentList) {
            List<ActualOrder> actualOrders = actualConsignment.getActualOrderList();
            for (ActualOrder actualOrder : actualOrders) {
                if (match(order, actualOrder)) {
                    return actualOrder;
                }
            }
        }
        return null;
    }

    public static ActualConsignment getActualConsignment(ActualShipment actualShipment, Consignment consignment) {
        for (ActualConsignment actualConsignment : actualShipment.getActualConsignmentList()) {
            if (actualConsignment.getOriginalId().equals(consignment.getId())) {
                return actualConsignment;
            }

        }
        return null;
    }
}