Cancelar Archivo PFX

using System;
using System.IO;
using System.Threading.Tasks;

 public class CancelarPFXRequest
 {
      public string Apikey { get; set; }
      public string FilePFX { get; set; }
      public string PassPFX { get; set; }
      public string Uuid { get; set; }
      public string RfcEmisor { get; set; }
      public string RfcReceptor { get; set; }
      public double Total { get; set; }
      public string Motivo { get; set; }
      public string FolioSustitucion { get; set; }
 }

 public async Task<RespuestaCancelar> CancelarCfdiPfxAsync(CancelarPFXRequest request)
  {
      using var client = new ServicioTimbradoWSPortTypeClient("ServicioTimbradoWSPort");
      try
      {
          var response = await client.cancelarPFX2Async(
              request.Apikey, request.FilePFX, request.PassPFX, 
              request.Uuid, request.RfcEmisor, request.RfcReceptor, 
              request.Total, request.Motivo, request.FolioSustitucion
          );
          return new RespuestaCancelar { Code = response.code, Message = response.message, Data = response.data, Status = response.status };
      }
      catch (Exception ex)
      {
         Console.WriteLine($"Error al cancelar CFDI con PFX: {ex.Message}");
         throw;
      }
  }

  public class RespuestaCancelar
 {
    public string? Code { get; set; }
    public string? Message { get; set; }
    public string? Data { get; set; }
    public string? Status { get; set; }
 }

 // Ejemplo de uso
 public async Task EjemploUsoCancelarPfxAsync()
 {
     var request = new CancelarPFXRequest
     {
         Apikey = "TU_API_KEY_AQUI",
         FilePFX = Convert.ToBase64String(File.ReadAllBytes("ruta/al/certificado.pfx")),
         PassPFX = "tu_contraseña_pfx",
         Uuid = "5FD4E09E-52F4-4A0E-8E4D-39E6B8E47168",
         RfcEmisor = "ABC010101XYZ",
         RfcReceptor = "XAXX010101000",
         Total = 116.00,
         Motivo = "01",
         FolioSustitucion = "8E4D39E6-B8E4-4A0E-52F4-5FD4E09E7168"
     };

     var resultado = await CancelarCfdiPfxAsync(request);

     if (resultado?.Status == "success")
     {
         Console.WriteLine("¡Cancelación Exitosa!");
         Console.WriteLine($"Mensaje: {resultado.Message}");
         Console.WriteLine("Acuse:");
         Console.WriteLine(resultado.Data);
     }
     else
     {
         Console.WriteLine($"Error: {resultado?.Code} - {resultado?.Message}");
     }
 }

import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Base64;
import java.util.concurrent.CompletableFuture;

public class CancelarPfxService {

  // ... (Definición de ExecutorService, Logger, etc.)

  public CompletableFuture<RespuestaCancelar> cancelarPfxAsync(String apiKey, String filePFX, String passPFX, String uuid, String rfcEmisor, String rfcReceptor, double total, String motivo, String folioSustitucion) {
      return CompletableFuture.supplyAsync(() -> {
          try {
              ServicioTimbradoWS service = new ServicioTimbradoWS();
              ServicioTimbradoWSPortType port = service.getServicioTimbradoWSPort();
              
              Respuesta response = port.cancelarPFX2(apiKey, filePFX, passPFX, uuid, rfcEmisor, rfcReceptor, total, motivo, folioSustitucion);

              RespuestaCancelar resultado = new RespuestaCancelar();
              resultado.setCode(response.getCode());
              resultado.setMessage(response.getMessage());
              resultado.setData(response.getData());
              resultado.setStatus(response.getStatus());
              return resultado;

          } catch (Exception ex) {
              throw new RuntimeException("Error al cancelar CFDI con PFX", ex);
          }
      }, executor);
  }

  // Ejemplo de uso
  public static void main(String[] args) {
      CancelarPfxService service = new CancelarPfxService();
      String apiKey = "TU_API_KEY_AQUI";
      try {
          String filePFX = Base64.getEncoder().encodeToString(Files.readAllBytes(Paths.get("ruta/al/certificado.pfx")));
          String passPFX = "tu_contraseña_pfx";
          String uuid = "5FD4E09E-52F4-4A0E-8E4D-39E6B8E47168";
          String rfcEmisor = "ABC010101XYZ";
          String rfcReceptor = "XAXX010101000";
          double total = 116.00;
          String motivo = "01";
          String folioSustitucion = "8E4D39E6-B8E4-4A0E-52F4-5FD4E09E7168";

          service.cancelarPfxAsync(apiKey, filePFX, passPFX, uuid, rfcEmisor, rfcReceptor, total, motivo, folioSustitucion)
              .whenComplete((resultado, ex) -> {
                  if (ex != null) {
                      System.err.println("Error: " + ex.getMessage());
                  } else if ("success".equals(resultado.getStatus())) {
                      System.out.println("¡Cancelación Exitosa!");
                      System.out.println("Acuse: " + resultado.getData());
                  } else {
                      System.err.println("Error: " + resultado.getCode() + " - " + resultado.getMessage());
                  }
                  service.shutdown();
              }).join();
      } catch (IOException e) {
          System.err.println("No se pudo leer el archivo PFX.");
      }
  }
}

import asyncio
import base64
from zeep.asyncio import AsyncClient

class CancelarPfxService:
    def __init__(self, wsdl_url: str):
        self.wsdl_url = wsdl_url
        self.async_client = AsyncClient(self.wsdl_url)

    async def cancelar_pfx_async(self, **kwargs) -> dict:
        response = await self.async_client.service.cancelarPFX2(**kwargs)
        return response

async def main():
    service = CancelarPfxService("https://dev.facturaloplus.com/ws/servicio.do?wsdl")
    api_key = "TU_API_KEY_AQUI"
    
    with open("ruta/al/certificado.pfx", "rb") as pfx_file:
        pfx_b64 = base64.b64encode(pfx_file.read()).decode('utf-8')

    params = {
        "apikey": api_key,
        "filePFX": pfx_b64,
        "passPFX": "tu_contraseña_pfx",
        "uuid": "5FD4E09E-52F4-4A0E-8E4D-39E6B8E47168",
        "rfcEmisor": "ABC010101XYZ",
        "rfcReceptor": "XAXX010101000",
        "total": 116.00,
        "motivo": "01",
        "folioSustitucion": "8E4D39E6-B8E4-4A0E-52F4-5FD4E09E7168"
    }

    resultado = await service.cancelar_pfx_async(**params)

    if resultado and resultado['status'] == 'success':
        print("¡Cancelación Exitosa!")
        print(f"Mensaje: {resultado['message']}")
        print(f"Acuse: {resultado['data']}")
    else:
        print(f"Error: {resultado['code']} - {resultado['message']}")

if __name__ == "__main__":
    asyncio.run(main())

<?php
class CancelarPfxService {
    private string $wsdlUrl;

    public function __construct(string $wsdlUrl) {
        $this->wsdlUrl = $wsdlUrl;
    }

    public function cancelarPfx(array $params): ?object {
        try {
            $soapClient = new SoapClient($this->wsdlUrl, ['trace' => 1, 'exceptions' => true]);
            $response = $soapClient->cancelarPFX2($params);
            return $response->return ?? null;
        } catch (Exception $e) {
            echo "Error: " . $e->getMessage();
            return null;
        }
    }
}

// Ejemplo de uso
$service = new CancelarPfxService("https://dev.facturaloplus.com/ws/servicio.do?wsdl");
$apiKey = "TU_API_KEY_AQUI";

$pfx_path = "ruta/al/certificado.pfx";

$params = [
    'apikey'          => $apiKey,
    'filePFX'         => base64_encode(file_get_contents($pfx_path)),
    'passPFX'         => "tu_contraseña_pfx",
    'uuid'            => "5FD4E09E-52F4-4A0E-8E4D-39E6B8E47168",
    'rfcEmisor'       => "ABC010101XYZ",
    'rfcReceptor'     => "XAXX010101000",
    'total'           => 116.00,
    'motivo'          => "01",
    'folioSustitucion'=> "8E4D39E6-B8E4-4A0E-52F4-5FD4E09E7168"
];

$resultado = $service->cancelarPfx($params);

header('Content-Type: text/plain');
if ($resultado && $resultado->status === 'success') {
    echo "¡Cancelación Exitosa!\n";
    echo "Mensaje: {$resultado->message}\n";
    echo "Acuse: {$resultado->data}\n";
} else {
    echo "Error: {$resultado->code} - {$resultado->message}\n";
}
?>