Verifying Assets

import { Que } from "que-sdk";

const que = new Que({
  apiKeyAuth: process.env["QUE_API_KEY_AUTH"] ?? "",
});

const asset = {
  bucket: 'que-signed-assets',
  key: 'a1b2c3d4/signed-photo.jpg',
};

async function verifyAsset() {
  try {
    const result = await que.verifyAsset({
      asset,
      includeCertificates: true,
    });
    const report = JSON.parse(result.report);

    console.log('Verification successful. Report:', report);
  } catch (error) {
    console.error('Verification failed:', error);
  }
}

verifyAsset();

import os
import json
from que_media import Que

with Que(
    api_key_auth=os.getenv("QUE_API_KEY_AUTH", ""),
) as que:

    try:
        result = que.verify_asset(asset={
            "bucket": "que-signed-assets",
            "key": "a1b2c3d4/signed-photo.jpg"
        }, mode="summary", include_certificates=True)

        report = json.loads(result.report)
        print(f"Verification successful. Report: {report}")
    except Exception as e:
        print(f"Verification failed: {e}")

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"os"

	"github.com/que-platform/que-sdk-go"
)

func main() {
	client := quesdk.NewClient(os.Getenv("QUE_API_KEY"))

	asset := quesdk.AssetReference{
		Bucket: "que-signed-assets",
		Key:    "a1b2c3d4/signed-photo.jpg",
	}

	result, err := client.Verify(context.Background(), &quesdk.VerifyRequest{
		Asset: asset,
	})
	if err != nil {
		fmt.Printf("Verification failed: %v\n", err)
		return
	}

	var report map[string]interface{}
	json.Unmarshal([]byte(result.Report), &report)
	fmt.Printf("Verification successful. Report: %+v\n", report)
}

// The Que SDK for Rust is not yet available.
// The following is a conceptual example.
use que_sdk::{QueClient, types::{AssetReference, VerifyRequest}};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = QueClient::new(std::env::var("QUE_API_KEY")?);

    let asset = AssetReference::S3 {
        bucket: "que-signed-assets".to_string(),
        key: "a1b2c3d4/signed-photo.jpg".to_string(),
    };

    let request = VerifyRequest { asset, ..Default::default() };
    let result = client.verify(request).await?;
    let report: serde_json::Value = serde_json::from_str(&result.report)?;

    println!("Verification successful. Report: {}", report);
    Ok(())
}

package hello.world;

import java.lang.Exception;
import org.openapis.openapi.Que;
import org.openapis.openapi.models.components.*;
import org.openapis.openapi.models.errors.ProblemResponseException;
import org.openapis.openapi.models.operations.VerifyAssetResponse;

public class VerifyAssetExample {

    public static void main(String[] args) throws ProblemResponseException, ProblemResponseException, ProblemResponseException, Exception {

        Que sdk = Que.builder()
                .apiKeyAuth(System.getenv().getOrDefault("API_KEY_AUTH", ""))
            .build();

        VerifyRequest req = VerifyRequest.builder()
                .asset(AssetRefDto.of(S3.builder()
                    .bucket("que-signed-assets")
                    .key("a1b2c3d4/signed-photo.jpg")
                    .build()))
                .includeCertificates(true)
                .build();

        VerifyAssetResponse res = sdk.verifyAsset()
                .request(req)
                .call();

        if (res.verifyResponse().isPresent()) {
            System.out.println("Verification successful. Report: " + res.verifyResponse().get().report());
        }
    }
}

<?php
declare(strict_types=1);

require 'vendor/autoload.php';

use Que;
use Que\Models\Components;

$sdk = Que\Que::builder()
    ->setSecurity(getenv('QUE_API_KEY_AUTH') ?: '')
    ->build();

$verifyRequest = new Components\VerifyRequest(
    asset: new Components\S3(
        bucket: 'que-signed-assets',
        key: 'a1b2c3d4/signed-photo.jpg'
    ),
    mode: Components\VerifyRequestMode::Detailed
);

try {
    $response = $sdk->verifyAsset(
        request: $verifyRequest
    );

    if ($response->verifyResponse !== null) {
        $report = json_decode($response->verifyResponse->report);
        print_r($report);
    }
} catch (Exception $e) {
    echo 'Verification failed: ' . $e->getMessage();
}