Criando aplicação completa utilizando o Apple Pay
Artigo escrito por Fabrício Rodrigues Pujol e Henrique Conte
Durante a apresentação do dia 9 de setembro de 2014 a Apple apresentou o Apple Pay, sendo esse seu próprio sistema mobile de pagamentos.
O Apple Pay permite que usuários de aparelhos iPhone 6 e iPhone 6+, bem como versões mais novas de Apple Watch façam compras online e se beneficiem deste método. Existem duas maneiras de usar o Apple Pay para comprar itens: Near Field Communication(NFC) ou através de um aplicativo iOS.
Com este tutorial queremos que você parta de um aplicativo básico, que não contenha nada de implementação do Apple Pay, e seguindo todos os passos deste tutorial possa ser capaz de fazer a implementação do início até o fim, desde as instalações dos certificados até o upload do backend.
Se você quiser saber mais sobre o Apple Pay, como ele funciona ou até cobertura de países você pode acessar aqui que é o site oficial da Apple sobre esse assunto. A lista de bancos que suportam Apple Pay atualmente no Brasil pode ser encontrada aqui.
Lembrete: Para implementar o Apple Pay você deve ter uma conta de desenvolvedor da Apple. Para saber mais sobre a conta de desenvolvedor acesse aqui.
Tudo tem um começo :)
Para facilitar as coisas nesse tutorial, iremos disponibilizar um aplicativo-base de onde você poderá seguir em frente e se preocupar apenas com a implementação do Apple Pay. O aplicativo é o ApplePayFruits que oferece para o usuário uma lista de frutas fofinhas que poderão ser compradas via Apple Pay no final deste tutorial :)
Lembrando que neste tutorial as transações que iremos fazer não irão incorrer em cobranças de verdade! — Fique a vontade para comprar quantas frutas quiser no aplicativo! :)
Vamos começar? Primeiro baixe o projeto inicial aqui!
Dê “build and run” no seu projeto para ver se ele está funcionando e se tudo estiver correto você verá estas telas:
O aplicativo é simples e apenas mostra uma lista de frutas pra comprar e caso o usuário clique na célula da fruta vai para a tela de detalhes desta fruta onde futuramente poderá efetuar a compra.
Vamos dar uma olhada rápida na estrutura básica do aplicativo, abaixo seguem as classes e os objetos mais importantes do projeto inicial:
- FruitListViewController: A view Controller principal que lista as frutas disponiveis para comprar.
- BuyFruitViewController: A view Controller que detalha das frutas e permite o usuário comprar elas.
- Fruit: O modelo da Fruta.
- FruitCell: Uma subclasse da UITableViewCell usada para mostrar as informações de cada fruta na lista.
Sinta-se livre para explorar o aplicativo e se sentir à vontade com o código, pois logo logo iremos prosseguir com este tutorial e fazer vocês implementar esse maravilhoso app de vender frutas fofinhas! Mas antes de “codar”, existem algumas configurações que precisaremos fazer no portal de desenvolvedor e no seu aplicativo, mas isso fica para a próxima sessão.
Configurando seu App para o Apple Pay
Para começar a utilizar o Apple Pay, é necessário possuir um Bundle Identifier único para seu projeto, então vá nas configurações do seu projeto e escreva outro Bundle Identifier ou adicione algumas letras ao existente.
Agora, vá para o Apple Developer e clique em Certificates, IDs & Profiles. Em seguida, clique em Identifiers e selecione o “+”.
Isso levará para uma tela com diversas opções de identificadores. O identificador que possibilita transações para bens físicos ou serviços externos ao app é o Merchant ID, então é o que iremos escolher. Selecione Merchants IDs e clique em continuar. Na próxima tela terão dois campos: description e identifier. Em description, insira o nome do seu app, como “Fruits Store”, e em identifier insira o Bundle Identifier criado anteriormente. O site deve adicionar “merchant.” no campo identifier automaticamente, mas, caso ele não adicione, escreva “merchant.” antes do seu Bundle Identifier. Clique em continuar e registre seu Merchant ID.
Estamos quase prontos para começarmos o código! Antes, só precisaremos de um Certificate Signing Request (CSR), um certificado digital necessário para autenticar transações. Para obtermos um, abra o Keychain Access no seu computador, vá para o Certificate Assistant e selecione “Request a Certificate From a Certificate Authority…”.
Uma janela com informações a serem inseridas no certificado deve abrir. Insira seu email no campo “User Email Address”, insira seu nome em “Common Name” e, para não ser necessário incluir um CA Email Address, selecione a opção de salvar o certificado no seu próprio computador.
O último certificado que precisaremos é o Apple Pay Payment Processing Certificate, responsável pela segurança de dados da transação. Volte para o Apple Developer e selecione novamente “Certificates, IDs & Profiles”. Selecione “Certificates” e clique no “+” para criar um novo.
O certificado que queremos é o Apple Pay Payment Processing Certificates, presente na seção de serviços. Selecione essa opção e clique em continuar. Será necessário adicionar um Merchant ID, então adicione o que acabamos de criar e clique em continuar. A pergunta “Will payments associated with this Merchant ID be processed exclusively in China?” deve aparecer, então apenas selecione “No” e continue. Em seguida, será necessário enviar o Certificate Signing Request (CSR) que criamos anteriormente, salvo em seu Keychain Access.
Observação: é possível que demore alguns minutos até o site aceitar o arquivo CSR que estamos enviando, então aguarde um pouco caso estejam aparecendo erros
Certificado criado! Baixe ele e abra para salvar em seu computador e para ser processado no Keychain Access.
Voltando para o Xcode, selecione seu projeto e vá para “Signing & Capabilities”. Lá, deve existir a opção “+ Capability”, como na imagem abaixo.
Abra essa janela, clique duas vezes na opção Apple Pay e selecione o Merchant ID que criamos anteriormente e pronto! Agora o seu aplicativo está com todas as configurações e certificados prontos para podermos trabalhar com o Apple Pay.
Criando uma requisição de pagamento
Agora que completamos os requisitos para o funcionamento do Apple Pay, vamos para o código! Se rodarmos o projeto, podemos ver que já existe uma lista de frutas que podemos comprar.
Essa lista está presente no arquivo FruitListTableViewController. Se clicarmos em alguma fruta, iremos para a tela de compras BuyFruitViewController, que é onde iremos trabalhar agora.
Vá para o método purchase:
@IBAction func purchase(sender: UIButton) {
// TODO: — Fill in implementation
}Adicione as seguintes linhas de código:
//1
let paymentItem = PKPaymentSummaryItem(label: fruit.title, amount: fruit.price)//2
let paymentMethods: [PKPaymentNetwork] = [.visa, .masterCard, .elo]
Na linha 1, estamos criando um item de pagamento que será apresentado ao usuário posteriormente, e na linha 2 estamos definindo os cartões permitidos para uso na compra. Nesse caso, escolhemos Visa, MasterCard e Elo, mas há diversas outras opções, como American Express e Maestro.
Entretanto, nós ainda não possuímos os objetos e as funções de pagamento. Para isso, adicione a seguinte linha no início do arquivo.
import PassKitAgora sim! Como já temos o item de pagamento e os cartões permitidos, já podemos descobrir se o usuário pode fazer pagamentos e, com isso, criamos nossa requisição. Para isso, adicione o seguinte código dentro da função purchase.
if PKPaymentAuthorizationViewController.canMakePayments(usingNetworks: paymentMethods) {let request = PKPaymentRequest()request.currencyCode = “BRL” // 1 — Definimos a moeda de cobrançarequest.countryCode = “BR” // 2 — Código do paísrequest.merchantIdentifier = “merchant.com.appFruits.ApplePayFruits” // 3 — Merchant IDrequest.merchantCapabilities = .capability3DS // 4 — Protocolo de criptografiarequest.supportedNetworks = paymentMethods // 5 — Adicionando Métodos de pagamentorequest.paymentSummaryItems = [paymentItem] // 6 — Adicionando os itens que serão cobrados
}
Após confirmar que o usuário pode realizar pagamentos criamos a requisição e:
- Definimos a moeda em que a compra será cobrada
- Definimos o código do país
- Adicionamos o Merchant ID. Certifique-se de mudar para o que foi criado anteriormente
- Definimos os protocolos de criptografia. O protocolo 3DS é muito utilizado pois suporta cartões de crédito e débito
- Adicionamos os métodos de pagamentos criados anteriormente
- Adicionamos os itens que serão comprados, já criados também também
É possível, ainda, inserir informações como local para entrega do produto ou informações para contato entre cliente e consumidor, porém não iremos utilizar elas nesse momento, pois achamos que é um passo além do que queremos neste tutorial.
Em seguida, iremos apresentar a tela de pagamento para o usuário!
if PKPaymentAuthorizationViewController.canMakePayments(usingNetworks: paymentMethods) {…guard let paymentVC = PKPaymentAuthorizationViewController(paymentRequest: request) else { print(“Failed opening authorization view controller”) return
}paymentVC.delegate = selfself.present(paymentVC, animated: true, completion: nil)
}
Aqui criamos a View Controller de pagamento, definimos seu delegate e apresentamos ao usuário.
Um erro deve aparecer na sua tela, pois ainda não conformamos nossa classe com o protocolo PKPaymentAuthorizationViewControllerDelegate. Para corrigir este erro Inclua ao final do arquivo BuyFruitViewController a seguinte extensão:
extension BuyFruitViewController: PKPaymentAuthorizationViewControllerDelegate { func paymentAuthorizationViewControllerDidFinish(_ controller: PKPaymentAuthorizationViewController) { } func paymentAuthorizationViewController(_ controller: PKPaymentAuthorizationViewController, didAuthorizePayment payment: PKPayment, completion: @escaping (PKPaymentAuthorizationStatus) -> Void) { }}
Tendo as duas funções básicas do protocolo, podemos lidar com as respostas do usuário dadas pelo usuário dentro da View Controller de pagamento. Quando o usuário finalizar o pagamento, seja com sucesso ou não, queremos que a tela seja fechada, então adicione o seguinte na primeira função paymentAuthorizationViewControllerDidFinish:
dismiss(animated: true, completion: nil)Na segunda função, didAuthorizePayment, chamada quando o pagamento é autorizado, iremos por ora apenas informar que a operação foi concluída com sucesso, então insira esse código:
func paymentAuthorizationViewController(_ controller: PKPaymentAuthorizationViewController, didAuthorizePayment payment: PKPayment, completion: @escaping (PKPaymentAuthorizationStatus) -> Void) { completion(.success)}
Se tentarmos comprar uma fruta agora, veremos a seguinte tela :)
A compra foi aprovada! Entretanto, ainda não há nenhum local para de fato receber o dinheiro da transação. Para fazermos isso ainda teremos que criar uma conta no Stripe (nossa gateway), configurar ela com o nosso aplicativo e criar um servidor, mas isso fica para as próximas seções!
Completando uma transação Parte I (certificados e conta stripe)
Agora que temos toda a parte do Apple Pay no aplicativo completamente funcional, você vai querer que os “requests” de pagamento sejam cumpridos, entretanto o Apple Pay não cumpre as transações de pagamento ele apenas autoriza as transações criando tokens que vão permitir que os pagamentos sejam processados.
Para isso, é necessário um processador online de pagamentos, como o Paypal ou o Stripe. Nesse tutorial, utilizaremos o Stripe (caso queira dar uma olhada na documentação da stripe sobre Apple Pay pode checar aqui), porque, além de ser fácil de configurar, ele também possui um ambiente para testar compras dentro do app sem efetuar gastos de verdade, ou seja você poderá comprar quantas frutas fofinhas quiser sem realmente gastar um tostão!
Para seguirmos o nosso tutorial e não deixarmos as nossas frutas sem dono iremos precisar que você se registre no site da Stripe em uma conta free aqui, assim podemos pegar os certificados necessários e utilizar seus serviços.
Após criar a conta, crie um novo certificado clicando aqui, como mostra na imagem abaixo:
Ao clicar para adicionar uma nova aplicação, um arquivo .certSigningRequest deve ser baixado automaticamente.
Volte para o portal de desenvolvedores da Apple e vá em Certificates, Identifiers & Profiles, depois clique em Identifiers e filtre por Merchant IDs. Selecione o Merchant ID que você criou para o app e clique para criar um certificado:
O site irá pedir um Certificate Signing Request (CSR), então insira o arquivo que acabamos de baixar do Stripe e depois clique em download para receber seu arquivo .cer.
Nota: É possível que demore alguns minutos para o certificado gerado no Stripe ser aceito no portal da Apple, então não se assuste caso ele seja recusado na primeira tentativa.
Agora, volte para a seção onde criamos o certificado do Stripe e envie o novo arquivo que criamos agora:
Volte para a página inicial do Stripe agora e confira se há duas chaves disponíveis, chamadas de Publishable key e Secret Key:
Possuindo essas chaves, já estamos prontos para fazermos transações falsas acontecerem dentro do ambiente do Stripe. Está tudo pronto para você enviar requests com o seu merchant ID para o Stripe para ser descriptografado e processado.
No momento, nosso app apenas autoriza transações. O que precisamos fazer agora é implementar a realização dos pagamentos.
No momento o nosso aplicativo não está fazendo nada além de invocar um “successful completion handler” no método paymentAuthorizationViewController(controller:, didAuthorizePayment:, completion:) encontrado na classe … quando o usuário autoriza um pagamento.
A sua tarefa agora é pegar o token de autorização e mandar para o Stripe para processamento, para voce conseguir isso você vai precisar fazer três coisas:
1. Mandar o token de autorização via PKPayment para o Stripe para ser descriptografado. Caso ocorra sucesso, Stripe vai retornar o seu próprio token.
2. Mandar o token do Stripe para um servidor para o backend ficar ciente da ordem e performar qualquer processamento necessário.
3. Mandar o token do Stripe de volta para o Stripe para engatilhar a cobrança.
Para isso iremos precisar implementar um servidor, mas não se preocupe iremos fazer isso logo logo na próxima seção!
Completando uma transação Parte II (criando um servidor para teste)
Para completar uma transação, é necessário ter um servidor correspondente para processar o pedido do usuário. Nesse momento, vamos criar um servidor local capaz de receber pedidos feitos pelo aplicativo e enviá-los para o Stripe.
O Stripe fornece algumas bibliotecas para ajudar você a criar a sua request de pagamento, mas nós iremos criar um servidor inicial local o framework Flask junto com o SDK do Stripe para Python.
O Flask é um micro-framework o qual é usado principalmente em pequenas aplicações com requisitos mais simples — como um site básico — que possui um núcleo simples e expansível garantindo que um projeto utilize apenas os recursos necessários para a sua execução, permitindo assim que, conforme a necessidade surja, novos pacotes possam ser adicionados para incrementar as funcionalidades da aplicação.
Para instalarmos o Flask, utilizaremos o pip, um comando utilizado para instalar frameworks de Python. Se você não tiver pip instalado, você pode conferir no site oficial como obter.
Abra o terminal então e insira o seguinte comando:
pip install FlaskNota: Caso seu computador tenha Python 3 instalado, é possível que o computador não reconheça o comando pip. Substitua os comandos pip por pip3 e o problema deve ser resolvido.
Tendo o Flask instalado, insira o seguinte comando para instalar a biblioteca Python do Stripe:
pip install StripeTemos agora os dois frameworks instalados, estamos prontos para escrever o código usado para criar o servidor local! Abra um editor de texto, como o Visual Studio Code ou o Sublime e crie um arquivo em Python chamado Main.py.
import stripe
from flask import Flask
from flask import request
from flask import jsonapp = Flask(__name__)#1
@app.route(‘/pay’, methods=[‘POST’])def pay():# 2
# Coloque sua própria Stripe Secret Key (sk_test)
stripe.api_key = “sk_test_SUA_CHAVE”#3
# Decodifique o pedido como um JSON
json = request.get_json(force=True)# Pegue os detalhes do cartão
token = json[‘stripeToken’]amount = json[‘amount’]description = json[‘description’]# Crie o pedido que será cobrado no cartão do usuário
try:#4
charge = stripe.Charge.create(amount = amount,currency = “brl”,card = token,description = description)except stripe.error.CardError as e:# O cartão foi rejeitado
return “Failed!”return “Success!”if __name__ == ‘__main__’:# Coloque o host como 0.0.0.0 para ser utilizado na sua máquina
app.run(debug=True, host = ‘0.0.0.0’)
Nesse código, estamos:
- Criando a rota HTTP suportando métodos POST através da porta /pay.
- Adicionamos a Stripe Secret Key. Certifique-se de que você colocou a sua própria chave, encontrada na página inicial do Stripe.
- Lemos o pedido como um JSON.
- Criamos a cobrança que será cobrada no cartão do usuário. Note que o amount é medido em centavos.
Com esse código, estaremos com um servidor local pronto para receber transações internas do Stripe. Para rodar o programa, execute o comando no terminal:
python main.pyNota: Caso seu computador não reconheça o comando python, tente executar escrevendo python3.
Ao rodar o programa, o Terminal deve exibir uma resposta similar a essa:
Obtendo uma resposta assim, sabemos que nosso servidor de testes está pronto, só faltando enviar os dados do app para ele. Lembramos que quando formos testar as compras do app neste servidor de teste o servidor tem que estar rodando durante as transações.
Integrando Stripe em seu App
Agora que nosso servidor de testes está pronto para aceitar pagamentos você só precisa mandar eles do seu aplicativo, para tanto vamos fazer as alterações necessárias em nosso app.
Assim como nós adicionamos o framework Stripe no nosso projeto em Python, também devemos adicionar ao app em Swift. A SDK para iOS do Stripe está disponível no seu Github, e o jeito mais fácil de incluí-la é utilizando CocoaPods.
Nota: Caso você não seja muito familiar com CocoaPods, dê uma olhada nesse tutorial no site do Ray Wenderlich
Possuindo CocoaPods instalado no seu computador, basta abrir o Terminal, ir para o diretório onde está seu arquivo .xcodeproj e inserir o seguinte comando:
pod initUm arquivo chamado Podfile deve aparecer na pasta. Abra ele e insira a seguinte linha nele:
pod ‘Stripe/ApplePay’O arquivo deve ficar parecido com a imagem abaixo:
Salve o arquivo e volte para o Terminal, que deve estar no mesmo diretório ainda, e execute o seguinte comando para instalar o pod:
pod installApós instalarmos um pod no projeto, é necessário fechar o Xcode e abrir de novo, mas dessa vez abrindo o projeto branco (.xcworspace) em vez do projeto normal (.xcodeproj).
Com o projeto aberto, vamos precisar, primeiramente, adicionar um símbolo de pré-processamento para alertar o Xcode que usaremos o Stripe. Para isso:
- Selecione seu projeto no Xcode
- Escolha o próprio target
- Vá para Build Settings
- Pesquise por Preprocessor Macros
- Adicione a string STRIPE_ENABLE_APPLEPAY tanto no campo de Debug quanto em Release de Preprocessor Macros
A sua tela deve estar parecida com a tela abaixo:
Estamos quase lá! Volte então para BuyFruitViewController.swift e escreva no início do arquivo:
import StripeAgora vá para função didAuthorizePayment payment: PKPayment, completion:. Nela, substitua o código atual pelo seguinte:
// 1: Define a chave de testes
Stripe.setDefaultPublishableKey(“pk_test_SUA_PUBLISHABLE_KEY”)// 2: Cria o token do Stripe
STPAPIClient.shared().createToken(with: payment) { (token, error) in// 3: Checamos se houve algum erro na criação do token
if error != nil { print(“\(String(describing: error?.localizedDescription))”) completion(PKPaymentAuthorizationStatus.failure)
}else { //4: Definimos o endereço da URL
let url = URL(string: “http://SEU_ENDERECO_DE_IP:5000/pay") var request = URLRequest(url: url!)
request.httpMethod = “POST”
request.setValue(“application/json”, forHTTPHeaderField: “Content-Type”)
request.setValue(“application/json”, forHTTPHeaderField: “Accept”) // 5: Adicionamos os atributos do JSON
let body: [String: Any] = [
“stripeToken”: token?.tokenId ?? “”,
“amount”: self.fruit.price.multiplying(by: 100),
“description”: self.fruit.title
] request.httpBody = try? JSONSerialization.data(withJSONObject: body, options: JSONSerialization.WritingOptions()) }}
No código acima, estamos:
- Definindo a chave do Stripe utilizada para publicações — certifique-se de colocar a sua própria chave, disponível no site do Stripe.
- Criamos o Token que será enviado para o Stripe utilizando o Token do Apple Pay.
- Checamos se houve algum erro ao criar o Token e, se houver, retornamos o Status Failure.
- Caso não tenham erros, definimos o endereço da URL que será utilizada na requisição. Certifique-se de utilizar seu próprio IP e de inserir o “:5000/pay” após ele, pois é a porta que definimos anteriormente no programa em Python. Veja nesse site como descobrir seu IP.
- Adicionamos os atributos do JSON. StripeToken é o TokenID recebido pelo Stripe; Amount é o custo da transação medido em centavos, por isso multiplicamos por 100, e Description é a descrição do produto sendo comprado.
Estamos com nossa requisição pronta para ser enviada para o Stripe! Criamos um Token, definimos o endereço e a chave necessária, criamos o pedido com preço e descrição e agora falta apenas contatar eles.
Para isso, vamos utilizar uma URLSession padrão, então insira o código abaixo logo após o que acabamos de escrever:
let session = URLSession.shared
let dataTask = session.dataTask(with: request) { (data, response, error) inif error == nil {
print(“PAYMENT SUCCEDED”)
completion(PKPaymentAuthorizationStatus.success)
}
else {
print(“PAYMENT FAILED”)
completion(PKPaymentAuthorizationStatus.failure)
}
}dataTask.resume()
O código acima está criando uma URLSession e fazendo uma chamada na requisição que definimos anteriormente. Caso aconteça algum erro, finalizamos a função paymentAuthorizationViewController(controller:, didAuthorizePayment:, completion:) com o Status Failure; caso contrário, utilizamos o Status Success. Ao final, resumimos a session.
Execute o programa em Python agora e rode de novo o app no simulador. Tente comprar uma fruta de sua preferência e confira se deu tudo certo.
Caso a sua compra tiver sido realizada com sucesso, essa mensagem deve aparecer no seu Terminal:
O código 200 significa que a operação foi realizada com sucesso, então caso o número seja diferente, confira se há algum erro no código ou nos certificados.
Acessando o site do Stripe agora, notamos que o valor da compra que fizemos está já no Dashboard! Isso significa que as transações já estão funcionando perfeitamente, bastando subir um servidor para processar transações que ocorram fora de sua máquina :)
Nota: Certifique-se que o Dashboard está no modo Viewing test data, pois é nele que aparecem as transações que fazemos com cartões de simulação.
Finalizando transações
Para podermos fazer transações fora da nossa máquina, é necessário possuir um servidor remoto ativo. Há diversas maneiras de subir um servidor, mas nesse tutorial utilizaremos o Heroku para subir os nosso servidor. Sendo assim, precisamos que você Crie uma conta no site e vamos começar!
Primeiro, é necessário possuir a Command Line Interface (CLI) do Heroku. O jeito mais fácil de instalá-la é usando o comando no Terminal:
brew install herokuNota: Caso você não possua o gerenciador de pacotes Brew, dê uma olhada aqui para instalá-lo.
Vamos precisar também do Gunicorn, uma interface para servidores web, caso queira saber mais clique aqui. Para instalá-lo, insira o comando:
pip install gunicornLembre-se que seu computador talvez não reconheça o comando pip — nesse caso, tente utilizar pip3.
Agora, crie uma pasta no local de sua preferência e vá até ela pela linha de comando, pois vamos criar os arquivos necessários para subirmos nosso servidor para o Heroku. Estando na pasta, digite o seguinte comando para criar um novo arquivo, utilizado para executar comandos ao inicializar o app:
touch ProcfileAbra o Procfile e digite o seguinte dentro dele e depois salve:
web: gunicorn wsgi:appEm seguida, digite:
touch runtime.txtAbra o arquivo runtime.txt, utilizado para especificar a versão de Python da aplicação, e digite o seguinte:
Python-3.7.4.Estamos quase terminando de criar arquivos! Digite no Terminal:
touch requirements.txtAbra o requirements.txt, utilizado para especificar dependências na nossa aplicação, e insira nele:
gunicorn
flask
stripeAgora, digite no Terminal para criar um arquivo em Python:
touch wsgi.pyAbra o arquivo wsgi.py e insira nele:
from app.main import appif __name__ == “__main__”:
app.run()
Por último, crie uma pasta utilizando o seguinte comando:
mkdir appAbra a pasta que acabamos de criar e arraste o arquivo main.py, que criamos anteriormente para subir o servidor local, para dentro dela.
Ufa, terminamos de criar arquivos!
Agora, vamos inicializar um repositório para podermos enviar os arquivos feitos e o código escrito. Para isso, insira as linhas abaixo no Terminal:
git init
git add .
git commit -m “first commit”Após inicializar o repositório, precisamos conectá-lo com o Heroku. Para isso, primeiro é necessário fazer login pela CLI. Então, digite o seguinte no Terminal:
heroku loginVocê deve receber a seguinte mensagem no Terminal:
Pressione alguma tecla e você será redirecionado para o site deles, como na imagem abaixo:
Após logar com sucesso, devemos criar nosso app correspondente no Heroku, utilizando um nome único:
heroku create nome-do-seu-appInsira, por último, o seguinte comando para enviar todos arquivos que criamos para o Heroku:
git push heroku masterVá agora no site do Heroku e confira se seu app está lá! Se tudo estiver bem, você poderá ver mais informações sobre sua aplicação. Caso contrário, cheque como ver o Log do seu app para descobrir onde está o erro.
Com o aplicativo funcionando no Heroku, clique no botão Open app e copie o link que ele abrir.
A página possivelmente será um erro 404, mas não se preocupe, queremos apenas o link dela. Volte no seu programa no Xcode agora, na função paymentAuthorizationViewController(controller:, didAuthorizePayment:, completion:) e substitua o endereço da URL, que atualmente deve ser seu IP, pelo /pay. A nova URL deve estar assim:
let url = URL(string: “Seu_Link_Do_Heroku/pay”)Com isso, não estaremos mais rodando nosso programa apenas na nossa máquina, possibilitando que outras pessoas realizem pagamentos pelo Apple Pay através do nosso aplicativo :)
Para onde ir agora?
Baixe a versão final do projeto aqui.
Vale ressaltar que o ambiente que criamos é de teste e que para podermos utilizarmos o ambiente onde os pagamentos sejam de fato processados e cobrados, voce deverá entrar em contato com o Stripe para validar a sua conta com eles.
Lembre-se que implementamos apenas o básico de pagamentos, pois não implementamos nenhum tipo de segurança para nossas transações e o nosso servidor foi implementado da forma mais básica possível para que pudéssemos testar as transações, então aconselhamos que caso você use o Apple Pay em um aplicativo de verdade tome cuidado e implemente um backend mais robusto e seguro!
Aqui estão alguns links que podem ser úteis para aprofundar sua implementação:
Habilitando compras com cartões de crédito e débito diretamente
Coletando pagamentos e transferindo pagamentos
Referências
Como subir um app para o Heroku usando Python e Flask
Criando uma aplicação com Apple Pay
Integrando Apple Pay no seu app
