java代码发起钉钉审批流程实例

已于 2023-06-05 14:31:37 修改
阅读量1.9k 收藏 12
点赞数 7
文章标签： java 钉钉 spring
于 2023-06-01 14:50:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/devotemyself/article/details/130988080
版权

用钉钉应用，创建审批流程实例，但是官方给的代码，缺了很多包，后期根据参数重新编写

package com.fycx.businessv1.controller;

import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.http.HttpRequest;
import cn.hutool.http.HttpResponse;
import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.fycx.businessv1.service.SysUserService;
import com.fycx.common.core.exception.ServiceException;
import com.fycx.common.core.web.domain.AjaxResult;
import com.fycx.system.api.domain.SysUser;
import lombok.Getter;
import lombok.Setter;
import org.apache.commons.codec.binary.Base64;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.io.ByteArrayOutputStream;
import java.lang.reflect.Field;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.Permission;
import java.security.PermissionCollection;
import java.security.Security;
import java.util.*;


/**
 * @ClassName DingTalkController
 * @author: maliang
 * @Description dingding控制层
 * @date 2023/5/30 11:38
 * @Version 1.0版本
 */
@RestController
@RequestMapping("/dingTalk")
public class DingTalkController {

    /**
     * 钉钉应用Key
     */
    private String corpId = "dingg3wi80ddyuzorsin";

    /**
     * 钉钉应用，回调的key
     */
    private String aesKey = "m4ceYAYx8AGP9zVKTVTAqm8gdvt2ujeNHTGElK3R8jI";

    /**
     * 应用回调的token
     */
    private String token = "xBuctYRbUlcGbI7h6kAmA5MFDKX8jYgpGBe5Q646Et7VWKdouj";

    /**
     * 钉钉应用id
     */
    private String agentId = "2613878378";

    /**
     * 钉钉应用key
     */
    private String appKey = "dingg3wi80ddyuzorsin";

    /**
     * 流程模板code
     */
    private String processCode = "PROC-74820311-D2F2-4111-AD85-82CAF722A927";

    /**
     * 钉钉应用
     */
    private String appSecret = "GC4yWJqqM1rdTMl65uMdERGWhj9fDmThs1TaseL5rRlouafLu5GVWCwvPLXSY9bV";

    @Resource
    private SysUserService sysUserService;

    /**
     * 测试使用接口
     *
     * @return
     */
    @PostMapping("getUser")
    public AjaxResult getById() {
        List<SysUser> page = sysUserService.getBaseMapper().selectList(Wrappers.lambdaQuery());
        return AjaxResult.success(page);
    }

    /**
     * 订阅流程事件
     *
     * @param msgSignature 签名
     * @param timeStamp    时间
     * @param nonce        生成参数
     * @param json         参数
     * @return
     * @throws DingCallbackCrypto.DingTalkEncryptException
     */
    @PostMapping("dealData")
    public Map<String, String> dealData(@RequestParam(value = "msg_signature", required = false) String msgSignature,
                                        @RequestParam(value = "timestamp", required = false) String timeStamp,
                                        @RequestParam(value = "nonce", required = false) String nonce,
                                        @RequestBody(required = false) JSONObject json) throws DingCallbackCrypto.DingTalkEncryptException {
        // 1. 从http请求中获取加解密参数
        String encrypt = json.getString("encrypt");

        // 2. 使用加解密类型
        DingCallbackCrypto callbackCrypto = new DingCallbackCrypto(token, aesKey, corpId);
        final String decryptMsg = callbackCrypto.getDecryptMsg(msgSignature, timeStamp, nonce, encrypt);

        // 3. 反序列化回调事件json数据
        JSONObject eventJson = JSON.parseObject(decryptMsg);
        String eventType = eventJson.getString("EventType");
        // 4. 根据EventType分类处理
        if ("check_url".equals(eventType)) {
            System.out.println("check_url");
            // 测试回调url的正确性
        } else if ("user_add_org".equals(eventType)) {
            System.out.println("user_add_org");
            // 处理通讯录用户增加时间
        } else if ("bpms_task_change".equals(eventType)) {
            System.out.println("bpms_task_change");
            // 处理审批实例变更（审批任务开始、结束、转交）
        } else if ("bpms_instance_change".equals(eventType)) {
            System.out.println("bpms_instance_change");
            String type = eventJson.getString("type");
            if ("finish".equals(type)) {
                // 处理审批实例始末（审批任务开始、结束）
                // 存入数据库
                String businessId = eventJson.getString("businessId");
                System.out.println("审批编号" + businessId);
            }
        }
        // 5. 返回success的加密数据
        return callbackCrypto.getEncryptedMap("success");
    }

    /**
     * 创建审批流程实例  权限：Workflow.Instance.Write，qyapi_get_member_by_mobile
     */
    @PostMapping("startProcessInstance")
    public void startProcessInstance(@RequestBody DingDingFormEntity dingDingFormEntity) {
        Integer num = dingDingFormEntity.getNum();
        if (Objects.isNull(num)) {
            throw new ServiceException("表单校验失败");
        }
        String url = "https://api.dingtalk.com/v1.0/workflow/processInstances";
        HashMap<Object, Object> formMap = MapUtil.newHashMap();
        formMap.put("microappAgentId", agentId);
        String token = getToken();
        formMap.put("originatorUserId", getUserId(token, "17640252619"));
        formMap.put("processCode", processCode);
        List<Map<String, Object>> paramList = ListUtil.toList();
        HashMap<String, Object> hashMap = MapUtil.newHashMap();
        hashMap.put("name", "数量");
        hashMap.put("value", num.toString());
        HashMap<String, Object> hashMap2 = MapUtil.newHashMap();
        hashMap2.put("name", "理由");
        hashMap2.put("value", dingDingFormEntity.getReason());
        paramList.add(hashMap);
        paramList.add(hashMap2);
        formMap.put("formComponentValues", paramList);
        List<HashMap<String, List<String>>> approversList = ListUtil.toList();
        System.out.println("token:" + token);
        List<String> phones = dingDingFormEntity.getPhones();
        for (String phone : phones) {
            HashMap<String, List<String>> userId = MapUtil.of("userIds", Collections.singletonList(getUserId(token, phone)));
            approversList.add(userId);
        }
        formMap.put("approvers", approversList);
        HttpResponse execute = HttpRequest.post(url).header("x-acs-dingtalk-access-token", token).body(JSONUtil.toJsonStr(formMap)).execute();
        String body = execute.body();
        System.out.println(body);
    }

    /**
     * 查询审批详情信息
     *
     * @param instanceId 实例id
     */
    @GetMapping("getByInstanceId")
    public void getByInstanceId(@RequestParam String instanceId) {
        String url = "https://api.dingtalk.com/v1.0/workflow/processInstances?processInstanceId={}";
        url = StrUtil.format(url, instanceId);
        HttpResponse execute = HttpRequest.get(url).header("x-acs-dingtalk-access-token", getToken()).execute();
        String body = execute.body();
        cn.hutool.json.JSONObject jsonObject = JSONUtil.parseObj(body);
        String result = jsonObject.getStr("result");
        cn.hutool.json.JSONObject resultJson = JSONUtil.parseObj(result);
        System.out.println(resultJson);
    }

    /**
     * @return 应用的token
     */
    public String getToken() {
        final String url = "https://api.dingtalk.com/v1.0/oauth2/accessToken";
        Map<String, Object> param = MapUtil.newHashMap();
        param.put("appKey", appKey);
        param.put("appSecret", appSecret);
        HttpResponse execute = HttpRequest.post(url).body(JSONUtil.toJsonStr(param)).execute();
        String body = execute.body();
        return JSONUtil.parseObj(body).getStr("accessToken");
    }

    public String getUserId(String token, String phone) {
        final String url = "https://oapi.dingtalk.com/topapi/v2/user/getbymobile?access_token=" + token;
        String body = HttpRequest.post(url).body(JSONUtil.toJsonStr(MapUtil.of("mobile", phone))).execute().body();
        cn.hutool.json.JSONObject jsonObject = JSONUtil.parseObj(body);
        String errmsg = jsonObject.getStr("errmsg");
        if (!"ok".equals(errmsg)) {
            throw new ServiceException(StrUtil.format("用户：{}未授权钉钉应用权限", phone));
        }
        String result = jsonObject.getStr("result");
        return JSONUtil.parseObj(result).getStr("userid");
    }

    public static class DingCallbackCrypto {
        private static final Charset CHARSET = StandardCharsets.UTF_8;
        private static final Base64 base64 = new Base64();
        private byte[] aesKey;
        private String token;
        private String corpId;
        /**
         * ask getPaddingBytes key固定长度
         **/
        private static final Integer AES_ENCODE_KEY_LENGTH = 43;
        /**
         * 加密随机字符串字节长度
         **/
        private static final Integer RANDOM_LENGTH = 16;

        /**
         * 构造函数
         *
         * @param token          钉钉开放平台上，开发者设置的token
         * @param encodingAesKey 钉钉开放台上，开发者设置的EncodingAESKey
         * @param corpId         企业自建应用-事件订阅, 使用appKey
         *                       企业自建应用-注册回调地址, 使用corpId
         *                       第三方企业应用, 使用suiteKey
         * @throws DingTalkEncryptException 执行失败，请查看该异常的错误码和具体的错误信息
         */
        public DingCallbackCrypto(String token, String encodingAesKey, String corpId) throws DingTalkEncryptException {
            if (null == encodingAesKey || encodingAesKey.length() != AES_ENCODE_KEY_LENGTH) {
                throw new DingTalkEncryptException(DingTalkEncryptException.AES_KEY_ILLEGAL);
            }
            this.token = token;
            this.corpId = corpId;
            aesKey = Base64.decodeBase64(encodingAesKey + "=");
        }

        public Map<String, String> getEncryptedMap(String plaintext) throws DingTalkEncryptException {
            return getEncryptedMap(plaintext, System.currentTimeMillis(), Utils.getRandomStr(16));
        }

        /**
         * 将和钉钉开放平台同步的消息体加密,返回加密Map
         *
         * @param plaintext 传递的消息体明文
         * @param timeStamp 时间戳
         * @param nonce     随机字符串
         * @return
         * @throws DingTalkEncryptException
         */
        public Map<String, String> getEncryptedMap(String plaintext, Long timeStamp, String nonce)
                throws DingTalkEncryptException {
            if (null == plaintext) {
                throw new DingTalkEncryptException(DingTalkEncryptException.ENCRYPTION_PLAINTEXT_ILLEGAL);
            }
            if (null == timeStamp) {
                throw new DingTalkEncryptException(DingTalkEncryptException.ENCRYPTION_TIMESTAMP_ILLEGAL);
            }
            if (null == nonce) {
                throw new DingTalkEncryptException(DingTalkEncryptException.ENCRYPTION_NONCE_ILLEGAL);
            }
            // 加密
            String encrypt = encrypt(Utils.getRandomStr(RANDOM_LENGTH), plaintext);
            String signature = getSignature(token, String.valueOf(timeStamp), nonce, encrypt);
            Map<String, String> resultMap = new HashMap<String, String>();
            resultMap.put("msg_signature", signature);
            resultMap.put("encrypt", encrypt);
            resultMap.put("timeStamp", String.valueOf(timeStamp));
            resultMap.put("nonce", nonce);
            return resultMap;
        }

        /**
         * 密文解密
         *
         * @param msgSignature 签名串
         * @param timeStamp    时间戳
         * @param nonce        随机串
         * @param encryptMsg   密文
         * @return 解密后的原文
         * @throws DingTalkEncryptException
         */
        public String getDecryptMsg(String msgSignature, String timeStamp, String nonce, String encryptMsg)
                throws DingTalkEncryptException {
            //校验签名
            String signature = getSignature(token, timeStamp, nonce, encryptMsg);
            if (!signature.equals(msgSignature)) {
                throw new DingTalkEncryptException(DingTalkEncryptException.COMPUTE_SIGNATURE_ERROR);
            }
            // 解密
            String result = decrypt(encryptMsg);
            return result;
        }

        /*
         * 对明文加密.
         * @param text 需要加密的明文
         * @return 加密后base64编码的字符串
         */
        private String encrypt(String random, String plaintext) throws DingTalkEncryptException {
            try {
                byte[] randomBytes = random.getBytes(CHARSET);
                byte[] plainTextBytes = plaintext.getBytes(CHARSET);
                byte[] lengthByte = Utils.int2Bytes(plainTextBytes.length);
                byte[] corpidBytes = corpId.getBytes(CHARSET);
                ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
                byteStream.write(randomBytes);
                byteStream.write(lengthByte);
                byteStream.write(plainTextBytes);
                byteStream.write(corpidBytes);
                byte[] padBytes = PKCS7Padding.getPaddingBytes(byteStream.size());
                byteStream.write(padBytes);
                byte[] unencrypted = byteStream.toByteArray();
                byteStream.close();
                Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
                SecretKeySpec keySpec = new SecretKeySpec(aesKey, "AES");
                IvParameterSpec iv = new IvParameterSpec(aesKey, 0, 16);
                cipher.init(Cipher.ENCRYPT_MODE, keySpec, iv);
                byte[] encrypted = cipher.doFinal(unencrypted);
                String result = base64.encodeToString(encrypted);
                return result;
            } catch (Exception e) {
                throw new DingTalkEncryptException(DingTalkEncryptException.COMPUTE_ENCRYPT_TEXT_ERROR);
            }
        }

        /*
         * 对密文进行解密.
         * @param text 需要解密的密文
         * @return 解密得到的明文
         */
        private String decrypt(String text) throws DingTalkEncryptException {
            byte[] originalArr;
            try {
                // 设置解密模式为AES的CBC模式
                Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
                SecretKeySpec keySpec = new SecretKeySpec(aesKey, "AES");
                IvParameterSpec iv = new IvParameterSpec(Arrays.copyOfRange(aesKey, 0, 16));
                cipher.init(Cipher.DECRYPT_MODE, keySpec, iv);
                // 使用BASE64对密文进行解码
                byte[] encrypted = Base64.decodeBase64(text);
                // 解密
                originalArr = cipher.doFinal(encrypted);
            } catch (Exception e) {
                throw new DingTalkEncryptException(DingTalkEncryptException.COMPUTE_DECRYPT_TEXT_ERROR);
            }

            String plainText;
            String fromCorpid;
            try {
                // 去除补位字符
                byte[] bytes = PKCS7Padding.removePaddingBytes(originalArr);
                // 分离16位随机字符串,网络字节序和corpId
                byte[] networkOrder = Arrays.copyOfRange(bytes, 16, 20);
                int plainTextLegth = Utils.bytes2int(networkOrder);
                plainText = new String(Arrays.copyOfRange(bytes, 20, 20 + plainTextLegth), CHARSET);
                fromCorpid = new String(Arrays.copyOfRange(bytes, 20 + plainTextLegth, bytes.length), CHARSET);
            } catch (Exception e) {
                throw new DingTalkEncryptException(DingTalkEncryptException.COMPUTE_DECRYPT_TEXT_LENGTH_ERROR);
            }

            // corpid不相同的情况
            if (!fromCorpid.equals(corpId)) {
                throw new DingTalkEncryptException(DingTalkEncryptException.COMPUTE_DECRYPT_TEXT_CORPID_ERROR);
            }
            return plainText;
        }

        /**
         * 数字签名
         *
         * @param token     isv token
         * @param timestamp 时间戳
         * @param nonce     随机串
         * @param encrypt   加密文本
         * @return
         * @throws DingTalkEncryptException
         */
        public String getSignature(String token, String timestamp, String nonce, String encrypt)
                throws DingTalkEncryptException {
            try {
                String[] array = new String[]{token, timestamp, nonce, encrypt};
                Arrays.sort(array);
                System.out.println(JSON.toJSONString(array));
                StringBuffer sb = new StringBuffer();
                for (int i = 0; i < 4; i++) {
                    sb.append(array[i]);
                }
                String str = sb.toString();
                System.out.println(str);
                MessageDigest md = MessageDigest.getInstance("SHA-1");
                md.update(str.getBytes());
                byte[] digest = md.digest();

                StringBuffer hexstr = new StringBuffer();
                String shaHex = "";
                for (int i = 0; i < digest.length; i++) {
                    shaHex = Integer.toHexString(digest[i] & 0xFF);
                    if (shaHex.length() < 2) {
                        hexstr.append(0);
                    }
                    hexstr.append(shaHex);
                }
                return hexstr.toString();
            } catch (Exception e) {
                throw new DingTalkEncryptException(DingTalkEncryptException.COMPUTE_SIGNATURE_ERROR);
            }
        }

        public static class Utils {
            public Utils() {
            }

            public static String getRandomStr(int count) {
                String base = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
                Random random = new Random();
                StringBuffer sb = new StringBuffer();

                for (int i = 0; i < count; ++i) {
                    int number = random.nextInt(base.length());
                    sb.append(base.charAt(number));
                }

                return sb.toString();
            }

            public static byte[] int2Bytes(int count) {
                byte[] byteArr = new byte[]{(byte) (count >> 24 & 255), (byte) (count >> 16 & 255), (byte) (count >> 8 & 255),
                        (byte) (count & 255)};
                return byteArr;
            }

            public static int bytes2int(byte[] byteArr) {
                int count = 0;

                for (int i = 0; i < 4; ++i) {
                    count <<= 8;
                    count |= byteArr[i] & 255;
                }

                return count;
            }
        }

        public static class PKCS7Padding {
            private static final Charset CHARSET = Charset.forName("utf-8");
            private static final int BLOCK_SIZE = 32;

            public PKCS7Padding() {
            }

            public static byte[] getPaddingBytes(int count) {
                int amountToPad = 32 - count % 32;
                if (amountToPad == 0) {
                    amountToPad = 32;
                }

                char padChr = chr(amountToPad);
                String tmp = new String();

                for (int index = 0; index < amountToPad; ++index) {
                    tmp = tmp + padChr;
                }

                return tmp.getBytes(CHARSET);
            }

            public static byte[] removePaddingBytes(byte[] decrypted) {
                int pad = decrypted[decrypted.length - 1];
                if (pad < 1 || pad > 32) {
                    pad = 0;
                }

                return Arrays.copyOfRange(decrypted, 0, decrypted.length - pad);
            }

            private static char chr(int a) {
                byte target = (byte) (a & 255);
                return (char) target;
            }
        }

        public static class DingTalkEncryptException extends Exception {
            public static final int SUCCESS = 0;
            public static final int ENCRYPTION_PLAINTEXT_ILLEGAL = 900001;
            public static final int ENCRYPTION_TIMESTAMP_ILLEGAL = 900002;
            public static final int ENCRYPTION_NONCE_ILLEGAL = 900003;
            public static final int AES_KEY_ILLEGAL = 900004;
            public static final int SIGNATURE_NOT_MATCH = 900005;
            public static final int COMPUTE_SIGNATURE_ERROR = 900006;
            public static final int COMPUTE_ENCRYPT_TEXT_ERROR = 900007;
            public static final int COMPUTE_DECRYPT_TEXT_ERROR = 900008;
            public static final int COMPUTE_DECRYPT_TEXT_LENGTH_ERROR = 900009;
            public static final int COMPUTE_DECRYPT_TEXT_CORPID_ERROR = 900010;
            private static Map<Integer, String> msgMap = new HashMap();
            private Integer code;

            static {
                msgMap.put(0, "成功");
                msgMap.put(900001, "加密明文文本非法");
                msgMap.put(900002, "加密时间戳参数非法");
                msgMap.put(900003, "加密随机字符串参数非法");
                msgMap.put(900005, "签名不匹配");
                msgMap.put(900006, "签名计算失败");
                msgMap.put(900004, "不合法的aes key");
                msgMap.put(900007, "计算加密文字错误");
                msgMap.put(900008, "计算解密文字错误");
                msgMap.put(900009, "计算解密文字长度不匹配");
                msgMap.put(900010, "计算解密文字corpid不匹配");
            }

            public Integer getCode() {
                return this.code;
            }

            public DingTalkEncryptException(Integer exceptionCode) {
                super((String) msgMap.get(exceptionCode));
                this.code = exceptionCode;
            }
        }

        static {
            try {
                Security.setProperty("crypto.policy", "limited");
                RemoveCryptographyRestrictions();
            } catch (Exception var1) {
            }

        }

        private static void RemoveCryptographyRestrictions() throws Exception {
            Class<?> jceSecurity = getClazz("javax.crypto.JceSecurity");
            Class<?> cryptoPermissions = getClazz("javax.crypto.CryptoPermissions");
            Class<?> cryptoAllPermission = getClazz("javax.crypto.CryptoAllPermission");
            if (jceSecurity != null) {
                setFinalStaticValue(jceSecurity, "isRestricted", false);
                PermissionCollection defaultPolicy = (PermissionCollection) getFieldValue(jceSecurity, "defaultPolicy", (Object) null, PermissionCollection.class);
                if (cryptoPermissions != null) {
                    Map<?, ?> map = (Map) getFieldValue(cryptoPermissions, "perms", defaultPolicy, Map.class);
                    map.clear();
                }

                if (cryptoAllPermission != null) {
                    Permission permission = (Permission) getFieldValue(cryptoAllPermission, "INSTANCE", (Object) null, Permission.class);
                    defaultPolicy.add(permission);
                }
            }

        }

        private static Class<?> getClazz(String className) {
            Class clazz = null;

            try {
                clazz = Class.forName(className);
            } catch (Exception var3) {
            }

            return clazz;
        }

        private static void setFinalStaticValue(Class<?> srcClazz, String fieldName, Object newValue) throws Exception {
            Field field = srcClazz.getDeclaredField(fieldName);
            field.setAccessible(true);
            Field modifiersField = Field.class.getDeclaredField("modifiers");
            modifiersField.setAccessible(true);
            modifiersField.setInt(field, field.getModifiers() & -17);
            field.set((Object) null, newValue);
        }

        private static <T> T getFieldValue(Class<?> srcClazz, String fieldName, Object owner, Class<T> dstClazz) throws Exception {
            Field field = srcClazz.getDeclaredField(fieldName);
            field.setAccessible(true);
            return dstClazz.cast(field.get(owner));
        }
    }

    @Getter
    @Setter
    public static class DingDingFormEntity {

        private List<String> phones;

        private Integer num;

        private String reason;
    }

}

参考资料
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
https://open-dev.dingtalk.com
https://open-dev.dingtalk.com/apiExplorer
能找到我这篇博客的网友应该已经费了很多心思，代码里的参数，应该不用我写的那么详细就能找到了，如果实在找不到可以给我留言，在下边追加

devotemyself
关注
  • 7
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
基于vue实现钉钉审批流程(仿)
jiey0407的博客
03-02 5882
做项目有个需求——实现审批流程，看了钉钉审批流感觉功能很强大，模仿其实现审批效果。 效果图 没有找到windows录制视频转gif的软件,所以只能放一张静图了，有好的软件欢迎各位积极分享。 代码位置 整个流程上传至github:https://github.com/ylqymm/workFlow 步骤 初始化 workFlow.vue: <div class="approval-flow fd-nav-content"> <div class="dingflow-desig
钉钉获取审批java_打造钉钉事件分发平台之钉钉审批等事件处理
weixin_36118025的博客
02-28 1550
基于apache flink的流处理实时模型44元包邮(需用券)去购买 >前言上讲和上上讲我们说到了钉钉的审批和钉钉通讯录的一个简单示例，这次我们讲下如何快速打造一个自己的钉钉事件分发平台。让你能够通过监听用户在钉钉上的操作，然后进行对应的业务处理，比如钉钉流程审批完后业务处理、通讯录员工增加后对应自己系统的业务处理等等为什么要做一套自己的钉钉事件分发平台?之前我们讲过通过钉钉提供的通讯录接...
C#对接钉钉OA审批流程
03-26
C#对接钉钉OA审批流程，业务系统发布消息后，自动同步到钉钉，也可以把文件发送给个人
Java对接钉钉事件订阅（审批事件）
Levi_Wu的博客
07-07 4246
文章目录前言需求总体流程实现写在最后 前言 项目中刚好涉及到了需要对接钉钉事件订阅（审批事件），谨以此篇博客和大家分享下。 需求 需要把钉钉每次发起请假流程审批的数据存入数据库。 总体流程 钉钉发起请假申请 -> 钉钉服务器把消息推送给我们项目服务器 -> 我们项目服务器解析入库 实现 钉钉接口文档地址：传送门 一、搭建本地测试服务 因为需要解析钉钉服务器发起的请求，编写一个控制器 DealDingTalkDataController.class @Slf4j @RestController @
【打造高效工作流程】 - DingFlow：您的智能审批助手！
gitblog_00044的博客
06-15 253
????【打造高效工作流程】???? - DingFlow：您的智能审批助手！ 项目地址:https://gitcode.com/codebdy/dingflow 在数字化转型的浪潮下，企业对于流程自动化的需求日益增长。DingFlow应运而生，它不仅仅是一个基于React构建的审批流应用，更是为企业提供了一套完整的解决方案，让工作流程变得更加透明和高效。 项目介绍 DingFlow 是一个模拟钉钉审批流程的...
钉钉审批实例解析工具类
wyz0923的博客
12-29 542
这是一个解析钉钉审批模版，提取用户输入数据 并转为实现类的工具类
java提交钉钉审批的一个流程例子
宁波阿成的博客
06-02 3553
这个例子通过自己定义流程，根据钉钉定义的流程表单来实现
创建钉钉审批流实例
秋风未动蝉先觉
04-19 549
Java创建钉钉审批实例
钉钉发起实例审批php,钉钉C#发起审批实例demo
weixin_34902131的博客
04-16 668
钉钉C#发起审批实例demo钉钉上只有JAVA的demo，虽然也提供了.net的SDK，但是那资料又臭又长，看的头都大了，这是c#的服务端发起审批的demo，亲测有效IDingTalkClient client = new DefaultDingTalkClient("https://eco.taobao.com/router/rest");SmartworkBpmsProcessinstance...
Java 发起带有附件的钉钉审批流
hsadfdsahfdsgfds的博客
01-03 823
不久前接了一个需求，如图:看似只是个上传文件功能，然而可把我给痛疼的 钉钉服务端API发起带有附件的审批流文档链接 ： 按照文档一步一步来，不要急https://open.dingtalk.com/document/orgapp/initiate-an-approval-flow-with-attachments 文档就不带着看了，直接上代码吧 1.POM 依赖 <dependency> <groupId>com.aliyun</groupId&g
真正的国产工作流引擎、json 格式实例模型、仿钉钉审批流程设计器
11-08
真正的国产工作流引擎、json 格式实例模型、仿钉钉审批流程设计器。
钉钉获取oa审批记录的方法
07-04
数据库设计时，通常会为每个审批实例创建一条记录，字段包括审批ID、发起人、审批时间、审批结果、审批流程等。同时，为了方便查询和分析，可能还会创建一些索引，例如针对审批时间的索引，以便快速检索某个时间段内...
钉钉对接Java demo
03-29
【钉钉对接Java demo】是基于Java编程语言实现的一个示例项目，主要目的是演示如何将企业级通讯工具钉钉与自定义的业务系统进行有效集成。这个demo涵盖了多个关键知识点，包括API调用、OAuth2.0授权机制、消息推送...
接入发送钉钉的demo
11-27
一个接入钉钉的通知小demo，可以直接拿去用，把里面的jar包传私服上，pom文件添加下，配置下自己的dingding.properties，里面的参数直接看代码吧，参数找你们企业钉钉管理员要。可以调用里面的方法先获取所有的部门...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 436
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 1133
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 236
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 606
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
java发起钉钉审批
10-17
可以使用钉钉开放平台提供的审批API来实现Java发起钉钉审批的功能。具体步骤如下： 1. 在钉钉开放平台创建自己的应用，并获取应用的AppKey和AppSecret。 2. 获取企业内部应用的access_token，用于调用企业内部接口。 3. 构造审批实例，包括审批流程、审批人、抄送人等信息。 4. 调用审批API发起审批请求。 以下是Java代码示例： ``` // 获取access_token String appKey = "your_app_key"; String appSecret = "your_app_secret"; String accessTokenUrl = "https://oapi.dingtalk.com/gettoken?appkey=" + appKey + "&appsecret=" + appSecret; String accessToken = HttpUtil.get(accessTokenUrl).getJSONObject("access_token"); // 构造审批实例 JSONObject processInstance = new JSONObject(); processInstance.put("process_code", "your_process_code"); processInstance.put("originator_user_id", "your_user_id"); processInstance.put("dept_id", "your_dept_id"); processInstance.put("approvers", "[{\"userid\":\"user1\"},{\"userid\":\"user2\"}]"); processInstance.put("cc_list", "[{\"userid\":\"user3\"},{\"userid\":\"user4\"}]"); processInstance.put("form_component_values", "[{\"name\":\"field1\",\"value\":\"value1\"},{\"name\":\"field2\",\"value\":\"value2\"}]"); // 发起审批请求 String createProcessInstanceUrl = "https://oapi.dingtalk.com/topapi/processinstance/create?access_token=" + accessToken; JSONObject result = HttpUtil.post(createProcessInstanceUrl, processInstance); ```
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值