Iterando sobre uma operação de pagamento ou administrativa

using System;
using Cappta.Gp.Api.Com;

namespace CappAPIIntegration
{
    class Program
    {
        static void Main(string[] args)
        {
            //Não esqueça de realizar a autenticação e iniciar uma operação tef aqui \o/

            do
            {
                if (iteracaoTef is IMensagem)
                {
                    IMensagem mensagem = iteracaoTef as IMensagem;
                    Console.WriteLine(mensagem.Descricao);
                }

                else if(iteracaoTef is IRespostaTransacaoPendente)
                {
                    IRespostaTransacaoPendente transacoesPendentes = iteracaoTef as IRespostaTransacaoPendente;
                    Console.WriteLine(transacoesPendentes.Mensagem);

                    foreach (var transacao in transacoesPendentes.ListaTransacoesPendentes)
                    {
                        Console.WriteLine(transacoesPendentes.NumeroControle);
                        Console.WriteLine(transacoesPendentes.NomeBandeiraCartao);
                        Console.WriteLine(transacoesPendentes.NomeAdquirente);
                        Console.WriteLine(transacoesPendentes.Valor);
                        Console.WriteLine(transacoesPendentes.DataHoraAutorizacao);
                    }

                    // Enviamos o parametro com valor de "1" para confirmar a transação pendente e o parametro acao como 1 para avançar a operação.
                    cappta.EnviarParametro(parametro: "1", acao: 1);
                }

                else if(iteracaoTef is IRequisicaoParametro)
                {
                    IRequisicaoParametro reqParametro = iteracaoTef as IRequisicaoParametro;
                    Console.WriteLine(reqParametro.Mensagem);
                    string parametro = Console.ReadLine();

                    //Continue lendo que daqui a pouco já explicamos esta função ;)
                    cappta.EnviarParametro(parametro, String.IsNullOrWhiteSpace(parametro) ? 1 : 2);
                }

                iteracaoTef = cappta.IterarOperacaoTef();

            } while (PagamentoFinalizado(iteracaoTef) == false);

            //Agora basta tratar o resultado da iteração =D

            //Eiii o/, caso a operação seja um pagamento não esqueça de confirma-lo ou desfaze-lo aqui
        }

        public static bool PagamentoFinalizado(IIteracaoTef iteracaoTef)
        {
            return iteracaoTef is IRespostaOperacaoAprovada
                || iteracaoTef is IRespostaOperacaoRecusada;
        }
    }
}

program cappapiintegration;

uses Cappta_Gp_Api_Com_1_0_TLB, SysUtils;

var
  cappta : IClienteCappta;
  iteracaoTef : IIteracaoTef;
  tipoIteracao : integer;
  mensagem : IMensagem;
  reqParametro : IRequisicaoParametro;
  transacoesPendentes : IRespostaTransacaoPendente;
  parametro: string;
  acaoRequisicao: integer;
  transacoesPendentesSafeArray: PSafeArray;
  lBound, uBound, contadorTransacoesPendentes: LongInt;
  transacaoPendente: ITransacaoPendente;

begin
  // -- Não esqueça de realizar a autenticação e iniciar uma operação tef aqui \o/ --

  Repeat

    iteracaoTef := cappta.IterarOperacaoTef();
    tipoIteracao := iteracaoTef.Get_TipoIteracao;

    if tipoIteracao is IMensagem then
    begin
       mensagem := (iteracaoTef as IMensagem);
       WriteLn(mensagem.Get_Descricao);
    end;


    if tipoIteracao is IRespostaTransacaoPendente then
    begin
       transacoesPendentes := (iteracaoTef as IRespostaTransacaoPendente);
       WriteLn(transacoesPendentes.Get_Mensagem);

       transacoesPendentesSafeArray := transacoesPendentes.Get_ListaTransacoesPendentes;

       SafeArrayGetLBound(transacoesPendentesSafeArray, 1, lBound);
       SafeArrayGetUBound(transacoesPendentesSafeArray, 1, uBound);

       for Contador := lBound to uBound do
         begin
              SafeArrayGetElement(transacoesPendentesSafeArray, @contador, transacaoPendente);

              WriteLn(transacaoPendente.Get_numeroControle);
              WriteLn(transacaoPendente.Get_NomeBandeiraCartao);
              WriteLn(transacaoPendente.Get_NomeAdquirente);
              WriteLn(transacaoPendente.Get_valor);
              WriteLn(transacaoPendente.Get_DataHoraAutorizacao);
          end;

       // Enviamos o primeiro parametro com valor de "1" para confirmar a transação pendente e o segundo parametro com valor de 1 para avançar a operação.
       cappta.EnviarParametro('1', 1);
    end;



    if tipoIteracao is IRequisicaoParametro then
    begin
       reqParametro := (iteracaoTef as IRequisicaoParametro);
       WriteLn(reqParametro.Get_Mensagem);
       ReadLn(Input, parametro);

       if Length(parametro) = 0 then
       begin
         acaoRequisicao := 2;
         parametro := ' ';
       end
       else begin acaoRequisicao := 1; end;

       // -- Continue lendo que daqui a pouco já explicamos esta função ;) --

       cappta.EnviarParametro(parametro, acaoRequisicao);
    end;

  Until (iteracaoTef.Get_TipoIteracao <> 1) and (iteracaoTef.Get_TipoIteracao <> 2);

  // -- Agora basta tratar o resultado da iteração =D --

  // -- Eiii o/, caso a operação seja um pagamento não esqueça de confirma-lo ou desfaze-lo aqui --
end.

Imports Cappta.Gp.Api.Com
Imports Cappta.Gp.Api.Com.Model

Module Module1
    Sub Main()

        Dim cappta As New ClienteCappta()

        Dim iteracaoTef As IIteracaoTef

        Do
            iteracaoTef = cappta.IterarOperacaoTef()

            If TypeOf iteracaoTef Is IMensagem Then
                Dim mensagem As IMensagem = iteracaoTef
                Console.WriteLine(mensagem.Descricao)
            End If

            If TypeOf iteracaoTef Is IRequisicaoParametro Then

                Dim reqParametro As IRequisicaoParametro = iteracaoTef
                Console.WriteLine(reqParametro.Mensagem)

                Dim input = Console.ReadLine()
                Dim parametro As Integer

                If (String.IsNullOrWhiteSpace(input)) Then
                    parametro = 2
                Else
                    parametro = 1
                End If
                cappta.EnviarParametro(input, parametro)
            End If

            If TypeOf iteracaoTef Is IRespostaTransacaoPendente Then

                Dim transacoesPendentes As IRespostaTransacaoPendente = iteracaoTef

                For Each transacao In transacoesPendentes.ListaTransacoesPendentes
                    Console.WriteLine(transacao.NumeroControle)
                    Console.WriteLine(transacao.NomeBandeiraCartao)
                    Console.WriteLine(transacao.NomeAdquirente)
                    Console.WriteLine(transacao.Valor)
                    Console.WriteLine(transacao.DataHoraAutorizacao)

                Next
                'Enviamos o parametro com valor de "1" para confirmar a transação pendente e o parametro acao como 1 para avançar a operação.
                cappta.EnviarParametro("1", 1)

            End If

        Loop While PagamentoFinalizado(iteracaoTef) = False
    End Sub

    Function PagamentoFinalizado(iteracaoTef As IIteracaoTef)

        Return TypeOf iteracaoTef Is IRespostaOperacaoAprovada Or TypeOf iteracaoTef Is IRespostaOperacaoRecusada

    End Function


End Module

Public Sub IterarOperacaoTef(objCappta As ClienteCappta)
 
 If OptionUsarMultiTef.Value Then
    DesabilitarControlesMultiTef
 End If
 DesabilitarBotoes

 Dim iteracaoTef As Cappta_Gp_Api_Com.IIteracaoTef

 Do
 
    Set iteracaoTef = objCappta.IterarOperacaoTef()

    If TypeOf iteracaoTef Is IMensagem Then
        Call ExibirMensagem(iteracaoTef)
        Sleep INTERVALO_MILISEGUNDOS
    End If

    If TypeOf iteracaoTef Is IRequisicaoParametro Then
        Call RequisitarParametros(iteracaoTef, objCappta)
    End If

    If TypeOf iteracaoTef Is IRespostaTransacaoPendente Then
        Call ResolverTransacaoPendente(iteracaoTef, objCappta)
    End If

    If TypeOf iteracaoTef Is IRespostaOperacaoRecusada Then
        Call ExibirDadosOperacaoRecusada(iteracaoTef)
    End If

    If TypeOf iteracaoTef Is IRespostaOperacaoAprovada Then
        Call ExibirDadosOperacaoAprovada(iteracaoTef)
        Call FinalizarPagamento(objCappta)
    End If

  Loop While OperacaoNaoFinalizada(iteracaoTef)
  
  If sessaoMultiTefEmAndamento = False Then
    HabilitarControlesMultiTef
  End If
  HabilitarBotoes
  

End Sub

private void IterarOperacaoTef() {
        if (this.RadioButtonUsarMultiTef.isSelected()) {
            this.DesabilitarControlesMultiTef();
        }
        this.DesabilitarBotoes();
        IIteracaoTef iteracaoTef = null;

        do {
            iteracaoTef = cappta.iterarOperacaoTef();
            if (iteracaoTef.is(IMensagem.class)) {
                IMensagem iMensagem = iteracaoTef.queryInterface(IMensagem.class);
                ExibirMensagem(iMensagem);
            }

            if (iteracaoTef.is(IRequisicaoParametro.class)) {
                IRequisicaoParametro iRequisicaoParametro = iteracaoTef.queryInterface(IRequisicaoParametro.class);
                RequisitarParametros(iRequisicaoParametro);
            }

            if (iteracaoTef.is(IRespostaTransacaoPendente.class)) {
                IRespostaTransacaoPendente resposta = iteracaoTef.queryInterface(IRespostaTransacaoPendente.class);
                ResolverTransacaoPendente(resposta);
            }
            if (iteracaoTef.is(IRespostaOperacaoRecusada.class)) {
                IRespostaOperacaoRecusada resposta = iteracaoTef.queryInterface(IRespostaOperacaoRecusada.class);
                ExibirDadosOperacaoRecusada(resposta);
            }
            if (iteracaoTef.is(IRespostaOperacaoAprovada.class)) {
                IRespostaOperacaoAprovada resposta = iteracaoTef.queryInterface(IRespostaOperacaoAprovada.class);
                ExibirDadosOperacaoAprovada(resposta);
                FinalizarPagamento();
            }

        } while (OperacaoNaoFinalizada(iteracaoTef));

        if (this.sessaoMultiTefEmAndamento == false) {
            this.HabilitarControlesMultiTef();
        }//true
        HabilitarBotoes();
    }