Upload de Documentos

// Criar sem documento
const tx = await client.transactions.create({
  purpose: 'DOCUMENT_SIGNATURE',
  policy: { profile: 'CLICK_ONLY' },
  signer: { name: 'João Silva', userExternalId: 'user-001' },
});
console.log(tx.status); // CREATED

// Upload separado
const updated = await client.documents.upload(tx.transactionId, {
  content: pdfBase64,
  filename: 'contrato.pdf',
});
console.log(updated.status); // DOCUMENT_UPLOADED

from signdocs_brasil.models import UploadDocumentRequest

# Criar sem documento
tx = client.transactions.create(CreateTransactionRequest(
    purpose='DOCUMENT_SIGNATURE',
    policy=Policy(profile='CLICK_ONLY'),
    signer=Signer(name='João Silva', user_external_id='user-001'),
))

# Upload separado
updated = client.documents.upload(
    tx.transaction_id,
    UploadDocumentRequest(content=pdf_base64, filename='contrato.pdf'),
)

// Criar sem documento
tx, _ := client.Transactions.Create(ctx, &signdocs.CreateTransactionRequest{
    Purpose: signdocs.TransactionPurposeDocumentSignature,
    Policy:  signdocs.Policy{Profile: signdocs.PolicyProfileClickOnly},
    Signer:  signdocs.Signer{Name: "João Silva", UserExternalID: "user-001"},
})

// Upload separado
updated, _ := client.Documents.Upload(ctx, tx.TransactionID, &signdocs.UploadDocumentRequest{
    Content:  pdfBase64,
    Filename: "contrato.pdf",
})

// Criar sem documento
CreateTransactionRequest request = new CreateTransactionRequest();
request.purpose = "DOCUMENT_SIGNATURE";
request.policy = new Policy("CLICK_ONLY");
request.signer = new Signer("João Silva", null, "user-001");
Transaction tx = client.transactions().create(request);

// Upload separado
Transaction updated = client.documents().upload(tx.transactionId,
    new UploadDocumentRequest(pdfBase64, "contrato.pdf"));

// Criar sem documento
$tx = $client->transactions->create(new CreateTransactionRequest(
    purpose: 'DOCUMENT_SIGNATURE',
    policy: new Policy(profile: 'CLICK_ONLY'),
    signer: new Signer(name: 'João Silva', userExternalId: 'user-001'),
));

// Upload separado
$updated = $client->documents->upload($tx->transactionId,
    new UploadDocumentRequest(content: $pdfBase64, filename: 'contrato.pdf'));

const presign = await client.documents.presign(tx.transactionId, {
  contentType: 'application/pdf',
  filename: 'contrato.pdf',
});
console.log(presign.uploadUrl);     // URL S3 temporária
console.log(presign.uploadToken);   // Token para confirmar upload
console.log(presign.s3Key);         // Chave do objeto no S3
console.log(presign.expiresIn);     // Tempo de expiração em segundos
console.log(presign.contentType);   // application/pdf
console.log(presign.instructions);  // Instruções de upload

from signdocs_brasil.models import PresignRequest

presign = client.documents.presign(tx.transaction_id, PresignRequest(
    content_type='application/pdf',
    filename='contrato.pdf',
))
print(presign.upload_url)
print(presign.upload_token)
print(presign.s3_key)
print(presign.expires_in)
print(presign.content_type)

presign, _ := client.Documents.Presign(ctx, tx.TransactionID, &signdocs.PresignRequest{
    ContentType: "application/pdf",
    Filename:    "contrato.pdf",
})
fmt.Println(presign.UploadURL)
fmt.Println(presign.UploadToken)
fmt.Println(presign.S3Key)
fmt.Println(presign.ExpiresIn)
fmt.Println(presign.ContentType)

PresignResponse presign = client.documents().presign(tx.transactionId,
    new PresignRequest("application/pdf", "contrato.pdf"));
System.out.println(presign.uploadUrl);
System.out.println(presign.getUploadToken());
System.out.println(presign.s3Key);
System.out.println(presign.expiresIn);
System.out.println(presign.contentType);

$presign = $client->documents->presign($tx->transactionId, new PresignRequest(
    contentType: 'application/pdf',
    filename: 'contrato.pdf',
));
echo $presign->uploadUrl;
echo $presign->uploadToken;
echo $presign->s3Key;
echo $presign->expiresIn;
echo $presign->contentType;

const fileBuffer = fs.readFileSync('contrato.pdf');

await fetch(presign.uploadUrl, {
  method: 'PUT',
  headers: { 'Content-Type': presign.contentType },
  body: fileBuffer,
});

import requests

with open('contrato.pdf', 'rb') as f:
    file_content = f.read()

requests.put(
    presign.upload_url,
    headers={'Content-Type': presign.content_type},
    data=file_content,
)

fileContent, _ := os.ReadFile("contrato.pdf")

req, _ := http.NewRequest("PUT", presign.UploadURL, bytes.NewReader(fileContent))
req.Header.Set("Content-Type", presign.ContentType)
http.DefaultClient.Do(req)

byte[] fileContent = Files.readAllBytes(Path.of("contrato.pdf"));

HttpRequest uploadReq = HttpRequest.newBuilder()
    .uri(URI.create(presign.uploadUrl))
    .header("Content-Type", presign.contentType)
    .PUT(HttpRequest.BodyPublishers.ofByteArray(fileContent))
    .build();
HttpClient.newHttpClient().send(uploadReq, HttpResponse.BodyHandlers.discarding());

$fileContent = file_get_contents('contrato.pdf');

$ch = curl_init($presign->uploadUrl);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
curl_setopt($ch, CURLOPT_POSTFIELDS, $fileContent);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: ' . $presign->contentType,
]);
curl_exec($ch);
curl_close($ch);

const confirmed = await client.documents.confirm(tx.transactionId, {
  uploadToken: presign.uploadToken,
});
console.log(confirmed.status); // DOCUMENT_UPLOADED

from signdocs_brasil.models import ConfirmDocumentRequest

confirmed = client.documents.confirm(tx.transaction_id, ConfirmDocumentRequest(
    upload_token=presign.upload_token,
))

confirmed, _ := client.Documents.Confirm(ctx, tx.TransactionID, &signdocs.ConfirmDocumentRequest{
    UploadToken: presign.UploadToken,
})

Transaction confirmed = client.documents().confirm(tx.transactionId,
    new ConfirmDocumentRequest(presign.getUploadToken()));

$confirmed = $client->documents->confirm($tx->transactionId, new ConfirmDocumentRequest(
    uploadToken: $presign->uploadToken,
));

const download = await client.documents.download(tx.transactionId);
console.log(download.downloadUrl);  // URL pré-assinada (expira em minutos)
console.log(download.filename);     // contrato.pdf
console.log(download.contentType);  // application/pdf

download = client.documents.download(tx.transaction_id)
print(download.download_url)
print(download.filename)

download, _ := client.Documents.Download(ctx, tx.TransactionID)
fmt.Println(download.DownloadURL)
fmt.Println(download.Filename)

DownloadResponse download = client.documents().download(tx.transactionId);
System.out.println(download.downloadUrl);
System.out.println(download.filename);

$download = $client->documents->download($tx->transactionId);
echo $download->downloadUrl;
echo $download->filename;