访客下放权限

epmet-commons/epmet-commons-tools/src/main/java/com/epmet/commons/tools/redis/RedisKeys.java

@@ -856,4 +856,20 @@ public class RedisKeys {
 		}
 		return rootPrefix.concat("staffbaseinfo:")+userId;
 	}
+
+
+	/**
+	 * 大华publicKey
+	 */
+	public static String getDhPublicKey() {
+		return rootPrefix.concat("dh:public");
+	}
+
+	/**
+	 * 大华token
+	 */
+	public static String getDhToken() {
+		return rootPrefix.concat("dh:token");
+	}
+
 }

epmet-user/epmet-user-client/src/main/java/com/epmet/dto/DhTokenDTO.java

@@ -0,0 +1,39 @@
+package com.epmet.dto;
+
+import lombok.Data;
+
+import java.io.Serializable;
+
+
+/**
+ * 大华设备鉴权信息
+ *
+ * @author generator generator@elink-cn.com
+ * @since v1.0.0 2022-04-22
+ */
+@Data
+public class DhTokenDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 主键
+     */
+	private String id;
+
+    /**
+     * loginName
+     */
+	private String loginName;
+
+    /**
+     * token
+     */
+    private String token;
+
+    /**
+     * publicKey
+     */
+	private String publicKey;
+
+}

epmet-user/epmet-user-client/src/main/java/com/epmet/dto/form/DhAuthFormDTO.java

@@ -0,0 +1,27 @@
+package com.epmet.dto.form;
+
+import com.epmet.dto.result.DhChannelResultDTO;
+import lombok.Data;
+
+import java.io.Serializable;
+import java.util.List;
+
+
+/**
+ * 海康社区人员信息下放
+ *
+ * @author generator generator@elink-cn.com
+ * @since v1.0.0 2022-05-20
+ */
+@Data
+public class DhAuthFormDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private String cardNumber;
+
+    private String timeQuantumId;
+
+    private List<DhChannelResultDTO> cardPrivilegeDetails;
+
+}

epmet-user/epmet-user-client/src/main/java/com/epmet/dto/form/DhCardPageFormDTO.java

@@ -0,0 +1,29 @@
+package com.epmet.dto.form;
+
+import lombok.Data;
+
+import java.io.Serializable;
+
+
+/**
+ * 海康社区人员信息下放
+ *
+ * @author generator generator@elink-cn.com
+ * @since v1.0.0 2022-05-20
+ */
+@Data
+public class DhCardPageFormDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private Integer pageNum;
+
+    private Integer pageSize;
+
+    private String personCode;
+
+    private String cardNumber;
+
+    private String cardStatus;
+
+}

epmet-user/epmet-user-client/src/main/java/com/epmet/dto/form/DhChannelFormDTO.java

@@ -0,0 +1,23 @@
+package com.epmet.dto.form;
+
+import lombok.Data;
+
+import java.io.Serializable;
+
+
+/**
+ * 海康社区人员信息下放
+ *
+ * @author generator generator@elink-cn.com
+ * @since v1.0.0 2022-05-20
+ */
+@Data
+public class DhChannelFormDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private String interfaceId;
+
+    private String jsonParam;
+
+}

epmet-user/epmet-user-client/src/main/java/com/epmet/dto/form/DhChannelPageFormDTO.java

@@ -0,0 +1,25 @@
+package com.epmet.dto.form;
+
+import lombok.Data;
+
+import java.io.Serializable;
+
+
+/**
+ * 海康社区人员信息下放
+ *
+ * @author generator generator@elink-cn.com
+ * @since v1.0.0 2022-05-20
+ */
+@Data
+public class DhChannelPageFormDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private Integer pageNum;
+
+    private Integer pageSize;
+
+    private String deviceGenre;
+
+}

epmet-user/epmet-user-client/src/main/java/com/epmet/dto/form/DhDeptFormDTO.java

@@ -0,0 +1,25 @@
+package com.epmet.dto.form;
+
+import lombok.Data;
+
+import java.io.Serializable;
+
+
+/**
+ * 海康社区人员信息下放
+ *
+ * @author generator generator@elink-cn.com
+ * @since v1.0.0 2022-05-20
+ */
+@Data
+public class DhDeptFormDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private String name;
+
+    private String description;
+
+    private Long parentId;
+
+}

epmet-user/epmet-user-client/src/main/java/com/epmet/dto/form/DhIdentityFormDTO.java

@@ -0,0 +1,29 @@
+package com.epmet.dto.form;
+
+import lombok.Data;
+
+import java.io.Serializable;
+
+
+/**
+ * 海康社区人员信息下放
+ *
+ * @author generator generator@elink-cn.com
+ * @since v1.0.0 2022-05-20
+ */
+@Data
+public class DhIdentityFormDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private String name;
+
+    private Double subsidyAmount;
+
+    private Integer isCashRecharge;
+
+    private Integer isMachineRecharge;
+
+    private String description;
+
+}

epmet-user/epmet-user-client/src/main/java/com/epmet/dto/form/DhLoginPassFormDTO.java

@@ -0,0 +1,23 @@
+package com.epmet.dto.form;
+
+import lombok.Data;
+
+import java.io.Serializable;
+
+
+/**
+ * 海康社区人员信息下放
+ *
+ * @author generator generator@elink-cn.com
+ * @since v1.0.0 2022-05-20
+ */
+@Data
+public class DhLoginPassFormDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private String loginName;
+
+    private String loginPass;
+
+}

epmet-user/epmet-user-client/src/main/java/com/epmet/dto/form/DhNodeFormDTO.java

@@ -0,0 +1,23 @@
+package com.epmet.dto.form;
+
+import lombok.Data;
+
+import java.io.Serializable;
+
+
+/**
+ * 海康社区人员信息下放
+ *
+ * @author generator generator@elink-cn.com
+ * @since v1.0.0 2022-05-20
+ */
+@Data
+public class DhNodeFormDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private String typeCode;
+
+    private String nodeId;
+
+}

epmet-user/epmet-user-client/src/main/java/com/epmet/dto/form/DhPersonCardFormDTO.java

@@ -0,0 +1,39 @@
+package com.epmet.dto.form;
+
+import lombok.Data;
+
+import java.io.Serializable;
+
+
+/**
+ * 海康社区人员信息下放
+ *
+ * @author generator generator@elink-cn.com
+ * @since v1.0.0 2022-05-20
+ */
+@Data
+public class DhPersonCardFormDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private Long personId;
+
+    private String personName;
+
+    private String cardNumber;
+
+    private String cardType;
+
+    private String category;
+
+    private String cardStatus;
+
+    private String startDate;
+
+    private String endDate;
+
+    private String cardPassword;
+
+    private String subSystems;
+
+}

epmet-user/epmet-user-client/src/main/java/com/epmet/dto/form/DhPersonCardListFormDTO.java

@@ -0,0 +1,22 @@
+package com.epmet.dto.form;
+
+import lombok.Data;
+
+import java.io.Serializable;
+import java.util.List;
+
+
+/**
+ * 海康社区人员信息下放
+ *
+ * @author generator generator@elink-cn.com
+ * @since v1.0.0 2022-05-20
+ */
+@Data
+public class DhPersonCardListFormDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private List<DhPersonCardFormDTO> objectList;
+
+}

epmet-user/epmet-user-client/src/main/java/com/epmet/dto/form/DhPersonDelFormDTO.java

@@ -0,0 +1,22 @@
+package com.epmet.dto.form;
+
+import lombok.Data;
+
+import java.io.Serializable;
+import java.util.List;
+
+
+/**
+ * 海康社区人员信息下放
+ *
+ * @author generator generator@elink-cn.com
+ * @since v1.0.0 2022-05-20
+ */
+@Data
+public class DhPersonDelFormDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private List<Integer> personIds;
+
+}

epmet-user/epmet-user-client/src/main/java/com/epmet/dto/form/DhPersonFormDTO.java

@@ -0,0 +1,39 @@
+package com.epmet.dto.form;
+
+import lombok.Data;
+
+import java.io.Serializable;
+
+
+/**
+ * 海康社区人员信息下放
+ *
+ * @author generator generator@elink-cn.com
+ * @since v1.0.0 2022-05-20
+ */
+@Data
+public class DhPersonFormDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private String paperType;
+
+    private String paperNumber;
+
+    private String name;
+
+    private String code;
+
+    private Long deptId;
+
+    private String sex;
+
+    private String birthday;
+
+    private String phone;
+
+    private String status;
+
+    private String personIdentityId;
+
+}

epmet-user/epmet-user-client/src/main/java/com/epmet/dto/form/DhPersonImgFormDTO.java

@@ -0,0 +1,23 @@
+package com.epmet.dto.form;
+
+import lombok.Data;
+
+import java.io.Serializable;
+
+
+/**
+ * 海康社区人员信息下放
+ *
+ * @author generator generator@elink-cn.com
+ * @since v1.0.0 2022-05-20
+ */
+@Data
+public class DhPersonImgFormDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private String personCode;
+
+    private String base64file;
+
+}

epmet-user/epmet-user-client/src/main/java/com/epmet/dto/form/DhPersonPageFormDTO.java

@@ -0,0 +1,25 @@
+package com.epmet.dto.form;
+
+import lombok.Data;
+
+import java.io.Serializable;
+
+
+/**
+ * 海康社区人员信息下放
+ *
+ * @author generator generator@elink-cn.com
+ * @since v1.0.0 2022-05-20
+ */
+@Data
+public class DhPersonPageFormDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private Integer pageNum;
+
+    private Integer pageSize;
+
+    private String code;
+
+}

epmet-user/epmet-user-client/src/main/java/com/epmet/dto/form/DhPlanFormDTO.java

@@ -0,0 +1,27 @@
+package com.epmet.dto.form;
+
+import lombok.Data;
+
+import java.io.Serializable;
+
+
+/**
+ * 海康社区人员信息下放
+ *
+ * @author generator generator@elink-cn.com
+ * @since v1.0.0 2022-05-20
+ */
+@Data
+public class DhPlanFormDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private String detail;
+
+    private String memo;
+
+    private String name;
+
+    private Integer type;
+
+}

epmet-user/epmet-user-client/src/main/java/com/epmet/dto/form/DhPlanPageFormDTO.java

@@ -0,0 +1,25 @@
+package com.epmet.dto.form;
+
+import lombok.Data;
+
+import java.io.Serializable;
+
+
+/**
+ * 海康社区人员信息下放
+ *
+ * @author generator generator@elink-cn.com
+ * @since v1.0.0 2022-05-20
+ */
+@Data
+public class DhPlanPageFormDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private Integer pageNum;
+
+    private Integer pageSize;
+
+    private String singleCondition;
+
+}

epmet-user/epmet-user-client/src/main/java/com/epmet/dto/form/DhPublicKeyFormDTO.java

@@ -0,0 +1,21 @@
+package com.epmet.dto.form;
+
+import lombok.Data;
+
+import java.io.Serializable;
+
+
+/**
+ * 海康社区人员信息下放
+ *
+ * @author generator generator@elink-cn.com
+ * @since v1.0.0 2022-05-20
+ */
+@Data
+public class DhPublicKeyFormDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private String loginName;
+
+}

epmet-user/epmet-user-client/src/main/java/com/epmet/dto/form/VisitVisitorFormDTO.java

@@ -0,0 +1,51 @@
+package com.epmet.dto.form;
+
+import com.epmet.commons.tools.validator.group.AddGroup;
+import com.epmet.commons.tools.validator.group.DefaultGroup;
+import lombok.Data;
+
+import javax.validation.constraints.NotBlank;
+import java.io.Serializable;
+
+
+/**
+ * 租客表
+ *
+ * @author generator generator@elink-cn.com
+ * @since v1.0.0 2022-07-26
+ */
+@Data
+public class VisitVisitorFormDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 姓名
+     */
+    @NotBlank(message = "姓名不能为空",groups = {AddGroup.class, DefaultGroup.class})
+	private String name;
+
+    /**
+     * 身份证
+     */
+    @NotBlank(message = "身份证号不能为空",groups = {AddGroup.class, DefaultGroup.class})
+	private String idCard;
+
+    /**
+     * 手机号
+     */
+    @NotBlank(message = "联系方式不能为空",groups = {AddGroup.class, DefaultGroup.class})
+	private String mobile;
+
+    /**
+     * 头像
+     */
+	private String faceImg;
+
+    /**
+     * 节点
+     */
+    private String node;
+
+
+}

epmet-user/epmet-user-client/src/main/java/com/epmet/dto/result/DhChannelResultDTO.java

@@ -0,0 +1,23 @@
+package com.epmet.dto.result;
+
+import lombok.Data;
+
+import java.io.Serializable;
+
+
+/**
+ * 海康社区人员信息下放
+ *
+ * @author generator generator@elink-cn.com
+ * @since v1.0.0 2022-05-20
+ */
+@Data
+public class DhChannelResultDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private String privilegeType;
+
+    private String resouceCode;
+
+}

epmet-user/epmet-user-server/src/main/java/com/epmet/service/impl/IcResiCollectServiceImpl.java

@@ -31,6 +31,7 @@ import com.epmet.feign.GovOrgFeignClient;
 import com.epmet.feign.GovOrgOpenFeignClient;
 import com.epmet.service.IcResiCollectService;
 import com.epmet.service.IcUserChangeRecordService;
+import com.epmet.util.dh.DhDeviceUtil;
 import com.github.pagehelper.PageHelper;
 import com.github.pagehelper.PageInfo;
 import org.apache.commons.collections4.CollectionUtils;
@@ -71,6 +72,8 @@ public class IcResiCollectServiceImpl extends BaseServiceImpl<IcResiCollectDao,
 
     @Autowired
     private IcUserChangeRecordService icUserChangeRecordService;
+    @Autowired
+    private DhDeviceUtil dhDeviceUtil;
 
     @Override
     @Transactional(rollbackFor = Exception.class)
@@ -183,6 +186,19 @@ public class IcResiCollectServiceImpl extends BaseServiceImpl<IcResiCollectDao,
             Map<String, IcResiMemberEntity> memMap = queryOriginMem(collectInfo.getId());
             saveOrUpdateMem(newMemberList, memMap,collectInfo);
         }
+
+        // 如果是顺德居小区的人还要下放门禁
+        if (formDTO.getVillageName().contains("顺德居")) {
+            formDTO.getMemberList().forEach(item->{
+                VisitVisitorFormDTO visitor = new VisitVisitorFormDTO();
+                visitor.setIdCard(item.getIdNum());
+                visitor.setMobile(item.getMobile());
+                visitor.setName(item.getName());
+                visitor.setFaceImg(item.getFaceImg());
+                dhDeviceUtil.sendAuth(visitor);
+            });
+        }
+
         return new Result().ok("提交成功");
     }
 

epmet-user/epmet-user-server/src/main/java/com/epmet/service/impl/IcResiCollectVisitorServiceImpl.java

@@ -17,10 +17,12 @@ import com.epmet.dto.SaveCollectVisitorFormDTO;
 import com.epmet.dto.form.CollectDetailFormDTO;
 import com.epmet.dto.form.CollectListFormDTO;
 import com.epmet.dto.form.VisitListFormDTO;
+import com.epmet.dto.form.VisitVisitorFormDTO;
 import com.epmet.dto.result.CollectListResultDTO;
 import com.epmet.entity.IcResiCollectVisitorEntity;
 import com.epmet.redis.IcResiCollectVisitorRedis;
 import com.epmet.service.IcResiCollectVisitorService;
+import com.epmet.util.dh.DhDeviceUtil;
 import com.github.pagehelper.PageHelper;
 import com.github.pagehelper.PageInfo;
 import org.apache.commons.lang3.StringUtils;
@@ -48,6 +50,9 @@ public class IcResiCollectVisitorServiceImpl extends BaseServiceImpl<IcResiColle
     @Autowired
     private IcResiCollectServiceImpl icResiCollectServiceImpl;
 
+    @Autowired
+    private DhDeviceUtil dhDeviceUtil;
+
     @Override
     public PageData<IcResiCollectVisitorDTO> page(Map<String, Object> params) {
         IPage<IcResiCollectVisitorEntity> page = baseDao.selectPage(
@@ -146,6 +151,15 @@ public class IcResiCollectVisitorServiceImpl extends BaseServiceImpl<IcResiColle
         entity.setPids(neighborHoodDTO.getAgencyPids());
         entity.setCustomerId(neighborHoodDTO.getCustomerId());
         insert(entity);
+
+        // 如果是顺德居小区的人还要下放门禁
+        if (dto.getVillageName().contains("顺德居")) {
+            VisitVisitorFormDTO visitor = new VisitVisitorFormDTO();
+            visitor.setMobile(dto.getMobile());
+            visitor.setName(dto.getName());
+            visitor.setFaceImg(dto.getFaceImg());
+            dhDeviceUtil.sendAuth(visitor);
+        }
         return new Result().ok("提交成功");
     }
 

epmet-user/epmet-user-server/src/main/java/com/epmet/util/dh/Base64Util.java

@@ -0,0 +1,768 @@
+package com.epmet.util.dh;
+
+
+import java.math.BigInteger;
+
+/**
+ * Provides Base64 encoding and decoding as defined by <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045</a>.
+ *
+ * <p>
+ * This class implements section <cite>6.8. Base64 Content-Transfer-Encoding</cite> from RFC 2045 <cite>Multipurpose
+ * Internet Mail Extensions (MIME) Part One: Format of Internet Message Bodies</cite> by Freed and Borenstein.
+ * </p>
+ * <p>
+ * The class can be parameterized in the following manner with various constructors:
+ * </p>
+ * <ul>
+ * <li>URL-safe mode: Default off.</li>
+ * <li>Line length: Default 76. Line length that aren't multiples of 4 will still essentially end up being multiples of
+ * 4 in the encoded data.
+ * <li>Line separator: Default is CRLF ("\r\n")</li>
+ * </ul>
+ * <p>
+ * The URL-safe parameter is only applied to encode operations. Decoding seamlessly handles both modes.
+ * </p>
+ * <p>
+ * Since this class operates directly on byte streams, and not character streams, it is hard-coded to only
+ * encode/decode character encodings which are compatible with the lower 127 ASCII chart (ISO-8859-1, Windows-1252,
+ * UTF-8, etc).
+ * </p>
+ * <p>
+ * This class is thread-safe.
+ * </p>
+ *
+ * @see <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045</a>
+ * @since 1.0
+ * @version $Id: Base64.java 1635986 2014-11-01 16:27:52Z tn $
+ */
+public class Base64Util extends BaseNCodec {
+
+    /**
+     * BASE32 characters are 6 bits in length.
+     * They are formed by taking a block of 3 octets to form a 24-bit string,
+     * which is converted into 4 BASE64 characters.
+     */
+    private static final int BITS_PER_ENCODED_BYTE = 6;
+    private static final int BYTES_PER_UNENCODED_BLOCK = 3;
+    private static final int BYTES_PER_ENCODED_BLOCK = 4;
+
+    /**
+     * Chunk separator per RFC 2045 section 2.1.
+     *
+     * <p>
+     * N.B. The next major release may break compatibility and make this field private.
+     * </p>
+     *
+     * @see <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045 section 2.1</a>
+     */
+    static final byte[] CHUNK_SEPARATOR = {'\r', '\n'};
+
+    /**
+     * This array is a lookup table that translates 6-bit positive integer index values into their "Base64 Alphabet"
+     * equivalents as specified in Table 1 of RFC 2045.
+     *
+     * Thanks to "commons" project in ws.apache.org for this code.
+     * http://svn.apache.org/repos/asf/webservices/commons/trunk/modules/util/
+     */
+    private static final byte[] STANDARD_ENCODE_TABLE = {
+            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+            'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+            'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+            'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
+    };
+
+    /**
+     * This is a copy of the STANDARD_ENCODE_TABLE above, but with + and /
+     * changed to - and _ to make the encoded Base64 results more URL-SAFE.
+     * This table is only used when the Base64's mode is set to URL-SAFE.
+     */
+    private static final byte[] URL_SAFE_ENCODE_TABLE = {
+            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+            'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+            'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+            'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_'
+    };
+
+    /**
+     * This array is a lookup table that translates Unicode characters drawn from the "Base64 Alphabet" (as specified
+     * in Table 1 of RFC 2045) into their 6-bit positive integer equivalents. Characters that are not in the Base64
+     * alphabet but fall within the bounds of the array are translated to -1.
+     *
+     * Note: '+' and '-' both decode to 62. '/' and '_' both decode to 63. This means decoder seamlessly handles both
+     * URL_SAFE and STANDARD base64. (The encoder, on the other hand, needs to know ahead of time what to emit).
+     *
+     * Thanks to "commons" project in ws.apache.org for this code.
+     * http://svn.apache.org/repos/asf/webservices/commons/trunk/modules/util/
+     */
+    private static final byte[] DECODE_TABLE = {
+            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+            -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, 62, -1, 63, 52, 53, 54,
+            55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4,
+            5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
+            24, 25, -1, -1, -1, -1, 63, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34,
+            35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51
+    };
+
+    /**
+     * Base64 uses 6-bit fields.
+     */
+    /** Mask used to extract 6 bits, used when encoding */
+    private static final int MASK_6BITS = 0x3f;
+
+    // The static final fields above are used for the original static byte[] methods on Base64.
+    // The private member fields below are used with the new streaming approach, which requires
+    // some state be preserved between calls of encode() and decode().
+
+    /**
+     * Encode table to use: either STANDARD or URL_SAFE. Note: the DECODE_TABLE above remains static because it is able
+     * to decode both STANDARD and URL_SAFE streams, but the encodeTable must be a member variable so we can switch
+     * between the two modes.
+     */
+    private final byte[] encodeTable;
+
+    // Only one decode table currently; keep for consistency with Base32 code
+    private final byte[] decodeTable = DECODE_TABLE;
+
+    /**
+     * Line separator for encoding. Not used when decoding. Only used if lineLength &gt; 0.
+     */
+    private final byte[] lineSeparator;
+
+    /**
+     * Convenience variable to help us determine when our buffer is going to run out of room and needs resizing.
+     * <code>decodeSize = 3 + lineSeparator.length;</code>
+     */
+    private final int decodeSize;
+
+    /**
+     * Convenience variable to help us determine when our buffer is going to run out of room and needs resizing.
+     * <code>encodeSize = 4 + lineSeparator.length;</code>
+     */
+    private final int encodeSize;
+
+    /**
+     * Creates a Base64 codec used for decoding (all modes) and encoding in URL-unsafe mode.
+     * <p>
+     * When encoding the line length is 0 (no chunking), and the encoding table is STANDARD_ENCODE_TABLE.
+     * </p>
+     *
+     * <p>
+     * When decoding all variants are supported.
+     * </p>
+     */
+    public Base64Util() {
+        this(0);
+    }
+
+    /**
+     * Creates a Base64 codec used for decoding (all modes) and encoding in the given URL-safe mode.
+     * <p>
+     * When encoding the line length is 76, the line separator is CRLF, and the encoding table is STANDARD_ENCODE_TABLE.
+     * </p>
+     *
+     * <p>
+     * When decoding all variants are supported.
+     * </p>
+     *
+     * @param urlSafe
+     *            if <code>true</code>, URL-safe encoding is used. In most cases this should be set to
+     *            <code>false</code>.
+     * @since 1.4
+     */
+    public Base64Util(final boolean urlSafe) {
+        this(MIME_CHUNK_SIZE, CHUNK_SEPARATOR, urlSafe);
+    }
+
+    /**
+     * Creates a Base64 codec used for decoding (all modes) and encoding in URL-unsafe mode.
+     * <p>
+     * When encoding the line length is given in the constructor, the line separator is CRLF, and the encoding table is
+     * STANDARD_ENCODE_TABLE.
+     * </p>
+     * <p>
+     * Line lengths that aren't multiples of 4 will still essentially end up being multiples of 4 in the encoded data.
+     * </p>
+     * <p>
+     * When decoding all variants are supported.
+     * </p>
+     *
+     * @param lineLength
+     *            Each line of encoded data will be at most of the given length (rounded down to nearest multiple of
+     *            4). If lineLength &lt;= 0, then the output will not be divided into lines (chunks). Ignored when
+     *            decoding.
+     * @since 1.4
+     */
+    public Base64Util(final int lineLength) {
+        this(lineLength, CHUNK_SEPARATOR);
+    }
+
+    /**
+     * Creates a Base64 codec used for decoding (all modes) and encoding in URL-unsafe mode.
+     * <p>
+     * When encoding the line length and line separator are given in the constructor, and the encoding table is
+     * STANDARD_ENCODE_TABLE.
+     * </p>
+     * <p>
+     * Line lengths that aren't multiples of 4 will still essentially end up being multiples of 4 in the encoded data.
+     * </p>
+     * <p>
+     * When decoding all variants are supported.
+     * </p>
+     *
+     * @param lineLength
+     *            Each line of encoded data will be at most of the given length (rounded down to nearest multiple of
+     *            4). If lineLength &lt;= 0, then the output will not be divided into lines (chunks). Ignored when
+     *            decoding.
+     * @param lineSeparator
+     *            Each line of encoded data will end with this sequence of bytes.
+     * @throws IllegalArgumentException
+     *             Thrown when the provided lineSeparator included some base64 characters.
+     * @since 1.4
+     */
+    public Base64Util(final int lineLength, final byte[] lineSeparator) {
+        this(lineLength, lineSeparator, false);
+    }
+
+    /**
+     * Creates a Base64 codec used for decoding (all modes) and encoding in URL-unsafe mode.
+     * <p>
+     * When encoding the line length and line separator are given in the constructor, and the encoding table is
+     * STANDARD_ENCODE_TABLE.
+     * </p>
+     * <p>
+     * Line lengths that aren't multiples of 4 will still essentially end up being multiples of 4 in the encoded data.
+     * </p>
+     * <p>
+     * When decoding all variants are supported.
+     * </p>
+     *
+     * @param lineLength
+     *            Each line of encoded data will be at most of the given length (rounded down to nearest multiple of
+     *            4). If lineLength &lt;= 0, then the output will not be divided into lines (chunks). Ignored when
+     *            decoding.
+     * @param lineSeparator
+     *            Each line of encoded data will end with this sequence of bytes.
+     * @param urlSafe
+     *            Instead of emitting '+' and '/' we emit '-' and '_' respectively. urlSafe is only applied to encode
+     *            operations. Decoding seamlessly handles both modes.
+     *            <b>Note: no padding is added when using the URL-safe alphabet.</b>
+     * @throws IllegalArgumentException
+     *             The provided lineSeparator included some base64 characters. That's not going to work!
+     * @since 1.4
+     */
+    public Base64Util(final int lineLength, final byte[] lineSeparator, final boolean urlSafe) {
+        super(BYTES_PER_UNENCODED_BLOCK, BYTES_PER_ENCODED_BLOCK,
+                lineLength,
+                lineSeparator == null ? 0 : lineSeparator.length);
+        // TODO could be simplified if there is no requirement to reject invalid line sep when length <=0
+        // @see test case Base64Test.testConstructors()
+        if (lineSeparator != null) {
+            if (containsAlphabetOrPad(lineSeparator)) {
+                final String sep = newStringUtf8(lineSeparator);
+                throw new IllegalArgumentException("lineSeparator must not contain base64 characters: [" + sep + "]");
+            }
+            if (lineLength > 0){ // null line-sep forces no chunking rather than throwing IAE
+                this.encodeSize = BYTES_PER_ENCODED_BLOCK + lineSeparator.length;
+                this.lineSeparator = new byte[lineSeparator.length];
+                System.arraycopy(lineSeparator, 0, this.lineSeparator, 0, lineSeparator.length);
+            } else {
+                this.encodeSize = BYTES_PER_ENCODED_BLOCK;
+                this.lineSeparator = null;
+            }
+        } else {
+            this.encodeSize = BYTES_PER_ENCODED_BLOCK;
+            this.lineSeparator = null;
+        }
+        this.decodeSize = this.encodeSize - 1;
+        this.encodeTable = urlSafe ? URL_SAFE_ENCODE_TABLE : STANDARD_ENCODE_TABLE;
+    }
+
+    /**
+     * Returns our current encode mode. True if we're URL-SAFE, false otherwise.
+     *
+     * @return true if we're in URL-SAFE mode, false otherwise.
+     * @since 1.4
+     */
+    public boolean isUrlSafe() {
+        return this.encodeTable == URL_SAFE_ENCODE_TABLE;
+    }
+
+    /**
+     * <p>
+     * Encodes all of the provided data, starting at inPos, for inAvail bytes. Must be called at least twice: once with
+     * the data to encode, and once with inAvail set to "-1" to alert encoder that EOF has been reached, to flush last
+     * remaining bytes (if not multiple of 3).
+     * </p>
+     * <p><b>Note: no padding is added when encoding using the URL-safe alphabet.</b></p>
+     * <p>
+     * Thanks to "commons" project in ws.apache.org for the bitwise operations, and general approach.
+     * http://svn.apache.org/repos/asf/webservices/commons/trunk/modules/util/
+     * </p>
+     *
+     * @param in
+     *            byte[] array of binary data to base64 encode.
+     * @param inPos
+     *            Position to start reading data from.
+     * @param inAvail
+     *            Amount of bytes available from input for encoding.
+     * @param context
+     *            the context to be used
+     */
+    @Override
+    void encode(final byte[] in, int inPos, final int inAvail, final Context context) {
+        if (context.eof) {
+            return;
+        }
+        // inAvail < 0 is how we're informed of EOF in the underlying data we're
+        // encoding.
+        if (inAvail < 0) {
+            context.eof = true;
+            if (0 == context.modulus && lineLength == 0) {
+                return; // no leftovers to process and not using chunking
+            }
+            final byte[] buffer = ensureBufferSize(encodeSize, context);
+            final int savedPos = context.pos;
+            switch (context.modulus) { // 0-2
+                case 0 : // nothing to do here
+                    break;
+                case 1 : // 8 bits = 6 + 2
+                    // top 6 bits:
+                    buffer[context.pos++] = encodeTable[(context.ibitWorkArea >> 2) & MASK_6BITS];
+                    // remaining 2:
+                    buffer[context.pos++] = encodeTable[(context.ibitWorkArea << 4) & MASK_6BITS];
+                    // URL-SAFE skips the padding to further reduce size.
+                    if (encodeTable == STANDARD_ENCODE_TABLE) {
+                        buffer[context.pos++] = pad;
+                        buffer[context.pos++] = pad;
+                    }
+                    break;
+
+                case 2 : // 16 bits = 6 + 6 + 4
+                    buffer[context.pos++] = encodeTable[(context.ibitWorkArea >> 10) & MASK_6BITS];
+                    buffer[context.pos++] = encodeTable[(context.ibitWorkArea >> 4) & MASK_6BITS];
+                    buffer[context.pos++] = encodeTable[(context.ibitWorkArea << 2) & MASK_6BITS];
+                    // URL-SAFE skips the padding to further reduce size.
+                    if (encodeTable == STANDARD_ENCODE_TABLE) {
+                        buffer[context.pos++] = pad;
+                    }
+                    break;
+                default:
+                    throw new IllegalStateException("Impossible modulus "+context.modulus);
+            }
+            context.currentLinePos += context.pos - savedPos; // keep track of current line position
+            // if currentPos == 0 we are at the start of a line, so don't add CRLF
+            if (lineLength > 0 && context.currentLinePos > 0) {
+                System.arraycopy(lineSeparator, 0, buffer, context.pos, lineSeparator.length);
+                context.pos += lineSeparator.length;
+            }
+        } else {
+            for (int i = 0; i < inAvail; i++) {
+                final byte[] buffer = ensureBufferSize(encodeSize, context);
+                context.modulus = (context.modulus+1) % BYTES_PER_UNENCODED_BLOCK;
+                int b = in[inPos++];
+                if (b < 0) {
+                    b += 256;
+                }
+                context.ibitWorkArea = (context.ibitWorkArea << 8) + b; //  BITS_PER_BYTE
+                if (0 == context.modulus) { // 3 bytes = 24 bits = 4 * 6 bits to extract
+                    buffer[context.pos++] = encodeTable[(context.ibitWorkArea >> 18) & MASK_6BITS];
+                    buffer[context.pos++] = encodeTable[(context.ibitWorkArea >> 12) & MASK_6BITS];
+                    buffer[context.pos++] = encodeTable[(context.ibitWorkArea >> 6) & MASK_6BITS];
+                    buffer[context.pos++] = encodeTable[context.ibitWorkArea & MASK_6BITS];
+                    context.currentLinePos += BYTES_PER_ENCODED_BLOCK;
+                    if (lineLength > 0 && lineLength <= context.currentLinePos) {
+                        System.arraycopy(lineSeparator, 0, buffer, context.pos, lineSeparator.length);
+                        context.pos += lineSeparator.length;
+                        context.currentLinePos = 0;
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * <p>
+     * Decodes all of the provided data, starting at inPos, for inAvail bytes. Should be called at least twice: once
+     * with the data to decode, and once with inAvail set to "-1" to alert decoder that EOF has been reached. The "-1"
+     * call is not necessary when decoding, but it doesn't hurt, either.
+     * </p>
+     * <p>
+     * Ignores all non-base64 characters. This is how chunked (e.g. 76 character) data is handled, since CR and LF are
+     * silently ignored, but has implications for other bytes, too. This method subscribes to the garbage-in,
+     * garbage-out philosophy: it will not check the provided data for validity.
+     * </p>
+     * <p>
+     * Thanks to "commons" project in ws.apache.org for the bitwise operations, and general approach.
+     * http://svn.apache.org/repos/asf/webservices/commons/trunk/modules/util/
+     * </p>
+     *
+     * @param in
+     *            byte[] array of ascii data to base64 decode.
+     * @param inPos
+     *            Position to start reading data from.
+     * @param inAvail
+     *            Amount of bytes available from input for encoding.
+     * @param context
+     *            the context to be used
+     */
+    @Override
+    void decode(final byte[] in, int inPos, final int inAvail, final Context context) {
+        if (context.eof) {
+            return;
+        }
+        if (inAvail < 0) {
+            context.eof = true;
+        }
+        for (int i = 0; i < inAvail; i++) {
+            final byte[] buffer = ensureBufferSize(decodeSize, context);
+            final byte b = in[inPos++];
+            if (b == pad) {
+                // We're done.
+                context.eof = true;
+                break;
+            } else {
+                if (b >= 0 && b < DECODE_TABLE.length) {
+                    final int result = DECODE_TABLE[b];
+                    if (result >= 0) {
+                        context.modulus = (context.modulus+1) % BYTES_PER_ENCODED_BLOCK;
+                        context.ibitWorkArea = (context.ibitWorkArea << BITS_PER_ENCODED_BYTE) + result;
+                        if (context.modulus == 0) {
+                            buffer[context.pos++] = (byte) ((context.ibitWorkArea >> 16) & MASK_8BITS);
+                            buffer[context.pos++] = (byte) ((context.ibitWorkArea >> 8) & MASK_8BITS);
+                            buffer[context.pos++] = (byte) (context.ibitWorkArea & MASK_8BITS);
+                        }
+                    }
+                }
+            }
+        }
+
+        // Two forms of EOF as far as base64 decoder is concerned: actual
+        // EOF (-1) and first time '=' character is encountered in stream.
+        // This approach makes the '=' padding characters completely optional.
+        if (context.eof && context.modulus != 0) {
+            final byte[] buffer = ensureBufferSize(decodeSize, context);
+
+            // We have some spare bits remaining
+            // Output all whole multiples of 8 bits and ignore the rest
+            switch (context.modulus) {
+//              case 0 : // impossible, as excluded above
+                case 1 : // 6 bits - ignore entirely
+                    // TODO not currently tested; perhaps it is impossible?
+                    break;
+                case 2 : // 12 bits = 8 + 4
+                    context.ibitWorkArea = context.ibitWorkArea >> 4; // dump the extra 4 bits
+                    buffer[context.pos++] = (byte) ((context.ibitWorkArea) & MASK_8BITS);
+                    break;
+                case 3 : // 18 bits = 8 + 8 + 2
+                    context.ibitWorkArea = context.ibitWorkArea >> 2; // dump 2 bits
+                    buffer[context.pos++] = (byte) ((context.ibitWorkArea >> 8) & MASK_8BITS);
+                    buffer[context.pos++] = (byte) ((context.ibitWorkArea) & MASK_8BITS);
+                    break;
+                default:
+                    throw new IllegalStateException("Impossible modulus "+context.modulus);
+            }
+        }
+    }
+
+    /**
+     * Tests a given byte array to see if it contains only valid characters within the Base64 alphabet. Currently the
+     * method treats whitespace as valid.
+     *
+     * @param arrayOctet
+     *            byte array to test
+     * @return <code>true</code> if all bytes are valid characters in the Base64 alphabet or if the byte array is empty;
+     *         <code>false</code>, otherwise
+     * @deprecated 1.5 Use {@link #isBase64(byte[])}, will be removed in 2.0.
+     */
+    @Deprecated
+    public static boolean isArrayByteBase64(final byte[] arrayOctet) {
+        return isBase64(arrayOctet);
+    }
+
+    /**
+     * Returns whether or not the <code>octet</code> is in the base 64 alphabet.
+     *
+     * @param octet
+     *            The value to test
+     * @return <code>true</code> if the value is defined in the the base 64 alphabet, <code>false</code> otherwise.
+     * @since 1.4
+     */
+    public static boolean isBase64(final byte octet) {
+        return octet == PAD_DEFAULT || (octet >= 0 && octet < DECODE_TABLE.length && DECODE_TABLE[octet] != -1);
+    }
+
+    /**
+     * Tests a given String to see if it contains only valid characters within the Base64 alphabet. Currently the
+     * method treats whitespace as valid.
+     *
+     * @param base64
+     *            String to test
+     * @return <code>true</code> if all characters in the String are valid characters in the Base64 alphabet or if
+     *         the String is empty; <code>false</code>, otherwise
+     *  @since 1.5
+     */
+    public static boolean isBase64(final String base64) {
+        return isBase64(getBytesUtf8(base64));
+    }
+
+    /**
+     * Tests a given byte array to see if it contains only valid characters within the Base64 alphabet. Currently the
+     * method treats whitespace as valid.
+     *
+     * @param arrayOctet
+     *            byte array to test
+     * @return <code>true</code> if all bytes are valid characters in the Base64 alphabet or if the byte array is empty;
+     *         <code>false</code>, otherwise
+     * @since 1.5
+     */
+    public static boolean isBase64(final byte[] arrayOctet) {
+        for (int i = 0; i < arrayOctet.length; i++) {
+            if (!isBase64(arrayOctet[i]) && !isWhiteSpace(arrayOctet[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Encodes binary data using the base64 algorithm but does not chunk the output.
+     *
+     * @param binaryData
+     *            binary data to encode
+     * @return byte[] containing Base64 characters in their UTF-8 representation.
+     */
+    public static byte[] encodeBase64(final byte[] binaryData) {
+        return encodeBase64(binaryData, false);
+    }
+
+    /**
+     * Encodes binary data using the base64 algorithm but does not chunk the output.
+     *
+     * NOTE:  We changed the behaviour of this method from multi-line chunking (commons-codec-1.4) to
+     * single-line non-chunking (commons-codec-1.5).
+     *
+     * @param binaryData
+     *            binary data to encode
+     * @return String containing Base64 characters.
+     * @since 1.4 (NOTE:  1.4 chunked the output, whereas 1.5 does not).
+     */
+    public static String encodeBase64String(final byte[] binaryData) {
+        return newStringUtf8(encodeBase64(binaryData, false));
+    }
+
+    /**
+     * Encodes binary data using a URL-safe variation of the base64 algorithm but does not chunk the output. The
+     * url-safe variation emits - and _ instead of + and / characters.
+     * <b>Note: no padding is added.</b>
+     * @param binaryData
+     *            binary data to encode
+     * @return byte[] containing Base64 characters in their UTF-8 representation.
+     * @since 1.4
+     */
+    public static byte[] encodeBase64URLSafe(final byte[] binaryData) {
+        return encodeBase64(binaryData, false, true);
+    }
+
+    /**
+     * Encodes binary data using a URL-safe variation of the base64 algorithm but does not chunk the output. The
+     * url-safe variation emits - and _ instead of + and / characters.
+     * <b>Note: no padding is added.</b>
+     * @param binaryData
+     *            binary data to encode
+     * @return String containing Base64 characters
+     * @since 1.4
+     */
+    public static String encodeBase64URLSafeString(final byte[] binaryData) {
+        return newStringUtf8(encodeBase64(binaryData, false, true));
+    }
+
+    /**
+     * Encodes binary data using the base64 algorithm and chunks the encoded output into 76 character blocks
+     *
+     * @param binaryData
+     *            binary data to encode
+     * @return Base64 characters chunked in 76 character blocks
+     */
+    public static byte[] encodeBase64Chunked(final byte[] binaryData) {
+        return encodeBase64(binaryData, true);
+    }
+
+    /**
+     * Encodes binary data using the base64 algorithm, optionally chunking the output into 76 character blocks.
+     *
+     * @param binaryData
+     *            Array containing binary data to encode.
+     * @param isChunked
+     *            if <code>true</code> this encoder will chunk the base64 output into 76 character blocks
+     * @return Base64-encoded data.
+     * @throws IllegalArgumentException
+     *             Thrown when the input array needs an output array bigger than {@link Integer#MAX_VALUE}
+     */
+    public static byte[] encodeBase64(final byte[] binaryData, final boolean isChunked) {
+        return encodeBase64(binaryData, isChunked, false);
+    }
+
+    /**
+     * Encodes binary data using the base64 algorithm, optionally chunking the output into 76 character blocks.
+     *
+     * @param binaryData
+     *            Array containing binary data to encode.
+     * @param isChunked
+     *            if <code>true</code> this encoder will chunk the base64 output into 76 character blocks
+     * @param urlSafe
+     *            if <code>true</code> this encoder will emit - and _ instead of the usual + and / characters.
+     *            <b>Note: no padding is added when encoding using the URL-safe alphabet.</b>
+     * @return Base64-encoded data.
+     * @throws IllegalArgumentException
+     *             Thrown when the input array needs an output array bigger than {@link Integer#MAX_VALUE}
+     * @since 1.4
+     */
+    public static byte[] encodeBase64(final byte[] binaryData, final boolean isChunked, final boolean urlSafe) {
+        return encodeBase64(binaryData, isChunked, urlSafe, Integer.MAX_VALUE);
+    }
+
+    /**
+     * Encodes binary data using the base64 algorithm, optionally chunking the output into 76 character blocks.
+     *
+     * @param binaryData
+     *            Array containing binary data to encode.
+     * @param isChunked
+     *            if <code>true</code> this encoder will chunk the base64 output into 76 character blocks
+     * @param urlSafe
+     *            if <code>true</code> this encoder will emit - and _ instead of the usual + and / characters.
+     *            <b>Note: no padding is added when encoding using the URL-safe alphabet.</b>
+     * @param maxResultSize
+     *            The maximum result size to accept.
+     * @return Base64-encoded data.
+     * @throws IllegalArgumentException
+     *             Thrown when the input array needs an output array bigger than maxResultSize
+     * @since 1.4
+     */
+    public static byte[] encodeBase64(final byte[] binaryData, final boolean isChunked,
+                                      final boolean urlSafe, final int maxResultSize) {
+        if (binaryData == null || binaryData.length == 0) {
+            return binaryData;
+        }
+
+        // Create this so can use the super-class method
+        // Also ensures that the same roundings are performed by the ctor and the code
+        final Base64Util b64 = isChunked ? new Base64Util(urlSafe) : new Base64Util(0, CHUNK_SEPARATOR, urlSafe);
+        final long len = b64.getEncodedLength(binaryData);
+        if (len > maxResultSize) {
+            throw new IllegalArgumentException("Input array too big, the output array would be bigger (" +
+                    len +
+                    ") than the specified maximum size of " +
+                    maxResultSize);
+        }
+
+        return b64.encode(binaryData);
+    }
+
+    /**
+     * Decodes a Base64 String into octets.
+     * <p>
+     * <b>Note:</b> this method seamlessly handles data encoded in URL-safe or normal mode.
+     * </p>
+     *
+     * @param base64String
+     *            String containing Base64 data
+     * @return Array containing decoded data.
+     * @since 1.4
+     */
+    public static byte[] decodeBase64(final String base64String) {
+        return new Base64Util().decode(base64String);
+    }
+
+    /**
+     * Decodes Base64 data into octets.
+     * <p>
+     * <b>Note:</b> this method seamlessly handles data encoded in URL-safe or normal mode.
+     * </p>
+     *
+     * @param base64Data
+     *            Byte array containing Base64 data
+     * @return Array containing decoded data.
+     */
+    public static byte[] decodeBase64(final byte[] base64Data) {
+        return new Base64Util().decode(base64Data);
+    }
+
+    // Implementation of the Encoder Interface
+
+    // Implementation of integer encoding used for crypto
+    /**
+     * Decodes a byte64-encoded integer according to crypto standards such as W3C's XML-Signature.
+     *
+     * @param pArray
+     *            a byte array containing base64 character data
+     * @return A BigInteger
+     * @since 1.4
+     */
+    public static BigInteger decodeInteger(final byte[] pArray) {
+        return new BigInteger(1, decodeBase64(pArray));
+    }
+
+    /**
+     * Encodes to a byte64-encoded integer according to crypto standards such as W3C's XML-Signature.
+     *
+     * @param bigInt
+     *            a BigInteger
+     * @return A byte array containing base64 character data
+     * @throws NullPointerException
+     *             if null is passed in
+     * @since 1.4
+     */
+    public static byte[] encodeInteger(final BigInteger bigInt) {
+        if (bigInt == null) {
+            throw new NullPointerException("encodeInteger called with null parameter");
+        }
+        return encodeBase64(toIntegerBytes(bigInt), false);
+    }
+
+    /**
+     * Returns a byte-array representation of a <code>BigInteger</code> without sign bit.
+     *
+     * @param bigInt
+     *            <code>BigInteger</code> to be converted
+     * @return a byte array representation of the BigInteger parameter
+     */
+    static byte[] toIntegerBytes(final BigInteger bigInt) {
+        int bitlen = bigInt.bitLength();
+        // round bitlen
+        bitlen = ((bitlen + 7) >> 3) << 3;
+        final byte[] bigBytes = bigInt.toByteArray();
+
+        if (((bigInt.bitLength() % 8) != 0) && (((bigInt.bitLength() / 8) + 1) == (bitlen / 8))) {
+            return bigBytes;
+        }
+        // set up params for copying everything but sign bit
+        int startSrc = 0;
+        int len = bigBytes.length;
+
+        // if bigInt is exactly byte-aligned, just skip signbit in copy
+        if ((bigInt.bitLength() % 8) == 0) {
+            startSrc = 1;
+            len--;
+        }
+        final int startDst = bitlen / 8 - len; // to pad w/ nulls as per spec
+        final byte[] resizedBytes = new byte[bitlen / 8];
+        System.arraycopy(bigBytes, startSrc, resizedBytes, startDst, len);
+        return resizedBytes;
+    }
+
+    /**
+     * Returns whether or not the <code>octet</code> is in the Base64 alphabet.
+     *
+     * @param octet
+     *            The value to test
+     * @return <code>true</code> if the value is defined in the the Base64 alphabet <code>false</code> otherwise.
+     */
+    @Override
+    protected boolean isInAlphabet(final byte octet) {
+        return octet >= 0 && octet < decodeTable.length && decodeTable[octet] != -1;
+    }
+
+}

epmet-user/epmet-user-server/src/main/java/com/epmet/util/dh/BaseNCodec.java

@@ -0,0 +1,521 @@
+package com.epmet.util.dh;
+
+
+import java.nio.charset.Charset;
+import java.util.Arrays;
+
+/**
+ * Abstract superclass for Base-N encoders and decoders.
+ *
+ * <p>
+ * This class is thread-safe.
+ * </p>
+ *
+ * @version $Id: BaseNCodec.java 1634404 2014-10-26 23:06:10Z ggregory $
+ */
+public abstract class BaseNCodec {
+
+    /**
+     * Holds thread context so classes can be thread-safe.
+     *
+     * This class is not itself thread-safe; each thread must allocate its own copy.
+     *
+     * @since 1.7
+     */
+    static class Context {
+
+        /**
+         * Place holder for the bytes we're dealing with for our based logic.
+         * Bitwise operations store and extract the encoding or decoding from this variable.
+         */
+        int ibitWorkArea;
+
+        /**
+         * Place holder for the bytes we're dealing with for our based logic.
+         * Bitwise operations store and extract the encoding or decoding from this variable.
+         */
+        long lbitWorkArea;
+
+        /**
+         * Buffer for streaming.
+         */
+        byte[] buffer;
+
+        /**
+         * Position where next character should be written in the buffer.
+         */
+        int pos;
+
+        /**
+         * Position where next character should be read from the buffer.
+         */
+        int readPos;
+
+        /**
+         * Boolean flag to indicate the EOF has been reached. Once EOF has been reached, this object becomes useless,
+         * and must be thrown away.
+         */
+        boolean eof;
+
+        /**
+         * Variable tracks how many characters have been written to the current line. Only used when encoding. We use
+         * it to make sure each encoded line never goes beyond lineLength (if lineLength &gt; 0).
+         */
+        int currentLinePos;
+
+        /**
+         * Writes to the buffer only occur after every 3/5 reads when encoding, and every 4/8 reads when decoding. This
+         * variable helps track that.
+         */
+        int modulus;
+
+        Context() {
+        }
+
+        /**
+         * Returns a String useful for debugging (especially within a debugger.)
+         *
+         * @return a String useful for debugging.
+         */
+        @SuppressWarnings("boxing") // OK to ignore boxing here
+        public String toString() {
+            return String.format("%s[buffer=%s, currentLinePos=%s, eof=%s, ibitWorkArea=%s, lbitWorkArea=%s, " +
+                    "modulus=%s, pos=%s, readPos=%s]", this.getClass().getSimpleName(), Arrays.toString(buffer),
+                    currentLinePos, eof, ibitWorkArea, lbitWorkArea, modulus, pos, readPos);
+        }
+    }
+
+    /**
+     * EOF
+     *
+     * @since 1.7
+     */
+    static final int EOF = -1;
+
+    /**
+     *  MIME chunk size per RFC 2045 section 6.8.
+     *
+     * <p>
+     * The {@value} character limit does not count the trailing CRLF, but counts all other characters, including any
+     * equal signs.
+     * </p>
+     *
+     * @see <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045 section 6.8</a>
+     */
+    public static final int MIME_CHUNK_SIZE = 76;
+
+    /**
+     * PEM chunk size per RFC 1421 section 4.3.2.4.
+     *
+     * <p>
+     * The {@value} character limit does not count the trailing CRLF, but counts all other characters, including any
+     * equal signs.
+     * </p>
+     *
+     * @see <a href="http://tools.ietf.org/html/rfc1421">RFC 1421 section 4.3.2.4</a>
+     */
+    public static final int PEM_CHUNK_SIZE = 64;
+
+    private static final int DEFAULT_BUFFER_RESIZE_FACTOR = 2;
+
+    /**
+     * Defines the default buffer size - currently {@value}
+     * - must be large enough for at least one encoded block+separator
+     */
+    private static final int DEFAULT_BUFFER_SIZE = 8192;
+
+    /** Mask used to extract 8 bits, used in decoding bytes */
+    protected static final int MASK_8BITS = 0xff;
+
+    /**
+     * Byte used to pad output.
+     */
+    protected static final byte PAD_DEFAULT = '='; // Allow static access to default
+
+    /**
+     * @deprecated Use {@link #pad}. Will be removed in 2.0.
+     */
+    @Deprecated
+    protected final byte PAD = PAD_DEFAULT; // instance variable just in case it needs to vary later
+
+    protected final byte pad; // instance variable just in case it needs to vary later
+
+    /** Number of bytes in each full block of unencoded data, e.g. 4 for Base64 and 5 for Base32 */
+    private final int unencodedBlockSize;
+
+    /** Number of bytes in each full block of encoded data, e.g. 3 for Base64 and 8 for Base32 */
+    private final int encodedBlockSize;
+
+    /**
+     * Chunksize for encoding. Not used when decoding.
+     * A value of zero or less implies no chunking of the encoded data.
+     * Rounded down to nearest multiple of encodedBlockSize.
+     */
+    protected final int lineLength;
+
+    /**
+     * Size of chunk separator. Not used unless {@link #lineLength} &gt; 0.
+     */
+    private final int chunkSeparatorLength;
+
+    /**
+     * Note <code>lineLength</code> is rounded down to the nearest multiple of {@link #encodedBlockSize}
+     * If <code>chunkSeparatorLength</code> is zero, then chunking is disabled.
+     * @param unencodedBlockSize the size of an unencoded block (e.g. Base64 = 3)
+     * @param encodedBlockSize the size of an encoded block (e.g. Base64 = 4)
+     * @param lineLength if &gt; 0, use chunking with a length <code>lineLength</code>
+     * @param chunkSeparatorLength the chunk separator length, if relevant
+     */
+    protected BaseNCodec(final int unencodedBlockSize, final int encodedBlockSize,
+                         final int lineLength, final int chunkSeparatorLength) {
+        this(unencodedBlockSize, encodedBlockSize, lineLength, chunkSeparatorLength, PAD_DEFAULT);
+    }
+
+    /**
+     * Note <code>lineLength</code> is rounded down to the nearest multiple of {@link #encodedBlockSize}
+     * If <code>chunkSeparatorLength</code> is zero, then chunking is disabled.
+     * @param unencodedBlockSize the size of an unencoded block (e.g. Base64 = 3)
+     * @param encodedBlockSize the size of an encoded block (e.g. Base64 = 4)
+     * @param lineLength if &gt; 0, use chunking with a length <code>lineLength</code>
+     * @param chunkSeparatorLength the chunk separator length, if relevant
+     * @param pad byte used as padding byte.
+     */
+    protected BaseNCodec(final int unencodedBlockSize, final int encodedBlockSize,
+                         final int lineLength, final int chunkSeparatorLength, final byte pad) {
+        this.unencodedBlockSize = unencodedBlockSize;
+        this.encodedBlockSize = encodedBlockSize;
+        final boolean useChunking = lineLength > 0 && chunkSeparatorLength > 0;
+        this.lineLength = useChunking ? (lineLength / encodedBlockSize) * encodedBlockSize : 0;
+        this.chunkSeparatorLength = chunkSeparatorLength;
+
+        this.pad = pad;
+    }
+
+    /**
+     * Returns true if this object has buffered data for reading.
+     *
+     * @param context the context to be used
+     * @return true if there is data still available for reading.
+     */
+    boolean hasData(final Context context) {  // package protected for access from I/O streams
+        return context.buffer != null;
+    }
+
+    /**
+     * Returns the amount of buffered data available for reading.
+     *
+     * @param context the context to be used
+     * @return The amount of buffered data available for reading.
+     */
+    int available(final Context context) {  // package protected for access from I/O streams
+        return context.buffer != null ? context.pos - context.readPos : 0;
+    }
+
+    /**
+     * Get the default buffer size. Can be overridden.
+     *
+     * @return {@link #DEFAULT_BUFFER_SIZE}
+     */
+    protected int getDefaultBufferSize() {
+        return DEFAULT_BUFFER_SIZE;
+    }
+
+    /**
+     * Increases our buffer by the {@link #DEFAULT_BUFFER_RESIZE_FACTOR}.
+     * @param context the context to be used
+     */
+    private byte[] resizeBuffer(final Context context) {
+        if (context.buffer == null) {
+            context.buffer = new byte[getDefaultBufferSize()];
+            context.pos = 0;
+            context.readPos = 0;
+        } else {
+            final byte[] b = new byte[context.buffer.length * DEFAULT_BUFFER_RESIZE_FACTOR];
+            System.arraycopy(context.buffer, 0, b, 0, context.buffer.length);
+            context.buffer = b;
+        }
+        return context.buffer;
+    }
+
+    /**
+     * Ensure that the buffer has room for <code>size</code> bytes
+     *
+     * @param size minimum spare space required
+     * @param context the context to be used
+     * @return the buffer
+     */
+    protected byte[] ensureBufferSize(final int size, final Context context){
+        if ((context.buffer == null) || (context.buffer.length < context.pos + size)){
+            return resizeBuffer(context);
+        }
+        return context.buffer;
+    }
+
+    /**
+     * Extracts buffered data into the provided byte[] array, starting at position bPos, up to a maximum of bAvail
+     * bytes. Returns how many bytes were actually extracted.
+     * <p>
+     * Package protected for access from I/O streams.
+     *
+     * @param b
+     *            byte[] array to extract the buffered data into.
+     * @param bPos
+     *            position in byte[] array to start extraction at.
+     * @param bAvail
+     *            amount of bytes we're allowed to extract. We may extract fewer (if fewer are available).
+     * @param context
+     *            the context to be used
+     * @return The number of bytes successfully extracted into the provided byte[] array.
+     */
+    int readResults(final byte[] b, final int bPos, final int bAvail, final Context context) {
+        if (context.buffer != null) {
+            final int len = Math.min(available(context), bAvail);
+            System.arraycopy(context.buffer, context.readPos, b, bPos, len);
+            context.readPos += len;
+            if (context.readPos >= context.pos) {
+                context.buffer = null; // so hasData() will return false, and this method can return -1
+            }
+            return len;
+        }
+        return context.eof ? EOF : 0;
+    }
+
+    /**
+     * Checks if a byte value is whitespace or not.
+     * Whitespace is taken to mean: space, tab, CR, LF
+     * @param byteToCheck
+     *            the byte to check
+     * @return true if byte is whitespace, false otherwise
+     */
+    protected static boolean isWhiteSpace(final byte byteToCheck) {
+        switch (byteToCheck) {
+            case ' ' :
+            case '\n' :
+            case '\r' :
+            case '\t' :
+                return true;
+            default :
+                return false;
+        }
+    }
+
+    /**
+     * Encodes an Object using the Base-N algorithm. This method is provided in order to satisfy the requirements of
+     * the Encoder interface, and will throw an EncoderException if the supplied object is not of type byte[].
+     *
+     * @param obj
+     *            Object to encode
+     * @return An object (of type byte[]) containing the Base-N encoded data which corresponds to the byte[] supplied.
+     * @throws Exception
+     *             if the parameter supplied is not of type byte[]
+     */
+    public Object encode(final Object obj) throws Exception {
+        if (!(obj instanceof byte[])) {
+            throw new Exception("Parameter supplied to Base-N encode is not a byte[]");
+        }
+        return encode((byte[]) obj);
+    }
+
+    /**
+     * Encodes a byte[] containing binary data, into a String containing characters in the Base-N alphabet.
+     * Uses UTF8 encoding.
+     *
+     * @param pArray
+     *            a byte array containing binary data
+     * @return A String containing only Base-N character data
+     */
+    public String encodeToString(final byte[] pArray) {
+        return newStringUtf8(encode(pArray));
+    }
+
+    /**
+     * Encodes a byte[] containing binary data, into a String containing characters in the appropriate alphabet.
+     * Uses UTF8 encoding.
+     *
+     * @param pArray a byte array containing binary data
+     * @return String containing only character data in the appropriate alphabet.
+    */
+    public String encodeAsString(final byte[] pArray){
+        return newStringUtf8(encode(pArray));
+    }
+
+    /**
+     * Decodes an Object using the Base-N algorithm. This method is provided in order to satisfy the requirements of
+     * the Decoder interface, and will throw a DecoderException if the supplied object is not of type byte[] or String.
+     *
+     * @param obj
+     *            Object to decode
+     * @return An object (of type byte[]) containing the binary data which corresponds to the byte[] or String
+     *         supplied.
+     * @throws Exception
+     *             if the parameter supplied is not of type byte[]
+     */
+    public Object decode(final Object obj) throws Exception {
+        if (obj instanceof byte[]) {
+            return decode((byte[]) obj);
+        } else if (obj instanceof String) {
+            return decode((String) obj);
+        } else {
+            throw new Exception("Parameter supplied to Base-N decode is not a byte[] or a String");
+        }
+    }
+
+    /**
+     * Decodes a String containing characters in the Base-N alphabet.
+     *
+     * @param pArray
+     *            A String containing Base-N character data
+     * @return a byte array containing binary data
+     */
+    public byte[] decode(final String pArray) {
+        return decode(getBytesUtf8(pArray));
+    }
+
+    /**
+     * Decodes a byte[] containing characters in the Base-N alphabet.
+     *
+     * @param pArray
+     *            A byte array containing Base-N character data
+     * @return a byte array containing binary data
+     */
+    public byte[] decode(final byte[] pArray) {
+        if (pArray == null || pArray.length == 0) {
+            return pArray;
+        }
+        final Context context = new Context();
+        decode(pArray, 0, pArray.length, context);
+        decode(pArray, 0, EOF, context); // Notify decoder of EOF.
+        final byte[] result = new byte[context.pos];
+        readResults(result, 0, result.length, context);
+        return result;
+    }
+
+    /**
+     * Encodes a byte[] containing binary data, into a byte[] containing characters in the alphabet.
+     *
+     * @param pArray
+     *            a byte array containing binary data
+     * @return A byte array containing only the basen alphabetic character data
+     */
+    public byte[] encode(final byte[] pArray) {
+        if (pArray == null || pArray.length == 0) {
+            return pArray;
+        }
+        final Context context = new Context();
+        encode(pArray, 0, pArray.length, context);
+        encode(pArray, 0, EOF, context); // Notify encoder of EOF.
+        final byte[] buf = new byte[context.pos - context.readPos];
+        readResults(buf, 0, buf.length, context);
+        return buf;
+    }
+
+    // package protected for access from I/O streams
+    abstract void encode(byte[] pArray, int i, int length, Context context);
+
+    // package protected for access from I/O streams
+    abstract void decode(byte[] pArray, int i, int length, Context context);
+
+    /**
+     * Returns whether or not the <code>octet</code> is in the current alphabet.
+     * Does not allow whitespace or pad.
+     *
+     * @param value The value to test
+     *
+     * @return <code>true</code> if the value is defined in the current alphabet, <code>false</code> otherwise.
+     */
+    protected abstract boolean isInAlphabet(byte value);
+
+    /**
+     * Tests a given byte array to see if it contains only valid characters within the alphabet.
+     * The method optionally treats whitespace and pad as valid.
+     *
+     * @param arrayOctet byte array to test
+     * @param allowWSPad if <code>true</code>, then whitespace and PAD are also allowed
+     *
+     * @return <code>true</code> if all bytes are valid characters in the alphabet or if the byte array is empty;
+     *         <code>false</code>, otherwise
+     */
+    public boolean isInAlphabet(final byte[] arrayOctet, final boolean allowWSPad) {
+        for (int i = 0; i < arrayOctet.length; i++) {
+            if (!isInAlphabet(arrayOctet[i]) &&
+                    (!allowWSPad || (arrayOctet[i] != pad) && !isWhiteSpace(arrayOctet[i]))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Tests a given String to see if it contains only valid characters within the alphabet.
+     * The method treats whitespace and PAD as valid.
+     *
+     * @param basen String to test
+     * @return <code>true</code> if all characters in the String are valid characters in the alphabet or if
+     *         the String is empty; <code>false</code>, otherwise
+     * @see #isInAlphabet(byte[], boolean)
+     */
+    public boolean isInAlphabet(final String basen) {
+        return isInAlphabet(getBytesUtf8(basen), true);
+    }
+
+    /**
+     * Tests a given byte array to see if it contains any characters within the alphabet or PAD.
+     *
+     * Intended for use in checking line-ending arrays
+     *
+     * @param arrayOctet
+     *            byte array to test
+     * @return <code>true</code> if any byte is a valid character in the alphabet or PAD; <code>false</code> otherwise
+     */
+    protected boolean containsAlphabetOrPad(final byte[] arrayOctet) {
+        if (arrayOctet == null) {
+            return false;
+        }
+        for (final byte element : arrayOctet) {
+            if (pad == element || isInAlphabet(element)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Calculates the amount of space needed to encode the supplied array.
+     *
+     * @param pArray byte[] array which will later be encoded
+     *
+     * @return amount of space needed to encoded the supplied array.
+     * Returns a long since a max-len array will require &gt; Integer.MAX_VALUE
+     */
+    public long getEncodedLength(final byte[] pArray) {
+        // Calculate non-chunked size - rounded up to allow for padding
+        // cast to long is needed to avoid possibility of overflow
+        long len = ((pArray.length + unencodedBlockSize-1)  / unencodedBlockSize) * (long) encodedBlockSize;
+        if (lineLength > 0) { // We're using chunking
+            // Round up to nearest multiple
+            len += ((len + lineLength-1) / lineLength) * chunkSeparatorLength;
+        }
+        return len;
+    }
+
+    public static Charset UTF8 = Charset.forName("UTF-8");
+
+    public static String newStringUtf8(byte[] bytes) {
+        return newString(bytes, UTF8);
+    }
+
+    private static String newString(final byte[] bytes, final Charset charset) {
+        return bytes == null ? null : new String(bytes, charset);
+    }
+
+    public static byte[] getBytesUtf8(final String string) {
+        return getBytes(string, UTF8);
+    }
+
+    private static byte[] getBytes(final String string, final Charset charset) {
+        if (string == null) {
+            return null;
+        }
+        return string.getBytes(charset);
+    }
+}

epmet-user/epmet-user-server/src/main/java/com/epmet/util/dh/DhCloudProperties.java

@@ -0,0 +1,60 @@
+package com.epmet.util.dh;
+
+import org.springframework.stereotype.Component;
+
+/**
+ * 海康设备参数
+ *
+ * @author zhy
+ * @date 2022/5/20 14:59
+ */
+@Component
+public class DhCloudProperties {
+
+    /**
+     * URL
+     */
+    private String url;
+
+    /**
+     * 账号
+     */
+    private String loginName;
+
+
+    /**
+     * 账号密码
+     */
+    private String loginPass;
+
+    public DhCloudProperties() {
+        url = "http://112.6.213.175:8314";
+        loginName = "shundeju";
+        loginPass = "hg123456";
+    }
+
+
+    public String getUrl() {
+        return url;
+    }
+
+    public void setUrl(String url) {
+        this.url = url;
+    }
+
+    public String getLoginName() {
+        return loginName;
+    }
+
+    public void setLoginName(String loginName) {
+        this.loginName = loginName;
+    }
+
+    public String getLoginPass() {
+        return loginPass;
+    }
+
+    public void setLoginPass(String loginPass) {
+        this.loginPass = loginPass;
+    }
+}

epmet-user/epmet-user-server/src/main/java/com/epmet/util/dh/DhDeviceUtil.java

@@ -0,0 +1,902 @@
+package com.epmet.util.dh;
+
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.epmet.commons.tools.exception.EpmetErrorCode;
+import com.epmet.commons.tools.exception.EpmetException;
+import com.epmet.commons.tools.exception.RenException;
+import com.epmet.commons.tools.redis.RedisKeys;
+import com.epmet.commons.tools.redis.RedisUtils;
+import com.epmet.commons.tools.utils.ConvertUtils;
+import com.epmet.commons.tools.utils.HttpClientManager;
+import com.epmet.dto.DhTokenDTO;
+import com.epmet.dto.form.*;
+import com.epmet.dto.result.DhChannelResultDTO;
+import net.coobird.thumbnailator.Thumbnails;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import javax.imageio.ImageIO;
+import javax.xml.bind.DatatypeConverter;
+import java.awt.image.BufferedImage;
+import java.io.*;
+import java.math.BigDecimal;
+import java.net.URL;
+import java.time.LocalDate;
+import java.util.*;
+
+/**
+ * 海康设备下放命令
+ *
+ * @author zhy
+ * @date 2022/5/20 9:36
+ */
+@Component
+public class DhDeviceUtil {
+    private static Logger logger = LoggerFactory.getLogger(DhDeviceUtil.class);
+
+    @Autowired
+    private DhCloudProperties dhCloudProperties;
+
+    @Autowired
+    private RedisUtils redisUtils;
+
+    private final String GET_PUBLIC_KEY = "/WPMS/getPublicKey";
+    private final String GET_LOGIN_PASS = "/WPMS/login";
+    private final String GET_DEPARTMENT = "/CardSolution/card/department";
+    private final String GET_NODE = "/CardSolution/resource/tree/nodeList";
+    private final String GET_CHANNEL = "/admin/rest/api";
+    private final String GET_PERSON_IDENTITY = "/CardSolution/card/person/personidentity";
+    private final String GET_DOOR_PLAN = "/CardSolution/card/accessControl/timeQuantum/1/page";
+    private final String GET_DOOR_CHANNEL = "/CardSolution/card/accessControl/channel/bycondition/combined";
+    private final String ADD_PERSON = "/CardSolution/card/person";
+    private final String LIST_PERSON = "/CardSolution/card/person/bycondition/combined";
+    private final String DEL_PERSON = "/CardSolution/card/person/delete";
+    private final String ADD_PERSON_IMG = "/CardSolution/common/saveMobileBase64ImageToByte";
+    private final String ADD_AUTH = "/CardSolution/card/accessControl/doorAuthority/update";
+    private final String LIST_CARD = "/CardSolution/card/card/bycondition/combined";
+    private final String DEL_CARD = "/CardSolution/card/card/returnByNumber/";
+    private final String OPEN_CARD = "/CardSolution/card/card/open/batch";
+
+
+    /**
+     * 主方法，准备下发开门权限
+     *
+     * @param dto
+     * @return void
+     * @author zhy
+     * @date 2022/8/17 15:24
+     */
+    public void sendAuth(VisitVisitorFormDTO dto) {
+        if (StringUtils.isBlank(dto.getIdCard())) {
+            dto.setIdCard(IDUtils.getIdNo(true));
+        }
+
+        DhPersonFormDTO formDTO = new DhPersonFormDTO();
+        formDTO.setPaperType("身份证");
+        formDTO.setPaperNumber(dto.getIdCard());
+        formDTO.setName(dto.getName());
+        formDTO.setCode(dto.getIdCard().substring(dto.getIdCard().length() - 10));
+        formDTO.setSex(IDUtils.getSex(dto.getIdCard()));
+        formDTO.setBirthday(dto.getIdCard().substring(6, 10) + "-" + dto.getIdCard().substring(10, 12) + "-" + dto.getIdCard().substring(12, 14));
+        formDTO.setPhone(dto.getMobile());
+        formDTO.setStatus("在职");
+        addPersonAuth(formDTO, dto.getFaceImg(), dto.getNode());
+    }
+
+    /**
+     * 获取publicKey
+     *
+     * @param
+     * @return void
+     * @author zhy
+     * @date 2022/5/20 16:40
+     */
+    private String getPublicKey() {
+        String key = RedisKeys.getDhPublicKey();
+        Object obj = redisUtils.get(key);
+        if (null != obj) {
+            return (String) obj;
+        }
+
+        String url = dhCloudProperties.getUrl().concat(GET_PUBLIC_KEY);
+        Map<String, String> paramsMap = new HashMap<>(4);
+
+        DhPublicKeyFormDTO dto = new DhPublicKeyFormDTO();
+        dto.setLoginName(dhCloudProperties.getLoginName());
+
+        String data = HttpClientManager.getInstance().sendPostByJSONAndHeader(url, JSON.toJSONString(dto), paramsMap).getData();
+
+        if (null == data) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "publicKey获取失败");
+        }
+
+        JSONObject toResult = JSON.parseObject(data);
+        if (!toResult.containsKey("publicKey")) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "publicKey获取失败");
+        }
+        String publicKey = toResult.get("publicKey").toString();
+
+        redisUtils.set(key, publicKey, RedisUtils.MINUTE_THIRTY_EXPIRE);
+        return publicKey;
+    }
+
+    /**
+     * 获取loginPass
+     *
+     * @param
+     * @return void
+     * @author zhy
+     * @date 2022/5/20 16:40
+     */
+    private DhTokenDTO getLoginPass(String publicKey) {
+        String key = RedisKeys.getDhToken();
+        Object obj = redisUtils.get(key);
+        if (null != obj) {
+            return (DhTokenDTO) obj;
+        }
+
+        String url = dhCloudProperties.getUrl().concat(GET_LOGIN_PASS);
+        Map<String, String> paramsMap = new HashMap<>(4);
+
+        DhLoginPassFormDTO dto = new DhLoginPassFormDTO();
+        dto.setLoginName(dhCloudProperties.getLoginName());
+        String pwd;
+        try {
+            pwd = RSAUtils.getPwdByRsa(publicKey, dhCloudProperties.getLoginPass());
+        } catch (Exception e) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "loginPass加密失败");
+        }
+        dto.setLoginPass(pwd);
+
+        String data = HttpClientManager.getInstance().sendPostByJSONAndHeader(url, JSON.toJSONString(dto), paramsMap).getData();
+
+        if (null == data) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "loginPass获取失败");
+        }
+
+        JSONObject toResult = JSON.parseObject(data);
+        if (!toResult.containsKey("token")) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "loginPass获取失败");
+        }
+        DhTokenDTO token = new DhTokenDTO();
+        token.setId(toResult.get("id").toString());
+        token.setLoginName(toResult.get("loginName").toString());
+        token.setPublicKey(toResult.get("publicKey").toString());
+        token.setToken(toResult.get("token").toString());
+        redisUtils.set(key, token, RedisUtils.MINUTE_THIRTY_EXPIRE);
+        return token;
+    }
+
+    /**
+     * 新增部门
+     *
+     * @param
+     * @return java.lang.String
+     * @author zhy
+     * @date 2022/5/23 10:08
+     */
+    private Long getDept() {
+        String url = dhCloudProperties.getUrl().concat(GET_DEPARTMENT);
+        String urlParam = getDhUrlParams();
+        url = url + urlParam;
+
+        Map<String, Object> paramsMap = new HashMap<>(4);
+//        DhDeptFormDTO dto = new DhDeptFormDTO();
+//        dto.setName("访客部门");
+//        dto.setParentId(1L);
+
+        String data = HttpClientManager.getInstance().sendGet(url, paramsMap).getData();
+
+        if (null == data) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "查询部门列表失败");
+        }
+        JSONObject toResult = JSON.parseObject(data);
+        DhResult result = ConvertUtils.mapToEntity(toResult, DhResult.class);
+        if (null != toResult.get("success")) {
+            result.setCode(200);
+        }
+        if (!result.getSuccess()) {
+            logger.info(result.getErrMsg());
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "查询部门列表失败!" + result.getErrMsg());
+        }
+        Object registerResult = result.getData();
+
+        JSONArray jsonArray = JSON.parseArray(registerResult.toString());
+        for (int i = 0; i < jsonArray.size(); i++) {
+            if ("临时人员".equals(jsonArray.getJSONObject(i).get("name").toString())) {
+                return Long.parseLong(jsonArray.getJSONObject(i).get("id").toString());
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * 查询节点
+     *
+     * @param
+     * @return java.lang.String
+     * @author zhy
+     * @date 2022/5/23 10:08
+     */
+    private String getNode(String nodeName) {
+        String url = dhCloudProperties.getUrl().concat(GET_NODE);
+        String urlParam = getDhUrlParams();
+        url = url + urlParam;
+
+        Map<String, String> paramsMap = new HashMap<>(4);
+        DhNodeFormDTO dto = new DhNodeFormDTO();
+        dto.setNodeId("ORG_001");
+        dto.setTypeCode("01;0;8;7");
+
+        String data = HttpClientManager.getInstance().sendPostByJSONAndHeader(url, JSON.toJSONString(dto), paramsMap).getData();
+
+        if (null == data) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "查询节点列表失败");
+        }
+        JSONObject toResult = JSON.parseObject(data);
+        DhResult result = ConvertUtils.mapToEntity(toResult, DhResult.class);
+        if (null != toResult.get("success")) {
+            result.setCode(200);
+        }
+        if (!result.getSuccess()) {
+            logger.info(result.getErrMsg());
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "查询节点列表失败!" + result.getErrMsg());
+        }
+        Object registerResult = result.getData();
+
+        JSONArray jsonArray = JSON.parseArray(registerResult.toString());
+        for (int i = 0; i < jsonArray.size(); i++) {
+            if (nodeName.equals(jsonArray.getJSONObject(i).get("name").toString())) {
+                return jsonArray.getJSONObject(i).get("id").toString();
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * 人员预处理
+     *
+     * @param
+     * @return java.lang.String
+     * @author zhy
+     * @date 2022/5/23 10:08
+     */
+    private void personHandle(String code) {
+        String url = dhCloudProperties.getUrl().concat(LIST_PERSON);
+        String urlParam = getDhUrlParams();
+        url = url + urlParam;
+
+        Map<String, String> paramsMap = new HashMap<>(4);
+        DhPersonPageFormDTO dto = new DhPersonPageFormDTO();
+        dto.setPageNum(1);
+        dto.setPageSize(100);
+        dto.setCode(code);
+
+        String data = HttpClientManager.getInstance().sendPostByJSONAndHeader(url, JSON.toJSONString(dto), paramsMap).getData();
+
+        if (null == data) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "查询人员列表失败");
+        }
+        JSONObject toResult = JSON.parseObject(data);
+        DhResult result = ConvertUtils.mapToEntity(toResult, DhResult.class);
+        if (null != toResult.get("success")) {
+            result.setCode(200);
+        }
+        if (!result.getSuccess()) {
+            logger.info(result.getErrMsg());
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "查询人员列表失败!" + result.getErrMsg());
+        }
+        Object registerResult = result.getData();
+
+        JSONObject jsonObject = JSON.parseObject(registerResult.toString());
+
+        List<Integer> ids = new ArrayList<>();
+        JSONArray jsonArray = JSON.parseArray(jsonObject.get("pageData").toString());
+        for (int i = 0; i < jsonArray.size(); i++) {
+            ids.add(Integer.parseInt(jsonArray.getJSONObject(i).get("id").toString()));
+        }
+        if (!ids.isEmpty()) {
+            DhPersonDelFormDTO del = new DhPersonDelFormDTO();
+            del.setPersonIds(ids);
+            delPerson(del);
+        }
+
+    }
+
+    /**
+     * 卡片预处理
+     *
+     * @param
+     * @return java.lang.String
+     * @author zhy
+     * @date 2022/5/23 10:08
+     */
+    private void cardHandle(String code) {
+        String url = dhCloudProperties.getUrl().concat(LIST_CARD);
+        String urlParam = getDhUrlParams();
+        url = url + urlParam;
+
+        Map<String, String> paramsMap = new HashMap<>(4);
+        DhCardPageFormDTO dto = new DhCardPageFormDTO();
+        dto.setPageNum(1);
+        dto.setPageSize(100);
+        dto.setPersonCode(code);
+
+        String data = HttpClientManager.getInstance().sendPostByJSONAndHeader(url, JSON.toJSONString(dto), paramsMap).getData();
+
+        if (null == data) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "查询卡片列表失败");
+        }
+        JSONObject toResult = JSON.parseObject(data);
+        DhResult result = ConvertUtils.mapToEntity(toResult, DhResult.class);
+        if (null != toResult.get("success")) {
+            result.setCode(200);
+        }
+        if (!result.getSuccess()) {
+            logger.info(result.getErrMsg());
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "查询卡片列表失败!" + result.getErrMsg());
+        }
+        Object registerResult = result.getData();
+
+        JSONObject jsonObject = JSON.parseObject(registerResult.toString());
+
+        JSONArray jsonArray = JSON.parseArray(jsonObject.get("pageData").toString());
+        for (int i = 0; i < jsonArray.size(); i++) {
+            delCard(jsonArray.getJSONObject(i).get("cardNumber").toString());
+        }
+    }
+
+    /**
+     * 删除人员
+     *
+     * @param
+     * @return java.lang.String
+     * @author zhy
+     * @date 2022/5/23 10:08
+     */
+    private void delPerson(DhPersonDelFormDTO dto) {
+        String url = dhCloudProperties.getUrl().concat(DEL_PERSON);
+        String urlParam = getDhUrlParams();
+        url = url + urlParam;
+
+        Map<String, String> paramsMap = new HashMap<>(4);
+
+        String data = HttpClientManager.getInstance().sendPostByJSONAndHeader(url, JSON.toJSONString(dto), paramsMap).getData();
+        if (null == data) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "删除人员失败");
+        }
+    }
+
+    /**
+     * 退卡
+     *
+     * @param
+     * @return java.lang.String
+     * @author zhy
+     * @date 2022/5/23 10:08
+     */
+    private void delCard(String cardNum) {
+        String url = dhCloudProperties.getUrl().concat(DEL_CARD);
+        url = url + cardNum;
+        String urlParam = getDhUrlParams();
+        url = url + urlParam;
+
+        Map<String, String> paramsMap = new HashMap<>(4);
+
+        String data = HttpClientManager.getInstance().sendPostByJSONAndHeader(url, StringUtils.EMPTY, paramsMap).getData();
+        if (null == data) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "删除卡片失败");
+        }
+    }
+
+    /**
+     * 获取身份
+     *
+     * @param
+     * @return java.lang.String
+     * @author zhy
+     * @date 2022/5/23 11:04
+     */
+    private String getIdentity() {
+        String url = dhCloudProperties.getUrl().concat(GET_PERSON_IDENTITY);
+        String urlParam = getDhUrlParams();
+        url = url + urlParam;
+
+        Map<String, Object> paramsMap = new HashMap<>(4);
+//        DhIdentityFormDTO dto = new DhIdentityFormDTO();
+//        dto.setName("访客");
+//        dto.setSubsidyAmount(0D);
+//        dto.setIsCashRecharge(1);
+//        dto.setIsMachineRecharge(1);
+
+        String data = HttpClientManager.getInstance().sendGet(url, paramsMap).getData();
+
+        if (null == data) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "获取身份列表失败");
+        }
+        JSONObject toResult = JSON.parseObject(data);
+        DhResult result = ConvertUtils.mapToEntity(toResult, DhResult.class);
+        if (null != toResult.get("success")) {
+            result.setCode(200);
+        }
+        if (!result.getSuccess()) {
+            logger.info(result.getErrMsg());
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "获取身份列表失败!" + result.getErrMsg());
+        }
+        Object registerResult = result.getData();
+        JSONArray jsonArray = JSON.parseArray(registerResult.toString());
+        for (int i = 0; i < jsonArray.size(); i++) {
+            if ("默认身份".equals(jsonArray.getJSONObject(i).get("name").toString())) {
+                return jsonArray.getJSONObject(i).get("id").toString();
+            }
+        }
+
+        return "";
+    }
+
+    /**
+     * 获取开门计划
+     *
+     * @param
+     * @return java.lang.String
+     * @author zhy
+     * @date 2022/5/23 11:04
+     */
+    private Long getPlan() {
+        String url = dhCloudProperties.getUrl().concat(GET_DOOR_PLAN);
+        String urlParam = getDhUrlParams();
+        url = url + urlParam;
+
+        Map<String, String> paramsMap = new HashMap<>(4);
+        DhPlanPageFormDTO dto = new DhPlanPageFormDTO();
+        dto.setPageNum(1);
+        dto.setPageSize(100);
+        dto.setSingleCondition("默认");
+
+        String data = HttpClientManager.getInstance().sendPostByJSONAndHeader(url, JSON.toJSONString(dto), paramsMap).getData();
+
+        if (null == data) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "查询开门计划失败");
+        }
+        JSONObject toResult = JSON.parseObject(data);
+        DhResult result = ConvertUtils.mapToEntity(toResult, DhResult.class);
+        if (null != toResult.get("success")) {
+            result.setCode(200);
+        }
+        if (!result.getSuccess()) {
+            logger.info(result.getErrMsg());
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "查询开门计划失败!" + result.getErrMsg());
+        }
+        Object registerResult = result.getData();
+
+        JSONObject jsonObject = JSON.parseObject(registerResult.toString());
+
+        JSONArray jsonArray = JSON.parseArray(jsonObject.get("pageData").toString());
+
+        if (jsonArray.size() > 0) {
+            return Long.parseLong(jsonArray.getJSONObject(0).get("id").toString());
+        }
+
+        return null;
+    }
+
+    /**
+     * 查询通道
+     *
+     * @param
+     * @return java.lang.String
+     * @author zhy
+     * @date 2022/5/23 11:04
+     */
+    private List<DhChannelResultDTO> getChannel() {
+        String url = dhCloudProperties.getUrl().concat(GET_DOOR_CHANNEL);
+        String urlParam = getDhUrlParams();
+        url = url + urlParam;
+
+        Map<String, String> paramsMap = new HashMap<>(4);
+        DhChannelPageFormDTO dto = new DhChannelPageFormDTO();
+        dto.setPageSize(100);
+        dto.setPageNum(1);
+        dto.setDeviceGenre("0");
+
+        String data = HttpClientManager.getInstance().sendPostByJSONAndHeader(url, JSON.toJSONString(dto), paramsMap).getData();
+
+        if (null == data) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "查询通道列表失败");
+        }
+        JSONObject toResult = JSON.parseObject(data);
+        DhResult result = ConvertUtils.mapToEntity(toResult, DhResult.class);
+        if (null != toResult.get("success")) {
+            result.setCode(200);
+        }
+        if (!result.getSuccess()) {
+            logger.info(result.getErrMsg());
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "查询通道列表失败!" + result.getErrMsg());
+        }
+        Object registerResult = result.getData();
+
+        JSONObject jsonObject = JSON.parseObject(registerResult.toString());
+
+        JSONArray jsonArray = JSON.parseArray(jsonObject.get("pageData").toString());
+
+        List<DhChannelResultDTO> list = new ArrayList<>();
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONObject jsonItem = jsonArray.getJSONObject(i);
+            DhChannelResultDTO channel = new DhChannelResultDTO();
+            channel.setPrivilegeType("1");
+            channel.setResouceCode(jsonItem.get("channelCode").toString());
+            list.add(channel);
+        }
+
+        return list;
+    }
+
+    /**
+     * 查询通道-从全部设备中获取
+     *
+     * @param
+     * @return java.lang.String
+     * @author zhy
+     * @date 2022/5/23 11:04
+     */
+    private List<DhChannelResultDTO> getAllChannel(String nodeName) {
+        String nodeId = getNode(nodeName);
+        if (StringUtils.isBlank(nodeId)) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "查询节点失败");
+        }
+        nodeId = nodeId.replaceAll("ORG_", "");
+        String url = dhCloudProperties.getUrl().concat(GET_CHANNEL);
+        String urlParam = getDhUrlParams();
+        url = url + urlParam;
+
+        Map<String, String> paramsMap = new HashMap<>(4);
+        DhChannelFormDTO dto = new DhChannelFormDTO();
+        dto.setInterfaceId("admin_001_006");
+        dto.setJsonParam("{\"param\":{\"unitType\":7,\"orgCode\":\"" + nodeId + "\"}}");
+
+        String data = HttpClientManager.getInstance().sendPostByJSONAndHeader(url, JSON.toJSONString(dto), paramsMap).getData();
+
+        if (null == data) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "查询通道列表失败");
+        }
+        JSONObject toResult = JSON.parseObject(data);
+        DhResult result = ConvertUtils.mapToEntity(toResult, DhResult.class);
+        if (null != toResult.get("success")) {
+            result.setCode(200);
+        }
+        if (!result.getSuccess()) {
+            logger.info(result.getErrMsg());
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "查询通道列表失败!" + result.getErrMsg());
+        }
+        Object registerResult = result.getData();
+
+        JSONArray jsonArray = JSON.parseArray(registerResult.toString());
+
+        List<DhChannelResultDTO> list = new ArrayList<>();
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONObject jsonItem = jsonArray.getJSONObject(i);
+            DhChannelResultDTO channel = new DhChannelResultDTO();
+            channel.setPrivilegeType("1");
+            channel.setResouceCode(jsonItem.get("channelId").toString());
+            list.add(channel);
+        }
+
+        return list;
+    }
+
+    /**
+     * 新增人员
+     *
+     * @param dto
+     * @return java.lang.String
+     * @author zhy
+     * @date 2022/5/23 11:04
+     */
+    private Long addPerson(DhPersonFormDTO dto) {
+        // 数据预处理
+        dataHandle(dto.getCode());
+
+        String url = dhCloudProperties.getUrl().concat(ADD_PERSON);
+        String urlParam = getDhUrlParams();
+        url = url + urlParam;
+
+        Long deptId = getDept();
+        if (null == deptId) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "查询临时人员部门失败");
+        }
+        String identity = getIdentity();
+        if (StringUtils.isBlank(identity)) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "获取身份失败");
+        }
+        dto.setDeptId(deptId);
+        dto.setPersonIdentityId(identity);
+
+        Map<String, String> paramsMap = new HashMap<>(4);
+
+        String data = HttpClientManager.getInstance().sendPostByJSONAndHeader(url, JSON.toJSONString(dto), paramsMap).getData();
+
+        if (null == data) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "新增人员失败");
+        }
+        JSONObject toResult = JSON.parseObject(data);
+        DhResult result = ConvertUtils.mapToEntity(toResult, DhResult.class);
+        if (null != toResult.get("success")) {
+            result.setCode(200);
+        }
+        if (!result.getSuccess()) {
+            logger.info(result.getErrMsg());
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "新增人员失败!" + result.getErrMsg());
+        }
+        Object registerResult = result.getData();
+        if (null != registerResult) {
+            return Long.parseLong(registerResult.toString());
+        }
+        return null;
+    }
+
+    /**
+     * 下发人员头像
+     *
+     * @param dto
+     * @return java.lang.String
+     * @author zhy
+     * @date 2022/5/23 11:04
+     */
+    private String addPersonImg(DhPersonFormDTO dto, String imgUrl) {
+        DhPersonImgFormDTO imgFormDTO = new DhPersonImgFormDTO();
+        String url = dhCloudProperties.getUrl().concat(ADD_PERSON_IMG);
+        String urlParam = getDhUrlParams();
+        url = url + urlParam;
+
+        imgFormDTO.setPersonCode(dto.getCode());
+        imgFormDTO.setBase64file(getBase64ByUrl(imgUrl));
+
+        Map<String, String> paramsMap = new HashMap<>(4);
+
+        String data = HttpClientManager.getInstance().sendPostByJSONAndHeader(url, JSON.toJSONString(imgFormDTO), paramsMap).getData();
+
+        if (null == data) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "下发人员头像失败");
+        }
+        JSONObject toResult = JSON.parseObject(data);
+        DhResult result = ConvertUtils.mapToEntity(toResult, DhResult.class);
+        if (null != toResult.get("success")) {
+            result.setCode(200);
+        }
+        if (!result.getSuccess()) {
+            logger.info(result.getErrMsg());
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "下发人员头像失败!" + result.getErrMsg());
+        } else {
+            return "success";
+        }
+    }
+
+    /**
+     * 人员开卡
+     *
+     * @param dto
+     * @return java.lang.String
+     * @author zhy
+     * @date 2022/5/23 11:04
+     */
+    private String addPersonCard(DhPersonFormDTO dto) {
+        Long personId = addPerson(dto);
+        if (personId == null) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "添加人员信息失败");
+        }
+        DhPersonCardListFormDTO cardListFormDTO = new DhPersonCardListFormDTO();
+        List<DhPersonCardFormDTO> cardList = new ArrayList<>();
+        DhPersonCardFormDTO cardFormDTO = new DhPersonCardFormDTO();
+        String url = dhCloudProperties.getUrl().concat(OPEN_CARD);
+        String urlParam = getDhUrlParams();
+        url = url + urlParam;
+
+        cardFormDTO.setPersonId(personId);
+        cardFormDTO.setPersonName(dto.getName());
+        cardFormDTO.setCardNumber(generateNiceString(8));
+        cardFormDTO.setCardType("0");
+        cardFormDTO.setCategory("0");
+        cardFormDTO.setCardStatus("ACTIVE");
+        cardFormDTO.setStartDate(LocalDate.now().toString());
+        cardFormDTO.setEndDate(LocalDate.now().toString());
+        String pwd;
+        try {
+            pwd = RSAUtils.getPwdByRsa(getPublicKey(), "123456");
+        } catch (Exception e) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "密码加密失败");
+        }
+        cardFormDTO.setCardPassword(pwd);
+        cardFormDTO.setSubSystems("1");
+        cardList.add(cardFormDTO);
+        cardListFormDTO.setObjectList(cardList);
+
+        Map<String, String> paramsMap = new HashMap<>(4);
+
+        String data = HttpClientManager.getInstance().sendPostByJSONAndHeader(url, JSON.toJSONString(cardListFormDTO), paramsMap).getData();
+
+        if (null == data) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "人员开卡失败");
+        }
+        JSONObject toResult = JSON.parseObject(data);
+        DhResult result = ConvertUtils.mapToEntity(toResult, DhResult.class);
+        if (null != toResult.get("success")) {
+            result.setCode(200);
+        }
+        if (!result.getSuccess()) {
+            logger.info(result.getErrMsg());
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "人员开卡失败!" + result.getErrMsg());
+        } else {
+            return cardFormDTO.getCardNumber();
+        }
+    }
+
+    /**
+     * 下发人员权限
+     *
+     * @param dto
+     * @return java.lang.String
+     * @author zhy
+     * @date 2022/5/23 11:04
+     */
+    private String addPersonAuth(DhPersonFormDTO dto, String imgUrl, String node) {
+        String personCard = addPersonCard(dto);
+        if (StringUtils.isBlank(personCard)) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "开卡失败");
+        } else if (StringUtils.isNotBlank(imgUrl)) {
+            addPersonImg(dto, imgUrl);
+        }
+
+//        List<DhChannelResultDTO> channel = getAllChannel(node);
+        List<DhChannelResultDTO> channel = getChannel();
+        if (channel.isEmpty()) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "获取通道失败");
+        }
+
+        Long plan = getPlan();
+        if (plan == null) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "获取开门计划失败");
+        }
+
+        DhAuthFormDTO authFormDTO = new DhAuthFormDTO();
+        String url = dhCloudProperties.getUrl().concat(ADD_AUTH);
+        String urlParam = getDhUrlParams();
+        url = url + urlParam;
+
+        authFormDTO.setCardNumber(personCard);
+        authFormDTO.setTimeQuantumId(plan.toString());
+        authFormDTO.setCardPrivilegeDetails(channel);
+
+        Map<String, String> paramsMap = new HashMap<>(4);
+
+        String data = HttpClientManager.getInstance().sendPostByJSONAndHeader(url, JSON.toJSONString(authFormDTO), paramsMap).getData();
+
+        if (null == data) {
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "下发人员权限失败");
+        }
+        JSONObject toResult = JSON.parseObject(data);
+        DhResult result = ConvertUtils.mapToEntity(toResult, DhResult.class);
+        if (null != toResult.get("success")) {
+            result.setCode(200);
+        }
+        if (!result.getSuccess()) {
+            logger.info(result.getErrMsg());
+            throw new EpmetException(EpmetErrorCode.EPMET_COMMON_OPERATION_FAIL.getCode(), "下发人员权限失败!" + result.getErrMsg());
+        } else {
+            return "success";
+        }
+    }
+
+    /**
+     * 拼接url固定参数
+     *
+     * @param
+     * @return java.lang.String
+     * @author zhy
+     * @date 2022/7/28 16:09
+     */
+    private String getDhUrlParams() {
+        DhTokenDTO token = getLoginPass(getPublicKey());
+        return "?userId=" + token.getId() + "&username=" + token.getLoginName() + "&token=" + token.getToken();
+    }
+
+    private String getBase64ByUrl(String imgUrl) {
+        String ossDomain;
+        byte[] fileBytes;
+        try {
+            URL url = new URL(imgUrl);
+            DataInputStream dataInputStream = new DataInputStream(url.openStream());
+            byte[] originBytes = toByteArray(dataInputStream);
+
+            fileBytes = compressPicCycle(originBytes, 100L, 0.1);
+        } catch (IOException e) {
+            logger.error("图片上传异常", e);
+            throw new RenException("图片上传异常");
+        }
+        return DatatypeConverter.printBase64Binary(fileBytes);
+    }
+
+    /**
+     * @param bytes       原图片字节数组
+     * @param desFileSize 指定图片大小,单位 kb
+     * @param accuracy    精度,递归压缩的比率,建议小于0.9
+     * @return
+     */
+    private byte[] compressPicCycle(byte[] bytes, long desFileSize, double accuracy) throws IOException {
+        // 获取目标图片
+        long fileSize = bytes.length;
+        System.out.println("=====fileSize======== " + fileSize);
+        // 判断图片大小是否小于指定图片大小
+        if (fileSize <= desFileSize * 1024) {
+            return bytes;
+        }
+        //计算宽高
+        BufferedImage bim = ImageIO.read(new ByteArrayInputStream(bytes));
+        int imgWidth = bim.getWidth();
+        System.out.println(imgWidth + "====imgWidth=====");
+        int imgHeight = bim.getHeight();
+        int desWidth = new BigDecimal(imgWidth).multiply(new BigDecimal(accuracy)).intValue();
+        System.out.println(desWidth + "====desWidth=====");
+        int desHeight = new BigDecimal(imgHeight).multiply(new BigDecimal(accuracy)).intValue();
+        ByteArrayOutputStream baos = new ByteArrayOutputStream(); //字节输出流（写入到内存）
+        Thumbnails.of(new ByteArrayInputStream(bytes)).size(desWidth, desHeight).outputQuality(accuracy).toOutputStream(baos);
+        //如果不满足要求,递归直至满足要求
+        return compressPicCycle(baos.toByteArray(), desFileSize, accuracy);
+    }
+
+    /**
+     * inputstream输入流转换成byte[]字节数组
+     *
+     * @param input
+     * @return byte[]
+     * @author yinzuomei
+     * @date 2020/2/27 16:09
+     */
+    private byte[] toByteArray(InputStream input) throws IOException {
+        ByteArrayOutputStream output = new ByteArrayOutputStream();
+        byte[] buffer = new byte[1024 * 4];
+        int n = 0;
+        while (-1 != (n = input.read(buffer))) {
+            output.write(buffer, 0, n);
+        }
+        return output.toByteArray();
+    }
+
+    /**
+     * 随机生成16进制字符串
+     *
+     * @param len
+     * @return java.lang.String
+     * @author zhy
+     * @date 2022/7/29 9:47
+     */
+    private String generateNiceString(int len) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < len; i++) {
+            sb.append(Integer.toHexString(new Random().nextInt(16)));
+        }
+        return sb.toString().toUpperCase();
+    }
+
+    /**
+     * 退卡，然后删除人员
+     *
+     * @param code
+     * @return void
+     * @author zhy
+     * @date 2022/8/3 10:48
+     */
+    private void dataHandle(String code) {
+        // 先退卡
+        cardHandle(code);
+        // 再删人员
+        personHandle(code);
+    }
+
+}

epmet-user/epmet-user-server/src/main/java/com/epmet/util/dh/DhResult.java

@@ -0,0 +1,141 @@
+/**
+ * Copyright (c) 2018 人人开源 All rights reserved.
+ *
+ * https://www.renren.io
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.epmet.util.dh;
+
+import com.alibaba.fastjson.JSON;
+import com.epmet.commons.tools.exception.EpmetErrorCode;
+import com.epmet.commons.tools.exception.ErrorCode;
+import com.epmet.commons.tools.utils.MessageUtils;
+import org.apache.commons.lang3.StringUtils;
+
+import java.io.Serializable;
+
+/**
+ * 响应数据
+ *
+ * @author Mark sunlightcs@gmail.com
+ * @since 1.0.0
+ */
+public class DhResult<T> implements Serializable {
+    private static final long serialVersionUID = 1L;
+    /**
+     * 编码：0表示成功，其他值表示失败
+     */
+    private Integer code = 0;
+    /**
+     * 消息内容
+     */
+    private String errMsg = "success";
+
+    /**
+     * 内部信息
+     */
+    private Boolean success = true;
+
+    /**
+     * 响应数据
+     */
+    private T data;
+
+    public DhResult<T> ok(T data) {
+        this.setData(data);
+        return this;
+    }
+
+    public boolean success(){
+        return code == 0;
+    }
+
+    /**
+     * 返回
+     *     "code": 8000,
+     *     "msg": "服务器开小差了...",
+     */
+    public DhResult<T> error() {
+        this.code = EpmetErrorCode.SERVER_ERROR.getCode();
+        this.errMsg = EpmetErrorCode.getMsg(code);
+        if (StringUtils.isBlank(this.errMsg)) {
+            this.errMsg = MessageUtils.getMessage(this.code);
+        }
+        return this;
+    }
+
+    /**
+     * 根据错误编码查询msg返回
+     */
+    public DhResult<T> error(int code) {
+        this.code = code;
+        this.errMsg = EpmetErrorCode.getMsg(code);
+        if (StringUtils.isBlank(this.errMsg)) {
+            this.errMsg = MessageUtils.getMessage(this.code);
+        }
+        return this;
+    }
+
+    /**
+     * 传入错误编码+msg返回
+     */
+    public DhResult<T> error(int code, String msg) {
+        this.code = code;
+        this.errMsg = msg;
+        return this;
+    }
+
+    /**
+     *
+     * @param msg
+     * @return 此方法废弃，统一使用
+     * logger.error(XXXX);
+     * throw new RenException(XXXX);
+     * XXXX定义常量里
+     */
+    @Deprecated
+    public DhResult<T> error(String msg) {
+        this.code = ErrorCode.INTERNAL_SERVER_ERROR;
+        this.errMsg = msg;
+        return this;
+    }
+
+    public int getCode() {
+        return code;
+    }
+
+    public void setCode(int code) {
+        this.code = code;
+    }
+
+    public String getErrMsg() {
+        return errMsg;
+    }
+
+    public void setErrMsg(String errMsg) {
+        this.errMsg = errMsg;
+    }
+
+    public T getData() {
+        return data;
+    }
+
+    public void setData(T data) {
+        this.data = data;
+    }
+
+    public Boolean getSuccess() {
+        return success;
+    }
+
+    public void setSuccess(Boolean success) {
+        this.success = success;
+    }
+
+    @Override
+    public String toString() {
+        return JSON.toJSONString(this);
+    }
+}

epmet-user/epmet-user-server/src/main/java/com/epmet/util/dh/IDUtils.java

@@ -0,0 +1,85 @@
+package com.epmet.util.dh;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Random;
+
+public class IDUtils {
+    public static String getIdNo(boolean male) {
+        //随机生成生日 1~99岁
+        long begin = System.currentTimeMillis() - 3153600000000L;//100年内
+        long end = System.currentTimeMillis() - 31536000000L; //1年内
+        long rtn = begin + (long) (Math.random() * (end - begin));
+        Date date = new Date(rtn);
+        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMdd");
+        String birth = simpleDateFormat.format(date);
+        return getIdNo(birth, male);
+    }
+
+    public static String getIdNo(String birth, boolean male) {
+        StringBuilder sb = new StringBuilder();
+        Random random = new Random();
+        int value = random.nextInt(Cities.cities.length);
+        sb.append(Cities.cities[value]);
+        sb.append(birth);
+        value = random.nextInt(999) + 1;
+        if (male && value % 2 == 0) {
+            value++;
+        }
+        if (!male && value % 2 == 1) {
+            value++;
+        }
+        if (value >= 100) {
+            sb.append(value);
+        } else if (value >= 10) {
+            sb.append('0').append(value);
+        } else {
+            sb.append("00").append(value);
+        }
+        sb.append(calcTrailingNumber(sb));
+        return sb.toString();
+    }
+
+    private static final int[] calcC = {7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2};
+    private static final char[] calcR = {'1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2'};
+
+    private static char calcTrailingNumber(StringBuilder sb) {
+        int[] n = new int[17];
+        int result = 0;
+        for (int i = 0; i < n.length; i++) {
+            n[i] = Integer.parseInt(String.valueOf(sb.charAt(i)));
+        }
+        for (int i = 0; i < n.length; i++) {
+            result += calcC[i] * n[i];
+        }
+        return calcR[result % 11];
+    }
+
+    /**
+     * 根据身份证号判断用户性别
+     *
+     * @param cardNo
+     * @return
+     */
+    public static String getSex(String cardNo) {
+        String sexStr = "0";
+        if (cardNo.length() == 15) {
+            sexStr = cardNo.substring(14, 15);
+        } else if (cardNo.length() == 18) {
+            sexStr = cardNo.substring(16, 17);
+        }
+        int sexNo = Integer.parseInt(sexStr);
+        return sexNo % 2 == 0 ? "女" : "男";
+    }
+
+//    public static void main(String[] args) {
+//        long a = System.currentTimeMillis();
+//        System.out.println(getIdNo("19790306", true));
+//        System.out.println(getIdNo("20100112", false));
+//        System.out.println(getIdNo(true));
+//        System.out.println(getIdNo(false));
+//        a = System.currentTimeMillis() - a;
+//        System.out.println(a);
+//    }
+
+}

epmet-user/epmet-user-server/src/main/java/com/epmet/util/dh/RSAUtils.java

@@ -0,0 +1,316 @@
+package com.epmet.util.dh;
+
+import cn.hutool.core.codec.Base64;
+import org.bouncycastle.jce.provider.BouncyCastleProvider;
+
+import javax.crypto.Cipher;
+import java.security.*;
+import java.security.interfaces.RSAPrivateKey;
+import java.security.interfaces.RSAPublicKey;
+import java.security.spec.PKCS8EncodedKeySpec;
+import java.security.spec.X509EncodedKeySpec;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 
+ *<p>Title:RSAUtils</p>
+ *<p>Description:RSA工具类</p>
+ *<p>Company:浙江大华技术股份有限公司</p>
+ * @author 32174
+ * @date 2018年12月18日
+ */
+public class RSAUtils{
+	public static final String KEY_ALGORITHM = "RSA";
+	public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
+	public static final String PADDING="RSA/None/PKCS1Padding";
+	
+	private static final String PUBLIC_KEY = "RSAPublicKey";
+	private static final String PRIVATE_KEY = "RSAPrivateKey";
+	
+	private static final int KEY_SIZE = 1024;  //  秘钥长度1024，最长加密117字节明文
+	
+	static{
+		Security.addProvider(new BouncyCastleProvider());
+	}
+	/**
+	 * 用私钥对信息生成数字签名
+	 * 
+	 * @param data
+	 *            加密数据
+	 * @param privateKey
+	 *            私钥
+	 * 
+	 * @return
+	 * @throws Exception
+	 */
+	public static String sign(byte[] data, String privateKey) throws Exception {
+		// 解密由base64编码的私钥
+		byte[] keyBytes = decryptBASE64(privateKey);
+
+		// 构造PKCS8EncodedKeySpec对象
+		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
+
+		// KEY_ALGORITHM 指定的加密算法
+		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
+
+		// 取私钥匙对象
+		PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);
+
+		// 用私钥对信息生成数字签名
+		Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
+		signature.initSign(priKey);
+		signature.update(data);
+
+		return encryptBASE64(signature.sign());
+	}
+	
+	/**
+	 * BASE64加密
+	 * 
+	 * @param key
+	 * @return
+	 * @throws Exception
+	 */
+	public static String encryptBASE64(byte[] key) throws Exception {	
+		return Base64Util.encodeBase64String(key);
+	}
+	
+	/**
+	 * BASE64解密
+	 * 
+	 * @param key
+	 * @return
+	 * @throws Exception
+	 */
+	public static byte[] decryptBASE64(String key) throws Exception {
+		return Base64Util.decodeBase64(key.getBytes());
+	}
+
+	/**
+	 * 校验数字签名
+	 * 
+	 * @param data
+	 *            加密数据
+	 * @param publicKey
+	 *            公钥
+	 * @param sign
+	 *            数字签名
+	 * 
+	 * @return 校验成功返回true 失败返回false
+	 * @throws Exception
+	 * 
+	 */
+	public static boolean verify(byte[] data, String publicKey, String sign)
+			throws Exception {
+
+		// 解密由base64编码的公钥
+		byte[] keyBytes = decryptBASE64(publicKey);
+
+		// 构造X509EncodedKeySpec对象
+		X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
+
+		// KEY_ALGORITHM 指定的加密算法
+		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
+
+		// 取公钥匙对象
+		PublicKey pubKey = keyFactory.generatePublic(keySpec);
+
+		Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
+		signature.initVerify(pubKey);
+		signature.update(data);
+
+		// 验证签名是否正常
+		return signature.verify(decryptBASE64(sign));
+	}
+
+	/**
+	 * 解密<br>
+	 * 用私钥解密
+	 * 
+	 * @param data
+	 * @param key
+	 * @return
+	 * @throws Exception
+	 */
+	public static byte[] decryptByPrivateKey(byte[] data, String key)
+			throws Exception {
+		// 对密钥解密
+		byte[] keyBytes = decryptBASE64(key);
+
+		// 取得私钥
+		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
+		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
+		Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
+
+		// 对数据解密
+		Cipher cipher = Cipher.getInstance(PADDING ,  BouncyCastleProvider.PROVIDER_NAME);
+		cipher.init(Cipher.DECRYPT_MODE, privateKey);
+
+		return cipher.doFinal(data);
+	}
+
+	/**
+	 * 解密<br>
+	 * 用公钥解密
+	 * 
+	 * @param data
+	 * @param key
+	 * @return
+	 * @throws Exception
+	 */
+	public static byte[] decryptByPublicKey(byte[] data, String key)
+			throws Exception {
+		// 对密钥解密
+		byte[] keyBytes = decryptBASE64(key);
+
+		// 取得公钥
+		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
+		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
+		Key publicKey = keyFactory.generatePublic(x509KeySpec);
+
+		// 对数据解密
+		Cipher cipher = Cipher.getInstance(PADDING ,  BouncyCastleProvider.PROVIDER_NAME);
+		cipher.init(Cipher.DECRYPT_MODE, publicKey);
+
+		return cipher.doFinal(data);
+	}
+
+	/**
+	 * 加密<br>
+	 * 用公钥加密
+	 * 
+	 * @param data
+	 * @param key
+	 * @return
+	 * @throws Exception
+	 */
+	public static byte[] encryptByPublicKey(byte[] data, String key)
+			throws Exception {
+		// 对公钥解密
+		byte[] keyBytes = decryptBASE64(key);
+
+		// 取得公钥
+		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
+		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
+		Key publicKey = keyFactory.generatePublic(x509KeySpec);
+
+		// 对数据加密
+		Cipher cipher = Cipher.getInstance(PADDING ,  BouncyCastleProvider.PROVIDER_NAME);
+		cipher.init(Cipher.ENCRYPT_MODE, publicKey);
+
+		return cipher.doFinal(data);
+	}
+
+	/**
+	 * 加密<br>
+	 * 用私钥加密
+	 * 
+	 * @param data
+	 * @param key
+	 * @return
+	 * @throws Exception
+	 */
+	public static byte[] encryptByPrivateKey(byte[] data, String key)
+			throws Exception {
+		// 对密钥解密
+		byte[] keyBytes = decryptBASE64(key);
+
+		// 取得私钥
+		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
+		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
+		Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
+
+		// 对数据加密
+		Cipher cipher = Cipher.getInstance(PADDING ,  BouncyCastleProvider.PROVIDER_NAME);
+		cipher.init(Cipher.ENCRYPT_MODE, privateKey);
+
+		return cipher.doFinal(data);
+	}
+
+	/**
+	 * 取得私钥(BASE64编码)
+	 * 
+	 * @param keyMap
+	 * @return
+	 * @throws Exception
+	 */
+	public static String getPrivateKey(Map<String, Object> keyMap)
+			throws Exception {
+		Key key = (Key) keyMap.get(PRIVATE_KEY);
+
+		return encryptBASE64(key.getEncoded());
+	}
+
+	/**
+	 * 取得公钥(BASE64编码)
+	 * 
+	 * @param keyMap
+	 * @return
+	 * @throws Exception
+	 */
+	public static String getPublicKey(Map<String, Object> keyMap)
+			throws Exception {
+		Key key = (Key) keyMap.get(PUBLIC_KEY);
+
+		return encryptBASE64(key.getEncoded());
+	}
+	
+	/**
+	 * 判断字符串是否被公钥加密
+	 * @param text
+	 * @param privateKey
+	 * @return
+	 */
+	public static boolean isTextEncryptByPublicKey(String text , String privateKey){
+		boolean bol = true;
+		try{
+			 byte[] encryBytes = RSAUtils.decryptBASE64(text);
+			 RSAUtils.decryptByPrivateKey(encryBytes, privateKey);
+		}catch(Exception e){
+			bol = false;
+		}
+		return bol;
+	}
+
+	/**
+	 * 初始化密钥
+	 * 
+	 * @return
+	 * @throws Exception
+	 */
+	public static Map<String, Object> initKey() throws Exception {
+		KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM , BouncyCastleProvider.PROVIDER_NAME);
+		keyPairGen.initialize(KEY_SIZE , new SecureRandom());
+
+		KeyPair keyPair = keyPairGen.generateKeyPair();
+
+		// 公钥
+		RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
+
+		// 私钥
+		RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
+
+		Map<String, Object> keyMap = new HashMap<String, Object>(2);
+
+		keyMap.put(PUBLIC_KEY, publicKey);
+		keyMap.put(PRIVATE_KEY, privateKey);
+		return keyMap;
+	}
+
+	/**
+	 * 密码加密
+	 *
+	 * @param
+	 * @return java.lang.String
+	 * @author zhy
+	 * @date 2022/7/29 10:46
+	 */
+	public static String getPwdByRsa(String publicKey, String str) throws Exception {
+		byte[] decoded = Base64.decode(publicKey);
+		RSAPublicKey pubKey =(RSAPublicKey)KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(decoded));// RSA加密
+		Cipher cipher = Cipher.getInstance("RSA");
+		cipher.init(Cipher.ENCRYPT_MODE, pubKey);
+		return Base64.encode(cipher.doFinal(str.getBytes("UTF-8")));
+	}
+}