C#本地應用向釘釘推送信息並在釘釘上創建審批流完成審批

1.創建應用（https://open.dingtalk.com/document/isv/create-isvapp）
2.VS2019創建WEB API項目並部署到公網可以訪問的IIS上

Nuget安裝System.Text.Json;

using System.Net.Http;
using System.Text;
using System.Web.Http;

namespace Multek.DingTalkService.WebApi.Controllers
{
    [RoutePrefix("api/AppEvent")]
    public class AppEventController : ApiController
    {
        //public IHttpActionResult Post()
        //{
        //    AppService app = new AppService();
        //    var r = app.DingtalkCallback("", "66caf4181a353e39b7c186e923ecaf5c", "MAiNC53WwilSzJYfvyNluAa6UHtV7PBMoeGnWOeBgXt", "1467996111");
        //    var obj = new { success = r };
        //    return Json(obj);
        //}
        [HttpGet]
        public object GetAll()
        {
            return Ok<string>("Success");
        }

        [HttpPost]
        public HttpResponseMessage PostData(int id)
        {
            return Request.CreateResponse();
        }

        [Route("Order/SaveData")]
        [HttpPost]
        public object SaveData()
        {
            var a = "Ben";
            return Ok<string>("Success");
        }

        [Route("Order/DingdingCallback")]
        [HttpPost]
        public HttpResponseMessage DingdingCallback(string signature, string timestamp, string nonce)
        { 
            JeffSoft.Logger.Error("DingdingCallback Success:" + signature + "," + timestamp + "");
            //第一部分
            //這兩句代碼是為了接收body體中傳入的加密json串
            Request.Content.ReadAsStreamAsync().Result.Seek(0, System.IO.SeekOrigin.Begin);
            string content = Request.Content.ReadAsStringAsync().Result;
            //反序列化json串拿去加密字符串
            JToken json = JToken.Parse(content);
            string ever = json["encrypt"].ToString();
            //實例化釘釘解密類構造參數為對應的 應用中的token、aes_key、AppKey值
            DingTalkEncryptor dingTalkEncryptor = new DingTalkEncryptor("896caad7fcfd398abc6b333c6156c769", "MAiNC53WwilSzJYfvyNluAa6UHtV7PBMoeGnWOeBgXt", "dinglqafhlqtb8zreom5");  
            //定義字符串接收解密后的值
            string text = dingTalkEncryptor.getDecryptMsg(signature, timestamp, nonce, ever);
            JeffSoft.Logger.Error("dingTalkEncryptor.getDecryptMsg:" + text + "");
            JToken jToken = JToken.Parse(text);
            //取出事件類型字段
            string EventType = jToken["EventType"].ToString();
            JeffSoft.Logger.Error("DingdingCallback Success,EventType:" + EventType + "");
            //第二部分
            //  { //判斷事件類型是否是日程事件
            if ("bpms_instance_change" == EventType)
            {
                var DDtitle = jToken["title"].ToString();
                var DDresult= jToken["result"].ToString();
                var mes = string.Format("bpms_instance_change Success,title:{0},result:{1}", DDtitle, DDresult);
                JeffSoft.Logger.Error(mes);
            }

            //第三部分
            //返回加密字符串          
            var msg = dingTalkEncryptor.getEncryptedMap("success");
            var msg_signature = msg["msg_signature"];
            var encrypt = msg["encrypt"];
            var timeStamp = msg["timeStamp"];
            var nonce1 = msg["nonce"];
            var v = new
            {
                msg_signature = msg["msg_signature"],
                encrypt = msg["encrypt"],
                timeStamp = msg["timeStamp"],
                nonce = msg["nonce"],
            };
            //var obj = new { success = r };
            //    return Json(obj);
            var data = JsonConvert.SerializeObject(v); 

            //返回json數
            return new HttpResponseMessage()
            {
                Content = new StringContent(data, Encoding.UTF8, "application/json"),
            };
        }
    }
}

DingTalkEncryptor.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Text;
using System.Security.Cryptography;
using System.Text.Json;

namespace DingDingWebAPI.Controllers
{
    /**
    * 釘釘開放平台加解密方法
    */
    public class DingTalkEncryptor
    {
        //private static readonly Charset CHARSET = Charset.forName("utf-8");
        //private static readonly Base64         base64  = new Base64();
        private byte[] aesKey;
        private String token;
        private String corpId;
        /**ask getPaddingBytes key固定長度**/
        private static readonly int AES_ENCODE_KEY_LENGTH = 43;
        /**加密隨機字符串字節長度**/
        private static readonly int RANDOM_LENGTH = 16;

        /**
         * 構造函數
         * @param token            釘釘開放平台上，開發者設置的token
         * @param encodingAesKey   釘釘開放台上，開發者設置的EncodingAESKey
         * @param corpId           企業自建應用-事件訂閱, 使用appKey
         *                         企業自建應用-注冊回調地址, 使用corpId
         *                         第三方企業應用, 使用suiteKey
         *
         * @throws DingTalkEncryptException 執行失敗，請查看該異常的錯誤碼和具體的錯誤信息
         */
        public DingTalkEncryptor(String token, String encodingAesKey, String corpId)
        {
            if (null == encodingAesKey || encodingAesKey.Length != AES_ENCODE_KEY_LENGTH)
            {
                throw new DingTalkEncryptException(DingTalkEncryptException.AES_KEY_ILLEGAL);
            }
            this.token = token;
            this.corpId = corpId;
            aesKey = Convert.FromBase64String(encodingAesKey + "=");
        }

        /**
         * 將和釘釘開放平台同步的消息體加密,返回加密Map
         */
        public Dictionary<String, String> getEncryptedMap(String plaintext)
        {

            var time = DateTime.Now.Millisecond;
            return getEncryptedMap(plaintext, time);
        }

        /**
         * 將和釘釘開放平台同步的消息體加密,返回加密Map
         * @param plaintext     傳遞的消息體明文
         * @param timeStamp      時間戳
         * @param nonce           隨機字符串
         * @return
         * @throws DingTalkEncryptException
         */
        public Dictionary<String, String> getEncryptedMap(String plaintext, long timeStamp)
        {
            if (null == plaintext)
            {
                throw new DingTalkEncryptException(DingTalkEncryptException.ENCRYPTION_PLAINTEXT_ILLEGAL);
            }
            var nonce = Utils.getRandomStr(RANDOM_LENGTH);
            if (null == nonce)
            {
                throw new DingTalkEncryptException(DingTalkEncryptException.ENCRYPTION_NONCE_ILLEGAL);
            }

            String encrypt = this.encrypt(nonce, plaintext);
            String signature = getSignature(token, timeStamp.ToString(), nonce, encrypt);
            Dictionary<String, String> resultMap = new Dictionary<String, String>();
            resultMap["msg_signature"] = signature;
            resultMap["encrypt"] = encrypt;
            resultMap["timeStamp"] = timeStamp.ToString();
            resultMap["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)
        {
            //校驗簽名
            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)
        {
            try
            {
                byte[] randomBytes = System.Text.Encoding.UTF8.GetBytes(random);// random.getBytes(CHARSET);
                byte[] plainTextBytes = System.Text.Encoding.UTF8.GetBytes(plaintext);// plaintext.getBytes(CHARSET);
                byte[] lengthByte = Utils.int2Bytes(plainTextBytes.Length);
                byte[] corpidBytes = System.Text.Encoding.UTF8.GetBytes(corpId);// corpId.getBytes(CHARSET);
                //MemoryStream byteStream = new MemoryStream();
                var bytestmp = new List<byte>();
                bytestmp.AddRange(randomBytes);
                bytestmp.AddRange(lengthByte);
                bytestmp.AddRange(plainTextBytes);
                bytestmp.AddRange(corpidBytes);
                byte[] padBytes = PKCS7Padding.getPaddingBytes(bytestmp.Count);
                bytestmp.AddRange(padBytes);
                byte[] unencrypted = bytestmp.ToArray();

                RijndaelManaged rDel = new RijndaelManaged();
                rDel.Mode = CipherMode.CBC;
                rDel.Padding = PaddingMode.Zeros;
                rDel.Key = aesKey;
                rDel.IV = aesKey.ToList().Take(16).ToArray();
                ICryptoTransform cTransform = rDel.CreateEncryptor();
                byte[] resultArray = cTransform.TransformFinalBlock(unencrypted, 0, unencrypted.Length);
                return Convert.ToBase64String(resultArray, 0, resultArray.Length);


                //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)
        {
            byte[] originalArr;
            try
            {
                byte[] toEncryptArray = Convert.FromBase64String(text);
                RijndaelManaged rDel = new RijndaelManaged();
                rDel.Mode = CipherMode.CBC;
                rDel.Padding = PaddingMode.Zeros;
                rDel.Key = aesKey;
                rDel.IV = aesKey.ToList().Take(16).ToArray();
                ICryptoTransform cTransform = rDel.CreateDecryptor();
                originalArr = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
                //return System.Text.UTF8Encoding.UTF8.GetString(resultArray);

                //// 設置解密模式為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);
                Console.Out.WriteLine("bytes size:" + bytes.Length);

                // 分離16位隨機字符串,網絡字節序和corpId
                byte[] networkOrder = bytes.Skip(16).Take(4).ToArray();// Arrays.copyOfRange(bytes, 16, 20);
                for (int i = 0; i < 4; i++)
                {
                    Console.Out.WriteLine("networkOrder size:" + (int)networkOrder[i]);
                }

                Console.Out.WriteLine("bytes plainText:" + networkOrder.Length + " " + JsonSerializer.Serialize(networkOrder));
                int plainTextLegth = Utils.bytes2int(networkOrder);
                Console.Out.WriteLine("bytes size:" + plainTextLegth);

                plainText = System.Text.UTF8Encoding.UTF8.GetString(bytes.Skip(20).Take(plainTextLegth).ToArray()); // new String(Arrays.copyOfRange(bytes, 20, 20 + plainTextLegth), CHARSET);
                fromCorpid = System.Text.UTF8Encoding.UTF8.GetString(bytes.Skip(20 + plainTextLegth).ToArray()); //new String(Arrays.copyOfRange(bytes, 20 + plainTextLegth, bytes.length), CHARSET);
                Console.Out.WriteLine("bytes plainText:" + plainText);

            }
            catch (Exception e)
            {
                throw new DingTalkEncryptException(DingTalkEncryptException.COMPUTE_DECRYPT_TEXT_LENGTH_ERROR);
            }
            Console.Out.WriteLine(fromCorpid + "=====" + corpId);


            // 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)
        {
            try
            {
                Console.Out.WriteLine(encrypt);

                String[] array = new String[] { token, timestamp, nonce, encrypt };
                Array.Sort(array, StringComparer.Ordinal);
                //var tmparray = array.ToList();
                //tmparray.Sort(new JavaStringComper());
                //array = tmparray.ToArray();
                Console.Out.WriteLine("array:" + JsonSerializer.Serialize(array));
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < 4; i++)
                {
                    sb.Append(array[i]);
                }
                String str = sb.ToString();
                Console.Out.WriteLine(str);
                //MessageDigest md = MessageDigest.getInstance("SHA-1");
                //md.update(str.getBytes());
                //byte[] digest = md.digest();
                System.Security.Cryptography.SHA1 hash = System.Security.Cryptography.SHA1.Create();
                System.Text.Encoding encoder = System.Text.Encoding.ASCII;
                byte[] combined = encoder.GetBytes(str);
                ////byte 轉換
                //sbyte[] myByte = new sbyte[]
                //byte[] mySByte = new byte[myByte.Length];



                //for (int i = 0; i < myByte.Length; i++)

                //{

                //    if (myByte[i] > 127)

                //        mySByte[i] = (sbyte)(myByte[i] - 256);

                //    else

                //        mySByte[i] = (sbyte)myByte[i];

                //}

                byte[] digest = hash.ComputeHash(combined);
                StringBuilder hexstr = new StringBuilder();
                String shaHex = "";
                for (int i = 0; i < digest.Length; i++)
                {
                    shaHex = ((int)digest[i]).ToString("x");// 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 class DingTalkEncryptException : Exception
    {
        /**成功**/
        public static readonly int SUCCESS = 0;
        /**加密明文文本非法**/
        public readonly static int ENCRYPTION_PLAINTEXT_ILLEGAL = 900001;
        /**加密時間戳參數非法**/
        public readonly static int ENCRYPTION_TIMESTAMP_ILLEGAL = 900002;
        /**加密隨機字符串參數非法**/
        public readonly static int ENCRYPTION_NONCE_ILLEGAL = 900003;
        /**不合法的aeskey**/
        public readonly static int AES_KEY_ILLEGAL = 900004;
        /**簽名不匹配**/
        public readonly static int SIGNATURE_NOT_MATCH = 900005;
        /**計算簽名錯誤**/
        public readonly static int COMPUTE_SIGNATURE_ERROR = 900006;
        /**計算加密文字錯誤**/
        public readonly static int COMPUTE_ENCRYPT_TEXT_ERROR = 900007;
        /**計算解密文字錯誤**/
        public readonly static int COMPUTE_DECRYPT_TEXT_ERROR = 900008;
        /**計算解密文字長度不匹配**/
        public readonly static int COMPUTE_DECRYPT_TEXT_LENGTH_ERROR = 900009;
        /**計算解密文字corpid不匹配**/
        public readonly static int COMPUTE_DECRYPT_TEXT_CORPID_ERROR = 900010;

        private static Dictionary<int, String> msgMap = new Dictionary<int, String>();
        static DingTalkEncryptException()
        {
            msgMap[SUCCESS] = "成功";
            msgMap[ENCRYPTION_PLAINTEXT_ILLEGAL] = "加密明文文本非法";
            msgMap[ENCRYPTION_TIMESTAMP_ILLEGAL] = "加密時間戳參數非法";
            msgMap[ENCRYPTION_NONCE_ILLEGAL] = "加密隨機字符串參數非法";
            msgMap[SIGNATURE_NOT_MATCH] = "簽名不匹配";
            msgMap[COMPUTE_SIGNATURE_ERROR] = "簽名計算失敗";
            msgMap[AES_KEY_ILLEGAL] = "不合法的aes key";
            msgMap[COMPUTE_ENCRYPT_TEXT_ERROR] = "計算加密文字錯誤";
            msgMap[COMPUTE_DECRYPT_TEXT_ERROR] = "計算解密文字錯誤";
            msgMap[COMPUTE_DECRYPT_TEXT_LENGTH_ERROR] = "計算解密文字長度不匹配";
            msgMap[COMPUTE_DECRYPT_TEXT_CORPID_ERROR] = "計算解密文字corpid不匹配";
        }

        private int code;
        public DingTalkEncryptException(int exceptionCode) : base(msgMap[exceptionCode])
        {
            this.code = exceptionCode;
        }
    }

    /*
     * PKCS7算法的加密填充
     */
    public class PKCS7Padding
    {
        //private readonly static Charset CHARSET = Charset.forName("utf-8");
        private readonly static int BLOCK_SIZE = 32;

        /**
         * 填充mode字節
         * @param count
         * @return
         */
        public static byte[] getPaddingBytes(int count)
        {
            int amountToPad = BLOCK_SIZE - (count % BLOCK_SIZE);
            if (amountToPad == 0)
            {
                amountToPad = BLOCK_SIZE;
            }
            char padChr = chr(amountToPad);
            String tmp = string.Empty; ;
            for (int index = 0; index < amountToPad; index++)
            {
                tmp += padChr;
            }
            return System.Text.Encoding.UTF8.GetBytes(tmp);
        }

        /**
         * 移除mode填充字節
         * @param decrypted
         * @return
         */
        public static byte[] removePaddingBytes(byte[] decrypted)
        {
            int pad = (int)decrypted[decrypted.Length - 1];
            if (pad < 1 || pad > BLOCK_SIZE)
            {
                pad = 0;
            }
            //Array.Copy()
            var output = new byte[decrypted.Length - pad];
            Array.Copy(decrypted, output, decrypted.Length - pad);
            return output;
        }

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

    }

    /**
 * 加解密工具類
 */
    public class Utils
    {
        /**
     *
     * @return
     */
        public static String getRandomStr(int count)
        {
            String baset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
            Random random = new Random();
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < count; i++)
            {
                int number = random.Next(baset.Length);
                sb.Append(baset[number]);
            }
            return sb.ToString();
        }


        /*
         * int轉byte數組,高位在前
         */
        public static byte[] int2Bytes(int count)
        {
            byte[] byteArr = new byte[4];
            byteArr[3] = (byte)(count & 0xFF);
            byteArr[2] = (byte)(count >> 8 & 0xFF);
            byteArr[1] = (byte)(count >> 16 & 0xFF);
            byteArr[0] = (byte)(count >> 24 & 0xFF);
            return byteArr;
        }

        /**
         * 高位在前bytes數組轉int
         * @param byteArr
         * @return
         */
        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 class JavaStringComper : IComparer<string>
    {
        public int Compare(string x, string y)
        {
            return String.Compare(x, y);
        }
    }


}

3.配置事件訂閱（https://open.dingtalk.com/document/orgapp-server/configure-event-subcription）

4.進入釘釘管理后台(https://oa.dingtalk.com/)創建審批表單模板(https://open.dingtalk.com/document/isvapp-server/create-or-modify-an-approval-form-template)

https://oa.dingtalk.com/  工作台--》應用程序--》OA審批--》進入--》創建

5.發起審批實例（https://open.dingtalk.com/document/orgapp-server/initiate-approval）

得到得到accessToken（https://api.dingtalk.com/v1.0/oauth2/accessToken）

post：

{

    "appKey":"dinglqafhlqtb8zreom5",

    "appSecret":"SE93VaqKzjSoCoyhiPmigPrrZO7J5fR0-efFlsJXg7OrZPiqH6C-LlGX0gy4QpD1"

}

返回

{

    "expireIn": 7200,

    "accessToken": "9015791f471e34aa89804286dee0a1eb"

}

發起審批實例

https://oapi.dingtalk.com/topapi/processinstance/create?access_token=9015791f471e34aa89804286dee0a1eb

POST：

{
"form_component_values": [
{
"name": "單號",
"value": "B1000006"
},
{
"name": "設備編號",
"value": "AOI10002"
},
{
"name": "維修員",
"value": "Ben"
},

],
"agent_id": 1496597138,
"process_code": "PROC-9B39B0F8-C8EA-4401-87A8-4FCBCA0FE13F", //對接審批流的process_code
//"cc_position": "FINISH",
//"approvers": "6526336,8181347",
//"cc_list": "6526336,8181347",
"dept_id": -1,
"approvers_v2": [ //設置審批人，會簽、或簽設置的審批人必須大於等於2個人
{
"task_action_type": "OR",
"user_ids": [
"8181347" ,
"6526336"
]
}

],

"originator_user_id": "8181347"
}