baoshi-was/app/Services/LaborApplyService.php

<?php

namespace App\Services;

use App\LaborCompany;
use App\LaborCompanyDispatch;
use App\Traits\ServiceAppAop;
use App\LaborApply;
use App\Warehouse;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Support\Carbon;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\DB;
use function DeepCopy\deep_copy;

class LaborApplyService
{
    //超时时间 默认为19：00
    const TIME_OUT_HOUR = 18;
    const LABOR_APPLY_STATUS = 'LABOR_APPLY_STATUS';
    //上次次临时工申请分配的时间
    const  LATELY_LABOR_COMPANY_DISPATCH_CREATED_AT = 'LATELY_LABOR_COMPANY_DISPATCH_CREATED_AT';
    const LABOR_APPLY_STATUS_TTL = 60 * 30;
    //到岗日期是申请日期的前一天 为保证数据正确 计算实际人数的时间为到岗日期的后一天 故时间为2
    const CALCULATION_ARRIVED_MAN_NUM_DEFAULT_SUB_DAYS = 2;
    //临时工工作时长最小值 低于这个时间的不计入
    const CALCULATION_ARRIVED_MAN_NUM_MIN_ONLINE_DURATION = 1;
    use ServiceAppAop;

    protected $modelClass = LaborApply::class;

    /**
     * 获取预约开放状态
     *
     * @return int 1 开放 2 禁止 3 临时开放
     */
    public function getCanCreateStatus(): int
    {
        $can_create_status = (now()->lte(now()->startOfDay()->addHours(self::TIME_OUT_HOUR))) ? LaborApply::CAN_CREATE_STATUS_OPEN : LaborApply::CAN_CREATE_STATUS_FORBID;
        if (Cache::has(self::LABOR_APPLY_STATUS)) {
            $can_create_status = Cache::get(self::LABOR_APPLY_STATUS);
        }
        return $can_create_status;
    }

    /**
     * 设置预约开放状态 1 开放 2 禁止 3 临时开放
     * @param int $status
     */
    public function setCanCreateStatus(int $status)
    {
        Cache::put(self::LABOR_APPLY_STATUS, $status, self::LABOR_APPLY_STATUS_TTL);
    }

    public function allocationAppendLaborToLaborCompany()
    {
        $lately_allocation_at = Cache::get(self::LATELY_LABOR_COMPANY_DISPATCH_CREATED_AT);
        $labor_applies = LaborApply::query()
            ->where('created_at', '>=', $lately_allocation_at)
            ->get();
    }

    /**
     * 生产劳务派遣报表
     *
     * 查询全部仓库
     * 遍历仓库
     * 按照仓库，查询当日的的申请，将申请的男女工分别加和
     * 按照仓库查询对应的劳务所 按照优先级排序
     * 将男女工之和依次分配到 劳务所
     * 如果分配完成后 发现还有剩下的 则将状态设置为2
     * @param bool $isAppend
     * @return array
     */
    public function allocationLaborToLaborCompany(bool $isAppend=false): array
    {
        //当前时间小于 1.00 禁止生成数据
        if (now()->lte(now()->startOfDay()->addHours(1))) return ['success' => false, 'error_message' => '当前时间禁止生成临时工派遣数据'];
        //上次分配时间 默认为前一天的18:00
        $lately_allocation_at = now()->subDay()->startOfDay()->addHours(self::TIME_OUT_HOUR);
        //缓存中有上次的同步时间
        if (Cache::has(self::LATELY_LABOR_COMPANY_DISPATCH_CREATED_AT)) {
            $lately_allocation_at = Cache::get(self::LATELY_LABOR_COMPANY_DISPATCH_CREATED_AT);
        }
        //派遣日期 为报表生成日期的后一天
        $dispatch_date = now()->addDay()->startOfDay()->toDateTimeString();

        //查询全部仓库
        $warehouses = Warehouse::all();
        //给每个仓库计算分配数据 更改申请状态为指派成功
        foreach ($warehouses as $warehouse) {
            //查询当日的的申请，将申请的男女工分别加和
            $builder = DB::table('labor_applies')
                ->selectRaw("sum(man_num) as man_num ,sum(woman_num) as woman_num")
                ->whereBetween('created_at', [now()->startOfDay(), now()->endOfDay()])
                ->where('warehouse_id', $warehouse->id);
            //如果是追加模式
            if ($isAppend) {
                //只查询最后一次分配后的申请
                $builder->where('created_at', '>=', $lately_allocation_at);
            }
            $apply_man_nums = $builder
                ->groupBy('warehouse_id')
                ->first();
            if (empty($apply_man_nums)) continue;
            //按照仓库查询对应的劳务所 按照优先级排序 单号正序 双号逆序
            $companies = $this->getCompaniesOrderByDay($warehouse);
            //需要的男工人数
            $man_num = $apply_man_nums->man_num;
            //需要的女工人数
            $woman_num = $apply_man_nums->woman_num;
            //插入的分配数据
            $laborCompanyDispatchInsertArray = $this->buildLaborCompanyDispatchInsertArray($companies, $man_num, $woman_num, $dispatch_date);
            //插入分配数据
            LaborCompanyDispatch::query()->insert($laborCompanyDispatchInsertArray);

            LaborApply::query()
                ->whereBetween('created_at', [now()->startOfDay(), now()->endOfDay()])
                ->where('warehouse_id', $warehouse->id)
                ->update([
                    'status' => 2,//指派成功
                ]);
        }
        //保存分配时间为当前时间
        Cache::put(self::LATELY_LABOR_COMPANY_DISPATCH_CREATED_AT, now());
        return ['success' => true, 'message' => '生成临时工派遣数据成功'];
    }

    /**
     * 设置为状态为溢出
     * @param array $laborCompanyAppliesTarget
     * @return array
     */
    private function setExceedMaxLaborNumStatusExceedMaxLaborNum(array $laborCompanyAppliesTarget): array
    {
        return array_map(function (&$item) {
            $item['exceed_max_labor_num_status'] = LaborCompanyDispatch::EXCEED_MAX_LABOR_NUM;
            return $item;
        }, $laborCompanyAppliesTarget);
    }

    /**
     * 构建插入的分配数据
     * @param $companies
     * @param $man_num
     * @param $woman_num
     * @param string $dispatch_date
     * @return array
     */
    private function buildLaborCompanyDispatchInsertArray($companies, $man_num, $woman_num, string $dispatch_date): array
    {
        $laborCompanyDispatchInsertArray = [];
        //遍历劳务公司
        foreach ($companies as $company) {
            if ($man_num > 0 || $woman_num > 0) {
                //分配给指定劳务的男工人数
                $dispatch_man_num = $man_num > $company->man_num ? $company->man_num : $man_num;
                //分配给指定劳务的女工人数
                $dispatch_woman_num = $woman_num > $company->woman_num ? $company->woman_num : $woman_num;
                //待分配的男工
                $man_num -= $dispatch_man_num;
                //待分配的女工
                $woman_num -= $dispatch_woman_num;
                $laborCompanyDispatchInsertArray[] = [
                    'labor_company_id' => $company->id,
                    'man_num' => $dispatch_man_num,
                    'woman_num' => $dispatch_woman_num,
                    'dispatch_date' => $dispatch_date,
                    'exceed_max_labor_num_status' => LaborCompanyDispatch::NOT_EXCEED_MAX_LABOR_NUM,//没有超限额
                    'status' => 1,//创建
                ];
            }

        }
        //全部劳务公司分配完后 还有剩余的男工/女工
        if ($man_num > 0 || $woman_num > 0) {
            //设置状态为超额
            $laborCompanyDispatchInsertArray = $this->setExceedMaxLaborNumStatusExceedMaxLaborNum($laborCompanyDispatchInsertArray);
        }
        return $laborCompanyDispatchInsertArray;
    }

    /**
     * 按照仓库查询对应的劳务所 按照优先级排序 单号正序 双号逆序
     * @param $warehouse
     * @return Builder[]|Collection
     */
    private function getCompaniesOrderByDay($warehouse)
    {
        $builder = LaborCompany::query()
            ->where('warehouse_id', $warehouse->id);
        if (now()->day % 2 === 0) {
            $builder->orderBy('priority');
        } else {
            $builder->orderBy('priority', 'desc');
        }
        return $builder->get();
    }

    /**
     * 按照给定的申请日期计算到岗人数
     *
     * 查询指定日期的 每个小组的申请人数
     * 遍历申请数据
     *      根据申请数据的仓库小组id，日期（申请日期后一天）查询打卡数据，计算人数之和 更新申请表actual_num
     * @param Carbon|null $apply_date
     */
    public function calculationArrivedManNum(Carbon $apply_date = null)
    {
        //查询的申请日期
        if (empty($apply_date)) {
            $apply_date = now()->subDays(self::CALCULATION_ARRIVED_MAN_NUM_DEFAULT_SUB_DAYS);
        }
        //查询指定日期的 每个小组的申请人数
        $laborApplies = DB::table('labor_applies')
            ->selectRaw('user_workgroup_id as user_workgroup_id , sum(man_num + woman_num) as apply_num , warehouse_id')
            ->whereDate('created_at', $apply_date->toDateString())
            ->groupBy('user_workgroup_id','warehouse_id')
            ->get();
        //根据申请数据的仓库小组id，日期（申请日期后一天）
        $check_in_at = deep_copy($apply_date)->addDay()->toDateString();
        //遍历申请数据
        foreach ($laborApplies as $laborApply) {
            //查询打卡数据，计算人数之和
            $arrived_num =
                DB::table('labor_reports')
                    ->selectRaw("count( DISTINCT 'identity_number',identity_number) as num")//根据身份证号去重防止重复入组

                    ->where('user_workgroup_id', $laborApply->user_workgroup_id)
                    ->whereDate('check_in_at', $check_in_at)
                    ->where('online_duration', '>=', self::CALCULATION_ARRIVED_MAN_NUM_MIN_ONLINE_DURATION)
                    ->first()->num;
            //更新申请表actual_num
            LaborApply::query()
                ->whereDate('created_at', deep_copy($apply_date)->toDateString())
                ->where('user_workgroup_id', $laborApply->user_workgroup_id)
                ->update([
                    'actual_num' => $arrived_num,
                    'status' => 4,//任务完结
                ]);
        }
        //根据分配时间完结任务  $check_in_at：实际入场日期 就是 dispatch_date
        LaborCompanyDispatch::query()
            ->whereDate('dispatch_date', $check_in_at)
            ->update([
                'status' => 4//任务完结
            ]);
    }
}