baoshi-was/app/Services/NewOrderCountingRecordService.php

<?php


namespace App\Services;


use App\Order;
use App\OrderCountingRecord;
use App\User;
use Carbon\Carbon;
use Illuminate\Support\Facades\Cache;

class NewOrderCountingRecordService
{
    public function orderCountingRecords($start, $end, $unit, $ownerIds)
    {
        $key = 'orderCountingRecords_' . $start . '_' . $end . '_' . $unit . '_' . json_encode($ownerIds);
        $queryCondition = $this->transfersToCondition($start, $end, $unit, $ownerIds);
        return cache()->remember($key, 600, function () use ($queryCondition) {
            return $this->getOrderCountingRecords($queryCondition);
        });
    }


    public function getCountingOwnerIds($ownerIds = null): array
    {

        $user = auth()->user();
        /** @var UserService $userService */
        $userService = app('UserService');
        $permittingOwnerIds = $userService->getPermittingOwnerIds($user);
        if (!$ownerIds) {
            return $permittingOwnerIds;
        }
        return Cache::remember(
            'PermittingOwnerIds' . '_' . auth()->user()->id . '_' . implode('_', $ownerIds),
            600, function () use ($ownerIds, $permittingOwnerIds) {
            /** @var User $user */
            return array_intersect($ownerIds, $permittingOwnerIds);
        });
    }

    public function getFromCache($queryCondition)
    {
        $lackingCondition = [];
        $orderCountingRecords_FromCache = collect();
        $lackingCondition['unit'] = $queryCondition['unit'];
        foreach ($queryCondition['data'] as $dateStr => $ownerIds) {
            foreach ($ownerIds as $ownerId) {
                $key = 'order_counting_records_' . $dateStr . '_' . $ownerId . '_' . $queryCondition['unit'];
                $items = cache()->get($key);
                if (empty($items)) {
                    if (empty($lackingCondition['data'][$dateStr])) {
                        $lackingCondition['data'][$dateStr] = [];
                    }
                    $lackingCondition['data'][$dateStr][] = $ownerId;
                } else {
                    $orderCountingRecords_FromCache = $orderCountingRecords_FromCache->concat($items);
                }
            }
        }
        return ['orderCountingRecords_FromCache' => $orderCountingRecords_FromCache,
            'lackingCondition' => $lackingCondition];
    }

    public function dataFromMiddleTable($queryCondition)
    {
        $result = [];
        $orderSqlBuilder = OrderCountingRecord::query();
        $unit = $queryCondition['unit'];
        foreach ($queryCondition as $date => $owners) {
            $orderSqlBuilder->orWhere(function ($query) use ($owners, $date, $unit) {
                $query->whereIn('owner_id', $owners)->where('date_target', $date)->where('counting_unit', $unit);
            });
        }
        $dataFromMiddleTable = $orderSqlBuilder->get();
        $this->insertIntoCache($dataFromMiddleTable, $unit);

        $queryCondition = $this->unQueryCondition($dataFromMiddleTable, $queryCondition);
        $result['unQueryCondition'] = $queryCondition;
        $result['dataFromMiddleTable'] = $dataFromMiddleTable;
        return $result;
    }

    public function getOrderCountingRecords($queryCondition)
    {

        list($orderCountingRecords_fromCache, $lackingCondition)
            = $this->getFromCache($queryCondition);
        if (empty($lackingCondition['data'])) {
            return $orderCountingRecords_fromCache;
        }

        list($orderCountingRecords_fromSelfTable, $lackingCondition)
            = $this->dataFromMiddleTable($lackingCondition);

        if (empty($lackingCondition['data'])) {
            return $orderCountingRecords_fromCache->concat($orderCountingRecords_fromSelfTable);
        }
        list($orderCountingRecords_combinedByLower, $lackingCondition)
            = $this->getByLowerUnit($lackingCondition);

        $orderCountingRecords_FromOrder = $this->dataFromOrder($lackingCondition);

        return $orderCountingRecords_FromOrder
            ->concat($orderCountingRecords_fromCache)
            ->concat($orderCountingRecords_fromSelfTable)
            ->concat($orderCountingRecords_combinedByLower);
    }


    public function getByLowerUnit($queryCondition)
    {
        switch ($queryCondition['unit']) {
            case '年':
                break;
            case '月':
                break;
            case '周':
                $conditionClone = ['unit' => '日', 'data' => collect([])];
                foreach ($queryCondition['data'] as $date => $ownerIds) {
                    $startAt = $date;
                    $endAt = Carbon::parse($date)->endOfWeek()->toDateString();
                    $conditionClone['data']->concat(
                        $this->transfersToCondition(
                            $startAt, $endAt, $queryCondition['unit'], $ownerIds
                        )['data']
                    );
                }
                $conditionClone['data'] = $conditionClone['data']->toArray();
                $orderCountingRecords_days = $this->getOrderCountingRecords($conditionClone);
                $orderCountingRecords_combinedByLower = $this->turnDaysToWeeks($orderCountingRecords_days);
                break;
            case '日':
                return [[], $queryCondition];
            default:
        }
        return [$orderCountingRecords_combinedByLower, []];
    }

    public function transfersToCondition($start, $end, $unit, $ownerIds)
    {
        $condition = [
            'data' => [],
            'unit' => $unit,];
        $startAt = Carbon::parse($start);
        $dates = [];
        switch ($unit) {
            case '年':
                $dates = collect($startAt->yearsUntil($end, 1)->toArray())
                    ->map(function (Carbon $date) {
                        return $date->firstOfYear();
                    });
                break;
            case '月':
                $dates = collect($startAt->monthsUntil($end, 1)->toArray())
                    ->map(function (Carbon $date) {
                        return $date->firstOfMonth();
                    });
                break;
            case '周':
                $dates = collect($startAt->weeksUntil($end, 1)->toArray())
                    ->map(function (Carbon $date) {
                        return $date->startOfWeek();
                    });
                break;
            case '日':
                $dates = collect($startAt->daysUntil($end, 1)->toArray())
                    ->map(function (Carbon $date) {
                        return $date->startOfDay();
                    });
                break;
            default:
        }

        foreach ($dates as $day) {
            $condition['data'][$day->toDateString()] = $ownerIds;
        }
        return $condition;
    }

    public function dataFromOrder($queryCondition)
    {
        $orderSqlBuilder = Order::query()->selectRaw("owner_id,warehouse_id,shop_id,logistic_id,count(1) as amounts ,DATE_FORMAT(created_at,'%Y-%m-%d') as date_target");
        foreach ($queryCondition['date'] as $dateStr => $ownerIds) {
            $orderSqlBuilder->orWhere(function ($query) use ($ownerIds, $dateStr) {
                $query->whereIn('owner_id', $ownerIds)->where('created_at', '>', $dateStr)->where('created_at', '<', Carbon::parse($dateStr)->addDay()->toDateString())->where('wms_status', '订单完成');
            });
        }
        $dataFromOrder = $orderSqlBuilder->groupBy(['owner_id', 'warehouse_id', 'shop_id', 'logistic_id', 'date_target'])->get();

        $dataFromMiddleTable = $this->ordersToOrderCountingRecords($dataFromOrder);
        $this->insertIntoMiddleTable($dataFromMiddleTable);
        $this->insertIntoCache($dataFromMiddleTable, $queryCondition['unit']);
        return $dataFromMiddleTable;
    }

    public function insertIntoMiddleTable($data)
    {
        $data->filter(function ($item) {
            return $this->isNotCurrentDate($item->date_target);
        })->chunk(1000)->each(function ($item) {
            OrderCountingRecord::query()->insert($item->toArray());
        });
    }

    public function insertIntoCache($collect, $unit)
    {
        $map = [];
        $collect->each(function ($order) use ($unit, &$map) {
            $key = "order_counting_records_{$order->date_target}_{$order->owner_id}_{$unit}";
            if (empty($map[$key])) $map[$key] = [];
            $map[$key][] = $order;
        });

        foreach ($map as $key => $orders) {
            $ttl = 3600 * 24;
            if (!$this->isNotCurrentDate($orders[0]['date_target'])) {
                $ttl = 70;
            }
            Cache::put($key, collect($orders), $ttl);
        }
    }

    public function isNotCurrentDate($dateStr): bool
    {
        return $dateStr != Carbon::now()->format('Y-m-d')
            && $dateStr != Carbon::now()->year . '-' . Carbon::now()->week
            && $dateStr != Carbon::now()->year . '-' . Carbon::now()->month;
    }


    public function unQueryCondition($dataFromMiddleTable, $unQueryCondition)
    {
        $map = [];
        $dataFromMiddleTable->each(function ($item) use (&$map) {
            $key = 'owner_id=' . $item->owner_id . ' date_target' . $item->date_target;
            $map[$key] = true;
        });
        foreach ($unQueryCondition as $dateStr => $ownerIds) {
            foreach ($ownerIds as $key => $ownerId) {
                $key1 = 'owner_id=' . $ownerId . ' date_target' . $dateStr;
                if (isset($map[$key1])) {
                    //中间表查找到数据
                    unset($unQueryCondition[$dateStr][$key]);
                }
            }
        }
        return $unQueryCondition;
    }


    public function ordersToOrderCountingRecords($dataFromOrder)
    {
        $dataFromMiddleTable = collect();
        //当日当周当月当年的数据不能插入到中间表
        $dateTime = Carbon::now()->toDateTimeString();
        foreach ($dataFromOrder as $order) {
            $carbon = Carbon::parse($order->date_target);
            $year = $carbon->year;
            $week = $carbon->week;
            $month = $carbon->month;
            $dataFromMiddleTable->push(new OrderCountingRecord([
                'owner_id' => $order->owner_id,
                'shop_id' => $order->shop_id,
                'warehouse_id' => $order->warehouse_id,
                'logistic_id' => $order->logistic_id,
                'date_target' => $order->date_target,
                'counting_unit' => $order->counting_unit,
                'amount' => $order->amounts,
                'week' => $year . '-' . $week,
                'month' => $year . '-' . $month,
                'year' => $year,
                'created_at' => $dateTime,
                'updated_at' => $dateTime,
            ]));
        }
        return $dataFromMiddleTable;
    }

    public function turnDaysToWeeks($orderCountingRecords_days)
    {
        $orderCountingRecords_combinedByLower = collect();

        $orderCountingRecords_days->groupBy('owner_id', 'shop_id', 'warehouse_id', 'logistic_id', 'week')->each(function ($ownerId, $ownerIds) use (&$orderCountingRecords_combinedByLower) {
            $ownerIds->each(function ($shopId, $shopIds) use (&$orderCountingRecords_combinedByLower) {
                $shopIds->each(function ($warehouseId, $warehouseIds) use (&$orderCountingRecords_combinedByLower) {
                    $warehouseIds->each(function ($logisticId, $logisticIds) use (&$orderCountingRecords_combinedByLower) {
                        $logisticIds->each(function ($week, $weeks) use (&$orderCountingRecords_combinedByLower) {
                            $orderCountingRecord = $weeks->first();
                            $orderCountingRecord->amount = $weeks->reduce(function ($carry, $item) {
                                return $carry + $item->amount;
                            });
                            $orderCountingRecords_combinedByLower->push($orderCountingRecord);
                        });
                    });
                });
            });
        });
        return $orderCountingRecords_combinedByLower;
    }

}