baoshi-was/app/Services/UserService.php

<?php


namespace App\Services;


use App\Owner;
use App\User;
use App\UserWorkgroup;
use Firebase\JWT\JWT;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Cache;
use App\Traits\ServiceAppAop;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;


class UserService
{
    use ServiceAppAop;
    protected $modelClass=User::class;
    /** @var CacheService $cacheService */
    private $cacheService;
    function __construct(){
        $this->cacheService = app('CacheService');
    }

    function hasRoles(User $user, $roles){
        $thisRoles=$this->cacheService->getOrExecute("user{$user['id']}->roles",function()use($user){
            return $user->roles;
        });
        return !!$roles->intersect($thisRoles)->count();
    }

    function getPermittingLogisticIds($user=null){
        if(!$user)return [];
        return $this->cacheService->getOrExecute("user{$user['id']}->getPermittingLogisticIds",function()use($user){
                return $user->getPermittingLogisticIdsAttribute() ?? [];
        })??[];
    }


    /**
     * 检查用户的管理员身份
     *
     * @param integer $userId
     *
     * @return bool
     */
    public function checkAdminIdentity(int $userId):bool
    {
        if ($userId == Auth::id())return array_search(Auth::user()["name"],config("users.superAdmin"))!==false;
        /** @var User|\stdClass $user */
        $user = User::query()->select("name")->find($userId);
        if (!$user)return false;
        return array_search($user->name,config("users.superAdmin"))!==false;
    }

    /**
     * @param integer|null $userId
     *
     * @return array
     */
    public function getUserHasUserWorkGroups($userId = null)
    {
        if (!$userId)$userId = Auth::id();
        $key = "userWorkGroups:user_".$userId;
        if (!Cache::has($key)){
            if ($this->checkAdminIdentity($userId))Cache::forever($key,array_column(UserWorkgroup::query()->select("id")->get()->toArray(),"id"));
            else{
                $userWorkGroups = [];
                /** @var User|\stdClass $user */
                $user = new User();
                $user->id = $userId;
                $user->load("roles.userWorkGroups");
                $user->roles->each(function ($role)use (&$userWorkGroups){
                    $userWorkGroups = array_merge($userWorkGroups,array_column($role->userWorkGroups->toArray(),"id"));
                });
                Cache::forever($key,$userWorkGroups);
            }
        }
        return Cache::get($key);
    }

    /**
     * 清除用户缓存
     *
     * @param User $user
     */
    public function clearUserCache(User $user)
    {
        Cache::tags("authorities:user")->forget("authorities:user_".$user->id);
        Cache::tags("authorities:user")->forget("authorities:android:user_".$user->id);
        Cache::forget("userWorkGroups:user_".$user->id);
        Cache::tags("AUTHORITY_MENU_MAPPING")->forget("am_mapping_".$user->id);
        Cache::tags("USERS")->pull("user_info_".$user->id);
    }

    /**
     * 获取JWT token
     *
     * @param User|\stdClass $user
     * @param mixed $key
     * @return string
     */
    public function getJWTToken($user,$key):string
    {
        $time = time();
        $payload = [
            'iss' => $_SERVER["HTTP_HOST"], //签发者
            'iat' => $time,
            'nbf' => $time,
            'exp' => $time+config("api.timeliness_limits.token","7200"),
            'data' => [
                'id' => $user->id,
                'username' => $user->name
            ]
        ];
        $alg = 'RS256';
        return JWT::encode($payload, $key, $alg);
    }

    /**
     * 设置或刷新缓存
     *
     * @param User|\stdClass|Model $user
     * @param null $exp
     */
    public function setOrRefreshCache($user, $exp = null)
    {
        if (!$exp)$exp = config("api.timeliness_limits.token","7200");
        Cache::tags("USERS")->put("user_info_".$user->id,$user,$exp);
    }

    /**
     * @param integer $id
     * @param integer $exp
     * @return User|\stdClass|null
     */
    public function getOrRefreshCache(int $id,int $exp):?Model
    {
        $user = Cache::tags("USERS")->get("user_info_".$id);
        if ($user)return $user;
        $user = User::query()->find($id);
        if (!$user)return null;
        $time = $exp-time();
        $this->setOrRefreshCache($user,$time>0 ? $time : 7200);
        return $user;
    }

    public function setSingleTag($key, $token)
    {
        $val = $token."#".md5($_SERVER['HTTP_USER_AGENT']);
        Cache::tags(User::ANDROID_SINGLE_TAG)->put($key,$val,
            config("api.timeliness_limits.token","7200"));
    }

    public function verifySingleTag($key, $token):bool
    {
        $tV = Cache::tags(User::ANDROID_SINGLE_TAG)->get($key);
        if ($tV===null)return true;
        $userAgent = isset($_SERVER['HTTP_USER_AGENT']) ? "#".md5($_SERVER['HTTP_USER_AGENT']) : "";
        return $tV===($token.$userAgent);
    }

    /**
     * 这里与ownerService的getIdArr区别为映射真实ID,摒弃其余因素干扰(超管身份,超级权限等)
     *
     * @param int|null $userId
     * @return array
     */
    public function getUserUnderOwnerIdArr(?int $userId = null) :array
    {
        if (!$userId){
            /**@var $user User*/
            $user = Auth::user();
        }else{
            $user = new User();
            $user->id = $userId;
        }
        $user->load("owners:id");
        return array_column($user->owners->toArray(),"id");
    }

    public function bindOwner($workGroupIds, $ownerGroupIds, User $user){
        $ownerIds = [];
        if ($workGroupIds){
            $ownerIds = app("ObligationService")->getObligationUnderOwner($workGroupIds);
        }
        if ($ownerGroupIds){
            $ownerIds = array_merge($ownerIds, app("OwnerService")->getOwnerGroupUnderOwner($ownerGroupIds));
        }
        $ownerIds = array_unique($ownerIds);
        $user->owners()->sync($ownerIds);
    }

    /**
     * 获取工作组关联用户ID
     *
     * @param $groupIds
     * @return array
     */
    private function getGroupUser($groupIds) {
        return User::query()->select("id")->whereHas("userWorkgroups", function ($builder) use($groupIds) {
            $builder->whereIn("id", $groupIds);
        })->pluck("id")->toArray();
    }

    /**
     * 移除工作组用户的绑定货主
     *
     * @param array $groupIds
     * @param $ownerId
     */
    public function removeGroupUserBindOwner($groupIds, $ownerId) {
        if (!$groupIds || count($groupIds) == 0) {
            return;
        }
        $userId = $this->getGroupUser($groupIds);
        if (!$userId || count($userId) == 0) {
            return;
        }
        DB::table("owner_user")->where("owner_id", $ownerId)
            ->whereIn("user_id", $userId)
            ->delete();
    }

    /**
     * 新增工作组用户的绑定货主
     *
     * @param $groupIds
     * @param $ownerId
     */
    public function insertGroupUserBindOwner($groupIds, $ownerId) {
        if (!$groupIds || count($groupIds) == 0) {
            return;
        }
        $userId = User::query()->select("id")
            ->whereHas("owners", function ($builder)use($ownerId) {
                $builder->where("id", '!=' , $ownerId);
            })->whereHas("userWorkgroups", function ($builder) use($groupIds) {
                $builder->whereIn("id", $groupIds);
            })->pluck("id");
        if (!$userId || $userId->count() == 0) {
            return;
        }
        foreach ($userId as $user) {
            DB::insert("INSERT INTO owner_user(owner_id,user_id) VALUES ({$ownerId},{$user})");
        }
    }
}