course-site/app/Http/Controllers/Admin/Lab/AccountAppliesController.php

<?php

namespace App\Http\Controllers\Admin\Lab;

use App\Http\Controllers\Controller;
use App\Repositories\Enums\CheckStatusEnum;
use App\Repositories\Enums\ModelStatusEnum;
use App\Repositories\Enums\PermissionEnum;
use App\Repositories\Enums\ResponseCodeEnum;
use App\Repositories\Models\Base\Admin;
use App\Repositories\Models\Base\Department;
use App\Repositories\Models\Lab\AccountApply;
use App\Repositories\Models\School\Teacher;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Hash;
use Jiannei\Response\Laravel\Support\Facades\Response;
use Prettus\Validator\Contracts\ValidatorInterface;
use App\Contracts\Repositories\Lab\AccountApplyRepository;
use App\Repositories\Validators\Lab\AccountApplyValidator;

/**
 * Class AccountAppliesController.
 *
 * @package namespace App\Http\Controllers\Lab;
 */
class AccountAppliesController extends Controller
{
    /**
     * @var AccountApplyRepository
     */
    protected $repository;

    /**
     * @var AccountApplyValidator
     */
    protected $validator;

    /**
     * AccountAppliesController constructor.
     *
     * @param AccountApplyRepository $repository
     * @param AccountApplyValidator $validator
     */
    public function __construct(AccountApplyRepository $repository, AccountApplyValidator $validator)
    {
        parent::__construct();
        $this->repository = $repository;
        $this->validator = $validator;
    }

    /**
     * 列表
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse|\Illuminate\Http\Resources\Json\Resource
     * Author: Mead
     */
    public function index(Request $request)
    {
        $lists = $this->repository->paginate($request->get('per_page', self::PAGE_NUM));
        return Response::success($lists);
    }

    /**
     * 排班列表
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse|\Illuminate\Http\Resources\Json\Resource
     */
    public function lists(Request $request)
    {
        $lists = $this->repository->all();
        return Response::success($lists);
    }

    /**
     * 添加
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse|\Illuminate\Http\Resources\Json\Resource|void
     * @throws \Illuminate\Validation\ValidationException
     * Author: Mead
     */
    public function store(Request $request)
    {
        $this->validate($request, $this->validator->getRules(ValidatorInterface::RULE_CREATE));
        $data = $request->only(array_keys($this->validator->getRules(ValidatorInterface::RULE_CREATE)));

        if ($msg = check_password($data['password'])) {
            return $this->error($msg);
        }

        $model = AccountApply::query()->where('account', $data['account'])->first();
        if ($model) {
            if ($model->check_status == CheckStatusEnum::WAIT) {
                return $this->error('您已经提交申请，请耐心等待管理员审核。');
            }
            if ($model->check_status == CheckStatusEnum::OK) {
                return $this->error('您已经审核通过.');
            }
            if ($model->check_status == CheckStatusEnum::ERROR) {
                return $this->error('您的申请审核未通过，原因：' . $model->check_result);
            }
        }

        if (Admin::query()->where('username', $data['account'])->exists()) {
            return $this->error('该账号已存在');
        }
        $data['status'] = ModelStatusEnum::PAUSE;
        try {
            $model = AccountApply::query()->create($data);
            return Response::success([]);
        } catch (\Exception $e) {
            return $this->error($e);
        }
    }

    /**
     * 详情
     * @param $id
     * @return \Illuminate\Http\JsonResponse|\Illuminate\Http\Resources\Json\Resource
     * Author: Mead
     */
    public function show($id)
    {
        $data = $this->repository->find($id);
        return Response::success($data);
    }

    /**
     * 更新
     * @param Request $request
     * @param $id
     * @return \Illuminate\Http\JsonResponse|\Illuminate\Http\Resources\Json\Resource
     * @throws \Illuminate\Validation\ValidationException
     * Author: Mead
     */
    public function update(Request $request, $id)
    {
        $this->validate($request, $this->validator->getRules(ValidatorInterface::RULE_UPDATE));

        $check_status = AccountApply::query()->where('id', $id)->value('check_status');
        if ($check_status != CheckStatusEnum::WAIT) {
            return $this->error('已经审核，暂不允许修改');
        }

        try {
            $data = $request->only(array_keys($this->validator->getRules(ValidatorInterface::RULE_CREATE)));
            $model = AccountApply::query()->where('id', $id)->update($data);
            return Response::success($model);
        } catch (\Exception $e) {
            $this->error($e);
        }
    }

    /**
     * 删除
     * @param $id
     * @return \Illuminate\Http\JsonResponse|\Illuminate\Http\Resources\Json\Resource
     * Author: Mead
     */
    public function destroy($id)
    {
        $this->isCan(PermissionEnum::controller_account_del);
        try {
            $this->repository->skipPresenter()->delete($id);
            return Response::success(null, T('successfully delete.'));
        } catch (\Exception $exception) {
            return Response::fail(T('Delete failed.'), ResponseCodeEnum::SERVICE_UPDATE_DATA_ERROR);
        }
    }

    /**
     * 批量删除
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse|\Illuminate\Http\Resources\Json\Resource
     * Author: Mead
     */
    public function delete(Request $request)
    {
        $this->isCan(PermissionEnum::controller_account_del);
        try {
            $this->validate($request, [
                'ids' => 'required|array',
            ]);

            $ids = $request->get('ids');
            $this->repository->whereIn('id', $ids)->delete();
            return Response::success(null, T('successfully delete.'));
        } catch (\Exception $exception) {
            return Response::fail(T('Delete failed.'), ResponseCodeEnum::SERVICE_UPDATE_DATA_ERROR);
        }
    }

    /**
     * 审核账号
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse|\Illuminate\Http\Resources\Json\Resource
     * @throws \Illuminate\Validation\ValidationException
     */
    public function check(Request $request)
    {
        $this->validate($request, [
            'id' => 'required|integer',
            'check_status' => 'required|integer',
            'check_result' => 'nullable|sometimes',
            'roles' => 'nullable|sometimes|array',
        ]);

        $this->isCan(PermissionEnum::controller_account_check);

        $id = $request->get('id');
        $check_status = $request->get('check_status');
        $check_result = $request->get('check_result');
        $roles = $request->get('roles', []);

        $model = AccountApply::query()->find($id);
        if (!$model) {
            return $this->error('找不到该记录');
        }

        if (in_array($model->check_status, [CheckStatusEnum::OK, CheckStatusEnum::ERROR])) {
            return $this->error('该申请已经审核，请勿重复操作');
        }

        if ($model->check_status == CheckStatusEnum::OK) {
            if (Admin::query()->where('username', $model->account)->exists()) {
                return $this->error('该账号已存在');
            }

            $this->validate($request, [
                'roles' => 'required|array',
            ]);
        }

        $model->check_status = $check_status;
        $model->check_result = $check_result;
        $model->check_time = Carbon::now()->toDateTimeString();
        $model->check_admin_id = login_admin_id();
        $model->roles = $roles;
        $model->save();

        if ($check_status == CheckStatusEnum::OK) {
            $department = Department::query()->firstOrCreate(['name' => $model->department], ['status' => ModelStatusEnum::OK]);

            $admin = Admin::query()->create([
                'username' => $model->account,
                'password' => Hash::make($model->password),
                'name' => $model->name,
                'headimg' => '',
                'type' => Teacher::class,
                'type_id' => 0,
                'is_admin' => 0,
                'department_id' => $department->id ?? 0,
                'email' => $model->email,
                'mobile' => $model->mobile,
                'status' => ModelStatusEnum::OK,
            ]);

            $admin->syncRoles($roles);
        }

        return Response::success([]);
    }

    /**
     * 批量审核
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse|\Illuminate\Http\Resources\Json\Resource
     * @throws \Illuminate\Validation\ValidationException
     */
    public function approveCheck(Request $request)
    {
        $this->isCan(PermissionEnum::controller_account_check);

        $this->validate($request, [
            'ids' => 'required|array',
            'check_status' => 'required|integer',
            'check_result' => 'nullable|sometimes',
        ]);
        $ids = $request->get('ids');
        $check_status = $request->get('check_status');
        $check_result = $request->get('check_result');

        $accounts = AccountApply::query()->whereIn('id', $ids)->where('status', CheckStatusEnum::WAIT)->get();

        if (count($accounts) != count($ids)) {
            return $this->error('审核记录中和不满足条件的记录不匹配');
        }

        if ($check_status == ModelStatusEnum::OK) {
            foreach ($accounts as $account) {
                if (Admin::query()->where('username', $account->account)->exists()) {
                    return $this->error('该账号已存在');
                }
            }
        }

        DB::beginTransaction();
        try {

            foreach ($accounts as $account) {
                $account->check_status = $check_status;
                $account->check_result = $check_result;
                $account->check_time = Carbon::now()->toDateTimeString();
                $account->check_admin_id = login_admin_id();
                $account->save();
                $admin = Admin::query()->create([
                    'username' => $account->account,
                    'password' => Hash::make($account->password),
                    'name' => $account->name,
                    'headimg' => '',
                    'type' => Teacher::class,
                    'type_id' => 0,
                    'is_admin' => 0,
                    'department_id' => $department->id ?? 0,
                    'email' => $account->email,
                    'mobile' => $account->mobile,
                    'status' => ModelStatusEnum::OK,
                ]);
                $admin->syncRoles(['outside_teacher']);
            }
            DB::commit();

        } catch (\Exception $exception) {
            DB::rollBack();
            return $this->error($exception->getMessage());
        }

        return Response::success([]);
    }

}