udi-wms-java/src/main/java/com/glxp/api/service/sync/UpBasicService.java

package com.glxp.api.service.sync;

import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.extension.service.IService;
import com.glxp.api.constant.ConstantStatus;
import com.glxp.api.entity.auth.*;
import com.glxp.api.entity.basic.BasicBusTypeChangeEntity;
import com.glxp.api.entity.basic.BasicBusTypePreEntity;
import com.glxp.api.entity.basic.BasicBussinessTypeEntity;
import com.glxp.api.entity.basic.EntrustReceEntity;
import com.glxp.api.entity.inout.*;
import com.glxp.api.entity.purchase.PurOrderDetailEntity;
import com.glxp.api.entity.purchase.PurOrderEntity;
import com.glxp.api.entity.system.*;
import com.glxp.api.entity.thrsys.ThrBusTypeOriginEntity;
import com.glxp.api.req.auth.*;
import com.glxp.api.req.inout.FilterOrderRequest;
import com.glxp.api.req.sync.SpsSyncDataRequest;
import com.glxp.api.res.sync.*;
import com.glxp.api.res.system.SyncDataSetResponse;
import com.glxp.api.service.auth.*;
import com.glxp.api.service.basic.EntrustReceService;
import com.glxp.api.service.basic.IBasicBusTypeChangeService;
import com.glxp.api.service.basic.IBasicBusTypePreService;
import com.glxp.api.service.basic.IBasicBussinessTypeService;
import com.glxp.api.service.inout.*;
import com.glxp.api.service.purchase.PurOrderDetailService;
import com.glxp.api.service.purchase.PurOrderService;
import com.glxp.api.service.system.*;
import com.glxp.api.service.thrsys.IThrBusTypeOriginService;
import com.glxp.api.util.DateUtil;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;

@Service
public class UpBasicService {


    @Resource
    SyncDataSetService syncDataSetService;


    //已完成扫码单据
    @Resource
    IoOrderService orderService;
    @Resource
    IoCodeService codesService;
    @Resource
    IoOrderDetailBizService orderDetailBizService;
    @Resource
    IoOrderDetailCodeService orderDetailCodeService;
    @Resource
    IoOrderDetailResultService orderDetailResultService;
    @Resource
    PurOrderService purOrderService;
    @Resource
    PurOrderDetailService purOrderDetailService;
    @Resource
    IoOrderInvoiceService orderInvoiceService;
    @Resource
    private SystemParamConfigService systemParamConfigService;
    @Resource
    private EntrustReceService entrustReceService;
    @Resource
    private SystemPDFModuleService systemPDFModuleService;
    @Resource
    private SystemPDFTemplateService systemPDFTemplateService;
    @Resource
    private SystemPDFTemplateRelevanceCodeService systemPDFTemplateRelevanceCodeService;
    @Resource
    private SystemPDFTemplateRelevanceBizService systemPDFTemplateRelevanceBizService;
    @Resource
    private SystemPDFTemplateRelevanceLabelService systemPDFTemplateRelevanceLabelService;
    @Resource
    private SystemPDFTemplateRelevanceStatemenService systemPDFTemplateRelevanceStatemenService;
    @Resource
    private IBasicBusTypePreService basicBusTypePreService;

    //上传最近更新扫码单据
    public SpsSyncOrderResponse upAllOrder(SpsSyncDataRequest spsSyncDataRequest) {
        SpsSyncOrderResponse syncOrderResponse = new SpsSyncOrderResponse();
        //查询数据同步设置
        SyncDataSetResponse syncDataSetEntity = syncDataSetService.selectSet();
        List<IoOrderEntity> orderEntities = new ArrayList<>();
        FilterOrderRequest orderFilterRequest = new FilterOrderRequest();
        BeanUtils.copyProperties(spsSyncDataRequest, orderFilterRequest);
        if (CollUtil.isNotEmpty(syncDataSetEntity.getBusTypes())) {
            for (SyncDataBustypeEntity syncDataBustypeEntity : syncDataSetEntity.getBusTypes()) {
                List<IoOrderEntity> temps = orderService.findByStatus(syncDataBustypeEntity.getAction(), syncDataBustypeEntity.getOrderStatus(), DateUtil.parseDate(spsSyncDataRequest.getLastUpdateTime()));
                if (CollUtil.isNotEmpty(temps)) {
                    orderEntities.addAll(temps);
                }
            }
        }
        syncOrderResponse.setOrderEntities(orderEntities);
        List<IoCodeEntity> codeEntities = new ArrayList<>();
        List<IoOrderDetailBizEntity> orderDetailBizEntities = new ArrayList<>();
        List<IoOrderDetailCodeEntity> orderDetailCodeEntities = new ArrayList<>();
        List<IoOrderDetailResultEntity> orderDetailResultEntities = new ArrayList<>();
        List<IoOrderInvoiceEntity> orderInvoiceEntities = new ArrayList<>();
        if (CollUtil.isNotEmpty(orderEntities)) {
            for (IoOrderEntity orderEntity : orderEntities) {

                List<IoCodeEntity> codes = codesService.findByOrderId(orderEntity.getBillNo());
                if (CollUtil.isNotEmpty(codes)) {
                    codeEntities.addAll(codes);
                }

                List<IoOrderDetailBizEntity> bizEntities = orderDetailBizService.findByOrderId(orderEntity.getBillNo());
                if (CollUtil.isNotEmpty(bizEntities)) {
                    orderDetailBizEntities.addAll(bizEntities);
                }


                List<IoOrderDetailCodeEntity> detailCodeEntities = orderDetailCodeService.findByOrderId(orderEntity.getBillNo());
                if (CollUtil.isNotEmpty(detailCodeEntities)) {
                    orderDetailCodeEntities.addAll(detailCodeEntities);
                }


                List<IoOrderDetailResultEntity> detailResultEntities = orderDetailResultService.findByOrderId(orderEntity.getBillNo());
                if (CollUtil.isNotEmpty(detailResultEntities)) {
                    orderDetailResultEntities.addAll(detailResultEntities);
                }

                List<IoOrderInvoiceEntity> invoiceEntities = orderInvoiceService.findByBillNo(orderEntity.getBillNo());
                if (CollUtil.isNotEmpty(invoiceEntities)) {
                    orderInvoiceEntities.addAll(invoiceEntities);
                }
            }
        }

        syncOrderResponse.setCodeEntities(codeEntities);
        syncOrderResponse.setOrderDetailBizEntities(orderDetailBizEntities);
        syncOrderResponse.setOrderDetailCodeEntities(orderDetailCodeEntities);
        syncOrderResponse.setOrderDetailResultEntities(orderDetailResultEntities);
        syncOrderResponse.setOrderInvoiceEntities(orderInvoiceEntities);
        return syncOrderResponse;
    }

    //上传最近更新业务单据
    public SpsSyncBusOrderResponse upAllBusOrder(SpsSyncDataRequest spsSyncDataRequest) {
        SpsSyncBusOrderResponse syncOrderResponse = new SpsSyncBusOrderResponse();
        //查询数据同步设置
        SyncDataSetResponse syncDataSetEntity = syncDataSetService.selectSet();
        List<PurOrderEntity> purOrderEntities = new ArrayList<>();
        FilterOrderRequest orderFilterRequest = new FilterOrderRequest();
        BeanUtils.copyProperties(spsSyncDataRequest, orderFilterRequest);
        if (CollUtil.isNotEmpty(syncDataSetEntity.getChangeBusTypes())) {
            for (SyncDataChangeBustypesEntity syncDataChangeBustypesEntity : syncDataSetEntity.getChangeBusTypes()) {
                if (syncDataChangeBustypesEntity.getAction().equals(ConstantStatus.BUS_ORDER_CGDD)) {
                    List<PurOrderEntity> temps = purOrderService.findByStatus(syncDataChangeBustypesEntity.getAction(), syncDataChangeBustypesEntity.getOrderStatus(), DateUtil.parseDate(spsSyncDataRequest.getLastUpdateTime()));
                    if (CollUtil.isNotEmpty(temps)) {
                        purOrderEntities.addAll(temps);
                    }
                }
            }
        }
        syncOrderResponse.setPurOrderEntities(purOrderEntities);
        List<PurOrderDetailEntity> purOrderDetailEntities = new ArrayList<>();
        if (CollUtil.isNotEmpty(purOrderEntities)) {
            for (PurOrderEntity orderEntity : purOrderEntities) {
                List<PurOrderDetailEntity> detailResultEntities = purOrderDetailService.findByOrderId(orderEntity.getId() + "");
                if (CollUtil.isNotEmpty(detailResultEntities)) {
                    purOrderDetailEntities.addAll(detailResultEntities);
                }
            }
        }
        syncOrderResponse.setPurOrderDetailEntities(purOrderDetailEntities);
        return syncOrderResponse;
    }


    @Resource
    IBasicBussinessTypeService basicBussinessTypeService;
    @Resource
    IBasicBusTypeChangeService basicBusTypeChangeService;
    @Resource
    IThrBusTypeOriginService thrBusTypeOriginService;

    //上传最近更新单据类型
    public SpsSyncBusResponse upAllBus(SpsSyncDataRequest spsSyncDataRequest) {
        SpsSyncBusResponse spsSyncBusResponse = new SpsSyncBusResponse();
        SyncDataSetResponse syncDataSetEntity = syncDataSetService.selectSet();

        //扫码单据类型
        if (syncDataSetEntity.getTypeScan() == 1) {
            List<BasicBussinessTypeEntity> bussinessTypeEntities = basicBussinessTypeService.findByLastTime(DateUtil.parseDate(spsSyncDataRequest.getLastUpdateTime()));
            spsSyncBusResponse.setBussinessTypeEntities(bussinessTypeEntities);
        }

        //   业务单据类型
        if (syncDataSetEntity.getTypeBus() == 1) {
            List<BasicBusTypeChangeEntity> basicBusTypeChangeEntities = basicBusTypeChangeService.findByLastTime(DateUtil.parseDate(spsSyncDataRequest.getLastUpdateTime()));
            spsSyncBusResponse.setBusTypeChangeEntities(basicBusTypeChangeEntities);
        }

        //第三方单据类型
        if (syncDataSetEntity.getTypeThird() == 1) {
            List<ThrBusTypeOriginEntity> thrBusTypeOriginEntities = thrBusTypeOriginService.findByLastTime(DateUtil.parseDate(spsSyncDataRequest.getLastUpdateTime()));
            spsSyncBusResponse.setThrBusTypeOriginEntities(thrBusTypeOriginEntities);
        }


        return spsSyncBusResponse;
    }

    @Resource
    InvWarehouseService invWarehouseService;
    @Resource
    WarehouseBussinessTypeService warehouseBussinessTypeService;
    @Resource
    WarehouseUserService warehouseUserService;
    @Resource
    InvBusUserService invBusUserService;
    @Resource
    AuthAdminService authAdminService;
    @Resource
    DeptService deptService;
    @Resource
    DeptUserService deptUserService;

    public SpsSyncDataResponse uploadAllUserData(SpsSyncDataRequest spsSyncDataRequest) {
        SpsSyncDataResponse syncDataResponse = new SpsSyncDataResponse();
        SyncDataSetResponse syncDataSetEntity = syncDataSetService.selectSet();
        if (syncDataSetEntity.getBasicDept() == 1) {
            //获取部门信息
            FilterInvWarehouseRequest filterDeptRequest = new FilterInvWarehouseRequest();
            BeanUtils.copyProperties(spsSyncDataRequest, filterDeptRequest);
            List<DeptEntity> deptEntityList = deptService.filterGroupInvWarehouse(filterDeptRequest);
            syncDataResponse.setDeptEntityList(deptEntityList);

            List<DeptUserEntity> allDeptUserEntities = new ArrayList<>();
            if (CollUtil.isNotEmpty(deptEntityList)) {
                for (DeptEntity deptEntity : deptEntityList) {
                    FilterDeptUserReqeust filterDeptUserReqeust = new FilterDeptUserReqeust();
                    filterDeptUserReqeust.setDeptId(deptEntity.getId().longValue());
                    List<DeptUserEntity> deptUserEntities = deptUserService.selectDeptUser(filterDeptUserReqeust);
                    allDeptUserEntities.addAll(deptUserEntities);
                }
                syncDataResponse.setDeptUserEntities(allDeptUserEntities);
            }
        }


        //仓库字典
        if (syncDataSetEntity.getBasicInv() == 1) {

            //仓库字典
            List<InvWarehouseEntity> invWarehouseEntities = invWarehouseService.findByLastTime(DateUtil.parseDate(spsSyncDataRequest.getLastUpdateTime()));
            syncDataResponse.setInvWarehouseEntities(invWarehouseEntities);
            if (CollUtil.isNotEmpty(invWarehouseEntities)) {

                List<WarehouseBussinessTypeEntity> mWarehouseBussinessTypeEntities = new ArrayList<>();
                List<WarehouseUserEntity> mWarehouseUserEntities = new ArrayList<>();
                List<InvBusUserEntity> mInvBusUserEntities = new ArrayList<>();
                for (InvWarehouseEntity invWarehouseEntity : invWarehouseEntities) {
                    //获取仓库关联单据类型
                    FilterInvBusTypeRequest filterInvBusTypeRequest = new FilterInvBusTypeRequest();
                    filterInvBusTypeRequest.setCode(invWarehouseEntity.getCode());
                    List<WarehouseBussinessTypeEntity> warehouseBussinessTypeEntities = warehouseBussinessTypeService.filterList(filterInvBusTypeRequest);
                    mWarehouseBussinessTypeEntities.addAll(warehouseBussinessTypeEntities);

                    //获取仓库关联用户
                    FilterInvUserRequest filterInvUserRequest = new FilterInvUserRequest();
                    filterInvUserRequest.setCode(invWarehouseEntity.getCode());
                    List<WarehouseUserEntity> warehouseUserEntities = warehouseUserService.filterWarehouseUsers(filterInvUserRequest);
                    mWarehouseUserEntities.addAll(warehouseUserEntities);

                    if (CollUtil.isNotEmpty(warehouseUserEntities)) {
                        for (WarehouseUserEntity warehouseUserEntity : warehouseUserEntities) {
                            List<InvBusUserEntity> invBusUserEntities = invBusUserService.selectByUnion(warehouseUserEntity.getUserid() + "", invWarehouseEntity.getCode());
                            mInvBusUserEntities.addAll(invBusUserEntities);
                        }
                    }
                }
                syncDataResponse.setInvBusUserEntities(mInvBusUserEntities);
                syncDataResponse.setWarehouseUserEntities(mWarehouseUserEntities);
                syncDataResponse.setWarehouseBussinessTypeEntities(mWarehouseBussinessTypeEntities);
            }
        }

        //系统用户信息
        if (syncDataSetEntity.getSysUser() == 1) {
            FilterAuthUserRequest authAdminQueryRequest = new FilterAuthUserRequest();
            BeanUtils.copyProperties(spsSyncDataRequest, authAdminQueryRequest);
            List<AuthAdmin> authAdminList = authAdminService.listAdminPage(authAdminQueryRequest);
            syncDataResponse.setAuthAdminList(authAdminList);
        }


        return syncDataResponse;
    }

    /**
     * 上传最近更新的系统设置数据
     *
     * @param spsSyncDataRequest
     * @return
     */
    public SpsSyncSysSettingResponse upSysSetting(SpsSyncDataRequest spsSyncDataRequest) {
        SpsSyncSysSettingResponse spsSyncSysSettingResponse = new SpsSyncSysSettingResponse();
        //查询数据同步设置
        SyncDataSetResponse syncDataSet = syncDataSetService.selectSet();

        //系统运行参数
        if (syncDataSet.getSystemConfig() == 1) {
            List<SystemParamConfigEntity> systemParamConfigEntities = systemParamConfigService.findByLastTime(DateUtil.parseDate(spsSyncDataRequest.getLastUpdateTime()));
            spsSyncSysSettingResponse.setSystemParamConfigEntities(systemParamConfigEntities);
        }

        //委托验收设置
        if (syncDataSet.getEntrustAction() == 1) {
            List<EntrustReceEntity> entrustReceEntities = entrustReceService.findByLastTime(DateUtil.parseDate(spsSyncDataRequest.getLastUpdateTime()));
            spsSyncSysSettingResponse.setEntrustReceEntities(entrustReceEntities);
        }

        //打印设置
        if (syncDataSet.getPrintConfig() == 1) {
            List<SystemPDFModuleEntity> systemPDFModuleEntities = systemPDFModuleService.findByLastTime(DateUtil.parseDate(spsSyncDataRequest.getLastUpdateTime()));
            List<SystemPDFTemplateEntity> systemPDFTemplateEntities = systemPDFTemplateService.findByLastTime(DateUtil.parseDate(spsSyncDataRequest.getLastUpdateTime()));
            List<SysPdfTemplateRelevanceCodeEntity> sysPdfTemplateRelevanceCodeEntities = systemPDFTemplateRelevanceCodeService.findByLastTime(DateUtil.parseDate(spsSyncDataRequest.getLastUpdateTime()));
            List<SysPdfTemplateRelevanceBizEntity> sysPdfTemplateRelevanceBizEntities = systemPDFTemplateRelevanceBizService.findByLastTime(DateUtil.parseDate(spsSyncDataRequest.getLastUpdateTime()));
            List<SysPdfTemplateRelevanceLabelEntity> sysPdfTemplateRelevanceLabelEntities = systemPDFTemplateRelevanceLabelService.findByLastTime(DateUtil.parseDate(spsSyncDataRequest.getLastUpdateTime()));
            List<SysPdfTemplateRelevanceStatemenEntity> sysPdfTemplateRelevanceStatemenEntities = systemPDFTemplateRelevanceStatemenService.findByLastTime(DateUtil.parseDate(spsSyncDataRequest.getLastUpdateTime()));

            spsSyncSysSettingResponse.setSystemPDFModuleEntities(systemPDFModuleEntities);
            spsSyncSysSettingResponse.setSystemPDFTemplateEntities(systemPDFTemplateEntities);
            spsSyncSysSettingResponse.setSysPdfTemplateRelevanceCodeEntities(sysPdfTemplateRelevanceCodeEntities);
            spsSyncSysSettingResponse.setSysPdfTemplateRelevanceBizEntities(sysPdfTemplateRelevanceBizEntities);
            spsSyncSysSettingResponse.setSysPdfTemplateRelevanceLabelEntities(sysPdfTemplateRelevanceLabelEntities);
            spsSyncSysSettingResponse.setSysPdfTemplateRelevanceStatemenEntities(sysPdfTemplateRelevanceStatemenEntities);
        }

        //自动建出入库单
        if (syncDataSet.getScanChangeConfig() == 1) {
            List<BasicBusTypePreEntity> basicBusTypePreEntities = basicBusTypePreService.findByLastTime(DateUtil.parseDate(spsSyncDataRequest.getLastUpdateTime()));
            spsSyncSysSettingResponse.setBasicBusTypePreEntities(basicBusTypePreEntities);
        }

        //自动建业务单设置
        if (syncDataSet.getBusChangeConfig() == 1) {
            List<BasicBusTypeChangeEntity> basicBusTypeChangeEntities = basicBusTypeChangeService.findByLastTime(DateUtil.parseDate(spsSyncDataRequest.getLastUpdateTime()));
            spsSyncSysSettingResponse.setBasicBusTypeChangeEntities(basicBusTypeChangeEntities);
        }

        return spsSyncSysSettingResponse;
    }


}