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;
use Illuminate\Support\Collection;

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_each');
        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_each');
        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_each']])->count();
            if($count == 0){
                $orderPackageCommodities = OrderPackageCommodities::query()->firstOrCreate(['order_package_id' => $orderPackage['id'], 'commodity_id' => $commodity['id'], 'amount' => $detail['qty_each']]);
                LogService::log(__METHOD__,__FUNCTION__,'创建订单包裹详情'.json_encode($orderPackageCommodities));
            }
        } catch (\Exception $e) {
            LogService::log(__METHOD__,__FUNCTION__,'创建订单包裹失败'.$e->getMessage().$e->getTraceAsString());
        } finally {
            return $orderPackageCommodities ?? null;
        }
    }

    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_each,
                    '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_each){
                            unset($order_package_commodities[$key]);
                            unset($actAllocationDetails[$key1]);
                            $deleteKey[] = $key1;
                            break;
                        }else if($item ->sku == $commodity->sku && $item->amount !=  $actAllocationDetail->qty_each){
                            $updateParams[] = [
                                'id' => $item->id,
                                'commodity_id' => $commodity->id,
                                'amount' => $actAllocationDetail->qty_each,
                                '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);
    }

    /**
     * @param array $logistic_numbers
     * @return array|mixed
     */
    public function 删除包裹商品信息_根据快递单号($logistic_numbers)
    {
        $orderPackageCommodities = OrderPackageCommodities::query()->with('package')->whereHas('package',function($query)use($logistic_numbers){
            $query->whereIn('logistic_number',$logistic_numbers);
        })->get();
        $ids = data_get($orderPackageCommodities, '*.id');
        if(count($ids) == 0){return [];}
        try {
            OrderPackageCommodities::query()->whereIn('id', $ids)->delete();
            LogService::log(__METHOD__,__FUNCTION__,'删除多余OrderPackageCommodities '.$orderPackageCommodities->count().json_encode($orderPackageCommodities),null);
        } catch (\Exception $e) {
            LogService::log(__METHOD__,__FUNCTION__,'删除多余OrderPackageCommodities error'.$orderPackageCommodities->count().json_encode($orderPackageCommodities).$e->getMessage().$e->getTraceAsString(),null);
            return [];
        }
        return $ids;
    }

    /**
     * @param array $orderNos
     * @return \Illuminate\Database\Eloquent\Builder[]|\Illuminate\Database\Eloquent\Collection
     */
    public function getByOrderNos($orderNos)
    {
        return OrderPackageCommodities::query()->with('package.order','commodity')
            ->whereHas('package.order',function($query) use ($orderNos){
                $query->whereIn('code',$orderNos);
            })->get();
    }

    /**
     * @param Collection $orders
     * @return \Illuminate\Database\Eloquent\Builder[]|\Illuminate\Database\Eloquent\Collection
     */
    public function getByOrders($orders)
    {
        return $this->getByOrderNos(data_get($orders,'*.code'));
    }

    /**
     * @param OracleDOCOrderHeader $orderHeader
     * @param Order $order
     * @return array|Collection|\Tightenco\Collect\Support\Collection
     */
    public function 返回创建数组($orderHeader,$order)
    {
        /** @var DataHandlerService $dataHandlerService */
        $dataHandlerService = app(DataHandlerService::class);
        if($orderHeader->sostatus == 90){return [];}
        $actAllocationDetails = $orderHeader->actAllocationDetails->collect();
        $orderPackages = $dataHandlerService->dataHeader(['logistic_number'],$order->packages);
        $innerParams = collect();
        $actAllocationDetails->each(function($detail)use($orderPackages,$dataHandlerService,$innerParams){
            $orderPackage = $dataHandlerService->getKeyValue(['logistic_number'=>$detail->picktotraceid],$orderPackages);
            $sku =  $detail->sku;
            $amount =  $detail->qty_each;
            $order_package_id =  $orderPackage->id;
            $logistic_number =  $orderPackage->logistic_number;
            $params = [
                'ownerCode' > $detail->customerid,
                'orderNo' => $detail->orderno,
                'sku' => $sku,
                'amount' => $amount,
                'order_package_id' => $order_package_id,
                'logistic_number' => $logistic_number,
            ];
            $innerParam = $innerParams->where('order_package_id',$orderPackage->id)->where('sku',$sku)->first();
            if(!$innerParam){
                $innerParams->push($params);
            }else{
                $innerParam['amount'] += $amount;
            }
        });
        return $innerParams;
    }

    /**
     * @param array $innerParams
     * @param OracleDOCOrderHeader $orderHeaders
     * @return array
     */
    public function 生成OrderPackageCommodities_基于创建数组($innerParams,$orderHeaders)
    {
        /** @var DataHandlerService $dataHandlerService */
        $dataHandlerService = app(DataHandlerService::class);
        $commodities = app(CommodityService::class)->getByWmsOrder($orderHeaders);
        $owners = app(OwnerService::class)->getByWmsOrders($orderHeaders);
        $owner_id_map = $dataHandlerService->dataHeader(['id'],$owners);
        $commodities_owner_code_sku_map = [];
        foreach ($commodities as $commodity) {
            $owner_code = $dataHandlerService->getKeyValue(['id'=>$commodity->owner_id],$owner_id_map);
            $key = ' owner_code='.$owner_code.' sku='.$commodity->sku;
            $commodities_owner_code_sku_map[$key] = $commodity;
        }

        $dataTime = Carbon::now()->format('Y-m-d H:i:s');
        $createParams = [];
        foreach ($innerParams as $innerParam) {
            $key = ' owner_code='.$innerParam['ownerCode'].' sku='.$innerParam['sku'];
            $commodity =  $commodities_owner_code_sku_map[$key]  ?? null;
            $createParams[] = [
                'order_package_id' => $innerParam['order_package_id'],
                'commodity_id' => $commodity->id ?? null,
                'amount' => $innerParam['amount'],
                'created_at' => $dataTime,
                'updated_at' => $dataTime,
            ];
        }
        return $createParams;
    }

    /**
     * @param OrderPackageCommodities $orderPackageCommodities
     * @return Collection|\Tightenco\Collect\Support\Collection
     */
    public function 将orderPackageCommodity抽象成数组($orderPackageCommodities)
    {
        /** @var DataHandlerService $dataHandlerService */
        $dataHandlerService = app(DataHandlerService::class);
        $collect = collect();
        $ownerIds = array_unique(data_get($orderPackageCommodities,'*.commodity.owner_id'));
        $owners = Owner::query()->whereIn('id',$ownerIds)->get();
        $owner_id_map = $dataHandlerService->dataHeader(['id'],$owners);
        foreach ($orderPackageCommodities as $orderPackageCommodity) {
            $owner = $dataHandlerService->getKeyValue(['id'=>$orderPackageCommodity->commodity->owner_id],$owner_id_map);
            $params = [
                'id' => $orderPackageCommodity->id,
                'ownerCode' => $owner->code,
                'orderNo' => $orderPackageCommodity->package->order->code,
                'sku' => $orderPackageCommodity->commodity->sku,
                'amount' => $orderPackageCommodity->amount,
                'order_package_id' => $orderPackageCommodity->package->id,
                'logistic_number' => $orderPackageCommodity->package->logistic_number,
            ];
            $collect->push($params);
        }
        return $collect;
    }

    public function 数据重组(&$orderPackageCommoditiesCollect,&$params)
    {
        $collect_map = [];$params_map = [];$order_no_map = [];

        foreach ($orderPackageCommoditiesCollect as $item) {
            $orderNo = $item['orderNo'];
            if(!isset($collect_map[$orderNo])){$collect_map[$orderNo] = collect();}
            $collect_map[$orderNo]->push($item);
        }

        foreach ($params as $param) {
            $orderNo =  $param['orderNo'];
            if(isset($params_map[$orderNo])){$params_map[$orderNo] = collect();}
            $order_no_map[] = $orderNo;
            $params_map[$orderNo]->push($param);
        }
        $order_no_map = array_unique($order_no_map);
        $orderPackageCommoditiesCollect = $collect_map;
        $params = $params_map;
        return $order_no_map;
    }

    /**
     * @param Collection $OPCCollects
     * @param array $paramsCollect
     */
    public function 删选出能保留的OrderPackageCommodities(&$OPCCollects,&$paramsCollect,$orderMap)
    {
        $retains = collect();
        foreach ($orderMap as $orderNo) {
            $OPCCollect = $OPCCollects[$orderNo];
            $params = $paramsCollect[$orderNo];
        }
    }


    public function 删选可以保留的OrderPackageCommodities(&$OPCCollect,&$params)
    {
        $retain = collect();
        $map = [];
        foreach ($params as $param) {
            $key = ' logistic_number='.$param['logistic_number'].' sku='.$param['sku'].' amount='.$param['amount'];
            if(!$map[$key] ?? false){
                $map[$key] = [];
            }
            $map[$key][] = $param;
        }

        foreach ($OPCCollect as $item) {
            $key = ' logistic_number='.$item['logistic_number'].' sku='.$item['sku'].' amount='.$item['amount'];
            if(isset($map[$key])){
                $value = $map[$key][0];
                array_shift($map);
                $params->filter(function($param)use($value){
                    return count(array_diff_assoc($param,$value)) != 0 ;
                });
                $retain->push($value);
            }
        }
        return $retain;
    }

//
//    public function 删选需要修改的OrderPackageCommodities(&$OPCCollect,&$params)
//    {
//        $update = collect();
//        $map = [];
//        foreach ($OPCCollect as $item) {
//            $key = ' logistic_number='.$item['logistic_number'].' sku='.$item['sku'];
//            if(!isset($map[$key])){
//                $map[$key] = [];
//            }
//            $map[$key][] = $item;
//        }
//
//        foreach ($params as $param) {
//            $key = ' logistic_number='.$param['logistic_number'].' sku='.$param['sku'];
//            if(isset($map[$key])){
//
//            }
//        }
//    }


}