fix 权限

netflix-common/src/main/java/com/cyksj/common/annotation/Log.java

@@ -0,0 +1,38 @@
+package com.cyksj.common.annotation;
+
+
+import com.cyksj.enums.BusinessType;
+
+import java.lang.annotation.*;
+
+/*
+ *项目名: yicang-admin
+ *文件名: Log
+ *创建者: JavaZou
+ *创建时间:2022/9/30 10:47
+ */
+@Target({ElementType.PARAMETER, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface Log {
+	/**
+	 * 模块
+	 */
+	String module() default "";
+
+	/**
+	 * 功能
+	 */
+	BusinessType businessType() default BusinessType.OTHER;
+
+	/**
+	 * 是否保存请求的参数
+	 */
+	boolean isSaveRequestData() default false;
+
+	/**
+	 * 是否保存响应的参数
+	 */
+	boolean isSaveResponseData() default false;
+
+}

netflix-common/src/main/java/com/cyksj/enums/BusinessStatus.java

@@ -0,0 +1,19 @@
+package com.cyksj.enums;
+
+/*
+ *项目名: yicang-admin
+ *文件名: BusinessStatus
+ *创建者: JavaZou
+ *创建时间:2022/9/30 11:03
+ */
+public enum BusinessStatus {
+	/**
+	 * 成功
+	 */
+	SUCCESS,
+
+	/**
+	 * 失败
+	 */
+	FAIL,
+}

netflix-common/src/main/java/com/cyksj/enums/BusinessType.java

@@ -0,0 +1,39 @@
+package com.cyksj.enums;
+
+/*
+ *项目名: yicang-admin
+ *文件名: BusinessType
+ *创建者: JavaZou
+ *创建时间:2022/9/30 10:51
+ */
+public enum BusinessType {
+	/**
+	 * 其它
+	 */
+	OTHER,
+
+	/**
+	 * 新增
+	 */
+	POST,
+
+	/**
+	 * 修改
+	 */
+	PUT,
+
+	/**
+	 * 删除
+	 */
+	DELETE,
+
+	/**
+	 * 导出
+	 */
+	EXPORT,
+
+	/**
+	 * 导入
+	 */
+	IMPORT,
+}

netflix-dao/src/main/java/com/cyksj/mapper/manage/cms/CmsMenuMapper.java

@@ -0,0 +1,16 @@
+package com.cyksj.mapper.manage.cms;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.cyksj.model.entity.CmsMenu;
+
+import java.util.List;
+
+/*
+ *项目名: netflix
+ *文件名: CmsMenuMapper
+ *创建者: JavaZou
+ *创建时间:2023/1/11 15:11
+ */
+public interface CmsMenuMapper extends BaseMapper<CmsMenu> {
+	List<CmsMenu> getCmsMenusByUserId(Long userId);
+}

netflix-dao/src/main/java/com/cyksj/mapper/manage/cms/CmsRoleMapper.java

@@ -0,0 +1,16 @@
+package com.cyksj.mapper.manage.cms;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.cyksj.model.entity.CmsRole;
+
+import java.util.List;
+
+/*
+ *项目名: netflix
+ *文件名: CmsRoleMapper
+ *创建者: JavaZou
+ *创建时间:2023/1/11 15:11
+ */
+public interface CmsRoleMapper extends BaseMapper<CmsRole> {
+	List<CmsRole> getCmsRolesByUserId(Long userId);
+}

netflix-dao/src/main/java/com/cyksj/mapper/manage/cms/CmsUserMapper.java

@@ -0,0 +1,15 @@
+package com.cyksj.mapper.manage.cms;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.cyksj.model.entity.CmsUser;
+import com.cyksj.model.views.CmsUserVO;
+
+/*
+ *项目名: netflix
+ *文件名: CmsUserMapper
+ *创建者: JavaZou
+ *创建时间:2023/1/11 15:10
+ */
+public interface CmsUserMapper extends BaseMapper<CmsUser> {
+	CmsUserVO getCmsUserDetailByUserId(Long userId);
+}

netflix-dao/src/main/java/com/cyksj/model/entity/CmsMenu.java

@@ -0,0 +1,28 @@
+package com.cyksj.model.entity;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/*
+ *项目名: netflix
+ *文件名: CmsMenu
+ *创建者: JavaZou
+ *创建时间:2023/1/11 15:06
+ */
+@Getter
+@Setter
+public class CmsMenu extends BaseEntity{
+	private String title;
+
+	private String menuName;
+
+	private String perms;
+
+	private String type;
+
+	private String path;
+
+	private Integer order;
+
+	private Integer parentId;
+}

netflix-dao/src/main/java/com/cyksj/model/entity/CmsRole.java

@@ -0,0 +1,18 @@
+package com.cyksj.model.entity;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/*
+ *项目名: netflix
+ *文件名: CmsRole
+ *创建者: JavaZou
+ *创建时间:2023/1/11 15:05
+ */
+@Getter
+@Setter
+public class CmsRole extends BaseEntity{
+	private String roleName;
+
+	private String remark;
+}

netflix-dao/src/main/java/com/cyksj/model/entity/CmsRoleMenu.java

@@ -0,0 +1,18 @@
+package com.cyksj.model.entity;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/*
+ *项目名: netflix
+ *文件名: CmsRoleMenu
+ *创建者: JavaZou
+ *创建时间:2023/1/11 15:08
+ */
+@Getter
+@Setter
+public class CmsRoleMenu extends BaseEntity{
+	private Long roleId;
+
+	private Long menuId;
+}

netflix-dao/src/main/java/com/cyksj/model/entity/CmsUser.java

@@ -0,0 +1,54 @@
+package com.cyksj.model.entity;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import javax.validation.constraints.NotBlank;
+
+/*
+ *项目名: netflix
+ *文件名: CmsUser
+ *创建者: JavaZou
+ *创建时间:2023/1/11 14:27
+ */
+@Getter
+@Setter
+public class CmsUser extends BaseEntity{
+	/**
+	 * 管理员昵称
+	 */
+	@NotBlank(message = "请填写负责人姓名")
+	private String nickname;
+
+	/**
+	 * 账号
+	 */
+	private String username;
+
+	/**
+	 * 管理帐户密码
+	 */
+	private String password;
+
+	/**
+	 * 手机号码
+	 */
+	@NotBlank(message = "手机号不能为空")
+	private String phone;
+
+	/**
+	 * 添加人
+	 */
+	private String addName;
+
+	/**
+	 * 修改人
+	 */
+	private String modifiedBy;
+
+
+	/**
+	 * 管理员是否允许登录
+	 */
+	private Boolean status;
+}

netflix-dao/src/main/java/com/cyksj/model/entity/CmsUserRole.java

@@ -0,0 +1,18 @@
+package com.cyksj.model.entity;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/*
+ *项目名: netflix
+ *文件名: CmsUserRole
+ *创建者: JavaZou
+ *创建时间:2023/1/11 15:08
+ */
+@Getter
+@Setter
+public class CmsUserRole extends BaseEntity{
+	private Long userId;
+
+	private Long roleId;
+}

netflix-dao/src/main/java/com/cyksj/model/entity/SysLog.java

@@ -0,0 +1,89 @@
+package com.cyksj.model.entity;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/*
+ *项目名: yicang-admin
+ *文件名: SysLog
+ *创建者: JavaZou
+ *创建时间:2022/9/30 11:24
+ */
+@Getter
+@Setter
+public class SysLog extends BaseEntity {
+	/**
+	 * 操作人
+	 */
+	private String operator;
+
+	/**
+	 * 用户账号
+	 */
+	private String account;
+
+	/**
+	 * 操作模块
+	 */
+	private String module;
+
+	/**
+	 * 功能
+	 */
+	private String business;
+
+	/**
+	 * 功能业务
+	 */
+	private Integer businessType;
+
+	/**
+	 * 方法名
+	 */
+	private String method;
+
+	/**
+	 * 请求方式
+	 */
+	private String requestMethod;
+
+	/**
+	 * 操作url
+	 */
+	private String operateUrl;
+
+	/**
+	 * 操作ip
+	 */
+	private String operateIp;
+
+	/**
+	 * 操作地点
+	 */
+	private String operateLocation;
+
+	/**
+	 * 请求参数
+	 */
+	private String operateParams;
+
+	/**
+	 * 返回参数
+	 */
+	private String jsonResult;
+
+	/**
+	 * 状态
+	 */
+	private Integer status;
+
+	/**
+	 * 错误信息
+	 */
+	private String errMsg;
+
+	/**
+	 * 操作时间
+	 */
+	private String operateTime;
+}

netflix-dao/src/main/java/com/cyksj/model/manage/dto/AdminInfo.java

@@ -1,6 +1,6 @@
 package com.cyksj.model.manage.dto;
 
-import com.cyksj.model.manage.entity.Admin;
+import com.cyksj.model.entity.CmsUser;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
@@ -20,5 +20,5 @@ public class AdminInfo implements Serializable {
 
     private String token;
 
-    private Admin info;
+    private CmsUser info;
 }

netflix-dao/src/main/java/com/cyksj/model/views/CmsUserVO.java

@@ -0,0 +1,60 @@
+package com.cyksj.model.views;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.Set;
+
+/*
+ *项目名: yicang-admin
+ *文件名: CmsUserVO
+ *创建者: JavaZou
+ *创建时间:2022/9/30 13:34
+ */
+@Getter
+@Setter
+public class CmsUserVO {
+	private Integer id;
+
+	private String username;
+
+	/**
+	 * 用户名称
+	 */
+	private String nickname;
+
+	/**
+	 * 角色名称
+	 */
+	private String roleNames;
+
+	private String roleIds;
+
+	private String token;
+
+	private Boolean status;
+
+	/**
+	 * 添加人
+	 */
+	private String addName;
+
+	/**
+	 * 修改人
+	 */
+	private String modifiedBy;
+
+	/**
+	 * 权限列表
+	 */
+	private Set<String> permissions;
+
+	/**
+	 * 角色列表
+	 */
+	private Set<String> roles;
+
+	private String createDisplay;
+
+	private String updateDisplay;
+}

netflix-dao/src/main/resources/mapper/CmsMenuMapper.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+
+<mapper namespace="com.cyksj.mapper.manage.cms.CmsMenuMapper">
+
+    <select id="getCmsMenusByUserId" resultType="com.cyksj.model.entity.CmsMenu">
+        select distinct m.id,
+                        m.title,
+                        m.menu_name,
+                        m.perms,
+                        m.type,
+                        m.order,
+                        m.parent_id
+        from `cmsMenu` m
+                 inner join `cms_role_menu` um on m.id = um.menu_id
+                 inner join `cms_user_role` cur on cur.roleId = um.role_id
+                 inner join `cms_user` u on u.id = cur.user_id
+        where u.id = #{userId}
+    </select>
+</mapper>

netflix-dao/src/main/resources/mapper/CmsRoleMapper.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+
+<mapper namespace="com.cyksj.mapper.manage.cms.CmsRoleMapper">
+
+    <select id="getCmsRolesByUserId" resultType="com.cyksj.model.entity.CmsRole">
+        select distinct r.id,
+                        r.role_name,
+                        r.remark
+        from `cms_role` r
+                 inner join `cms_user_role` ur on r.id = ur.role_id
+                 inner join `cms_user` u on u.id = ur.user_id
+        where u.id = #{userId}
+    </select>
+</mapper>

netflix-dao/src/main/resources/mapper/CmsUserMapper.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+
+<mapper namespace="com.cyksj.mapper.manage.cms.CmsUserMapper">
+
+    <select id="getCmsUserDetailByUserId" resultType="com.cyksj.model.views.CmsUserVO">
+        select any_value(u.username),
+               any_value(u.nickname),
+               group_concat(r.role_name)
+        from `cmsUser` u
+                 inner join `cms_user_role` ur on u.id = ur.user_id
+                 inner join `cms_role` r on r.id = ur.role_id
+        where u.id = #{userId}
+        group by r.id
+    </select>
+</mapper>

netflix-service/src/main/java/com/cyksj/redis/RedisService.java

@@ -593,6 +593,9 @@ public class RedisService {
         EMAIL_CODE_KEY("email_code_key:%s", "邮箱验证码", 60 * 3),
         LOTTERY_KEY("lottery_key:%s", "抽奖key", 60 * 60 * 24l),
         TASK_TIME_LIMIT_KEY("task_time_limit:%s", "一次性任务key", 30),
+        CMS_USER_KEY("cms:user:%s:", "user缓存前缀", 60 * 60 * 24L * 7),
+        CMS_USER_ROLE_KEY("cms:user:role:%s:", "user角色缓存前缀", 60 * 60 * 24L * 7),
+        CMS_USER_PERMISSION_KEY("cms:user:permission:%s:", "user权限缓存前缀", 60 * 60 * 24L * 7),
         ;
 
         private String name;

netflix-service/src/main/java/com/cyksj/service/mange/cms/AbstractCmsMenuService.java

@@ -0,0 +1,120 @@
+package com.cyksj.service.mange.cms;
+
+import cn.dev33.satoken.annotation.SaCheckLogin;
+import cn.dev33.satoken.annotation.SaCheckPermission;
+import cn.dev33.satoken.stp.StpUtil;
+import cn.hutool.core.util.ObjectUtil;
+import org.elsa.mxx.api.controller.cms.AbstractCmsMenu;
+import org.elsa.mxx.api.response.latest.Callback;
+import org.elsa.mxx.api.response.latest.ListOut;
+import org.elsa.mxx.common.exception.NoteException;
+import org.elsa.mxx.core.entity.CmsMenu;
+import org.elsa.mxx.core.entity.CmsUser;
+import org.elsa.mxx.core.view.CmsMenuVO;
+import org.springframework.beans.BeanUtils;
+import org.springframework.stereotype.Service;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/*
+ *项目名: yicang-admin
+ *文件名: AbstractCmsMenuService
+ *创建者: JavaZou
+ *创建时间:2022/9/30 17:13
+ */
+@Service
+public class AbstractCmsMenuService extends AbstractCmsMenu {
+
+	@Override
+	public Callback<String> addMenu(@RequestBody CmsMenu cmsMenu) {
+		if (ObjectUtil.hasEmpty(cmsMenu.getTitle(), cmsMenu.getMenuName(), cmsMenu.getType())) {
+			throw new NoteException("必填项为空");
+		}
+		super.baseDao2.save(cmsMenu);
+		return Callback.<String>success().setMsg("新增菜单成功");
+	}
+
+	@Override
+	public Callback<String> putMenu(@RequestBody CmsMenu cmsMenu) throws Exception {
+		if (cmsMenu.getId() == null || cmsMenu.getId() < 1) {
+			throw new NoteException("菜单不存在");
+		}
+		CmsMenu menu = baseDao2.selectOneById(CmsMenu.class, cmsMenu.getId());
+		BeanUtils.copyProperties(cmsMenu, menu);
+		super.baseDao2.update(menu);
+		//更新该菜单关联的权限
+		List<CmsUser> cmsUserList = cmsMenuMapper.getAllCmsUserByMenuId(cmsMenu.getId());
+		if (null != cmsUserList) {
+			for (CmsUser cmsUser : cmsUserList) {
+				cmsUserManager.loadUserRedisCache(cmsUser);
+			}
+		}
+		return Callback.<String>success().setMsg("编辑菜单成功");
+	}
+
+	@Override
+	public Callback<String> deleteMenuById(@PathVariable("id") Integer id) throws Exception {
+		if (id == null || id < 1) {
+			throw new NoteException("菜单不存在");
+		}
+		List<CmsUser> cmsUserList = cmsMenuMapper.getAllCmsUserByMenuId(id);
+		if (null != cmsUserList) {
+			for (CmsUser cmsUser : cmsUserList) {
+				cmsUserManager.loadUserRedisCache(cmsUser);
+			}
+		}
+		cmsMenuMapper.deleteAllMenuRoleRelation(id);
+		cmsMenuMapper.deleteMenuAndChild(id);
+		return Callback.<String>success().setMsg("删除菜单成功");
+	}
+
+	@Override
+	@SaCheckPermission("menu:view")
+	public Callback<ListOut<CmsMenuVO>> getMenuList() {
+		Map<Integer, List<CmsMenuVO>> idMenusMap = cmsMenuMapper.getALlMenu().stream().collect(Collectors.groupingBy(CmsMenu::getParentId));
+		List<CmsMenuVO> list = cmsMenuMapper.getCmsMenusList();
+		for (CmsMenuVO cmsMenuVO : list) {
+			findChildMenu(cmsMenuVO, idMenusMap);
+		}
+		Integer size = cmsMenuMapper.countCmsMenu();
+		return Callback.<ListOut<CmsMenuVO>>success().setData(ListOut.<CmsMenuVO>create().setList(list).setTotal(size));
+	}
+
+	@Override
+	@SaCheckLogin
+	public Callback<ListOut<CmsMenuVO>> getNoPermsALLMenu() {
+		Map<Integer, List<CmsMenuVO>> idMenusMap = cmsMenuMapper.getALlMenu().stream().collect(Collectors.groupingBy(CmsMenu::getParentId));
+		List<CmsMenuVO> list = cmsMenuMapper.getCmsMenusList();
+		for (CmsMenuVO cmsMenuVO : list) {
+			findChildMenu(cmsMenuVO, idMenusMap);
+		}
+		Integer size = cmsMenuMapper.countCmsMenu();
+		return Callback.<ListOut<CmsMenuVO>>success().setData(ListOut.<CmsMenuVO>create().setList(list).setTotal(size));
+	}
+
+	private void findChildMenu(CmsMenuVO cmsMenuVO, Map<Integer, List<CmsMenuVO>> idMenusMap) {
+		List<CmsMenuVO> list = idMenusMap.get(cmsMenuVO.getId());
+		cmsMenuVO.setHasChildren(false);
+		if (list != null && list.size() > 0) {
+			cmsMenuVO.setChild(list);
+			cmsMenuVO.setHasChildren(true);
+			list.forEach(child -> findChildMenu(child, idMenusMap));
+		}
+	}
+
+	@SaCheckLogin
+	@Override
+	public Callback<ListOut<CmsMenuVO>> getSelfMenuList() {
+		List<CmsMenuVO> allSelf = cmsMenuMapper.getSelfCmsMenusList(StpUtil.getLoginIdAsString());
+		Map<Integer, List<CmsMenuVO>> idMenusMap = allSelf.stream().collect(Collectors.groupingBy(CmsMenu::getParentId));
+		List<CmsMenuVO> list = allSelf.stream().filter(vo -> vo.getParentId() == 0).collect(Collectors.toList());
+		for (CmsMenuVO cmsMenuVO : list) {
+			findChildMenu(cmsMenuVO, idMenusMap);
+		}
+		return Callback.<ListOut<CmsMenuVO>>success().setData(ListOut.<CmsMenuVO>create().setList(list));
+	}
+}

netflix-service/src/main/java/com/cyksj/service/mange/cms/AbstractCmsRoleService.java

@@ -0,0 +1,134 @@
+package com.cyksj.service.mange.cms;
+
+import cn.dev33.satoken.annotation.SaCheckLogin;
+import cn.hutool.core.util.StrUtil;
+import org.elsa.mxx.api.controller.cms.AbstractCmsRole;
+import org.elsa.mxx.api.request.CmsRoleReq;
+import org.elsa.mxx.api.response.latest.Callback;
+import org.elsa.mxx.api.response.latest.ListOut;
+import org.elsa.mxx.common.exception.NoteException;
+import org.elsa.mxx.core.entity.CmsRole;
+import org.elsa.mxx.core.entity.CmsRoleMenu;
+import org.elsa.mxx.core.entity.CmsUser;
+import org.springframework.beans.BeanUtils;
+import org.springframework.dao.DuplicateKeyException;
+import org.springframework.stereotype.Service;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestParam;
+
+import java.util.Arrays;
+import java.util.List;
+
+/*
+ *项目名: yicang-admin
+ *文件名: AbstractCmsRoleService
+ *创建者: JavaZou
+ *创建时间:2022/9/30 16:11
+ */
+@Service
+public class AbstractCmsRoleService extends AbstractCmsRole {
+
+	@Override
+	public Callback<String> addRole(@RequestBody CmsRoleReq cmsRoleReq) {
+		try {
+			if (StrUtil.isEmpty(cmsRoleReq.getRoleName())) {
+				throw new NoteException("必填项不能为空");
+			}
+			if (StrUtil.isEmpty(cmsRoleReq.getMenuIds())) {
+				throw new NoteException("请选择对应的菜单");
+			}
+			CmsRole cmsRole = new CmsRole();
+			BeanUtils.copyProperties(cmsRoleReq, cmsRole);
+			super.baseDao2.save(cmsRole);
+			cmsRoleReq.setId(cmsRole.getId());
+			if (StrUtil.isNotEmpty(cmsRoleReq.getMenuIds())) {
+				saveRoleMenuRelation(cmsRoleReq);
+			}
+		} catch (DuplicateKeyException keyEx) {
+			throw new NoteException("角色名重复");
+		}
+		return Callback.<String>success().setMsg("新增角色成功");
+	}
+
+	@Override
+	public Callback<String> putRole(@RequestBody CmsRoleReq cmsRoleReq) throws Exception {
+		if (cmsRoleReq.getId() == null || cmsRoleReq.getId() < 0) {
+			throw new NoteException("角色不存在");
+		}
+		if (StrUtil.isEmpty(cmsRoleReq.getMenuIds())) {
+			throw new NoteException("请选择对应的菜单");
+		}
+		CmsRole cmsRole = super.baseDao2.selectOneById(CmsRole.class, cmsRoleReq.getId());
+		Boolean isFlag = false;
+		if (StrUtil.isNotBlank(cmsRoleReq.getRoleName())) {
+			cmsRole.setRoleName(cmsRoleReq.getRoleName());
+			isFlag = true;
+		}
+		if (StrUtil.isNotBlank(cmsRoleReq.getRemark())) {
+			cmsRole.setRemark(cmsRoleReq.getRemark());
+			isFlag = true;
+		}
+		if (isFlag) {
+			super.baseDao2.save(cmsRole);
+		}
+		cmsRoleMapper.deleteMenuRoleRelation(cmsRoleReq.getId());
+		if (StrUtil.isNotBlank(cmsRoleReq.getMenuIds())) {
+			this.saveRoleMenuRelation(cmsRoleReq);
+		}
+		//查出所关联该角色的所有用户
+		List<CmsUser> cmsUserList = cmsRoleMapper.getAllCmsUserByRoleId(cmsRoleReq.getId());
+		if (cmsUserList != null) {
+			for (CmsUser cmsUser : cmsUserList) {
+				//更新缓存
+				cmsUserManager.loadUserRedisCache(cmsUser);
+			}
+		}
+		return Callback.<String>success().setMsg("更新角色成功");
+	}
+
+	@Override
+	public Callback<String> delRoleById(@PathVariable("id") Integer id) {
+		if (id == null || id < 0) {
+			throw new NoteException("角色不存在");
+		}
+		List<CmsUser> cmsUserList = cmsRoleMapper.getAllCmsUserByRoleId(id);
+		if (null != cmsUserList && !cmsUserList.isEmpty()) {
+			throw new NoteException("请先删除该角色关联下的用户");
+		}
+		cmsRoleMapper.deleteMenuRoleRelation(id);
+		super.baseDao2.deleteById(CmsRole.class, id);
+		return Callback.<String>success().setMsg("删除角色成功");
+	}
+
+
+	@Override
+	public Callback<ListOut<CmsRole>> getRoleList(@RequestParam(required = false, defaultValue = "1") Integer start, @RequestParam(required = false, defaultValue = "5") Integer limit) {
+		List<CmsRole> list = cmsRoleMapper.getCmsRoleList((start - 1) * limit, limit);
+		Integer size = cmsRoleMapper.countCmsRole();
+		return Callback.<ListOut<CmsRole>>success().setData(ListOut.<CmsRole>create().setList(list).setTotal(size));
+	}
+
+	@Override
+	@SaCheckLogin
+	public Callback<List<String>> getMenuByRoleId(String roleId) {
+		if (StrUtil.isEmpty(roleId)) {
+			throw new NoteException("角色不存在");
+		}
+		//目前是单个角色
+		List<String> menus = cmsRoleMapper.getAllMenusByRoleIds(roleId.split(","));
+		return Callback.<List<String>>success().setData(menus);
+	}
+
+	@Override
+	@SaCheckLogin
+	public Callback<CmsRole> getDetailByRoleId(@PathVariable("roleId") Integer roleId) {
+		return Callback.<CmsRole>success().setData(baseDao2.selectOneById(CmsRole.class, roleId));
+	}
+
+	private void saveRoleMenuRelation(CmsRoleReq cmsRoleReq) {
+		Arrays.stream(cmsRoleReq.getMenuIds().split(",")).forEach(menuId -> {
+			super.baseDao2.save(new CmsRoleMenu(cmsRoleReq.getId(), Integer.valueOf(menuId)));
+		});
+	}
+}

netflix-service/src/main/java/com/cyksj/service/mange/cms/AbstractCmsUserService.java

@@ -0,0 +1,191 @@
+package com.cyksj.service.mange.cms;
+
+import cn.dev33.satoken.annotation.SaCheckLogin;
+import cn.dev33.satoken.annotation.SaCheckPermission;
+import cn.dev33.satoken.stp.StpUtil;
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
+import lombok.SneakyThrows;
+import org.elsa.mxx.api.controller.cms.AbstractCmsUser;
+import org.elsa.mxx.api.request.CmsUserReq;
+import org.elsa.mxx.api.request.UpdatePwdReq;
+import org.elsa.mxx.api.response.latest.Callback;
+import org.elsa.mxx.api.response.latest.GatewayResponse;
+import org.elsa.mxx.api.response.latest.ListOut;
+import org.elsa.mxx.common.annotation.Log;
+import org.elsa.mxx.common.enums.BusinessType;
+import org.elsa.mxx.common.exception.NoteException;
+import org.elsa.mxx.common.utils.Codec;
+import org.elsa.mxx.core.entity.CmsUser;
+import org.elsa.mxx.core.view.CmsUserVO;
+import org.springframework.dao.DuplicateKeyException;
+import org.springframework.stereotype.Service;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestParam;
+
+import java.util.List;
+
+/*
+ *项目名: yicang-admin
+ *文件名: AbstractCmsUserService
+ *创建者: JavaZou
+ *创建时间:2022/9/30 13:40
+ */
+@Service
+public class AbstractCmsUserService extends AbstractCmsUser {
+
+	@Override
+	public Callback<CmsUserVO> login(@RequestBody CmsUser cmsUser) throws Exception {
+		if (StrUtil.isEmpty(cmsUser.getAccount()) || StrUtil.isEmpty(cmsUser.getPassword())) {
+			throw new NoteException("登录信息为空");
+		}
+		CmsUser user = cmsUserMapper.getCmsUserByAccount(cmsUser.getAccount());
+		if (user == null) {
+			throw new NoteException(GatewayResponse.GatewayApiCode.CMS_USER_NO_FIND.getMsg());
+		}
+		String encodePasscode = Codec.DoDigest.custom().setAlgorithm(Codec.DoDigest.Algorithm.SHA256).setStringData(cmsUser.getPassword()).toBase64String();
+		if (!StrUtil.equals(user.getPassword(), encodePasscode)) {
+			throw new NoteException(GatewayResponse.GatewayApiCode.CMS_USER_PASSWORD_ERROR.getMsg());
+		}
+		if (!user.getStatus()) {
+			throw new NoteException(GatewayResponse.GatewayApiCode.CMS_USER_FROZEN.getMsg());
+		}
+		CmsUserVO cmsUserVO = new CmsUserVO();
+		BeanUtil.copyProperties(user, cmsUserVO);
+		StpUtil.login(cmsUser.getAccount());
+		//token
+		cmsUserVO.setToken(StpUtil.getTokenValue());
+		//缓存用户信息
+		cmsUserManager.loadUserRedisCache(user);
+
+		//用户权限
+		cmsUserVO.setPermissions(cmsUserManager.getUserPermissions(user.getAccount()));
+
+		//用户角色
+		cmsUserVO.setRoles(cmsUserManager.getUserRoles(user.getAccount()));
+
+		return Callback.<CmsUserVO>success().setData(cmsUserVO);
+	}
+
+	@SneakyThrows
+	@Log(module = "用户管理/新增角色", isSaveRequestData = true, isSaveResponseData = true, businessType = BusinessType.POST)
+	@Override
+	public Callback<String> addUser(@RequestBody CmsUserReq cmsUserReq) {
+		try {
+			if (ObjectUtil.hasEmpty(cmsUserReq.getAccount(), cmsUserReq.getNickName(), cmsUserReq.getRoleIds())) {
+				throw new NoteException("必填项不能为空");
+			}
+			CmsUser cmsUser = new CmsUser();
+			BeanUtil.copyProperties(cmsUserReq, cmsUser);
+			//添加人
+			CmsUser addUser = cmsUserManager.getUser(StpUtil.getLoginIdAsString());
+			cmsUser.setAddName(addUser.getNickName());
+			cmsUser.setPassword(Codec.DoDigest.custom().setAlgorithm(Codec.DoDigest.Algorithm.SHA256).setStringData(initialPwd).toBase64String());
+			super.baseDao2.save(cmsUser);
+			//保存用户角色关系
+			cmsUserManager.saveUserRoleRelation(cmsUser.getId(), cmsUserReq.getRoleIds());
+		} catch (DuplicateKeyException keyEx) {
+			throw new NoteException("用户账户重复");
+		}
+		return Callback.<String>success().setMsg("新增用户成功");
+	}
+
+	@Log(module = "用户管理/修改角色", isSaveRequestData = true, isSaveResponseData = true, businessType = BusinessType.PUT)
+	@Override
+	public Callback<String> updateUser(@RequestBody CmsUserReq cmsUserReq) throws Exception {
+		if (cmsUserReq.getId() == null || cmsUserReq.getId() < 1) {
+			throw new NoteException("id error");
+		}
+		CmsUser cmsUser = super.baseDao2.selectOneById(CmsUser.class, cmsUserReq.getId());
+		if (cmsUser == null) {
+			throw new NoteException(GatewayResponse.GatewayApiCode.CMS_USER_NO_FIND.getMsg());
+		}
+		if (StrUtil.isNotBlank(cmsUserReq.getNickName())) {
+			cmsUser.setNickName(cmsUserReq.getNickName());
+		}
+		if (StrUtil.isNotBlank(cmsUserReq.getRoleIds())) {
+			cmsUserManager.delUserRoleRelation(cmsUser);
+			cmsUserManager.saveUserRoleRelationAndCache(cmsUser, cmsUserReq.getRoleIds());
+		}
+		//修改人
+		CmsUser update = cmsUserManager.getUser(StpUtil.getLoginIdAsString());
+		cmsUser.setModifiedBy(update.getNickName());
+		baseDao2.update(cmsUser);
+		return Callback.<String>success().setMsg("更新用户成功");
+	}
+
+	@Log(module = "用户管理/状态变更", isSaveRequestData = true, isSaveResponseData = true, businessType = BusinessType.OTHER)
+	@Override
+	public Callback<String> updateUserStatus(@PathVariable("id") Integer id) {
+		if (id == null || id < 1) {
+			throw new NoteException(GatewayResponse.GatewayApiCode.CMS_USER_NO_FIND.getMsg());
+		}
+		CmsUser cmsUser = baseDao2.selectOneById(CmsUser.class, id);
+		if (cmsUser == null) {
+			throw new NoteException(GatewayResponse.GatewayApiCode.CMS_USER_NO_FIND.getMsg());
+		}
+		cmsUser.setStatus(!cmsUser.getStatus());
+		baseDao2.update(cmsUser);
+		if (!cmsUser.getStatus()) {
+			//状态为禁用时,将上线的用户下线
+			StpUtil.logout(cmsUser.getAccount());
+		}
+		return Callback.<String>success().setMsg("用户状态变更成功");
+	}
+
+	@SneakyThrows
+	@Override
+	public Callback<String> resetPwd(@PathVariable("id") Integer id) {
+		CmsUser cmsUser = baseDao2.selectOneById(CmsUser.class, id);
+		cmsUser.setPassword(Codec.DoDigest.custom().setAlgorithm(Codec.DoDigest.Algorithm.SHA256).setStringData(initialPwd).toBase64String());
+		baseDao2.update(cmsUser);
+		cacheService.saveUser(cmsUser.getAccount());
+		return Callback.<String>success().setMsg("重置密码成功");
+	}
+
+	@SneakyThrows
+	@SaCheckLogin
+	@Override
+	public Callback<String> updateUserPwd(@RequestBody UpdatePwdReq updatePwdReq) {
+		if (ObjectUtil.hasEmpty(updatePwdReq.getOldPwd(), updatePwdReq.getNewPwd())) {
+			throw new NoteException("必填项为空");
+		}
+		CmsUser user = cmsUserManager.getUser(StpUtil.getLoginIdAsString());
+		String oldPwdSha = Codec.DoDigest.custom().setAlgorithm(Codec.DoDigest.Algorithm.SHA256).setStringData(updatePwdReq.getOldPwd()).toBase64String();
+		if (!StrUtil.equals(oldPwdSha, user.getPassword())) {
+			throw new NoteException("旧密码错误");
+		}
+		String newPwdSha = Codec.DoDigest.custom().setAlgorithm(Codec.DoDigest.Algorithm.SHA256).setStringData(updatePwdReq.getNewPwd()).toBase64String();
+		user.setPassword(newPwdSha);
+		baseDao2.update(user);
+		cacheService.saveUser(user.getAccount());
+		return Callback.<String>success().setMsg("修改密码成功");
+	}
+
+	@SaCheckLogin
+	@Override
+	public Callback<String> logout() {
+		StpUtil.logout(StpUtil.getLoginIdAsString());
+		return Callback.<String>success().setMsg("退出登录成功");
+	}
+
+	@Log(module = "用户管理/删除用户", isSaveRequestData = true, businessType = BusinessType.DELETE)
+	@Override
+	public Callback<String> delUserById(@PathVariable("id") Integer id) throws Exception {
+		CmsUser cmsUser = super.baseDao2.selectOneById(CmsUser.class, id);
+		//删除用户角色关联关系、缓存
+		cmsUserManager.delUserRoleRelation(cmsUser);
+		super.baseDao2.deleteById(CmsUser.class, id);
+		return Callback.<String>success().setMsg("删除用户成功");
+	}
+
+	@Override
+	@SaCheckPermission("accountList:view")
+	public Callback<ListOut<CmsUserVO>> getUserList(Boolean status, @RequestParam(required = false, defaultValue = "1") Integer start, @RequestParam(required = false, defaultValue = "5") Integer limit) {
+		List<CmsUserVO> users = cmsUserMapper.getCmsUserList(status, (start - 1) * limit, limit);
+		Integer size = cmsUserMapper.countCmsUser(status);
+		return Callback.<ListOut<CmsUserVO>>success().setData(ListOut.<CmsUserVO>create().setList(users).setTotal(size));
+	}
+}

netflix-service/src/main/java/com/cyksj/service/mange/cms/AbstractSysService.java

@@ -0,0 +1,31 @@
+package com.cyksj.service.mange.cms;
+
+import cn.dev33.satoken.annotation.SaCheckPermission;
+import org.elsa.mxx.api.controller.cms.AbstractSys;
+import org.elsa.mxx.api.response.latest.Callback;
+import org.elsa.mxx.api.response.latest.ListOut;
+import org.elsa.mxx.core.entity.SysLog;
+import org.springframework.stereotype.Service;
+import org.springframework.web.bind.annotation.RequestParam;
+
+import java.util.List;
+
+/*
+ *项目名: yicang-admin
+ *文件名: AbstractSysService
+ *创建者: JavaZou
+ *创建时间:2022/10/8 13:36
+ */
+@Service
+public class AbstractSysService extends AbstractSys {
+
+	@Override
+	@SaCheckPermission("accountRecord:view")
+	public Callback<ListOut<SysLog>> sysLogListByCondition(String account, Long startTime, Long endTime,
+	                                                       @RequestParam(required = false, defaultValue = "1") Long start,
+	                                                       @RequestParam(required = false, defaultValue = "5") Long limit) {
+		List<SysLog> list = super.sysLogMapper.getSysLogListByCondition(account, startTime, endTime, (start - 1) * limit, limit);
+		Integer size = super.sysLogMapper.countSysLogListByCondition(account, startTime, endTime);
+		return Callback.<ListOut<SysLog>>success().setData(ListOut.<SysLog>create().setList(list).setTotal(size));
+	}
+}

netflix-service/src/main/java/com/cyksj/service/mange/cms/manager/CmsUserManager.java

@@ -0,0 +1,119 @@
+package com.cyksj.service.mange.cms.manager;
+
+import com.cyksj.mapper.manage.cms.CmsMenuMapper;
+import com.cyksj.mapper.manage.cms.CmsRoleMapper;
+import com.cyksj.mapper.manage.cms.CmsUserMapper;
+import com.cyksj.model.entity.CmsMenu;
+import com.cyksj.model.entity.CmsRole;
+import com.cyksj.model.entity.CmsUser;
+import com.cyksj.model.entity.CmsUserRole;
+import com.cyksj.service.mange.cms.manager.service.CacheService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+/*
+ *项目名: yicang-admin
+ *文件名: CmsUserManager
+ *创建者: JavaZou
+ *创建时间:2022/9/30 13:59
+ */
+@Service
+@Slf4j
+@RequiredArgsConstructor
+public class CmsUserManager {
+	private final CacheService cacheService;
+
+	private final CmsUserMapper cmsUserMapper;
+
+	private final CmsRoleMapper cmsRoleMapper;
+
+	private final CmsMenuMapper cmsMenuMapper;
+
+	public CmsUser getUser(String account) {
+		return selectCacheByTemplate(() -> cacheService.getUserCache(account), () -> cmsUserMapper.getCmsUserByAccount(account));
+	}
+
+
+	public void loadUserRedisCache(CmsUser user) throws Exception {
+		cacheService.saveUser(user.getId());
+		// 缓存用户角色
+		cacheService.saveRoles(user.getId());
+		// 缓存用户权限
+		cacheService.savePermissions(user.getId());
+	}
+
+	public Set<String> getUserPermissions(String account) {
+		List<CmsMenu> cmsMenus = selectCacheByTemplate(() -> cacheService.getUserPermsCache(account), () -> cmsMenuMapper.getCmsMenusByAccount(account));
+		if (cmsMenus == null) {
+			return null;
+		}
+		return cmsMenus.stream().map(CmsMenu::getPerms).collect(Collectors.toSet());
+	}
+
+	public Set<String> getUserRoles(String account) {
+		List<CmsRole> cmsRoles = selectCacheByTemplate(
+				() -> cacheService.getUserRoleCache(account),
+				() -> cmsRoleMapper.getCmsRolesByAccount(account)
+		);
+		if (cmsRoles == null) {
+			return null;
+		}
+		return cmsRoles.stream().map(CmsRole::getRoleName).collect(Collectors.toSet());
+	}
+
+	/**
+	 * 缓存查询模板
+	 *
+	 * @param cacheSelector    查询缓存的方法
+	 * @param databaseSelector 数据库查询方法
+	 * @return T
+	 */
+	public static <T> T selectCacheByTemplate(Supplier<T> cacheSelector, Supplier<T> databaseSelector) {
+		try {
+			log.debug("查询redis ······");
+			// 先查 Redis缓存
+			T t = cacheSelector.get();
+			if (t == null) {
+				// 没有记录再查询数据库
+				return databaseSelector.get();
+			}
+			return t;
+		} catch (Exception e) {
+			// 缓存查询出错，则去数据库查询
+			log.error("redis查询 error：", e);
+			log.debug("查询数据库 ······");
+			return databaseSelector.get();
+		}
+	}
+
+	public void saveUserRoleRelation(Integer userId, String roleIds) {
+		Arrays.stream(roleIds.split(",")).forEach(roleId->{
+			baseDao2.save(new CmsUserRole(userId, roleId));
+		});
+	}
+
+	public void delUserRoleRelation(CmsUser cmsUser) throws Exception {
+		cmsRoleMapper.deleteUserRoleRelation(cmsUser.getId());
+		//删除用户缓存
+		cacheService.deleteUserCache(cmsUser.getAccount());
+		//删除角色缓存
+		cacheService.delUserRoleCache(cmsUser.getAccount());
+		//删除权限缓存
+		cacheService.delUserPermissionsCache(cmsUser.getAccount());
+	}
+
+	public void saveUserRoleRelationAndCache(CmsUser cmsUser, String roles) throws Exception {
+		//用户角色关联入库
+		this.saveUserRoleRelation(cmsUser.getId(), roles);
+		//缓存用户最数据
+		loadUserRedisCache(cmsUser);
+	}
+}

netflix-service/src/main/java/com/cyksj/service/mange/cms/manager/service/CacheService.java

@@ -0,0 +1,34 @@
+package com.cyksj.service.mange.cms.manager.service;
+
+
+import com.cyksj.model.entity.CmsMenu;
+import com.cyksj.model.entity.CmsRole;
+import com.cyksj.model.entity.CmsUser;
+
+import java.util.List;
+
+/*
+ *项目名: yicang-admin
+ *文件名: CacheService
+ *创建者: JavaZou
+ *创建时间:2022/9/30 14:08
+ */
+public interface CacheService {
+	void saveUser(Long userId) throws Exception;
+
+	void saveRoles(Long userId) throws Exception;
+
+	void savePermissions(Long userId) throws Exception;
+
+	void deleteUserCache(Long userId) throws Exception;
+
+	List<CmsRole> getUserRoleCache(Long userId);
+
+	List<CmsMenu> getUserPermsCache(Long userId);
+
+	CmsUser getUserCache(Long userId);
+
+	void delUserRoleCache(Long userId);
+
+	void delUserPermissionsCache(Long userId);
+}

netflix-service/src/main/java/com/cyksj/service/mange/cms/manager/service/impl/CacheServiceImpl.java

@@ -0,0 +1,124 @@
+package com.cyksj.service.mange.cms.manager.service.impl;
+
+import com.cyksj.mapper.manage.cms.CmsMenuMapper;
+import com.cyksj.mapper.manage.cms.CmsRoleMapper;
+import com.cyksj.mapper.manage.cms.CmsUserMapper;
+import com.cyksj.model.entity.CmsMenu;
+import com.cyksj.model.entity.CmsRole;
+import com.cyksj.model.entity.CmsUser;
+import com.cyksj.model.views.CmsUserVO;
+import com.cyksj.redis.RedisService;
+import com.cyksj.service.mange.cms.manager.service.CacheService;
+import com.fasterxml.jackson.databind.JavaType;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/*
+ *项目名: yicang-admin
+ *文件名: CacheServiceImpl
+ *创建者: JavaZou
+ *创建时间:2022/9/30 14:11
+ */
+@Service
+@Slf4j
+public class CacheServiceImpl implements CacheService {
+	@Autowired
+	private CmsUserMapper cmsUserMapper;
+
+	@Autowired
+	private CmsRoleMapper cmsRoleMapper;
+
+	@Autowired
+	private CmsMenuMapper cmsMenuMapper;
+
+	@Autowired
+	private RedisService redisService;
+
+	@Autowired
+	private ObjectMapper mapper;
+
+	@Override
+	public void saveUser(Long userId) throws Exception {
+		CmsUserVO cmsUserVO = cmsUserMapper.getCmsUserDetailByUserId(userId);
+		this.deleteUserCache(userId);
+		redisService.set(RedisService.key.CMS_USER_KEY.getNameFormat(userId), mapper.writeValueAsString(cmsUserVO));
+	}
+
+	@Override
+	public void saveRoles(Long userId) throws Exception {
+		List<CmsRole> roles = cmsRoleMapper.getCmsRolesByUserId(userId);
+		if (roles.size() > 0) {
+			this.deleteUserRolesCache(userId);
+			redisService.set(RedisService.key.CMS_USER_ROLE_KEY.getNameFormat(userId), mapper.writeValueAsString(roles));
+		}
+	}
+
+	@Override
+	public void savePermissions(Long userId) throws Exception {
+		List<CmsMenu> cmsMenus = cmsMenuMapper.getCmsMenusByUserId(userId);
+		if (cmsMenus.size() > 0) {
+			this.deleteUserPermissionsCache(userId);
+			redisService.set(RedisService.key.CMS_USER_PERMISSION_KEY.getNameFormat(userId), mapper.writeValueAsString(cmsMenus));
+		}
+	}
+
+	private void deleteUserRolesCache(Long userId) {
+		redisService.del(RedisService.key.CMS_USER_ROLE_KEY.getNameFormat(userId));
+	}
+
+	private void deleteUserPermissionsCache(Long userId) {
+		redisService.del(RedisService.key.CMS_USER_PERMISSION_KEY.getNameFormat(userId));
+	}
+
+	@Override
+	public void deleteUserCache(Long userId) {
+		redisService.del(RedisService.key.CMS_USER_KEY.getNameFormat(userId));
+	}
+
+	@SneakyThrows
+	@Override
+	public List<CmsRole> getUserRoleCache(Long userId){
+		Object cmsRoleStr = redisService.get(RedisService.key.CMS_USER_ROLE_KEY.getNameFormat(userId));
+		if (cmsRoleStr == null) {
+			return null;
+		}
+		JavaType type = mapper.getTypeFactory().constructParametricType(List.class, CmsRole.class);
+		return mapper.readValue(cmsRoleStr.toString(), type);
+	}
+
+	@SneakyThrows
+	@Override
+	public List<CmsMenu> getUserPermsCache(Long userId){
+		Object cmsMenusStr = redisService.get(RedisService.key.CMS_USER_PERMISSION_KEY.getNameFormat(userId));
+		if (cmsMenusStr == null) {
+			return null;
+		}
+		JavaType type = mapper.getTypeFactory().constructParametricType(List.class, CmsMenu.class);
+		return mapper.readValue(cmsMenusStr.toString(), type);
+	}
+
+	@SneakyThrows
+	@Override
+	public CmsUser getUserCache(Long userId) {
+		Object o = redisService.get(RedisService.key.CMS_USER_KEY.getNameFormat(userId));
+		if (o == null) {
+			return null;
+		}
+		return mapper.readValue(o.toString(), CmsUser.class);
+	}
+
+	@Override
+	public void delUserRoleCache(Long userId) {
+		redisService.del(RedisService.key.CMS_USER_ROLE_KEY.getNameFormat(userId));
+	}
+
+	@Override
+	public void delUserPermissionsCache(Long userId) {
+		redisService.del(RedisService.key.CMS_USER_PERMISSION_KEY.getNameFormat(userId));
+	}
+}

netflix-web/src/main/java/com/cyksj/aspect/LogAspect.java

@@ -0,0 +1,209 @@
+package com.cyksj.aspect;
+
+import cn.dev33.satoken.stp.StpUtil;
+import cn.hutool.core.date.DateTime;
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.extra.servlet.ServletUtil;
+import cn.hutool.http.HttpUtil;
+import cn.hutool.json.JSONObject;
+import cn.hutool.json.JSONUtil;
+import com.baomidou.dynamic.datasource.toolkit.StringUtils;
+import com.cyksj.common.annotation.Log;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.aspectj.lang.JoinPoint;
+import org.aspectj.lang.annotation.AfterReturning;
+import org.aspectj.lang.annotation.AfterThrowing;
+import org.aspectj.lang.annotation.Aspect;
+import org.elsa.mxx.api.logic.manage.cms.manager.CmsUserManager;
+import org.elsa.mxx.common.annotation.Log;
+import org.elsa.mxx.common.dao.BaseDao2;
+import org.elsa.mxx.common.enums.BusinessStatus;
+import org.elsa.mxx.common.utils.Jsons;
+import org.elsa.mxx.core.entity.CmsUser;
+import org.elsa.mxx.core.entity.SysLog;
+import org.elsa.mxx.job.GlobalThreadPoolTaskExecutor;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpMethod;
+import org.springframework.stereotype.Component;
+import org.springframework.validation.BindingResult;
+import org.springframework.web.multipart.MultipartFile;
+import org.springframework.web.servlet.HandlerMapping;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.util.Collection;
+import java.util.Enumeration;
+import java.util.Map;
+
+/*
+ *项目名: yicang-admin
+ *文件名: LogAspect
+ *创建者: JavaZou
+ *创建时间:2022/9/30 10:55
+ */
+@Aspect
+@Component
+@Slf4j
+@RequiredArgsConstructor
+public class LogAspect {
+	private final HttpServletRequest request;
+
+	private final CmsUserManager cmsUserManager;
+
+	/**
+	 * 处理后完成
+	 * 切入点
+	 */
+	@AfterReturning(pointcut = "@annotation(controllerLog)", returning = "jsonResult")
+	public void doAfterReturning(JoinPoint joinPoint, Log controllerLog, Object jsonResult) {
+		handleLog(joinPoint, controllerLog, null, jsonResult);
+	}
+
+	/**
+	 * 异常处理
+	 * 切入
+	 */
+	@AfterThrowing(pointcut = "@annotation(controllerLog)", throwing = "e")
+	public void doAfterThrowing(JoinPoint joinPoint, Log controllerLog, Exception e) {
+		handleLog(joinPoint, controllerLog, e, null);
+	}
+
+	private void handleLog(JoinPoint joinPoint, Log controllerLog, Exception e, Object jsonResult) {
+		try {
+			// 获取当前的用户
+			CmsUser cmsUser = cmsUserManager.getUser(StpUtil.getLoginIdAsString());
+			SysLog sysLog = new SysLog();
+			sysLog.setOperateIp(ServletUtil.getClientIP(request));
+			sysLog.setOperateUrl(request.getRequestURI());
+			sysLog.setStatus(BusinessStatus.SUCCESS.ordinal());
+			sysLog.setOperateTime(DateTime.now().toString());
+			//操作人
+			if (cmsUser != null) {
+				sysLog.setOperator(cmsUser.getNickName());
+				sysLog.setAccount(cmsUser.getAccount());
+			}
+			if (e != null) {
+				sysLog.setStatus(BusinessStatus.FAIL.ordinal());
+				sysLog.setErrMsg(StrUtil.subSufByLength(e.getMessage(), 2000));
+			}
+			// 设置方法名称
+			String className = joinPoint.getTarget().getClass().getName();
+			String methodName = joinPoint.getSignature().getName();
+			sysLog.setMethod(String.format("%s.%s", className, methodName));
+			// 处理设置注解上的参数
+			getControllerMethodDescription(joinPoint, controllerLog, sysLog, jsonResult);
+			//请求方式
+			sysLog.setRequestMethod(request.getMethod());
+			sysLog.setOperateLocation(getRealAddressByIP(sysLog.getOperateIp()));
+			baseDao2.save(sysLog);
+		} catch (Exception exp) {
+			// 记录本地异常日志
+			log.error("==前置通知异常==");
+			log.error("异常信息:{}", exp.getMessage());
+		}
+	}
+
+	private void getControllerMethodDescription(JoinPoint joinPoint, Log log, SysLog sysLog, Object jsonResult) throws Exception {
+		sysLog.setModule(log.module());
+		sysLog.setBusinessType(log.businessType().ordinal());
+		// 是否需要保存request，参数和值
+		if (log.isSaveRequestData()) {
+			// 获取参数的信息，传入到数据库中。
+			setRequestValue(joinPoint, sysLog, log);
+		}
+		// 是否需要保存response，参数和值
+		if (log.isSaveResponseData() && jsonResult != null) {
+			sysLog.setJsonResult(StrUtil.subSufByLength(Jsons.toJson(jsonResult), 2000));
+		}
+	}
+
+	/**
+	 * 请求入参
+	 */
+	private void setRequestValue(JoinPoint joinPoint, SysLog sysLog, Log log) throws Exception {
+		String requestMethod = log.businessType().name();
+		if (HttpMethod.PUT.name().equals(requestMethod) || HttpMethod.POST.name().equals(requestMethod)) {
+			String params = argsArrayToString(joinPoint.getArgs());
+			sysLog.setOperateParams(StrUtil.subSufByLength(params, 2000));
+		} else {
+			Map<Object, Object> paramsMap = (Map<Object, Object>) request.getAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE);
+			if (paramsMap.size() == 0) {
+				Enumeration<String> parameterNames = request.getParameterNames();
+				while (parameterNames.hasMoreElements()) {
+					String key = parameterNames.nextElement();
+					String value = request.getParameter(key);
+					paramsMap.put(key, value);
+				}
+			}
+			sysLog.setOperateParams(StrUtil.subSufByLength(paramsMap.toString(), 2000));
+		}
+	}
+
+	/**
+	 * 参数拼装
+	 */
+	private String argsArrayToString(Object[] paramsArray) {
+		String params = "";
+		if (paramsArray != null && paramsArray.length > 0) {
+			for (Object o : paramsArray) {
+				if (o != null && !isFilterObject(o)) {
+					try {
+						Object jsonObj = Jsons.toJson(o);
+						params += jsonObj.toString() + " ";
+					} catch (Exception e) {
+					}
+				}
+			}
+		}
+		return params.trim();
+	}
+
+	/**
+	 * 判断是否需要过滤的对象。
+	 *
+	 * @param o 对象信息。
+	 * @return 如果是需要过滤的对象，则返回true；否则返回false。
+	 */
+	@SuppressWarnings("rawtypes")
+	public boolean isFilterObject(final Object o) {
+		Class<?> clazz = o.getClass();
+		if (clazz.isArray()) {
+			return clazz.getComponentType().isAssignableFrom(MultipartFile.class);
+		} else if (Collection.class.isAssignableFrom(clazz)) {
+			Collection collection = (Collection) o;
+			for (Object value : collection) {
+				return value instanceof MultipartFile;
+			}
+		} else if (Map.class.isAssignableFrom(clazz)) {
+			Map map = (Map) o;
+			for (Object value : map.entrySet()) {
+				Map.Entry entry = (Map.Entry) value;
+				return entry.getValue() instanceof MultipartFile;
+			}
+		}
+		return o instanceof MultipartFile || o instanceof HttpServletRequest || o instanceof HttpServletResponse
+				|| o instanceof BindingResult;
+	}
+
+	public String getRealAddressByIP(String ip) {
+		if (StringUtils.isBlank(ip)) {
+			return "unknown";
+		}
+		try {
+			String rspStr = HttpUtil.get("http://whois.pconline.com.cn/ipJson.jsp?ip=" + ip + "&json=true");
+			if (StrUtil.isEmpty(rspStr)) {
+				log.error("获取地理位置异常 {}", ip);
+				return "unknown";
+			}
+			JSONObject obj = JSONUtil.parseObj(rspStr);
+			String region = obj.getStr("pro");
+			String city = obj.getStr("city");
+			return String.format("%s %s", region, city);
+		} catch (Exception e) {
+			log.error("获取地理位置异常 {}", ip);
+		}
+
+		return "unknown";
+	}
+}

netflix-web/src/main/java/com/cyksj/web/controller/manage/AdminController.java

@@ -1,290 +1,290 @@
-package com.cyksj.web.controller.manage;
-
-import cn.dev33.satoken.stp.StpUtil;
-import cn.hutool.core.date.DateTime;
-import cn.hutool.core.date.DateUtil;
-import cn.hutool.core.lang.Validator;
-import cn.hutool.core.util.StrUtil;
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
-import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
-import com.baomidou.mybatisplus.core.toolkit.Wrappers;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import com.cyksj.common.constant.WeChatTemplateConst;
-import com.cyksj.common.exception.BusinessRuntimeException;
-import com.cyksj.common.util.Codec;
-import com.cyksj.common.util.Jsons;
-import com.cyksj.dto.Result;
-import com.cyksj.enums.GatewayResponse;
-import com.cyksj.mapper.CustomerServiceMapper;
-import com.cyksj.mapper.PhoneCodeMapper;
-import com.cyksj.model.dto.WxMpTemplateData;
-import com.cyksj.model.dto.WxMpTemplateMessage;
-import com.cyksj.model.entity.PhoneCode;
-import com.cyksj.model.manage.dto.AdminInfo;
-import com.cyksj.model.manage.entity.Admin;
-import com.cyksj.service.mange.AdminService;
-import com.cyksj.service.wechat.WeChatService;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.StringUtils;
-import org.springframework.dao.DuplicateKeyException;
-import org.springframework.validation.annotation.Validated;
-import org.springframework.web.bind.annotation.*;
-
-import javax.servlet.http.HttpServletRequest;
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.util.Date;
-import java.util.Enumeration;
-import java.util.List;
-import java.util.Map;
-
-/**
- * @description
- * @author chan
- * @date 2021-10-11 下午11:02
- */
-@RestController
-@RequestMapping("/manage/admin")
-@RequiredArgsConstructor
-@Slf4j
-public class AdminController {
-
-    private final AdminService adminService;
-
-    private final HttpServletRequest request;
-
-    private final WeChatService weChatService;
-
-    private final CustomerServiceMapper customerServiceMapper;
-
-    private final PhoneCodeMapper phoneCodeMapper;
-
-    private static final List<String> SEND_LIST = List.of("o_i5g6V5z5uDpx_SBhJ4ePek8g8k","o_i5g6X99wu2OmC4DcQKXKNmJexA");
-
-    @PostMapping(value = "/login")
-    public Result<String> login(@RequestBody Admin adminRequest) throws Exception {
-        Admin admin = adminService.getOne(
-                new QueryWrapper<Admin>().lambda().eq(Admin::getPhone,adminRequest.getPhone()));
-
-        if (null == admin) {
-            throw BusinessRuntimeException.getInstance("该用户不存在.");
-        }
-        if (null == admin.getStatus() || !admin.getStatus()) {
-            throw BusinessRuntimeException.getInstance("无登录权限.");
-        }
-
-        // 对比密码
-        String encodePasscode = Codec.DoDigest.custom().setAlgorithm(Codec.DoDigest.Algorithm.SHA256).setStringData(adminRequest.getPassWord()).toBase64String();
-
-        if (!StringUtils.equals(admin.getPassWord(), encodePasscode)) {
-            throw BusinessRuntimeException.getInstance("密码有误.");
-        }
-        return GatewayResponse.SUCCESS.newBuilder().toResult();
-    }
-
-    @PostMapping("/post")
-    public Result<String> saveAdmin(@RequestBody @Validated Admin admin) throws Exception {
-        Long adminId = StpUtil.getLoginIdAsLong();
-        Admin exist = adminService.getById(adminId);
-        if (exist == null) {
-            throw BusinessRuntimeException.getInstance("账号不存在,请重新登录");
-        }
-        if (exist.getCategory() != Admin.Category.superoot) {
-            throw BusinessRuntimeException.getInstance("无超级管理员权限");
-        }
-        if (StringUtils.isNotBlank(admin.getPassWord())) {
-            admin.setPassWord(Codec.DoDigest.custom().setAlgorithm(Codec.DoDigest.Algorithm.SHA256).setStringData(admin.getPassWord()).toBase64String());
-        }
-        if (admin.getId() == null) {
-            Admin ad = adminService.getOne(new LambdaQueryWrapper<Admin>().eq(Admin::getPhone, admin.getPhone()));
-            if (ad != null) {
-                throw BusinessRuntimeException.getInstance("该账号已存在.");
-            }
-        }
-        boolean mobile = Validator.isMobile(admin.getPhone());
-        if (!mobile) {
-            throw BusinessRuntimeException.getInstance("请输入正确的手机号");
-        }
-
-        try {
-            adminService.saveOrUpdate(admin);
-        } catch (DuplicateKeyException e) {
-            throw BusinessRuntimeException.getInstance("手机号重复");
-        }
-
-        return GatewayResponse.SUCCESS.newBuilder().toResult();
-    }
-
-    /**
-     * 删除管理员
-     */
-    @DeleteMapping("/delete/{id}")
-    public Result<String> deleteAdminById(@PathVariable Long id) {
-        Long adminId = StpUtil.getLoginIdAsLong();
-        Admin exist = adminService.getById(adminId);
-        if (exist == null) {
-            throw BusinessRuntimeException.getInstance("账号不存在,请重新登录");
-        }
-        if (exist.getCategory() != Admin.Category.superoot) {
-            throw BusinessRuntimeException.getInstance("无超级管理员权限");
-        }
-        if (id.equals(adminId)) {
-            throw BusinessRuntimeException.getInstance("无法删除自己");
-        }
-        adminService.removeById(id);
-        return GatewayResponse.SUCCESS.newBuilder().toResult("删除成功");
-    }
-
-    /**
-     * 编辑管理员
-     */
-    @PutMapping("/put")
-    public Result<String> editAdmin(@RequestBody Admin admin) throws Exception {
-        Long adminId = StpUtil.getLoginIdAsLong();
-        Admin exist = adminService.getById(adminId);
-        if (exist == null) {
-            throw BusinessRuntimeException.getInstance("账号不存在,请重新登录");
-        }
-        if (exist.getCategory() != Admin.Category.superoot) {
-            throw BusinessRuntimeException.getInstance("无超级管理员权限");
-        }
-        Admin user = adminService.getById(admin.getId());
-        if (admin.getId() == null || user == null) {
-            throw BusinessRuntimeException.getInstance("账号不存在");
-        }
-        Boolean flag = false;
-        if (StrUtil.isNotEmpty(admin.getPhone())) {
-            boolean mobile = Validator.isMobile(admin.getPhone());
-            if (!mobile) {
-                throw BusinessRuntimeException.getInstance("请输入正确的手机号");
-            }
-            if (!admin.getPhone().equals(user.getPhone())) {
-                flag = true;
-            }
-        }
-        if (StrUtil.isNotEmpty(admin.getPassWord())) {
-            String encodePwd = Codec.DoDigest.custom().setAlgorithm(Codec.DoDigest.Algorithm.SHA256).setStringData(admin.getPassWord()).toBase64String();
-            admin.setPassWord(encodePwd);
-            if (!encodePwd.equals(user.getPassWord())) {
-                flag = true;
-            }
-        }
-        adminService.saveOrUpdate(admin);
-        if (flag) {
-            StpUtil.logoutByLoginId(admin.getId());
-        }
-
-        return GatewayResponse.SUCCESS.newBuilder().toResult("编辑成功");
-    }
-
-
-    /**
-     * 校验手机号获取登录信息
-     */
-    @GetMapping("/get/loginInfo")
-    public Result<AdminInfo> getLoginInfo(String phone, String code) {
-        Admin admin = adminService.getOne(
-                new QueryWrapper<Admin>().lambda().eq(Admin::getPhone, phone));
-        if (null == admin) {
-            throw BusinessRuntimeException.getInstance("该用户不存在.");
-        }
-        if (StrUtil.hasEmpty(phone, code)) {
-            throw BusinessRuntimeException.getInstance("请输入对应信息");
-        }
-        DateTime now = DateTime.now();
-        PhoneCode phoneCode = phoneCodeMapper.selectOne(Wrappers.lambdaQuery(PhoneCode.class).eq(PhoneCode::getPhone, phone).last("limit 1"));
-        if (phoneCode == null || StrUtil.isEmpty(phoneCode.getCode())) {
-            throw BusinessRuntimeException.getInstance("请重新获取手机验证码");
-        }
-        //3分钟失效
-        Date updateTime = phoneCode.getUpdateTime();
-        DateTime afterFiveMinutes = DateUtil.offsetMinute(updateTime, 3);
-        if (now.isAfter(afterFiveMinutes)) {
-            throw BusinessRuntimeException.getInstance("手机验证码已失效,请重新获取");
-        }
-        if (!StrUtil.equals(code, phoneCode.getCode())) {
-            throw BusinessRuntimeException.getInstance("手机验证码错误,请重新输入");
-        }
-        // 生成token
-
-        StpUtil.login(admin.getId());
-
-        String token = StpUtil.getTokenValue();
-
-        admin.setPassWord("");
-
-        AdminInfo info = new AdminInfo();
-        info.setInfo(admin);
-        info.setToken(token);
-        return GatewayResponse.SUCCESS.newBuilder().toResult(info);
-    }
-
-    @GetMapping("/get/list")
-    public Result<Page<Admin>> list(@RequestParam(defaultValue = "1") Integer start, @RequestParam(defaultValue = "5") Integer limit) {
-        Page<Admin> page = adminService.page(new Page<>(start, limit), new LambdaQueryWrapper<Admin>().eq(Admin::getStatus, true));
-        return GatewayResponse.SUCCESS.newBuilder().toResult(page);
-    }
-
-    @GetMapping("/send/template")
-    public Result<String> sendTemplate(String title, String channel) throws Exception {
-        for (String openId : SEND_LIST) {
-            WxMpTemplateMessage templateMessage = new WxMpTemplateMessage()
-                    .setToUser(openId)
-                    .setTemplateId(WeChatTemplateConst.VDIEO_NOTIFY)
-                    .setUrl(" ");
-            WxMpTemplateMessage.TemplateData data = templateMessage.getData();
-            data.setFirst(new WxMpTemplateData("youtube频道有更新"));
-            data.setKeyword1(new WxMpTemplateData(title));
-            data.setKeyword2(new WxMpTemplateData(channel));
-            data.setKeyword3(new WxMpTemplateData(DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss")));
-            data.setKeyword4(new WxMpTemplateData("默认"));
-            data.setRemark(new WxMpTemplateData("您订阅的频道有新内容发布"));
-            log.info("发送video模板消息至客服:{}","磨牙怪");
-            weChatService.sendTemplateMessage(weChatService.getAccessToken(), Jsons.toJson(templateMessage));
-        }
-        return GatewayResponse.SUCCESS.newBuilder().toResult();
-    }
-
-    @RequestMapping("/callback")
-    public String youtubeCallback(HttpServletRequest request, @RequestHeader Map<String, String> headers) throws IOException {
-        log.info("----------------打印请求全部消息开始----------------");
-        Enumeration<String> headerNames = request.getHeaderNames();
-        while (headerNames.hasMoreElements()) {
-            String name = headerNames.nextElement();
-            log.info("{} - {}", name, request.getHeader(name));
-        }
-        log.info("----------------打印请求全部消息结束----------------");
-        log.info("-----------------打印请求头消息开始-----------------");
-        headers.forEach((String key, String value) -> log.info(String.format("Header '%s' = %s", key, value)));
-        log.info("-----------------打印请求头消息结束-----------------");
-        Map<String, String[]> parameterMap = request.getParameterMap();
-        log.info("------------------打印全部参数开始------------------");
-        String result = "";
-        if (parameterMap.isEmpty()) {
-            log.info("请求参数为空");
-        }else {
-            parameterMap.forEach((String key, String[] value) -> {
-                for (String s : value) {
-                    log.info("Param '{}' = {}", key, s);
-                }
-            });
-            result = parameterMap.get("hub.challenge")[0];
-        }
-        log.info("------------------打印全部参数结束------------------");
-        log.info("-----------------打印Reader数据开始----------------");
-        StringBuilder buffer = new StringBuilder();
-        try (BufferedReader reader = request.getReader()){
-            String line;
-            while ((line = reader.readLine()) != null) {
-                buffer.append(line);
-            }
-        } catch (IOException e) {
-            log.error(e.getMessage(), e);
-        }
-        log.info("reader -> {}", buffer);
-        log.info("-----------------打印Reader数据结束----------------");
-        return result;
-    }
-
-}
+//package com.cyksj.web.controller.manage;
+//
+//import cn.dev33.satoken.stp.StpUtil;
+//import cn.hutool.core.date.DateTime;
+//import cn.hutool.core.date.DateUtil;
+//import cn.hutool.core.lang.Validator;
+//import cn.hutool.core.util.StrUtil;
+//import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+//import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+//import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+//import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+//import com.cyksj.common.constant.WeChatTemplateConst;
+//import com.cyksj.common.exception.BusinessRuntimeException;
+//import com.cyksj.common.util.Codec;
+//import com.cyksj.common.util.Jsons;
+//import com.cyksj.dto.Result;
+//import com.cyksj.enums.GatewayResponse;
+//import com.cyksj.mapper.CustomerServiceMapper;
+//import com.cyksj.mapper.PhoneCodeMapper;
+//import com.cyksj.model.dto.WxMpTemplateData;
+//import com.cyksj.model.dto.WxMpTemplateMessage;
+//import com.cyksj.model.entity.PhoneCode;
+//import com.cyksj.model.manage.dto.AdminInfo;
+//import com.cyksj.model.manage.entity.Admin;
+//import com.cyksj.service.mange.AdminService;
+//import com.cyksj.service.wechat.WeChatService;
+//import lombok.RequiredArgsConstructor;
+//import lombok.extern.slf4j.Slf4j;
+//import org.apache.commons.lang3.StringUtils;
+//import org.springframework.dao.DuplicateKeyException;
+//import org.springframework.validation.annotation.Validated;
+//import org.springframework.web.bind.annotation.*;
+//
+//import javax.servlet.http.HttpServletRequest;
+//import java.io.BufferedReader;
+//import java.io.IOException;
+//import java.util.Date;
+//import java.util.Enumeration;
+//import java.util.List;
+//import java.util.Map;
+//
+///**
+// * @description
+// * @author chan
+// * @date 2021-10-11 下午11:02
+// */
+//@RestController
+//@RequestMapping("/manage/admin")
+//@RequiredArgsConstructor
+//@Slf4j
+//public class AdminController {
+//
+//    private final AdminService adminService;
+//
+//    private final HttpServletRequest request;
+//
+//    private final WeChatService weChatService;
+//
+//    private final CustomerServiceMapper customerServiceMapper;
+//
+//    private final PhoneCodeMapper phoneCodeMapper;
+//
+//    private static final List<String> SEND_LIST = List.of("o_i5g6V5z5uDpx_SBhJ4ePek8g8k","o_i5g6X99wu2OmC4DcQKXKNmJexA");
+//
+//    @PostMapping(value = "/login")
+//    public Result<String> login(@RequestBody Admin adminRequest) throws Exception {
+//        Admin admin = adminService.getOne(
+//                new QueryWrapper<Admin>().lambda().eq(Admin::getPhone,adminRequest.getPhone()));
+//
+//        if (null == admin) {
+//            throw BusinessRuntimeException.getInstance("该用户不存在.");
+//        }
+//        if (null == admin.getStatus() || !admin.getStatus()) {
+//            throw BusinessRuntimeException.getInstance("无登录权限.");
+//        }
+//
+//        // 对比密码
+//        String encodePasscode = Codec.DoDigest.custom().setAlgorithm(Codec.DoDigest.Algorithm.SHA256).setStringData(adminRequest.getPassWord()).toBase64String();
+//
+//        if (!StringUtils.equals(admin.getPassWord(), encodePasscode)) {
+//            throw BusinessRuntimeException.getInstance("密码有误.");
+//        }
+//        return GatewayResponse.SUCCESS.newBuilder().toResult();
+//    }
+//
+//    @PostMapping("/post")
+//    public Result<String> saveAdmin(@RequestBody @Validated Admin admin) throws Exception {
+//        Long adminId = StpUtil.getLoginIdAsLong();
+//        Admin exist = adminService.getById(adminId);
+//        if (exist == null) {
+//            throw BusinessRuntimeException.getInstance("账号不存在,请重新登录");
+//        }
+//        if (exist.getCategory() != Admin.Category.superoot) {
+//            throw BusinessRuntimeException.getInstance("无超级管理员权限");
+//        }
+//        if (StringUtils.isNotBlank(admin.getPassWord())) {
+//            admin.setPassWord(Codec.DoDigest.custom().setAlgorithm(Codec.DoDigest.Algorithm.SHA256).setStringData(admin.getPassWord()).toBase64String());
+//        }
+//        if (admin.getId() == null) {
+//            Admin ad = adminService.getOne(new LambdaQueryWrapper<Admin>().eq(Admin::getPhone, admin.getPhone()));
+//            if (ad != null) {
+//                throw BusinessRuntimeException.getInstance("该账号已存在.");
+//            }
+//        }
+//        boolean mobile = Validator.isMobile(admin.getPhone());
+//        if (!mobile) {
+//            throw BusinessRuntimeException.getInstance("请输入正确的手机号");
+//        }
+//
+//        try {
+//            adminService.saveOrUpdate(admin);
+//        } catch (DuplicateKeyException e) {
+//            throw BusinessRuntimeException.getInstance("手机号重复");
+//        }
+//
+//        return GatewayResponse.SUCCESS.newBuilder().toResult();
+//    }
+//
+//    /**
+//     * 删除管理员
+//     */
+//    @DeleteMapping("/delete/{id}")
+//    public Result<String> deleteAdminById(@PathVariable Long id) {
+//        Long adminId = StpUtil.getLoginIdAsLong();
+//        Admin exist = adminService.getById(adminId);
+//        if (exist == null) {
+//            throw BusinessRuntimeException.getInstance("账号不存在,请重新登录");
+//        }
+//        if (exist.getCategory() != Admin.Category.superoot) {
+//            throw BusinessRuntimeException.getInstance("无超级管理员权限");
+//        }
+//        if (id.equals(adminId)) {
+//            throw BusinessRuntimeException.getInstance("无法删除自己");
+//        }
+//        adminService.removeById(id);
+//        return GatewayResponse.SUCCESS.newBuilder().toResult("删除成功");
+//    }
+//
+//    /**
+//     * 编辑管理员
+//     */
+//    @PutMapping("/put")
+//    public Result<String> editAdmin(@RequestBody Admin admin) throws Exception {
+//        Long adminId = StpUtil.getLoginIdAsLong();
+//        Admin exist = adminService.getById(adminId);
+//        if (exist == null) {
+//            throw BusinessRuntimeException.getInstance("账号不存在,请重新登录");
+//        }
+//        if (exist.getCategory() != Admin.Category.superoot) {
+//            throw BusinessRuntimeException.getInstance("无超级管理员权限");
+//        }
+//        Admin user = adminService.getById(admin.getId());
+//        if (admin.getId() == null || user == null) {
+//            throw BusinessRuntimeException.getInstance("账号不存在");
+//        }
+//        Boolean flag = false;
+//        if (StrUtil.isNotEmpty(admin.getPhone())) {
+//            boolean mobile = Validator.isMobile(admin.getPhone());
+//            if (!mobile) {
+//                throw BusinessRuntimeException.getInstance("请输入正确的手机号");
+//            }
+//            if (!admin.getPhone().equals(user.getPhone())) {
+//                flag = true;
+//            }
+//        }
+//        if (StrUtil.isNotEmpty(admin.getPassWord())) {
+//            String encodePwd = Codec.DoDigest.custom().setAlgorithm(Codec.DoDigest.Algorithm.SHA256).setStringData(admin.getPassWord()).toBase64String();
+//            admin.setPassWord(encodePwd);
+//            if (!encodePwd.equals(user.getPassWord())) {
+//                flag = true;
+//            }
+//        }
+//        adminService.saveOrUpdate(admin);
+//        if (flag) {
+//            StpUtil.logoutByLoginId(admin.getId());
+//        }
+//
+//        return GatewayResponse.SUCCESS.newBuilder().toResult("编辑成功");
+//    }
+//
+//
+//    /**
+//     * 校验手机号获取登录信息
+//     */
+//    @GetMapping("/get/loginInfo")
+//    public Result<AdminInfo> getLoginInfo(String phone, String code) {
+//        Admin admin = adminService.getOne(
+//                new QueryWrapper<Admin>().lambda().eq(Admin::getPhone, phone));
+//        if (null == admin) {
+//            throw BusinessRuntimeException.getInstance("该用户不存在.");
+//        }
+//        if (StrUtil.hasEmpty(phone, code)) {
+//            throw BusinessRuntimeException.getInstance("请输入对应信息");
+//        }
+//        DateTime now = DateTime.now();
+//        PhoneCode phoneCode = phoneCodeMapper.selectOne(Wrappers.lambdaQuery(PhoneCode.class).eq(PhoneCode::getPhone, phone).last("limit 1"));
+//        if (phoneCode == null || StrUtil.isEmpty(phoneCode.getCode())) {
+//            throw BusinessRuntimeException.getInstance("请重新获取手机验证码");
+//        }
+//        //3分钟失效
+//        Date updateTime = phoneCode.getUpdateTime();
+//        DateTime afterFiveMinutes = DateUtil.offsetMinute(updateTime, 3);
+//        if (now.isAfter(afterFiveMinutes)) {
+//            throw BusinessRuntimeException.getInstance("手机验证码已失效,请重新获取");
+//        }
+//        if (!StrUtil.equals(code, phoneCode.getCode())) {
+//            throw BusinessRuntimeException.getInstance("手机验证码错误,请重新输入");
+//        }
+//        // 生成token
+//
+//        StpUtil.login(admin.getId());
+//
+//        String token = StpUtil.getTokenValue();
+//
+//        admin.setPassWord("");
+//
+//        AdminInfo info = new AdminInfo();
+//        info.setInfo(admin);
+//        info.setToken(token);
+//        return GatewayResponse.SUCCESS.newBuilder().toResult(info);
+//    }
+//
+//    @GetMapping("/get/list")
+//    public Result<Page<Admin>> list(@RequestParam(defaultValue = "1") Integer start, @RequestParam(defaultValue = "5") Integer limit) {
+//        Page<Admin> page = adminService.page(new Page<>(start, limit), new LambdaQueryWrapper<Admin>().eq(Admin::getStatus, true));
+//        return GatewayResponse.SUCCESS.newBuilder().toResult(page);
+//    }
+//
+//    @GetMapping("/send/template")
+//    public Result<String> sendTemplate(String title, String channel) throws Exception {
+//        for (String openId : SEND_LIST) {
+//            WxMpTemplateMessage templateMessage = new WxMpTemplateMessage()
+//                    .setToUser(openId)
+//                    .setTemplateId(WeChatTemplateConst.VDIEO_NOTIFY)
+//                    .setUrl(" ");
+//            WxMpTemplateMessage.TemplateData data = templateMessage.getData();
+//            data.setFirst(new WxMpTemplateData("youtube频道有更新"));
+//            data.setKeyword1(new WxMpTemplateData(title));
+//            data.setKeyword2(new WxMpTemplateData(channel));
+//            data.setKeyword3(new WxMpTemplateData(DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss")));
+//            data.setKeyword4(new WxMpTemplateData("默认"));
+//            data.setRemark(new WxMpTemplateData("您订阅的频道有新内容发布"));
+//            log.info("发送video模板消息至客服:{}","磨牙怪");
+//            weChatService.sendTemplateMessage(weChatService.getAccessToken(), Jsons.toJson(templateMessage));
+//        }
+//        return GatewayResponse.SUCCESS.newBuilder().toResult();
+//    }
+//
+//    @RequestMapping("/callback")
+//    public String youtubeCallback(HttpServletRequest request, @RequestHeader Map<String, String> headers) throws IOException {
+//        log.info("----------------打印请求全部消息开始----------------");
+//        Enumeration<String> headerNames = request.getHeaderNames();
+//        while (headerNames.hasMoreElements()) {
+//            String name = headerNames.nextElement();
+//            log.info("{} - {}", name, request.getHeader(name));
+//        }
+//        log.info("----------------打印请求全部消息结束----------------");
+//        log.info("-----------------打印请求头消息开始-----------------");
+//        headers.forEach((String key, String value) -> log.info(String.format("Header '%s' = %s", key, value)));
+//        log.info("-----------------打印请求头消息结束-----------------");
+//        Map<String, String[]> parameterMap = request.getParameterMap();
+//        log.info("------------------打印全部参数开始------------------");
+//        String result = "";
+//        if (parameterMap.isEmpty()) {
+//            log.info("请求参数为空");
+//        }else {
+//            parameterMap.forEach((String key, String[] value) -> {
+//                for (String s : value) {
+//                    log.info("Param '{}' = {}", key, s);
+//                }
+//            });
+//            result = parameterMap.get("hub.challenge")[0];
+//        }
+//        log.info("------------------打印全部参数结束------------------");
+//        log.info("-----------------打印Reader数据开始----------------");
+//        StringBuilder buffer = new StringBuilder();
+//        try (BufferedReader reader = request.getReader()){
+//            String line;
+//            while ((line = reader.readLine()) != null) {
+//                buffer.append(line);
+//            }
+//        } catch (IOException e) {
+//            log.error(e.getMessage(), e);
+//        }
+//        log.info("reader -> {}", buffer);
+//        log.info("-----------------打印Reader数据结束----------------");
+//        return result;
+//    }
+//
+//}

netflix-web/src/main/java/com/cyksj/web/controller/manage/cms/CmsMenuController.java

@@ -0,0 +1,10 @@
+package com.cyksj.web.controller.manage.cms;
+
+/*
+ *项目名: netflix
+ *文件名: CmsMenuController
+ *创建者: JavaZou
+ *创建时间:2023/1/11 14:26
+ */
+public class CmsMenuController {
+}

netflix-web/src/main/java/com/cyksj/web/controller/manage/cms/CmsRoleController.java

@@ -0,0 +1,10 @@
+package com.cyksj.web.controller.manage.cms;
+
+/*
+ *项目名: netflix
+ *文件名: CmsRoleController
+ *创建者: JavaZou
+ *创建时间:2023/1/11 14:26
+ */
+public class CmsRoleController {
+}

netflix-web/src/main/java/com/cyksj/web/controller/manage/cms/CmsUserController.java

@@ -0,0 +1,277 @@
+package com.cyksj.web.controller.manage.cms;
+
+import cn.dev33.satoken.stp.StpUtil;
+import cn.hutool.core.date.DateTime;
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.lang.Validator;
+import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.cyksj.common.constant.WeChatTemplateConst;
+import com.cyksj.common.exception.BusinessRuntimeException;
+import com.cyksj.common.util.Codec;
+import com.cyksj.common.util.Jsons;
+import com.cyksj.dto.Result;
+import com.cyksj.enums.GatewayResponse;
+import com.cyksj.mapper.PhoneCodeMapper;
+import com.cyksj.mapper.manage.cms.CmsUserMapper;
+import com.cyksj.model.dto.WxMpTemplateData;
+import com.cyksj.model.dto.WxMpTemplateMessage;
+import com.cyksj.model.entity.CmsUser;
+import com.cyksj.model.entity.PhoneCode;
+import com.cyksj.model.manage.dto.AdminInfo;
+import com.cyksj.service.mange.AdminService;
+import com.cyksj.service.wechat.WeChatService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.dao.DuplicateKeyException;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import javax.servlet.http.HttpServletRequest;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.util.Date;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.Map;
+
+/*
+ *项目名: netflix
+ *文件名: CmsUserController
+ *创建者: JavaZou
+ *创建时间:2023/1/11 14:26
+ */
+@RestController
+@RequestMapping("/manage/admin")
+@RequiredArgsConstructor
+@Slf4j
+public class CmsUserController {
+	private final CmsUserMapper cmsUserMapper;
+
+	private final PhoneCodeMapper phoneCodeMapper;
+
+	private final AdminService adminService;
+
+	private final WeChatService weChatService;
+
+	private static final List<String> SEND_LIST = List.of("o_i5g6V5z5uDpx_SBhJ4ePek8g8k","o_i5g6X99wu2OmC4DcQKXKNmJexA");
+
+	@PostMapping(value = "/login")
+	public Result<String> login(@RequestBody CmsUser adminRequest) throws Exception {
+		CmsUser admin = cmsUserMapper.selectOne(
+				new QueryWrapper<CmsUser>().lambda().eq(CmsUser::getPhone,adminRequest.getPhone()));
+
+		if (null == admin) {
+			throw BusinessRuntimeException.getInstance("该用户不存在.");
+		}
+		if (null == admin.getStatus() || !admin.getStatus()) {
+			throw BusinessRuntimeException.getInstance("无登录权限.");
+		}
+
+		// 对比密码
+		String encodePasscode = Codec.DoDigest.custom().setAlgorithm(Codec.DoDigest.Algorithm.SHA256).setStringData(adminRequest.getPassword()).toBase64String();
+
+		if (!StringUtils.equals(admin.getPassword(), encodePasscode)) {
+			throw BusinessRuntimeException.getInstance("密码有误.");
+		}
+		return GatewayResponse.SUCCESS.newBuilder().toResult();
+	}
+
+	@PostMapping("/post")
+	public Result<String> saveAdmin(@RequestBody @Validated CmsUser admin) throws Exception {
+		Long adminId = StpUtil.getLoginIdAsLong();
+		CmsUser exist = cmsUserMapper.selectById(adminId);
+		if (exist == null) {
+			throw BusinessRuntimeException.getInstance("账号不存在,请重新登录");
+		}
+		if (StringUtils.isNotBlank(admin.getPassword())) {
+			admin.setPassword(Codec.DoDigest.custom().setAlgorithm(Codec.DoDigest.Algorithm.SHA256).setStringData(admin.getPassword()).toBase64String());
+		}
+		if (admin.getId() == null) {
+			CmsUser ad = cmsUserMapper.selectOne(new LambdaQueryWrapper<CmsUser>().eq(CmsUser::getPhone, admin.getPhone()));
+			if (ad != null) {
+				throw BusinessRuntimeException.getInstance("该账号已存在.");
+			}
+		}
+		boolean mobile = Validator.isMobile(admin.getPhone());
+		if (!mobile) {
+			throw BusinessRuntimeException.getInstance("请输入正确的手机号");
+		}
+
+		try {
+			cmsUserMapper.insert(admin);
+		} catch (DuplicateKeyException e) {
+			throw BusinessRuntimeException.getInstance("手机号重复");
+		}
+
+		return GatewayResponse.SUCCESS.newBuilder().toResult();
+	}
+
+	/**
+	 * 删除管理员
+	 */
+	@DeleteMapping("/delete/{id}")
+	public Result<String> deleteAdminById(@PathVariable Long id) {
+		Long adminId = StpUtil.getLoginIdAsLong();
+		CmsUser exist = cmsUserMapper.selectById(adminId);
+		if (exist == null) {
+			throw BusinessRuntimeException.getInstance("账号不存在,请重新登录");
+		}
+		if (id.equals(adminId)) {
+			throw BusinessRuntimeException.getInstance("无法删除自己");
+		}
+		cmsUserMapper.deleteById(id);
+		return GatewayResponse.SUCCESS.newBuilder().toResult("删除成功");
+	}
+
+	/**
+	 * 编辑管理员
+	 */
+	@PutMapping("/put")
+	public Result<String> editAdmin(@RequestBody CmsUser admin) throws Exception {
+		Long adminId = StpUtil.getLoginIdAsLong();
+		CmsUser exist = cmsUserMapper.selectById(adminId);
+		if (exist == null) {
+			throw BusinessRuntimeException.getInstance("账号不存在,请重新登录");
+		}
+		CmsUser user = cmsUserMapper.selectById(admin.getId());
+		if (admin.getId() == null || user == null) {
+			throw BusinessRuntimeException.getInstance("账号不存在");
+		}
+		Boolean flag = false;
+		if (StrUtil.isNotEmpty(admin.getPhone())) {
+			boolean mobile = Validator.isMobile(admin.getPhone());
+			if (!mobile) {
+				throw BusinessRuntimeException.getInstance("请输入正确的手机号");
+			}
+			if (!admin.getPhone().equals(user.getPhone())) {
+				flag = true;
+			}
+		}
+		if (StrUtil.isNotEmpty(admin.getPassword())) {
+			String encodePwd = Codec.DoDigest.custom().setAlgorithm(Codec.DoDigest.Algorithm.SHA256).setStringData(admin.getPassword()).toBase64String();
+			admin.setPassword(encodePwd);
+			if (!encodePwd.equals(user.getPassword())) {
+				flag = true;
+			}
+		}
+		cmsUserMapper.updateById(admin);
+		if (flag) {
+			StpUtil.logoutByLoginId(admin.getId());
+		}
+
+		return GatewayResponse.SUCCESS.newBuilder().toResult("编辑成功");
+	}
+
+	/**
+	 * 手机号获取登录信息
+	 */
+	@GetMapping("/get/loginInfo")
+	public Result<AdminInfo> getLoginInfo(String phone, String code) {
+		CmsUser admin = cmsUserMapper.selectOne(
+				new QueryWrapper<CmsUser>().lambda().eq(CmsUser::getPhone, phone));
+		if (null == admin) {
+			throw BusinessRuntimeException.getInstance("该用户不存在.");
+		}
+		if (StrUtil.hasEmpty(phone, code)) {
+			throw BusinessRuntimeException.getInstance("请输入对应信息");
+		}
+		DateTime now = DateTime.now();
+		PhoneCode phoneCode = phoneCodeMapper.selectOne(Wrappers.lambdaQuery(PhoneCode.class).eq(PhoneCode::getPhone, phone).last("limit 1"));
+		if (phoneCode == null || StrUtil.isEmpty(phoneCode.getCode())) {
+			throw BusinessRuntimeException.getInstance("请重新获取手机验证码");
+		}
+		//3分钟失效
+		Date updateTime = phoneCode.getUpdateTime();
+		DateTime afterFiveMinutes = DateUtil.offsetMinute(updateTime, 3);
+		if (now.isAfter(afterFiveMinutes)) {
+			throw BusinessRuntimeException.getInstance("手机验证码已失效,请重新获取");
+		}
+		if (!StrUtil.equals(code, phoneCode.getCode())) {
+			throw BusinessRuntimeException.getInstance("手机验证码错误,请重新输入");
+		}
+		// 生成token
+
+		StpUtil.login(admin.getId());
+
+		String token = StpUtil.getTokenValue();
+
+		admin.setPassword("");
+
+		AdminInfo info = new AdminInfo();
+		info.setInfo(admin);
+		info.setToken(token);
+		return GatewayResponse.SUCCESS.newBuilder().toResult(info);
+	}
+
+	@GetMapping("/get/list")
+	public Result<Page<CmsUser>> list(@RequestParam(defaultValue = "1") Integer start, @RequestParam(defaultValue = "5") Integer limit) {
+		Page<CmsUser> page = cmsUserMapper.selectPage(new Page<>(start, limit), new LambdaQueryWrapper<CmsUser>().eq(CmsUser::getStatus, true));
+		return GatewayResponse.SUCCESS.newBuilder().toResult(page);
+	}
+
+	@GetMapping("/send/template")
+	public Result<String> sendTemplate(String title, String channel) throws Exception {
+		for (String openId : SEND_LIST) {
+			WxMpTemplateMessage templateMessage = new WxMpTemplateMessage()
+					.setToUser(openId)
+					.setTemplateId(WeChatTemplateConst.VDIEO_NOTIFY)
+					.setUrl(" ");
+			WxMpTemplateMessage.TemplateData data = templateMessage.getData();
+			data.setFirst(new WxMpTemplateData("youtube频道有更新"));
+			data.setKeyword1(new WxMpTemplateData(title));
+			data.setKeyword2(new WxMpTemplateData(channel));
+			data.setKeyword3(new WxMpTemplateData(DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss")));
+			data.setKeyword4(new WxMpTemplateData("默认"));
+			data.setRemark(new WxMpTemplateData("您订阅的频道有新内容发布"));
+			log.info("发送video模板消息至客服:{}","磨牙怪");
+			weChatService.sendTemplateMessage(weChatService.getAccessToken(), Jsons.toJson(templateMessage));
+		}
+		return GatewayResponse.SUCCESS.newBuilder().toResult();
+	}
+
+	@RequestMapping("/callback")
+	public String youtubeCallback(HttpServletRequest request, @RequestHeader Map<String, String> headers) throws IOException {
+		log.info("----------------打印请求全部消息开始----------------");
+		Enumeration<String> headerNames = request.getHeaderNames();
+		while (headerNames.hasMoreElements()) {
+			String name = headerNames.nextElement();
+			log.info("{} - {}", name, request.getHeader(name));
+		}
+		log.info("----------------打印请求全部消息结束----------------");
+		log.info("-----------------打印请求头消息开始-----------------");
+		headers.forEach((String key, String value) -> log.info(String.format("Header '%s' = %s", key, value)));
+		log.info("-----------------打印请求头消息结束-----------------");
+		Map<String, String[]> parameterMap = request.getParameterMap();
+		log.info("------------------打印全部参数开始------------------");
+		String result = "";
+		if (parameterMap.isEmpty()) {
+			log.info("请求参数为空");
+		}else {
+			parameterMap.forEach((String key, String[] value) -> {
+				for (String s : value) {
+					log.info("Param '{}' = {}", key, s);
+				}
+			});
+			result = parameterMap.get("hub.challenge")[0];
+		}
+		log.info("------------------打印全部参数结束------------------");
+		log.info("-----------------打印Reader数据开始----------------");
+		StringBuilder buffer = new StringBuilder();
+		try (BufferedReader reader = request.getReader()){
+			String line;
+			while ((line = reader.readLine()) != null) {
+				buffer.append(line);
+			}
+		} catch (IOException e) {
+			log.error(e.getMessage(), e);
+		}
+		log.info("reader -> {}", buffer);
+		log.info("-----------------打印Reader数据结束----------------");
+		return result;
+	}
+}

netflix-web/src/main/java/com/cyksj/web/controller/manage/cms/interceptor/StpInterfaceImpl.java

@@ -0,0 +1,34 @@
+package com.cyksj.web.controller.manage.cms.interceptor;
+
+import cn.dev33.satoken.stp.StpInterface;
+import org.elsa.mxx.api.logic.manage.cms.manager.CmsUserManager;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/*
+ *项目名: yicang-admin
+ *文件名: Inter
+ *创建者: JavaZou
+ *创建时间:2022/9/30 10:34
+ */
+@Component
+public class StpInterfaceImpl implements StpInterface {
+	@Autowired
+	private CmsUserManager cmsUserManager;
+
+	/**
+	 * 用户权限列表
+	 */
+	@Override
+	public List<String> getPermissionList(Object loginId, String loginType) {
+		return new ArrayList<>(cmsUserManager.getUserPermissions(loginId.toString()));
+	}
+
+	@Override
+	public List<String> getRoleList(Object loginId, String loginType) {
+		return new ArrayList<>(cmsUserManager.getUserRoles(loginId.toString()));
+	}
+}

netflix-web/src/main/resources/application.yml

@@ -1 +1 @@
-spring:
  profiles:
    active:
      - ${activeProfile}
    
+spring:
  profiles:
    active: dev