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\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\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()
    {
        $track = request("track");
        $barCode = request("barCode");
        $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]);
        $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;
            $boxes = app("MaterialBoxService")->getModelAvailableBox($model->id);
            if ($boxes->count()==0)continue;
            if (!$m)$m = $model;
            $boxCodes = "";
            foreach ($boxes as $box){
                $boxCodes .= "'".$box->code."',";
            }
            $boxCodes = rtrim($boxCodes,",");
            $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;
                break;
            }
        }
        if (!$m)$this->error("没有可用料箱");
        $this->success(["need"=>$m->maximum,"material_box_model_id"=>$m->id,"commodity_id"=>$commodity->id]);
    }

    /**
     * 检查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")->whereIn("code",$boxes)->where("status",1)->get();
        foreach ($occupy as $item){
            unset($boxes[array_search($item->code,$boxes)]);
            $data .= '“'.$item->code.'”,';
        }
        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("入库管理-入库-半箱补货入库");
        $boxId = request("material_box_id");
        $modelId = request("material_box_model_id");
        if (!$modelId)$this->error("商品未设定库存上限");
        //获取目标库位
        $station = app("StationService")->getMirrorMappingLocation(request("station"));
        if (!$station)$this->error("未知库位");
        $isAvailable = app("StationService")->isAvailable($station);
        if (!$isAvailable)$this->error("库存被占用或存在任务未处理");
        $amount = app("StorageService")->checkPutAmount(request("asn"),request("barCode"));
        if ($amount<request("amount"))$this->error("待上架数量不足，最大可上数量为{$amount}");

        //发起取箱任务
        $exe = function ($boxId)use($station){
            DB::beginTransaction();
            $collection = new Collection();
            $task = StationTask::query()->create([
                'status' => "待处理",
                'station_id' => $station->id,
            ]);
            $collection->add(StationTaskMaterialBox::query()->create([
                'station_id' => $station->id,
                'material_box_id'=>$boxId,
                'status'=>"待处理",
                'type' => '取',
                'station_task_id' => $task->id,
            ]));
            if (!app("ForeignHaiRoboticsService")->fetchGroup($station->code,$collection,'','立架出至缓存架'))$this->error("呼叫机器人失败");
            //生成临时任务事务
            TaskTransaction::query()->create([
                "doc_code" => request("asn"),
                "bar_code" => request("barCode"),
                "fm_station_id" => $station->id,
                "material_box_id" => $boxId,
                "commodity_id" => request("commodity_id"),
                "amount" => request("amount"),
                "type" => "入库",
                "user_id" => Auth::id(),
                "mark" => 1
            ]);
            DB::commit();
            //亮灯
            app("CacheShelfService")->lightUp($station->code,'3','2');
            app("StationService")->locationOccupy($station->code);//占用库位
            Cache::forever("CACHE_SHELF_OCCUPANCY_{$station->id}",true);
        };
        if ($boxId && app("MaterialBoxService")->checkUsableBox($boxId))$this->success($exe($boxId));
        $item = app("StoreItemService")->getMaxAvailableDetail(request("asn"),request("barCode"));
        if (!$item)$this->error("无此单据记录");
        $models = app("MaterialBoxModelService")->getModelSortedByOwner($item->store->owner_id);
        $models->load(["commodity"=>function($query)use($item){
            $query->where("commodity_id",$item->commodity_id);
        }]);
        //获取料箱
        if ($boxId){
            $blacklist = [$boxId];
            $boxId = null;
            //料箱存在且不可用
            /** @var \Illuminate\Database\Eloquent\Collection $models */

            foreach ($models as $model){
                if (!$model->commodity)continue;
                //料箱不可用寻找新料箱
                $result = app("StorageService")->getHalfBoxLocation($model->commodity,$item,request("asn"),$blacklist);
                while ($result){
                    //料箱可用并且数量符合本次半箱数量 跳出
                    if (app("MaterialBoxService")->checkUsableBox($result->material_box_id)
                        && $model->maximum-$result->amount>=request("amount"))$this->success($exe($result->material_box_id));
                    else $blacklist[] = $result->material_box_id;
                    //否则黑名单此料箱继续查找 直至料箱为空
                    $result = app("StorageService")->getHalfBoxLocation($model->commodity,$item,request("asn"),$blacklist);
                }
            }
        }
        //料箱不存在且该商品有过入库记录 拿取空箱
        if (!$modelId){
            $box = null;
            foreach ($models as $model){
                if (!$model->commodity)continue;
                $box = app("MaterialBoxService")->getAnEmptyBox($model);
                if($box)break;
            }
        }else $box = app("MaterialBoxService")->getAnEmptyBox(MaterialBoxModel::query()->find($modelId));
        if (!$box)$this->error("无可用料箱");
        $this->success($exe($box->id));
    }

    /**
     * 溢出校正
     */
    public function overflowRevision()
    {
        $this->gate("入库管理-入库-半箱补货入库");
        $station = request("station");
        $amount = request("amount");
        //获取目标库位
        $station = app("StationService")->getMirrorMappingLocation($station);
        if (!$station)$this->error("未知库位");
        $task = TaskTransaction::query()->with("materialBox")->where("fm_station_id",$station->id)->where("amount",">",$amount)
            ->where("type","入库")->where("mark",1)->where("status",0)->first();
        if (!$task)$this->error("无任务存在");
        $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]);
        $this->success("校正成功");
    }

    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'=>['用户无权操作入库']]];
        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]);
            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()
    {
        $insert = function ($commodityId){
            $in = [];
            $map = [];
            $ids = [];
            foreach (request("models") as $model){
                $in[] = [
                    "commodity_id" => $commodityId,
                    "material_box_model_id" => $model["id"],
                    "maximum" => $model["maximum"]
                ];
                $map[$model["id"]] = $model;
                $ids[] = $model["id"];
            }
            return array($in,$map,$ids);
        };
        if (request("commodityId")){
            list($in,$map,$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();
        }
        $item = StoreItem::query()->whereHas("store",function (Builder $query){
            $query->where("asn_code",request("asn"));
        })->whereHas("commodity",function (Builder $query){
            $query->whereHas("barcodes",function (Builder $query){
                $query->where("code",request("barCode"));
            });
        })->first();
        if (!$item)$this->error("商品不存在");
        list($in,$map,$ids) = $insert($item->store->commodity_id);
        LogService::log(__CLASS__,__METHOD__,json_encode($in));
        CommodityMaterialBoxModel::query()->insert($in);
        $this->getMaterBoxModel($item,$map);
    }

    private function getMaterBoxModel($commodity,$map)
    {
        $models = app("MaterialBoxModelService")->getModelSortedByOwner($commodity->owner_id);
        foreach ($models as $model){
            if (!isset($map[$model->id]))continue;
            //$result = app("StorageService")->getHalfBoxLocation($map[$model->id],$item,$item->store->asn_code);
            $result = app("StorageService")->getMaxAvailableHalfBoxLocation($map[$model->id],$item,$item->store->asn_code);
            if (!$result)continue;
            $result->maximum = $model->maximum-$result->amount;
            $this->success($result);
        }
        $this->success(["need"=>$models[0]->maximum,"material_box_model_id"=>$models[0]->material_box_model_id,"commodity_id"=>$commodity->id]);
    }

    /**
     * 根据条码检索商品
     */
    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 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)];
        if (count($tasks)>1){
            $lotNums = "";
            foreach ($tasks as $task)$lotNums .= "'".$task->fmlotnum."',";
            $lotNums = rtrim($lotNums,",");
            $sql = <<<SQL
SELECT * FROM INV_LOT_ATT WHERE LOTNUM IN ({$lotNums});
SQL;
            $result["lots"] = DB::connection("oracle")->select(DB::raw($sql));
        }
        if (count($tasks)==1)$result["lots"] = $tasks[0]->fmlotnum;
        $this->success($result);
    }
}