Subversion Repositories SmartDukaan

package in.shop2020.warehouse.handler;

import in.shop2020.warehouse.domain.AmazonTransferredSkuDetail;
import in.shop2020.warehouse.DetailedPurchaseScan;
import in.shop2020.warehouse.InvAgeConsiderItems;
import in.shop2020.warehouse.InventoryAge;
import in.shop2020.warehouse.InventoryAvailability;
import in.shop2020.warehouse.InventoryMovement;
import in.shop2020.warehouse.InvoiceScan;
import in.shop2020.warehouse.ScanType;
import in.shop2020.warehouse.TransferInvoiceScan;
import in.shop2020.warehouse.domain.Scan;
import in.shop2020.warehouse.persistence.ScanMapper;

import java.util.Date;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class ScanHandler {
    @Autowired
    private ScanMapper scanMapper;

    /**
     * @param scan
     */
    public void insert(Scan scan) {
        scanMapper.insert(scan);
    }

    /**
     * @param inventoryItemId
     * @param scanType
     * @return
     */
    public List<Scan> getScans(long inventoryItemId, ScanType scanType) {
        return scanMapper.get(inventoryItemId, scanType);
    }

    /**
     * @param orderId
     */
    public List<Scan> getScans(long orderId) {
        return scanMapper.getScansFromOrderId(orderId);
    }

    /**
     * @param startDate
     * @param endDate
     * @return
     */
    public List<DetailedPurchaseScan> getPurchaseScans(long startDate,
            long endDate)
    {
        return scanMapper.getPurchaseScans(new Date(startDate), new Date(endDate));
    }

    /**
     * @param date
     * @return
     */
    public List<InvoiceScan> fetchMismatchScansPerInvoiceNumber(long date) {
        return scanMapper.fetchMismatchScansPerInvoiceNumber(new Date(date));
    }

    /**
     * @return
     */
    public List<InventoryAge> getInventoryAge() {
        return scanMapper.getInventoryAge();
    }

        public List<Scan> getScansForItem(Long itemId, Date fromDate, Date toDate) {
                return scanMapper.getScansForItem(itemId, fromDate, toDate);
        }

        public void genericScan(Scan scan) {
                scanMapper.genericScan(scan);
                
        }

        public List<in.shop2020.warehouse.InventoryAvailability> getCurrentSerializedInventoryByScans(Long physicalWarehouseId) {
                return scanMapper.getCurrentSerializedInventoryByScans(physicalWarehouseId);
        }

        public List<InventoryAvailability> getCurrentNonSerializedInventoryByScans(Long physicalWarehouseId) {
                return scanMapper.getCurrentNonSerializedInventoryByScans(physicalWarehouseId);
        }
        
        public List<in.shop2020.warehouse.InventoryAvailability> getHistoricSerializedInventoryByScans(Date date) {
                return scanMapper.getHistoricSerializedInventoryByScans(date);
        }

        public List<InventoryAvailability> getHistoricNonSerializedInventoryByScans(Date date) {
                return scanMapper.getHistoricNonSerializedInventoryByScans(date);
        }

        public List<InventoryMovement> getMovementSerializedInventoryByScans(
                        Date startDate, Date endDate) {
                return scanMapper.getMovementSerializedInventoryByScans(startDate, endDate);
        }

        public List<InventoryMovement> getMovementNonSerializedInventoryByScans(
                        Date startDate, Date endDate) {
                return scanMapper.getMovementNonSerializedInventoryByScans(startDate, endDate);
        }

        public List<Scan> getScansForOrderAndItem(Long orderId, Long itemId) {
                return scanMapper.getScansForOrderAndItem(orderId, itemId);
        }

        public List<DetailedPurchaseScan> getPurchaseScansByGrnDate(long startDate,
                        long endDate) {
                return scanMapper.getPurchaseScansByGrnDate(new Date(startDate), new Date(endDate));
        }

        public List<InventoryMovement> getCompleteMovementSerializedInventoryByScans(
                        Date startDate, Date endDate) {
                return scanMapper.getCompleteMovementSerializedInventoryByScans(startDate, endDate);
        }

        public List<InventoryMovement> getCompleteMovementNonSerializedInventoryByScans(
                        Date startDate, Date endDate) {
                return scanMapper.getCompleteMovementNonSerializedInventoryByScans(startDate, endDate);
        }

        public List<Long> getTransferrableWarehousesFromWarehouse(Long warehouseId) {
                return scanMapper.getTransferrableWarehousesFromWarehouse(warehouseId);
        }

        public List<Scan> getScansForTransferLot(long id) {
                return scanMapper.getScansForTransferLot(id);
        }

        public List<InventoryAvailability> getHistoricBadInventoryByScans(Date date) {
                return scanMapper.getHistoricBadInventoryByScans(date);
        }
        
        public Scan getScansForTransferLotAndInventoryItem(long transferLotId, long inventoryItemId){
                return scanMapper.getScansForTransferLotAndInventoryItem(transferLotId,inventoryItemId);
        }

        public List<InventoryAvailability> getOurHistoricSerializedInventoryByScans(
                        Date date) {
                return scanMapper.getOurHistoricSerializedInventoryByScans(date);
        }

        public List<InventoryAvailability> getOurHistoricNonSerializedInventoryByScans(
                        Date date) {
                return scanMapper.getOurHistoricNonSerializedInventoryByScans(date);
        }
        
        public List<AmazonTransferredSkuDetail> getAmazonTransferredSkuDetails(List<Long> itemIds){
                return scanMapper.getAmazonTransferredSkuDetails(itemIds);
        }
        
        public List<Scan> getScansforPurchase(Long purchaseId, ScanType scanType){
                return scanMapper.getScansforPurchase(purchaseId, scanType);
        }
        
        public List<InvAgeConsiderItems> getInventoryAgeConsideredItems(Long itemId){
                return scanMapper.getInventoryAgeConsideredItems(itemId);
        }
        
        public List<InventoryMovement> getCompleteMovementForThirdPartyWarehouse(
                        Date startDate, Date endDate) {
                return scanMapper.getCompleteMovementForThirdPartyWarehouse(startDate, endDate);
        }
        
        public List<TransferInvoiceScan> fetchMismatchScansPerTransferInvoiceNumber(long date){
                return scanMapper.fetchMismatchScansPerTransferInvoiceNumber(new Date(date));
        }
}