1 /// <summary>
2 /// DnsPod DDNS工具类
3 /// </summary>
4 public class DDNSToolkit
5 {
6 private static string userName = ConfigurationManager.AppSettings["DNSUserName"];
7 private static string password = ConfigurationManager.AppSettings["DNSPassword"];
8 /// <summary>
9 /// 公共参数
10 /// </summary>
11 private object baseParam = new
12 {
13 login_email = userName,//用户帐号，必选
14 login_password = password,//用户密码，必选
15 format = "json",//返回的数据格式，可选，默认为xml，建议用json
16 lang = "cn",//返回的错误语言，可选，默认为en，建议用cn
17 error_on_empty = "no"//没有数据时是否返回错误，可选，默认为yes，建议用no
18 };
19
20 #region 域名相关
21
22 /// <summary>
23 /// Return the domain_Id,when the domains contains more then one entity,returns the first one!
24 /// </summary>
25 /// <returns></returns>
26 public int DomainGetId(string keyword)//获取域名ID
27 {
28 var domainId = -1;
29 if (!string.IsNullOrWhiteSpace(keyword))
30 keyword = "keyword=" + keyword;
31 /*api说明 https://www.dnspod.cn/docs/domains.html#domain-list
32 公共参数
33 type 域名权限种类，可选参数，默认为’all’。包含以下类型：
34 all：所有域名
35 mine：我的域名
36 share：共享给我的域名
37 ismark：星标域名
38 pause：暂停域名
39 vip：VIP域名
40 recent：最近操作过的域名
41 share_out：我共享出去的域名
42 offset 记录开始的偏移，第一条记录为 0，依次类推，可选参数
43 length 共要获取的记录的数量，比如获取20条，则为20，可选参数
44 group_id 分组ID，获取指定分组的域名，可选参数
45 keyword，搜索的关键字，如果指定则只返回符合该关键字的域名，可选参数*/
46 var dataBaseObj = GetDNSApi("https://dnsapi.cn/Domain.List", keyword);
47 if (dataBaseObj != null)
48 {
49 if (dataBaseObj["status"]["code"] == "1")
50 {
51 if (dataBaseObj["domains"].Length > 0)
52 {
53 domainId = Convert.ToInt32(dataBaseObj["domains"][0]["id"]);
54 }
55 }
56 else
57 {
58 throw new ArgumentException(string.Format("DNSPod API：Domain.List调用异常，说明:{0}", dataBaseObj["status"]["message"]));
59 }
60 }
61 return domainId;
62 }
63
64 #endregion
65
66 #region 记录相关
67 /// <summary>
68 /// Get the recordId
69 /// </summary>
70 /// <param name="domainId">domainId</param>
71 /// <param name="subDomain">The name for subDomain</param>
72 /// <returns></returns>
73 public int RecordGetIdBySubdomain(int domainId, string subDomain)//获取记录ID
74 {
75 var recordId = -1;
76 /*api说明 https://www.dnspod.cn/docs/records.html#record-list
77 公共参数
78 domain_id 域名ID，必选
79 offset 记录开始的偏移，第一条记录为 0，依次类推，可选
80 length 共要获取的记录的数量，比如获取20条，则为20，可选
81 sub_domain 子域名，如果指定则只返回此子域名的记录，可选
82 keyword，搜索的关键字，如果指定则只返回符合该关键字的记录，可选*/
83 var dataBaseObj = GetDNSApi("https://dnsapi.cn/Record.List", new { domain_id = domainId, sub_domain = subDomain });
84 if (dataBaseObj != null)
85 {
86 if (dataBaseObj["status"]["code"] == "1")
87 {
88 if (dataBaseObj["records"].Length > 0)
89 {
90 domainId = Convert.ToInt32(dataBaseObj["records"][0]["id"]);
91 }
92 }
93 else
94 {
95 throw new ArgumentException(string.Format("DNSPod API：Record.List调用异常，说明:{0}", dataBaseObj["status"]["message"]));
96 }
97 }
98
99 return recordId;
100 }
101
102 /// <summary>
103 /// Create subdomain record
104 /// </summary>
105 /// <param name="domainId">domainId</param>
106 /// <param name="value">value:IP、CNAME、MX</param>
107 /// <param name="subDomain">subdomain name,like "www",defalut is "@"</param>
108 /// <param name="recordId"></param>
109 /// <returns></returns>
110 public bool RecordCreate(int domainId, string value, string subDomain, out int recordId)//创建记录
111 {
112 recordId = -1;
113 bool flag = false;
114 /*api说明 https://www.dnspod.cn/docs/records.html#record-create
115 公共参数
116 domain_id 域名ID, 必选
117 sub_domain 主机记录, 如 www, 默认@，可选
118 record_type 记录类型，通过API记录类型获得，大写英文，比如：A, 必选
119 record_line 记录线路，通过API记录线路获得，中文，比如：默认, 必选
120 value 记录值, 如 IP:200.200.200.200, CNAME: cname.dnspod.com., MX: mail.dnspod.com., 必选
121 mx {1-20} MX优先级, 当记录类型是 MX 时有效，范围1-20, MX记录必选
122 ttl {1-604800} TTL，范围1-604800，不同等级域名最小值不同, 可选*/
123 var dataBaseObj = GetDNSApi("https://dnsapi.cn/Record.Create", new
124 {
125 domain_id = domainId,
126 sub_domain = subDomain,
127 value = value,
128 record_type = "A",
129 record_line = "默认"
130 });
131 if (dataBaseObj != null)
132 {
133 if (dataBaseObj["status"]["code"] == "1")
134 {
135 flag = true;
136 recordId = Convert.ToInt32(dataBaseObj["record"]["id"]);
137 }
138 else
139 {
140 throw new ArgumentException(string.Format("DNSPod API：Record.Create调用异常，说明:{0}", dataBaseObj["status"]["message"]));
141 }
142 }
143 return flag;
144 }
145 /// <summary>
146 /// 修改记录
147 /// </summary>
148 /// <param name="domainId"></param>
149 /// <param name="recordId"></param>
150 /// <param name="subdomain"></param>
151 /// <param name="value"></param>
152 /// <param name="message"></param>
153 /// <returns></returns>
154 public bool RecordUpdate(int domainId, int recordId, string subdomain, string value, out string message)//修改记录
155 {
156 message = string.Empty;
157 bool flag = false;
158 /*api说明 https://www.dnspod.cn/docs/records.html#record-modify
159 公共参数
160 domain_id 域名ID，必选
161 record_id 记录ID，必选
162 sub_domain 主机记录，默认@，如 www，可选
163 record_type 记录类型，通过API记录类型获得，大写英文，比如：A，必选
164 record_line 记录线路，通过API记录线路获得，中文，比如：默认，必选
165 value 记录值, 如 IP:200.200.200.200, CNAME: cname.dnspod.com., MX: mail.dnspod.com.，必选
166 mx {1-20} MX优先级, 当记录类型是 MX 时有效，范围1-20, mx记录必选
167 ttl {1-604800} TTL，范围1-604800，不同等级域名最小值不同，可选*/
168 var resObj = GetDNSApi("https://dnsapi.cn/Record.Modify", new
169 {
170 domain_id = domainId,
171 record_id = recordId,
172 value = value,
173 sub_domain = subdomain,
174 record_type = "A",
175 record_line = "默认"
176 });
177 if (resObj != null)
178 {
179 if (resObj["status"]["code"] == "1")
180 {
181 /*更新成功，返回记录详情（记录中的各参数）
182 * "record": {
183 * "id":16894439,
184 * "name":"@",
185 * "value":"3.2.2.2",
186 * "status":"enable"
187 * }
188 */
189 message = GetObjectPropertiesString(resObj["record"]);
190 flag = true;
191 }
192 else
193 {
194 message = resObj["status"]["message"];
195 throw new ArgumentException(string.Format("DNSPod API：Record.Modify调用异常，说明:{0}", resObj["status"]["message"]));
196 }
197 }
198 return flag;
199 }
200 /// <summary>
201 /// 设置记录备注
202 /// </summary>
203 /// <param name="domainId">域名ID</param>
204 /// <param name="recordId">记录ID</param>
205 /// <param name="remark">备注信息</param>
206 /// <returns></returns>
207 public bool RecordRemark(int domainId, int recordId, string remark = "")//设置记录备注
208 {
209 bool flag = false;
210 var resObj = GetDNSApi("https://dnsapi.cn/Record.Remark", new
211 {
212 domain_id = domainId,
213 record_id = recordId,
214 remark = remark
215 });
216 if (resObj != null && resObj["status"]["code"] == "1")
217 flag = true;
218 return flag;
219 }
220
221 #endregion
222
223 #region 辅助方法
224
225 /// <summary>
226 /// Send the webrequest to the api,and get the data of JSON！
227 /// </summary>
228 /// <param name="apiAddress">The API address for DNSPod</param>
229 /// <param name="data">The object type parameter with key/value pairs，like{type:"POST"}</param>
230 /// <returns></returns>
231 private dynamic GetDNSApi(string apiAddress, object data)
232 {
233 return GetDNSApi(apiAddress, GetApiParamDataString(data));
234 }
235 /// <summary>
236 /// Send the webrequest to the api,and get the data of JSON！
237 /// </summary>
238 /// <param name="apiAddress">The API address for DNSPod</param>
239 /// <param name="data">The data that will send to the api,like "type=post"，split with "&" for more parameters!</param>
240 /// <returns>The returned data object</returns>
241 private dynamic GetDNSApi(string apiAddress, string data)
242 {
243
244 //若有额外参数，则将公共参数添加至参数请求中
245 if (!string.IsNullOrWhiteSpace(data))
246 {
247 data = string.Format("{0}&{1}", GetApiParamDataString(baseParam), data);
248 }
249 else
250 {
251 data = GetApiParamDataString(baseParam);//若无额外参数，只提交公共参数
252 }
253 HttpWebRequest request = (HttpWebRequest)WebRequest.Create(apiAddress);
254 request.Method = "POST";
255 request.Headers.Add("content", "text/html; charset=UTF-8");
256 request.ContentType = "application/x-www-form-urlencoded";
257 request.UserAgent = "ROS DDNS/V1";
258 byte[] postData = Encoding.UTF8.GetBytes(data);
259 request.ContentLength = postData.Length;
260 Stream smp = request.GetRequestStream();//得到请求流
261 smp.Write(postData, 0, postData.Length);//写入请求流
262 smp.Close();//关闭流
263
264
265 HttpWebResponse response = (HttpWebResponse)request.GetResponse();
266 StreamReader stream = new StreamReader(response.GetResponseStream(), System.Text.Encoding.UTF8);
267 string responseString = stream.ReadToEnd();//得到返回数据
268 stream.Close();
269 response.Close();
270 request = null;
271 dynamic obj = null;
272 if (!string.IsNullOrWhiteSpace(responseString))
273 {
274 obj = new JavaScriptSerializer().Deserialize(responseString, typeof(object) as dynamic);
275 }
276 return obj;
277 }
278 /// <summary>
279 ///
280 /// </summary>
281 /// <param name="data"></param>
282 /// <returns>The returned data of JSON</returns>
283 private string GetApiParamDataString(object data)
284 {
285 var dataString = string.Empty;
286 if (data != null)
287 {
288 //利用反复取可读属性或实例，返回属性集合
289 var objProperties = (from x in data.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance) where x.CanRead select x).ToList();
290 //将属性名与值拼接，返回string类型的数组
291 var arrProValue = (from y in objProperties select string.Format("{0}={1}", y.Name, y.GetValue(data, new object[0]))).ToList().ToArray();
292 //将数组以“&”连接
293 dataString = string.Join("&", arrProValue);
294 }
295 return dataString;
296 }
297 private string GetObjectPropertiesString(object obj)
298 {
299 var dataStr = new StringBuilder();
300 if (obj != null)
301 {
302 var d = obj as Dictionary<string, object>;
303 foreach (var item in d)
304 {
305 dataStr.AppendLine(string.Format("{0} - {1}", item.Key, item.Value));
306 }
307 }
308 return dataStr.ToString();
309 }
310
311 #endregion
312 }
313
314 #region 辅助类，用于返回dynamic类型对象
315
316 public class JsonParser
317 {
318 /// <summary>
319 /// 从json字符串到对象。
320 /// </summary>
321 /// <param name="jsonStr"></param>
322 /// <returns></returns>
323 public static dynamic FromJson(string jsonStr)
324 {
325 JavaScriptSerializer jss = new JavaScriptSerializer();
326 jss.RegisterConverters(new JavaScriptConverter[] { new DynamicJsonConverter() });
327
328 dynamic glossaryEntry = jss.Deserialize(jsonStr, typeof(object)) as dynamic;
329 return glossaryEntry;
330 }
331 }
332 public class DynamicJsonConverter : JavaScriptConverter
333 {
334 public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
335 {
336 if (dictionary == null)
337 throw new ArgumentNullException("dictionary");
338
339 if (type == typeof(object))
340 {
341 return new DynamicJsonObject(dictionary);
342 }
343
344 return null;
345 }
346
347 public override IDictionary<string, object> Serialize(object obj, JavaScriptSerializer serializer)
348 {
349 throw new NotImplementedException();
350 }
351
352 public override IEnumerable<Type> SupportedTypes
353 {
354 get { return new ReadOnlyCollection<Type>(new List<Type>(new Type[] { typeof(object) })); }
355 }
356 }
357
358 public class DynamicJsonObject : DynamicObject
359 {
360 private IDictionary<string, object> Dictionary { get; set; }
361
362 public DynamicJsonObject(IDictionary<string, object> dictionary)
363 {
364 this.Dictionary = dictionary;
365 }
366
367 public override bool TryGetMember(GetMemberBinder binder, out object result)
368 {
369 result = this.Dictionary[binder.Name];
370
371 if (result is IDictionary<string, object>)
372 {
373 result = new DynamicJsonObject(result as IDictionary<string, object>);
374 }
375 else if (result is ArrayList)
376 {
377 result = new List<DynamicJsonObject>((result as ArrayList).ToArray().Select(x => new DynamicJsonObject(x as IDictionary<string, object>)));
378 }
379 //else if (result is ArrayList && (result as ArrayList) is IDictionary<string, object>)
380 //{
381 // result = new List<DynamicJsonObject>((result as ArrayList).ToArray().Select(x => new DynamicJsonObject(x as IDictionary<string, object>)));
382 //}
383 //else if (result is ArrayList)
384 //{
385 // result = new List<object>((result as ArrayList).ToArray());
386 //}
387 return this.Dictionary.ContainsKey(binder.Name);
388 }
389 }
390 #endregion
浙公网安备 33010602011771号