php/app/common/repositories/shared/SharedProsperityUserRepository.php

<?php

namespace app\common\repositories\shared;

use app\common\dao\shared\SharedProsperityUserDao;
use app\common\dao\user\UserDao;
use app\common\enum\CommonEnum;
use app\common\enum\shared\SharedProsperityRewardRecordEnum;
use app\common\enum\shared\SharedProsperityUserEnum;
use app\common\repositories\BaseRepository;
use app\common\repositories\store\order\StoreOrderRepository;
use app\entity\data\shared\SharedProsperityRecommendConfigEntity;
use app\entity\data\shared\SharedProsperityUserEntity;
use think\db\exception\DbException;

class SharedProsperityUserRepository extends BaseRepository
{

    protected $dao;

    /**
     * SharedProsperityUserRepository constructor.
     * @param SharedProsperityUserDao $dao
     */
    public function __construct(SharedProsperityUserDao $dao)
    {
        $this->dao = $dao;
    }

    /**
     * @param int $id
     * @return SharedProsperityUserEntity
     */
    public function getSharedProsperityUserEntityById(int $id): SharedProsperityUserEntity
    {
        $entityList = $this->getSharedProsperityUserEntityListByIdList([$id]);
        $entity = array_shift($entityList);
        if ($entity instanceof SharedProsperityUserEntity) {
            return $entity;
        } else {
            /** @var SharedProsperityUserEntity */
            return SharedProsperityUserEntity::newInstance();
        }
    }

    /**
     * @param array $idList
     * @return SharedProsperityUserEntity[]
     */
    public function getSharedProsperityUserEntityListByIdList(array $idList): array
    {
        return $this->dao->getSharedProsperityUserEntityListByIdList($idList);
    }

    /**
     * @param int $userId
     * @return SharedProsperityUserEntity
     */
    public function getSharedProsperityUserEntityByUserId(int $userId): SharedProsperityUserEntity
    {
        $entityList = $this->getSharedProsperityUserEntityListByUserIdList([$userId]);
        $entity = array_shift($entityList);
        if ($entity instanceof SharedProsperityUserEntity) {
            return $entity;
        } else {
            /** @var SharedProsperityUserEntity */
            return SharedProsperityUserEntity::newInstance();
        }
    }

    /**
     * @param array $userIdList
     * @return SharedProsperityUserEntity[]
     */
    public function getSharedProsperityUserEntityListByUserIdList(array $userIdList): array
    {
        return $this->dao->getSharedProsperityUserEntityListByUserIdList($userIdList);
    }

    /**
     * 获取直接下级用户ID列表
     * @param int $parentId 用户ID
     * @return SharedProsperityUserEntity[] 直接下级用户ID列表
     */
    public function getSharedProsperityUserEntityListByParentId(int $parentId): array
    {
        return $this->dao->getSharedProsperityUserEntityListByParentId($parentId);
    }

    /**
     * @param array $userIdList
     * @return SharedProsperityUserEntity[]
     */
    public function getSharedProsperityUserEntityMapByUserIdList(array $userIdList): array
    {
        $sharedProsperityUserEntityList = $this->dao->getSharedProsperityUserEntityListByUserIdList($userIdList);
        /** @var SharedProsperityUserEntity[] $sharedProsperityUserEntityMapByUserId */
        $sharedProsperityUserEntityMapByUserId = array_column($sharedProsperityUserEntityList, null, 'userId');
        return $sharedProsperityUserEntityMapByUserId;
    }

    public function create($data)
    {
        return $this->dao->create($data);
    }

    /**
     * @param SharedProsperityUserEntity $sharedProsperityUserEntity
     * @return SharedProsperityUserEntity
     */
    public function createByEntity(SharedProsperityUserEntity $sharedProsperityUserEntity): SharedProsperityUserEntity
    {
        $result = $this->create($sharedProsperityUserEntity->toUnderlineArray())->toArray();
        /** @var SharedProsperityUserEntity $entity */
        $entity = SharedProsperityUserEntity::newInstance($result);
        return $entity;
    }

    /**
     * @param $id
     * @param $data
     * @return int
     */
    public function update($id, $data): int
    {
        try {
            return $this->dao->update($id, $data);
        } catch (DbException $e) {
            return 0;
        }
    }

    public function updateByUserId($userId, $data): int
    {
        try {
            return $this->dao->updateByUserId($userId, $data);
        } catch (DbException $e) {
            return 0;
        }
    }

    /**
     * @param SharedProsperityUserEntity $sharedProsperityUserEntity
     * @return SharedProsperityUserEntity
     */
    public function updateByEntity(SharedProsperityUserEntity $sharedProsperityUserEntity): SharedProsperityUserEntity
    {
        if (empty($sharedProsperityUserEntity->getId())) {
            return SharedProsperityUserEntity::newInstance();
        }
        $result = $this->update($sharedProsperityUserEntity->getId(), $sharedProsperityUserEntity->toUnderlineArray());
        if ($result > 0) {
            return $this->getSharedProsperityUserEntityById($sharedProsperityUserEntity->getId());
        }
        return SharedProsperityUserEntity::newInstance();
    }

    /**
     * 绑定 上级
     * @param int $userId
     * @param int $parentId
     * @return bool
     */
    public function bindParentId(int $userId, int $parentId): bool
    {
        $sharedProsperityUserEntity = $this->getSharedProsperityUserEntityByUserId($userId);
        if (empty($sharedProsperityUserEntity->getUserId())) {
            return false;
        }
        $sharedProsperityUserEntityByParentId = $this->getSharedProsperityUserEntityByUserId($parentId);
        if (empty($sharedProsperityUserEntityByParentId->getUserId())) {
            return false;
        }
        $sharedProsperityUserEntity = $this->updateByEntity($sharedProsperityUserEntity->setParentId($sharedProsperityUserEntityByParentId->getUserId()));
        if (empty($sharedProsperityUserEntity->getId())) {
            return false;
        }
        return true;
    }

    /**
     * 获取直推用户列表，并计算每个直推用户的团队总人数和团队总业绩（包含自己）
     * 返回三个列表：全部直推、大部门（团队业绩最大的直推用户）、小部门（其余直推用户）
     * 同时返回统计数据：我的部门总人数、总业绩、小部门业绩总和、大部门业绩总和
     * @param int $userId
     * @return array
     */
    public function getTeam(int $userId): array
    {
        // 获取直推用户
        $list = $this->dao->getDirectByUserId($userId);
        if (empty($list)) {
            // 没有直推用户，仍然返回统计数据（我的部门总人数和总业绩）
            $myTeamUserIds = $this->dao->getAllSubordinateUserIds($userId);
            $myTeamTotalCount = count($myTeamUserIds);
            $myTeamPvSum = $this->dao->getTeamPvSumWithSelf($userId);
            return [
                'all_direct' => [],
                'big_department' => [],
                'small_department' => [],
                'stats' => [
                    'my_team_total_count' => $myTeamTotalCount,
                    'my_team_pv_sum' => $myTeamPvSum,
                    'small_department_pv_sum' => 0,
                    'big_department_pv_sum' => 0,
                ]
            ];
        }
        // 收集所有直推用户ID
        $userIds = array_column($list, 'user_id');
        // 获取用户详细信息（昵称、头像、注册时间）
        /** @var UserDao $userDao */
        $userDao = app()->make(UserDao::class);
        $userEntities = $userDao->getUserEntityListByUidList($userIds);
        $userMap = [];
        foreach ($userEntities as $userEntity) {
            $userMap[$userEntity->getUid()] = [
                'nickname' => $userEntity->getNickname(),
                'avatar' => $userEntity->getAvatar(),
                'create_time' => $userEntity->getCreateTime(),
            ];
        }
        // 计算每个直推用户的团队总人数和团队总业绩
        $maxPv = 0;
        $maxPvIndex = -1;
        foreach ($list as $index => &$item) {
            $teamUserIds = $this->dao->getAllSubordinateUserIds($item['user_id'],false,4);
            $teamTotalCount = count($teamUserIds);
            $teamPvSum = $this->dao->getTeamPvSum($item['user_id'],4);
            $item['team_total_count'] = $teamTotalCount;
            $item['team_pv_sum'] = $teamPvSum;
            // 补充用户信息
            if (isset($userMap[$item['user_id']])) {
                $item['nickname'] = $userMap[$item['user_id']]['nickname'];
                $item['avatar'] = $userMap[$item['user_id']]['avatar'];
                $item['create_time'] = $userMap[$item['user_id']]['create_time'];
            } else {
                $item['nickname'] = '';
                $item['avatar'] = '';
                $item['create_time'] = '';
            }
            // 找出团队业绩最大的直推用户
            if ($teamPvSum > $maxPv) {
                $maxPv = $teamPvSum;
                $maxPvIndex = $index;
            }
        }
        unset($item);
        // 分割大部门和小部门
        $bigDepartment = [];
        $smallDepartment = [];
        if ($maxPvIndex >= 0) {
            $bigDepartment[] = $list[$maxPvIndex];
            foreach ($list as $index => $item) {
                if ($index !== $maxPvIndex) {
                    $smallDepartment[] = $item;
                }
            }
        } else {
            // 没有直推用户（理论上不会发生）
            $smallDepartment = $list;
        }
        // 计算统计数据
        $myTeamUserIds = $this->dao->getAllSubordinateUserIds($userId);
        $myTeamTotalCount = count($myTeamUserIds);
        $myTeamPvSum = $this->dao->getTeamPvSum($userId);
        $smallDepartmentPvSum = 0;
        foreach ($smallDepartment as $item) {
            $smallDepartmentPvSum += $item['team_pv_sum'];
        }
        $bigDepartmentPvSum = 0;
        foreach ($bigDepartment as $item) {
            $bigDepartmentPvSum += $item['team_pv_sum'];
        }
        return [
            'all_direct' => $list,
            'big_department' => $bigDepartment,
            'small_department' => $smallDepartment,
            'stats' => [
                'my_team_total_count' => $myTeamTotalCount,
                'my_team_pv_sum' => $myTeamPvSum,
                'small_department_pv_sum' => floor($smallDepartmentPvSum * 100) / 100,
                'big_department_pv_sum' => $bigDepartmentPvSum,
            ]
        ];
    }

    /**
     * 批量更新
     * @param $dataList
     * @return array
     */
    public function batchUpdateSharedProsperityUserDataByDataList($dataList): array
    {
        return $this->dao->saveAll($dataList);
    }

    /**
     * 用户身份升级
     * @param array $userIdList
     * @return void
     */
    public function identityUpgrade(array $userIdList)
    {
        if (empty($userIdList)) {
            return;
        }

        /** @var SharedProsperityRecommendConfigRepository $sharedProsperityRecommendConfigRepository */
        $sharedProsperityRecommendConfigRepository = app()->make(SharedProsperityRecommendConfigRepository::class);
        $sharedProsperityRecommendConfigEntityList = $sharedProsperityRecommendConfigRepository->getList();
        usort($sharedProsperityRecommendConfigEntityList, function (SharedProsperityRecommendConfigEntity $a, SharedProsperityRecommendConfigEntity $b) {
            return $a->getPv() <=> $b->getPv();  // 从小到大排序
        });

        $sharedProsperityUserEntityList = $this->getSharedProsperityUserEntityListByUserIdList($userIdList);

        // 批量更新用户等级
        $this->batchUpgradeUsers($sharedProsperityUserEntityList, $sharedProsperityRecommendConfigEntityList);

        // foreach ($sharedProsperityUserEntityList as $sharedProsperityUserEntity) {
        //     $partnerLevel = 0;
        //     foreach ($sharedProsperityRecommendConfigEntityList as $sharedProsperityRecommendConfigEntity) {
        //         if ($sharedProsperityUserEntity->getPv() >= $sharedProsperityRecommendConfigEntity->getPv()) {
        //             $partnerLevel = $sharedProsperityRecommendConfigEntity->getLevel();
        //         } else {
        //             // 如果本次验证的等级结果大于 之前的等级，说明用户升级了 需要更新等级
        //             if ($partnerLevel > $sharedProsperityUserEntity->getPartnerLevel()) {
        //                 $this->updateByEntity(
        //                     SharedProsperityUserEntity::newInstance()
        //                         ->setId($sharedProsperityUserEntity->getId())
        //                         ->setPartnerLevel($partnerLevel)
        //                 );
        //             }
        //             break;
        //         }
        //     }
        // }
    }

    /**
     * 批量更新用户等级
     * @param SharedProsperityUserEntity[] $sharedProsperityUserEntityList 用户实体列表
     * @param SharedProsperityRecommendConfigEntity[] $sharedProsperityRecommendConfigEntityList 等级配置列表
     * @return void
     */
    private function batchUpgradeUsers(array $sharedProsperityUserEntityList, array $sharedProsperityRecommendConfigEntityList)
    {
        foreach ($sharedProsperityUserEntityList as $sharedProsperityUserEntity) {

            // // 计算用户的团队业绩（向下5级）
            // $teamPv = $this->calculateTeamPv($sharedProsperityUserEntity->getId());

            // 根据团队业绩确定等级
            // $newLevel = $this->calculateLevelByTeamPv($teamPv, $sharedProsperityRecommendConfigEntityList);
            //
            // // 如果新等级大于当前等级，则更新
            // if ($newLevel > $sharedProsperityUserEntity->getPartnerLevel()) {
            //     $this->updateByEntity(
            //         SharedProsperityUserEntity::newInstance()
            //             ->setId($sharedProsperityUserEntity->getId())
            //             ->setPartnerLevel($newLevel)
            //     );
            // }

            $this->upgradeUpperLevels($sharedProsperityUserEntity->getUserId(), $sharedProsperityRecommendConfigEntityList);
        }
    }

    /**
     * 向上追溯更新上级身份等级（最多向上5层）
     * @param int $userId 当前用户ID
     * @param SharedProsperityRecommendConfigEntity[] $sharedProsperityRecommendConfigEntityList 等级配置列表
     * @return void
     */
    private function upgradeUpperLevels(int $userId, array $sharedProsperityRecommendConfigEntityList)
    {
        $maxLevels = SharedProsperityUserEnum::TEAM_DEPTH;
        $currentUserId = $userId;

        for ($i = 0; $i < $maxLevels; $i++) {
            // 获取上级用户ID
            $sharedProsperityUserEntity = $this->getSharedProsperityUserEntityByUserId($currentUserId);
            $parentId = $sharedProsperityUserEntity->getParentId();

            if (empty($parentId)) {
                break; // 没有上级，停止追溯
            }

            // 重新计算上级的团队业绩和等级
            $this->upgradeSingleUser($parentId, $sharedProsperityRecommendConfigEntityList);

            // 继续向上追溯
            $currentUserId = $parentId;
        }
    }

    /**
     * 升级单个用户身份
     * @param int $userId 用户ID
     * @param SharedProsperityRecommendConfigEntity[] $sharedProsperityRecommendConfigEntityList 等级配置列表
     * @return void
     */
    private function upgradeSingleUser(int $userId, array $sharedProsperityRecommendConfigEntityList)
    {
        // 获取用户实体
        $sharedProsperityUserEntity = $this->getSharedProsperityUserEntityByUserId($userId);

        if (empty($sharedProsperityUserEntity->getId())) {
            return;
        }

        // 计算团队业绩
        $teamPvMap = $this->calculateTeamPv($userId);

        // 当前只计算团队业绩的 小团队业绩
        $maxKey = array_keys($teamPvMap, max($teamPvMap))[0];
        unset($teamPvMap[$maxKey]);
        $teamPvBySmallSum = array_sum($teamPvMap);

        // 计算新等级
        $newLevel = $this->calculateLevelByTeamPv($teamPvBySmallSum, $sharedProsperityRecommendConfigEntityList);

        // 暂时新增加逻辑 用户购买 298 商品后，自动升级为1星合伙人，目前只有消费者 能够获得PV值，在奖励结算时，判断订单金额 是否大于 298 并且 用户身份为 用户，则升级为一星合伙人
        // 逻辑修改，如果用户的身份 是普通用户，则统计他在共富区内 所有消费的金额，是否超 每天自增的 升级限制金额，如果超过则升级为1星合伙人
        if ($sharedProsperityUserEntity->getPartnerLevel() == 0) {
            /** @var StoreOrderRepository $storeOrderRepository */
            $storeOrderRepository = app()->make(StoreOrderRepository::class);
            $sumTotalPrice = $storeOrderRepository->getSumTotalPriceByUidAndMerId($sharedProsperityUserEntity->getUserId(), CommonEnum::DESIGN_MERCHANT_ID['SharedProsperity']['code']);
            if (!empty($sumTotalPrice)) {
                /** @var SharedProsperityRecommendConfigRepository $sharedProsperityRecommendConfigRepository */
                $sharedProsperityRecommendConfigRepository = app()->make(SharedProsperityRecommendConfigRepository::class);
                $sharedProsperityRecommendConfigEntityList = $sharedProsperityRecommendConfigRepository->getList();
                usort($sharedProsperityRecommendConfigEntityList, function (SharedProsperityRecommendConfigEntity $a, SharedProsperityRecommendConfigEntity $b) {
                    return $a->getLevel() <=> $b->getLevel();  // 从小到大排序
                });
                foreach ($sharedProsperityRecommendConfigEntityList as $sharedProsperityRecommendConfigEntity) {
                    if (is_null($sharedProsperityRecommendConfigEntity->getConsume())) {
                        continue;
                    }
                    if ($sumTotalPrice >= $sharedProsperityRecommendConfigEntity->getConsume() && $newLevel < $sharedProsperityRecommendConfigEntity->getLevel()) {
                        $newLevel = $sharedProsperityRecommendConfigEntity->getLevel();
                    }
                }
            }
        }

        // 如果新等级大于当前等级，则更新
        if ($newLevel > $sharedProsperityUserEntity->getPartnerLevel()) {
            $this->updateByEntity(
                SharedProsperityUserEntity::newInstance()
                    ->setId($sharedProsperityUserEntity->getId())
                    ->setPartnerLevel($newLevel)
            );
        }
    }

    /**
     * 计算用户的团队业绩（向下5级）
     * @param int $userId 用户ID
     * @return array 团队业绩
     */
    private function calculateTeamPv(int $userId): array
    {
        $teamPvMap = [];

        // 获取所有下级用户ID（向下5级）
        // 第一层级在这里查询 因为要统计大小区
        $sharedProsperityUserEntityListByParentId = $this->getSharedProsperityUserEntityListByParentId($userId);

        // 循环 直属下级
        foreach ($sharedProsperityUserEntityListByParentId as $sharedProsperityUserEntityByUnderling) {
            $departmentTeamUserIdList = $this->getUserIdListByParentIdForDepth($sharedProsperityUserEntityByUnderling->getUserId(), SharedProsperityUserEnum::TEAM_DEPTH - 1);
            $departmentTeamUserIdList[] = $sharedProsperityUserEntityByUnderling->getUserId();

            // 直属团队的 业绩总和
            $teamPv = '0.00';
            if (!empty($departmentTeamUserIdList)) {
                // 批量获取下级用户的个人业绩并求和
                // 假设有方法批量获取用户的PV
                $sharedProsperityUserEntityListByTeam = $this->getSharedProsperityUserEntityListByUserIdList($departmentTeamUserIdList);
                foreach ($sharedProsperityUserEntityListByTeam as $sharedProsperityUserEntityByTeam) {
                    $teamPv = bcadd($teamPv, (string)$sharedProsperityUserEntityByTeam->getPv(), 2);
                }
            }
            $teamPvMap[$sharedProsperityUserEntityByUnderling->getUserId()] = $teamPv;
        }

        return $teamPvMap;
    }


    /**
     * 根据团队业绩计算等级
     * @param float $teamPv 团队业绩
     * @param array $configEntityList 等级配置列表
     * @return int 等级
     */
    private function calculateLevelByTeamPv(float $teamPv, array $configEntityList): int
    {
        $level = 0;

        foreach ($configEntityList as $configEntity) {
            if ($teamPv >= $configEntity->getPv()) {
                $level = $configEntity->getLevel();
            } else {
                break;
            }
        }

        return $level;
    }

    /**
     * 获取下级用户ID列表（向下指定层级）
     * @param int $parentId 用户ID
     * @param int $maxLevel 最大层级数
     * @param int $currentLevel 当前层级（内部递归使用）
     * @return array 下级用户ID列表
     */
    private function getUserIdListByParentIdForDepth(int $parentId, int $maxLevel, int $currentLevel = 1): array
    {
        if ($currentLevel > $maxLevel) {
            return [];
        }

        $subordinateIds = [];

        // 获取直接下级用户ID列表（假设有方法获取直接下级）
        $sharedProsperityUserEntityListByParentId = $this->getSharedProsperityUserEntityListByParentId($parentId);

        if (empty($sharedProsperityUserEntityListByParentId)) {
            return [];
        }

        // 添加直接下级
        $subordinateIds = array_merge($subordinateIds, array_column($sharedProsperityUserEntityListByParentId, 'userId'));

        // 递归获取下级的下级
        foreach ($sharedProsperityUserEntityListByParentId as $sharedProsperityUserEntity) {
            $nestedSubordinateIds = $this->getUserIdListByParentIdForDepth($sharedProsperityUserEntity->getUserId(), $maxLevel, $currentLevel + 1);
            if (!empty($nestedSubordinateIds)) {
                $subordinateIds = array_merge($subordinateIds, $nestedSubordinateIds);
            }
        }

        return array_unique($subordinateIds);
    }

    /**
     * 获取用户树
     * @param int $userId 用户ID
     * @return array 用户树，格式：[{name: '张三', parent: null, children: [...]}]
     */
    public function getUserTree($userId)
    {
        /** @var SharedProsperityUserDao $shareUserDao */
        $shareUserDao = app()->make(SharedProsperityUserDao::class);
        
        // 获取所有下级用户ID（包括自己）
        $subordinateIds = $shareUserDao->getAllSubordinateUserIds($userId, true);
        if (empty($subordinateIds)) {
            return [];
        }
        
        // 获取这些共富用户的基本信息（包含parent_id）
        $sharedUsers = $shareUserDao->getSharedProsperityUserEntityListByUserIdList($subordinateIds);

        if (empty($sharedUsers)) {
            return [];
        }

        // 用户身份
        $partnerLevel = [
            0 => '用户',
            1 => '一星合伙人',
            2 => '二星合伙人',
            3 => '三星合伙人',
            4 => '钻石合伙人',
            5 => '总裁合伙人',
            6 => '联席主席团',
        ];

        // 获取用户昵称映射
        $userIds = array_map(function ($entity) {
            return $entity->getUserId();
        }, $sharedUsers);
        /** @var UserDao $userDao */
        $userDao = app()->make(UserDao::class);
        $userInfos = $userDao->getUserEntityListByUidList($userIds);
        $idToName = [];
        foreach ($userInfos as $userInfo) {
            $sharedUserInfo = $shareUserDao->getSharedProsperityUserEntityListByUserIdList([$userInfo->getUid()]);
            $idToName[$userInfo->getUid()] = $userInfo->getNickname()  . '(' . $userInfo->account .')(身份：' . $partnerLevel[$sharedUserInfo[0]->getPartnerLevel()] . ')' ?? ('用户' . $userInfo->getUid());
        }
        
        // 构建节点数组
        $nodes = [];
        foreach ($sharedUsers as $sharedUser) {
            $nodes[] = [
                'user_id' => $sharedUser->getUserId(),
                'parent_id' => $sharedUser->getParentId(),
                'name' => $idToName[$sharedUser->getUserId()] ?? ('用户' . $sharedUser->getUserId()),
            ];
        }
        
        // 构建树，以传入的用户为根节点
        $rootNode = $this->findNode($nodes, $userId);
        if (!$rootNode) {
            return [];
        }
        $tree = [
            'name' => $rootNode['name'],
            'parent' => null,
            'children' => $this->buildSharedTree($nodes, $userId)
        ];
        return [$tree];
    }
    
    /**
     * 递归构建共富用户树
     * @param array $nodes 节点数组，每个节点包含 user_id, parent_id, name
     * @param int $parentId 父ID
     * @return array
     */
    private function buildSharedTree($nodes, $parentId)
    {
        $branch = [];
        foreach ($nodes as $node) {
            if ($node['parent_id'] == $parentId) {
                $children = $this->buildSharedTree($nodes, $node['user_id']);
                $branch[] = [
                    'name' => $node['name'],
                    'parent' => $this->findNodeName($nodes, $parentId) ?? null,
                    'children' => $children
                ];
            }
        }
        return $branch;
    }
    
    /**
     * 根据user_id查找节点名称
     * @param array $nodes
     * @param int $userId
     * @return string|null
     */
    private function findNodeName($nodes, $userId)
    {
        foreach ($nodes as $node) {
            if ($node['user_id'] == $userId) {
                return $node['name'];
            }
        }
        return null;
    }
    
    /**
     * 根据user_id查找节点
     * @param array $nodes
     * @param int $userId
     * @return array|null
     */
    private function findNode($nodes, $userId)
    {
        foreach ($nodes as $node) {
            if ($node['user_id'] == $userId) {
                return $node;
            }
        }
        return null;
    }

    public function adminList($params)
    {
        $page = $params['page'] ?? 1;
        $where = [];
        /** @var UserDao $userDao */
        $userDao = app()->make(UserDao::class);

        // 手机号搜索
        if (isset($params['account']) && $params['account']) {
            $userData = $userDao->accountByUser($params['account']);
            $uid = 0;
            if ($userData) {
                $uid = $userData->uid;
            }

            $where[] = ['user_id', '=', $uid];
        }

        // 昵称搜索
        if (isset($params['nickname']) && $params['nickname']) {
            $userData = $userDao->nicknameByUser($params['nickname']);
            $uid = 0;
            if ($userData) {
                $uid = $userData->uid;
            }
            $where[] = ['user_id', '=', $uid];
        }

        // 合伙人等级搜索
        if (isset($params['partner_level']) && $params['partner_level']) {
            $where[] = ['partner_level', '=', $params['partner_level']];
        }

        // 共富团等级搜索
        if (isset($params['user_group']) && $params['user_group']) {
            /** @var SharedProsperityGroupUserDao $groupUserDao */
            $groupUserDao = app()->make(SharedProsperityGroupUserDao::class);
            $groupUserData = $groupUserDao->getUserByLevel($params['user_group']);
            $uids = array_column($groupUserData['data'], 'user_id');
            $where[] = ['user_id', 'in', $uids];
            $page = 1;
        }

        $list = $this->dao->adminList($where, $page);
        return $list;
    }

    /**
     * @param $userId
     * @param $level
     * @return int
     * @author 史晨
     * @date 2026/2/27 14:23
     * 更新用户等级
     */
    public function updateLevel($userId, $level)
    {
        return $this->dao->updateByUserId($userId, ['partner_level' => $level]);
    }

    /**
     * @param $userId
     * @param $type
     * @param $number
     * @return bool
     * @author 史晨
     * @date 2026/2/27 15:16
     * 更新用户奖励
     */
    public function updateReward($userId, $type, $number)
    {
        $map = [
            1001 => 'consumer_stocks',
            1002 => 'withdrawal_limit',
            1003 => 'pv'
        ];

        try {
            Db::startTrans();

            $pm = 1;
            $remark = '后台操作增加' . $number;
            if ($number < 0) {
                $pm = 0;
                $remark = '后台操作减少' . abs($number);
            }

            if (isset($map[$type])) {
                // 更新数据
                $this->dao->updateRewardByUserId($userId, $map[$type], $number);
                // 记录日志
                $insertData = [
                    'user_id' => $userId,
                    'type' => $type,
                    'pm' => $pm,
                    'number' => abs($number),
                    'balance' => 0,
                    'status' => SharedProsperityRewardRecordEnum::STATUS['VALID']['code'],
                    'type_shop' => SharedProsperityRewardRecordEnum::TYPE_SHOP['Platform']['code'],
                    'order_sn' => 0,
                    'take_time' => date('Y-m-d H:i:s', time()),
                    'remark' => $remark,
                    'create_time' => date('Y-m-d H:i:s', time()),
                    'update_time' => date('Y-m-d H:i:s', time()),
                ];
                /** @var SharedProsperityRewardRecordDao $rewardRecordDao */
                $rewardRecordDao = app()->make(SharedProsperityRewardRecordDao::class);
                $rewardRecordDao->insertAll([$insertData]);
            } else {
                // 更新数据
                /** @var UserDao $userDao */
                $userDao = app()->make(UserDao::class);
                $userDao->updateBrokeragePriceByUid($userId, $number);;
                // 记录日志
                $bill = [
                    'uid' => $userId,
                    'link_id' => 0,
                    'pm' => $pm,
                    'title' => $remark,
                    'category' => 'now_money',
                    'type' => 'commission',
                    'number' => abs($number),
                    'balance' => 0,
                    'mark' => $remark,
                    'create_time' => date('Y-m-d H:i:s'),
                    'status' => 1,
                    'commission_type' => CommonEnum::COMMISSION_TYPE['SHARED_PROSPERITY_PARTNER_COMMISSION']['code'],
                    'order_sn' => 0,
                    'tripartite' => 0,
                    'type_shop' => 0,
                    'mer_id' => 0,
                    'source' => 0,
                    'order_type' => 1,
                    'is_red_brokerage' => 0,
                    'gzc' => 3,
                    'take_time' => time(),
                    'district_id' => '',
                    'street_id' => '',
                    'month' => '',
                ];
                Db::name('user_bill')->insert($bill);
            }
            Db::commit();
            return true;
        } catch (\Exception $e) {
            Db::rollback();
            return false;
        }
    }
}