AIGCFaceVerify

<?php


namespace AlibabaCloud\SDK\Sample\Verify\LRFR;

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

class AIGCFaceVerify
{
    /**
     * 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 AIGCFaceVerifyRequest([
            // 请输入场景ID。
            "sceneId" => 0,
            "outerOrderNo" => "<xxx>",
            // 要接入的认证方案，固定值：LR_FR_AIGC。
            "productCode" => "<LR_FR_AIGC>",
            // 请在以下方式中选择一种，传入人脸图片。
            // 方式一：人脸图片Base64。
            // "faceContrastPicture" => "<人脸图片Base64编码>",
            // 方式二：人脸图片OSS Bucket名和文件名。
            // "ossBucketName" => "<cn-shanghai-aliyun-cloudauth-xxxxx>",
            // "ossObjectName" => "<verify/xxxxx/xxxxxx.jpeg>",
            // 方式三：人脸图片的OSS URL地址。该地址必须公网可访问。
            "faceContrastPictureUrl" => "<https://cn-shanghai-aliyun-cloudauth-xxxxxx.oss-cn-shanghai.aliyuncs.com/verify/xxxxx/xxxxx.jpeg>"
        ]);
        // 推荐，支持服务路由。
        $response = self::aigcFaceVerifyAutoRoute($request);
        // 不支持服务自动路由。
        // $response = self::aigcFaceVerify("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->score);
        var_dump($response->body->resultObject->certifyId);
    }

    /**
     * aigcFaceVerifyAutoRoute
     * @param AIGCFaceVerifyRequest $request
     * @return AIGCFaceVerifyResponse|null
     */
    public static function aigcFaceVerifyAutoRoute(AIGCFaceVerifyRequest $request): ?AIGCFaceVerifyResponse
    {
        $endpoints = [
            "cloudauth.cn-shanghai.aliyuncs.com",
            "cloudauth.cn-beijing.aliyuncs.com"
        ];
        foreach($endpoints as $endpoint){
            try {
                $response = self::aigcFaceVerify($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;
    }

    /**
     * aigcFaceVerify
     * @param string $endpoint
     * @param AIGCFaceVerifyRequest $request
     * @return AIGCFaceVerifyResponse
     */
    public static function aigcFaceVerify(string $endpoint, AIGCFaceVerifyRequest $request): AIGCFaceVerifyResponse
    {
        $client = self::createClient($endpoint);
        // 创建RuntimeObject实例并设置运行参数。
        $runtime = new RuntimeOptions([]);
        $runtime->readTimeout = 10000;
        $runtime->connectTimeout = 10000;
        return $client->aIGCFaceVerifyWithOptions($request, $runtime);
    }
}
$path = __DIR__ . \DIRECTORY_SEPARATOR . \DIRECTORY_SEPARATOR . 'vendor' . \DIRECTORY_SEPARATOR . 'autoload.php';
if (file_exists($path)) {
    require_once $path;
}
AIGCFaceVerify::main();

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 AIGCFaceVerify:
    def __init__(self):
        pass

    @staticmethod
    def create_client(
            endpoint: str,
    ) -> CloudauthClient:
        # 阿里云账号AccessKey拥有所有API的访问权限，建议您使用RAM用户进行API访问或日常运维。
        # 强烈建议不要把AccessKey ID和AccessKey Secret保存到工程代码里，否则可能导致AccessKey泄露，威胁您账号下所有资源的安全。
        # 本示例通过阿里云Credentials工具从环境变量中读取AccessKey，来实现API访问的身份验证。
        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.AIGCFaceVerifyRequest(
            # 请输入场景ID。
            scene_id=0,
            outer_order_no='xxx',
            # 固定值。
            product_code='LR_FR_AIGC',

            # 方式一：照片Base64。
            # face_contrast_picture='人脸照片Base64编码'
            # 方式二：照片OSS Bucket名和文件名。
            # oss_bucket_name='cn-shanghai-aliyun-cloudauth-xxxxx',
            # oss_object_name='verify/xxxxx/xxxxxx.jpeg',
            # 方式三：照片OSS的URL地址，公网可访问。
            face_contrast_picture_url='https://cn-shanghai-aliyun-cloudauth-xxxxxx.oss-cn-shanghai.aliyuncs.com/verify/xxxxx/xxxxx.jpeg'
        )
        response = AIGCFaceVerify.aigc_face_verif_auto_route(request)
        # 不支持服务自动路由。
        # response = AIGCFaceVerify.aigc_face_verify('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.score)
        print(response.body.result_object.certify_id)

    @staticmethod
    def aigc_face_verif_auto_route(
            request: cloudauth_models.AIGCFaceVerifyRequest,
    ) -> cloudauth_models.AIGCFaceVerifyResponse:
        endpoints = [
            'cloudauth.cn-shanghai.aliyuncs.com',
            'cloudauth.cn-beijing.aliyuncs.com'
        ]
        for endpoint in endpoints:
            try:
                response = AIGCFaceVerify.aigc_face_verify(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:
                continue
        return None

    @staticmethod
    def aigc_face_verify(
            endpoint: str,
            request: cloudauth_models.AIGCFaceVerifyRequest,
    ) -> cloudauth_models.AIGCFaceVerifyResponse:
        client = AIGCFaceVerify.create_client(endpoint)
        # 创建RuntimeObject实例并设置运行参数。
        runtime = util_models.RuntimeOptions()
        runtime.read_timeout = 10000
        runtime.connect_timeout = 10000
        return client.a_igcface_verify_with_options(request, runtime)


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

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.AIGCFaceVerifyRequest{
		// 固定值。
		ProductCode: tea.String("LR_FR_AIGC"),
		// 请输入场景ID。
		SceneId: tea.Int64(xxxx),
		OuterOrderNo: tea.String("xxx"),

		// 方式一：照片Base64。
		// FaceContrastPicture: tea.String("人脸照片Base64编码"),
		// 方式二：照片OSS Bucket名和文件名。
		// OssBucketName: tea.String("cn-shanghai-aliyun-cloudauth-xxxxx"),
		// OssObjectName: tea.String("verify/xxxxx/xxxxxx.jpeg"),
		// 方式三：照片OSS的URL地址，公网可访问。
		FaceContrastPictureUrl: tea.String("https://cn-shanghai-aliyun-cloudauth-xxxxxx.oss-cn-shanghai.aliyuncs.com/verify/xxxxx/xxxxx.jpeg"),
	}
	response, _err := AIGCFaceVerifyAutoRoute(request)

	// 不支持服务自动路由。
	// response, _err := AIGCFaceVerify(tea.String("cloudauth.cn-shanghai.aliyuncs.com"), request)

	if _err != nil {
		return _err
	}

	if response != nil {
		fmt.Println(*response.Body.RequestId)
		fmt.Println(*response.Body.Code)
		fmt.Println(*response.Body.Message)
		fmt.Println(*response.Body.RequestId)
		fmt.Println(*response.Body.ResultObject.Result)
		fmt.Println(*response.Body.ResultObject.Score)
		fmt.Println(*response.Body.ResultObject.CertifyId)
	}

	return _err
}

func AIGCFaceVerifyAutoRoute(request *cloudauth.AIGCFaceVerifyRequest) (_result *cloudauth.AIGCFaceVerifyResponse, _err error) {
	endpoints := []*string{tea.String("cloudauth.cn-shanghai.aliyuncs.com"), tea.String("cloudauth.cn-beijing.aliyuncs.com")}
	var lastResponse *cloudauth.AIGCFaceVerifyResponse
	for _, endpoint := range endpoints {
		response, _err := AIGCFaceVerify(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 AIGCFaceVerify(endpoint *string, request *cloudauth.AIGCFaceVerifyRequest) (_result *cloudauth.AIGCFaceVerifyResponse, _err error) {
	client, _err := CreateClient(endpoint)
	if _err != nil {
		return _result, _err
	}

	// 创建RuntimeObject实例并设置运行参数。
	runtime := &util.RuntimeOptions{}
	runtime.ReadTimeout = tea.Int(10000)
	runtime.ConnectTimeout = tea.Int(10000)

	_body, _err := client.AIGCFaceVerifyWithOptions(request, runtime)
	if _err != nil {
		return _result, _err
	}
	_result = _body
	return _result, _err
}

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

using System;

using System.Collections.Generic;
using Tea;

namespace AIGCFaceVerify
{
    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.AIGCFaceVerifyRequest request = new AlibabaCloud.SDK.Cloudauth20190307.Models.AIGCFaceVerifyRequest
            {
                // 固定值。
                ProductCode = "LR_FR_AIGC",
                // 请输入场景ID。
                SceneId = xxx,
                OuterOrderNo = "xxx",

                // 方式一：照片Base64。
                //FaceContrastPicture = "人脸照片Base64编码",
                // 方式二：照片OSS Bucket名和文件名。
                // OssBucketName = "cn-shanghai-aliyun-cloudauth-xxxxx",
                // OssObjectName = "verify/xxxxx/xxxxxx.jpeg",
                // 方式三：照片OSS的URL地址，公网可访问。
                FaceContrastPictureUrl = "https://cn-shanghai-aliyun-cloudauth-xxxxxx.oss-cn-shanghai.aliyuncs.com/verify/xxxxx/xxxxx.jpeg",
            };
            AlibabaCloud.SDK.Cloudauth20190307.Models.AIGCFaceVerifyResponse response = AigcFaceVerifyAutoRoute(request);
            // 不支持服务自动路由。
            // AlibabaCloud.SDK.Cloudauth20190307.Models.AIGCFaceVerifyResponse response = AigcFaceVerify("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.Score);
            Console.WriteLine(response.Body.ResultObject.CertifyId);
        }


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

            foreach (var endpoint in endpoints)
            {
                try
                {
                    AlibabaCloud.SDK.Cloudauth20190307.Models.AIGCFaceVerifyResponse response = AigcFaceVerify(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.AIGCFaceVerifyResponse AigcFaceVerify(string endpoint, AlibabaCloud.SDK.Cloudauth20190307.Models.AIGCFaceVerifyRequest request)
        {
            AlibabaCloud.SDK.Cloudauth20190307.Client client = CreateClient(endpoint);
            // 创建RuntimeObject实例并设置运行参数。
            AlibabaCloud.TeaUtil.Models.RuntimeOptions runtime = new AlibabaCloud.TeaUtil.Models.RuntimeOptions();
            runtime.ReadTimeout = 10000;
            runtime.ConnectTimeout = 10000;
            return client.AIGCFaceVerifyWithOptions(request, runtime);
        }
    }
}

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');
const fs = require("fs");

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 aigcFaceVerify(endpoint, request) {
    const client = createClient(endpoint);
    // 创建RuntimeObject实例并设置运行参数。
    const runtime = new RuntimeOptions([]);
    runtime.readTimeout=10000;
    runtime.connectTimeout=10000;
    return await client.aIGCFaceVerifyWithOptions(request, runtime);
}

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

    for (const endpoint of endpoints) {
        try {
            const response = await aigcFaceVerify(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.AIGCFaceVerifyRequest({
        // 请输入场景ID。
        sceneId: xxx,
        // 设置商户请求的唯一标识。
        outerOrderNo: "xxx",
        // 要接入的认证方案。
        productCode: "LR_FR_AIGC",
      
        // 请在以下方式中选择一种，传入人脸图片。
        // 方式一：人脸图片Base64。
        // faceContrastPicture: "人脸图片Base64编码",
        // 方式二：人脸图片OSS bucket名和文件名。
        // ossBucketName: "cn-shanghai-aliyun-cloudauth-xxxxx",
        // ossObjectName: "verify/xxxxx/xxxxxx.jpeg",
        // 方式三：人脸图片的OSS URL地址。该地址必须公网可访问。
        faceContrastPictureUrl: "https://cn-shanghai-aliyun-cloudauth-xxxxxx.oss-cn-shanghai.aliyuncs.com/verify/xxxxx/xxxxx.jpeg"
    });

    // 推荐，支持服务路由。
    const response = await aigcFaceVerifyAutoRoute(request);
    // 不支持服务自动路由。
    // const response = await aigcFaceVerify("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.certifyId);
    console.log(response.body.resultObject.result);
    console.log(response.body.resultObject.score);
}
}
main().then(function (response) {});