Example #1
0
        public List <PW_Parameter> getTransactionResult()
        {
            List <PW_Parameter> ret = new List <PW_Parameter>();

            string message = string.Empty;

            foreach (E_PWINFO item in Enum.GetValues(typeof(E_PWINFO)).Cast <E_PWINFO>())
            {
                StringBuilder value      = new StringBuilder(10000);
                int           getInfoRet = Interop.PW_iGetResult((short)item, value, 10001);
                if (getInfoRet == 0)
                {
                    ret.Add(new PW_Parameter(item.ToString(), (ushort)item, value.ToString()));
                }
                if (getInfoRet == 0 && item == E_PWINFO.PWINFO_RESULTMSG)
                {
                    message = value.ToString();
                }
            }

            FormDisplayMessage fdm = new FormDisplayMessage();

            fdm.Show(message, 3000);

            return(ret);
        }
Example #2
0
        private int loopPP(int timeout = 0)
        {
            FormDisplayMessage fdm = new FormDisplayMessage();
            int ret     = 99;
            int counter = 0;

            do
            {
                ret = (int)E_PWRET.PWRET_TIMEOUT;
                if (counter > timeout && timeout > 0)
                {
                    return(ret);
                }
                counter++;
                Thread.Sleep(200);
                StringBuilder displayMessage = new StringBuilder(1000);
                //Debug.Print(string.Format("CALLED iPPEventLoop", displayMessage.ToString(), ret.ToString()));
                ret = Interop.PW_iPPEventLoop(displayMessage, (uint)1000);
                //Debug.Print(string.Format("CALLED iPPEventLoop COM MESSAGE {0} E RETORNO {1}", displayMessage.ToString(), ret.ToString()));

                if (ret == (int)E_PWRET.PWRET_DISPLAY)
                {
                    fdm.Show(displayMessage.ToString());
                }
            } while (ret == (int)E_PWRET.PWRET_NOTHING ||
                     ret == (int)E_PWRET.PWRET_DISPLAY);

            fdm.Close();
            fdm.Dispose();

            return(ret);
        }
        // Aguarda em loop a finalização da operação executada no PIN-pad, fazendo
        // os tratamento necessários dos retornos
        private int LoopPP()
        {
            int  ret;
            bool isFdmStarted = false;

            // Cria a janela para exibição de mensagens de interface
            FormDisplayMessage fdm = new FormDisplayMessage();

            // Loop executando até a finalização do comando de PIN-pad, seja ele com um erro
            // ou com sucesso
            do
            {
                // Chama o loop de eventos
                StringBuilder displayMessage = new StringBuilder(1000);
                ret = Interop.PW_iPPEventLoop(displayMessage, (uint)displayMessage.Capacity);

                // Caso tenha retornado uma mensagem para exibição, exibe
                if (ret == (int)E_PWRET.PWRET_DISPLAY)
                {
                    if (!isFdmStarted)
                    {
                        fdm.Start();
                        isFdmStarted = true;
                    }
                    fdm.ChangeText(displayMessage.ToString());
                }

                // Verifica se o operador abortou a operação no checkout
                if (isFdmStarted)
                {
                    if (fdm.isAborted())
                    {
                        // Aborta a operação em curso no PIN-pad
                        Interop.PW_iPPAbort();

                        // Atribui o retorno de aoperação cancelada
                        ret = (int)E_PWRET.PWRET_CANCEL;

                        break;
                    }
                }

                // Aguarda 200ms para chamar o loop de eventos novamente
                Thread.Sleep(200);
            } while (ret == (int)E_PWRET.PWRET_NOTHING || ret == (int)E_PWRET.PWRET_DISPLAY);

            // Fecha janela para exibição de mensagem
            if (isFdmStarted)
            {
                fdm.Stop();
            }

            // Registra o resultado final do loop de PIN-pad na janela de Debug
            Debug.Print(string.Format("PW_iPPEventLoop={0}", ret.ToString()));

            return(ret);
        }
        // Executa a captura de dado solicitada pela biblioteca
        private int ShowCorrespondingWindow(PW_GetData[] expectedData, ref FormDisplayQRcode fdqr)
        {
            int                ret   = 0;
            ushort             index = 0;
            FormDisplayMessage fdm;

            foreach (PW_GetData item in expectedData)
            {
                // Caso exista uma mensagem a ser exibida ao usuário antes da captura do dado
                if (item.szMsgPrevia.Length > 0)
                {
                    fdm = new FormDisplayMessage();
                    fdm.ShowDialog(item.szMsgPrevia, 3000);
                    fdm.Dispose();
                }

                ret = 0;
                switch (item.bTipoDeDado)
                {
                case 0:
                    Debug.Print(string.Format("ERRO!!! Item com valor zerado."));
                    return(ret);

                // Caso a automação trabalhe com captura de código de barras, necessário
                // implementar os casos que serão aceitos (digitado, leitor...), bem como
                //  as validações necessárias por tipo de código
                case (int)E_PWDAT.PWDAT_BARCODE:
                    ret = GetTypedDataFromUser(item);
                    return(ret);

                // Menu de opções
                case (int)E_PWDAT.PWDAT_MENU:
                    return(GetMenuFromUser(item));

                // Captura de dado digitado
                case (int)E_PWDAT.PWDAT_TYPED:
                    ret = GetTypedDataFromUser(item);
                    return(ret);

                // Autenticação de permissão de usuário
                case (int)E_PWDAT.PWDAT_USERAUTH:
                    ret = GetTypedDataFromUser(item);
                    return(ret);

                // Captura de dados do cartão
                case (int)E_PWDAT.PWDAT_CARDINF:
                    // Caso só seja aceito o modo de entrada de cartão digitado
                    if (item.ulTipoEntradaCartao == 1)
                    {
                        PW_GetData temp = item;
                        temp.wIdentificador = (ushort)E_PWINFO.PWINFO_CARDFULLPAN;
                        ret = GetTypedDataFromUser(temp);
                    }
                    // Caso seja aceito cartão lido pelo PIN-pad
                    else
                    {
                        ret = Interop.PW_iPPGetCard(index);
                        Debug.Print(string.Format("PW_iPPGetCard={0}", ret.ToString()));
                        if (ret == (int)E_PWRET.PWRET_OK)
                        {
                            ret = LoopPP();
                        }
                    }
                    return(ret);

                // Processamento offline do cartão
                case (int)E_PWDAT.PWDAT_CARDOFF:
                    ret = Interop.PW_iPPGoOnChip(index);
                    Debug.Print(string.Format("PW_iPPGoOnChip={0}", ret.ToString()));
                    if (ret == (int)E_PWRET.PWRET_OK)
                    {
                        ret = LoopPP();
                    }
                    return(ret);

                // Processamento online do cartão
                case (int)E_PWDAT.PWDAT_CARDONL:
                    ret = Interop.PW_iPPFinishChip(index);
                    Debug.Print(string.Format("PW_iPPFinishChip={0}", ret.ToString()));
                    if (ret == (int)E_PWRET.PWRET_OK)
                    {
                        ret = LoopPP();
                    }
                    return(ret);

                // Confirmação de dado no PIN-pad
                case (int)E_PWDAT.PWDAT_PPCONF:
                    ret = Interop.PW_iPPConfirmData(index);
                    Debug.Print(string.Format("PW_iPPConfirmData={0}", ret.ToString()));
                    if (ret == (int)E_PWRET.PWRET_OK)
                    {
                        ret = LoopPP();
                    }
                    return(ret);

                // Confirmação positiva PIN-pad
                case (int)E_PWDAT.PWDAT_PPDATAPOSCNF:
                    ret = Interop.PW_iPPPositiveConfirmation(index);
                    Debug.Print(string.Format("PW_iPPPositiveConfirmation={0}", ret.ToString()));
                    if (ret == (int)E_PWRET.PWRET_OK)
                    {
                        ret = LoopPP();
                    }
                    return(ret);

                // Comando genérico no PIN-pad
                case (int)E_PWDAT.PWDAT_PPGENCMD:
                    ret = Interop.PW_iPPGenericCMD(index);
                    Debug.Print(string.Format("PW_iPPGenericCMD={0}", ret.ToString()));
                    if (ret == (int)E_PWRET.PWRET_OK)
                    {
                        ret = LoopPP();
                    }
                    return(ret);

                // Senha do portador
                case (int)E_PWDAT.PWDAT_PPENCPIN:
                    ret = Interop.PW_iPPGetPIN(index);
                    Debug.Print(string.Format("PW_iPPGetPIN={0}", ret.ToString()));
                    if (ret == (int)E_PWRET.PWRET_OK)
                    {
                        ret = LoopPP();
                    }
                    return(ret);

                // Entrada digitada no PIN-pad
                case (int)E_PWDAT.PWDAT_PPENTRY:
                    ret = Interop.PW_iPPGetData(index);
                    Debug.Print(string.Format("PW_iPPGetData={0}", ret.ToString()));
                    if (ret == (int)E_PWRET.PWRET_OK)
                    {
                        ret = LoopPP();
                    }
                    return(ret);

                // Remoção de cartão do PIN-pad
                case (int)E_PWDAT.PWDAT_PPREMCRD:
                    ret = Interop.PW_iPPRemoveCard();
                    Debug.Print(string.Format("PW_iPPRemoveCard={0}", ret.ToString()));
                    if (ret == (int)E_PWRET.PWRET_OK)
                    {
                        ret = LoopPP();
                    }
                    return(ret);

                // Exibição de mensagem de interface no display da automação
                case (int)E_PWDAT.PWDAT_DSPCHECKOUT:
                    fdm = new FormDisplayMessage();
                    fdm.Start();
                    fdm.ChangeText(item.szPrompt);
                    Thread.Sleep(1000);
                    // Caso o operador tenha apertado a tecla ESC, cancela a operação e aborta o comando do PINpad
                    if (fdm.isAborted())
                    {
                        // Aborta a operação em curso no PIN-pad
                        Interop.PW_iPPAbort();

                        // Atribui o retorno de aoperação cancelada
                        ret = (int)E_PWRET.PWRET_CANCEL;
                    }
                    fdm.Stop();

                    if (ret != (int)E_PWRET.PWRET_OK)
                    {
                        return(ret);
                    }
                    // Sinaliza a exibição da mensagem para a biblioteca
                    ret = Interop.PW_iAddParam(item.wIdentificador, "");
                    return((int)E_PWRET.PWRET_OK);

                // Exibição de QRcode no display da automação
                case (int)E_PWDAT.PWDAT_DSPQRCODE:

                    // Exemplo 2: A string com o QR Code é recebida e um QRcode é gerado utilizando uma biblioteca
                    // de terceiros, para compilar essa opção é necessário descomentar a função AtualizaQRCode na classe FormDisplayQRcode
                    // e instalar a biblioteca  MessagingToolkit.QRCode em seu Visual studio através do gerenciador de pacotes
                    // com o comando "Install-Package MessagingToolkit.QRCode -ProjectName PGWLib"
                    StringBuilder stringQRcode = new StringBuilder(5001);

                    // Tenta obter o valor do QRcode a ser exibido, caso não ache retorna operação cancelada
                    if (Interop.PW_iGetResult((short)E_PWINFO.PWINFO_AUTHPOSQRCODE, stringQRcode, 5001) != (int)E_PWRET.PWRET_OK)
                    {
                        return((int)E_PWRET.PWRET_CANCEL);
                    }

                    // Exibe o QRcode e o prompt
                    fdqr.Start();

                    // Para esse caso em específico o QR code é muito grande para exibir no display "padrão"
                    // Somente para esse exemplo, liga o autoSize da janela
                    fdqr.ChangeText(item.szPrompt, stringQRcode.ToString());

                    // Caso o operador tenha apertado a tecla ESC, cancela a operação e aborta o comando do PINpad
                    if (fdqr.isAborted())
                    {
                        // Aborta a operação em curso no PIN-pad
                        Interop.PW_iPPAbort();

                        fdqr.Stop();

                        // Atribui o retorno de aoperação cancelada
                        return((int)E_PWRET.PWRET_CANCEL);
                    }

                    // Sinaliza a exibição do QRcode para a biblioteca
                    ret = Interop.PW_iAddParam(item.wIdentificador, "");
                    return((int)E_PWRET.PWRET_OK);

                default:
                    break;
                }
                index++;
            }
            return(ret);
        }
        // Executa a captura de dado solicitada pela biblioteca
        private int ShowCorrespondingWindow(PW_GetData[] expectedData)
        {
            int    ret   = 0;
            ushort index = 0;

            foreach (PW_GetData item in expectedData)
            {
                // Caso exista uma mensagem a ser exibida ao usuário antes da captura do dado
                if (item.szMsgPrevia.Length > 0)
                {
                    FormDisplayMessage fdm = new FormDisplayMessage();
                    fdm.ShowDialog(item.szMsgPrevia, 3000);
                    fdm.Dispose();
                }

                ret = 0;
                switch (item.bTipoDeDado)
                {
                case 0:
                    Debug.Print(string.Format("ERRO!!! Item com valor zerado."));
                    return(ret);

                // Caso a automação trabalhe com captura de código de barras, necessário
                // implementar os casos que serão aceitos (digitado, leitor...), bem como
                //  as validações necessárias por tipo de código
                case (int)E_PWDAT.PWDAT_BARCODE:
                    ret = GetTypedDataFromUser(item);
                    return(ret);

                // Menu de opções
                case (int)E_PWDAT.PWDAT_MENU:
                    return(GetMenuFromUser(item));

                // Captura de dado digitado
                case (int)E_PWDAT.PWDAT_TYPED:
                    ret = GetTypedDataFromUser(item);
                    return(ret);

                // Autenticação de permissão de usuário
                case (int)E_PWDAT.PWDAT_USERAUTH:
                    ret = GetTypedDataFromUser(item);
                    return(ret);

                // Captura de dados do cartão
                case (int)E_PWDAT.PWDAT_CARDINF:
                    // Caso só seja aceito o modo de entrada de cartão digitado
                    if (item.ulTipoEntradaCartao == 1)
                    {
                        PW_GetData temp = item;
                        temp.wIdentificador = (ushort)E_PWINFO.PWINFO_CARDFULLPAN;
                        ret = GetTypedDataFromUser(temp);
                    }
                    // Caso seja aceito cartão lido pelo PIN-pad
                    else
                    {
                        ret = Interop.PW_iPPGetCard(index);
                        Debug.Print(string.Format("PW_iPPGetCard={0}", ret.ToString()));
                        if (ret == (int)E_PWRET.PWRET_OK)
                        {
                            ret = LoopPP();
                        }
                    }
                    return(ret);

                // Processamento offline do cartão
                case (int)E_PWDAT.PWDAT_CARDOFF:
                    ret = Interop.PW_iPPGoOnChip(index);
                    Debug.Print(string.Format("PW_iPPGoOnChip={0}", ret.ToString()));
                    if (ret == (int)E_PWRET.PWRET_OK)
                    {
                        ret = LoopPP();
                    }
                    return(ret);

                // Processamento online do cartão
                case (int)E_PWDAT.PWDAT_CARDONL:
                    ret = Interop.PW_iPPFinishChip(index);
                    Debug.Print(string.Format("PW_iPPFinishChip={0}", ret.ToString()));
                    if (ret == (int)E_PWRET.PWRET_OK)
                    {
                        ret = LoopPP();
                    }
                    return(ret);

                // Confirmação de dado no PIN-pad
                case (int)E_PWDAT.PWDAT_PPCONF:
                    ret = Interop.PW_iPPConfirmData(index);
                    Debug.Print(string.Format("PW_iPPConfirmData={0}", ret.ToString()));
                    if (ret == (int)E_PWRET.PWRET_OK)
                    {
                        ret = LoopPP();
                    }
                    return(ret);

                // Confirmação positiva PIN-pad
                case (int)E_PWDAT.PWDAT_PPDATAPOSCNF:
                    ret = Interop.PW_iPPPositiveConfirmation(index);
                    Debug.Print(string.Format("PW_iPPPositiveConfirmation={0}", ret.ToString()));
                    if (ret == (int)E_PWRET.PWRET_OK)
                    {
                        ret = LoopPP();
                    }
                    return(ret);

                // Comando genérico no PIN-pad
                case (int)E_PWDAT.PWDAT_PPGENCMD:
                    ret = Interop.PW_iPPGenericCMD(index);
                    Debug.Print(string.Format("PW_iPPGenericCMD={0}", ret.ToString()));
                    if (ret == (int)E_PWRET.PWRET_OK)
                    {
                        ret = LoopPP();
                    }
                    return(ret);

                // Senha do portador
                case (int)E_PWDAT.PWDAT_PPENCPIN:
                    ret = Interop.PW_iPPGetPIN(index);
                    Debug.Print(string.Format("PW_iPPGetPIN={0}", ret.ToString()));
                    if (ret == (int)E_PWRET.PWRET_OK)
                    {
                        ret = LoopPP();
                    }
                    return(ret);

                // Entrada digitada no PIN-pad
                case (int)E_PWDAT.PWDAT_PPENTRY:
                    ret = Interop.PW_iPPGetData(index);
                    Debug.Print(string.Format("PW_iPPGetData={0}", ret.ToString()));
                    if (ret == (int)E_PWRET.PWRET_OK)
                    {
                        ret = LoopPP();
                    }
                    return(ret);

                // Remoção de cartão do PIN-pad
                case (int)E_PWDAT.PWDAT_PPREMCRD:
                    ret = Interop.PW_iPPRemoveCard();
                    Debug.Print(string.Format("PW_iPPRemoveCard={0}", ret.ToString()));
                    if (ret == (int)E_PWRET.PWRET_OK)
                    {
                        ret = LoopPP();
                    }
                    return(ret);

                default:
                    break;
                }
                index++;
            }
            return(ret);
        }