人脸Deepfake检测服务 _实人认证(ID Verification)-阿里云帮助中心

本文介绍人脸Deepfake检测服务的API。

接口信息

接口名称：DeepfakeDetect
全局接入地址：cloudauth.aliyuncs.com（IPv4）或cloudauth-dualstack.aliyuncs.com（IPv6）
请求方法：POST和GET
传输协议：HTTPS
接口说明：传入人脸图片，通过算法检测是否存在深度伪造风险。包含AIGC生成人脸、深度伪造换脸、模板人脸、翻拍人脸等风险场景，输出风险标签与置信度。

说明

人脸Deepfake检测接口当前处于免费公测阶段，免费公测的截止时间为2024年8月30日23:59:59，公测期间QPS不能超过3次/秒。

图片要求

为了确保模型效果稳定，您需要确保传入的图片中为人脸图片且该人脸的角度正常。此外，还需要满足以下条件：

图片格式：JPG，JPEG。
图片大小：推荐50~100 KB，最大不超过1 MB。
图片分辨率：建议640*480（高*宽），不超过1920*1080（高*宽），且保持照片的高大于宽。推荐短边缩放到720像素，压缩率0.8。
图片质量：照片清晰、曝光正常，脸部无过黑、过亮、光晕等情况。
图片人脸：当图片出现多人脸，系统会默认检测最大脸。

请求参数

名称	类型	必填	描述	示例值
OuterOrderNo	String	否	商户请求的唯一标识，值为32位长度的字母数字组合。其中前几位字符由商户自定义的简称组成，中间部分可以包含一段时间，而后段可以采用随机或递增序列。	e0c34a77f5ac40a5aa5e6ed20c******
FaceInputType	String	否	传入IMAGE，表示图片类型。	IMAGE
FaceUrl	String	否	传入人脸图片URL地址。说明 FaceUrl和FaceBase64需选择传入其中一个。	https://cn-shanghai-aliyun-cloudauth-xxxxxx.oss-cn-shanghai.aliyuncs.com/verify/xxxxx/xxxxx.jpeg
FaceBase64	String	否	传入人脸图片的Base64格式编码。说明 FaceUrl和FaceBase64需选择传入其中一个。	/9j/4AAQSkZJRgABAQAASxxxxxxx

响应参数

名称	类型	描述	示例值
RequestId	String	请求ID。	8FC3D6AC-9FED-4311-8DA7-C4BF47D9F260
Code	String	返回码。返回200表示请求成功，其他均为失败。	200
Message	String	返回信息。	success
ResultObject	Object	返回的结果信息
└Result	String	风险结果。 0：低风险 1：高风险 2：可疑	1
└RiskTag	String	风险标签。多个标签使用半角逗号（,）隔开，包括：疑似深度伪造：SuspectDeepForgery 疑似合成攻击：SuspectPSFace 疑似存在水印：SuspectWarterMark 疑似模板攻击：SuspectTemple 疑似生成人脸：SuspectAIGC Face 疑似翻拍人脸：SuspectRemake	SuspectDeepForgery,SuspectWarterMark
└RiskScore	Map	风险分值Map。	{ "SuspectPSFace": "0.9796", "SuspectRemake": "0.0000", "SuspectDeepForgery": "0.9500", "SuspectAIGCFace": "0.0001", "SuspectWaterMark": "0.0000" }

返回码

Code	Message	描述
200	success	成功。
400	参数不能为空	参数不能为空。
401	参数非法	非法参数。
402	权威源服务异常	权威源服务异常。
405	图片格式不正确	图片格式不正确。
406	检测不到人脸	检测不到人脸
410	未开通服务	产品未开通。
411	RAM无权限	RAM用户无权限，请授权AliyunYundunCloudAuthFullAccess。
412	欠费中	产品欠费，请充值后操作。
419	数据重复	数据重复，同时传入faceUrl，faceBase64参数。
420	传入图片不可用	传入图片不可用
421	传入图片过大	传入图片过大
500	系统错误	系统内部错误。

SDK调用示例

以下为您介绍不同语言SDK的调用示例。

Java

在pom.xml中添加如下依赖，即可在Maven工程中使用SDK。

Java SDK依赖。以下依赖版本仅供参考，建议在实际配置时获取最新依赖版本。

<dependency>
 <groupId>com.aliyun</groupId>
 <artifactId>cloudauth20190307</artifactId>
 <version>2.7.0</version>
</dependency>

身份验证依赖。如何配置环境变量，请参见管理访问凭据。

<dependency>
   <groupId>com.aliyun</groupId>
   <artifactId>credentials-java</artifactId>
   <version>LATEST</version>
</dependency>

示例：

import com.aliyun.cloudauth20190307.Client;
import com.aliyun.cloudauth20190307.models.DeepfakeDetectRequest;
import com.aliyun.cloudauth20190307.models.DeepfakeDetectResponse;
import com.aliyun.teaopenapi.models.Config;
import com.aliyun.teautil.models.RuntimeOptions;

import java.util.Arrays;
import java.util.List;

public class DeepfakeDetect {
    public static void main(String[] args) throws Exception {

        // 通过以下代码创建API请求并设置参数。
        DeepfakeDetectRequest request = new DeepfakeDetectRequest();

        request.setOuterOrderNo("123456789*****");
        request.setFaceInputType("IMAGE");
        request.setFaceUrl("https://xxx.xxx.xxx.xxx");

        // 推荐，支持服务路由。
        DeepfakeDetectResponse response = deepfakeDetectAutoRoute(request);

        // 不支持服务自动路由。
        //DeepfakeDetectResponse response = deepfakeDetect("cloudauth.cn-shanghai.aliyuncs.com", request);

        System.out.println(response.getBody().getRequestId());
        System.out.println(response.getBody().getCode());
        System.out.println(response.getBody().getMessage());
        System.out.println(response.getBody().getResultObject() == null ? null
                : response.getBody().getResultObject().getResult());
        System.out.println(response.getBody().getResultObject() == null ? null
                : response.getBody().getResultObject().getRiskTag());
    }

    private static DeepfakeDetectResponse deepfakeDetectAutoRoute(DeepfakeDetectRequest request) {
        // 第一个为主区域Endpoint，第二个为备区域Endpoint。
        List<String> endpoints = Arrays.asList("cloudauth.cn-shanghai.aliyuncs.com", "cloudauth.cn-beijing.aliyuncs.com");
        DeepfakeDetectResponse lastResponse = null;
        for (int i=0; i<endpoints.size(); i++) {
            try {
                DeepfakeDetectResponse response = deepfakeDetect(endpoints.get(i), request);
                lastResponse = response;

                // 服务端错误，切换到下个区域调用。
                if(response != null){
                    if(500 == response.getStatusCode()){
                        continue;
                    }
                    if(response.getBody() != null){
                        if("500".equals(response.getBody().getCode())){
                            continue;
                        }
                    }
                }

                return response;
            } catch (Exception e) {
                e.printStackTrace();
                if(i == endpoints.size()-1){
                    throw new RuntimeException(e);
                }
            }
        }

        return lastResponse;
    }

    private static DeepfakeDetectResponse deepfakeDetect(String endpoint, DeepfakeDetectRequest request)
            throws Exception {
        // 阿里云账号AccessKey拥有所有API的访问权限，建议您使用RAM用户进行API访问或日常运维。
        // 强烈建议不要把AccessKey ID和AccessKey Secret保存到工程代码里，否则可能导致AccessKey泄露，威胁您账号下所有资源的安全。
        // 本示例通过阿里云Credentials工具从环境变量中读取AccessKey，来实现API访问的身份验证。
        com.aliyun.credentials.Client credentialClient = new com.aliyun.credentials.Client();
        Config config = new Config();
        config.setCredential(credentialClient);
        config.setEndpoint(endpoint);
        // 设置http代理。
        //config.setHttpProxy("http://xx.xx.xx.xx:xxxx");
        // 设置https代理。
        //config.setHttpsProxy("http://xx.xx.xx.xx:xxxx");
        Client client = new Client(config);

        // 创建RuntimeObject实例并设置运行参数。
        RuntimeOptions runtime = new RuntimeOptions();
        runtime.readTimeout = 5000;
        runtime.connectTimeout = 5000;

        return client.deepfakeDetectWithOptions(request, runtime);
    }
}

PHP

关于PHP SDK源代码，请参见PHP SDK包。

通过Composer来管理项目依赖（推荐）

composer require alibabacloud/cloudauth-20190307 2.7.0

使用composer.json文件

{
   "require": {
       "alibabacloud/cloudauth-20190307": "2.7.0"
    }
}

示例：

<?php


namespace AlibabaCloud\SDK\Sample\Verify\Id;

use AlibabaCloud\Credentials\Credential; 
use AlibabaCloud\SDK\Cloudauth\V20190307\Cloudauth;
use AlibabaCloud\SDK\Cloudauth\V20190307\Models\DeepfakeDetectRequest;
use AlibabaCloud\SDK\Cloudauth\V20190307\Models\DeepfakeDetectResponse;
use Darabonba\OpenApi\Models\Config;
use AlibabaCloud\Tea\Utils\Utils;
use AlibabaCloud\Tea\Utils\Utils\RuntimeOptions;
use Exception;

class DeepfakeDetect
{
    /**
     * createClient
     * @param string $endpoint
     * @return Cloudauth
     */
    public static function createClient(string $endpoint): Cloudauth
    {
        // 阿里云账号AccessKey拥有所有API的访问权限，建议您使用RAM用户进行API访问或日常运维。
        // 强烈建议不要把AccessKey ID和AccessKey Secret保存到工程代码里，否则可能导致AccessKey泄露，威胁您账号下所有资源的安全。
        // 本示例通过阿里云Credentials工具从环境变量中读取AccessKey，来实现API访问的身份验证。 
        $credential = new Credential([]);
        $config = new Config([
			  // 使用credential配置凭证
    		    "credential" => $credential,
            // 设置HTTP代理。
            // "httpProxy" => "<http://xx.xx.xx.xx:xxxx>",
            // 设置HTTPS代理
            // "httpsProxy" => "<https://xx.xx.xx.xx:xxxx>",
            "endpoint" => $endpoint

        ]);
        return new Cloudauth($config);
    }

    /**
     * @return void
     */
    public static function main(){
        $request = new DeepfakeDetectRequest([
            "outerOrderNo" => "123456789****",
            "faceInputType" => "IMAGE",
            "faceUrl" => "https://xxx.xxx.xxx.xxx"
        ]);
        // 推荐，支持服务路由。
        $response = self::deepfakeDetectAutoRoute($request);
        // 不支持服务自动路由。
        // $response = self::deepfakeDetect("cloudauth.cn-shanghai.aliyuncs.com", $request);
        var_dump($response->body->requestId);
        var_dump($response->body->code);
        var_dump($response->body->message);
        var_dump($response->body->resultObject->result);
        var_dump($response->body->resultObject->riskTag);
    }

    /**
     * deepfakeDetectAutoRoute
     * @param DeepfakeDetectRequest $request
     * @return DeepfakeDetectResponse|null
     */
    public static function deepfakeDetectAutoRoute(DeepfakeDetectRequest $request): ?DeepfakeDetectResponse
    {
        $endpoints = [
            "cloudauth.cn-shanghai.aliyuncs.com",
            "cloudauth.cn-beijing.aliyuncs.com"
        ];
        foreach($endpoints as $endpoint){
            try {
                $response = self::deepfakeDetect($endpoint, $request);
                if (Utils::equalNumber(500, $response->statusCode)) {
                    continue;
                }
                if(Utils::equalString("500", $response->body->code)){
                    continue;
                }
                return $response;
            }
            catch (Exception $err) {
                var_dump($err -> getCode());
                var_dump($err -> getMessage());
            }
        }
        return null;
    }

    /**
     * deepfakeDetect
     * @param string $endpoint
     * @param DeepfakeDetectRequest $request
     * @return DeepfakeDetectResponse
     */
    public static function deepfakeDetect(string $endpoint, DeepfakeDetectRequest $request): DeepfakeDetectResponse
    {
        $client = self::createClient($endpoint);
        // 创建RuntimeObject实例并设置运行参数。
        $runtime = new RuntimeOptions([]);
        $runtime->readTimeout = 5000;
        $runtime->connectTimeout = 5000;
        return $client->deepfakeDetectWithOptions($request, $runtime);
    }
}

$path = __DIR__ . \DIRECTORY_SEPARATOR . \DIRECTORY_SEPARATOR . 'vendor' . \DIRECTORY_SEPARATOR . 'autoload.php';
if (file_exists($path)) {
    require_once $path;
}
DeepfakeDetect::main();

说明

Credentials工具配置方法，请参见身份验证配置。

Python

关于Python SDK源代码，请参见Python SDK包。

引入依赖并安装SDK：

pip install alibabacloud_tea_openapi==0.2.5
pip install alibabacloud_credentials==0.3.2
pip install alibabacloud_cloudauth20190307==2.7.0

说明

Credentials工具配置方法，请参见身份验证配置。

示例：

from alibabacloud_cloudauth20190307.client import Client as CloudauthClient
from alibabacloud_tea_openapi import models as open_api_models
from alibabacloud_cloudauth20190307 import models as cloudauth_models
from alibabacloud_tea_util.client import Client as UtilClient
from alibabacloud_tea_util import models as util_models
from alibabacloud_credentials.client import Client as CredClient


class DeepfakeDetect:
    def __init__(self):
        pass

    @staticmethod
    def create_client(
            endpoint: str,
    ) -> CloudauthClient:
        # 阿里云账号AccessKey拥有所有API的访问权限，建议您使用RAM用户进行API访问或日常运维。
        # 强烈建议不要把AccessKey ID和AccessKey Secret保存到工程代码里，否则可能导致AccessKey泄露，威胁您账号下所有资源的安全。
        # 本示例通过阿里云Credentials工具从环境变量中读取AccessKey，来实现API访问的身份验证。
        cred=CredClient()
        config = open_api_models.Config(
        credential=cred,
        # 设置HTTP代理。
        # http_proxy='http://xx.xx.xx.xx:xxxx',
        # 设置HTTPS代理。
        # https_proxy='https://username:password@xxx.xxx.xxx.xxx:9999',
        endpoint=endpoint
        )
        return CloudauthClient(config)

    @staticmethod
    def main() -> None:
        request = cloudauth_models.DeepfakeDetectRequest(
            outer_order_no = '123456*******',
            face_input_type = "IMAGE",
            face_url = "https://xxx.xxx.xxx.xxx"
        )
        response = DeepfakeDetect.deepfake_detect_auto_route(request)
        # 不支持服务自动路由。
        # response = DeepfakeDetect.deepfake_detect('cloudauth.cn-shanghai.aliyuncs.com', request)
        print(response.body.request_id)
        print(response.body.code)
        print(response.body.message)
        print(response.body.result_object.result)
        print(response.body.result_object.risk_tag)

    @staticmethod
    def deepfake_detect_auto_route(
            request: cloudauth_models.DeepfakeDetectRequest,
    ) -> cloudauth_models.DeepfakeDetectResponse:
        endpoints = [
            'cloudauth.cn-shanghai.aliyuncs.com',
            'cloudauth.cn-beijing.aliyuncs.com'
        ]
        for endpoint in endpoints:
            try:
                response = DeepfakeDetect.deepfake_detect(endpoint, request)
                if UtilClient.equal_number(500, response.status_code):
                    continue
                if response is not None and response.body is not None:
                    if UtilClient.equal_string("500", response.body.code):
                        continue
                return response
            except Exception as err:
                print(err)
                continue
        return None

    @staticmethod
    def deepfake_detect(
            endpoint: str,
            request: cloudauth_models.DeepfakeDetectRequest,
    ) -> cloudauth_models.DeepfakeDetectResponse:
        client = DeepfakeDetect.create_client(endpoint)
        # 创建RuntimeObject实例并设置运行参数。
        runtime = util_models.RuntimeOptions()
        runtime.read_timeout = 5000
        runtime.connect_timeout = 5000
        return client.deepfake_detect_with_options(request, runtime)


if __name__ == '__main__':
    DeepfakeDetect.main()

Go

引入Credentials工具并安装SDK：

go get -u github.com/aliyun/credentials-go
go get github.com/alibabacloud-go/cloudauth-20190307/v3

说明

Credentials工具配置方法，请参见管理访问凭证。

示例：

package main

import (
	"fmt"
	cloudauth "github.com/alibabacloud-go/cloudauth-20190307/v3/client"
	openapi "github.com/alibabacloud-go/darabonba-openapi/v2/client"
	util "github.com/alibabacloud-go/tea-utils/v2/service"
	"github.com/alibabacloud-go/tea/tea"
    "github.com/aliyun/credentials-go/credentials"
)


func CreateClient (endpoint *string) (_result *cloudauth.Client, _err error) {
  //阿里云账号AccessKey拥有所有API的访问权限，建议您使用RAM用户进行API访问或日常运维。
  //强烈建议不要把AccessKey ID和AccessKey Secret保存到工程代码里，否则可能导致AccessKey泄露，威胁您账号下所有资源的安全。
  //本示例通过阿里云Credentials工具从环境变量中读取AccessKey，来实现API访问的身份验证。
   // 初始化Credential。
	credential, _err := credentials.NewCredential(nil)
	if _err != nil {
		panic(_err)
	}
	// 初始化Client。
	config := &openapi.Config{
	// 使用Credential配置凭证。
	Credential: credential,
	Endpoint:   endpoint,
	// 设置HTTP代理。
	// HttpProxy: tea.String("http://xx.xx.xx.xx:xxxx"),
	// 设置HTTPS代理。
	// HttpsProxy: tea.String("https://username:password@xxx.xxx.xxx.xxx:9999"),
	}
	//_result = &cloudauth.Client{}
	_result, _err = cloudauth.NewClient(config)
	return _result, _err
}

func _main () (_err error) {
	request := &cloudauth.DeepfakeDetectRequest{
		OuterOrderNo: tea.String("123456789****"),
		FaceUrl: tea.String("https://xxx.xxx.xxx.xxx"),
        FaceInputType: tea.String("IMAGE")
	}
	response, _err := DeepfakeDetectAutoRoute(request)
	// 不支持服务自动路由。
	// response, _err := DeepfakeDetect(tea.String("cloudauth.cn-shanghai.aliyuncs.com"), request)
	if _err != nil {
		return _err
	}

	fmt.Println(*response.Body.RequestId)
	fmt.Println(*response.Body.Code)
	fmt.Println(*response.Body.Message)
	fmt.Println(*response.Body.ResultObject.Result)
    fmt.Println(*response.Body.ResultObject.RiskTag)
	return _err
}

func DeepfakeDetectAutoRoute (request *cloudauth.DeepfakeDetectRequest) (_result *cloudauth.DeepfakeDetectResponse, _err error) {
	endpoints := []*string{tea.String("cloudauth.cn-shanghai.aliyuncs.com"), tea.String("cloudauth.cn-beijing.aliyuncs.com")}
	var lastResponse *cloudauth.DeepfakeDetectResponse
	for _, endpoint := range endpoints {
		response, _err := DeepfakeDetect(endpoint, request)
		lastResponse = response
		if _err != nil {
			var err = &tea.SDKError{}
			if _t, ok := _err.(*tea.SDKError); ok {
				err = _t
				// 系统异常，切换到下个地域调用。
				if *err.StatusCode == 500 {
					continue
				}
			}
			return _result, _err
		}

		if *response.StatusCode == 500 {
			continue
		}

		if *response.Body.Code == "500"{
			continue
		}

		_result = response
		return _result, _err

	}
	_result = lastResponse
	return _result, _err
}

func DeepfakeDetect (endpoint *string, request *cloudauth.DeepfakeDetectRequest) (_result *cloudauth.DeepfakeDetectResponse, _err error) {
	client, _err := CreateClient(endpoint)
	if _err != nil {
		return _result, _err
	}

	// 创建RuntimeObject实例并设置运行参数。
	runtime := &util.RuntimeOptions{}
	runtime.ReadTimeout = tea.Int(5000)
	runtime.ConnectTimeout = tea.Int(5000)
	_result = &cloudauth.DeepfakeDetectResponse{}
	_body, _err := client.DeepfakeDetectWithOptions(request, runtime)
	if _err != nil {
		return _result, _err
	}
	_result = _body
	return _result, _err
}


func main() {
	err := _main()
	if err != nil {
		panic(err)
	}
}

.NET

引入依赖并安装SDK：

方式一：通过.NET命令行安装。

dotnet add package AlibabaCloud.SDK.Cloudauth20190307 --version 2.6.0
dotnet add package Aliyun.Credentials

方式二：使用包管理安装。

Install-Package AlibabaCloud.SDK.Cloudauth20190307 -Version 2.7.0
Install-Package Aliyun.Credentials

说明

Credentials工具配置方法，请参见管理访问凭证。

示例：

using System;

using System.Collections.Generic;
using Tea;


namespace DeepfakeDetect
{
    public class Program
    {

        public static AlibabaCloud.SDK.Cloudauth20190307.Client CreateClient(string endpoint)
        {
            AlibabaCloud.OpenApiClient.Models.Config config = new AlibabaCloud.OpenApiClient.Models.Config
            {
               Credential=new Aliyun.Credentials.Client(null)
            };
  					config.Endpoint = endpoint;
            return new AlibabaCloud.SDK.Cloudauth20190307.Client(config);
        }

        public static void Main(string[] args)
        {
            AlibabaCloud.SDK.Cloudauth20190307.Models.DeepfakeDetectRequest request = new AlibabaCloud.SDK.Cloudauth20190307.Models.DeepfakeDetectRequest
            {
                OuterOrderNo = "123456*******",
                FaceInputType = "IMAGE",
                FaceUrl = "https://xxx.xxx.xxx.xxx"
            };
            AlibabaCloud.SDK.Cloudauth20190307.Models.DeepfakeDetectResponse response = DeepfakeDetectAutoRoute(request);
            // 不支持服务自动路由。
            //AlibabaCloud.SDK.Cloudauth20190307.Models.DeepfakeDetectResponse response = DeepfakeDetect("cloudauth.cn-shanghai.aliyuncs.com", request);
            Console.WriteLine(response.Body.RequestId);
            Console.WriteLine(response.Body.Code);
            Console.WriteLine(response.Body.Message);
            Console.WriteLine(response.Body.ResultObject.Result);
            Console.WriteLine(response.Body.ResultObject.RiskTag);
        }


        public static AlibabaCloud.SDK.Cloudauth20190307.Models.DeepfakeDetectResponse DeepfakeDetectAutoRoute(AlibabaCloud.SDK.Cloudauth20190307.Models.DeepfakeDetectRequest request)
        {
            List<string> endpoints = new List<string>
            {
                "cloudauth.cn-shanghai.aliyuncs.com",
                "cloudauth.cn-beijing.aliyuncs.com"
            };
            AlibabaCloud.SDK.Cloudauth20190307.Models.DeepfakeDetectResponse lastResponse = null;

            foreach (var endpoint in endpoints)
            {
                try
                {
                    AlibabaCloud.SDK.Cloudauth20190307.Models.DeepfakeDetectResponse response = DeepfakeDetect(endpoint, request);
                    lastResponse = response;
                    if (response is not null)
                    {
                        if (AlibabaCloud.TeaUtil.Common.EqualNumber(500, (int)(response.StatusCode)))
                        {
                            continue;
                        }

                        if (response.Body is not null)
                        {
                            if (AlibabaCloud.TeaUtil.Common.EqualString("500", response.Body.Code))
                            {
                                continue;
                            }
                        }
                    }
                    return response;
                }
                catch (TeaException err)
                {
                    Console.WriteLine(err);
                    // 网络异常，切换到下个区域调用。
                    if (AlibabaCloud.TeaUtil.Common.EqualString("ServiceUnavailable", err.Code))
                    {
                        continue;
                    }
                }
                catch (Exception _err)
                {
                    Console.WriteLine(_err);
                    continue;
                }
            }
            return lastResponse;
        }

        public static AlibabaCloud.SDK.Cloudauth20190307.Models.DeepfakeDetectResponse DeepfakeDetect(string endpoint, AlibabaCloud.SDK.Cloudauth20190307.Models.DeepfakeDetectRequest request)
        {
            AlibabaCloud.SDK.Cloudauth20190307.Client client = CreateClient(endpoint);
            // 创建RuntimeObject实例并设置运行参数。
            AlibabaCloud.TeaUtil.Models.RuntimeOptions runtime = new AlibabaCloud.TeaUtil.Models.RuntimeOptions();
            runtime.ReadTimeout = 5000;
            runtime.ConnectTimeout = 5000;
            return client.DeepfakeDetectWithOptions(request, runtime);
        }
    }
}

Node.js

引入依赖并安装SDK：

npm install @alicloud/tea-util
npm install @alicloud/openapi-client
npm install @alicloud/cloudauth20190307@2.6.0
npm install @alicloud/credentials

说明

Credentials工具配置方法，请参见管理访问凭证。

示例：

const Config = require("@alicloud/openapi-client");
const CloudAuth = require("@alicloud/cloudauth20190307");
const CloudAuthClient = CloudAuth.default;
const {RuntimeOptions} = require("@alicloud/tea-util");
const { default: Credential } = require('@alicloud/credentials');

function createClient(endpoint) {
    // 阿里云账号AccessKey拥有所有API的访问权限，建议您使用RAM用户进行API访问或日常运维。
    // 强烈建议不要把AccessKey ID和AccessKey Secret保存到工程代码里，否则可能导致AccessKey泄露，威胁您账号下所有资源的安全。
    // 本示例通过阿里云Credentials工具从环境变量中读取AccessKey，来实现API访问的身份验证。
    const cred = new Credential();
    const config = new Config.Config({
    credential: cred,
    // 设置Endpoint。
    endpoint: endpoint,
    // 设置HTTP代理。
    // httpProxy: "http://xxx.xxx.xxx.xxx:9999",
    // 设置HTTPS代理。
    // httpsProxy: "https://username:password@xxx.xxx.xxx.xxx:9999",
  });
  return new CloudAuthClient(config);
}

async function deepfakeDetect(endpoint, request) {
    const client = createClient(endpoint);
    // 创建RuntimeObject实例并设置运行参数。
    const runtime = new RuntimeOptions([]);
    runtime.readTimeout=5000;
    runtime.connectTimeout=5000;
    return await client.deepfakeDetectWithOptions(request, runtime);
}

async function deepfakeDetectAutoRoute(request) {
    const endpoints = [
        "cloudauth.cn-shanghai.aliyuncs.com",
        "cloudauth.cn-beijing.aliyuncs.com"
    ];

    for (const endpoint of endpoints) {
        try {
            const response = await deepfakeDetect(endpoint, request);
            if (response.statusCode === 500) {
                continue;
            }
            if(response.body !== null){
                if(response.body.code === "500"){
                    continue;
                }
            }
            return response;
        } catch (err) {
            console.log(err);
            continue;
        }
    }
    return null;
}

async function main(){
    // 通过以下代码创建API请求并设置参数。
    const request = new CloudAuth.DeepfakeDetectRequest({
        outerOrderNo: "123456*******",
        faceInputType: "IMAGE",
        faceUrl: "https://xxx.xxx.xxx.xxx",
    });

    // 推荐，支持服务路由。
    const response = await deepfakeDetectAutoRoute(request);
    // 不支持服务自动路由。
    // const response = await deepfakeDetect("cloudauth.cn-shanghai.aliyuncs.com", request);
   if (response){
    console.log(response.body.requestId);
    console.log(response.body.code);
    console.log(response.body.message);
    console.log(response.body.resultObject.result);
    console.log(response.body.resultObject.riskTag);
    }
}

main().then(function (response) {});