baoshi-was/app/Services/OwnerPriceOperationService.php

<?php

namespace App\Services;

use App\Components\ErrorPush;
use App\Feature;
use App\Jobs\HandlePastBill;
use App\Owner;
use App\OwnerFeeDetail;
use App\OwnerPriceOperation;
use App\OwnerPriceOperationItem;
use App\Services\common\QueryService;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\DB;
use App\Traits\ServiceAppAop;


class OwnerPriceOperationService
{
    use ServiceAppAop;
    use ErrorPush;
    protected $modelClass=OwnerPriceOperation::class;
    /**
     * @param Builder $builder
     * @param array $params
     * @return Builder
     */
    private function query(Builder $builder, array $params)
    {
        if ($params["owner_id"] ?? false){
            $ids = $this->ownerGetIds($params["owner_id"]);
            if ($ids)$builder->whereIn("id",$ids);
            unset($params["owner_id"]);
        }
        $columnQueryRules = [
            "name" => ["like"=>""]
        ];
        return app(QueryService::class)->query($params, $builder, $columnQueryRules);
    }

    public function paginate(array $params, array $withs = [])
    {
        return $this->query(OwnerPriceOperation::query()->orderByDesc('id')->with($withs),$params)
            ->paginate($params["paginate"] ?? 50);
    }


    private function ownerGetIds(string $ownerId)
    {
        if (!$ownerId)return [];
        $arr = DB::select(DB::raw("SELECT owner_price_operation_id AS id FROM owner_price_operation_owner WHERE owner_id in (".$ownerId.")"));
        return array_column($arr,"id");
    }

    /**
     * 拷贝目标数据
     *
     * @param object|int $model
     * @param array $values
     * @param array $items
     * @param array|null $owners
     * @param bool $isLoadItem
     *
     * @return object|null
     */
    public function copy($model, $values = [], $owners = null, $items = [], $isLoadItem = true)
    {
        if (is_integer($model))$model = OwnerPriceOperation::query()->find($model);
        if (!$model)return null;
        $values["operation"] = "U";
        $values["target_id"] = $model->id;
        foreach ($model->getFillable() as $column){
            if (!array_key_exists($column,$values))$values[$column] = $model[$column];
        }
        if ($owners === null){
            $query = DB::raw("SELECT * FROM owner_price_operation_owner WHERE owner_price_operation_id = {$model->id}");
            $owners = array_column(DB::select($query),"owner_id");
        }
        /** @var OwnerPriceOperation $copyModel */
        $copyModel = OwnerPriceOperation::query()->create($values);
        $copyModel->owners()->sync($owners);
        $insert = [];
        if ($isLoadItem){
            $model->load("items");
            /** @var \stdClass $model */
            foreach ($model->items as $item){
                $columns = ["strategy","amount","unit_id","unit_price","feature","priority","discount_price","odd_price"];
                if ($items[$item->id] ?? false){
                    foreach ($columns as $column){
                        if (!array_key_exists($column,$items[$item->id]))$items[$item->id][$column] = $item[$column];
                    }
                    $obj = $items[$item->id];
                    unset($items[$item->id]);
                }else{
                    /** @var OwnerPriceOperationItem $item */
                    $obj = $item->toArray();
                    unset($obj["id"]);
                }
                $obj["owner_price_operation_id"] = $copyModel->id;
                $insert[] = $obj;
            }
        }else{
            foreach ($items as $item){
                $arr = [];
                $arr["owner_price_operation_id"] = $copyModel->id;
                $arr["strategy"] = $item["strategy"];
                $arr["amount"] = $item["amount"] ?? null;
                $arr["unit_id"] = $item["unit_id"];
                $arr["unit_price"] = $item["unit_price"];
                $arr["feature"] = $item["feature"] ?? null;
                $arr["odd_price"] = $item["odd_price"] ?? null;
                $arr["priority"] = $item["priority"] ?? 0;
                $arr["discount_price"] = isset($item["discount_price"]) ? (is_array($item["discount_price"]) ? implode(",",$item["discount_price"]) : $item["discount_price"]) : null;
                $insert[] = $arr;
            }
        }
        if ($insert)OwnerPriceOperationItem::query()->insert($insert);
        return $copyModel;
    }

    /**
     * 审核或恢复目标集
     *
     * @param bool $isAudit
     * @param integer|null|array $ownerId
     * @param integer|null|array $ids
     */
    public function auditOrRecover($isAudit = true, $ownerId = null, $ids = null)
    {
        if (!$ownerId && !$ids)return;
        $result = app(QueryService::class)->priceModelAuditOrRecoverQuery($isAudit,OwnerPriceOperation::query(),$ownerId,$ids);
        if ($result["delete"])$this->destroy($result["delete"]);
        if ($result["update"])OwnerPriceOperation::query()->whereIn("id",$result["update"])->update(["operation"=>null,"target_id"=>null]);
        if (!is_array($ownerId))$ownerId = [$ownerId];
        foreach ($ownerId as $ow)Cache::tags("operationFeeOwner:".$ow)->flush();
    }

    public function destroy($id)
    {
        if (!is_array($id))$id = [$id];
        OwnerPriceOperationItem::query()->whereIn("owner_price_operation_id",$id)->delete();

        DB::table("owner_price_operation_owner")->whereIn("owner_price_operation_id",$id)->delete();

        return OwnerPriceOperation::destroy($id);
    }

    /**
     * @param array $params
     * @return Model
     */
    public function create(array $params)
    {
        $params["operation"] = "C";
        return OwnerPriceOperation::query()->create($params);
    }

    public function insertItem(array $params)
    {
        OwnerPriceOperationItem::query()->insert($params);
    }

    public function find($id, $withs = [])
    {
        $query = OwnerPriceOperation::query()->with($withs)->find($id);
        return $query;
    }

    public function update(array $params, array $values)
    {
        $query = OwnerPriceOperation::query();
        foreach ($params as $column => $value){
            $query->where($column,$value);
        }
        return $query->update($values);
    }

    public function destroyItem($id)
    {
        return OwnerPriceOperationItem::query()->where("owner_price_operation_id",$id)->delete();
    }

    public function findUpdate(OwnerPriceOperation $model, array $params)
    {
        return $model->update($params);
    }

    /**
     *  获取计费模型缓存
     *
     * @param integer $owner
     * @param string $type
     * @param int|null $typeMark
     *
     * @return array|Collection
     *
     */
    public function getOwnerPriceOperation(int $owner, string $type, ?int $typeMark)
    {
        return Cache::tags("operationFeeOwner:".$owner)->remember("operationFee:".$owner.$type.$typeMark,config("cache.expirations.rarelyChange"),
            function ()use($owner,$type,$typeMark){
                $query = OwnerPriceOperation::query()->with(["items"=>function($query){
                    /** @var Builder $query */
                    $query->orderByRaw("CASE strategy  WHEN '起步' THEN 1 WHEN '默认' THEN 2 WHEN '特征' THEN 3 END DESC,priority");
                }])->where("operation_type",$type)->whereHas("owners",function ($query)use($owner){
                    /** @var Builder $query */
                    $query->where("id",$owner);
                })->where(function(Builder $query){
                    $query->whereNull("operation")->orWhere("operation","");
                })->orderByRaw("strategy desc,priority desc");

                if ($typeMark!==null)$query->where("type_mark",$typeMark);
                else $query->whereNull("type_mark");

                return $query->get();
        });
    }

    /**
     * 获取满减信息
     *
     * @param null|string $discount
     * @param integer $total
     *
     * @return bool|array
     */
    public function getDiscount(?string $discount, int $total)
    {
        if (!$discount)return false;
        foreach (array_reverse(explode(",",$discount),true) as $index=>$discount){
            if ($total >= $discount)return [$index=>$discount];
        }
        return false;
    }

    /**
     * 处理折扣单
     *
     * @param Model|\stdClass $rule
     * @param integer $owner
     * @param bool|array $result
     */
    public function handleDiscount(Model $rule, int $owner, $result)
    {
        if (!$result)return;
        $sign = false;
        //入口仅在此处存在 缓存1000s
        $key = "owner_price_operation_owner_".$rule->id."_".$owner;
        $discountIndex = key($result);
        $targetValue = $result[$discountIndex];
        $pivot = null;
        try{
            DB::beginTransaction();
            //此处暂时未使用cache的互斥锁 使用sql行锁代替下 防止缓存击穿
            $pivot = app(CacheService::class)->getOrExecute($key,function ()use($key,$targetValue,&$sign,$rule,$owner){
                return DB::selectOne(DB::raw("SELECT * FROM owner_price_operation_owner WHERE owner_price_operation_id = ? AND owner_id = ? for update"),[$rule->id,$owner]);
            },1000);
            if ($pivot && (!$pivot->discount_date || substr($pivot->discount_date,0,7)!=date("Y-m") || $pivot->target_value < $targetValue)){
                //未被标记过处理时间或处理时间不为本月，或上次处理值过期，处理历史即时账单
                $sign = true;
            }
            if ($sign){
                //先标记成功 这将在后续推进历史单处理流程，防止程序在此堵塞
                DB::update(DB::raw("UPDATE owner_price_operation_owner SET discount_date = ?,target_value = ? WHERE  owner_price_operation_id = ? AND owner_id = ?"),
                    [date("Y-m-d"),$targetValue,$rule->id,$owner]);
                $pivot->discount_date = date("Y-m-d");
                $pivot->target_value = $targetValue;
                Cache::put($key,$pivot,1000);
            }
            DB::commit();
        }catch (\Exception $exception){
            DB::rollBack();
            $this->push(__METHOD__."->".__LINE__,"即时账单满减处理失败",$exception->getMessage()."  参数".json_encode(array($rule, $owner, $result)));
        }
        //进入历史单处理
        if ($pivot && $sign)dispatch(new HandlePastBill(array($rule,$owner,$discountIndex,$pivot)));
    }

    /** 参数顺序： 数量 匹配对象 列映射 货主ID 单位ID 类型 SKU .
     *  匹配顺序： 类型 货主 策略 单位 特征                    ..多对多匹配规则废弃，1对1，设单位必定为件,对应规则必然只有一项存在
     *  单位匹配： 件，箱 由小到大，依次换算匹配           .
     *
     *  2:没有总数量存在，都为子项内数量
     *
     * @param array|object|Model $matchObject  key-val
     * @param array $columnMapping       key-val
     * @param integer $ownerId
     * @param string $type
     * @param int|null $typeMark
     *
     * @return double|array
     * 错误代码： -1:无匹配对象 -2:无计费模型 -3:未知单位 -4:sku为空 -5:货主未找到 -6:无箱规 -7:未匹配到计费模型
     *
     * 一. 2020-10-10 zzd
     * 二. 2021-01-08 zzd
     * 三. 2021-01-28 zzd
     *      增加满减策略：子策略匹配时不再考虑单，仅件箱换算，满减满足后标记模型修改历史对账单
     *      增加按订单计价策略：主匹配模型增加字段量价，该字段存在时视为按单计价，价格为该值
     * 四. 2021-02-18 zzd
     *      满减多阶段匹配 满减字段由单值改为字符串多值 匹配时转数组寻找最相近
     * 五. 2021-03-18 zzd
     *      区分单据类型，增加字段
     * 六. 2021-03-23 zzd
     *      不严格区分入库出库差异 统一模型
     * 七. 2021-03-30 zzd
     *      增加一级二级特征，零头价，满减按总件,附加费用等
     * 八. 2021-04-19 zzd
     *      增加税率计算，改变返回值数据结构，增加封顶费
     * 九. 2021-04-21 zzd
     *      排除掉order不存在包裹情况，预设输出值为null防止返回0,历史账单处理推进队列防止超时
     * 十. 2021-08-13
     *      优化匹配模型，设置超全局费用信息提取
     */
    public function matching($matchObject, array $columnMapping, int $ownerId, string $type = '出库', ?int $typeMark = null):array
    {
        $units = app("UnitService")->getUnitMapping(["件","单","箱","m³","T","kg"],true); //获取单位映射集
        $rules = $this->getOwnerPriceOperation($ownerId,$type,$typeMark);//货主下的全部规则
        if (!$rules)return array(null,null,null);  //规则不存在跳出

        if ($type == '出库'){
            $total = app("OrderService")->getOrderQuantity($ownerId)+1;//获取该货主本月C端单量
            $matchObject->packages->each(function ($package)use(&$orderTotal){
                if($package->commodities->count()==0)return;
                $package->commodities[0]->bulk = $package->bulk/1000000;
                $package->commodities[0]->weight = $package->weight;
                $package->commodities->each(function ($commodity)use(&$orderTotal){
                    $orderTotal += (int)$commodity->amount;
                });
            });
            $matchObject[$columnMapping[12]] = $orderTotal;
        }else {
            $total = 0;
            if ($matchObject->storeItems)foreach ($matchObject->storeItems as $item)$total += $item->amount;
            $matchObject[$columnMapping[12]] = $total;
            $total += app("StoreService")->getStoreAmount($ownerId);//获取该货主本月入库件数
        }
        foreach ($rules as $rule){
            if (!$rule->items)continue; //不存在子规则跳出
            //第一级匹配 特征类别不符合要求跳出
            if ($rule->strategy == '特征' && !app("FeatureService")->matchFeature($rule->feature,$columnMapping,$matchObject))continue;
            //获取满减信息并处理满减
            $result = $this->getDiscount($rule->discount_count,$total); //满减信息
            $this->handleDiscount($rule,$ownerId,$result);

            $taxRate = app("OwnerService")->getTaxRateFee($rule, $ownerId);//获取税率

            if (!$rule->total_price){
                $money = $this->matchItem($rule,$columnMapping,$matchObject,$units,$ownerId,$result);//匹配子项获取详细报价
                $money = $this->settingMaxFee($rule,$money,$taxRate,$units);
            } else{
                $money = $result ? explode(",",$rule->total_discount_price)[key($result)] : $rule->total_price;//按单计价存在，直接返回单总价或减免总价
                $arr = $this->resetChildNodeMapping($matchObject->toArray(),$columnMapping);
                if ($arr)$this->extractInfo($arr,$money,$result,array_flip($units),$taxRate);
            }

            if ($money<=0)$money=null;//计算失误
            $taxFee = $money*($taxRate/100);
            return array($rule->id,$money,$taxFee);
        }
        return array(null,null,null);
    }

    /**
     * 提取信息插入超全局变量中
     */
    private function extractInfo(array $arr, $money, $result, $flip, $taxRate)
    {
        foreach ($arr as $index => $item){
            $details = [[
                "name"      => "单价",
                "amount"    => $item["amount"] ?? 0,
                "price"     => 0,
                "unit_id"   => $flip["件"],
            ]];
            if ($index==0){
                $feeDescription = "按单计价".($result ? '('.value($result).')' : '').':'.$money.'元';
                $details[] = [
                    "name"      => "按单计费",
                    "amount"    => 1,
                    "price"     => $money,
                    "unit_id"   => $flip["单"],
                ];
            }else $feeDescription = '该单已被按单计费,续费0元';
            $GLOBALS["FEE_INFO"][] = [
                "commodity_id"  => $item["commodity_id"] ?? 0,
                "total_fee"     => $money,
                "tax_rate"      => $taxRate,
                "fee_description"  => $feeDescription,
                "details" => $details
            ];
        }
    }
    /**
     * 根据货主 sku寻找箱规并将指定数量切换为箱 返回箱规
     *
     * @param integer $ownerId
     * @param null|object|array $commodity
     *
     * @return int
     */
    private function changeUnit(int $ownerId,$commodity):int
    {
        if (!$commodity)return -4;
        if ($commodity["pack_spec"])return $commodity["pack_spec"];
        $pack = app("CommodityService")->getPack($ownerId,$commodity["sku"]);
        if (!$pack)return -6;
        return $pack;
    }

    /**
     * 重置子节点的映射对象  将无限极数组扁平化为二维 以Feature中定义的8:商品数量 key为基准
     *
     * @param object|array $matchObject
     * @param array $columnMapping
     *
     * @return array|null
     */
    private function resetChildNodeMapping($matchObject, array &$columnMapping):?array
    {
        $need = "";
        foreach (Feature::TYPE_NODE as $index){
            if (!$need)$need=strstr($columnMapping[$index],".",true);
            $columnMapping[$index] = ltrim(strstr($columnMapping[$index],"."),".");
        }
        $nextObj = strstr($columnMapping[8],".",true);
        $first = $matchObject[$need] ?? false;
        if ($first===false)return $matchObject;
        if (!$first)return $first;
        if (is_array($first))$first = reset($first);
        if ($nextObj && is_array($first[$nextObj])){
            $result = [];
            foreach ($matchObject[$need] as $arr)$result = array_merge($result,$arr[$nextObj]);
            return $this->resetChildNodeMapping($result,$columnMapping);
        }
        return $matchObject[$need];
    }

    /**
     * 匹配子策略
     *
     * @param Model|\stdClass $obj 策略对象
     * @param array $columnMapping 映射对象
     * @param Model|\stdClass $matchObject 被匹配对象
     * @param array $units 单位集
     * @param integer $ownerId 货主ID
     * @param bool|array $result 满减信息
     *
     * @return double
     */
    public function matchItem($obj, array $columnMapping, $matchObject, array $units, int $ownerId, $result)
    {
        $matchObject = $this->resetChildNodeMapping($matchObject->toArray(),$columnMapping);
        if (!$matchObject)return -1;
        $total = $surcharge = $oddMoney = $surchargeAmount = 0; //商品总数 附加费 零头附加费

        foreach ($matchObject as $commodity)$total += $commodity[$columnMapping[8]]; //取对象内商品数量总数将其当作子属性插入原对象
        if ($obj->surcharge_unit_id && $obj->surcharge){
            $surchargeAmount = $units[$obj->surcharge_unit_id] == '件' ? $total : 1;
            $surcharge += $obj->surcharge*$surchargeAmount;
        }//耗材附加费
        $flip = array_flip($units);
        $exe = function ($package,$index,$partMoney,$startNumber,$rule)use($columnMapping,$flip,$surcharge,$surchargeAmount,$obj,$units){
            $details = $package["fee_info"] ?? []; //获取在匹配过程中记录的费用,例：零头费
            $fee_description = $details ? "箱装包含零头附加费" : '';
            $details[] = [
                "name"      => "单价",
                "amount"    => $package[$columnMapping[8]],
                "price"     => $package["price"],
                "unit_id"   => $package["unitId"] ?? $flip["件"],
            ];
            if ($index==0){
                if ($surcharge){
                    $details[] = [
                        "name"      => "耗材附加费",
                        "amount"    => $surchargeAmount,
                        "price"     => $obj->surcharge,
                        "unit_id"   => $obj->surcharge_unit_id,
                    ];
                    $fee_description .= ",包含耗材附加费".$surcharge."元";
                    $partMoney += $surcharge;
                }
                if ($startNumber){
                    $details[] = [
                        "name"      => "起步费",
                        "amount"    => $startNumber,
                        "price"     => $rule->unit_price,
                        "unit_id"   => $rule->unit_id,
                    ];
                    $fee_description .= ",包含起步费({$startNumber}/{$units[$rule->unit_id]})".$rule->unit_price."元";
                    $partMoney += $rule->unit_price;
                }
            }else if ($startNumber) $fee_description .= "数量被起步数平摊";
            $GLOBALS["FEE_INFO"][] = [
                "commodity_id"  => $package["commodity_id"] ?? 0,
                "total_fee"     => $partMoney,
                "tax_rate"      => 0,
                "fee_description"  => ltrim($fee_description,","),
                "details" => $details
            ];
        };
        foreach ($obj->items as $rule){
            if ($result)$rule->unit_price = explode(",",$rule->discount_price)[key($result)]; //满足满减条件，单价调整为满减单价

            if ($rule->strategy=='起步'){
                $startNumber = $rule->amount;
                $money = 0;
                if ($startNumber){ //起步数存在 重设数量
                    $money = $rule->unit_price;
                    $matchObject=$this->settingCount($matchObject,$columnMapping[8],$startNumber,$rule->unit_id);
                }
                //费用计算
                if ($matchObject)foreach ($matchObject as $index=>$package){
                    if (!isset($package["price"]))$package["price"] = 0;
                    $partMoney = $package[$columnMapping[8]] * $package["price"];
                    $money += $partMoney;
                    $exe($package,$index,$partMoney,$startNumber,$rule); //向信息提取器输入信息
                }
                //起步费存在 验证重设
                if (!$startNumber && $money<$rule->unit_price){
                    $diffMoney = $rule->unit_price-$money;
                    if ($GLOBALS["FEE_INFO"]){
                        $msg = "低于起步费".$rule->unit_price."元,加收差费".$diffMoney;
                        $GLOBALS["FEE_INFO"][0]["fee_description"] .= $GLOBALS["FEE_INFO"][0]["fee_description"] ?
                            $GLOBALS["FEE_INFO"][0]["fee_description"].",".$msg : $msg;
                        $GLOBALS["FEE_INFO"][0]["details"][] = [
                            "name"      => "起步费补差",
                            "amount"    => 1,
                            "price"     => $diffMoney,
                            "unit_id"   => $flip["单"],
                        ];
                    }
                    $money += $diffMoney;
                }
                return $money+$surcharge+$oddMoney;
            }
            foreach ($matchObject as &$package){
                if (isset($package["price"]))continue; //单价存在 跳过
                if (!isset($units[$rule->unit_id]))return -3;//单位未知 跳出
                if ($rule->strategy=='特征'){
                    $package[$columnMapping[10]] = $total; //设置一个不存在的总数进入原对象
                    if (!app("FeatureService")->matchFeature($rule->feature,$columnMapping,$package)) continue;
                }
                $package["price"] = $rule->unit_price;
                $package["unitId"] = $rule->unit_id;
                $package["fee_info"] = [];
                //单位转换 数量匹配
                switch ($units[$rule->unit_id]){
                    case "箱"://为箱时同步商品寻找箱规并改变商品数量
                        $pack = $this->changeUnit($ownerId,$package[$columnMapping[9]]);
                        if ($pack<=0)return $pack;
                        if ($rule->odd_price){
                            $amount = $package[$columnMapping[8]];
                            $odd = $amount%$pack;
                            $amount = floor($amount/$pack);
                            $oddMoney += $rule->odd_price * $odd; //零头附加费
                            $package["fee_info"][] = [
                                "name"      => "零头附加费",
                                "amount"    => $odd,
                                "price"     => $rule->odd_price,
                                "unit_id"   => $flip["件"],
                            ];
                        }else $amount = ceil($package[$columnMapping[8]]/$pack);
                        if ($amount<0)return $amount;
                        $package[$columnMapping[8]] = $amount;
                        break;
                    case "m³":
                        $package[$columnMapping[8]] = $package["bulk"] ?? 0;
                        break;
                    case "kg":
                        $package[$columnMapping[8]] = $package["weight"] ?? 0;
                        break;
                    case "T":
                        $package[$columnMapping[8]] = ($package["weight"]/1000) ?? 0;
                        break;
                }
            }
        }
        $money = $surcharge+$oddMoney;
        foreach ($matchObject as $index=>$mo){
            if (!isset($mo["price"]))$mo["price"] = 0;
            $partMoney = $mo[$columnMapping[8]] * $mo["price"];
            $money += $partMoney;
            $exe($mo,$index,$partMoney,0,null);
        }
        return $money ?: -7;
    }

    /**
     * 设置封顶费
     *
     * @param $rule
     * @param $money
     * @param $taxRate
     * @param $units
     * @return double
     */
    private function settingMaxFee($rule,$money,$taxRate,$units):float
    {
        if ($rule->max_fee&&$money>$rule->max_fee){
            $money = $rule->max_fee;//封顶费
            foreach ($GLOBALS["FEE_INFO"] as $index=>$info){
                foreach ($GLOBALS["FEE_INFO"][$index]["details"] as &$item)$item["price"] = 0;
                $GLOBALS["FEE_INFO"][$index]["tax_rate"] = $taxRate;
                if ($index==0){
                    $GLOBALS["FEE_INFO"][$index]["total_fee"] = $rule->max_fee;
                    $GLOBALS["FEE_INFO"][$index]["fee_description"] = "订单费用超出封顶费,封顶费:".$rule->max_fee
                        ."(详：".$GLOBALS["FEE_INFO"][$index]["fee_description"].")";
                    $GLOBALS["FEE_INFO"][$index]["details"][] = [
                        "name"      => "封顶费",
                        "amount"    => 1,
                        "price"     => $rule->max_fee,
                        "unit_id"   => array_flip($units)["单"],
                    ];
                }else{
                    $GLOBALS["FEE_INFO"][$index]["total_fee"] = 0;
                    $GLOBALS["FEE_INFO"][$index]["fee_description"] = "封顶费平摊"
                        ."(详：".$GLOBALS["FEE_INFO"][$index]["fee_description"].")";
                }
            }
        }
        return $money;
    }
    //递归式重新设置数量 只设置单位匹配对象
    private function settingCount($packages,$amountColumn,$startNumber,$unitId)
    {
        if (!$packages) return null;
        $maxPrice = 0;
        foreach ($packages as $i => $package){
            if ($package[$amountColumn] <= 0){$package["price"] = 0;$packages[$i]["price"] = 0;continue;}
            if (!isset($package["price"])){$package["price"] = 0;$packages[$i]["price"] = 0;}
            if (isset($package["unitId"]) && $package["unitId"]!=$unitId)continue;//单位不一致 跳过
            if ($package["price"] > $maxPrice || ($package["price"]==0 && $maxPrice==0)){$maxPrice = $package["price"];$index = $i;}
        }
        if (!isset($index))return $packages;
        if ($packages[$index][$amountColumn] >= $startNumber){
            $packages[$index][$amountColumn] -= $startNumber;
            return $packages;
        }else{
            $startNumber -= $packages[$index][$amountColumn];
            $packages[$index]["price"] = 0;
            $this->settingCount($packages,$amountColumn,$startNumber,$unitId);
        }
        return $packages;
    }

    /**
     * 处理历史账单
     *
     * @param Model|\stdClass $rule
     * @param int $owner
     * @param int $discountIndex
     * @param \stdClass|object $pivot
     */
    public function handlePastBill($rule, int $owner, int $discountIndex, $pivot)
    {
        DB::beginTransaction();
        try{
            $month = date("Y-m");
            $day = date("t",strtotime($month));
            $query = OwnerFeeDetail::query()->where("owner_id",$owner)->whereBetween("worked_at",[$month."-01",$month."-".$day]);
            $units = app("UnitService")->getUnitMapping(["件","单","箱","m³","T","kg"],true); //获取单位映射集
            $taxRate = app("OwnerService")->getTaxRateFee($rule, $owner);//获取税率
            $exe = function ($mapping,$object,$detail)use($rule,$units,$owner,$discountIndex,$taxRate,$pivot){
                $GLOBALS["FEE_INFO"] = [];
                if (!$rule->total_price){
                    $money = $this->matchItem($rule,$mapping,$object,$units,$owner,[$discountIndex=>$pivot->target_value ?? true]);
                    $money = $this->settingMaxFee($rule,$money,$taxRate,$units);
                } else{
                    $money = explode(",",$rule->total_discount_price)[$discountIndex];//按单计价存在，直接返回单总价或减免总价
                    $arr = $this->resetChildNodeMapping($mapping->toArray(),$object);
                    if ($arr)$this->extractInfo($arr,$money,[$discountIndex=>$pivot->target_value ?? true],array_flip($units),$taxRate);
                }
                if ($money>0){ //重置
                    $detail->update(["work_fee"=>$money,"work_tax_fee"=>$taxRate ? ($money*($taxRate/100)) : null]);
                    app("StoreService")->clearFeeInfo($detail->operation_bill);
                    app("StoreService")->constructFeeInfo([
                        "worked_at" => $detail->worked_at,
                        "owner_id" => $detail->owner_id,
                        "model_id"  => $rule->id,
                        "source_number"=> null,
                        "doc_number"   => $detail->operation_bill,
                        "commodity_id" => 0,
                        "total_fee"    =>0,
                        "tax_rate"     =>0,
                        "fee_description"=>'',
                    ]);
                }
                else $this->push(__METHOD__."->".__LINE__,"处理历史即时账单时发生匹配错误","账单主键：".$detail->id."; 错误代码".$money.";参数列表:".json_encode(array($rule, $owner, $discountIndex)));
            };
            if ($rule->operation_type=='入库'){
                foreach ($query->with(["store.storeItems.commodity","store.warehouse"])
                             ->where("outer_table_name",'stores')->get() as $detail)
                    $exe(Feature::MAPPING["store"],$detail->store,$detail);
            }else{
                foreach ($query->with(["order.logistic","order.shop","order.packages.commodities.commodity","order.batch"])
                             ->where("outer_table_name",'orders')->get() as $detail)
                    $exe(Feature::MAPPING["order"],$detail->order,$detail);
            }
            DB::commit();
        }catch (\Exception $e){
            DB::rollBack();
            //处理失败回退标记
            DB::update(DB::raw("UPDATE owner_price_operation_owner SET discount_date = ?,target_value = ? WHERE  owner_price_operation_id = ? AND owner_id = ?"),
                [$pivot->discount_date,$pivot->target_value,$rule->id,$owner]);
            $this->push(__METHOD__."->".__LINE__,"处理历史即时账单时发生系统错误","计费模型主键：".$rule->id."; 错误信息".$e->getMessage().";参数列表:".json_encode(array($rule, $owner, $discountIndex,$pivot)));
        }
    }
}