Criar Fluxo reembolso retornar itens ao estoque para pagamentos PIX expirados

[zericksp]

Estamos com dificuldades na documentação que discorre sobre ação obsoleta "cancel order". 
Após varia tentativas junto a equipe de atendimento a clientes shoipify-plus, não obtivemos resultado para criar um fluxo que liste as ultimas ordens com created_at:>'{{ scheduledAt | date_minus: "1 hour" }}' gateway:'%Pix%' AND financial_status:pending. Após listar, cada ordem deve ser arquivada, reallizado reembolso e ter itens devolvidos ao estoque(inventário).
Qualque solução dentro do Flow será de grande ajuda. Já tenho a solução por API Graphql, mas se faz necessário deixar os processos dentro do Flow.

[AgenciaFY]

Olá Zericksp, como vai?

Entendo a sua frustração com a ação obsoleta "cancel order" no Shopify Flow e a necessidade de automatizar o processo de cancelamento de pedidos específicos diretamente dentro do Flow. Embora o Flow seja uma ferramenta poderosa para automações dentro do Shopify, ele possui algumas limitações em termos de ações nativas disponíveis. No entanto, é possível contornar essas limitações utilizando webhooks e integrações com APIs externas, como você já fez com a API GraphQL.

A seguir, apresento uma solução detalhada para criar o fluxo desejado dentro do Shopify Flow, utilizando webhooks para integrar com sua solução baseada em GraphQL:

Passo a Passo para Criar o Fluxo no Shopify Flow

1. Preparação da Solução Externa

Antes de configurar o Flow, certifique-se de que você possui um endpoint (API) configurado para receber os webhooks e executar as ações necessárias (listar pedidos, arquivar, realizar reembolso e retornar itens ao estoque). Como você já mencionou que possui uma solução via GraphQL API, essa parte já está implementada.

2. Configurar um Endpoint para Receber Webhooks

Caso ainda não tenha, você precisará configurar um servidor que possa receber requisições HTTP e interagir com a API GraphQL do Shopify. Esse servidor será responsável por:

• Receber a solicitação do Flow.
• Executar a lógica para listar os pedidos com os critérios especificados.
• Arquivar cada pedido.
• Realizar o reembolso.
• Retornar os itens ao estoque.

Exemplo de Implementação (usando Node.js e Express):

javascript

const express = require('express'); const app = express(); const axios = require('axios'); // Middleware para parsear JSON app.use(express.json()); app.post('/webhook/cancel-orders', async (req, res) => { try { // Lógica para listar pedidos com created_at > agora - 1 hora, gateway 'Pix' e financial_status 'pending' const query = ` { orders(first: 10, query: "created_at:>'${new Date(Date.now() - 60*60*1000).toISOString()}' AND gateway:'Pix' AND financial_status:pending") { edges { node { id name # Outros campos necessários } } } } `; const response = await axios.post('https://your-shopify-store.myshopify.com/admin/api/2023-10/graphql.json', { query }, { headers: { 'Content-Type': 'application/json', 'X-Shopify-Access-Token': 'YOUR_ACCESS_TOKEN' } }); const orders = response.data.data.orders.edges; for (const orderEdge of orders) { const order = orderEdge.node; // Arquivar o pedido await axios.post(`https://your-shopify-store.myshopify.com/admin/api/2023-10/orders/${order.id}/archive.json`, {}, { headers: { 'Content-Type': 'application/json', 'X-Shopify-Access-Token': 'YOUR_ACCESS_TOKEN' } }); // Realizar o reembolso const refundData = { refund: { # Detalhes do reembolso } }; await axios.post(`https://your-shopify-store.myshopify.com/admin/api/2023-10/orders/${order.id}/refunds.json`, refundData, { headers: { 'Content-Type': 'application/json', 'X-Shopify-Access-Token': 'YOUR_ACCESS_TOKEN' } }); // Retornar itens ao estoque // Lógica para atualizar o inventário } res.status(200).send('Pedidos cancelados com sucesso.'); } catch (error) { console.error(error); res.status(500).send('Erro ao processar os pedidos.'); } }); const PORT = process.env.PORT || 3000; app.listen(PORT, () => { console.log(`Servidor rodando na porta ${PORT}`); });

Nota: Substitua 'YOUR_ACCESS_TOKEN' pelo seu token de acesso à API do Shopify e ajuste a lógica conforme necessário para sua implementação específica.

3. Criar um Webhook no Shopify Flow

Agora, vamos configurar o Shopify Flow para acionar o webhook que você criou:

1. Acesse o Shopify Flow:

   • No painel de administração do Shopify, vá para Apps e selecione Flow.

2. Criar um Novo Fluxo:

   • Clique em Create Workflow.

3. Definir o Trigger (Gatilho):

   • Trigger: Como o Flow não suporta gatilhos baseados em tempo diretamente, você pode utilizar o gatilho “Order Created” para capturar novos pedidos e avaliar se eles atendem aos critérios.

   Configuração do Gatilho:

   • Trigger: Order Created

4. Adicionar Condições:

   • Condição 1: created_at > agora - 1 hora
   • Condição 2: gateway contém "Pix"
   • Condição 3: financial_status é "pending"

   Como Configurar:

   • Condição 1:

     • Campo: Order created at
     • Operador: is after
     • Valor: {{ scheduledAt | date_minus: "1 hour" }}

   • Condição 2:

     • Campo: Gateway
     • Operador: contains
     • Valor: Pix

   • Condição 3:

     • Campo: Financial Status
     • Operador: equals
     • Valor: pending

5. Adicionar Ação: Enviar Webhook

   • Ação: HTTP Request (Enviar Webhook)

   Configuração da Ação:

   • URL: https://seu-servidor.com/webhook/cancel-orders
   • Método: POST
   • Cabeçalhos:
     • Content-Type: application/json
   • Corpo:
     • Você pode enviar informações relevantes do pedido, caso necessário.

   Exemplo de Corpo JSON:

   json

   { "order_id": "{{ order.id }}", "order_name": "{{ order.name }}", "created_at": "{{ order.created_at }}" // Adicione outros campos se necessário }

6. Salvar e Ativar o Fluxo:

   • Após configurar o gatilho, as condições e a ação de webhook, salve o fluxo e ative-o.

4. Testar o Fluxo

Após configurar o fluxo, realize testes para garantir que tudo está funcionando conforme o esperado:

1. Criar um Pedido de Teste:

   • Simule a criação de um pedido que atenda aos critérios (gateway "Pix" e financial_status "pending").

2. Verificar a Execução do Webhook:

   • Verifique os logs do seu servidor para confirmar se o webhook foi recebido e processado corretamente.

3. Confirmar Ações no Shopify:

   • Após a execução, verifique se o pedido foi arquivado, o reembolso foi realizado e os itens foram devolvidos ao estoque.

5. Agendamento Periódico (Opcional)

Se você precisa executar essa verificação periodicamente (por exemplo, a cada hora), considere usar uma solução de agendamento externa para acionar o webhook:

1. Serviços de Agendamento:

   • Utilize serviços como AWS Lambda com CloudWatch Events, Google Cloud Functions com Cloud Scheduler, ou cron jobs em seu servidor para enviar requisições HTTP ao webhook https://seu-servidor.com/webhook/cancel-orders a cada hora.

2. Ajuste na Lógica do Endpoint:

   • Modifique a lógica do seu endpoint para listar e processar todos os pedidos que atendem aos critérios sem depender de gatilhos de criação de pedidos.

Considerações Finais

• Manutenção e Monitoramento:

  • Assegure-se de monitorar o fluxo e o endpoint para identificar e corrigir possíveis falhas rapidamente.

• Segurança:

  • Proteja seu endpoint utilizando autenticação (por exemplo, tokens secretos) para garantir que apenas requisições autorizadas possam acioná-lo.

• Logs e Auditoria:

  • Implemente logs detalhados para rastrear as ações realizadas e facilitar a auditoria e solução de problemas.

• Limitações do Shopify Flow:

  • Este método contorna a limitação de ações obsoletas no Flow, utilizando webhooks para integrar com soluções externas que podem interagir diretamente com a API do Shopify.

Espero que essa solução atenda às suas necessidades e permita automatizar o processo conforme desejado!


Abraços Paolo Werneck

AgenciaFY & Playecom

[zericksp]

Necesitamos levar todo este processo para dentro da Shopify, garantindo escalabilidade com baixa manutenção.

O processo já validado é feito diretamente com os webhook " Criação de pedido".
Poderia ser utilizado em uma tarefa CRON com o GRPHQL :
<<<'GRAPHQL' { orders(first: 50, query: "gateway:'XXX XXXX Pix' financial_status:pending created_at:1h") { edges { node {
id 

createdAt 

financialStatus 

gateway
}
}
}
}
GRAPHQL;
Mas já temos gravado todo conteúdo do pedido em uma base MySql e uma tarefa CRON recupera os dados do DB a cada 10 minutos com "SELECT ord_id,ord_cancelled_at,ord_closed_at,ord_cancel_reason,ord_confirmation_number,ord_created_at,ord_financial_status,ord_order_status_url,ord_payment_gateway_names,ord_processed_at,ord_status FROM tbl_shpf_orders WHERE ord_payment_gateway_names LIKE '%Pix%'
AND ord_financial_status <> 'paid' AND ord_closed_at IS NULL AND ord_processed_at <= DATE_SUB(NOW(), INTERVAL 2 HOUR) ORDER BY ord_processed_at DESC LIMIT 10;"
No Loop pelo resultado, executamos uma function de update no pedido, aproveitando esta base para montar uma tela de monitoramento dos pedidos ainda não atualizados com possibilidade de execução manual.

[AgenciaFY]

Para internalizar o processo na Shopify de forma mais escalável e com menor manutenção, é importante reduzir as dependências externas (como o uso de um banco MySQL intermediário e CRON jobs externos) e aproveitar recursos nativos da plataforma ou integrações mais fluidas. Abaixo seguem algumas estratégias e considerações:

1. Uso de Webhooks + Aplicativo Privado ou Custom App Interno:
Se você já utiliza o webhook de "Order Creation" (Criação de pedido), pode expandir essa lógica por meio de um app privado ou custom app registrado na loja. Esse app poderá:

• Receber o webhook de criação de pedido.
• Armazenar informações relevantes em metafields do próprio pedido ou em uma solução de armazenamento serverless (como Firestore, DynamoDB ou até mesmo um banco headless na nuvem) – mas isso apenas se for realmente necessário.
• Acionar lógicas de verificação diretamente a partir de eventos internos (via API) sem precisar de CRON job externo.

Isso elimina a necessidade de rodar um CRON local. Com o app privado, você pode configurar uma função serverless (AWS Lambda, Cloud Functions, etc.) que, a cada intervalo, se necessário, executa a query GraphQL direto na Shopify, atualiza pedidos e, caso queira, registra logs no próprio pedido via notas internas ou tags. Por ser serverless, a manutenção é reduzida e a escalabilidade melhora.

2. Shopify Flow (se disponível em seu plano):
Se a sua loja estiver num plano compatível, o Shopify Flow pode automatizar muitos processos internos, reduzindo a necessidade de CRONs externas. Você pode criar fluxos para:

• Quando um pedido é criado com determinado gateway (por exemplo, Pix), Flow aguarda X horas (uso de delays internos no Flow).
• Após o tempo de espera, Flow verifica o status financeiro do pedido.
• Caso não tenha sido pago, Flow pode acionar uma ação, como adicionar uma tag, enviar um e-mail, ou até mesmo chamar um webhook externo para sua função de atualização. Hoje o Flow não faz atualizações complexas nativamente no pedido em si (como alterar financial_status), mas pode disparar uma chamada HTTP para seu app privado, que então executa a ação via API GraphQL da Shopify.

Isso reduz a dependência de CRON jobs, já que o agendamento e as verificações passam a ser definidas dentro do ecossistema da Shopify.

3. Redução da dependência do MySQL externo:
Se a principal razão do MySQL era armazenar dados para monitoramento e execução manual, avalie alternativas:

• Metafields no próprio pedido: Armazene flags ou status temporários no metafield do pedido. Assim, a checagem é feita diretamente na Shopify via GraphQL. Você pode, por exemplo, marcar um pedido como “Aguardando Pix” e depois consultar esses pedidos via uma query GraphQL baseada em tags ou metafields, dispensando um banco externo.
• Aplicativos de terceiros ou Custom Admin UI Extensions: Crie uma interface de monitoramento dentro do admin da Shopify (usando as novas extensões da Shopify Admin UI) para visualizar pedidos pendentes de atualização. Assim, o controle e a execução manual (se necessária) acontecem totalmente dentro do ambiente Shopify.

4. Substituindo a CRON por Agendamentos em Nuvem e Lógicas Internas:
Caso precise realmente de algo semelhante a um CRON, você pode utilizar serviços na nuvem (como AWS EventBridge ou Cloud Scheduler no GCP) para disparar periodicamente uma função serverless que consulta os pedidos na Shopify via GraphQL. Dessa forma, a manutenção é apenas na nuvem, não exige servidor dedicado, e você integra diretamente com a API da Shopify, atualizando estados sem intermediários complexos.

5. Segurança e Manutenção Reduzida:

• Ao remover o MySQL e o CRON locais, você reduz pontos de falha.
• Ao centralizar a lógica no app privado e no Shopify Flow, a manutenção se torna mais fácil e integrada ao ecossistema Shopify.
• O uso de serverless functions torna a escalabilidade automática, já que não é necessário se preocupar com infraestrutura.

---

Resumo da Estratégia Recomendada:

1. Utilize webhooks de criação de pedido e, se disponível, o Shopify Flow para gerenciar eventos e atrasos internos.
2. Armazene dados do pedido no próprio pedido (tags ou metafields) para filtrar pedidos pendentes via API GraphQL sem depender de banco externo.
3. Substitua CRON jobs por eventos serverless ou pelos próprios fluxos do Shopify Flow, reduzindo a necessidade de manutenção externa.
4. Crie um app privado ou custom app para gerenciar atualizações de pedido e disponibilizar uma interface de monitoramento dentro do Admin da Shopify ou via uma UI Extension.

Assim, todo o fluxo (verificação, atualização e monitoramento) ficará concentrado dentro do ecossistema Shopify, garantindo escalabilidade, baixa manutenção e maior integração dos processos.