baoshi-was/app/Http/Controllers/StorageController.php

<?php

namespace App\Http\Controllers;

use App\Commodity;
use App\CommodityMaterialBoxModel;
use App\Components\AsyncResponse;
use App\MaterialBox;
use App\MaterialBoxCommodity;
use App\MaterialBoxModel;
use App\Owner;
use App\Services\ForeignHaiRoboticsService;
use App\Services\LogService;
use App\Station;
use App\StationTask;
use App\StationTaskMaterialBox;
use App\Store;
use App\StoreItem;
use App\TaskTransaction;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Foundation\Auth\AuthenticatesUsers;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Cookie;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Gate;
use Illuminate\Support\Facades\Validator;

class StorageController extends Controller
{
    use AsyncResponse;
    use AuthenticatesUsers;

    public function putShelf()
    {
        $this->error("停用缓存架上架，联系管理员开启");
        $this->gate("入库管理-入库-缓存架入库");
        $asn = \request("asn");
        $ide = \request("ide");
        $barCode = \request("barCode");
        $amount = (int)\request("amount");
        //check info
        if (!$asn || !$ide || !$barCode || !$amount)$this->error("信息不完整");
        $box = MaterialBox::query()->with("station")->where("code",$ide)->first();
        if (!$box)$this->error("WAS无此料箱");
        if (!$box->station)$this->error("WAS无此库位信息");
        if (!app("StationService")->isCacheShelfLocation($box->station))$this->error("非缓存架库位");
        $fromLocation = $box->station->code; //源库位

        $item = StoreItem::query()->whereHas("store",function (Builder $query){
            $query->where("asn_code",request("asn"));
        })->whereHas("commodity",function (Builder $query)use($barCode){
            $query->whereHas("barcodes",function (Builder $query)use($barCode){
                $query->where("code",$barCode);
            });
        })->first();
        if (!$item)$this->error("WAS无此ASN单信息");
        //get flux
        $tasks = app("StorageService")->getFluxTask($asn,$barCode,$amount);
        if (!$tasks)$this->error("该单无上架任务或不存在");
        //此处嵌套三层事务 以最高层级为准
        DB::beginTransaction(); //总体事务 回滚WAS错误操作
        try{
            //库存记录
            if (!app("StorageService")->enterWarehouse( $box->id, $item->commodity_id, $amount, $box->material_box_model_id))$this->error("库存异常");

            DB::connection("oracle")->transaction(function ()use($tasks,$ide){ //单体嵌套事务 回滚FLUX失败任务
                foreach ($tasks as $task)if (!app("StorageService")->fluxPA($task,$ide)){
                    DB::connection("oracle")->rollBack();
                    $this->error("FLUX上架失败");
                };
            });
            DB::commit();
        }catch (\Exception $e){
            DB::rollBack();
            $this->error($e->getMessage());
        }
        //亮灯
        app("CacheShelfService")->lightUp($fromLocation,'1','0',["detail01"=>$ide,"qty01"=>$amount]);

        $maximum = app("CommodityMaterialBoxModelService")->getMaximum($box->material_box_model_id,$item->commodity_id);
        $this->success(["model" => $box->material_box_model_id,"commodity" => $item->commodity_id, "maximum" => $maximum]);
    }

    public function setMaximum()
    {
        app("CommodityMaterialBoxModelService")->setMaximum(request("model"),request("commodity"),request("maximum"));
        $this->success();
    }

    /**
     * 检查最大限值并返回
     *
     */
    public function checkMaximum()
    {
        $lotNum = request("lotNum");
        $sql = <<<SQL
SELECT * FROM INV_LOT_ATT WHERE LOTNUM = '{$lotNum}'
SQL;
        $lot = DB::connection("oracle")->selectOne(DB::raw($sql));
        if (!$lot)$this->error("批次丢失");
        $commodity = Commodity::query()->whereHas("owner",function ($query)use($lot){
            $query->where("code",$lot->customerid);
        })->where("sku",$lot->sku)->first();
        if (!$commodity)$this->error("WAS无此商品信息");
        $models = CommodityMaterialBoxModel::query()->where("commodity_id",$commodity->id)->get();
        if ($models->count()==0)$this->success(["material_box_model_id"=>null,"commodity_id"=>$commodity->id]);
        $map = [];
        foreach ($models as $model)$map[$model->material_box_model_id] = $model;
        $models = app("MaterialBoxModelService")->getModelSortedByOwner($commodity->owner_id);
        $m = null;
        foreach ($models as $model){
            if (!isset($map[$model->id]))continue;
            $model->maximum = $map[$model->id]->maximum;
            list($boxCodes) = app("MaterialBoxService")->getModelAvailableBox($model->id,true);
            if (!$boxCodes)continue;
            if (!$m)$m = $model;
            $sql = <<<SQL
SELECT LOCATIONID,({$model->maximum}-QTY) AS QTY FROM INV_LOT_LOC_ID WHERE LOTNUM = '{$lotNum}'
AND LOCATIONID IN ({$boxCodes}) AND TRACEID = '*' AND {$model->maximum}-QTY > 0 ORDER BY (CASE QTY WHEN 0 THEN 1 ELSE 0 END),{$model->maximum}-QTY
SQL;
            $res = DB::connection("oracle")->selectOne(DB::raw($sql));
            if ($res){
                $m = $model;
                $m->maximum = $res->qty;
                $m->location = $res->locationid;
                break;
            }
        }
        if (!$m)$this->error("没有可用料箱");
        $this->success(["need"=>$m->maximum,"material_box_model_id"=>$m->id,"commodity_id"=>$commodity->id,"location"=>$m->locationid]);
    }

    /**
     * 检查ASN可上架总数
     */
    public function checkAsnAmount()
    {
        $sql = <<<sql
SELECT sum(fmqty) amount FROM DOC_ASN_DETAILS LEFT JOIN BAS_SKU ON DOC_ASN_DETAILS.CUSTOMERID = BAS_SKU.CUSTOMERID AND DOC_ASN_DETAILS.SKU = BAS_SKU.SKU
LEFT JOIN TSK_TASKLISTS ON DOC_ASN_DETAILS.ASNNO = TSK_TASKLISTS.DOCNO AND DOC_ASN_DETAILS.ASNLINENO = TSK_TASKLISTS.DOCLINENO
WHERE ASNNO = ? AND (ALTERNATE_SKU1 = ? OR ALTERNATE_SKU2 = ? OR ALTERNATE_SKU3 = ?)
  AND TASKPROCESS = '00' AND TASKTYPE = 'PA'
sql;
        $task = DB::connection("oracle")->selectOne(DB::raw($sql),[request("asn"),request("barCode"),request("barCode"),request("barCode")]);
        $this->success($task->amount ?? 0);
    }

    /**
     * 重置缓存架指定格口
     */
    public function resetCacheShelf()
    {
        $this->gate("入库管理-入库-缓存架入库");
        $boxes = request("boxes");
        //清理任务
        $data = '';
        //剔除准备执行任务但没有真正开始执行的待定库位
        $occupy = Station::query()->select("id","code")->whereIn("code",$boxes)->where("status",1)->get();
        foreach ($occupy as $item){
            $data .= '“'.$item->code.'”,';
            unset($boxes[array_search($item->code,$boxes)]);
        }
        if ($occupy->count()>0){
            $data .= "存在任务待处理,无法调取  ";
            $boxes = array_values($boxes);
        }
        //剔除存在任务的库位
        $tasks = StationTaskMaterialBox::query()->with("station:id,code")
            ->whereIn("station_id",Station::query()->select("id")->whereIn("code",$boxes))
            ->whereNotIn("status",["完成","取消"])->get();
        foreach ($tasks as $task){
            unset($boxes[array_search($task->station->code,$boxes)]);
            $data .= '“'.$task->station->code.'”,';
        };
        if ($tasks->count()>0){
            $data .= "任务排队中,无法调取";
            $boxes = array_values($boxes);
        }
        //重新调取料箱
        $result = app("ForeignHaiRoboticsService")->paddingCacheShelf(Station::query()->whereIn("code",$boxes)->get());
        if ($result===null)$this->error("任务下发错误，检查日志");
        if ($result===false)$this->error("已无可用料箱，部分库位填充失败");
        $this->success(["data"=>$data,"boxes"=>$boxes]);
    }

    /**
     * 取得料箱
     */
    public function acquireBox()
    {
        $this->gate("入库管理-入库-半箱补货入库");
        $param = request()->only(["track","barCode","lotNum","amount","call"]);
        $track = $param["track"] ?? null;
        $barCode = $param["barCode"] ?? null;
        $lotNum = $param["lotNum"] ?? null;
        $amount = $param["amount"] ?? null;
        $manualCall = $param["call"] ?? false;
        if (!$track || !$barCode || !$lotNum || !$amount)$this->error("提交信息不完整");

        $sql = <<<SQL
SELECT SUM(FMQTY) qty,TSK_TASKLISTS.SKU,TSK_TASKLISTS.CUSTOMERID
FROM TSK_TASKLISTS
LEFT JOIN BAS_SKU ON TSK_TASKLISTS.CUSTOMERID = BAS_SKU.CUSTOMERID
AND TSK_TASKLISTS.SKU = BAS_SKU.SKU
WHERE FMID = ? AND FMLOTNUM = ? AND
      (ALTERNATE_SKU1 = ? OR ALTERNATE_SKU2 = ? OR ALTERNATE_SKU3 = ?)
  AND TASKPROCESS = '00' AND TASKTYPE = 'PA'
GROUP BY FMID,FMLOTNUM,TSK_TASKLISTS.SKU,TSK_TASKLISTS.CUSTOMERID
SQL;
        $task = DB::connection("oracle")->selectOne(DB::raw($sql),[$track,$lotNum,$barCode,$barCode,$barCode]);
        if (!$task || $task->qty<$amount)$this->error("待上架数量不足");
        $commodity = Commodity::query()->whereHas("owner",function ($query)use($task){
            $query->where("code",$task->customerid);
        })->where("sku",$task->sku)->first();
        if (!$commodity)$this->error("商品在WAS丢失，联系管理员处理");

        /** @var \Illuminate\Database\Eloquent\Collection $models */
        $models = app("MaterialBoxModelService")->getModelSortedByOwner($commodity->owner_id);
        $models->load(["commodity"=>function($query)use($commodity){
            $query->where("commodity_id",$commodity->id);
        }]);
        $models = $models->whereNotNull("commodity");
        if ($models->count()==0)$this->success(["status"=>false,"commodityId"=>$commodity->id]);

        //设定一个默认缓存架 仅用于任务占位 没有实际作用
        $defaultStation = Station::query()->where("station_type_id",5)
            ->whereNull("parent_id")->first();
        if (!$defaultStation)$this->error("默认缓存架丢失");
        DB::beginTransaction();
        try {
            //建立任务
            $exe = function ($station, $boxId, $amount)use($defaultStation, $commodity, $lotNum, $track){
                $stationId = $station ? $station->id : $defaultStation->id;
                $task = StationTask::query()->create([
                    'status' => "待处理",
                    'station_id' => $stationId,
                ]);
                $task = StationTaskMaterialBox::query()->create([
                    'station_id' => $stationId,
                    'material_box_id'=>$boxId,
                    'status'=>"待处理",
                    'type' => '取',
                    'station_task_id' => $task->id,
                ]);
                //生成临时任务事务
                TaskTransaction::query()->create([
                    "bar_code" => request("barCode"),
                    "fm_station_id" => $stationId,
                    "material_box_id" => $boxId,
                    "commodity_id" => $commodity->id,
                    "amount" => $amount,
                    "type" => "入库",
                    "user_id" => Auth::id(),
                    "mark" => 1,
                    "lot_num" => $lotNum,
                    "track_num" => $track,
                    "status" => $station ? 0 : 3,
                    "task_id" => $task->id
                ]);
                return $task;
            };

            $stations = app("StationService")->getCacheShelf(true);
            $collection = collect();
            $location = collect();
            $ids = [];
            //寻找半箱
            $sql = <<<SQL
SELECT LOCATIONID,QTY FROM INV_LOT_LOC_ID WHERE LOTNUM = '{$lotNum}'
AND LOCATIONID LIKE 'IDE%' AND SKU = '{$commodity->sku}' AND TRACEID = '*' AND QTY > 0 AND QTY > 0 ORDER BY QTY
SQL;
            $invs = DB::connection("oracle")->select(DB::raw($sql));
            if ($invs){
                $map = [];
                $codes = [];
                foreach ($invs as $inv){
                    $map[$inv->locationid] = $inv->qty;
                    $codes[] = $inv->locationid;
                }
                $modelMap = [];
                $orderBy = "CASE material_box_model_id ";
                foreach ($models as $key=>$model){
                    $orderBy .= 'WHEN '.$model->id." THEN ".$key;
                    $modelMap[$model->id] = $model->commodity->maximum;
                }
                $orderBy.= " END";
                $boxes = MaterialBox::query()->whereIn("code",$codes)->orderByRaw($orderBy)->get();
                //筛选下海柔可用箱
                list($codes,$notCodes) = app("MaterialBoxService")->checkHaiQ(array_column($boxes->toArray(),"code"));
                if (!$codes)$boxes = new \Illuminate\Database\Eloquent\Collection();
                $boxes = $boxes->filter(function ($box)use($codes,$notCodes){
                    if (!isset($codes[$box->code]) || isset($notCodes[$box->code]))return false;
                    return true;
                });
                foreach ($boxes as $box){
                    if ($modelMap[$box->material_box_model_id]<=$map[$box->code])continue;
                    $num = $modelMap[$box->material_box_model_id]-$map[$box->code];
                    $station = $stations->last();
                    $number = $amount >= $num ? $amount-$num : $amount;
                    $task = $exe($station, $box->id, $number);
                    if ($station){
                        $stations->offsetUnset($stations->count()-1);
                        $collection->push($task);
                        $location->push($station->code);
                        $ids[] = ["code"=>$station->code,"id"=>$station->id,"amount"=>$number];
                    }
                    $amount -= $number;
                    if ($amount==0)break;
                }
            }

            if ($amount){
                //寻找空箱
                $blacklist = [];//空箱逐一寻找需要列队黑名单
                foreach ($models as $model){
                    while ($amount!=0){
                        $station = $stations->last();
                        $box = app("MaterialBoxService")->getAnEmptyBox($model,$blacklist);
                        if (!$box)break; //此型号下无空箱可用
                        $blacklist[] = $box->id; //当前空箱黑名单
                        $number = $amount >= $model->commodity->maximum ? $amount-$model->commodity->maximum : $amount;
                        $task = $exe($station, $box->id, $number);
                        if ($station){
                            $stations->offsetUnset($stations->count()-1);
                            $collection->push($task);
                            $location->push($station->code);
                            $ids[] = ["code"=>$station->code,"id"=>$station->id,"amount"=>$number];
                        }
                        $amount -= $number;
                    }
                    if ($amount==0)break;
                }
            }
            if ($location->count()){
                /** @var ForeignHaiRoboticsService $service */
                $service = app("ForeignHaiRoboticsService");
                if ($manualCall)$result = $this->mergeIntoCache($location,$collection);
                else $result = $service->fetchGroup_multiLocation($location,$collection,'','立架出至缓存架');
                if (!$result){
                    DB::rollBack();
                    $this->error("机器人呼叫失败，海柔任务错误");
                }
                foreach ($ids as $obj){
                    $options = [
                        "detail01" => $obj["code"],
                        "detail02" => $barCode,
                        "qty02" => $obj["amount"],
                        "title" => '入库任务',
                        "uomDesc02" => "件"
                    ];
                    app("CacheShelfService")->lightUp($obj["code"],'3','0',$options);
                    Cache::forever("CACHE_SHELF_OCCUPANCY_{$obj["id"]}",true);
                }
                app("StationService")->locationOccupyMulti($location->toArray());
            }
            DB::commit();
            $this->success(["status"=>true,"amount"=>$amount]);
        }catch (\Exception $e){
            DB::rollBack();
            $this->error("处理失败：".$e->getMessage());
        }
    }

    /**
     * 并入缓存 等待呼叫
     *
     * @param Collection $location
     * @param Collection $collection
     *
     * @return bool
     */
    public function mergeIntoCache(Collection $location,Collection $collection):bool
    {
        $key = "CACHE_SHELF_CALL_".Auth::id();
        if (Cache::has($key)){
            list($locationAdd,$collectionAdd) = Cache::get($key);
            $location = $locationAdd->merge($location);
            $collection = $collectionAdd->merge($collection);
        }
        return Cache::forever($key,[$location,$collection]);
    }

    public function callRobot()
    {
        /** @var ForeignHaiRoboticsService $service */
        $service = app("ForeignHaiRoboticsService");
        $key = "CACHE_SHELF_CALL_".Auth::id();
        list($location,$collection) = Cache::get($key);
        if ($location->count()==0||$collection->count()==0)$this->error("没有可执行任务");
        $res = $service->fetchGroup_multiLocation($location,$collection,'','立架出至缓存架');
        if (!$res)$this->error("呼叫失败，海柔拒绝任务");
        Cache::forget($key);
        $this->success();
    }

    /**
     * 溢出校正
     */
    public function overflowRevision()
    {
        $this->gate("入库管理-入库-半箱补货入库");
        $ide = request("ide");
        $amount = request("amount");
        //获取目标料箱
        $box = MaterialBox::query()->where("code",$ide)->first();
        if (!$box)$this->error("未知料箱");

        DB::beginTransaction();
        try {
            $task = TaskTransaction::query()->where("material_box_id",$box->id)->where("amount",">=",$amount)
                ->where("type","入库")->where("mark",1)->where("status",0)->lockForUpdate()->first();
            if (!$task)$this->error("无任务存在");
            if ($task->amount == $amount){
                $station = Station::query()->find($task->fm_station_id);
                app("CacheShelfService")->lightUp($station->code);
                $task->delete();
            }
            else $task->update(["amount" => DB::raw("amount - {$amount}")]);
            $storage = MaterialBoxCommodity::query()->where("material_box_id",$task->material_box_id)
                ->where("commodity_id",$task->commodity_id)->first();
            $maximum = (($storage->amount ?? 0)+$task->amount)-$amount;
            CommodityMaterialBoxModel::query()->where("material_box_model_id",$task->materialBox->material_box_model_id)
                ->where("commodity_id",$task->commodity_id)->update(["maximum"=>$maximum]);
            DB::commit();
            $this->success("校正成功");
        }catch (\Exception $e){
            DB::rollBack();
            $this->error("校正失败");
        }
    }

    public function syncStorage()
    {
        ini_set('max_execution_time', 0);
        $model = MaterialBoxModel::query()->create([
            "code" => "common"
        ]);
        $sql = <<<sql
    select * from INV_LOT_LOC_ID where traceid = '*' and locationid like 'IDE%'
sql;
        DB::beginTransaction();
        foreach (DB::connection("oracle")->select(DB::raw($sql)) as $inv){
            $materialBox = MaterialBox::query()->firstOrCreate(["code"=>$inv->locationid],[
                "code" => $inv->locationid,
                "material_box_model_id"=>$model
            ]);
            $owner = Owner::query()->firstOrCreate([
                "code" => $inv->customerid
            ],[
                "code" => $inv->customerid,
                "name" => $inv->customerid,
            ]);
            $commodity = Commodity::query()->where("owner_id",$owner->id)->where("sku",$inv->sku)->first();
            $s = MaterialBoxCommodity::query()->where("material_box_id",$materialBox->id)
                ->where("commodity_id",$commodity->id)->first();
            if (!$s)MaterialBoxCommodity::query()->create([
                "material_box_id" => $materialBox->id,
                "commodity_id" => $commodity->id,
                "amount" => $inv->qty,
            ]);else $s->update(["amount" => $inv->qty]);
        }
        DB::commit();
        $this->success();
    }

    /**
     * 在安卓端的个体登录鉴权
     *
     */
    public function androidLogin()
    {
        $errors=Validator::make(request()->input(),[
            "name"      => 'required|string',
            'password'  => 'required|string'])->errors();
        if($errors->count()>0){return ['success'=>false,'errors'=>$errors];}
        request()->offsetSet("remember",true);
        if (!$this->attemptLogin(request()))return ['success'=>false,'errors'=>['name'=>['登录信息验证失败']]];
        if (!Gate::allows("入库管理-入库-缓存架入库") && !Gate::allows("入库管理-入库-半箱补货入库"))return ['success'=>false,'errors'=>['name'=>['用户无权操作入库']]];
        $rememberTokenName = Auth::getRecallerName();
        Cookie::queue($rememberTokenName, Cookie::get($rememberTokenName), 720);
        return ['success'=>true,'url'=>url("store/inStorage/android.index")];
    }
    public function username(): string
    {
        return 'name';
    }

    /**
     * 库外箱绑定至库位
     */
    public function bindBox()
    {
        $location = request("location");
        $box = request("ide");
        if (!$location || !$box)$this->error("参数传递错误");
        $task = StationTaskMaterialBox::query()->select("id")->where(function ($query)use($location,$box){
            /** @var Builder $query */
            $query->whereHas("station",function ($query)use($location){
                /** @var Builder $query */
                $query->where("code",$location);
            })->orWhereHas("materialBox",function ($query)use($box){
                /** @var Builder $query */
                $query->where("code",$box);
            });
        })->whereNotIn("status",["完成","取消"])->first();
        if ($task)$this->error("库位或料箱存在任务待执行,无法放置料箱");
        $ks = DB::connection("mysql_haiRobotics")->table("ks_bin")->select(DB::raw("1"))
            ->where("ks_bin_code",$box)->where("status",4)->first();
        if (!$ks)$this->error("海柔料箱状态异常");
        DB::beginTransaction();
        try {
            $station = Station::query()->where("code",$location)->where("status",0)->first();
            $box = MaterialBox::query()->where("code",$box)->first();
            if (!$station || !$box)$this->error("库位或料箱未在WAS记录");
            $station->update(["material_box_id"=>$box->id]);
            app("CacheShelfService")->lightUp($station->code);
            DB::commit();
            $this->success();
        }catch (\Exception $e){
            DB::rollBack();
            $this->error($e->getMessage());
        }
    }

    public function bindModelIndex(){
        $models = MaterialBoxModel::query()->get();
        return view("store.inStorage.boxBindModel",compact("models"));
    }

    public function searchIde()
    {
        $ide = request("ide");
        $box = MaterialBox::query()->where("code",$ide)->first();
        if (!$box)$this->error("料箱不存在");
        $this->success($box->material_box_model_id);
    }

    public function boxBindModel()
    {
        $this->success(MaterialBox::query()->where("code",request("ide"))
            ->update(["material_box_model_id"=>request("material_box_model_id")]));
    }

    public function commodityBindModel()
    {
        $models = MaterialBoxModel::query()->get();
        return view("store.inStorage.commodityBindModel",compact("models"));
    }

    public function getModels()
    {
        $this->success(MaterialBoxModel::query()->select("id","code","description","maximum_kind")->get());
    }

    /**
     * 设定料箱最大
     */
    public function settingModelMaximum()
    {
        if (!request("commodityId"))$this->error("未获取商品");
        $insert = function ($commodityId){
            $in = [];
            $ids = [];
            foreach (request("models") as $model){
                $in[] = [
                    "commodity_id" => $commodityId,
                    "material_box_model_id" => $model["id"],
                    "maximum" => $model["maximum"]
                ];
                $ids[] = $model["id"];
            }
            return array($in,$ids);
        };
        list($in,$ids) = $insert(request("commodityId"));
        if ($ids){
            $map = array_flip($ids);
            foreach (CommodityMaterialBoxModel::query()->where("commodity_id",request("commodityId"))
                         ->lockForUpdate()->get() as $model){
                $index = $map[$model->material_box_model_id];
                if ($model->maximum != $in[$index]["maximum"]){
                    CommodityMaterialBoxModel::query()->where("commodity_id",request("commodityId"))
                        ->where("material_box_model_id",$model->material_box_model_id)
                        ->update(["maximum"=>$in[$index]["maximum"]]);
                }
                unset($in[$index]);
            }
            $in = array_values($in);
        }
        if ($in){
            LogService::log(__CLASS__,__METHOD__,json_encode($in));
            CommodityMaterialBoxModel::query()->insert($in);
        }
        $this->success();
    }

    /**
     * 根据条码检索商品
     */
    public function searchBarCode()
    {
        $commodities = Commodity::query()->with("owner")->whereHas("barcodes",function (Builder $query){
            $query->where("code",request("barCode"));
        })->get();
        if (!$commodities->count())$this->error("库内无此商品信息");
        if ($commodities->count()>1)$commodities->load("owner");
        $this->success($commodities);
    }

    /**
     * 根据商品ID检索已存在的上限设定
     */
    public function searchModel()
    {
        $mapping = [];
        foreach (CommodityMaterialBoxModel::query()->where("commodity_id",request("id"))->get() as $model){
            $mapping[$model->material_box_model_id] = $model->maximum;
        }
        $this->success($mapping);
    }

    /**
     * 根据ASN号检索未设定商品型号上限的信息
     */
    public function searchAsn()
    {
        $sql = <<<SQL
SELECT CUSTOMERID,SKU FROM TSK_TASKLISTS WHERE DOCNO = ? AND TASKPROCESS = '00' AND TASKTYPE = 'PA' GROUP BY CUSTOMERID,SKU
SQL;
        $store = Store::query()->select("owner_id")->where("asn_code",request("asn"))->first();
        if (!$store || !$store->owner_id)$this->error("WAS内无此ASN单信息");

        $tasks = DB::connection("oracle")->select(DB::raw($sql),[request("asn")]);
        $codes = array_column($tasks,"sku");
        $model = MaterialBoxModel::query()->where("maximum_kind",1)->first();
        if (!$model)$this->error("单品型号缺失");
        $commodities = Commodity::query()->with("model")->where("owner_id",$store->owner_id)
            ->whereIn("sku",$codes)->get()->toArray();
        if (count($codes)!=count($commodities))$this->error("WAS商品信息不全");
        foreach ($commodities as $index=>$commodity){
            if ($commodity->model)unset($commodities[$index]);
        }
        $this->success(["commodities"=>array_values($commodities),"model"=>$model]);
    }

    /**
     * 设置商品上限
     */
    public function settingCommodityMaximum()
    {
        $modelId = request("modelId");
        $insert = [];
        $date = date("Y-m-d H:i:s");
        foreach (request("commodities") as $commodity){
            $insert[] = [
                "commodity_id" => $commodity["id"],
                "material_box_model_id" => $modelId,
                "maximum" => $commodity->maximum,
                "created_at" => $date,
                "updated_at" => $date,
            ];
        }
        $this->success(CommodityMaterialBoxModel::query()->insert($insert));
    }

    /**
     * 检查任务获取多批次
     */
    public function checkTask()
    {
        $track = request("track");
        $barCode = request("barCode");
        $sql = <<<SQL
SELECT TSK_TASKLISTS.FMLOTNUM,SUM(FMQTY) qty FROM TSK_TASKLISTS LEFT JOIN BAS_SKU ON TSK_TASKLISTS.CUSTOMERID = BAS_SKU.CUSTOMERID
AND TSK_TASKLISTS.SKU = BAS_SKU.SKU
WHERE FMID = ? AND (ALTERNATE_SKU1 = ? OR ALTERNATE_SKU2 = ? OR ALTERNATE_SKU3 = ?)
AND TASKPROCESS = '00' AND TASKTYPE = 'PA' GROUP BY FMID,FMLOTNUM
SQL;
        $tasks = DB::connection("oracle")->select(DB::raw($sql),[$track,$barCode,$barCode,$barCode]);
        $result = ["count"=>count($tasks)];
        switch ($result["count"]){
            case 0:
                break;
            case 1:
                $result["lots"] = $tasks[0]->fmlotnum;
                $result["lotMap"] = [$result["lots"] => $tasks[0]->qty];
                break;
            default:
                $lotNums = "";
                $result["lotMap"] = [];
                foreach ($tasks as $task){
                    $lotNums .= "'".$task->fmlotnum."',";
                    $result["lotMap"][$task->fmlotnum] = $task->qty;
                }
                $lotNums = rtrim($lotNums,",");
                $sql = <<<SQL
SELECT * FROM INV_LOT_ATT WHERE LOTNUM IN ({$lotNums});
SQL;
                $result["lots"] = DB::connection("oracle")->select(DB::raw($sql));
        }
        $this->success($result);
    }

    /**
     * 改变ASN许可规则
     */
    public function changeAsnRule()
    {
        $ids = request("ids");
        $val = request("val");
        $this->success(Owner::query()->whereIn("id",$ids)->update(["is_check_asn"=>$val ? 0 : 1]));
    }
}