..

src/main/java/io/renren/common/utils/ConfigConstant.java

     * 云存储配置KEY
     */
    public final static String CLOUD_STORAGE_CONFIG_KEY = "CLOUD_STORAGE_CONFIG_KEY";
    /**
	 * 秒嘀短信平台url前半部分
	 */
	public static final String BASE_URL = "https://openapi.miaodiyun.com/distributor/sendSMS";
	/**
	 * 秒嘀短信平台开发者注册后系统自动生成的账号，可在官网登录后查看
	 */
	public static final String ACCOUNT_SID = "6f5c2612d691480a9bbbee0c64e10872";
	/**
	 * 秒嘀短信平台开发者注册后系统自动生成的TOKEN，可在官网登录后查看
	 */
	public static final String AUTH_TOKEN = "4fac48f2d37d4ba89cc037e7d012348e";
	
    /**
     * 秒嘀短信模板id
     */
    public static final String TEMPLATE_ID= "206770";
    /**
     * 短信过期时间(分钟)
     */
    public static final int EXPIRE_TIME = 5;
	/**
	 * http请求响应数据类型, JSON或XML
	 */
    public static final String RESP_DATA_TYPE = "JSON";
}

src/main/java/io/renren/common/utils/HttpRequestUtil.java

package io.renren.common.utils;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.URL;
import java.net.URLConnection;
import org.apache.commons.codec.digest.DigestUtils;
/**
 * http请求工具
 */
public class HttpRequestUtil {
    /**
     * 构造通用参数timestamp、sig和respDataType
     * 
     * @return
     */
    public static String createCommonParam(String sid,String token) {
        // 时间戳
        long timestamp = System.currentTimeMillis();
        // 签名
        String sig = DigestUtils.md5Hex(sid + token + timestamp);
        return "&timestamp=" + timestamp + "&sig=" + sig + "&respDataType=" + ConfigConstant.RESP_DATA_TYPE;
    }
    /**
     * post请求
     * 
     * @param url
     *            功能和操作
     * @param body
     *            要post的数据
     * @return
     * @throws IOException
     */
    public static String post(String url, String body) {
        System.out.println("body:" + System.lineSeparator() + body);
        String result = "";
        try {
            OutputStreamWriter out = null;
            BufferedReader in = null;
            URL realUrl = new URL(url);
            URLConnection conn = realUrl.openConnection();
            // 设置连接参数
            conn.setDoOutput(true);
            conn.setDoInput(true);
            conn.setConnectTimeout(5000);
            conn.setReadTimeout(20000);
            conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            // 提交数据
            out = new OutputStreamWriter(conn.getOutputStream(), "UTF-8");
            out.write(body);
            out.flush();
            // 读取返回数据
            in = new BufferedReader(new InputStreamReader(conn.getInputStream(), "UTF-8"));
            String line = "";
            boolean firstLine = true; // 读第一行不加换行符
            while ((line = in.readLine()) != null) {
                if (firstLine) {
                    firstLine = false;
                } else {
                    result += System.lineSeparator();
                }
                result += line;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
    /**
     * 回调测试工具方法
     * 
     * @param url
     * @return
     */
    public static String postHuiDiao(String url, String body) {
        String result = "";
        try {
            OutputStreamWriter out = null;
            BufferedReader in = null;
            URL realUrl = new URL(url);
            URLConnection conn = realUrl.openConnection();
            // 设置连接参数
            conn.setDoOutput(true);
            conn.setDoInput(true);
            conn.setConnectTimeout(5000);
            conn.setReadTimeout(20000);
            // 提交数据
            out = new OutputStreamWriter(conn.getOutputStream(), "UTF-8");
            out.write(body);
            out.flush();
            // 读取返回数据
            in = new BufferedReader(new InputStreamReader(conn.getInputStream(), "UTF-8"));
            String line = "";
            boolean firstLine = true; // 读第一行不加换行符
            while ((line = in.readLine()) != null) {
                if (firstLine) {
                    firstLine = false;
                } else {
                    result += System.lineSeparator();
                }
                result += line;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
}

src/main/java/io/renren/common/utils/JsonUtils.java

package io.renren.common.utils;
import java.io.IOException;
import org.springframework.util.StringUtils;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
public class JsonUtils {
    private static ObjectMapper objectMapper = new ObjectMapper();
    
    //对象转字符串
    public static <T> String obj2String(final T obj) {
        if (obj == null) {
            return null;
        }
        try {
            return obj instanceof String ? (String) obj : objectMapper.writeValueAsString(obj);
        } catch (final Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    // 字符串转对象
    @SuppressWarnings("unchecked")
    public static <T> T string2Obj(final String str, final Class<T> clazz) {
        if (StringUtils.isEmpty(str) || clazz == null) {
            return null;
        }
        try {
            return clazz.equals(String.class) ? (T) str : objectMapper.readValue(str, clazz);
        } catch (final IOException e) {
            e.printStackTrace();
            return null;
        }
    }
    public static String bean2Json(Object obj) {
        try {
            return objectMapper.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
            return null;
        }
    }
//    public static <T> T json2Bean(String jsonStr, Class<T> objClass) {
//        try {
//            return mapper.readValue(jsonStr, objClass);
//        } catch (IOException e) {
//            e.printStackTrace();
//            return null;
//        }
//    }
    public static <T> T json2Bean(String jsonStr, TypeReference<T> typeReference) {
        try {
            return objectMapper.readValue(jsonStr, typeReference);
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }
}

src/main/java/io/renren/modules/admin/controller/EmployeeController.java

package io.renren.modules.admin.controller;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;
import org.apache.commons.lang.RandomStringUtils;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.crypto.hash.Sha256Hash;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import io.renren.common.annotation.SysLog;
import io.renren.common.utils.PageUtils;
import io.renren.common.utils.R;
import io.renren.common.validator.ValidatorUtils;
import io.renren.common.validator.group.AddGroup;
import io.renren.common.validator.group.UpdateGroup;
import io.renren.modules.admin.entity.EmployeeEntity;
import io.renren.modules.admin.service.EmployeeService;
/**
 * 
 *
    @RequestMapping("/list")
    @RequiresPermissions("admin:employee:list")
    public R list(@RequestParam Map<String, Object> params){
        PageUtils page = employeeService.queryPage(params);
        Long companyId = 1L;
        PageUtils page = employeeService.queryPage(params,  companyId);
        return R.ok().put("page", page);
    }
    @RequiresPermissions("admin:employee:info")
    public R info(@PathVariable("id") Long id){
		EmployeeEntity employee = employeeService.getById(id);
        
        return R.ok().put("employee", employee);
    }
    @RequestMapping("/save")
    @RequiresPermissions("admin:employee:save")
    public R save(@RequestBody EmployeeEntity employee){
//        Date date = new Date();
////        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
////        String format = dateFormat.format(date);
        //创建时间
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        java.util.Date time = null;
        try {
            time= sdf.parse(sdf.format(new Date()));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        employee.setCreateTime(time);
		employeeService.save(employee);
        ValidatorUtils.validateEntity(employee, AddGroup.class);
        employee.setCompanyId(1L);
        employeeService.saveEmployee(employee);
        
        return R.ok();
    }
    @RequestMapping("/update")
    @RequiresPermissions("admin:employee:update")
    public R update(@RequestBody EmployeeEntity employee){
        ValidatorUtils.validateEntity(employee, UpdateGroup.class);
        //修改时间
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        java.util.Date time = null;
        try {
            time= sdf.parse(sdf.format(new Date()));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        employee.setModifyTime(time);
		employeeService.updateById(employee);
        employeeService.updateEmployee(employee);
        
        return R.ok();
    }
    @RequestMapping("/delete")
    @RequiresPermissions("admin:employee:delete")
    public R delete(@RequestBody Long[] ids){
		employeeService.delete(ids);
        employeeService.removeByIds(Arrays.asList(ids));
        
        return R.ok();
    }
//    /**
//     * 删除
//     */
//    @RequestMapping("/delete/{id}")
//    @RequiresPermissions("admin:employee:delete")
//    public R delete(@PathVariable("id") Long id){
//		//employeeService.removeByIds(Arrays.asList(ids));
//        boolean flag = employeeService.delete(id);
//        if(flag){
//            R.ok("逻辑删除成功");
//
//
//        }
//
//        return R.ok();
//    }
//    /**
//     * 重置密码
//     */
//    @SysLog("修改密码")
//    @PostMapping("/password/{id}")
//    @RequiresPermissions("admin:employee:password")
//    public R password(@PathVariable("id") Long id){
//        boolean flag = employeeService.updatePasswordByid(id);
//
//        if(flag){
//            return  R.ok("重置密码成功");
//        }
//        return R.ok();
//
//    }
    /**
     * 重置密码
     */
    @SysLog("修改密码")
    @PostMapping("/password")
    @RequiresPermissions("admin:employee:password")
    public R password(@RequestParam Map<String,Object> params){
        Long id = Long.valueOf(params.get("id").toString());
        boolean flag = employeeService.updatePasswordByid(id);
        if(flag){
            return  R.ok("重置密码成功");
        }
    @SysLog("重置密码")
    @PostMapping("/repassword/{id}")
    @RequiresPermissions("admin:employee:repassword")
    public R repassword(@PathVariable("id") Long id){
        EmployeeEntity employee = employeeService.getById(id);
        employee.setPassword("123456");
        employeeService.updateEmployee(employee);
        return R.ok();
    }
    /**
     * 模糊查询name获取 employee(获得id在分配人员时使用)
     * 模糊查询name获取list
     */
    @GetMapping("/listbyname")
    @RequiresPermissions("admin:employee:list")
    public R listByName(@RequestParam Map<String,Object> params){
        Long companyId = 1L;
        String truename = (String) params.get("truename");
        List<Map<String, Object>> list = employeeService.selectNameList(truename);
        List<Map<String, Object>> list = employeeService.selectNameList(truename, companyId);
        return  R.ok().put("list", list);
    }
    /**
     * 模糊查询company_id获取 employee id,name(获得id在分配人员时使用)
     * 根据company_id获取 employee id,name(获得id在分配人员时使用)
     */
    
    @GetMapping("/listbycid/{cid}")
    @RequiresPermissions("admin:employee:list")
    public R selectNameListByCompanyId(@PathVariable("cid") Long cid) {

src/main/java/io/renren/modules/admin/controller/MemberController.java

import io.renren.modules.admin.entity.MemberEntity;
import io.renren.modules.admin.service.MemberService;
import io.renren.modules.sys.controller.AbstractController;
import io.renren.modules.admin.service.AttendersService;
/**
 * 会员表
    public R info(@PathVariable("id") Long id){
        MemberEntity member = memberService.getById(id);
        member.setPassword("");
        List<Map<String, Object>> meetingList = memberService.getMeetingListById(id);
        List<Map<String, Object>> meetingList = memberService.getMeetingListByMemberId(id);
        
        return R.ok().put("member", member).put("meetingList", meetingList);
    }
    @ApiOperation("修改")
    public R update(@RequestBody MemberEntity member){
        ValidatorUtils.validateEntity(member, UpdateGroup.class);
        member.setModifyTime(new Date());
        member.setModifyId(getUserId());
		memberService.updateById(member);
		memberService.updateMember(member);
        return R.ok();
    }
    public R repassword(@PathVariable("id") Long id){
        MemberEntity member = memberService.getById(id);
        member.setPassword("123456");
        member.setModifyTime(new Date());
        member.setModifyId(getUserId());
		memberService.updateById(member);
		memberService.updateMember(member);
        return R.ok();
    }

src/main/java/io/renren/modules/admin/dao/EmployeeDao.java

 */
@Mapper
public interface EmployeeDao extends BaseMapper<EmployeeEntity> {
    List<EmployeeEntity> findAllByisDel(int isDel);
    @Select("select e.id,e.truename,e.username,e.password,e.phone,e.email,e.create_time,e.modify_time,e.is_del,c.companyname,c.id as cid " +
            " from employee e left JOIN company c on e.company_id = c.id" +
            " where e.is_del = 0 AND (e.truename like '%${key}%' or e.username like '%${key2}%') limit #{startLimt},#{endLimt}")
    List<Map<String, Object>> getPageList(String key1, String key2, int startLimt, int endLimt);
    boolean updatePasswordByid(Long id);
    @Select("select count(*) from employee where is_del=0 and (truename like '%${key1}%' or username like '%${key2}%')")
    Integer getCounts(String key1,String key2);
//    boolean delete(Long id);
    List<EmployeeEntity> findAllByisDel(int isDel);
    //多表联查 + 分页
    @Select("select e.id,e.truename,e.username,e.password,e.phone,e.email,e.create_time,e.modify_time,e.is_del,c.companyname,c.id as cid " +
     * @param truename
     * @return
     */
    @Select("select id,truename from employee where truename like '%${truename}%'")
    List<Map<String, Object>> selectNameList(String truename);
    @Select("select id,truename from employee where truename like '%${truename}%' and `company_id`=#{companyId};")
    List<Map<String, Object>> selectNameList(String truename, Long companyId);
    @Select("SELECT `id`,`truename` FROM `employee` WHERE `company_id`=#{companyId};")
    List<Map<String, Object>> selectNameListByCompanyId(Long companyId);

src/main/java/io/renren/modules/admin/dao/MemberDao.java

     * 根据会员id, 查询获取最近参加的会议
     */
    @Select("SELECT a.id as aid,a.meeting_id,m.name_cn FROM attenders a JOIN meeting m ON a.meeting_id=m.id WHERE a.member_id=#{Id} ORDER BY a.id;")
    List<Map<String, Object>> getMeetingListById(Long Id);
    List<Map<String, Object>> getMeetingListByMemberId(Long Id);
}

src/main/java/io/renren/modules/admin/entity/EmployeeEntity.java

import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonIgnore;
import io.renren.common.validator.group.AddGroup;
import io.renren.common.validator.group.UpdateGroup;
import java.io.Serializable;
import java.util.Date;
import javax.validation.constraints.Email;
import javax.validation.constraints.NotBlank;
import lombok.Data;
/**
	/**
	 * 账号
	 */
	@NotBlank(message="用户名不能为空", groups = {AddGroup.class, UpdateGroup.class})
	private String username;
	/**
	 * 密码
	 */
	@JsonIgnore
	private String password;
	/**
	 * 盐
	 */
	@JsonIgnore
	private String salt;
	/**
	 * 姓名
	 */
	@NotBlank(message="姓名不能为空", groups = {AddGroup.class, UpdateGroup.class})
	private String truename;
	/**
	 * 单位id
	/**
	 * 部门id
	 */
	private Long departmentId;
	private String department;
	/**
	 * 职位id
	 */
	private Long positionId;
	private String position;
	/**
	 * 联系电话
	 */
	@NotBlank(message="手机号不能为空", groups = {AddGroup.class, UpdateGroup.class})
	private String phone;
	/**
	 * 邮箱
	 */
	@Email(message="邮箱格式不正确", groups = {AddGroup.class, UpdateGroup.class})
	private String email;
	/**
	 * 创建时间
	/**
	 * 是否被删除 状态  0：正常   1：删除
	 */
	@JsonIgnore
	@TableLogic
	private Integer isDel;
}

src/main/java/io/renren/modules/admin/entity/MemberEntity.java

	/**
	 * 密码
	 */
	@NotBlank(message="密码不能为空", groups = AddGroup.class)
	// @JsonIgnore
	@JsonIgnore
	private String password;
	/**
	 * 盐
	/**
	 * 是否被删除 状态  0：正常   1：删除
	 */
	@JsonIgnore
	private Integer isDel;
}

src/main/java/io/renren/modules/admin/service/EmployeeService.java

package io.renren.modules.admin.service;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import java.util.List;
import java.util.Map;
import com.baomidou.mybatisplus.extension.service.IService;
import io.renren.common.utils.PageUtils;
import io.renren.modules.admin.entity.EmployeeEntity;
import javafx.scene.control.Pagination;
import org.apache.ibatis.annotations.Param;
import java.util.List;
import java.util.Map;
/**
 * 
    PageUtils queryPage(Map<String, Object> params);
    PageUtils queryPage(Map<String, Object> params, Long companyId);
    
    PageUtils myQueryPage(Map<String, Object> params);
    List<EmployeeEntity> findAllByisDel(int isDel);
    /**
     */
    List<EmployeeEntity> findAllByTrueName(String truename);
    boolean updatePasswordByid(Long id);
    void delete(Long[] ids);
    // 多表联查 + 分页
    PageUtils queryList(int page, int limit, String key);
    
    
	void updateEmployee(EmployeeEntity employee);
    
	void saveEmployee(EmployeeEntity employee);
    
    /**
     * 根据真实姓名模糊查询id
     * 
     * @param truename
     * @return
     */
    List<Map<String, Object>> selectNameList(String truename);
    List<Map<String, Object>> selectNameList(String truename, Long companyId);
    /**
     * 获取工作人员联系方式
     */
    List<Map<String, Object>> getContact(String ids);
    /**
     * 根据单位获取员工列表
     * @return
     */
    Map<Long, String> selectNameListByCompanyId(Long companyId);
    List<Map<String, Object>> getContact(String ids);
}

src/main/java/io/renren/modules/admin/service/MemberService.java

     * 根据会员id, 查询获取最近参加的会议
	 * @param id
     */
	List<Map<String, Object>> getMeetingListById(Long id);
	List<Map<String, Object>> getMeetingListByMemberId(Long id);
    /**
	 * 保存用户
	/**
	 * 修改用户
	 */
	void update(MemberEntity member);
	void updateMember(MemberEntity member);
	/**
	 * 更新审核状态

src/main/java/io/renren/modules/admin/service/impl/EmployeeServiceImpl.java

package io.renren.modules.admin.service.impl;
import org.apache.commons.lang.RandomStringUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.shiro.crypto.hash.Sha256Hash;
import org.springframework.stereotype.Service;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
    @Override
    public PageUtils queryPage(Map<String, Object> params) {
        Long companyId = params.containsKey("companyId") ? Long.valueOf((String) params.get("companyId")) : 1L;
        String key = (String) params.get("key");
        IPage<EmployeeEntity> page = this.page(
                new Query<EmployeeEntity>().getPage(params),
                new QueryWrapper<EmployeeEntity>()
                .eq("company_id", companyId)
                .like(StringUtils.isNotBlank(key),"username",key)
                        .or()
                .like(StringUtils.isNotBlank(key),"truename",key)
        return new PageUtils(page);
    }
    
    @Override
    public List<EmployeeEntity> findAllByisDel(int isDel) {
        return  baseMapper.findAllByisDel(isDel);
    public PageUtils queryPage(Map<String, Object> params, Long companyId) {
        String key = (String) params.get("key");
        IPage<EmployeeEntity> page = this.page(
                new Query<EmployeeEntity>().getPage(params),
                new QueryWrapper<EmployeeEntity>()
                .eq("company_id", companyId)
                .like(StringUtils.isNotBlank(key),"username",key)
                        .or()
                .like(StringUtils.isNotBlank(key),"truename",key)
        );
        return new PageUtils(page);
    }
    
    @Override
    public List<EmployeeEntity> findAllByTrueName(String truename) {
        return baseMapper.findAllByTrueName(truename);
    public PageUtils myQueryPage(Map<String, Object> params) {
        // Long company_id = params.containsKey("company_id") ? Long.valueOf((String) params.get("company_id")) : 1;
        String key = params.containsKey("page") ? (String) params.get("key") : "";
        int page = params.containsKey("page") ? Integer.valueOf(params.get("page").toString()): 1;
        int limit = params.containsKey("limit") ? Integer.valueOf(params.get("limit").toString()) : 10;
        if (page < 1) {
            page = 1;
        }
        int startLimt = (page-1) * limit;
        int endLimt = startLimt + limit;
        List<Map<String, Object>> employeeList=baseMapper.getPageList(key, key, startLimt, endLimt);
        int total = baseMapper.getCounts(key, key);
        return  new  PageUtils(employeeList, total, limit, page);
    }
    @Override
    public boolean updatePasswordByid(Long id) {
        return baseMapper.updatePasswordByid(id);
    public List<EmployeeEntity> findAllByisDel(int isDel) {
        return  baseMapper.findAllByisDel(isDel);
    }
    @Override
    public void delete(Long[]  ids) {
       baseMapper.deleteBatchIds(Arrays.asList(ids));
    public List<EmployeeEntity> findAllByTrueName(String truename) {
        return baseMapper.findAllByTrueName(truename);
    }
    @Override
    }
    @Override
    public List<Map<String, Object>> selectNameList(String truename) {
        return baseMapper.selectNameList(truename);
    public List<Map<String, Object>> selectNameList(String truename, Long companyId) {
        return baseMapper.selectNameList(truename, companyId);
    }
    @Override
    public List<Map<String, Object>> getContact(String ids) {
        return baseMapper.getContact(ids);
    }
    @Override
    public void saveEmployee(EmployeeEntity employee) {
        // if(StringUtils.isBlank(employee.getPassword())){
        //     employee.setPassword("123456");
        // }
        employee.setPassword("123456");
        employee.setCreateTime(new Date());
        String salt = RandomStringUtils.randomAlphanumeric(20);
        employee.setPassword(new Sha256Hash(employee.getPassword(), salt).toHex());
        employee.setSalt(salt);
        this.save(employee);
    }
    @Override
    public void updateEmployee(EmployeeEntity employee) {
        employee.setModifyTime(new Date());
        // if(StringUtils.isBlank(employee.getPassword())){
		// 	employee.setPassword(null);
		// }else{
        //     String salt = RandomStringUtils.randomAlphanumeric(20);
        //     employee.setPassword(new Sha256Hash(employee.getPassword(), salt).toHex());
        //     employee.setSalt(salt);
        // }
        employee.setPassword(null);
        this.updateById(employee);
    }
}

src/main/java/io/renren/modules/admin/service/impl/MemberServiceImpl.java

import org.apache.commons.lang.RandomStringUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.shiro.crypto.hash.Sha256Hash;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import io.renren.modules.admin.dao.MemberDao;
import io.renren.modules.admin.entity.MemberEntity;
import io.renren.modules.admin.service.MemberService;
import io.renren.modules.admin.service.AttendersService;
@Service("memberService")
public class MemberServiceImpl extends ServiceImpl<MemberDao, MemberEntity> implements MemberService {
    @Autowired
    private AttendersService attendersService;
    @Override
    public PageUtils queryPage(Map<String, Object> params) {
        String key = (String)params.get("key");
            mMap.put("email", member.getEmail());
            mMap.put("createTime", member.getCreateTime());
            mMap.put("isCheck", member.getIsCheck());
            List<Map<String, Object>> meetingList = attendersService.getMeetingListByMemberId(memberId);
            List<Map<String, Object>> meetingList = this.getMeetingListByMemberId(memberId);
            int meetingCounts = meetingList.size();
            if (meetingCounts > 0) {
                Map<String, Object> meetingInfo = meetingList.get(meetingCounts - 1);
            mMap.put("meetingCounts", meetingCounts);
            list.add(mMap);
        }
        return new PageUtils(list, (int)page.getTotal(), (int)page.getSize(), (int)page.getCurrent());
    }
    @Override
	@Transactional
    public void saveMember(MemberEntity member){
         // if(StringUtils.isBlank(member.getPassword())){
        //     member.setPassword("123456");
        // }
        member.setCreateTime(new Date());
        member.setPassword("123456");
        //sha256加密
		String salt = RandomStringUtils.randomAlphanumeric(20);
		member.setPassword(new Sha256Hash(member.getPassword(), salt).toHex());
		member.setSalt(salt);
        member.setSalt(salt);
		this.save(member); 
    }
    @Override
	@Transactional
    public void update(MemberEntity member) {
    public void updateMember(MemberEntity member) {
        member.setModifyTime(new Date());
        // if(StringUtils.isBlank(member.getPassword())){
		// 	member.setPassword(null);
		// }else{
        //     String salt = RandomStringUtils.randomAlphanumeric(20);
        //     member.setPassword(new Sha256Hash(member.getPassword(), salt).toHex());
        //     member.setSalt(salt);
        // }
        member.setPassword(null);
        
        member.setUsername(null);
        if(StringUtils.isBlank(member.getPassword())){
			member.setPassword(null);
		}else{
			member.setPassword(new Sha256Hash(member.getPassword(), member.getSalt()).toHex());
		}
        this.updateById(member);
    }
    }
    @Override
    public List<Map<String, Object>> getMeetingListById(Long id) {
        return baseMapper.getMeetingListById(id);
    public List<Map<String, Object>> getMeetingListByMemberId(Long id) {
        return baseMapper.getMeetingListByMemberId(id);
    }
}

src/main/java/io/renren/modules/app/controller/AppRegisterController.java

import io.renren.common.utils.R;
import io.renren.common.validator.ValidatorUtils;
import io.renren.common.validator.group.AddGroup;
import io.renren.modules.app.entity.UserEntity;
import io.renren.modules.app.form.RegisterForm;
import io.renren.modules.app.service.SmsCodeService;
import io.renren.modules.app.service.UserService;
import io.renren.common.utils.JsonUtils;
import io.renren.modules.app.entity.SmsStatusEntity;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.codec.digest.DigestUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.Date;
/**
 * 注册
    @Autowired
    private UserService userService;
    // @PostMapping("register")
    // @ApiOperation("注册")
    // public R register(@RequestBody RegisterForm form){
    //     //表单校验
        //  ValidatorUtils.validateEntity(form);
        //  UserEntity user = new UserEntity();
        //  user.setMobile(form.getMobile());
        //  user.setUsername(form.getMobile());
        //  user.setPassword(DigestUtils.sha256Hex(form.getPassword()));
        //  user.setCreateTime(new Date());
        //  userService.save(user);
    @Autowired
    private SmsCodeService smsCodeService;
    //     return R.ok();
    // }
    /**
     * 短信验证码
     */
    @PostMapping("/mobilecode")
    public R mobileCode(String uuid, String phone) {
        // 获取短信验证码
        String code = smsCodeService.getCode(uuid, phone);
        try {
            String result = smsCodeService.sendCode(code, phone);
            return R.ok().put("result", result);
        } catch (Exception e) {
            e.printStackTrace();
            return R.error();
        }
    }
    @PostMapping("register")
    @ApiOperation("注册")
    public R register(@RequestBody UserEntity user){
        user.setUsername(user.getPhone());
    public R register(@RequestBody RegisterForm form){
        boolean captcha = smsCodeService.validate(form.getUuid(), form.getCode());
		if(!captcha){
			return R.error("验证码不正确");
        }
        
        //表单校验
        ValidatorUtils.validateEntity(user, AddGroup.class);
         ValidatorUtils.validateEntity(form);
        userService.saveUser(user);
         UserEntity user = new UserEntity();
         user.setPhone(form.getPhone());
         user.setUsername(form.getPhone());
         user.setPassword(form.getPassword());
         userService.saveUser(user);
        return R.ok();
    }

src/main/java/io/renren/modules/app/controller/SmsTestController.java

package io.renren.modules.app.controller;
import io.renren.common.utils.HttpRequestUtil;
import io.renren.modules.app.service.SmsCodeService;
import io.renren.common.utils.ConfigConstant;
import java.net.URLEncoder;
import java.util.UUID;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("app/smscode")
public class SmsTestController {
	@Autowired
    private SmsCodeService smsCodeService;
    
    /**
	 * 短信发送(验证码通知，会员营销)
	 * 接口文档地址：http://www.miaodiyun.com/doc/https_sms.html
	 */
	@PostMapping("/test")
	public String execute() throws Exception{
		String uuid = UUID.randomUUID().toString();
		String phone = "17611467373";
		String code = smsCodeService.getCode(uuid, phone);
		StringBuilder sb = new StringBuilder();
		sb.append("accountSid").append("=").append(ConfigConstant.ACCOUNT_SID);
		sb.append("&to").append("=").append(phone);
		sb.append("&param").append("=").append(URLEncoder.encode(code + "," + ConfigConstant.EXPIRE_TIME,"UTF-8"));
		sb.append("&templateid").append("=").append("206770");
		String body = sb.toString() + HttpRequestUtil.createCommonParam(ConfigConstant.ACCOUNT_SID, ConfigConstant.AUTH_TOKEN);
		String result = HttpRequestUtil.post(ConfigConstant.BASE_URL, body);
		System.out.println(result);
		return result;
	}
}

src/main/java/io/renren/modules/app/dao/SmsCodeDao.java

package io.renren.modules.app.dao;
import io.renren.modules.app.entity.SmsCodeEntity;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
/**
 * 短信平台验证码
 * 
 * @author chenshun
 * @email sunlightcs@gmail.com
 * @date 2020-05-20 09:54:35
 */
@Mapper
public interface SmsCodeDao extends BaseMapper<SmsCodeEntity> {
	
}

src/main/java/io/renren/modules/app/entity/SmsCodeEntity.java

package io.renren.modules.app.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.util.Date;
import lombok.Data;
/**
 * 短信平台验证码
 * 
 * @author chenshun
 * @email sunlightcs@gmail.com
 * @date 2020-05-20 09:54:35
 */
@Data
@TableName("sms_code")
public class SmsCodeEntity implements Serializable {
	private static final long serialVersionUID = 1L;
	/**
	 * 
	 */
	@TableId(type = IdType.INPUT)
	private String uuid;
	/**
	 * 
	 */
	private String phone;
	/**
	 * 
	 */
	private String code;
	/**
	 * 过期时间
	 */
	private Date expireTime;
}

src/main/java/io/renren/modules/app/entity/SmsStatusEntity.java

package io.renren.modules.app.entity;
import lombok.Data;
/**
 * 短信发送返回值实体类
 */
@Data
public class SmsStatusEntity {
    private String respCode;
    private String respDesc;
    private String smsId;
    private String[] failList;
}

src/main/java/io/renren/modules/app/form/RegisterForm.java

import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Email;
/**
 * 注册表单
    @ApiModelProperty(value = "手机号")
    @NotBlank(message="手机号不能为空")
    private String phone;
    @ApiModelProperty(value = "密码")
    @NotBlank(message="密码不能为空")
    private String password;
    @ApiModelProperty(value = "姓名")
    @NotBlank(message="姓名不能为空")
    private String truename;
    @ApiModelProperty(value = "性别")
	private Integer sex;
    @ApiModelProperty(value = "头像")
	private String titlePic;
    @ApiModelProperty(value = "所属机构")
	private String organization;
    @ApiModelProperty(value = "职位")
	private String position;
    @ApiModelProperty(value = "职称")
	private String jobTitle;
    @ApiModelProperty(value = "邮箱")
	@Email(message="邮箱格式不正确")
	private String email;
    @ApiModelProperty(value = "短信验证码")
    @NotBlank(message="短信验证码不能为空")
    private String code;
    @ApiModelProperty(value = "uuid")
    private String uuid;
}

src/main/java/io/renren/modules/app/service/SmsCodeService.java

package io.renren.modules.app.service;
import com.baomidou.mybatisplus.extension.service.IService;
import io.renren.common.utils.PageUtils;
import io.renren.modules.app.entity.SmsCodeEntity;
import java.util.Map;
/**
 * 短信验证码
 *
 * @author chenshun
 * @email sunlightcs@gmail.com
 * @date 2020-05-20 09:54:35
 */
public interface SmsCodeService extends IService<SmsCodeEntity> {
    /**
     * 获取短信验证码
     */
    String getCode(String uuid, String phone);
    /**
     * 验证码效验
     * @param uuid  uuid
     * @param code  验证码
     * @return  true：成功  false：失败
     */
    boolean validate(String uuid, String code);
    /**
     *  发送短信验证码
     * @param code
     * @param phone
     * @return
     * @throws Exception
     */
	String sendCode(String code, String phone) throws Exception;
}

src/main/java/io/renren/modules/app/service/impl/SmsCodeServiceImpl.java

package io.renren.modules.app.service.impl;
import org.springframework.stereotype.Service;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.Date;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import io.renren.common.exception.RRException;
import org.apache.commons.lang.StringUtils;
import io.renren.common.utils.ConfigConstant;
import io.renren.common.utils.DateUtils;
import io.renren.common.utils.HttpRequestUtil;
import io.renren.modules.app.dao.SmsCodeDao;
import io.renren.modules.app.entity.SmsCodeEntity;
import io.renren.modules.app.service.SmsCodeService;
@Service("smsCodeService")
public class SmsCodeServiceImpl extends ServiceImpl<SmsCodeDao, SmsCodeEntity> implements SmsCodeService {
    @Override
    public String getCode(String uuid, String phone){
        if (StringUtils.isBlank(uuid)) {
            throw new RRException("uuid不能为空");
        }
        // 生成数字验证码
        String code = String.valueOf((int) ((Math.random() * 9 + 1) * 100000));
        SmsCodeEntity smsCodeEntity = new SmsCodeEntity();
        smsCodeEntity.setUuid(uuid);
        smsCodeEntity.setPhone(phone);
        smsCodeEntity.setCode(code);
        smsCodeEntity.setExpireTime(DateUtils.addDateMinutes(new Date(), ConfigConstant.EXPIRE_TIME));
        this.save(smsCodeEntity);
        return code;
    }
    @Override
    public boolean validate(String uuid, String code) {
        SmsCodeEntity smsCodeEntity = this.getOne(new QueryWrapper<SmsCodeEntity>().eq("uuid", uuid));
        if(smsCodeEntity == null){
            return false;
        }
        //删除验证码
        this.removeById(uuid);
        if(smsCodeEntity.getCode().equalsIgnoreCase(code) && smsCodeEntity.getExpireTime().getTime() >= System.currentTimeMillis()){
            return true;
        }
        return false;
    }
    @Override
    public String sendCode(String code, String phone) throws Exception {
        StringBuilder sb = new StringBuilder();
		sb.append("accountSid").append("=").append(ConfigConstant.ACCOUNT_SID);
		sb.append("&to").append("=").append(phone);
        sb.append("&param").append("=").append(URLEncoder.encode(code + "," + ConfigConstant.EXPIRE_TIME, "UTF-8"));
		sb.append("&templateid").append("=").append(ConfigConstant.TEMPLATE_ID);
		String body = sb.toString() + HttpRequestUtil.createCommonParam(ConfigConstant.ACCOUNT_SID, ConfigConstant.AUTH_TOKEN);
		String result = HttpRequestUtil.post(ConfigConstant.BASE_URL, body);
		System.out.println(result);
        return result;
    }
}

src/main/resources/mapper/admin/EmployeeDao.xml

    <select id="findAllByisDel" resultType="io.renren.modules.admin.entity.EmployeeEntity">
        select * from employee where  is_del = #{isDel}
    </select>
    <update id="updatePasswordByid" parameterType="map">
        update employee set password = "123456" where id = #{id}
    </update>
    <!--<update id="delete" parameterType="map">-->
        <!--update employee set is_del= 1  where id = #{id}-->
    <!--</update>-->
    <!--<select id="queryListBykey" resultType="io.renren.modules.generator.entity.EmployeeEntity">-->
      <!--select e.id,e.truename,e.username,e.password,e.phone,e.email,e.create_time,e.modify_time,e.is_del,c.companyname from employee e left JOIN company c on e.company_id = c.id-->
        <!--where e.is_del = 0 AND (e.truename like '%${key}%' or e.username like '%${key2}%') limit #{page},#{limit}-->
    <!--</select>-->
    <!--<select id="queryTotalCount" resultType="io.renren.modules.generator.entity.EmployeeEntity">-->
        <!--select count(*) from employee where is_del=0 and (truename like '%${key}%' or username like '%${key2}%')-->
    <!--</select>-->
</mapper>