Webhooks

import crypto from 'node:crypto';

function verify(rawBody, signatureHeader, secret) {
  const expected = crypto
    .createHmac('sha256', secret)
    .update(rawBody)
    .digest('hex');
  const received = signatureHeader.replace(/^sha256=/, '');
  const a = Buffer.from(expected, 'hex');
  const b = Buffer.from(received, 'hex');
  return a.length === b.length && crypto.timingSafeEqual(a, b);
}

using System.Security.Cryptography;
using System.Text;

static bool Verify(string rawBody, string signatureHeader, string secret)
{
    var key = Encoding.UTF8.GetBytes(secret);
    var payload = Encoding.UTF8.GetBytes(rawBody);
    using var hmac = new HMACSHA256(key);
    var expected = Convert.ToHexString(hmac.ComputeHash(payload)).ToLowerInvariant();
    var received = signatureHeader.Replace("sha256=", "");
    return CryptographicOperations.FixedTimeEquals(
        Encoding.ASCII.GetBytes(expected),
        Encoding.ASCII.GetBytes(received));
}

import hmac, hashlib

def verify(raw_body: bytes, signature_header: str, secret: str) -> bool:
    expected = hmac.new(secret.encode(), raw_body, hashlib.sha256).hexdigest()
    received = signature_header.removeprefix("sha256=")
    return hmac.compare_digest(expected, received)

export enum WebhookAction {
  UpdateOperation = 0,
  DocumentSigned = 1,
  CompletedOperation = 2,
  // 3 e 4 são obsoletos
  DocumentReady = 5,
  AttachmentFilled = 6,
  FormFilled = 7,
  SelfieCaptured = 8,
}

export interface WebhookPayload<T = OperationData> {
  Action: WebhookAction;
  ActionDescription: keyof typeof WebhookAction;
  Success: boolean;
  Message: string;
  CreatedAt: string;
  CompanyId: number | null;
  OperationId: number | null;
  OperationMemberId: number | null;
  Data: T;
}

export interface OperationData {
  Id: number;
  OperationCompanyId: number;
  CompanyId: number;
  Name: string;
  ExternalId: string | null;
  CreatedAt: string;
  Status: number;
  Stage: number;
  Source: string;
  Version: number;
  HasManualFinish: boolean;
  Members?: MemberData[];
  Member?: MemberData;
  Files: FileData[];
  Metadata: { Key: string; Value: string }[];
}

export interface MemberData {
  Id: number;
  Name: string;
  Email: string;
  Phone: string;
  Order: number;
  Role: string;
  Observer: boolean;
  Attachments: AttachmentData[];
  FormFields: FormFieldData[];
  AntifraudResults?: AntifraudResult[];
}

export interface FileData {
  Id: number;
  ExternalId: string;
  Name: string;
  OriginalName: string;
  Description: string;
  Size: string;
  TotalPages: number;
  Updated: boolean;
}

export interface AttachmentData {
  Id: number;
  MemberId: number;
  Name: string;
  FileType: string;
  Status: string;
  Required: boolean;
}

export interface FormFieldData {
  Id: number;
  Name: string;
  Type: string;
  FieldType: string;
  Value: string;
  Required: boolean | null;
}

export interface AntifraudResult {
  Approved: boolean;
  Score: number | null;
  NumberOfAttempts: number;
  Timestamp: string | null;
  ValidationType: 'Liveness' | 'FacialCpfSerpro' | 'CpfSerpro';
}

public enum WebhookAction
{
    UpdateOperation = 0,
    DocumentSigned = 1,
    CompletedOperation = 2,
    DocumentReady = 5,
    AttachmentFilled = 6,
    FormFilled = 7,
    SelfieCaptured = 8,
}

public record WebhookPayload(
    WebhookAction Action,
    string ActionDescription,
    bool Success,
    string Message,
    DateTime CreatedAt,
    long? CompanyId,
    long? OperationId,
    long? OperationMemberId,
    OperationData Data);

public record OperationData(
    long Id,
    long OperationCompanyId,
    long CompanyId,
    string Name,
    string? ExternalId,
    int Status,
    int Stage,
    List<MemberData>? Members,
    MemberData? Member,
    List<FileData> Files);

public record MemberData(long Id, string Name, string Email,
    List<FormFieldData> FormFields, List<AntifraudResult>? AntifraudResults);