4 | 5 | Lin-CMS-TP5 6 |
4 |
9 | 
10 | 
11 | 
12 |
163 |
164 | ### 微信公众号
165 |
166 | 微信搜索：林间有风
167 |
168 | 
169 |
--------------------------------------------------------------------------------
/application/.htaccess:
--------------------------------------------------------------------------------
1 | deny from all
--------------------------------------------------------------------------------
/application/api/behavior/Logger.php:
--------------------------------------------------------------------------------
1 | '日志信息不能为空'
31 | ]);
32 | }
33 |
34 | if (is_array($params)) {
35 | list('uid' => $uid, 'username' => $username, 'msg' => $message) = $params;
36 | } else {
37 | $tokenService = LoginToken::getInstance();
38 | $uid = $tokenService->getCurrentUid();
39 | $username = $tokenService->getCurrentUserName();
40 | $message = $params;
41 | }
42 |
43 | $data = [
44 | 'message' => $username . $message,
45 | 'user_id' => $uid,
46 | 'username' => $username,
47 | 'status_code' => Response::getCode(),
48 | 'method' => Request::method(),
49 | 'path' => '/' . Request::path(),
50 | 'permission' => null
51 | ];
52 |
53 | LinLog::create($data);
54 |
55 | }
56 | }
--------------------------------------------------------------------------------
/application/api/controller/cms/Admin.php:
--------------------------------------------------------------------------------
1 | get('page/d', 0);
56 | $count = $request->get('count/d', 10);
57 | $groupId = $request->get('group_id/d');
58 |
59 | return AdminService::getUsers($page, $count, $groupId);
60 | }
61 |
62 | /**
63 | * @adminRequired
64 | * @permission('修改用户密码','管理员','hidden')
65 | * @validate('ResetPasswordValidator')
66 | * @param Request $request
67 | * @param $id
68 | * @return Json
69 | * @throws NotFoundException
70 | */
71 | public function changeUserPassword(Request $request, $id)
72 | {
73 | $newPassword = $request->put('new_password');
74 | AdminService::changeUserPassword($id, $newPassword);
75 | Hook::listen('logger', "修改了用户ID为{$id}的密码");
76 |
77 | return writeJson(200, null, '修改成功', 4);
78 | }
79 |
80 | /**
81 | * @adminRequired
82 | * @permission('删除用户','管理员','hidden')
83 | * @param int $id
84 | * @param('id','用户id','require|integer')
85 | * @return Json
86 | * @throws NotFoundException
87 | * @throws OperationException
88 | */
89 | public function deleteUser(int $id)
90 | {
91 | AdminService::deleteUser($id);
92 | Hook::listen('logger', "删除了用户ID为：{$id}的用户");
93 | return writeJson(201, $id, '删除用户成功', 5);
94 | }
95 |
96 | /**
97 | * @adminRequired
98 | * @permission('管理员更新用户信息','管理员','hidden')
99 | * @param Request $request
100 | * @param('id','用户id','require|integer')
101 | * @param('group_ids','分组id','require|array|min:1')
102 | * @return Json
103 | * @throws NotFoundException
104 | * @throws OperationException
105 | * @throws ForbiddenException
106 | * @throws DataNotFoundException
107 | * @throws ModelNotFoundException
108 | * @throws DbException
109 | */
110 | public function updateUser(Request $request, $id)
111 | {
112 | $groupIds = $request->put('group_ids');
113 | AdminService::updateUserInfo($id, $groupIds);
114 |
115 | Hook::listen('logger', "更新了用户：{$id}的所属分组");
116 | return writeJson(201, $id, '更新用户成功', 6);
117 | }
118 |
119 | /**
120 | * @adminRequired
121 | * @permission('查询所有分组','管理员','hidden')
122 | * @return array|PDOStatement|string|\think\Collection|Collection
123 | * @throws DataNotFoundException
124 | * @throws DbException
125 | * @throws ModelNotFoundException
126 | * @throws NotFoundException
127 | */
128 | public function getGroupAll()
129 | {
130 | return AdminService::getAllGroups();
131 | }
132 |
133 | /**
134 | * @adminRequired
135 | * @permission('查询一个权限组及其权限','管理员','hidden')
136 | * @param int $id
137 | * @param('id','分组id','require|integer')
138 | * @return Query
139 | * @throws DbException
140 | * @throws NotFoundException
141 | */
142 | public function getGroup(int $id)
143 | {
144 | return AdminService::getGroup($id);
145 | }
146 |
147 | /**
148 | * @adminRequired
149 | * @permission('新建一个权限组','管理员','hidden')
150 | * @param Request $request
151 | * @param('name','分组名字','require')
152 | * @param('permission_ids','权限id','require|array|min:1')
153 | * @return Json
154 | * @throws DataNotFoundException
155 | * @throws DbException
156 | * @throws ModelNotFoundException
157 | * @throws NotFoundException
158 | * @throws OperationException
159 | */
160 | public function createGroup(Request $request)
161 | {
162 | $name = $request->post('name');
163 | $info = $request->post('info');
164 | $permissionIds = $request->post('permission_ids');
165 |
166 | $groupId = AdminService::createGroup($name, $info, $permissionIds);
167 |
168 | Hook::listen('logger', "创建了分组：{$name}");
169 | return writeJson(201, $groupId, '新增分组成功', 15);
170 | }
171 |
172 | /**
173 | * @adminRequired
174 | * @permission('更新一个权限组','管理员','hidden')
175 | * @param Request $request
176 | * @param int $id
177 | * @param('id','分组id','require|integer')
178 | * @param('info','分组信息','require')
179 | * @param('name','分组名字','require')
180 | * @return Json
181 | * @throws DataNotFoundException
182 | * @throws DbException
183 | * @throws ModelNotFoundException
184 | * @throws NotFoundException
185 | */
186 | public function updateGroup(Request $request, int $id)
187 | {
188 | $name = $request->put('name');
189 | $info = $request->put('info');
190 |
191 | $res = AdminService::updateGroup($id, $name, $info);
192 |
193 | Hook::listen('logger', "更新了id为{$id}的分组");
194 | return writeJson(200, $res, '更新分组信息成功', 7);
195 | }
196 |
197 | /**
198 | * @adminRequired
199 | * @permission('更新一个权限组','管理员','hidden')
200 | * @param int $id
201 | * @param('id','分组id','require|integer')
202 | * @return Json
203 | * @throws ForbiddenException
204 | * @throws NotFoundException
205 | * @throws OperationException
206 | */
207 | public function deleteGroup(int $id)
208 | {
209 | AdminService::deleteGroup($id);
210 |
211 | Hook::listen('logger', "删除了id为{$id}的分组");
212 | return writeJson(200, null, '删除分组成功', 8);
213 | }
214 |
215 | /**
216 | * @adminRequired
217 | * @permission('分配多个权限','管理员','hidden')
218 | * @param Request $request
219 | * @param('group_id','分组id','require|integer')
220 | * @param('permission_ids','权限id','require|array|min:1')
221 | * @return Json
222 | * @throws DbException
223 | * @throws NotFoundException
224 | * @throws OperationException
225 | */
226 | public function dispatchPermissions(Request $request)
227 | {
228 | $groupId = $request->post('group_id');
229 | $permissionIds = $request->post('permission_ids');
230 |
231 | AdminService::dispatchPermissions($groupId, $permissionIds);
232 |
233 | Hook::listen('logger', "修改了分组ID为{$groupId}的权限");
234 | return writeJson(200, null, '分配权限成功', 9);
235 | }
236 |
237 | /**
238 | * @adminRequired
239 | * @permission('删除多个权限','管理员','hidden')
240 | * @param Request $request
241 | * @param('group_id','分组id','require|integer')
242 | * @param('permission_ids','权限id','require|array|min:1')
243 | * @return Json
244 | * @throws DbException
245 | * @throws NotFoundException
246 | */
247 | public function removePermissions(Request $request)
248 | {
249 | $groupId = $request->post('group_id');
250 | $permissionIds = $request->post('permission_ids');
251 |
252 | $deleted = AdminService::removePermissions($groupId, $permissionIds);
253 |
254 | Hook::listen('logger', "修改了分组ID为{$groupId}的权限");
255 | return writeJson(200, $deleted, '删除权限成功', 10);
256 | }
257 | }
--------------------------------------------------------------------------------
/application/api/controller/cms/File.php:
--------------------------------------------------------------------------------
1 | '字段中含有非法字符',
32 | ]);
33 | }
34 | $file = (new LocalUploader($request))->upload();
35 | return $file;
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/application/api/controller/cms/Log.php:
--------------------------------------------------------------------------------
1 | get('start');
32 | $end = $request->get('end');
33 | $name = $request->get('name');
34 | $page = $request->get('page/d', 0);
35 | $count = $request->get('count/d', 10);
36 |
37 | return LogService::getLogs($page, $count, $start, $end, $name);
38 | }
39 |
40 | /**
41 | * @groupRequired
42 | * @permission('搜索日志','日志')
43 | * @param Request $request
44 | * @param('page','分页数','integer')
45 | * @param('count','分页值','integer')
46 | * @param('start','开始日期','date')
47 | * @param('end','结束日期','date')
48 | * @return array
49 | * @throws ParameterException
50 | */
51 | public function getUserLogs(Request $request)
52 | {
53 | $start = $request->get('start');
54 | $end = $request->get('end');
55 | $name = $request->get('name');
56 | $keyword = $request->get('keyword');
57 | $page = $request->get('page/d', 0);
58 | $count = $request->get('count/d', 10);
59 |
60 | return LogService::searchLogs($page, $count, $start, $end, $name, $keyword);
61 | }
62 |
63 | /**
64 | * @groupRequired
65 | * @permission('查询日志记录的用户','日志')
66 | * @param Request $request
67 | * @param('page','分页数','integer')
68 | * @param('count','分页值','integer')
69 | * @return array
70 | * @throws ParameterException
71 | */
72 | public function getUsers(Request $request)
73 | {
74 | $page = $request->get('page/d', 0);
75 | $count = $request->get('count/d', 10);
76 |
77 | return LogService::getUserNames($page, $count);
78 | }
79 | }
--------------------------------------------------------------------------------
/application/api/controller/cms/User.php:
--------------------------------------------------------------------------------
1 | loginTokenService = LoginToken::getInstance();
36 | }
37 |
38 |
39 | /**
40 | * @adminRequired
41 | * @permission('注册','管理员','hidden')
42 | * @param Request $request
43 | * @validate('RegisterForm')
44 | * @return Json
45 | * @throws NotFoundException
46 | * @throws OperationException
47 | * @throws RepeatException
48 | * @throws ForbiddenException
49 | * @throws DataNotFoundException
50 | * @throws ModelNotFoundException
51 | * @throws DbException
52 | */
53 | public function register(Request $request)
54 | {
55 | $params = $request->post();
56 | $user = UserService::createUser($params);
57 |
58 | Hook::listen('logger', "新建了用户：{$user['username']}");
59 | return writeJson(201, $user['id'], '注册用户成功');
60 | }
61 |
62 | /**
63 | * @param Request $request
64 | * @validate('LoginForm')
65 | * @return array
66 | * @throws DataNotFoundException
67 | * @throws DbException
68 | * @throws ModelNotFoundException
69 | * @throws NotFoundException
70 | * @throws AuthFailedException
71 | */
72 | public function userLogin(Request $request)
73 | {
74 | $username = $request->post('username');
75 | $password = $request->post('password');
76 | $user = UserService::verify($username, $password);
77 |
78 | $tokenExtend = UserService::generateTokenExtend($user);
79 |
80 | $token = $this->loginTokenService->getToken($tokenExtend);
81 |
82 | Hook::listen('logger', array('uid' => $user->id, 'username' => $user->identifier, 'msg' => '登陆成功获取了令牌'));
83 | return [
84 | 'access_token' => $token['accessToken'],
85 | 'refresh_token' => $token['refreshToken']
86 | ];
87 | }
88 |
89 | /**
90 | * @return array
91 | * @throws TokenException
92 | */
93 | public function refreshToken()
94 | {
95 | $token = $this->loginTokenService->getTokenFromHeaders();
96 | $token = $this->loginTokenService->refresh($token);
97 | return [
98 | 'access_token' => $token['accessToken']
99 | ];
100 | }
101 |
102 | /**
103 | * @loginRequired
104 | */
105 | public function getAllowedApis()
106 | {
107 | $uid = $this->loginTokenService->getCurrentUid();
108 | return UserService::getPermissions($uid);
109 | }
110 |
111 | /**
112 | * @loginRequired
113 | * @return mixed
114 | */
115 | public function getInformation()
116 | {
117 | $uid = $this->loginTokenService->getCurrentUid();
118 | return UserService::getInformation($uid);
119 | }
120 |
121 | /**
122 | * @loginRequired
123 | * @param Request $request
124 | * @validate('UpdateUserForm')
125 | * @return Json
126 | * @throws RepeatException
127 | */
128 | public function update(Request $request)
129 | {
130 | $params = $request->put();
131 | $row = UserService::updateUser($params);
132 | return writeJson(200, $row, '用户信息更新成功');
133 | }
134 |
135 | /**
136 | * @loginRequired
137 | * @validate('ChangePasswordForm')
138 | * @param Request $request
139 | * @return Json
140 | * @throws AuthFailedException
141 | * @throws NotFoundException
142 | */
143 | public function changePassword(Request $request)
144 | {
145 | $oldPassword = $request->put('old_password');
146 | $newPassword = $request->put('new_password');
147 |
148 | $row = UserService::changePassword($oldPassword, $newPassword);
149 |
150 | Hook::listen('logger', '修改了自己的密码');
151 | return writeJson(200, $row, '密码修改成功');
152 | }
153 | }
154 |
--------------------------------------------------------------------------------
/application/api/controller/v1/Book.php:
--------------------------------------------------------------------------------
1 | post();
56 | BookModel::create($params);
57 | return writeJson(201, '', '新建图书成功');
58 | }
59 |
60 | public function update(Request $request)
61 | {
62 | $params = $request->put();
63 | $bookModel = new BookModel();
64 | $bookModel->save($params, ['id' => $params['id']]);
65 | return writeJson(201, '', '更新图书成功');
66 | }
67 |
68 | /**
69 | * @groupRequired
70 | * @permission('删除图书','图书')
71 | * @param $bid
72 | * @return Json
73 | */
74 | public function delete($bid)
75 | {
76 | BookModel::destroy($bid);
77 | Hook::listen('logger', '删除了id为' . $bid . '的图书');
78 | return writeJson(201, '', '删除图书成功');
79 | }
80 | }
--------------------------------------------------------------------------------
/application/api/model/BaseModel.php:
--------------------------------------------------------------------------------
1 | belongsToMany('LinUser', 'Lin_user_group', 'user_id', 'group_id');
26 | }
27 |
28 | public function permissions()
29 | {
30 | return $this->belongsToMany('LinPermission', 'lin_group_permission', 'permission_id', 'group_id');
31 | }
32 | }
--------------------------------------------------------------------------------
/application/api/model/admin/LinGroupPermission.php:
--------------------------------------------------------------------------------
1 | count();
27 | $logList = $logList->limit($start, $count)
28 | ->order('create_time desc')
29 | ->select();
30 | return [
31 | 'logList' => $logList,
32 | 'total' => $total
33 | ];
34 | }
35 |
36 | public static function searchLogs(int $start, int $count, $params = [])
37 | {
38 | $logList = self::withSearch(['name', 'start', 'end', 'keyword'], $params);
39 |
40 | $total = $logList->count();
41 | $logList = $logList->limit($start, $count)
42 | ->order('create_time desc')
43 | ->select();
44 | return [
45 | 'logList' => $logList,
46 | 'total' => $total
47 | ];
48 | }
49 |
50 |
51 | public static function getUserNames(int $start, int $count)
52 | {
53 | $users = self::field('username');
54 |
55 | $total = $users->count();
56 | $users = $users->limit($start, $count)
57 | ->group('username')
58 | ->select();
59 |
60 | return [
61 | 'userList' => $users,
62 | 'total' => $total
63 | ];
64 | }
65 |
66 | public function searchNameAttr($query, $value)
67 | {
68 | if ($value) {
69 | $query->where('username', $value);
70 | }
71 | }
72 |
73 | public
74 | function searchStartAttr($query, $value)
75 | {
76 | if ($value) {
77 | $query->where('create_time', '>= time', $value);
78 | }
79 | }
80 |
81 | public
82 | function searchEndAttr($query, $value)
83 | {
84 | if ($value) {
85 | $query->where('create_time', '<= time', $value);
86 | }
87 | }
88 |
89 | public
90 | function searchKeywordAttr($query, $value)
91 | {
92 | if ($value) {
93 | $query->whereLike('message', "%{$value}%");
94 | }
95 | }
96 | }
--------------------------------------------------------------------------------
/application/api/model/admin/LinPermission.php:
--------------------------------------------------------------------------------
1 | where('username', '<>', 'root');
27 | $total = $userList->count();
28 |
29 | $userList = $userList
30 | ->limit($start, $count)
31 | ->with('groups')
32 | ->select();
33 |
34 | return [
35 | 'userList' => $userList,
36 | 'total' => $total
37 | ];
38 | }
39 |
40 | public function groups()
41 | {
42 | return $this->belongsToMany('LinGroup', 'lin_user_group', 'group_id', 'user_id');
43 | }
44 |
45 | public function identity()
46 | {
47 | return $this->hasMany('LinUserIdentity', 'user_id');
48 | }
49 |
50 | public function searchGroupIdAttr($query, $value)
51 | {
52 | if ($value) {
53 | $query->join('lin_group g', 'g.id=' . $value)->where('g.id', '<>', 1);
54 | }
55 | }
56 |
57 | public function getAvatarAttr($value)
58 | {
59 | if ($value) {
60 | $host = Config::get('file.host') ?? "http://127.0.0.1:5000/";
61 | $dir = Config::get('file.store_dir');
62 | return $host . $dir . '/' . $value;
63 | }
64 | return $value;
65 | }
66 | }
--------------------------------------------------------------------------------
/application/api/model/admin/LinUserGroup.php:
--------------------------------------------------------------------------------
1 | where('identifier', $currentUser->getAttr('username'))
28 | ->find();
29 |
30 | if (!$user) {
31 | throw new NotFoundException();
32 | }
33 |
34 | $user->credential = md5($newPassword);
35 | $user->save();
36 | }
37 |
38 | public function checkPassword(string $password): bool
39 | {
40 | return $this->getAttr('credential') === md5($password);
41 | }
42 | }
--------------------------------------------------------------------------------
/application/api/service/admin/Admin.php:
--------------------------------------------------------------------------------
1 | run();
45 | foreach ($permissionList as $permission) {
46 | $model = LinPermissionModel::where('name', $permission['name'])
47 | ->where('module', $permission['module'])
48 | ->find();
49 | if (!$model) {
50 | self::createPermission($permission['name'], $permission['module']);
51 | }
52 | }
53 |
54 | $permissions = LinPermissionModel::where('mount', MountTypeEnum::MOUNT)
55 | ->select()->toArray();
56 | $result = [];
57 | foreach ($permissions as $permission) {
58 | $result[$permission['module']][] = $permission;
59 | }
60 | return $result;
61 | }
62 |
63 | /**
64 | * @param int $page
65 | * @param int $count
66 | * @param int $groupId
67 | * @return array
68 | * @throws ParameterException
69 | */
70 | public static function getUsers(int $page, int $count, int $groupId = null): array
71 | {
72 | list($start, $count) = paginate($count, $page);
73 | $params = $groupId ? ['group_id' => $groupId] : [];
74 | $users = LinUserModel::getUsers($start, $count, $params);
75 |
76 | return [
77 | 'items' => $users['userList'],
78 | 'count' => $count,
79 | 'page' => $page,
80 | 'total' => $users['total']
81 | ];
82 | }
83 |
84 | /**
85 | * @param int $uid
86 | * @param string $newPassword
87 | * @throws NotFoundException
88 | */
89 | public static function changeUserPassword(int $uid, string $newPassword): void
90 | {
91 | $user = LinUserModel::get($uid);
92 | if (!$user) {
93 | throw new NotFoundException();
94 | }
95 |
96 | LinUserIdentityModel::resetPassword($user, $newPassword);
97 |
98 | }
99 |
100 | /**
101 | * @param int $uid
102 | * @throws NotFoundException
103 | * @throws OperationException
104 | */
105 | public static function deleteUser(int $uid): void
106 | {
107 | $user = LinUserModel::get($uid, 'identity');
108 | if (!$user) {
109 | throw new NotFoundException();
110 | }
111 |
112 | Db::startTrans();
113 | try {
114 | $user->groups()->detach();
115 | $user->together('identity')->delete();
116 | Db::commit();
117 | } catch (Exception $ex) {
118 | DB::rollback();
119 | throw new OperationException(['msg' => "删除用户失败"]);
120 | }
121 | }
122 |
123 | /**
124 | * @param int $uid
125 | * @param array $groupIds
126 | * @throws ForbiddenException
127 | * @throws NotFoundException
128 | * @throws OperationException
129 | * @throws DataNotFoundException
130 | * @throws ModelNotFoundException
131 | * @throws DbException
132 | */
133 | public static function updateUserInfo(int $uid, array $groupIds): void
134 | {
135 | $user = LinUserModel::get($uid);
136 | if (!$user) {
137 | throw new NotFoundException();
138 | }
139 |
140 | $userGroupIds = LinUserGroupModel::where('user_id', $uid)->column('group_id');
141 | $isAdmin = LinGroupModel::where('level', GroupLevelEnum::ROOT)
142 | ->whereIn('id', $userGroupIds)
143 | ->find();
144 | if ($isAdmin) {
145 | throw new ForbiddenException(['code' => 10078, 'msg' => '不允许调整root分组信息']);
146 | }
147 |
148 | foreach ($userGroupIds as $groupId) {
149 | $group = LinGroupModel::get($groupId);
150 | if ($group['level'] === GroupLevelEnum::ROOT) {
151 | throw new ForbiddenException(['code' => 10073, 'msg' => '不允许添加用户到root分组']);
152 | }
153 |
154 | if (!$group) {
155 | throw new NotFoundException(['code' => 10077]);
156 | }
157 | }
158 |
159 | Db::startTrans();
160 | try {
161 | $user->groups()->detach();
162 | $user->groups()->attach($groupIds);
163 | Db::commit();
164 | } catch (Exception $ex) {
165 | DB::rollback();
166 | throw new OperationException(['msg' => "更新用户分组失败"]);
167 | }
168 | }
169 |
170 | /**
171 | * @return array|PDOStatement|string|\think\Collection|Collection
172 | * @throws DataNotFoundException
173 | * @throws DbException
174 | * @throws ModelNotFoundException
175 | * @throws NotFoundException
176 | */
177 | public static function getAllGroups()
178 | {
179 | $groups = LinGroupModel::where('level', '<>', GroupLevelEnum::ROOT)->select();
180 | if ($groups->isEmpty()) {
181 | throw new NotFoundException();
182 | }
183 | return $groups;
184 | }
185 |
186 | /**
187 | * @param int $id
188 | * @return \think\db\Query
189 | * @throws DbException
190 | * @throws NotFoundException
191 | */
192 | public static function getGroup(int $id)
193 | {
194 | $group = LinGroupModel::where('level', '<>', GroupLevelEnum::ROOT)
195 | ->get($id, 'permissions');
196 | if (!$group) {
197 | throw new NotFoundException();
198 | }
199 |
200 | return $group;
201 | }
202 |
203 | /**
204 | * @param string $name
205 | * @param string $info
206 | * @param array $permissionIds
207 | * @return int
208 | * @throws DataNotFoundException
209 | * @throws DbException
210 | * @throws ModelNotFoundException
211 | * @throws NotFoundException
212 | * @throws OperationException
213 | */
214 | public static function createGroup(string $name, string $info, array $permissionIds): int
215 | {
216 | $isExist = LinGroupModel::where('name', $name)->find();
217 | if ($isExist) {
218 | throw new OperationException(['msg' => '分组名已存在']);
219 | }
220 |
221 | foreach ($permissionIds as $permissionId) {
222 | $permission = LinPermissionModel::where('mount', MountTypeEnum::MOUNT)
223 | ->get($permissionId);
224 | if (!$permission) {
225 | throw new NotFoundException(['error_code' => 10231, 'msg' => '分配了不存在的权限']);
226 | }
227 | }
228 |
229 | Db::startTrans();
230 | try {
231 | $group = LinGroupModel::create(['name' => $name, 'info' => $info], true);
232 | $group->permissions()->saveAll($permissionIds);
233 | Db::commit();
234 | return $group->getAttr('id');
235 | } catch (\Exception $ex) {
236 | Db::rollback();
237 | throw new OperationException(['msg' => "新增分组失败:{$ex->getMessage()}"]);
238 | }
239 |
240 | }
241 |
242 | /**
243 | * @param int $id
244 | * @param string $name
245 | * @param string $info
246 | * @return int
247 | * @throws DataNotFoundException
248 | * @throws DbException
249 | * @throws ModelNotFoundException
250 | * @throws NotFoundException
251 | */
252 | public static function updateGroup(int $id, string $name, string $info): int
253 | {
254 | $group = LinGroupModel::where('level', '<>', GroupLevelEnum::ROOT)
255 | ->find($id);
256 |
257 | if (!$group) {
258 | throw new NotFoundException();
259 | }
260 |
261 | return $group->save(['name' => $name, 'info' => $info]);
262 | }
263 |
264 | /**
265 | * @param int $id
266 | * @throws ForbiddenException
267 | * @throws NotFoundException
268 | * @throws OperationException
269 | */
270 | public static function deleteGroup(int $id): void
271 | {
272 | $group = LinGroupModel::find($id);
273 |
274 | if (!$group) {
275 | throw new NotFoundException();
276 | }
277 |
278 | if ($group->getAttr('level') === GroupLevelEnum::ROOT) {
279 | throw new ForbiddenException(['msg' => '不允许删除root分组']);
280 | }
281 |
282 | if ($group->getAttr('level') === GroupLevelEnum::GUEST) {
283 | throw new ForbiddenException(['msg' => '不允许删除guest分组']);
284 | }
285 |
286 | Db::startTrans();
287 | try {
288 | $group->permissions()->detach();
289 | $group->users()->detach();
290 | Db::commit();
291 | } catch (Exception $ex) {
292 | Db::rollback();
293 | throw new OperationException(['msg' => "删除分组失败:{$ex->getMessage()}"]);
294 | }
295 | }
296 |
297 | /**
298 | * @param int $id
299 | * @param array $permissionIds
300 | * @throws DbException
301 | * @throws NotFoundException
302 | * @throws OperationException
303 | */
304 | public static function dispatchPermissions(int $id, array $permissionIds)
305 | {
306 | $group = LinGroupModel::where('level', '<>', GroupLevelEnum::ROOT)
307 | ->get($id);
308 | if (!$group) {
309 | throw new NotFoundException();
310 | }
311 |
312 | foreach ($permissionIds as $permissionId) {
313 | $permission = LinPermissionModel::where('mount', MountTypeEnum::MOUNT)
314 | ->get($permissionId);
315 | if (!$permission) {
316 | throw new NotFoundException(['error_code' => 10231, 'msg' => '分配了不存在的权限']);
317 | }
318 | }
319 |
320 | try {
321 | $group->permissions()->attach($permissionIds);
322 | } catch (Exception $ex) {
323 | throw new OperationException(['msg' => '权限分配失败']);
324 | }
325 | }
326 |
327 | /**
328 | * @param int $id
329 | * @param array $permissionIds
330 | * @return int
331 | * @throws DbException
332 | * @throws NotFoundException
333 | */
334 | public static function removePermissions(int $id, array $permissionIds): int
335 | {
336 | $group = LinGroupModel::where('level', '<>', GroupLevelEnum::ROOT)
337 | ->get($id);
338 | if (!$group) {
339 | throw new NotFoundException();
340 | }
341 |
342 | foreach ($permissionIds as $permissionId) {
343 | $permission = LinPermissionModel::where('mount', MountTypeEnum::MOUNT)
344 | ->get($permissionId);
345 | if (!$permission) {
346 | throw new NotFoundException(['error_code' => 10231, 'msg' => '分配了不存在的权限']);
347 | }
348 | }
349 |
350 | return $group->permissions()->detach($permissionIds);
351 | }
352 |
353 | public static function createPermission(string $name, string $module): LinPermissionModel
354 | {
355 | return LinPermissionModel::create(['name' => $name, 'module' => $module, 'mount' => 1]);
356 | }
357 | }
--------------------------------------------------------------------------------
/application/api/service/admin/Log.php:
--------------------------------------------------------------------------------
1 | $start, 'end' => $end, 'name' => $name];
29 | $logsRes = LinLogModel::getLogs($offset, $count, $params);
30 |
31 | return [
32 | 'items' => $logsRes['logList'],
33 | 'count' => $count,
34 | 'page' => $page,
35 | 'total' => $logsRes['total']
36 | ];
37 | }
38 |
39 | /**
40 | * @param int $page
41 | * @param int $count
42 | * @param string|null $start
43 | * @param string|null $end
44 | * @param string|null $name
45 | * @param string|null $keyword
46 | * @return array
47 | * @throws ParameterException
48 | */
49 | public static function searchLogs(int $page, int $count, string $start = null,
50 | string $end = null, string $name = null, string $keyword = null)
51 | {
52 | list($offset, $count) = paginate($count, $page);
53 | $params = ['start' => $start, 'end' => $end, 'name' => $name, 'keyword' => $keyword];
54 |
55 | $logsRes = LinLogModel::searchLogs($offset, $count, $params);
56 |
57 | return [
58 | 'items' => $logsRes['logList'],
59 | 'count' => $count,
60 | 'page' => $page,
61 | 'total' => $logsRes['total']
62 | ];
63 | }
64 |
65 | /**
66 | * @param int $page
67 | * @param int $count
68 | * @return array
69 | * @throws ParameterException
70 | */
71 | public static function getUserNames(int $page, int $count)
72 | {
73 | list($start, $count) = paginate($count, $page);
74 | $usersRes = LinLogModel::getUserNames($start, $count);
75 | $items = array_map(function ($item) {
76 | return $item['username'];
77 | }, $usersRes['userList']->toArray());
78 |
79 | return [
80 | 'items' => $items,
81 | 'count' => $count,
82 | 'page' => $page,
83 | 'total' => $usersRes['total']
84 | ];
85 | }
86 | }
--------------------------------------------------------------------------------
/application/api/service/admin/User.php:
--------------------------------------------------------------------------------
1 | find();
50 | if ($user) {
51 | throw new RepeatException(['msg' => '用户名已存在']);
52 | }
53 |
54 | if (isset($params['email'])) {
55 | $user = LinUserModel::where('email', $params['email'])->find();
56 | if ($user) {
57 | throw new RepeatException(['msg' => '邮箱地址已存在']);
58 | }
59 | }
60 |
61 | if (isset($params['group_ids'])) {
62 | $groups = LinGroupModel::select($params['group_ids']);
63 | foreach ($groups as $group) {
64 | if ($group['level'] === GroupLevelEnum::ROOT) {
65 | throw new ForbiddenException(['msg' => '不允许分配用户到root分组']);
66 | }
67 | }
68 |
69 | if ($groups->isEmpty()) {
70 | throw new NotFoundException();
71 | }
72 | }
73 |
74 | return self::registerUser($params);
75 | }
76 |
77 | /**
78 | * @param string $username
79 | * @param string $password
80 | * @return Model
81 | * @throws AuthFailedException
82 | * @throws DataNotFoundException
83 | * @throws DbException
84 | * @throws ModelNotFoundException
85 | * @throws NotFoundException
86 | */
87 | public static function verify(string $username, string $password): Model
88 | {
89 | $user = new LinUserIdentityModel();
90 |
91 | $user = $user->where('identifier', $username)
92 | ->where('identity_type', IdentityTypeEnum::PASSWORD)
93 | ->find();
94 |
95 | if (!$user) {
96 | throw new NotFoundException(['msg' => '用户不存在']);
97 | }
98 |
99 | if (!$user->checkPassword($password)) {
100 | throw new AuthFailedException();
101 | }
102 | return $user;
103 | }
104 |
105 | public static function generateTokenExtend(Model $linUserIdentityModel)
106 | {
107 | $user = LinUserModel::get($linUserIdentityModel['user_id']);
108 | $userPermissions = self::getPermissions($user->getAttr('id'));
109 | return [
110 | 'id' => $user->getAttr('id'),
111 | 'identifier' => $linUserIdentityModel->getAttr('identifier'),
112 | 'email' => $user->getAttr('email'),
113 | 'admin' => $userPermissions['admin'],
114 | 'permissions' => $userPermissions['permissions'],
115 | ];
116 | }
117 |
118 | public static function getPermissions(int $uid): array
119 | {
120 | $user = LinUserModel::get($uid);
121 |
122 | $groupIds = LinUserGroupModel::where('user_id', $uid)
123 | ->column('group_id');
124 |
125 | $root = LinGroupModel::where('level', GroupLevelEnum::ROOT)
126 | ->whereIn('id', $groupIds)->find();
127 |
128 | $user = $user->hidden(['username'])->toArray();
129 | $user['admin'] = $root ? true : false;
130 |
131 | if ($root) {
132 | $permissions = LinPermissionModel::where('mount', MountTypeEnum::MOUNT)
133 | ->select()
134 | ->toArray();
135 | $user['permissions'] = formatPermissions($permissions);
136 | } else {
137 | $permissionIds = LinGroupPermissionModel::whereIn('group_id', $groupIds)
138 | ->column('permission_id');
139 | $permissions = LinPermissionModel::where('mount', MountTypeEnum::MOUNT)
140 | ->select($permissionIds)->toArray();
141 |
142 | $user['permissions'] = formatPermissions($permissions);
143 |
144 | }
145 |
146 | return $user;
147 | }
148 |
149 | public static function getInformation(int $uid)
150 | {
151 | return LinUser::get($uid, 'groups');
152 | }
153 |
154 | public static function updateUser(array $params): int
155 | {
156 | $user = LoginToken::getInstance()->getTokenExtend();
157 | if (isset($params['username']) && $params['username'] !== $user['username']) {
158 | $isExit = LinUserModel::where('username', $params['username'])
159 | ->find();
160 | if ($isExit) {
161 | throw new RepeatException(['msg' => "用户名已被占用"]);
162 | }
163 | }
164 |
165 | if (isset($params['email']) && $params['email'] !== $user['email']) {
166 | $isExit = LinUserModel::where('email', $params['email'])
167 | ->find();
168 | if ($isExit) {
169 | throw new RepeatException(['msg' => "邮箱已被占用"]);
170 | }
171 | }
172 |
173 | $user = LinUserModel::get($user['id']);
174 | return $user->allowField(true)->save($params);
175 | }
176 |
177 | public static function changePassword(string $oldPassword, string $newPassword): int
178 | {
179 | $currentUser = LoginToken::getInstance()->getTokenExtend();
180 | $user = new LinUserIdentityModel();
181 |
182 | $user = $user::where('identity_type', IdentityTypeEnum::PASSWORD)
183 | ->where('identifier', $currentUser['identifier'])
184 | ->find();
185 |
186 | if (!$user) {
187 | throw new NotFoundException();
188 | }
189 |
190 | if (!$user->checkPassword($oldPassword)) {
191 | throw new AuthFailedException();
192 | }
193 |
194 | $user->credential = md5($newPassword);
195 | return $user->save();
196 | }
197 |
198 | /**
199 | * @param array $params
200 | * @return LinUserModel
201 | * @throws OperationException
202 | */
203 | private static function registerUser(array $params): LinUserModel
204 | {
205 | Db::startTrans();
206 | try {
207 | $user = LinUserModel::create($params, true);
208 | $user->identity()->save([
209 | 'identity_type' => IdentityTypeEnum::PASSWORD,
210 | 'identifier' => $user['username'],
211 | 'credential' => md5($params['password'])
212 | ]);
213 |
214 | // 判断是否同时分配了分组
215 | if (isset($params['group_ids']) && count($params['group_ids']) > 0) {
216 | $user->groups()->attach($params['group_ids']);
217 | } else {
218 | // 没有分配分组，添加到游客分组
219 | $group = LinGroupModel::where('level', GroupLevelEnum::GUEST)->find();
220 | $user->groups()->attach([$group['id']]);
221 | }
222 | Db::commit();
223 | return $user;
224 | } catch (Exception $ex) {
225 | Db::rollback();
226 | throw new OperationException(['msg' => "注册用户失败：{$ex->getMessage()}"]);
227 | }
228 |
229 | }
230 |
231 | // private static function formatPermissions(array $permissions)
232 | // {
233 | // $groupPermission = [];
234 | // foreach ($permissions as $permission) {
235 | // $item = [
236 | // 'name' => $permission['name'],
237 | // 'module' => $permission['module']
238 | // ];
239 | // $groupPermission[$permission['module']][] = $item;
240 | // }
241 | //
242 | // $result[] = array_map(function ($item) {
243 | // return $item;
244 | // }, $groupPermission);
245 | // return $result;
246 | // }
247 | }
--------------------------------------------------------------------------------
/application/api/service/token/LoginToken.php:
--------------------------------------------------------------------------------
1 | tokenConfig = (new TokenConfig())
42 | ->dualToken($config['enable_dual_token'])
43 | ->setAlgorithms($config['algorithms'])
44 | ->setIat(time())
45 | ->setIss($config['issuer'])
46 | ->setAccessSecretKey($config['access_secret_key'])
47 | ->setAccessExp($config['access_expire_time'])
48 | ->setRefreshSecretKey($config['refresh_secret_key'])
49 | ->setRefreshExp($config['refresh_expire_time']);
50 | }
51 |
52 | public static function getInstance(): LoginToken
53 | {
54 | if (!self::$instance instanceof self) {
55 | self::$instance = new self();
56 | }
57 | return self::$instance;
58 | }
59 |
60 | /**
61 | * 获取令牌
62 | * @param array $extend 要插入到令牌扩展字段中的信息
63 | * @return array
64 | * @throws \Exception
65 | */
66 | public function getToken(array $extend): array
67 | {
68 | $this->tokenConfig->setExtend($extend);
69 | return TokenUtils::makeToken($this->tokenConfig);
70 | }
71 |
72 | /**
73 | * 令牌刷新
74 | * @param string $refreshToken 当开启了双令牌后颁发的refreshToken,用于刷新accessToken
75 | * @return array
76 | * @throws TokenException
77 | */
78 | public function refresh(string $refreshToken): array
79 | {
80 | try {
81 | return TokenUtils::refresh($refreshToken, $this->tokenConfig);
82 | } catch (SignatureInvalidException $signatureInvalidException) {
83 | throw new TokenException(['msg' => '令牌签名错误']);
84 | } catch (BeforeValidException $beforeValidException) {
85 | throw new TokenException();
86 | } catch (ExpiredException $expiredException) {
87 | throw new TokenException(['error_code' => 10042, 'msg' => '令牌已过期，请重新登录']);
88 | } catch (UnexpectedValueException $unexpectedValueException) {
89 | throw new TokenException();
90 | }
91 | }
92 |
93 | /**
94 | * @param string|null $token
95 | * @param string $tokenType
96 | * @return array
97 | * @throws TokenException
98 | */
99 | public function verify(string $token = null, string $tokenType = 'access')
100 | {
101 | $token = $token ?: $this->getTokenFromHeaders();
102 | try {
103 | return TokenUtils::verifyToken($token, $tokenType, $this->tokenConfig);
104 | } catch (SignatureInvalidException $signatureInvalidException) {
105 | throw new TokenException(['msg' => '令牌签名错误']);
106 | } catch (BeforeValidException $beforeValidException) {
107 | throw new TokenException();
108 | } catch (ExpiredException $expiredException) {
109 | throw new TokenException(['error_code' => 10041, 'msg' => '令牌已过期']);
110 | } catch (UnexpectedValueException $unexpectedValueException) {
111 | throw new TokenException();
112 | }
113 | }
114 |
115 | /**
116 | * 获取令牌扩展字段内容
117 | * @param string|null $token
118 | * @param string $tokenType
119 | * @return array
120 | * @throws TokenException
121 | */
122 | public function getTokenExtend(string $token = null, string $tokenType = 'access'): array
123 | {
124 | return (array)$this->verify($token, $tokenType)['extend'];
125 | }
126 |
127 | /**
128 | * 获取指定令牌扩展内容字段的值
129 | * @param string $val
130 | * @return mixed
131 | * @throws TokenException
132 | */
133 | public function getExtendVal(string $val)
134 | {
135 | return $this->getTokenExtend()[$val];
136 | }
137 |
138 | public function getCurrentUid()
139 | {
140 | return $this->getExtendVal('id');
141 | }
142 |
143 | public function getCurrentUserName()
144 | {
145 | return $this->getExtendVal('identifier');
146 | }
147 |
148 | public function getTokenFromHeaders(): string
149 | {
150 | $authorization = Request::header('authorization');
151 |
152 | if (!$authorization) {
153 | throw new TokenException(['msg' => '请求未携带Authorization信息']);
154 | }
155 |
156 | list($type, $token) = explode(' ', $authorization);
157 |
158 | if ($type !== 'Bearer') throw new TokenException(['msg' => '接口认证方式需为Bearer']);
159 |
160 | if (!$token || $token === 'undefined') {
161 | throw new TokenException(['msg' => '尝试获取的Authorization信息不存在']);
162 | }
163 |
164 | return $token;
165 | }
166 | }
--------------------------------------------------------------------------------
/application/api/validate/user/ChangePasswordForm.php:
--------------------------------------------------------------------------------
1 | 'require',
13 | 'new_password|新密码' => 'require|confirm:confirm_password',
14 | 'confirm_password|确认密码' => 'require',
15 | ];
16 | }
--------------------------------------------------------------------------------
/application/api/validate/user/LoginForm.php:
--------------------------------------------------------------------------------
1 | 'require',
18 | 'password' => 'require',
19 | ];
20 |
21 | protected $message = [
22 | 'username' => '用户名不能为空',
23 | 'password' => '密码不能为空'
24 | ];
25 | }
--------------------------------------------------------------------------------
/application/api/validate/user/RegisterForm.php:
--------------------------------------------------------------------------------
1 | 'require|confirm:confirm_password',
18 | 'confirm_password' => 'require',
19 | 'username' => 'require|length:2,10',
20 | 'group_ids' => 'array',
21 | 'email' => 'email'
22 | ];
23 | }
--------------------------------------------------------------------------------
/application/api/validate/user/ResetPasswordValidator.php:
--------------------------------------------------------------------------------
1 | 'require|integer',
18 | 'new_password|新密码' => 'require|confirm:confirm_password',
19 | 'confirm_password|确认密码' => 'require',
20 | ];
21 | }
--------------------------------------------------------------------------------
/application/api/validate/user/UpdateUserForm.php:
--------------------------------------------------------------------------------
1 | 'length:2,10',
18 | 'email' => 'email',
19 | 'nickname' => 'length:2,10',
20 | ];
21 | }
--------------------------------------------------------------------------------
/application/command.php:
--------------------------------------------------------------------------------
1 |
10 | // +----------------------------------------------------------------------
11 |
12 | return [];
13 |
--------------------------------------------------------------------------------
/application/common.php:
--------------------------------------------------------------------------------
1 |
10 | // +----------------------------------------------------------------------
11 |
12 | // 应用公共文件
13 | use LinCmsTp5\exception\ParameterException;
14 | use think\response\Json;
15 |
16 | /**
17 | * 统一响应包装函数
18 | * @param $code
19 | * @param $errorCode
20 | * @param $data
21 | * @param $msg
22 | * @return Json
23 | */
24 | function writeJson($code, $data, $msg = 'ok', $errorCode = 0)
25 | {
26 | $data = [
27 | 'code' => $errorCode,
28 | 'result' => $data,
29 | 'message' => $msg
30 | ];
31 | return json($data, $code);
32 | }
33 |
34 | /**
35 | * 分页参数处理函数
36 | * @param int $count
37 | * @param int $page
38 | * @return array
39 | * @throws ParameterException
40 | */
41 | function paginate(int $count = 10, int $page = 0)
42 | {
43 | // $count = intval(Request::get('count', $count));
44 | // $start = intval(Request::get('page', $page));
45 | // $page = $start;
46 | $count = $count >= 15 ? 15 : $count;
47 | $start = $page * $count;
48 |
49 | if ($start < 0 || $count < 0) throw new ParameterException();
50 |
51 | return [$start, $count];
52 | }
53 |
54 | /**
55 | * 权限数组格式化函数
56 | * @param array $permissions
57 | * @return array
58 | */
59 | function formatPermissions(array $permissions)
60 | {
61 | $groupPermission = [];
62 | foreach ($permissions as $permission) {
63 | $item = [
64 | 'permission' => $permission['name'],
65 | 'module' => $permission['module']
66 | ];
67 | $groupPermission[$permission['module']][] = $item;
68 | }
69 | $result = [];
70 | foreach ($groupPermission as $key => $item) {
71 | array_push($result, [$key => $item]);
72 | }
73 |
74 | return $result;
75 | }
--------------------------------------------------------------------------------
/application/http/middleware/Authentication.php:
--------------------------------------------------------------------------------
1 | check();
23 |
24 | if (!$auth) {
25 | throw new ForbiddenException();
26 | }
27 |
28 | return $next($request);
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/application/index/controller/Index.php:
--------------------------------------------------------------------------------
1 | *{ padding: 0; margin: 0; } div{ padding: 4px 48px;} a{color:#2E5CD5;cursor:
21 | pointer;text-decoration: none} a:hover{text-decoration:underline; } body{ background: #fff; font-family:
22 | "Century Gothic","Microsoft yahei"; color: #333;font-size:18px;} h1{ font-size: 100px; font-weight: normal;
23 | margin-bottom: 12px; } p{ line-height: 1.6em; font-size: 42px }
24 | Lin
心上无垢，林间有风。