/** 产品密钥ID，产品标识 */
    private final static String SECRETID = "your_secret_id";
    /** 产品私有密钥，服务端生成签名信息使用，请严格保管，避免泄露 */
    private final static String SECRETKEY = "your_secret_key";
    /** 业务ID，易盾根据产品业务特点分配 */
    private final static String BUSINESSID = "your_business_id";
    /** 易盾内容安全文本在线检测接口地址 */
    private final static String API_URL = "http://as.dun.163yun.com/v3/text/check";
    /** 实例化HttpClient，发送http请求使用，可根据需要自行调参 */
    private static HttpClient httpClient = HttpClient4Utils.createHttpClient(100, 20, 2000, 2000, 2000);

    /**
     *
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        Map<String, String> params = new HashMap<String, String>();
        // 1.设置公共参数
        params.put("secretId", SECRETID);
        params.put("businessId", BUSINESSID);
        params.put("version", "v3.1");
        params.put("timestamp", String.valueOf(System.currentTimeMillis()));
        params.put("nonce", String.valueOf(new Random().nextInt()));

        // 2.设置私有参数
        params.put("dataId", "ebfcad1c-dba1-490c-b4de-e784c2691768");
        params.put("content", "易盾测试内容！v3接口!");
        // params.put("dataType", "1");
        // params.put("ip", "123.115.77.137");
        // params.put("account", "java@163.com");
        // params.put("deviceType", "4");
        // params.put("deviceId", "92B1E5AA-4C3D-4565-A8C2-86E297055088");
        // params.put("callback", "ebfcad1c-dba1-490c-b4de-e784c2691768");
        // params.put("publishTime", String.valueOf(System.currentTimeMillis()));

        // 3.生成签名信息
        String signature = SignatureUtils.genSignature(SECRETKEY, params);
        params.put("signature", signature);

        // 4.发送HTTP请求，这里使用的是HttpClient工具包，产品可自行选择自己熟悉的工具包发送请求
        String response = HttpClient4Utils.sendPost(httpClient, API_URL, params, Consts.UTF_8);

        // 5.解析接口返回值
        JsonObject jObject = new JsonParser().parse(response).getAsJsonObject();
        int code = jObject.get("code").getAsInt();
        String msg = jObject.get("msg").getAsString();
        if (code == 200) {
            JsonObject resultObject = jObject.getAsJsonObject("result");
            int action = resultObject.get("action").getAsInt();
            String taskId = resultObject.get("taskId").getAsString();
            JsonArray labelArray = resultObject.getAsJsonArray("labels");
            /*for (JsonElement labelElement : labelArray) {
                JsonObject lObject = labelElement.getAsJsonObject();
                int label = lObject.get("label").getAsInt();
                int level = lObject.get("level").getAsInt();
                JsonObject detailsObject=lObject.getAsJsonObject("details");
                JsonArray hintArray=detailsObject.getAsJsonArray("hint");
            }*/
            if (action == 0) {
                System.out.println(String.format("taskId=%s，文本机器检测结果：通过", taskId));
            } else if (action == 1) {
                System.out.println(String.format("taskId=%s，文本机器检测结果：嫌疑，需人工复审，分类信息如下：%s", taskId, labelArray.toString()));
            } else if (action == 2) {
                System.out.println(String.format("taskId=%s，文本机器检测结果：不通过，分类信息如下：%s", taskId, labelArray.toString()));
            }
        } else {
            System.out.println(String.format("ERROR: code=%s, msg=%s", code, msg));
        }

    }

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
易盾反垃圾云服务文本在线检测接口python示例代码
接口文档: http://dun.163.com/api.html
python版本：python3.7
运行:
    1. 修改 SECRET_ID,SECRET_KEY,BUSINESS_ID 为对应申请到的值
    2. $ python text_check.py
"""
__author__ = 'yidun-dev'
__date__ = '2019/11/27'
__version__ = '0.2-dev'

import hashlib
import time
import random
import urllib.request as urlrequest
import urllib.parse as urlparse
import json


class TextCheckAPIDemo(object):
    """文本在线检测接口示例代码"""

    API_URL = "http://as.dun.163yun.com/v3/text/check"
    VERSION = "v3.1"

    def __init__(self, secret_id, secret_key, business_id):
        """
        Args:
            secret_id (str) 产品密钥ID，产品标识
            secret_key (str) 产品私有密钥，服务端生成签名信息使用
            business_id (str) 业务ID，易盾根据产品业务特点分配
        """
        self.secret_id = secret_id
        self.secret_key = secret_key
        self.business_id = business_id

    def gen_signature(self, params=None):
        """生成签名信息
        Args:
            params (object) 请求参数
        Returns:
            参数签名md5值
        """
        buff = ""
        for k in sorted(params.keys()):
            buff += str(k) + str(params[k])
        buff += self.secret_key
        return hashlib.md5(buff.encode("utf8")).hexdigest()

    def check(self, params):
        """请求易盾接口
        Args:
            params (object) 请求参数
        Returns:
            请求结果，json格式
        """
        params["secretId"] = self.secret_id
        params["businessId"] = self.business_id
        params["version"] = self.VERSION
        params["timestamp"] = int(time.time() * 1000)
        params["nonce"] = int(random.random() * 100000000)
        params["signature"] = self.gen_signature(params)

        try:
            params = urlparse.urlencode(params).encode("utf8")
            request = urlrequest.Request(self.API_URL, params)
            content = urlrequest.urlopen(request, timeout=1).read()
            return json.loads(content)
        except Exception as ex:
            print("调用API接口失败:", str(ex))


if __name__ == "__main__":
    """示例代码入口"""
    SECRET_ID = "your_secret_id"  # 产品密钥ID，产品标识
    SECRET_KEY = "your_secret_key"  # 产品私有密钥，服务端生成签名信息使用，请严格保管，避免泄露
    BUSINESS_ID = "your_business_id"  # 业务ID，易盾根据产品业务特点分配
    api = TextCheckAPIDemo(SECRET_ID, SECRET_KEY, BUSINESS_ID)

    params = {
        "dataId": "ebfcad1c-dba1-490c-b4de-e784c2691768",
        "content": "易盾测试内容！"
		# "dataType": "1"
        # "ip": "123.115.77.137"
        # "account": "python@163.com"
        # "deviceType": "4"
        # "deviceId": "92B1E5AA-4C3D-4565-A8C2-86E297055088"
        # "callback": "ebfcad1c-dba1-490c-b4de-e784c2691768"
        # "publishTime": str(int(time.time() * 1000))
        # "callbackUrl": "http://***"  # 主动回调地址url,如果设置了则走主动回调逻辑
    }

    ret = api.check(params)

    code: int = ret["code"]
    msg: str = ret["msg"]
    if code == 200:
        result: dict = ret["result"]
        action: int = result["action"]
        taskId: str = result["taskId"]
        labelArray: list = result["labels"]
        # for labelItem in labelArray:
        #     label: int = labelItem["label"]
        #     level: int = labelItem["level"]
        #     details: dict = labelItem["details"]
        #     hintArray: list = labelItem["hint"]
        if action == 0:
            print("taskId: %s, 文本机器检测结果: 通过" % (taskId))
        elif action == 1:
            print("taskId: %s, 文本机器检测结果: 嫌疑, 需人工复审, 分类信息如下: %s" % (taskId, labelArray))
        elif action == 2:
            print("taskId=%s, 文本机器检测结果: 不通过, 分类信息如下: %s" % (taskId, labelArray))
    else:
        print("ERROR: code=%s, msg=%s" % (ret["code"], ret["msg"]))

<?php
/** 产品密钥ID，产品标识 */
define("SECRETID", "your_secret_id");
/** 产品私有密钥，服务端生成签名信息使用，请严格保管，避免泄露 */
define("SECRETKEY", "your_secret_key");
/** 业务ID，易盾根据产品业务特点分配 */
define("BUSINESSID", "your_business_id");
/** 易盾反垃圾云服务文本在线检测接口地址 */
define("API_URL", "http://as.dun.163yun.com/v3/text/check");
/** api version */
define("VERSION", "v3.1");
/** API timeout*/
define("API_TIMEOUT", 2);
require("../util.php");

/**
 * 反垃圾请求接口简单封装
 * $params 请求参数
 */
function check($params){
	$params["secretId"] = SECRETID;
	$params["businessId"] = BUSINESSID;
	$params["version"] = VERSION;
	$params["timestamp"] = time() * 1000;// time in milliseconds
	$params["nonce"] = sprintf("%d", rand()); // random int

	$params = toUtf8($params);
	$params["signature"] = gen_signature(SECRETKEY, $params);
	// var_dump($params);

	$result = curl_post($params, API_URL, API_TIMEOUT);
	if($result === FALSE){
		return array("code"=>500, "msg"=>"file_get_contents failed.");
	}else{
		return json_decode($result, true);	
	}
}

// 简单测试
function main(){
    echo "mb_internal_encoding=".mb_internal_encoding()."\n";
	$params = array(
		"dataId"=>"ebfcad1c-dba1-490c-b4de-e784c2691768",
		"content"=>"易盾测试内容！v3接口！"
		// "dataType"=>"1",
		// "ip"=>"123.115.77.137",
		// "account"=>"php@163.com",
		// "deviceType"=>"4",
		// "deviceId"=>"92B1E5AA-4C3D-4565-A8C2-86E297055088",
		// "callback"=>"ebfcad1c-dba1-490c-b4de-e784c2691768",
		// "publishTime"=>round(microtime(true)*1000)
	);

	$ret = check($params);
	var_dump($ret);
	if ($ret["code"] == 200) {
		$action = $ret["result"]["action"];
		$taskId = $ret["result"]["taskId"];
		$labelArray = $ret["result"]["labels"];
        if ($action == 0) {
			echo "taskId={$taskId}，文本机器检测结果：通过\n";
        } else if ($action == 1) {
	      		echo "taskId={$taskId}，文本机器检测结果：嫌疑，需人工复审，分类信息如下：".json_encode($labelArray)."\n";
		} else if ($action == 2) {
			echo "taskId={$taskId}，文本机器检测结果：不通过，分类信息如下：".json_encode($labelArray)."\n";
		}
    	}else{
    		var_dump($ret); // error handler
    	}
}

main();
?>

using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Net.Http;

namespace Com.Netease.Is.Antispam.Demo
{
    class TextCheckApiDemo
    {
        public static void textCheck()
        {
            /** 产品密钥ID，产品标识 */
            String secretId = "your_secret_id";
            /** 产品私有密钥，服务端生成签名信息使用，请严格保管，避免泄露 */
            String secretKey = "your_secret_key";
            /** 业务ID，易盾根据产品业务特点分配 */
            String businessId = "your_business_id";
            /** 易盾内容安全服务文本在线检测接口地址 */
            String apiUrl = "http://as.dun.163yun.com/v3/text/check";
            Dictionary<String, String> parameters = new Dictionary<String, String>();

            long curr = (long)(DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalMilliseconds;
            String time = curr.ToString();

            // 1.设置公共参数
            parameters.Add("secretId", secretId);
            parameters.Add("businessId", businessId);
            parameters.Add("version", "v3.1");
            parameters.Add("timestamp", time);
            parameters.Add("nonce", new Random().Next().ToString());

            // 2.设置私有参数
            parameters.Add("dataId", "ebfcad1c-dba1-490c-b4de-e784c2691768");
            parameters.Add("content", "易盾测试内容！v3接口!");
            // parameters.Add("dataType", "1");
            // parameters.Add("ip", "123.115.77.137");
            // parameters.Add("account", "csharp@163.com");
            // parameters.Add("deviceType", "4");
            // parameters.Add("deviceId", "92B1E5AA-4C3D-4565-A8C2-86E297055088");
            // parameters.Add("callback", "ebfcad1c-dba1-490c-b4de-e784c2691768");
            // parameters.Add("publishTime", time);

            // 3.生成签名信息
            String signature = Utils.genSignature(secretKey, parameters);
            parameters.Add("signature", signature);

            // 4.发送HTTP请求
            HttpClient client = Utils.makeHttpClient();
            String result = Utils.doPost(client, apiUrl, parameters, 1000);
            Console.WriteLine(result);
            if(result != null)
            {
                JObject ret = JObject.Parse(result);
                int code = ret.GetValue("code").ToObject<Int32>();
                String msg = ret.GetValue("msg").ToObject<String>();
                if (code == 200)
                {
                    JObject resultObject = (JObject)ret["result"];
                    String taskId = resultObject["taskId"].ToObject<String>();
                    int action = resultObject["action"].ToObject<Int32>();
                    JArray labelArray = (JArray)resultObject.SelectToken("labels");
                    if (action == 0)
                    {
                        Console.WriteLine(String.Format("taskId={0}，文本机器检测结果：通过", taskId));
                    }
                    else if (action == 1)
                    {
                        Console.WriteLine(String.Format("taskId={0}，文本机器检测结果：嫌疑，需人工复审，分类信息如下：{1}", taskId, labelArray));
                    }
                    else if (action == 2)
                    {
                        Console.WriteLine(String.Format("taskId={0}，文本机器检测结果：不通过，分类信息如下：{1}", taskId, labelArray));
                    }
                }
                else
                {
                    Console.WriteLine(String.Format("ERROR: code={0}, msg={1}", code, msg));
                }
            }
            else
            {
                Console.WriteLine("Request failed!");
            }

        }
    }
}

var utils=require("./utils");
//产品密钥ID，产品标识
var secretId="your_secret_id";
// 产品私有密钥，服务端生成签名信息使用，请严格保管，避免泄露
var secretKey="your_secret_key";
// 业务ID，易盾根据产品业务特点分配
var businessId="your_business_id";
// 易盾内容安全服务文本在线检测接口地址
var apiurl="http://as.dun.163yun.com/v3/text/check";
//请求参数
var post_data = {
    // 1.设置公有有参数
    secretId:secretId,
    businessId:businessId,
    version:"v3.1",
    timestamp:new Date().getTime(),
    nonce:utils.noncer(),
    // 2.设置私有参数
    dataId:"ebfcad1c-dba1-490c-b4de-e784c2691768",
    content:"易盾测试内容！v3接口!"
    // ip:"123.115.77.137",
    // dataType:"1",
    // account:"nodejs@163.com",
    // deviceType:"4",
    // deviceId:"92B1E5AA-4C3D-4565-A8C2-86E297055088",
    // callback:"ebfcad1c-dba1-490c-b4de-e784c2691768",
    // publishTime:new Date().getTime()
};
var signature=utils.genSignature(secretKey,post_data);
post_data.signature=signature;
//http请求结果
var responseCallback=function(responseData){
    var data = JSON.parse(responseData);
    var code=data.code;
    var msg=data.msg;
    if(code==200){
        var result=data.result;
        var taskId=result.taskId;
        var action=result.action;
        var labelArray=result.labels;
        if(action==0){
            console.log("taskId="+taskId+"，文本机器检测结果：通过")
        }else if(action==1){
            console.log("taskId="+taskId+"，文本机器检测结果：嫌疑，需人工复审，分类信息如下："+JSON.stringify(labelArray))
        }else if(action==2){
            console.log("taskId="+taskId+"，文本机器检测结果：不通过，分类信息如下："+JSON.stringify(labelArray))
        }
    }else{
         console.log('ERROR:code=' + code+',msg='+msg);
    }
}
utils.sendHttpRequest(apiurl,"POST",post_data,responseCallback);

*/
package main

import (
	"crypto/md5"
	"encoding/hex"
	"fmt"
	simplejson "github.com/bitly/go-simplejson"
	"io/ioutil"
	"math/rand"
	"net/http"
	"net/url"
	"sort"
	"strconv"
	"strings"
	"time"
)

const (
	apiUrl     = "http://as.dun.163yun.com/v3/text/query"
	version    = "v3.1"
	secretId   = "your_secret_id"   //产品密钥ID，产品标识
	secretKey  = "your_secret_key"  //产品私有密钥，服务端生成签名信息使用，请严格保管，避免泄露
	businessId = "your_business_id" //业务ID，易盾根据产品业务特点分配
)

//请求易盾接口
func check(params url.Values) *simplejson.Json {
	params["secretId"] = []string{secretId}
	params["businessId"] = []string{businessId}
	params["version"] = []string{version}
	params["timestamp"] = []string{strconv.FormatInt(time.Now().UnixNano()/1000000, 10)}
	params["nonce"] = []string{strconv.FormatInt(rand.New(rand.NewSource(time.Now().UnixNano())).Int63n(10000000000), 10)}
	params["signature"] = []string{genSignature(params)}

	resp, err := http.Post(apiUrl, "application/x-www-form-urlencoded", strings.NewReader(params.Encode()))

	if err != nil {
		fmt.Println("调用API接口失败:", err)
		return nil
	}

	defer resp.Body.Close()

	contents, _ := ioutil.ReadAll(resp.Body)
	result, _ := simplejson.NewJson(contents)
	return result
}

//生成签名信息
func genSignature(params url.Values) string {
	var paramStr string
	keys := make([]string, 0, len(params))
	for k := range params {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	for _, key := range keys {
		paramStr += key + params[key][0]
	}
	paramStr += secretKey
	md5Reader := md5.New()
	md5Reader.Write([]byte(paramStr))
	return hex.EncodeToString(md5Reader.Sum(nil))
}

func main() {
	params := url.Values{
		"dataId":  []string{"ebfcad1c-dba1-490c-b4de-e784c2691768"},
		"content": []string{"易盾测试内容！"},
		//"dataType": []string{"1"},
		//"ip": []string{"123.115.77.137"},
		//"account": []string{"golang@163.com"},
		//"deviceType": []string{"4"},
		//"deviceId": []string{"92B1E5AA-4C3D-4565-A8C2-86E297055088"},
		//"callback": []string{"ebfcad1c-dba1-490c-b4de-e784c2691768"},
		//"publishTime": []string{"1479677336255"},
		//"callbackUrl": []string{"http://***"},	//主动回调地址url,如果设置了则走主动回调逻辑
	}

	ret := check(params)

	code, _ := ret.Get("code").Int()
	message, _ := ret.Get("msg").String()
	if code == 200 {
		result := ret.Get("result")
		action, _ := result.Get("action").Int()
		taskId, _ := result.Get("taskId").String()
		labelArray, _ := result.Get("labels").Array()
		//for _, labelItem := range labelArray {
		//	if labelItemMap, ok := labelItem.(map[string]interface{}); ok {
		//		label, _ := labelItemMap["label"].(json.Number).Int64()
		//		level, _ := labelItemMap["level"].(json.Number).Int64()
		//		details := labelItemMap["details"].(map[string]interface{})
		//		hintArray := labelItemMap["hint"].([]interface{})
		//	}
		//}
		if action == 0 {
			fmt.Printf("taskId: %s, 文本机器检测结果: 通过", taskId)
		} else if action == 1 {
			fmt.Printf("taskId: %s, 文本机器检测结果: 嫌疑, 需人工复审, 分类信息如下: %s", taskId, labelArray)
		} else if action == 2 {
			fmt.Printf("taskId=%s, 文本机器检测结果: 不通过, 分类信息如下: %s", taskId, labelArray)
		}
	} else {
		fmt.Printf("ERROR: code=%d, msg=%s", code, message)
	}
}