baoshi-was/app/Services/OrderPackageCommoditiesService.php

<?php

namespace App\Services;

use App\Commodity;
use App\OracleActAllocationDetails;
use App\OracleBasSKU;
use App\OracleDOCOrderDetail;
use App\OracleDOCOrderHeader;
use App\Order;
use App\OrderPackage;
use App\OrderPackageCommodities;
use App\Owner;
use App\Services\common\BatchUpdateService;
use App\Services\common\DataHandlerService;
use Carbon\Carbon;

class OrderPackageCommoditiesService
{

    public function insert(array $params){
        return OrderPackageCommodities::query()->insert($params);
    }

    public function batchUpdate($params){
        return app(BatchUpdateService::class)->batchUpdate('order_package_commodities',$params);
    }

    public function basedOnOracleDetailsStore($orderNo, $orderPackage)
    {
        $details = OracleDOCOrderDetail::query()->where('orderNo', $orderNo)->get();
        $orderPackageCommodities = OrderPackageCommodities::query()->where('order_package_id',$orderPackage['id'])->get();
        $this->根据详情更新OrderPackage下的商品信息($orderPackage,$orderPackageCommodities,$details,'qtyordered');
        unset($details,$orderPackageCommodities);
    }

    public function basedOnActAllocationDetailsStoreByOrderNo($orderNo,$orderPackage){
        $details = OracleActAllocationDetails::query()->where('orderno', $orderNo)->get();
        $orderPackageCommodities =  OrderPackageCommodities::query()->where('order_package_id',$orderPackage['id'])->get();
        $this->根据详情更新OrderPackage下的商品信息($orderPackage,$orderPackageCommodities,$details,'qty');
        unset($details,$orderPackageCommodities);
    }

    public function 根据详情更新OrderPackage下的商品信息($orderPackage,$orderPackageCommodities,$details,$key){
        $newItems = [];
        foreach ($details as $detail) {
            $owner = Owner::query()->where(['code' => $detail['customerid']])->first();      // 货主
            $sku = $detail->sku;    // sku
            $owner_id = $owner->id; // 货主id
            $commodity = Commodity::query()->where(['sku' => $sku, 'owner_id' => $owner_id])->first(); // 商品
            if ($commodity == null) {
                $basSku = OracleBasSKU::query()->where(['sku' => $sku, 'customerid' => $detail->customerid])->first();   // 没有找到对应的商品信息
                $commodity = Commodity::query()->create(['sku' => $sku, 'owner_id' => $owner_id, 'name' => $basSku->descr_c]);
            }
            $data =  ['order_package_id' => $orderPackage['id'], 'commodity_id' => $commodity['id'], 'amount' => $detail[$key]];
            array_push($newItems,$data);
        }
        $diffarr = [];
        foreach ($newItems as $newItem) {
            $packageCommodity =  $orderPackageCommodities->where('order_package_id',$newItem['order_package_id'])->where('commodity_id',$newItem['commodity_id'])->first();
            if($packageCommodity!=null){
                if($packageCommodity['amount'] != $newItem['amount']){
                    $packageCommodity->update(['amount'=>intval($newItem['amount'])]);
                }
                $orderPackageCommodities =  $orderPackageCommodities->filter(function ($item) use ($packageCommodity){
                    if($item['id'] == $packageCommodity['id']){
                        return false;
                    }
                    return true;
                });
                array_push($diffarr,$newItem);
            }
        }
        if($orderPackageCommodities->count() > 0){
            foreach ($orderPackageCommodities as $orderPackageCommodity) {
                $id = $orderPackageCommodity['id'];
                OrderPackageCommodities::destroy($id);
            }
        }
        $newItems = array_filter($newItems,function($newItem) use ($diffarr){
            foreach ($diffarr as $item) {
                if($item['order_package_id'] == $newItem['order_package_id'] &&
                    $item['commodity_id'] == $newItem['commodity_id'] &&
                    $item['amount'] == $newItem['amount']){
                    return false;
                }
            }
            return true;
        });
        try {
            if(count($newItems) > 0 ){
                OrderPackageCommodities::query()->insert($newItems);
                LogService::log(__METHOD__,__FUNCTION__,'添加包裹商品信息'.json_encode($newItems));
            }
        } catch (\Exception $e) {
            LogService::log(__METHOD__,__FUNCTION__,'添加包裹商品信息异常'.json_encode($newItems).$e->getMessage(),$e->getTraceAsString());
        } finally {
            unset($newItems,$orderPackageCommodities);
        }
    }

    public function basedOnActAllocationDetailsStore($orderPackage)
    {
        $details = OracleActAllocationDetails::query()->where('picktotraceid', $orderPackage->logistic_number)->get();
        $orderPackageCommodities =  OrderPackageCommodities::query()->where('order_package_id',$orderPackage['id'])->get();
        $this->根据详情更新OrderPackage下的商品信息($orderPackage,$orderPackageCommodities,$details,'qty');
        unset($details,$orderPackageCommodities);
    }

    public function basedOnActAllocationDetail(Order $order, OracleDOCOrderHeader $header, array $details)
    {
        foreach ($details as $detail) {
            $logistic_number = $details['picktotraceid'];
            if ($logistic_number == '*' || $logistic_number == null || $logistic_number == '') {
                $logistic_number = $header['soreference5'];
                if ($logistic_number == '*' || $logistic_number == null || $logistic_number == '') {
                    continue;
                }
            }
            $orderPackage = OrderPackage::query()->firstOrCreate(['order_id'=>$order['id'],'logistic_number',$details]);
            $this->createByActAllocationDetail($detail, $orderPackage);
        }
    }

    private function createByActAllocationDetail($detail,$orderPackage)
    {
        $owner = Owner::query()->where(['code' => $detail->customerid])->first();      // 货主
        $sku = $detail->sku;
        $owner_id = $owner['id'];
        $commodity = Commodity::query()->where(['sku' => $sku, 'owner_id' => $owner_id])->first();
        if ($commodity == null) {
            $basSku = OracleBasSKU::query()->where(['sku' => $sku, 'customerid' => $detail->customerid])->first();
            $commodity = Commodity::query()->create(['sku' => $sku, 'owner_id' => $owner_id, 'name' => $basSku->descr_c]);
        }
        try {
            $count  = OrderPackageCommodities::query()->where(['order_package_id' => $orderPackage['id'], 'commodity_id' => $commodity['id'], 'amount' => $detail['qty']])->count();
            if($count == 0){
                $orderPackageCommodities = OrderPackageCommodities::query()->firstOrCreate(['order_package_id' => $orderPackage['id'], 'commodity_id' => $commodity['id'], 'amount' => $detail['qty']]);
                LogService::log(__METHOD__,__FUNCTION__,'创建订单包裹详情'.json_encode($orderPackageCommodities));
            }
        } catch (\Exception $e) {
            LogService::log(__METHOD__,__FUNCTION__,'创建订单包裹失败'.$e->getMessage().$e->getTraceAsString());
        } finally {
            return $orderPackageCommodities ?? null;
        }
    }

    public function getOrderPackageCommoditiesByOrderId($orderId)
    {
        $order = Order::query()->where('id', $orderId)->first();
        if (!$order) {
            return null;
        }
        $orderPackageIds = OrderPackage::query()->select('id')->where('order_id', $order['id'])->get();
        if (!$orderPackageIds) {
            return null;
        }
        return OrderPackageCommodities::query()->with('commodity')->whereIn('order_package_id', $orderPackageIds)->get();
    }

    public function createByOrderDetail(OracleDOCOrderDetail $detail, OrderPackage $orderPackage)
    {
        $owner = Owner::query()->where('code', $detail['customerid'])->first();      // 货主
        $sku = $detail->sku;    // sku
        $owner_id = $owner->id; // 货主id
        $commodity = Commodity::query()->where('sku', $sku)->where('owner_id', $owner_id)->first(); // 商品
        if ($commodity == null) {
            $basSku = OracleBasSKU::query()->where('sku', $sku)->where('customerid' , $detail->customerid)->first();   // 没有找到对应的商品信息
            $commodity = Commodity::query()->create(['sku' => $sku, 'owner_id' => $owner_id, 'name' => $basSku->descr_c]);
        }
        return OrderPackageCommodities::query()->create(['order_package_id' => $orderPackage['id'], 'commodity_id' => $commodity['id'], 'amount' => $detail['qtyordered']]);
    }

    public function 根据WMS订单信息创建WAS订单包裹商品($orderHeaders,$oracleDOCOrderDetails,$actAllocationDetails,$orders)
    {
        /** @var CommodityService $commodityService */
        $commodityService = app('commodityService');
        $commodities = $commodityService->getWASCommoditiesByWMSOrderHeaders($orderHeaders); // 商品

        $orderPackages = [];
        $orderList = [];
        foreach ($orders as $order) {
            $orderList[$order['id']] = $order;
            $packages = $order['packages'] ?? [];
            foreach ($packages as $package) {
                $orderPackages[$package['logistic_number']]  = $package;
            }
        }
        $fillables = [];
        foreach ($orderPackages as $key=>$orderPackage) {
            $logistic_number = $key;
            $order = $orderList[$orderPackage['order_id']];
            $details1 =  $actAllocationDetails[strval($logistic_number)] ?? [];
            $details2 = [];
            if(count($details1)== 0){
                $details2 = $actAllocationDetails[$order['code']] ?? [];
            }
            if(count($details1) > 0 ||  count($details2) > 0){
                $items = $this->根据订单分配详情返回创建数组($details1,$orderPackage,$commodities,$order);
                foreach ($items as $item){
                    $fillables[] = $item;
                }
                $items = $this->根据订单分配详情返回创建数组($details2,$orderPackage,$commodities,$order);
                foreach ($items as $item){
                    $fillables[] = $item;
                }
                continue;
             }
            $details =  $oracleDOCOrderDetails[$order['code']] ?? [];
            if($details->count() >0){
                $items = $this->根据订单详情返回创建数组($details,$orderPackage,$commodities,$order);
                foreach ($items as $item){
                    $fillables[] = $item;
                }
            }
        }
        try {
            if(count($fillables) > 0){
                OrderPackageCommodities::query()->insert($fillables);
                LogService::log(__METHOD__,__FUNCTION__,'批量创建 OrderPackageCommodities'.count($fillables).json_encode($fillables));
            }
        } catch (\Exception $e) {
            LogService::log(__METHOD__,__FUNCTION__,'批量创建异常 OrderPackageCommodities error '.json_encode($fillables).$e->getMessage().$e->getTraceAsString());
        } finally {
            $orderIds = data_get($orders,'*.id');
            return Order::query()->with('packages.commodities')->whereIn('id',$orderIds)->get();
        }
    }

    // XXX 逻辑优化 删除不存在未完成
    public function 更新WAS订单快递打包商品信息($orderHeaders,$orders,$commodities)
    {
        $newItems = $this->获取WMS订单打包信息($orderHeaders,$commodities,$orders);
        $orderPackagesCommodities = $this->basedOrdersReturnOrderPackageCommodities($orders);

        $multipleData = [['id','order_package_id','commodity_id']];
        $packageCommodity_list_amount = [];
        $packageCommodity_list = [];

        foreach ($orderPackagesCommodities as $item) {
            $key = 'order_package_id='.$item['order_package_id'].' commodity_id='.$item['commodity_id'].' amount='.$item['amount'];
            if(!($packageCommodity_list_amount[$key] ?? false)){
                $packageCommodity_list_amount[$key] = [];
            }
            $packageCommodity_list_amount[$key][] = $item;
            $key2 = 'order_package_id'.$item['order_package_id'].' commodity_id='.$item['commodity_id'];
            if($packageCommodity_list[$key2] ?? false){
                $packageCommodity_list[$key2] = [];
            }
            $packageCommodity_list[$key2][] = $item;
        }
        foreach ($newItems as $key=>$newItem) {
            $key1 = 'order_package_id='.$newItem['order_package_id'].' commodity_id='.$newItem['commodity_id'].' amount='.$newItem['amount'];
            $packageCommodity = $packageCommodity_list_amount[$key1][0] ?? false;
            if($packageCommodity ?? false){
                unset($newItems[$key]);
                array_shift($packageCommodity_list_amount[$key1]);
            }else{
                $key2 = 'order_package_id'.$newItem['order_package_id'].' commodity_id='.$newItem['commodity_id'];
                $packageCommodity = $packageCommodity_list[$key2][0] ?? false;
                if($packageCommodity ?? false) {
                    $amount = intval($newItem['amount']);
                    if($packageCommodity['amount'] !== $amount){
                        $data = [
                            'order_package_id' => $packageCommodity['order_package_id'],
                            'commodity_id' => $packageCommodity['commodity_id'],
                            'amount' => $amount,
                        ];
                        $multipleData[]  = $data;
                    }
                    array_shift($packageCommodity_list[$key2]);
                    unset($newItems[$key]);
                }
            }
        }
        try {
            if (count($newItems) > 0) {
                OrderPackageCommodities::query()->insert($newItems);
                LogService::log(__METHOD__, __FUNCTION__, '添加打包信息' . json_encode($newItems));
            }
        }catch (\Exception $e) {
            LogService::log(__METHOD__, __FUNCTION__, '添加打包信息失败' . json_encode($newItems).$e->getMessage().$e->getTraceAsString());
        }

        if(count($multipleData) > 1){
            try {
                /** @var BatchUpdateService $batchUpdateService */
                $batchUpdateService = app('batchUpdateService');
                $batchUpdateService->batchUpdate('order_package_commodities', $multipleData);
                LogService::log(__METHOD__,__FUNCTION__,'批量更新'.count($multipleData).json_encode($multipleData));
            } catch (\Exception $e) {
                LogService::log(__METHOD__,__FUNCTION__,'批量更新失败'.json_encode($multipleData).$e->getMessage(),$e->getTraceAsString());
            } finally {
                unset($multipleData);
            }
        }
    }

    private function 获取WMS订单打包信息($orderHeaders,$commodities,$orders){
        $newItems = [];

        $commodities_list = [];
        foreach ($commodities as $commodity) {
            $key = 'sku='.$commodity['sku'].' owner_id='.$commodity['owner_id'];
            $commodities_list[$key] = $commodity;
        }
        foreach ($orderHeaders as $orderHeader) {
            $order = $orders[$orderHeader['orderno']] ?? null;
            if(!isset($order)){
                continue;
            }
            $orderPackages = $order['packages'];
            $oracleDOCOrderDetails = $orderHeader['oracleDOCOrderDetails'] ?? [];
            $actAllocationDetails = $orderHeader['actAllocationDetails'] ?? [];

            if($actAllocationDetails->count() > 0){
                foreach ($orderPackages as $orderPackage) {
                    $details = [];
                    if($orderPackage['logistic_number'] == $orderHeader['soreference5'] ){
                        foreach ($actAllocationDetails as $detail) {
                            if($detail['picktotraceid'] == '*' || $detail['picktotraceid'] == $orderHeader['soreference5'])
                                $details[] = $detail;
                        }
                    }else{
                        $logistic_number = $orderPackage['logistic_number'];
                        foreach ($actAllocationDetails as $detail) {
                            if($detail['picktotraceid'] == $logistic_number)
                                $details[] = $detail;
                        }
                    }
                    $addArr = $this->basedDetailsReturnFillables($details,$orderPackage,$commodities_list,$order,'qty');
                    $newItems = array_merge($newItems,$addArr);
                }
            }elseif($oracleDOCOrderDetails->count() > 0){
                foreach ($orderPackages as $orderPackage) {
                    $details = [];
                    $logistic_number = $orderPackage['logistic_number'];
                    foreach ($actAllocationDetails as $detail) {
                        if($detail['dropid'] == $logistic_number){
                            array_push($details,$detail);
                        }
                    }
                    $addArr = $this->basedDetailsReturnFillables($details,$orderPackage,$commodities_list,$order,'qtyordered');
                    $newItems = array_merge($newItems,$addArr);
                }
            }
        }
        return $newItems;
    }

    public function 根据订单详情返回创建数组($details,$orderPackage,$commodities,$order){
        $orderPackagerCommodities = [];
        foreach ($details as $detail) {
            $commodity = $commodities->where('sku', $detail['sku'])->where('owner_id', $order['owner_id'])->first();
            $fillable = [
                'order_package_id' => $orderPackage['id'] ?? '',
                'commodity_id' => $commodity['id'] ?? '',
                'amount' => $detail['qtyordered'],
            ];
            $orderPackagerCommodities[] = $fillable;
        }
        return $orderPackagerCommodities;
    }

    public function 根据订单分配详情返回创建数组($details,$orderPackage,$commodities,$order){
        $orderPackagerCommodities = [];
        foreach ($details as $detail) {

            $commodity = $commodities->where('sku', $detail['sku'])->where('owner_id', $order['owner_id'])->first();
            $fillable = [
                'order_package_id' => $orderPackage['id'] ?? '',
                'commodity_id' => $commodity['id'] ?? '',
                'amount' => $detail['qty'] ?? '',
            ];
            array_push($orderPackagerCommodities,$fillable);
        }
        return $orderPackagerCommodities;
    }

    public function basedOrdersReturnOrderPackageCommodities($orders){
        $orderPackageCommodities = [];
        foreach ($orders as $order) {
            foreach ($order['packages'] as $package) {
                foreach ($package['commodities'] as $commodity) {
                    $orderPackageCommodities[] = $commodity;
                }
            }
        }
        return $orderPackageCommodities;
    }

    public function basedDetailsReturnFillables($details,$orderPackage,$commoditiesMap,$order,$column){
        $orderPackagerCommodities = [];
        foreach ($details as $detail) {
            $key = 'sku='.$detail['sku'].' owner_id='.$order['owner_id'];
            $commodity = $commoditiesMap[$key] ?? '';
            $fillable = [
                'order_package_id' => $orderPackage['id'] ?? '',
                'commodity_id' => $commodity['id'] ?? '',
                'amount' => $detail[$column] ?? '',
            ];
            array_push($orderPackagerCommodities,$fillable);
        }
        return $orderPackagerCommodities;
    }

    public function createByWmsOrder($orderHeaders)
    {
        if(!$orderHeaders){ return [];}
        /** @var DataHandlerService $dataHandlerService */
        $dataHandlerService = app(DataHandlerService::class);

        $order_packages = app(OrderPackageService::class)->getByWmsOrders($orderHeaders);
        $order_packages_logistic_number_map = $dataHandlerService->dataHeader(['logistic_number'],$order_packages);

        $commodities = app(CommodityService::class)->getByWmsOrders($orderHeaders);
        $commodity_owner_id_sku_map =  $dataHandlerService->dataHeader(['owner_id','sku'],$commodities);

        $owners = app(OwnerService::class)->getByWmsOrders($orderHeaders);
        $owner_code_map = $dataHandlerService->dataHeader(['code'],$owners);

        $order_packages_commodities = $this->getByWmsOrder($orderHeaders);
        $map = [];
        foreach ($order_packages_commodities as $item) {
            $key = ' commodity_id='.$item->commodity_id.' order_package_id'.$item->order_package_id.' amount='.$item->amount;
            $map[$key][] = $item;
        }
        $insert_params = [];
        foreach ($orderHeaders as $orderHeader) {
            $actAllocationDetails = $orderHeader->actAllocationDetails;
            $logistic_numbers = array_diff(array_unique(data_get($actAllocationDetails,'*.picktotraceid')),['*','',null]);
            if(count($logistic_numbers) > 0){
                $params = $this->getParamsByActAllocationDetails($actAllocationDetails,
                    $order_packages_logistic_number_map,
                    $owner_code_map,
                    $commodity_owner_id_sku_map,
                    $logistic_numbers);
                foreach ($params as $key =>$param) {
                    $mapkey = ' commodity_id='.($param['commodity_id'] ?? '').' order_package_id'.($param['order_package_id'] ?? '').' amount='.($param['amount'] ?? '');
                    if(($map[$mapkey] ?? false) && count($map[$mapkey]) >0){
                        array_shift($map[$mapkey]);
                        unset($params[$key]);
                    }
                }
                $insert_params = array_merge($insert_params,$params);
                unset($params);
            }
        }
        if(count($insert_params) > 0){
            $this->create($insert_params);
        }
        unset($orderHeaders,$order_packages,$owner_code_map,$commodities,$insert_params);
    }

    public function getParamsByActAllocationDetails($details,array $order_packages_logistic_number_map,array $owner_code_map,array $commodity_owner_id_sku_map,array $logistic_numbers){
        /** @var DataHandlerService  $dataHandlerService */
        $dataHandlerService =  app(DataHandlerService::class);
        if(!$details)return [];
        $params = [];
        $create_at = Carbon::now()->format('Y-m-d H:i:s');
        $updated_at = Carbon::now()->format('Y-m-d H:i:s');
        foreach ($details as $actAllocationDetail) {
            $pickToTraceID = $actAllocationDetail->picktotraceid;
            if(in_array($pickToTraceID,$logistic_numbers)){
                $orderPackage = $dataHandlerService->getKeyValue(['logistic_number'=>$pickToTraceID],$order_packages_logistic_number_map);
                if(!$orderPackage)continue;
                $owner = $dataHandlerService->getKeyValue(['code'=>$actAllocationDetail->customerid],$owner_code_map);
                if(!$owner)continue;
                $commodity = $dataHandlerService->getKeyValue(['owner_id'=>$owner->id,'sku'=>$actAllocationDetail->sku],$commodity_owner_id_sku_map);
                if(!$commodity)continue;
                $params[] = [
                    'commodity_id' =>$commodity->id,
                    'order_package_id' =>$orderPackage->id,
                    'amount' => $actAllocationDetail->qty,
                    'created_at' => $create_at
                ];
            }
        }
        unset($details,$order_packages_logistic_number_map,$owner_code_map,$commodity_owner_id_sku_map,$logistic_numbers);
        return $params;
    }


    public function create(array $params){
        if(!$params){return [];}
        try {
            $this->insert($params);
            LogService::log(__METHOD__,__FUNCTION__,'批量创建 OrderPackageCommodities'.count($params).json_encode($params));
        } catch (\Exception $e) {
            LogService::log(__METHOD__,__FUNCTION__,'批量创建 OrderPackageCommodities error'.json_encode($params)."||".$e->getMessage().'||'.$e->getTraceAsString());
        } finally {
            $order_package_ids = array_unique(data_get($params,'*.order_package_id'));
            unset($params);
            return OrderPackageCommodities::query()
                ->with('commodity')
                ->whereIn('order_package_id',$order_package_ids)
                ->get();
        }
    }

    public function updateByWmsOrder($orderHeaders){
        if(!$orderHeaders){return ;}
        /** @var DataHandlerService $dataHandlerService*/
        $dataHandlerService = app(DataHandlerService::class);
        $commodities = app(CommodityService::class)->getByWmsOrders($orderHeaders);
        $owners = app(OwnerService::class)->getByWmsOrders($orderHeaders);
        $owners_id_map = $dataHandlerService->dataHeader(['id'],$owners);
        $owner_code_map = $dataHandlerService->dataHeader(['code'],$owners);
        $commodity_owner_id_sku_map = $dataHandlerService->dataHeader(['owner_id','sku'],$commodities);

        $commodities_owner_code_code_map = [];
        foreach ($commodities as $commodity) {
            $owner = $dataHandlerService->getKeyValue(['id'=>$commodity->owner_id],$owners_id_map);
            $commodities_owner_code_code_map[' owner_code='.$owner->code.' code='.$commodity->code] = $commodity;
        }

        $order_nos = data_get($orderHeaders,'*.orderno');
        $order_package_commodities = OrderPackageCommodities::query()->with('package.order','commodity')
            ->whereHas('package.order',function($query) use ($order_nos){
                $query->whereIn('code',$order_nos);
            })->get();

        $order_packages = OrderPackage::query()->with('order')->whereHas('order',function($query) use ($order_nos){
            $query->whereIn('code',$order_nos);
        })->get();
        $order_package_logistic_numbers_map = $dataHandlerService->dataHeader(['logistic_number'],$order_packages);
        $order_no_map = [];
        foreach ($order_package_commodities as $order_package_commodity) {
            $order = $order_package_commodity->package->order;
            $order_no_map[$order->code][] = $order_package_commodity;
        }

        $insertParams = [];
        $updateParams = [['id','order_package_id'.'commodity_id','amount','updated_at']];
        $updated_at = Carbon::now()->toDateTimeString();
        $created_at = Carbon::now()->toDateTimeString();
        foreach ($orderHeaders as $orderHeader) {
            $order_package_commodities = $order_no_map[$orderHeader->orderno] ?? false;
            $actAllocationDetails = $orderHeader->actAllocationDetails;
            $logistic_numbers = array_unique(array_diff(data_get($actAllocationDetails,'*.picktotraceid'),['','*',null])) ;
            if(!$order_package_commodities){
                $params =  $this->getParamsByActAllocationDetails($actAllocationDetails,$order_package_logistic_numbers_map, $owner_code_map, $commodity_owner_id_sku_map, $logistic_numbers);
                foreach ($params as $param) {
                    $insertParams[] = $param;
                }
                continue;
            }
            if($actAllocationDetails->count() > count($order_package_commodities)){
                $deleteKey = [];
                foreach ($actAllocationDetails as $key1=>$actAllocationDetail) {
                    foreach ( $order_package_commodities as $key=>$item) {
                        $commodity = $item->commodity;
                        if($actAllocationDetail->sku == $commodity->sku && $item->amount ==  $actAllocationDetail->qty){
                            unset($order_package_commodities[$key]);
                            unset($actAllocationDetails[$key1]);
                            $deleteKey[] = $key1;
                            break;
                        }else if($item ->sku == $commodity->sku && $item->amount !=  $actAllocationDetail->qty){
                            $updateParams[] = [
                                'id' => $item->id,
                                'commodity_id' => $commodity->id,
                                'amount' => $actAllocationDetail->qty,
                                'updated_at' => $updated_at
                            ];
                            $deleteKey[] = $key1;
                            unset($actAllocationDetails[$key1]);
                        }
                    }
                }
                $actAllocationDetails  =$actAllocationDetails->filter(function ($value, $key) use($deleteKey) {
                    return !in_array($key, $deleteKey);
                });
                $params =  $this->getParamsByActAllocationDetails($actAllocationDetails,$order_package_logistic_numbers_map, $owner_code_map, $commodity_owner_id_sku_map, $logistic_numbers);
                foreach ($params as $param) {
                    $insertParams[] = $param;
                }
                continue;
            }
        }

        if(count($updateParams) > 0){
            $this->batchUpdate($updateParams);
        }

        if(count($insertParams) > 0){
            try {
                $this->insert($insertParams);
                LogService::log(__METHOD__,__FUNCTION__,'批量添加 OrderPackageCommodities '. count($insertParams) .json_encode($insertParams));
            } catch (\Exception $e) {
                LogService::log(__METHOD__,__FUNCTION__,'批量添加 OrderPackageCommodities error'.json_encode($insertParams)."||".$e->getMessage().'||'.$e->getTraceAsString());
            }
        }
    }

    public function getByWmsOrder($orderHeaders){
        $order_no =  data_get($orderHeaders,'*.orderno');
        return OrderPackageCommodities::query()
            ->with('package.order')
            ->whereHas('package.order',function($query) use ($order_no){
                $query->whereIn('code',$order_no);
            })->get();
    }


    public function batchUpdateItself($column, array $params)
    {
        return app(BatchUpdateService::class)->batchUpdateItself('order_package_commodities', $column, $params);
    }
}