C#获取钉钉部门

获取钉钉的信息，需要许多请求，也就有许多URL，所以在项目新建一个类，保存所有用到的URL。

namespace DDHelper
{
    public sealed class Urls
    {
        /// <summary>
        /// 创建会话
        /// </summary>
        public const string chat_create="https://oapi.dingtalk.com/chat/create";

        /// <summary>
        /// 获取会话信息
        /// </summary>
        public const string chat_get="https://oapi.dingtalk.com/chat/get";

        /// <summary>
        /// 发送会话消息
        /// </summary>
        public const string chat_send="https://oapi.dingtalk.com/chat/send";

        /// <summary>
        /// 更新会话消息
        /// </summary>
        public const string chat_update="https://oapi.dingtalk.com/chat/update";
        
        /// <summary>
        /// 获取部门列表
        /// </summary>
        public const string department_list="https://oapi.dingtalk.com/department/list";

        /// <summary>
        /// 根据部门ID获取部门下人员信息
        /// </summary>
        public const string department_user="https://oapi.dingtalk.com/user/simplelist";

        /// <summary>
        /// 获取访问票记
        /// </summary>
        public const string gettoken="https://oapi.dingtalk.com/gettoken";

        /// <summary>
        /// 发送消息
        /// </summary>
        public const string message_send="https://oapi.dingtalk.com/message/send";

        /// <summary>
        /// 用户列表
        /// </summary>
        public const string user_list="https://oapi.dingtalk.com/user/list";

        /// <summary>
        /// 用户详情
        /// </summary>
        public const string user_get="https://oapi.dingtalk.com/user/get";

        /// <summary>
        /// 获取JSAPI的票据
        /// </summary>
        public const string get_jsapi_ticket="https://oapi.dingtalk.com/get_jsapi_ticket";

        /// <summary>
        /// 发起审批
        /// </summary>
        public const string get_Examination_and_approval="https://eco.taobao.com/router/rest";

    }
}

获取Tokan，也需要有接收类：

using System;

namespace DDHelper
{
    /// <summary>
    /// 访问票据
    /// </summary>
    public class AccessToken
    {
        /// <summary>
        /// 票据的值
        /// </summary>
        public string Value
        {
            get; set;
        }

        /// <summary>
        /// 票据的开始时间
        /// </summary>
        public DateTime Begin
        {
            get;
            set;
        } = DateTime . Parse ( "1970-01-01" );
    }
}

为避免URL拼接的时候写错参数，新建一个小字典，保存拼接参数

namespace DDHelper
{
    /// <summary>
    /// Url的Key
    /// </summary>
    public sealed class Keys
    {
        /// <summary>
        /// 企业id
        /// </summary>
        public const string corpid="corpid";   
        /// <summary>
        /// 企业秘钥
        /// </summary>
        public const string corpsecret="corpsecret";
        /// <summary>
        /// 开发者id
        /// </summary>
        public const string departmentID = "departmentID";

        public const string userid = "userid";

        public const string chatid = "chatid";

        public const string access_token = "access_token";

        public const string jsapi_ticket = "jsapi_ticket";

        public const string noncestr = "noncestr";

        public const string timestamp = "timestamp";

        public const string url = "url";
    }
}

先获取Token

/// <summary>
        /// 获取token
        /// </summary>
        /// <param name="forced"></param>
        private static void UpdateAccessToken (bool forced = false )
        {
            //ConstVars.CACHE_TIME是缓存时间(常量，也可放到配置文件中)，这样在有效期内则直接从缓存中获取票据，不需要再向服务器中获取。
            if ( !forced && AccessToken . Begin . AddSeconds ( ConstVars . CACHE_TIME ) >= DateTime . Now )
            {
                return;
            }

            string apiurl = $"{Urls.gettoken}?{DDHelper . Keys . corpid}={AppSetting.corpid}&{DDHelper . Keys . corpsecret}={ AppSetting.corpsecret}";
            TokenResult tokenResult = Analyze . Get<TokenResult> ( apiurl );

            if ( tokenResult . ErrCode == ErrCodeEnum . OK )
            {
                AccessToken . Value = tokenResult . Access_token;
                AccessToken . Begin = DateTime . Now;
            }
        }

接受获取的Token，需要一个类：

namespace DDHelper
{
    public class ResultPackage
    {
        public ErrCodeEnum ErrCode
        {
            get; set;
        } = ErrCodeEnum . Unknown;

        /// <summary>
        /// 错误消息
        /// </summary>
        public string ErrMsg
        {
            get; set;
        }

        /// <summary>
        /// 结果的Json形式
        /// </summary>
        public string Json
        {
            get;
            set;
        }

        public bool IsOK ( )
        {
            return ErrCode == ErrCodeEnum . OK;
        }

        public override string ToString ( )
        {
            string info = $"{nameof ( ErrCode )}:{ErrCode},{nameof ( ErrMsg )}:{ErrMsg}";

            return info;
        }

    }
}

namespace DDHelper
{
    public class TokenResult :ResultPackage
    {
        public string Access_token
        {
            get; set;
        }
    }
}

封装GET、POST请求的方法：

using System . Collections . Generic;
using System . IO;
using System . Net;
using System . Text;

namespace DDHelper
{
    public class RequestHelper
    {
        /// <summary>
        /// 执行基本的命令方法,以GET方法
        /// </summary>
        /// <param name="apiurl"></param>
        /// <returns></returns>
        public static string Get ( string apiurl )
        {
            WebRequest request = WebRequest . Create ( @apiurl );
            request . Method = "GET";
            WebResponse response = request . GetResponse ( );
            Stream stream = response . GetResponseStream ( );
            Encoding encode = Encoding . UTF8;
            StreamReader reader = new StreamReader ( stream ,encode );
            string resultJson = reader . ReadToEnd ( );
            return resultJson;
        }

        /// <summary>
        /// 以post方式提交命令
        /// </summary>
        /// <param name="apiurl"></param>
        /// <param name="jsonString"></param>
        /// <returns></returns>
        public static string Post ( string apiurl ,string jsonString )
        {
            WebRequest requset = WebRequest . Create ( @apiurl );
            requset . Method = "POST";
            requset . ContentType = "application/json";

            byte [ ] bs = Encoding . UTF8 . GetBytes ( jsonString );
            requset . ContentLength = bs . Length;
            Stream newStream = requset . GetRequestStream ( );
            newStream . Write ( bs ,0 ,bs . Length );
            newStream . Close ( );

            WebResponse response = requset . GetResponse ( );
            Stream stream = response . GetResponseStream ( );
            Encoding encode = Encoding . UTF8;
            StreamReader reader = new StreamReader ( stream ,encode );
            string resultJson = reader . ReadToEnd ( );
            return resultJson;
        }

        /// <summary>
        /// 以POST方式提交机器人消息
        /// </summary>
        /// <param name="apiurl">请求的URL</param>
        /// <param name="jsonString">请求的json参数</param>
        /// <param name="headers">请求的key-value字典</param>
        /// <returns></returns>
        public static string Post ( string apiurl ,string jsonString ,Dictionary<string ,string> headers = null )
        {
            WebRequest request = WebRequest . Create ( @apiurl );
            request . Method = "POST";
            request . ContentType = "application/json";
            if ( headers != null )
            {
                foreach ( var keyValue in headers )
                {
                    if ( keyValue . Key == "Content-Type" )
                    {
                        request . ContentType = keyValue . Value;
                        continue;
                    }
                    request . Headers . Add ( keyValue . Key ,keyValue . Value );
                }
            }

            if ( string . IsNullOrEmpty ( jsonString ) )
            {
                request . ContentLength = 0;
            }
            else
            {
                byte [ ] bs = Encoding . UTF8 . GetBytes ( jsonString );
                request . ContentLength = bs . Length;
                Stream newStream = request . GetRequestStream ( );
                newStream . Write ( bs ,0 ,bs . Length );
                newStream . Close ( );
            }

            WebResponse response = request . GetResponse ( );
            Stream stream = response . GetResponseStream ( );
            Encoding encode = Encoding . UTF8;
            StreamReader reader = new StreamReader ( stream ,encode );
            string resultJson = reader . ReadToEnd ( );
            return resultJson;
        }
    }
}

将接收的json串，转成我们需要的类，方便处理：
 

using Newtonsoft . Json;
using System;
using System . Collections . Generic;
using System . IO;
using System . Xml;
using System . Xml . Serialization;

namespace DDHelper
{
    public class XmlUtil
    {

        /// <summary>
        /// 反序列化
        /// </summary>
        /// <param name="type"></param>
        /// <param name="xml"></param>
        /// <returns></returns>
        public static object Deserialize ( Type type ,string xml )
        {
            try
            {
                using ( StringReader sr = new StringReader ( xml ) )
                {
                    XmlSerializer xmldes = new XmlSerializer ( type );
                    return xmldes . Deserialize ( sr );
                }
            }
            catch ( Exception ex )
            {
                throw new Exception ( ex . Message );
            }
        }

        /// <summary>
        /// 反序列化
        /// </summary>
        /// <param name="type"></param>
        /// <param name="stream"></param>
        /// <returns></returns>
        public static object Deserialize ( Type type ,Stream stream )
        {
            XmlSerializer xmldex = new XmlSerializer ( type );
            return xmldex . Deserialize ( stream );
        }

        /// <summary>
        /// 序列化
        /// </summary>
        /// <param name="type"></param>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static string Serializer ( Type type ,object obj )
        {
            MemoryStream stream = new MemoryStream ( );
            XmlSerializer xml = new XmlSerializer ( type );
            try
            {
                //序列化对象
                xml . Serialize ( stream ,obj );
            }
            catch ( Exception )
            {
                throw;
            }
            stream . Position = 0;
            StreamReader sr = new StreamReader ( stream );
            string str = sr . ReadToEnd ( );

            sr . Dispose ( );
            stream . Dispose ( );

            return str;
        }

        /// <summary>
        /// 读取xml,得到发送审批结果
        /// </summary>
        /// <param name="xml"></param>
        /// <returns></returns>
        public static ApprovalResult ReadXmlToApprovalResult ( string xml )
        {
            XmlDocument xmlDoc = new XmlDocument ( );
            xmlDoc . LoadXml ( xml );
            XmlNodeList xn = xmlDoc . SelectNodes ( "//result" );
            ApprovalResult appResu = new ApprovalResult ( );
            foreach ( XmlElement element in xn )
            {
                appResu . ding_open_errcode = Convert . ToInt32 ( element . GetElementsByTagName ( "ding_open_errcode" ) [ 0 ] . InnerText );
                appResu . request_id = string . Empty;
                appResu . is_success = Convert . ToBoolean ( element . GetElementsByTagName ( "is_success" ) [ 0 ] . InnerText );
                appResu . process_instance_id = element . GetElementsByTagName ( "process_instance_id" ) [ 0 ] . InnerText;
            }
            return appResu;
        }

        /// <summary>
        /// 读取xml,得到审批结果信息
        /// </summary>
        /// <param name="xml"></param>
        /// <returns></returns>
        public static List<ApprovalReceiveResult> ReadXmlToApprovalReceiveResult ( string xml )
        {
            XmlDocument xmlDoc = new XmlDocument ( );
            xmlDoc . LoadXml ( xml );
            XmlNodeList xn = xmlDoc . SelectNodes ( "//operation_records_vo" );
            List<ApprovalReceiveResult> listApp = new List<ApprovalReceiveResult> ( );

            foreach ( XmlElement element in xn )
            {
                ApprovalReceiveResult appResu = new ApprovalReceiveResult ( );
                appResu . Date = Convert . ToDateTime ( element . GetElementsByTagName ( "date" ) [ 0 ] . InnerText );
                appResu . OperationResult = element . GetElementsByTagName ( "operation_result" ) [ 0 ] . InnerText;
                appResu . OperationType = element . GetElementsByTagName ( "operation_type" ) [ 0 ] . InnerText;
                if ( element . ChildNodes . Count > 4 && element . ChildNodes . Item ( 3 ) . Name . Equals ( "remark" ) )
                    appResu . Remark = element . GetElementsByTagName ( "remark" ) [ 0 ] . InnerText;
                else
                    appResu . Remark = string . Empty;
                appResu . OperationUser = element . GetElementsByTagName ( "userid" ) [ 0 ] . InnerText;
                listApp . Add ( appResu );
            }

            return listApp;
        }

        /// <summary>
        /// 把Json转为实体类
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="result"></param>
        /// <returns></returns>
        public static List<T> JsonStringToObj<T> ( string result ) where T : class
        {
            List<T> list = new List<T> ( );
            T t = JsonConvert . DeserializeObject<T> ( result );
            list . Add ( t );
            return list;
        }

    }
}

using System . Collections . Generic;
using Newtonsoft . Json;

namespace DDHelper
{
    public class Analyze
    {
        
        /// <summary>
        /// GET请求
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="requestUrl"></param>
        /// <returns></returns>
        public static T Get<T> ( string requestUrl ) where T : ResultPackage, new()
        {
            string resultJson = RequestHelper . Get ( requestUrl );
            return AnalyzeResult<T> ( resultJson );
        }

        /// <summary>
        /// POST请求
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="requestUrl"></param>
        /// <param name="requestParamOfJsonStr"></param>
        /// <returns></returns>
        public static T POST<T> ( string requestUrl ,string requestParamOfJsonStr ) where T : ResultPackage, new()
        {
            string resultJson = RequestHelper . Post ( requestUrl ,requestParamOfJsonStr );
            return AnalyzeResult<T> ( resultJson );
        }

        /// <summary>
        /// 分析结果
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="resultJson"></param>
        /// <returns></returns>
        public static T AnalyzeResult<T> ( string resultJson ) where T : ResultPackage, new()
        {
            ResultPackage tempResult = null;
            if ( !string . IsNullOrEmpty ( resultJson ) )
            {
                tempResult = JsonConvert . DeserializeObject<ResultPackage> ( resultJson );
            }
            T result = null;
            if ( tempResult != null && tempResult . IsOK ( ) )
            {
                result = JsonConvert . DeserializeObject<T> ( resultJson );
            }
            else if ( tempResult != null )
            {
                result = tempResult as T;
            }
            else if ( tempResult == null )
            {
                result = new T ( );
            }

            result . Json = resultJson;
            return result;
        }

        /// <summary>
        /// POST机器人请求
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="apiurl"></param>
        /// <param name="jsonString"></param>
        /// <param name="headers"></param>
        /// <returns></returns>
        public static T POST<T> ( string apiurl ,string jsonString ,Dictionary<string ,string> headers = null ) where T : ResultPackage, new()
        {
            string resultJson = RequestHelper . Post ( apiurl ,jsonString ,headers );
            return AnalyzeResult<T> ( resultJson );
        }

    }
}

上面都是为获取Token，及后面的请求做准备的基础，下面获取Token后，拼接获取部门信息的URL

 /// <summary>
        /// 获取url
        /// </summary>
        /// <param name="Url">url</param>
        /// <param name="forceUpdate"></param>
        /// <returns></returns>
        private static string FormatApiUrlWithToken ( string Url ,bool forceUpdate = false )
        {
            //获取token
            UpdateAccessToken ( forceUpdate );
            string apiurl = $"{Url}?{DDHelper . Keys . access_token}={AccessToken . Value}";

            return apiurl;
        }

得到Token之后，也得到了获取部门的URL，下面就要获取部门信息：

/// <summary>
        /// 获取部门信息并保存
        /// </summary>
        private void getDepartMentInfo ( )
        {
            string apiurl = FormatApiUrlWithToken ( Urls . department_list );
            var result = Analyze . Get<DepartResultSet> ( apiurl );
            List<DepartResultSet> list = XmlUtil . JsonStringToObj<DepartResultSet> ( result . Json );
            if ( list . Count > 0 )
            {
                foreach ( DepartResultSet depart in list )
                {
                    if ( depart . department . Count > 0 )
                    {
                        //保存部门信息到数据库
                        isOk = _bll . SaveDepart ( depart . department );
                        if (isOk == false)
                            break;
                    }
                }
            }

            if ( isOk == false )
            {
                Utility . LogHelper . WriteLog ( "部门信息保存失败" );
            }
        }

上面有一个地方需要注意，部门获取到了，也只是json串，所以需要转成我们要的类(和获取Token请求结果一样，都继承自ResultPackage类)

using System.Collections.Generic;

namespace DDHelper
{
    public class DepartResultSet :ResultPackage
    {
        public List<Depart> department
        {
            get; set;
        }
    }
}

namespace DDHelper
{
    public class Depart
    {
        /// <summary>
        /// 部门id
        /// </summary>
        public string id
        {
            get; set;
        }
        
        /// <summary>
        /// 部门名称
        /// </summary>
        public string name
        {
            get; set;
        }

        /// <summary>
        /// 父部门id，根部门为1 
        /// </summary>
        public string parentId
        {
            get; set;
        }

        /// <summary>
        /// 是否同步创建一个关联此部门的企业群, true表示是, false表示不是  
        /// </summary>
        public bool createDeptGroup
        {
            get; set;
        }

        /// <summary>  
        /// 当群已经创建后，是否有新人加入部门会自动加入该群, true表示是, false表示不是  
        /// </summary>  
        public bool autoAddUser
        {
            get; set;
        }

    }
}

到此处，部门信息就获取到了，也保存到后台了，需要的基础类基本都有了，后面获取其它信息就不用再建基础类了

来源：CSDN

作者：独孤薄荷

链接：https://blog.csdn.net/u011871201/article/details/103733375