baoshi-was/app/Services/CommodityService.php

<?php

namespace App\Services;

use App\Commodity;
use App\Http\Controllers\CommodityController;
use App\CommodityBarcode;
use App\OracleBasSKU;
use App\Owner;
use App\Services\common\BatchUpdateService;
use App\Services\common\DataHandlerService;
use App\ValueStore;
use App\Shop;
use Carbon\Carbon;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Support\Facades\Cache;
use function Symfony\Component\String\s;

Class CommodityService
{
    /** @var CacheService $cacheService */
    private $cacheService;

    function __construct()
    {
        $this->cacheService = app('CacheService');
    }

    public function firstOrCreate($param, $column = null): Commodity
    {
        if ($column) return Commodity::query()->firstOrCreate($param, $column);
        return Commodity::query()->firstOrCreate($param);
    }

    public function updateOrCreate($param, $column = null)
    {
        if ($column) return Commodity::query()->updateOrCreate($param, $column);
        return Commodity::query()->updateOrCreate($param);
    }

    public function first(array $params, $with = null)
    {
        $commodity = Commodity::query();
        if ($with) $commodity->with($with);
        foreach ($params as $column => $value) {
            if (!is_array($value)) $commodity->where($column, $value);
            else $commodity->whereIn($column, $value);
        }
        return $commodity->first();
    }

    public function get(array $params)
    {
        $query = Commodity::query()->with('barcodes');
        if ($params["owner_id"] ?? false) {
            $query->where("owner_id", $params["owner_id"]);
        }
        if ($params["sku"] ?? false) {
            if (!is_array($params["sku"])) $params["sku"] = [$params["sku"]];
            $query->whereIn('sku', $params["sku"]);
        }
        return $query->get();
    }

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


    public function getOwnerCommodities(array $params)
    {
        $query = Commodity::query();
        foreach ($params as $column => $value) {
            if (!is_array($value)) $query->where($column, $value);
            else $query->whereIn($column, $value);
        }
        return $query->get();
    }

    /* 批量更新 */
    public function batchUpdate(array $params)
    {
        return app(BatchUpdateService::class)->batchUpdate('commodities', $params);
    }

    /* 根据货主条形码查找商品 */
    private function ownerBarcodeSeekCommodityQuery(Builder $query, array $ownerParam, $barcode)
    {
        $query->whereHas('owner', function ($builder) use ($ownerParam) {
            foreach ($ownerParam as $column => $param) {
                $builder->where($column, $param);
            }
        });
        $query->whereHas('barcodes', function ($builder) use ($barcode) {
            if (is_array($barcode)) $builder->whereIn('code', $barcode);
            else $builder->where('code', $barcode);
        });
        return $query;
    }

    public function ownerBarcodeSeekCommodityFirst(array $ownerParam, $barcode, $with = null)
    {
        $commodity = Commodity::query();
        if ($with) $commodity->with($with);
        $commodity = $this->ownerBarcodeSeekCommodityQuery($commodity, $ownerParam, $barcode);
        return $commodity->first();
    }

    public function ownerBarcodeSeekCommodityGet(array $ownerParam, $barcode, $isNullSku = false)
    {
        $commodities = Commodity::query()->with('barcodes');
        if ($isNullSku) $commodities->whereNull('sku');
        $commodities = $this->ownerBarcodeSeekCommodityQuery($commodities, $ownerParam, $barcode);
        return $commodities->get();
    }

    /* 通过货主代码与条形码寻找FLUX商品补充至WMS 单条*/
    public function ownerAndBarcodeFirstOrCreate(Owner $owner, $barcode)
    {
        $wmsCommodity = app('OracleBasSkuService')->first(['customerid' => $owner->code, 'barcode' => $barcode]);
        if (!$wmsCommodity) return null;

        $commodity = $this->firstOrCreate(['owner_id' => $owner->id, 'sku' => $wmsCommodity->sku], [
            "name" => $wmsCommodity->descr_c,
            "sku" => $wmsCommodity->sku,
            "owner_id" => $owner->id,
            "length" => $wmsCommodity->skulength,
            "width" => $wmsCommodity->skuwidth,
            "height" => $wmsCommodity->skuhigh,
            "volumn" => $wmsCommodity->cube,
        ]);
        if ($wmsCommodity->alternate_sku1) app('CommodityBarcodeService')->first([
            'commodity_id' => $commodity->id,
            'code' => $wmsCommodity->alternate_sku1,
        ]);
        if ($wmsCommodity->alternate_sku2) app('CommodityBarcodeService')->first([
            'commodity_id' => $commodity->id,
            'code' => $wmsCommodity->alternate_sku2,
        ]);
        return $commodity;
    }

    public function create(array $params)
    {
        return Commodity::query()->create($params);
    }

    public function getByWmsOrders($orderHeaders)
    {
        if (!$orderHeaders) return null;
        $customerId_sku_map = [];
        foreach ($orderHeaders as $orderHeader) {
            $oracleDOCOrderDetails = $orderHeader->oracleDOCOrderDetails;
            foreach ($oracleDOCOrderDetails as $oracleDOCOrderDetail) {
                $value = [
                    'owner_code' => $oracleDOCOrderDetail->customerid,
                    'sku' => $oracleDOCOrderDetail->sku
                ];
                if (!in_array($value, $customerId_sku_map)) {
                    $customerId_sku_map[] = $value;
                }
            }
        }

        $owner_codes = array_diff(array_unique(data_get($customerId_sku_map, '*.owner_code')), ['', '*', null]);
        if (!$owner_codes) return null;

        $owners = Owner::query()->whereIn('code', $owner_codes)->get();

        $owners_code_map = [];
        $owners_id_map = [];
        foreach ($owners as $owner) {
            $owners_code_map[$owner->code] = $owner;
            $owners_id_map[$owner->id] = $owner;
        }
        $orderHeader_sku = array_diff(array_unique(data_get($customerId_sku_map, '*.sku')), ['', '*', null]);
        $commodities = Commodity::query()
            ->whereIn('owner_id', data_get($owners, '*.id'))
            ->whereIn('sku', $orderHeader_sku)
            ->groupBy('owner_id', 'sku')  //*!!!!!!!!
            ->get();

        if ($commodities->count() < count($customerId_sku_map)) {
            $commoditiesInWAS索引_sku = [];
            foreach ($commodities as $commodityInWms) {
                $owner = $owners_id_map[$commodityInWms->owner_id] ?? '';
                if (!$owner) continue;
                $key = 'owner_cod=' . $owner['code'] . ' sku=' . $commodityInWms->sku;
                $commoditiesInWAS索引_sku[$key] = $commodityInWms;
            }
            $commodities需要新增 = [];
            foreach ($customerId_sku_map as $commodityInWms) {
                $key = 'owner_cod=' . $commodityInWms['owner_code'] . ' sku=' . $commodityInWms['sku'];
                if ($commoditiesInWAS索引_sku[$key] ?? false) continue;
                $commodities需要新增[$key] = $commodityInWms;
            }
            $commodity_set = $this->createCommodities($commodities需要新增, $owners_code_map);
            $commodities = $commodities->concat($commodity_set);
        }
        return $commodities;
    }

    public function createCommodities($params, $owners_code_map)
    {
        if (!$params) return [];
        $bas_sku_arr = OracleBasSKU::query()
            ->selectRaw('customerid,sku,descr_c,skulength,skuwidth,skuhigh,cube')
            ->whereIn('CustomerID', data_get($params, '*.owner_code'))
            ->whereIn('Sku', data_get($params, '*.sku'))
            ->get();
        $insert_params = [];
        $created_at = Carbon::now()->format('Y-m-d H:i:s');
        foreach ($bas_sku_arr as $bas_sku) {
            $owner = $owners_code_map[$bas_sku->customerid] ?? '';
            if (!$owner) continue;
            if ($bas_sku->sku == null) continue;
            if ($bas_sku->descr_c == '') continue;
            $insert_params[] = [
                'owner_id' => $owner->id,
                'sku' => $bas_sku->sku,
                'name' => $bas_sku->descr_c,
                'created_at' => $created_at,
                'length' => $bas_sku->skulength,
                'width' => $bas_sku->skuwidth,
                'height' => $bas_sku->skuhigh,
                'volumn' => $bas_sku->cube
            ];
        }
        if (count($insert_params) > 0) {
            try {
                $this->insert($insert_params);
                app('LogService')->log(__METHOD__, __FUNCTION__, '批量添加 commodity ' . count($insert_params) . json_encode($insert_params));
            } catch (\Exception $e) {
                app('LogService')->log(__METHOD__, __FUNCTION__, '批量添加 commodity error' . json_encode($insert_params) . "||" . $e->getMessage() . '||' . $e->getTraceAsString());
            }
        }
        return Commodity::query()
            ->whereIn('owner_id', data_get($owners_code_map, '*.id'))
            ->whereIn('sku', data_get($params, '*.sku'))
            ->get();
    }

    public function createTemporaryCommodity(array $params)
    {
        $params["type"] = "临时";
        return Commodity::query()->create($params);
    }


    public function syncBarcodes($barcodesStr, $ownerId, $sku): Commodity
    {
        $barcodes = (function () use ($barcodesStr) {
            $barcodes = rtrim($barcodesStr, ',');
            $barcodes = explode(',', $barcodes);
            foreach ($barcodes as $k => $barcode) {
                if (!trim($barcode)) unset($barcodes[$k]);
            }
            return $barcodes;
        })();
        $commodity = $this->firstOrCreate(['owner_id' => $ownerId, 'sku' => $sku]);
        $commodityBarcodes = $commodity['barcodes'] ?? new Collection();


        /** @var CommodityBarcodeService $commodityBarcodeService */
        $commodityBarcodeService = app('CommodityBarcodeService');
        $redundantCommodityBarcodes = new Collection();
        foreach ($commodityBarcodes as $commodityBarcode) {//清除数组中 已经在商品有的条码，清除商品条码中，不在数组中的条码
            $hasMatch = false;
            foreach ($barcodes as $key => $barcode) {
                if ($barcodes[$key] == $commodityBarcode['code']) {
                    $hasMatch = true;
                    unset($barcodes[$key]);
                    break;
                }
            }
            if (!$hasMatch) {
                $redundantCommodityBarcodes->push($commodityBarcode);
            }
        }
        if (!empty($redundantCommodityBarcodes)) {
            $commodityBarcodeService->destroyCollections($redundantCommodityBarcodes);
        }
        if (!empty($barcodes)) {
            $commodityBarcodeService->insertMany_onCommodities([['commodity_id' => $commodity['id'], 'barcodes' => $barcodes]]);
        }
        return $commodity;
    }

    public function destroyWithOffspring(Commodity $commodity)
    {
        $barcodesIds = $commodity->barcodes->map(function ($barcode) {
            return $barcode['id'];
        });
        CommodityBarcode::destroy($barcodesIds);
        $commodity->delete();
    }

    public function syncWMSOrderCode($owner, $skus)
    {
        $basSku = OracleBasSKU::query()->whereIn('SKU', $skus)->where('CustomerID', $owner->code)->get();
        $inner_params = [];
        $created_at = new Carbon();
        $basSku->each(function ($bas_sku) use (&$inner_params, $owner, $created_at) {
            $inner_params = [
                'owner_id' => $owner->id,
                'sku' => $bas_sku->sku,
                'name' => $bas_sku->descr_c,
                'created_at' => $created_at,
                'length' => $bas_sku->skulength,
                'width' => $bas_sku->skuwidth,
                'height' => $bas_sku->skuhigh,
                'volumn' => $bas_sku->cube
            ];
        });
        if (count($inner_params) > 0) {
            try {
                $this->insert($inner_params);
                app('LogService')->log(__METHOD__, __FUNCTION__, json_encode($inner_params));
            } catch (\Exception $e) {
                app('LogService')->log(__METHOD__, 'Error ' . __FUNCTION__, json_encode($inner_params) . ' || ' . $e->getMessage());
            }
        }
    }

    //获取箱规
    public function getPack($owner_id, $sku)
    {
        $that = $this;
        return app("CacheService")->getOrExecute("pack_{$owner_id}_{$sku}", function () use ($owner_id, $sku, $that) {
            $commodity = $that->first([
                "owner_id" => $owner_id,
                "sku" => $sku
            ]);
            if (!$commodity || $commodity->pack_spec === null) {
                $owner = app("OwnerService")->find($owner_id);
                $action = new CommodityController();
                $action->syncOwnerCommodities($owner->id, $owner->code, $sku);
            }
            return $that->first([
                "owner_id" => $owner_id,
                "sku" => $sku
            ])->pack_spec;
        });
    }

    //是否存在
    public function isExist(array $params)
    {
        $query = Commodity::query();
        if ($params["barcode"] ?? false) {
            $query->whereHas("barcodes", function ($query) use ($params) {
                /** @var Builder $query */
                $query->where("code", $params["barcode"]);
            });
            unset($params["barcode"]);
        }
        foreach ($params as $column => $param) {
            $query->where($column, $param);
        }
        if ($query->count() > 0) return true;
        return false;
    }

    public function getCommoditiesByMap($map)
    {
        /**
         * @var OwnerService $ownerService
         * @var OracleBasSkuService $oracleBasSkuService
         */
        $ownerService = app('OwnerService');
        $oracleBasSkuService = app('OracleBasSkuService');

        $commodities_map = (function () use ($map) {
            $commodities_map = [];
            if (count($map) == 0) return $commodities_map;
            Commodity::query()->with("owner")->whereIn('sku', array_unique(data_get($map, '*.sku')))->whereHas('owner', function ($query) use ($map) {
                $query->whereIn('code', array_unique(data_get($map, '*.owner_code')));
            })->get()->each(function ($commodity) use (&$commodities_map) {
                $commodities_map[json_encode(['owner_code' => $commodity['owner']['code'], 'sku' => $commodity['sku']])] = $commodity;
            });
            return $commodities_map;
        })();

        $owner_codes = (function () use ($map) {
            $owner_codes = [];
            if (count($map) == 0) return $owner_codes;
            foreach ($map as $item) {
                $owner_codes[$item['owner_code']] = $item['owner_code'];
            }
            return $owner_codes;
        })();

        $owner_map = (function () use ($ownerService, $owner_codes) {
            $owners = $ownerService->getOwnerByCodes($owner_codes);
            $map = [];
            $owners->each(function ($owner) use (&$map) {
                $map[$owner['code']] = $owner['id'];
            });
            return $map;
        })();

        $collect = collect();
        if (count($map) == 0) return $collect;
        $unexists = [];
        $sku = [];
        $owner_code = [];

        foreach ($map as $item) {
            $owner = Cache::get("owner_code_{$item['owner_code']}_sku_{$item['sku']}");
            if ($owner) {
                $collect->push($owner);
                continue;
            }
            $key = json_encode(['owner_code' => $item['owner_code'], 'sku' => $item['sku']]);
            if (!empty($commodities_map[json_encode($key)])) {
                $commodities_map[$key];
                continue;
            }
            $unexists[json_encode($key)] = true;
            $sku[] = $item['sku'];
            $owner_code[] = $item['owner_code'];
        }

        if (count($unexists) == 0) return $collect;
        $BasSKUs = $oracleBasSkuService->get(['SKU' => $sku, 'CustomerID' => $owner_code]);
        $BasSKUs = $BasSKUs->filter(function ($bas_sku) use ($unexists, $commodities_map) {
            $arr = [
                'owner_code' => $bas_sku['customerid'],
                'sku' => $bas_sku['sku']
            ];
            $key = json_encode($arr);
            if (!empty($commodities_map($key))) return false;
            return $unexists[json_encode($arr)] ?? false;
        });
        $inner_params = (function () use ($BasSKUs, $owner_map) {
            $map = [];
            $date = Carbon::now();
            $BasSKUs->each(function ($basSku) use (&$map, $owner_map, $date) {
                $map[] = [
                    'owner_id' => $owner_map[$basSku['customerid']] ?? '',
                    'sku' => $basSku->sku,
                    'name' => $basSku->descr_c,
                    'length' => $basSku->skulength,
                    'width' => $basSku->skuwidth,
                    'height' => $basSku->skuhigh,
                    'volumn' => $basSku->cube,
                    'created_at' => $date,
                    'updated_at' => $date,
                ];
            });
            return $map;
        })();
        if (count($inner_params) == 0) return $collect;
        foreach (array_chunk($inner_params, 4000) as $item) {
            try {
                $bool = Commodity::query()->insert($item);
                if ($bool) {
                    app('LogService')->log(__METHOD__, __FUNCTION__, "批量添加 Commodity Success " . count($inner_params) . ' || ' . json_encode($inner_params));
                    $commodities = Commodity::query()->with('owner')->whereIn('owner_id', data_get($item, '*.owner_id'))->whereIn('sku', data_get($item, '*.sku'))->get();
                    $this->pushToCache($commodities);
                    $collect = $collect->concat($commodities);
                } else app('LogService')->log(__METHOD__, __FUNCTION__, "批量添加 Commodity FAILED " . ' || ' . json_encode($inner_params));
            } catch (\Exception $e) {
                app('LogService')->log(__METHOD__, __FUNCTION__, "批量添加 Commodity ERROR " . ' || ' . json_encode($inner_params) . ' || ' . json_encode($e->getMessage()) . ' || ' . json_encode($e->getTraceAsString()));
            }
        }
        return $collect;
    }

    public function syncCommodityCreated()
    {
        $created_at = config('sync.commodity_sync.created_at');
        $create_set = config('sync.commodity_sync.cache_prefix.create_set');
        $create_keys = config('sync.commodity_sync.cache_prefix.create_keys');
        $create_key = config('sync.commodity_sync.cache_prefix.create');
        /** @var OracleBasSkuService $oracleBasSkuService */
        $oracleBasSkuService = app(OracleBasSkuService::class);
        $last_time = $this->getAsnLastSyncAt($created_at, 'create');
        $basSkus = $oracleBasSkuService->getWmsCreatedCommodities($last_time);
        $last_time = $basSkus->first()['addtime'];
        $last_records = $basSkus->where('addtime', $last_time);
        if (!$basSkus) return;
        $addBasSkus = $this->getLastRecordsByRedis($create_set, $create_key, $basSkus);
        if (count($addBasSkus) > 0) {
            $this->syncCreateCommodity($addBasSkus);
            $this->deleteCacheKey($create_set, $create_keys);
            $this->setLastRecordsByRedis($create_key, $create_set, $create_keys, $last_records);
            $this->setAsnLastSyncAt($created_at, $last_time);
        }
    }

    public function syncCommodityUpdated()
    {
        $updated_at = config('sync.commodity_sync.updated_at');
        $update_set = config('sync.commodity_sync.cache_prefix.update_set');
        $update_keys = config('sync.commodity_sync.cache_prefix.update_keys');
        $update_key = config('sync.commodity_sync.cache_prefix.update');
        /** @var OracleBasSkuService $oracleBasSkuService */
        $oracleBasSkuService = app(OracleBasSkuService::class);
        $last_time = $this->getAsnLastSyncAt($updated_at, 'update');
        $basSkus = $oracleBasSkuService->getWmsUpdatedCommodities($last_time);
        $last_time = $basSkus->first()['edittime'];
        $last_records = $basSkus->where('edittime', $last_time);
        if (!$basSkus) return;
        $addBasSkus = $this->getLastRecordsByRedis($update_set, $update_key, $basSkus);
        if (count($addBasSkus) > 0) {
            $this->syncUpdateCommodity($addBasSkus);
            $this->deleteCacheKey($update_set, $update_keys);
            $this->setLastRecordsByRedis($update_key, $update_set, $update_keys, $last_records);
            $this->setAsnLastSyncAt($updated_at, $last_time);
        }
    }

    public function syncCreateCommodity($addBasSkus)
    {
        if (count($addBasSkus) < 1) return null;
        $insert_params = $this->getParamsByBasSkus($addBasSkus);
        if (!$insert_params) return;
        $this->insertCommodities($insert_params);
        /** @var CommodityBarcodeService $commodityBarcodeService */
        $commodityBarcodeService = app(CommodityBarcodeService::class);
        $commodityBarcodeService->createBarcodeByWms($addBasSkus);
    }

    public function insertCommodities($insert_params)
    {
        foreach (array_chunk($insert_params, 1000) as $item) {
            try {
                $bool = Commodity::query()->insert($item);
                if ($bool) {
                    app('LogService')->log(__METHOD__, __FUNCTION__, "批量添加 Commodity Success " . count($insert_params) . ' || ' . json_encode($insert_params));
                    $commodities = Commodity::query()->with('owner')->whereIn('owner_id', data_get($item, '*.owner_id'))->whereIn('sku', data_get($item, '*.sku'))->get();
                    $this->pushToCache($commodities);
                } else app('LogService')->log(__METHOD__, __FUNCTION__, "批量添加 Commodity FAILED " . ' || ' . json_encode($insert_params));
            } catch (\Exception $e) {
                app('LogService')->log(__METHOD__, __FUNCTION__, "批量添加 Commodity ERROR " . ' || ' . json_encode($insert_params) . ' || ' . json_encode($e->getMessage()) . ' || ' . json_encode($e->getTraceAsString()));
            }
        }
    }

    public function getParamsByBasSkus($addBasSkus)
    {
        $owner_sku_map = [];
        $sku = [];
        $owner_code = [];
        $addBasSkus->each(function ($addBasSku) use (&$owner_sku_map, &$sku, &$owner_code) {
            if (!empty($addBasSku['customerid']) && !empty($addBasSku['sku'])) {
                $key = "owner_code_{$addBasSku['customerid']}_sku_{$addBasSku['sku']}";
                $owner_sku_map[$key] = ['owner_code' => $addBasSku['customerid'], 'sku' => $addBasSku['sku']];
                $sku[] = $addBasSku['sku'];
                $owner_code[] = $addBasSku['customerid'];
            }
        });
        /** @var OwnerService $ownerService */
        $ownerService = app(OwnerService::class);

        $owner_codes = (function () use ($owner_sku_map) {
            $owner_codes = [];
            if (count($owner_sku_map) == 0) return $owner_codes;
            foreach ($owner_sku_map as $item) {
                $owner_codes[$item['owner_code']] = $item['owner_code'];
            }
            return $owner_codes;
        })();
        $owner_id = (function () use ($ownerService, $owner_codes) {
            $owners = $ownerService->getOwnerByCodes($owner_codes);
            $map = [];
            $owners->each(function ($owner) use (&$map) {
                $map[] = $owner['id'];
            });
            return $map;
        })();
        $owner_map = (function () use ($ownerService, $owner_codes) {
            $owners = $ownerService->getOwnerByCodes($owner_codes);
            $map = [];
            $owners->each(function ($owner) use (&$map) {
                $map[$owner['code']] = $owner['id'];
            });
            return $map;
        })();
        if (count($owner_sku_map) == 0) return null;
        $commodities = Commodity::query()
            ->whereIn('owner_id', array_unique($owner_id))
            ->whereIn('sku', array_unique($sku))
            ->groupBy('owner_id', 'sku')
            ->get();
        $unexists = [];
        foreach ($owner_sku_map as $item) {
            $commodity = Cache::get("owner_code_{$item['owner_code']}_sku_{$item['sku']}");
            if ($commodity) continue;
            $commodity = $commodities->where('sku', $item['sku'])->where('owner_id', $owner_map[$item['owner_code']])->first();
            if ($commodity) continue;
            $items = [
                'owner_code' => $item['owner_code'],
                'sku' => $item['sku']
            ];
            $unexists[json_encode($items)] = true;
        }
        if (count($unexists) == 0) return null;
        $BasSKUs = $addBasSkus->filter(function ($bas_sku) use ($unexists) {
            $arr = [
                'owner_code' => $bas_sku['customerid'],
                'sku' => $bas_sku['sku']
            ];
            return $unexists[json_encode($arr)] ?? false;
        });
        $inner_params = (function () use ($BasSKUs, $owner_map) {
            $map = [];
            $BasSKUs->each(function ($basSku) use (&$map, $owner_map) {
                $map[] = [
                    'owner_id' => $owner_map[$basSku['customerid']] ?? '',
                    'sku' => $basSku->sku,
                    'name' => $basSku->descr_c,
                    'length' => $basSku->skulength,
                    'width' => $basSku->skuwidth,
                    'height' => $basSku->skuhigh,
                    'volumn' => $basSku->cube,
                    'created_at' => $basSku->addtime,
                    'updated_at' => $basSku->edittime,
                    'pack_spec' => $basSku->packid == 'STANDARD' ? 0 : explode("/", $basSku->packid)[1],
                ];
            });
            return $map;
        })();
        if (count($inner_params) == 0) return null;
        return $inner_params;
    }

    public function syncUpdateCommodity($addBasSkus)
    {
        $owner_sku_map = [];
        $sku = [];
        $addBasSkus->each(function ($addBasSku) use (&$owner_sku_map, &$sku) {
            if (!empty($addBasSku['customerid']) && !empty($addBasSku['sku'])) {
                $key = "owner_code_{$addBasSku['customerid']}_sku_{$addBasSku['sku']}";
                $owner_sku_map[$key] = ['owner_code' => $addBasSku['customerid'], 'sku' => $addBasSku['sku']];
                $sku[] = $addBasSku['sku'];
            }
        });
        /**
         * @var OwnerService $ownerService
         * @var DataHandlerService $dataHandlerService
         */
        $ownerService = app(OwnerService::class);
        $owner_codes = (function () use ($owner_sku_map) {
            $owner_codes = [];
            if (count($owner_sku_map) == 0) return $owner_codes;
            foreach ($owner_sku_map as $item) {
                $owner_codes[$item['owner_code']] = $item['owner_code'];
            }
            return $owner_codes;
        })();
        $owner_map = (function () use ($ownerService, $owner_codes) {
            $owners = $ownerService->getOwnerByCodes($owner_codes);
            $map = [];
            $owners->each(function ($owner) use (&$map) {
                $map[$owner['code']] = $owner['id'];
            });
            return $map;
        })();
        $owner_id = (function () use ($ownerService, $owner_codes) {
            $owners = $ownerService->getOwnerByCodes($owner_codes);
            $map = [];
            $owners->each(function ($owner) use (&$map) {
                $map[] = $owner['id'];
            });
            return $map;
        })();
        $commodities = Commodity::query()
            ->whereIn('owner_id', array_unique($owner_id))
            ->whereIn('sku', array_unique($sku))
            ->groupBy('owner_id', 'sku')
            ->get();
        $dataHandlerService = app(DataHandlerService::class);
        $commodities_map = $dataHandlerService->dataHeader(['owner_id', 'sku'], $commodities);
        $updateParams = [[
            'id', 'name', 'sku', 'owner_id', 'length', 'width', 'height', 'volumn', 'pack_spec', 'updated_at', 'created_at'
        ]];
        $insert_params = [];
        foreach ($addBasSkus as $basSku) {
            $commodity = Cache::get("owner_code_{$basSku['customerid']}_sku_{$basSku['sku']}");
            if (!$commodity) {
                $commodity = $dataHandlerService->getKeyValue(['owner_id' => $owner_map[$basSku['customerid']], 'sku' => $basSku['sku']], $commodities_map);
                if (!$commodity) {
                    $insert_params[] = [
                        'owner_id' => $owner_map[$basSku['customerid']] ?? '',
                        'sku' => $basSku->sku,
                        'name' => $basSku->descr_c,
                        'length' => $basSku->skulength,
                        'width' => $basSku->skuwidth,
                        'height' => $basSku->skuhigh,
                        'volumn' => $basSku->cube,
                        'created_at' => $basSku->addtime,
                        'updated_at' => $basSku->edittime,
                        'pack_spec' => $basSku->packid == 'STANDARD' ? 0 : explode("/", $basSku->packid)[1],
                    ];
                    continue;
                };
            }
            if ($commodity->sku != $basSku->sku ||
                $commodity->name != $basSku->descr_c ||
                $commodity->length != $basSku->skulength ||
                $commodity->width != $basSku->skuwidth ||
                $commodity->height != $basSku->skuhigh ||
                $commodity->volumn != $basSku->cube ||
                $commodity->created_at != $basSku->addtime ||
                $commodity->updated_at != $basSku->edittime ||
                $commodity->pack_spec != $basSku->pickid) {
                $updateParams[] = [
                    'id' => $commodity->id,
                    'owner_id' => $owner_map[$basSku['customerid']] ?? '',
                    'sku' => $basSku->sku,
                    'name' => $basSku->descr_c,
                    'length' => $basSku->skulength,
                    'width' => $basSku->skuwidth,
                    'height' => $basSku->skuhigh,
                    'volumn' => $basSku->cube,
                    'created_at' => $basSku->addtime,
                    'updated_at' => $basSku->edittime,
                    'pack_spec' => $basSku->packid == 'STANDARD' ? 0 : explode("/", $basSku->packid)[1],
                ];
            }
        }
        if (count($insert_params) > 0) $this->insertCommodities($insert_params);
        if (count($updateParams) > 0) $this->batchUpdate($updateParams);
        $commodities = Commodity::query()->with('owner')->whereIn('owner_id', data_get($updateParams, '*.owner_id'))->whereIn('sku', data_get($updateParams, '*.sku'))->get();
        $this->pushToCache($commodities);
        /** @var CommodityBarcodeService $commodityBarcodeService */
        $commodityBarcodeService = app(CommodityBarcodeService::class);
        $commodityBarcodeService->updateBarcodeByWms($addBasSkus);
    }

    private function pushToCache($commodities)
    {
        if (count($commodities) < 1) return null;
        foreach ($commodities as $commodity) {
            $commodity_key = "owner_code_{$commodity['owner']['code']}_sku_{$commodity['sku']}";
            Cache::remember($commodity_key, config('cache.expirations.forever'), function () use ($commodity) {
                return $commodity;
            });
        }
    }

    public function getAsnLastSyncAt($key, $type)
    {
        $last_time = ValueStore::query()->where('name', $key)->value('value');
        if ($last_time) return $last_time;
        if ($type == 'create') {
            $store = Commodity::query()->orderByDesc('created_at')->first();
            if ($store) return $store->created_at;
        } else {
            $store = Commodity::query()->orderByDesc('updated_at')->first();
            if ($store) return $store->updated_at;
        }
        return Carbon::now()->subSeconds(65);
    }

    public function setAsnLastSyncAt($key, $last_time)
    {
        $asnLastSyncAt = ValueStore::query()->updateOrCreate([
            'name' => $key,
        ], [
            'name' => $key,
            'value' => $last_time,
        ]);
        LogService::log(__METHOD__, __FUNCTION__, '修改或更新' . $key . json_encode($asnLastSyncAt));
        return $asnLastSyncAt;
    }

    public function getLastRecordsByRedis($set, $prefixKey, $basSkus)
    {
        if (Cache::get($set)) {
            $addBasSkus = collect();
            foreach ($basSkus as $basSku) {
                if (Cache::get($prefixKey . $basSku->customerid . '_' . $basSku->sku)) continue;
                $addBasSkus->add($basSku);
            }
            return $addBasSkus;
        }
        return $basSkus;
    }

    public function deleteCacheKey($set, $keys)
    {
        if (Cache::get($set)) {
            $cacheKeys = Cache::get($keys);
            if (!$cacheKeys) return;
            foreach ($cacheKeys as $cacheKey) {
                Cache::forget($cacheKey);
            }
            Cache::forget($keys);
        }
    }

    public function setLastRecordsByRedis($prefixKey, $set, $keys, $last_records)
    {
        $cacheKeys = [];
        foreach ($last_records as $last_record) {
            Cache::put($prefixKey . $last_record->customerid . '_' . $last_record->sku, true);
            array_push($cacheKeys, $prefixKey . $last_record->customerid . '_' . $last_record->sku);
        }
        Cache::put($keys, $cacheKeys);
        Cache::put($set, true);
    }

    function update(){
        //Cache
        //Commodity
    }
    function updateMany(){
        //Cache
        //Commodity
    }

    function get_($ownerIds = null, $skus = null, $barcodes = null,$paginate = 100, $page = 1,$isSyncWms = false)
    {
        if ($paginate < 100 || fmod($paginate, 100) != 0) return null; //$paginate小于100，或取余数100不为0，异常 //取余函数fmod()
        $status = null;
        if ($ownerIds && !$skus && !$barcodes) $status = '只有货主条件';
        if ($skus) $status = '有SKU';
        if ($barcodes && !$skus) $status = '有条码没SKU';
        if (!$status)return null;
        for (; $page <= $paginate / 100; $page++) {
            switch ($status) {
                case $status = '只有货主条件':
                    sort($ownerIds);
                    $md5 = md5(json_encode([$ownerIds, $paginate, $page]));
//                    Cache::get('commodity_ownerId_'.$ownerId);
                    Cache::put('commodity_ownerIds_');
                    return Cache::remember('commodity_' . $md5,config('cache.expirations.forever'),function ()use($ownerIds,$paginate,$page){
                        return Commodity::query()->with('barcodes')->whereIn('owner_id',$ownerIds)->paginate($paginate,'[*]','page',$page);
                    });
                case $status = '有SKU':
                    sort($skus);
                    $md5 = md5(json_encode([$skus]));
//                return Cache::remember('commodity_' . $md5, 'time', function () {
//                    在取出的记录用 $ownerIds和$barcodes筛选
//                })
                case $status = '有条码没SKU':
                    $md5 = md5(json_encode([$barcodes]));
//                return Cache::remember('commodity_' . $md5, 'time', function () {
//                    在取出的记录用 $ownerIds
//                })
            }
        }
    }
}