react-native-mesmart 0.7.4 → 1.0.0

package/android/src/main/java/com/stone/StoneImpl.kt

@@ -0,0 +1,270 @@
+package com.stone
+
+import br.com.stone.posandroid.providers.PosPrintReceiptProvider
+import br.com.stone.posandroid.providers.PosTransactionProvider
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.mesmart.Utils
+import com.stone.utils.StoneUtils
+import com.stone.utils.TransactionObjectMapper
+import stone.application.StoneStart
+import stone.application.enums.Action
+import stone.application.enums.InstalmentTransactionEnum
+import stone.application.enums.ReceiptType
+import stone.application.interfaces.StoneActionCallback
+import stone.application.interfaces.StoneCallbackInterface
+import stone.database.transaction.TransactionObject
+import stone.providers.BaseTransactionProvider
+import stone.providers.CancellationProvider
+import stone.providers.CaptureTransactionProvider
+import stone.utils.Stone
+import stone.utils.keys.StoneKeyType
+
+class StoneImpl(
+  private val reactContext: ReactApplicationContext
+) {
+  private var transaction: TransactionObject? = null
+  private var paymentProvider: BaseTransactionProvider? = null
+  var stoneCode = ""
+  var isActivated = false
+
+  private fun sendEvent(
+    reactContext: ReactContext,
+    params: WritableMap?
+  ) {
+    reactContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit("onStoneEventData", params)
+  }
+
+  private fun checkStone() {
+    if (!isActivated)
+      throw Exception("Stone não foi ativado.")
+  }
+
+  fun activate(providerId: String, authorization: String, appName: String) {
+    if (isActivated)
+      throw Exception("Stone já foi ativado.")
+
+    val userList = StoneStart.init(reactContext, mapOf(
+      StoneKeyType.QRCODE_PROVIDERID    to providerId,
+      StoneKeyType.QRCODE_AUTHORIZATION to authorization,
+    ))
+    Stone.setAppName(appName)
+
+    val userWithStoneCode = userList?.find { it.stoneCode.isNotEmpty() }
+    if (userList != null && userWithStoneCode != null)
+      stoneCode = userWithStoneCode.stoneCode
+
+    isActivated = true
+  }
+
+  fun pay(value: String, paymentMethod: String, isCapture: Boolean, promise: Promise) {
+    checkStone()
+
+    transaction = TransactionObject()
+    transaction!!.amount = value
+    transaction!!.instalmentTransaction = InstalmentTransactionEnum.getAt(0)
+    transaction!!.typeOfTransaction = StoneUtils.resolveTransactionType(paymentMethod)
+    transaction!!.isCapture = isCapture
+
+    paymentProvider = PosTransactionProvider(
+      reactContext,
+      transaction,
+      Stone.getUserModel(0)
+    )
+    paymentProvider?.useDefaultUI(true)
+    paymentProvider?.setConnectionCallback(object: StoneActionCallback {
+      override fun onSuccess() {
+        sendEvent(
+          reactContext,
+          Arguments.createMap().apply {
+            putString("type", "onSuccess")
+            putString("status", StoneUtils.resolveTransactionStatus(paymentProvider?.transactionStatus))
+            putString("statusEnum", paymentProvider?.transactionStatus?.name.orEmpty())
+            putString("authorizationCode", paymentProvider?.authorizationCode.orEmpty())
+            putString("action", StoneUtils.resolveActionCode(transaction?.actionCode))
+            putString("actionCode", transaction?.actionCode.orEmpty())
+            putString("messageFromAuthorize", paymentProvider?.messageFromAuthorize.orEmpty())
+          }
+        )
+
+        transaction?.let {
+          promise.resolve(
+            TransactionObjectMapper.toWritableMap(it)
+          )
+        }
+
+        paymentProvider = null
+        transaction = null
+      }
+
+      override fun onError() {
+        sendEvent(
+          reactContext,
+          Arguments.createMap().apply {
+            putString("type", "onError")
+            putString("status", StoneUtils.resolveTransactionStatus(paymentProvider?.transactionStatus))
+            putString("statusEnum", paymentProvider?.transactionStatus?.name.orEmpty())
+            putString("messageFromAuthorize", paymentProvider?.messageFromAuthorize.orEmpty())
+            putString("action", StoneUtils.resolveActionCode(transaction?.actionCode))
+            putString("actionCode", transaction?.actionCode.orEmpty())
+            putArray("listOfErrors",
+              StoneUtils.convertErrorsEnumToReadableArray(
+                paymentProvider?.listOfErrors,
+                true
+              )
+            )
+            putArray("listOfErrorsEnum",
+              StoneUtils.convertErrorsEnumToReadableArray(
+                paymentProvider?.listOfErrors,
+                false)
+            )
+          }
+        )
+
+        transaction?.let {
+          promise.resolve(
+            TransactionObjectMapper.toWritableMap(it)
+          )
+        }
+
+        paymentProvider = null
+        transaction = null
+      }
+
+      override fun onStatusChanged(action: Action?) {
+        sendEvent(
+          reactContext,
+          Arguments.createMap().apply {
+            putString("type", "onStatusChanged")
+            putString("action", StoneUtils.resolveTransactionAction(action))
+            putString("actionEnum", action?.name.orEmpty())
+            if (action == Action.TRANSACTION_WAITING_QRCODE_SCAN)
+              putString("qrCode", Utils.bitmapToBase64(transaction?.qrCode))
+          }
+        )
+      }
+    })
+    paymentProvider?.execute()
+  }
+
+  fun abortPayment() {
+    checkStone()
+    paymentProvider?.abortPayment()
+  }
+
+  fun printVia(transaction: TransactionObject, type: ReceiptType, promise: Promise) {
+    checkStone()
+
+    val provider = PosPrintReceiptProvider(
+      reactContext,
+      transaction,
+      type
+    )
+    provider.connectionCallback = object: StoneCallbackInterface {
+      override fun onSuccess() {
+        promise.resolve(null)
+      }
+
+      override fun onError() {
+        promise.reject(
+          "listOfErrors: ${
+            StoneUtils.convertErrorsEnumToReadableArray(provider.listOfErrors, true)
+          }\n" +
+          "listOfErrorsEnums: ${provider.listOfErrors}"
+        )
+      }
+    }
+    provider.execute()
+  }
+
+  fun captureTransaction(transaction: TransactionObject, promise: Promise) {
+    checkStone()
+
+    val provider = CaptureTransactionProvider(reactContext, transaction)
+    provider.connectionCallback = object: StoneCallbackInterface {
+      override fun onSuccess() {
+        promise.resolve(
+          Arguments.createMap().apply {
+            putString("responseCode", provider.responseCodeEnum.name)
+            putString("messageFromAuthorize", provider.messageFromAuthorize.orEmpty())
+            putMap("transaction",
+              TransactionObjectMapper.toWritableMap(
+                provider.transactionObject
+              )
+            )
+          }
+        )
+      }
+
+      override fun onError() {
+        promise.reject(
+          "Falha ao tentar capturar transação.\n" +
+          "responseCode: ${
+            try {
+              provider.responseCodeEnum
+            } catch (e: Exception) {
+              null
+            }
+          }\n" +
+          "messageFromAuthorize: ${provider.messageFromAuthorize}\n" +
+          "listOfErrors: ${
+            StoneUtils.convertErrorsEnumToReadableArray(provider.listOfErrors, true)
+          }\n" +
+          "listOfErrorsEnum: ${provider.listOfErrors}"
+        )
+      }
+    }
+    provider.execute()
+  }
+
+  fun cancelTransaction(transaction: TransactionObject, promise: Promise) {
+    checkStone()
+
+    val provider = CancellationProvider(reactContext, transaction)
+    provider.connectionCallback = object: StoneCallbackInterface {
+      override fun onSuccess() {
+        promise.resolve(
+          Arguments.createMap().apply {
+            putString("action", StoneUtils.resolveActionCode(provider.Cancellation().actionCode))
+            putString("actionCode", provider.Cancellation().actionCode.orEmpty())
+            putString("responseCode", provider.responseCodeEnum.name)
+            putString("messageFromAuthorize", provider.messageFromAuthorize.orEmpty())
+            putMap(
+              "transaction",
+              TransactionObjectMapper.toWritableMap(
+                transaction
+              )
+            )
+          }
+        )
+      }
+
+      override fun onError() {
+        promise.reject(
+          "Falha ao tentar cancelar transação.\n" +
+          "action: ${StoneUtils.resolveActionCode(provider.Cancellation().actionCode)}\n" +
+          "actionCode: ${provider.Cancellation().actionCode}\n" +
+          "responseCode: ${
+            try {
+              provider.responseCodeEnum
+            } catch (e: Exception) {
+              null
+            }
+          }\n" +
+          "messageFromAuthorize: ${provider.messageFromAuthorize}\n" +
+          "listOfErrors: ${
+            StoneUtils.convertErrorsEnumToReadableArray(provider.listOfErrors, true)
+          }\n" +
+          "listOfErrorsEnum: ${provider.listOfErrors}"
+        )
+      }
+    }
+    provider.execute()
+  }
+}

package/android/src/main/java/com/stone/StoneModule.kt

@@ -0,0 +1,121 @@
+package com.stone
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.stone.utils.TransactionObjectMapper
+import stone.application.enums.ReceiptType
+
+class StoneModule(
+  reactContext: ReactApplicationContext
+) : ReactContextBaseJavaModule(reactContext) {
+  private var stone: StoneImpl = StoneImpl(reactContext)
+
+  override fun getName(): String {
+    return "Stone"
+  }
+
+  @ReactMethod
+  fun init(keys: ReadableMap, appName: String, promise: Promise) {
+    try {
+      val providerId = keys.getString("providerId").orEmpty()
+      val authorization = keys.getString("authorization").orEmpty()
+
+      if (providerId.isEmpty())
+        throw Exception("providerId não pode ser vazio!")
+      if (authorization.isEmpty())
+        throw Exception("authorization não pode ser vazio!")
+      if (appName.isEmpty())
+        throw Exception("appName não pode ser vazio!")
+
+      stone.activate(providerId, authorization, appName)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      e.printStackTrace()
+      promise.reject(e)
+    }
+  }
+
+  @ReactMethod
+  fun isActivated(promise: Promise) {
+    try {
+      promise.resolve(stone.isActivated)
+    } catch (e: Exception) {
+      e.printStackTrace()
+      promise.reject(e)
+    }
+  }
+
+  @ReactMethod
+  fun getStoneCode(promise: Promise) {
+    try {
+      promise.resolve(stone.stoneCode)
+    } catch (e: Exception) {
+      e.printStackTrace()
+      promise.reject(e)
+    }
+  }
+
+  @ReactMethod
+  fun pay(value: String, paymentMethod: String, isCapture: Boolean, promise: Promise) {
+    try {
+      stone.pay(value, paymentMethod, isCapture, promise)
+    } catch (e: Exception) {
+      e.printStackTrace()
+      promise.reject(e)
+    }
+  }
+
+  @ReactMethod
+  fun abortPayment(promise: Promise) {
+    try {
+      stone.abortPayment()
+      promise.resolve(null)
+    } catch (e: Exception) {
+      e.printStackTrace()
+      promise.reject(e)
+    }
+  }
+
+  @ReactMethod
+  fun printVia(data: ReadableMap, type: String, promise: Promise) {
+    try {
+      stone.printVia(
+        TransactionObjectMapper.fromReadableMap(data),
+        ReceiptType.valueOf(type.uppercase()),
+        promise
+      )
+    } catch (e: Exception) {
+      e.printStackTrace()
+      promise.reject(e)
+    }
+  }
+
+  @ReactMethod
+  fun captureTransaction(data: ReadableMap, promise: Promise) {
+    try {
+      stone.captureTransaction(
+        TransactionObjectMapper.fromReadableMap(data),
+        promise
+      )
+    } catch (e: Exception) {
+      e.printStackTrace()
+      promise.reject(e)
+    }
+  }
+
+  @ReactMethod
+  fun cancelTransaction(data: ReadableMap, promise: Promise) {
+    try {
+      stone.cancelTransaction(
+        TransactionObjectMapper.fromReadableMap(data),
+        promise
+      )
+    } catch (e: Exception) {
+      e.printStackTrace()
+      promise.reject(e)
+    }
+  }
+}

package/android/src/main/java/com/stone/utils/StoneUtils.kt

@@ -0,0 +1,282 @@
+package com.stone.utils
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.WritableNativeArray
+import stone.application.enums.Action
+import stone.application.enums.ErrorsEnum
+import stone.application.enums.TransactionStatusEnum
+import stone.application.enums.TypeOfTransactionEnum
+
+object StoneUtils {
+  fun resolveTransactionType(str: String): TypeOfTransactionEnum? {
+    return when(str) {
+      "debitCard" -> TypeOfTransactionEnum.DEBIT
+      "creditCard" -> TypeOfTransactionEnum.CREDIT
+      "voucher" -> TypeOfTransactionEnum.VOUCHER
+      "pix" -> TypeOfTransactionEnum.PIX
+      else -> null
+    }
+  }
+
+  fun resolveTransactionStatus(transactionStatus: TransactionStatusEnum?): String {
+    return when (transactionStatus) {
+      TransactionStatusEnum.UNKNOWN -> "Ocorreu um erro antes de ser enviada para o autorizador"
+      TransactionStatusEnum.APPROVED -> "Transação aprovada com sucesso"
+      TransactionStatusEnum.DECLINED -> "Transação negada"
+      TransactionStatusEnum.DECLINED_BY_CARD -> "Transação negada pelo cartão"
+      TransactionStatusEnum.CANCELLED -> "Transação cancelada"
+      TransactionStatusEnum.REJECTED -> "Transação rejeitada"
+      TransactionStatusEnum.WITH_ERROR -> "Transação não completada com sucesso"
+      TransactionStatusEnum.PENDING_REVERSAL -> "Transação foi interrompida por algum motivo"
+      TransactionStatusEnum.PENDING -> "O provider de transação está em andamento"
+      TransactionStatusEnum.REVERSED -> "A transação foi cancelada automaticamente devido à algum erro ou interrupção no fluxo de pagamento"
+      null -> ""
+      else -> ""
+    }
+  }
+
+  fun resolveTransactionAction(action: Action?): String {
+    return when (action) {
+      Action.TRANSACTION_WAITING_CARD -> "Aproxime ou insira o cartão de pagamento"
+      Action.TRANSACTION_WAITING_SWIPE_CARD -> ""
+      Action.TRANSACTION_WAITING_QRCODE_SCAN -> "Aguardando pagamento do QRCode"
+      Action.TRANSACTION_WAITING_PASSWORD -> "Informe a senha do seu cartão"
+      Action.TRANSACTION_SENDING -> "Aguardando resposta da operadora"
+      Action.TRANSACTION_REMOVE_CARD -> "Por favor, remova o seu cartão"
+      Action.REVERSING_TRANSACTION_WITH_ERROR -> ""
+      Action.TRANSACTION_CARD_REMOVED -> "Cartão removido"
+      Action.TRANSACTION_TYPE_SELECTION -> ""
+      Action.TRANSACTION_REQUIRES_CARDHOLDER_TO_CHECK_DEVICE -> ""
+      Action.SWITCH_INTERFACE -> ""
+      null -> ""
+      else -> ""
+    }
+  }
+
+  fun convertErrorsEnumToReadableArray(errors: List<ErrorsEnum>?, convertErrorToString: Boolean): ReadableArray {
+    val writableArray = WritableNativeArray()
+    errors?.forEach { error ->
+      writableArray.pushString(
+        if (convertErrorToString)
+          resolveTransactionErrors(error)
+        else error.name
+      )
+    }
+    return writableArray
+  }
+
+  fun resolveActionCode(actionCode: String?): String {
+    return when (actionCode) {
+      "1000" -> "Não aprovado"
+      "1001" -> "Cartão vencido"
+      "1002" -> "Suspeita de fraude"
+      "1003" -> "Estabelecimento entrar em contato com adquirente"
+      "1004" -> "Cartão com restrição"
+      "1005" -> "Estabelecimento entrar em contato com departamento de segurança do adquirente"
+      "1006" -> "Tentativas de senha excedidas"
+      "1007" -> "Consultar o emissor"
+      "1008" -> "Consultar as condições especiais do emissor"
+      "1009" -> "Estabelecimento inválido"
+      "1010" -> "Valor inválido"
+      "1011" -> "Cartão inválido"
+      "1012" -> "Senha necessária"
+      "1014" -> "Nenhuma conta do tipo selecionado"
+      "1015" -> "Função selecionada não suportada"
+      "1016" -> "Saldo insuficiente"
+      "1017" -> "Senha inválida"
+      "1019" -> "Transação não permitida para o portador"
+      "1020" -> "Transação não permitida para o terminal"
+      "1021" -> "Limite de valor para saque excedido"
+      "1022" -> "Violação de segurança"
+      "1023" -> "Limite de quantidade de saques excedido"
+      "1024" -> "Violação da lei"
+      "1025" -> "Cartão bloqueado"
+      "1026" -> "Dados de senha inválidos"
+      "1027" -> "Erro no tamanho da senha"
+      "1028" -> "Erro de sincronia de chave de senha"
+      "1029" -> "Suspeita de cartão falso"
+      "1030" -> "Moeda inaceitável para o emissor"
+      "1032" -> "Cartão perdido ou roubado"
+      "1035" -> "Conta encerrada"
+      "1036" -> "Conta poupança encerrada ou bloqueada para encerramento"
+      "1037" -> "Conta de crédito encerrada ou bloqueada para encerramento"
+      "1039" -> "Conta corrente encerrada ou bloqueada para encerramento"
+      "1041" -> "Status ruim para conta de origem"
+      "1042" -> "Status ruim para conta de destino"
+      "1045" -> "Código de segurança inválido"
+      "1047" -> "Troca de senha necessária"
+      "1048" -> "Nova senha inválida"
+      "1057" -> "Data de pagamento inválida"
+      "1060" -> "Transação não completou normalmente no terminal"
+      "1061" -> "Transação não suportada pelo emissor"
+      "1062" -> "Saque fácil não disponível"
+      "1063" -> "Limite de saque fácil excedido"
+      "1064" -> "Negado offline pelo terminal"
+      "1065" -> "Negado, não foi possível processar offline"
+      "2000" -> "Não aprovado"
+      "2001" -> "Cartão vencido"
+      "2002" -> "Suspeita de fraude"
+      "2003" -> "Estabelecimento entrar em contato com emissor"
+      "2004" -> "Cartão com restrição"
+      "2005" -> "Estabelecimento entrar em contato com departamento de segurança do adquirente"
+      "2006" -> "Tentativas de senha excedidas"
+      "2007" -> "Condições especiais"
+      "2008" -> "Cartão perdido"
+      "2009" -> "Cartão roubado"
+      "2010" -> "Suspeita de cartão falso"
+      "2011" -> "Limite de quantidade de saques excedido"
+      "2012" -> "Limite de valor para saque excedido"
+      "9100" -> "Erro no formato da mensagem"
+      "9102" -> "Transação inválida"
+      "9103" -> "Tente novamente"
+      "9105" -> "Adquirente não suportado pelo switch"
+      "9107" -> "Emissor fora de operação"
+      "9108" -> "Não foi possível enviar a transação para o destinatário"
+      "9109" -> "Erro no sistema"
+      "9110" -> "Emissor se desconectou"
+      "9111" -> "Emissor não respondeu em tempo"
+      "9112" -> "Emissor indisponível"
+      "9113" -> "Transmissão duplicada"
+      "9114" -> "Não foi possível encontrar a transação original"
+      "9116" -> "MAC incorreto"
+      "9117" -> "Erro de sincronização de chave de MAC"
+      "9118" -> "Nenhuma chave de comunicação disponível"
+      "9119" -> "Erro de sincronização de chave de encriptação"
+      "9120" -> "Erro de segurança de software/hardware, tente novamente"
+      "9121" -> "Erro de segurança de software/hardware"
+      "9122" -> "Número da mensagem fora de sequência"
+      "9123" -> "Requisição em progresso"
+      "9124" -> "Código de segurança inválido"
+      "9125" -> "Erro no banco de dados"
+      "9132" -> "Erro nos dados de recorrência"
+      "9133" -> "Atualização não permitida"
+      "9350" -> "Violação de acordo comercial"
+      "9999" -> "Erro não especificado"
+      "UNPR" -> "Não Foi possível processar – Não foi possível processar a mensagem. Tente novamente."
+      "IMSG" -> "Mensagem Invalida – A mensagem enviada possui um formato inválido."
+      "PARS" -> "Erro na leitura da mensagem – Algum campo obrigatório não está sendo enviado"
+      "SECU" -> "Segurança – Algum erro no processo de segurança. A chave de criptografia pode não estar presente no terminal."
+      "INTP" -> "SAK Invalido – O SAK enviado não foi reconhecido"
+      "RCPP" -> "Destinatário Invalido – O local para onde a mensagem foi enviada está inválida"
+      "DPMG" -> "Mensagem Duplicada – Esta mensagem já foi recebida pela Stone."
+      "VERS" -> "Protocolo – A versão do protocolo enviada não é suportada."
+      "MSGT" -> "Tipo da Mensagem – o Message Type enviado não é reconhecido."
+      else -> "Código de ação desconhecido"
+    }
+  }
+
+  private fun resolveTransactionErrors(error: ErrorsEnum?): String {
+    return when (error) {
+      ErrorsEnum.CARD_BLOCKED -> "Cartão bloqueado"
+      ErrorsEnum.CONNECTION_NOT_FOUND -> "Sem conexão com a internet, ligue a internet."
+      ErrorsEnum.DEVICE_NOT_COMPATIBLE -> "Dispositivo incompatível ou dependência não encontrada"
+      ErrorsEnum.UNEXPECTED_STATUS_COMMAND -> "Status inesperado do comando"
+      ErrorsEnum.GENERIC_ERROR -> "Erro genérico"
+      ErrorsEnum.IO_ERROR_WITH_PINPAD -> "Erro de comunicação com o pinpad"
+      ErrorsEnum.PINPAD_CONNECTION_NOT_FOUND -> "Conexão com o pinpad não encontrada"
+      ErrorsEnum.TABLES_NOT_FOUND -> ""
+      ErrorsEnum.NEED_LOAD_TABLES -> ""
+      ErrorsEnum.TIME_OUT -> "Tempo de operação esgotado"
+      ErrorsEnum.OPERATION_CANCELLED_BY_USER -> "Operação cancelada"
+      ErrorsEnum.CARD_REMOVED_BY_USER -> "Cartão removido"
+      ErrorsEnum.CANT_READ_CARD_HOLDER_INFORMATION -> "Não foi possível ler as informações do portador do cartão"
+      ErrorsEnum.INVALID_TRANSACTION -> "Transação inválida"
+      ErrorsEnum.PASS_TARGE_WITH_CHIP -> "Passe a tarja do cartão com chip"
+      ErrorsEnum.NULL_RESPONSE -> "Resposta nula recebida"
+      ErrorsEnum.ERROR_RESPONSE_COMMAND -> "Erro na resposta do comando"
+      ErrorsEnum.ACCEPTOR_REJECTION -> "Transação rejeitada pelo credenciador"
+      ErrorsEnum.EMAIL_MESSAGE_ERROR -> "Erro ao enviar mensagem de e-mail"
+      ErrorsEnum.INVALID_EMAIL_CLIENT -> "Cliente de e-mail inválido"
+      ErrorsEnum.EMAIL_EMPTY -> "E-mail vazio"
+      ErrorsEnum.EMAIL_RECIPIENT_EMPTY -> "Destinatário do e-mail vazio"
+      ErrorsEnum.INVALID_STONE_CODE_OR_UNKNOWN -> "Stone Code inválido ou desconhecido"
+      ErrorsEnum.TRANSACTION_NOT_FOUND -> "Transação não encontrada"
+      ErrorsEnum.INVALID_TRANSACTION_STATUS -> "Status de transação inválido"
+      ErrorsEnum.INVALID_STONECODE -> "Stone Code inválido"
+      ErrorsEnum.USERMODEL_NOT_FOUND -> "Modelo de usuário não encontrado"
+      ErrorsEnum.NO_PRINT_SUPPORT -> "Impressão não suportada"
+      ErrorsEnum.CANT_READ_CHIP_CARD -> "Não foi possível ler o cartão com chip"
+      ErrorsEnum.PINPAD_WITHOUT_KEY -> "Pinpad sem chave"
+      ErrorsEnum.PINPAD_WITHOUT_STONE_KEY -> "Pinpad sem chave Stone"
+      ErrorsEnum.PINPAD_ALREADY_CONNECTED -> "Pinpad já conectado"
+      ErrorsEnum.CONNECTIVITY_ERROR -> "Erro de conectividade"
+      ErrorsEnum.SWIPE_INCORRECT -> "Leitura incorreta, tente novamente"
+      ErrorsEnum.TOO_MANY_CARDS -> "Muitos cartões detectados"
+      ErrorsEnum.UNKNOWN_ERROR -> "Erro desconhecido"
+      ErrorsEnum.INTERNAL_ERROR -> "Erro interno"
+      ErrorsEnum.EMV_GENERIC_ERROR -> "Erro genérico de EMV"
+      ErrorsEnum.SWITCH_INTERFACE -> "Ocorreu um erro na leitura. Tente novamente inserindo o cartão"
+      ErrorsEnum.EMV_FAILED_CARD_CONN_ERROR -> "Falha ao comunicar com o cartão"
+      ErrorsEnum.EMV_NO_APP_ERROR -> "Método de pagamento não encontrado no cartão"
+      ErrorsEnum.EMV_INITIALIZATION_ERROR -> "Erro ao iniciar o fluxo de pagamento"
+      ErrorsEnum.EMV_CAPK_ERROR -> "Erro na configuração da chave pública"
+      ErrorsEnum.EMV_TLV_ERROR -> "Erro no formato dos dados de configuração"
+      ErrorsEnum.EMV_NO_CAPK_ERROR -> "Chave pública não presente"
+      ErrorsEnum.EMV_AID_ERROR -> "Erro ao configurar a aplicação de crédito/débito"
+      ErrorsEnum.PRINTER_GENERIC_ERROR -> "Erro genérico de impressão"
+      ErrorsEnum.PRINTER_BUSY_ERROR -> "Impressora ocupada"
+      ErrorsEnum.PRINTER_INIT_ERROR -> "Erro na inicialização da impressora"
+      ErrorsEnum.PRINTER_LOW_ENERGY_ERROR -> "Baixa energia na impressora"
+      ErrorsEnum.PRINTER_OUT_OF_PAPER_ERROR -> "Impressora sem papel"
+      ErrorsEnum.PRINTER_UNSUPPORTED_FORMAT_ERROR -> "Formato não suportado pela impressora"
+      ErrorsEnum.PRINTER_INVALID_DATA_ERROR -> "Dados inválidos para impressão"
+      ErrorsEnum.PRINTER_OVERHEATING_ERROR -> "Impressora superaquecida"
+      ErrorsEnum.PED_PASS_GENERIC_ERROR -> "Erro genérico na criptografia do PIN"
+      ErrorsEnum.PED_PASS_KEY_ERROR -> "Erro na chave de criptografia"
+      ErrorsEnum.PED_PASS_USER_CANCELED_ERROR -> "Operação cancelada pelo usuário"
+      ErrorsEnum.PED_PASS_NO_PIN_INPUT_ERROR -> "Nenhum PIN digitado"
+      ErrorsEnum.PED_PASS_TIMEOUT_ERROR -> "Tempo esgotado para entrada de PIN"
+      ErrorsEnum.PED_PASS_INIT_ERROR -> "Erro na inicialização do processo de criptografia do PIN"
+      ErrorsEnum.PED_PASS_CRYPT_ERROR -> "Erro de criptografia do PIN"
+      ErrorsEnum.PED_PASS_NO_KEY_FOUND_ERROR -> "Chave de criptografia não encontrada"
+      ErrorsEnum.TRANS_GENERIC_ERROR -> "Erro genérico de transação"
+      ErrorsEnum.TRANS_APP_BLOCKED_ERROR -> "Aplicação bloqueada"
+      ErrorsEnum.TRANS_SELECT_TYPE_USER_CANCELED_ERROR -> "Tipo de transação cancelado pelo usuário"
+      ErrorsEnum.TRANS_INVALID_AMOUNT_ERROR -> "Valor inválido para a transação"
+      ErrorsEnum.TRANS_PASS_MAG_BUT_IS_ICC_ERROR -> "Passe a tarja, mas é ICC"
+      ErrorsEnum.TRANS_NO_TRANS_TYPE_ERROR -> "Tipo de transação não especificado"
+      ErrorsEnum.TRANS_WRONG_TRANS_TYPE_ERROR -> "Tipo de transação incorreto"
+      ErrorsEnum.TRANS_APP_INVALID_ERROR -> "Aplicação inválida para o fluxo"
+      ErrorsEnum.TRANS_CVV_NOT_PROVIDED_ERROR -> "CVV não fornecido, mas é obrigatório"
+      ErrorsEnum.TRANS_CVV_INVALID_ERROR -> "CVV inválido"
+      ErrorsEnum.TRANS_APP_INVALID_INDEX_ERROR -> "Erro de índice de aplicação inválido"
+      ErrorsEnum.TRANS_ONLINE_PROCESS_ERROR_ERROR -> "Erro ao processar dados online"
+      ErrorsEnum.CARD_GENERIC_ERROR -> "Erro genérico do cartão"
+      ErrorsEnum.CARD_READ_ERROR -> "Erro na leitura do cartão"
+      ErrorsEnum.CARD_READ_TIMEOUT_ERROR -> "Nenhum cartão encontrado, operação cancelada"
+      ErrorsEnum.CARD_READ_CANCELED_ERROR -> "Leitura do cartão cancelada"
+      ErrorsEnum.CARD_UNSUPPORTED_ERROR -> "Cartão não suportado"
+      ErrorsEnum.CARD_READ_MULTI_ERROR -> "Múltiplos cartões detectados"
+      ErrorsEnum.TRANSACTION_FALLBACK_STARTED -> "Fallback de transação iniciado"
+      ErrorsEnum.TRANSACTION_FALLBACK_TIMEOUT -> "Tempo esgotado para fallback de transação"
+      ErrorsEnum.TRANSACTION_FALLBACK_INVALID_CARD_MODE -> "Modo de cartão inválido para fallback"
+      ErrorsEnum.NO_ACTIVE_APPLICATION -> "Nenhuma aplicação ativa disponível"
+      ErrorsEnum.MULTI_INSTANCES_OF_PROVIDER_RUNNING -> "Múltiplas instâncias do provedor em execução"
+      ErrorsEnum.UNKNOWN_TYPE_OF_USER -> "Tipo de usuário desconhecido"
+      ErrorsEnum.TRANSACTION_OBJECT_NULL_ERROR -> "Objeto de transação nulo"
+      ErrorsEnum.INVALID_AMOUNT -> "Valor inválido"
+      ErrorsEnum.APPNAME_NOT_SET -> "Nome do aplicativo não definido"
+      ErrorsEnum.SDK_VERSION_OUTDATED -> "Versão do SDK desatualizada"
+      ErrorsEnum.PINPAD_CLOSED_CONNECTION -> "Conexão com o pinpad fechada"
+      ErrorsEnum.NOT_STONE_POS_OR_POS_MISCONFIGURED -> "POS não é da Stone ou está mal configurado"
+      ErrorsEnum.COULD_NOT_ACTIVATE_ALL_STONE_CODES -> "Não foi possível ativar todos os Stone Codes"
+      ErrorsEnum.COULD_NOT_ACTIVATE_WITH_ACCEPTOR_CONFIGURATION_UPDATE_DATA_NULL -> "Não foi possível ativar com dados de atualização de configuração nulos"
+      ErrorsEnum.NO_MIFARE_SUPPORT -> "Suporte a MIFARE não disponível"
+      ErrorsEnum.MIFARE_ABORTED -> "Operação MIFARE abortada"
+      ErrorsEnum.MIFARE_DETECT_TIMEOUT -> "Tempo esgotado para detectar MIFARE"
+      ErrorsEnum.MIFARE_WRONG_CARD_TYPE -> "Tipo de cartão MIFARE incorreto"
+      ErrorsEnum.MIFARE_INVALID_KEY -> "Chave MIFARE inválida"
+      ErrorsEnum.MIFARE_NOT_AUTHENTICATED -> "MIFARE não autenticado"
+      ErrorsEnum.MIFARE_INVALID_SECTOR_NUMBER -> "Número de setor MIFARE inválido"
+      ErrorsEnum.MIFARE_INVALID_BLOCK_NUMBER -> "Número de bloco MIFARE inválido"
+      ErrorsEnum.MIFARE_INVALID_BLOCK_FORMAT -> "Formato de bloco MIFARE inválido"
+      ErrorsEnum.MIFARE_MULTI_CARD_DETECTED -> "Múltiplos cartões MIFARE detectados"
+      ErrorsEnum.DATA_CONTAINER_CONSTRAINT_ERROR -> "Erro de restrição do contêiner de dados"
+      ErrorsEnum.DATA_CONTAINER_INTEGRATION_ERROR -> "Erro de integração do contêiner de dados"
+      ErrorsEnum.QRCODE_NOT_GENERATED -> "Houve algum erro ao gerar o QRCode"
+      ErrorsEnum.QRCODE_EXPIRED -> "O QRcode expirou"
+      null -> "null"
+      else -> "Erro desconhecido"
+    }
+  }
+}