solidus_me 3.6.1 → 3.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: addb3bbf219a43732568b970d227822cab25d41c6f6667e5052b479f6373d5f8
-  data.tar.gz: 8e8234e002b306f3df1aa91e6a7225c8339a362131842e181545d5ea3b617fac
+  metadata.gz: fa89482d312023371ec4e9fd7460f58d6ba9a840fb1decb3caa3baf3c373a49e
+  data.tar.gz: cef322e476abd32180ef4e10c46943de02c93a92695be5786588574544a5e45e
 SHA512:
-  metadata.gz: f3ed82279b7572e7b4db74782e3733416d442efec00d27f11be21860f4240c07e00038569b1a6929adbd11005a10720337d71b04bf8ae9b2d8104ca28316a3de
-  data.tar.gz: fddc43a7bb64fd80fb5e3b60db1d9cd99d497d370ef0dbf070bf7dfb51555e981d2872c4dea67082078ce4accfe2e626d12d1f3e584590885f597666f52e705d
+  metadata.gz: 9b0ec3d830d746dc02ec25201ab0ab316b4e4ccc82ba96eee3a6e4ca61d8e948149b3b522883a3f136e3004a7a0fd7026c851c0861b2a0cd7e42d2b3fcff1ab8
+  data.tar.gz: f9066b9fc94c55981f93d4785636148729e083cb8a0f2acaa469bb1e048b9d2792a8b14956a41529c835c2a34fa7b9c2ab3aa464a4b857c1c154f4e10e44822d

data/README.md

@@ -1,54 +1,176 @@
-# Solidus Me
+# SolidusMe
 
-Gem para cotar empresas e valores de entrega junto à Api do Melhor Envio.
+[![Gem Version](https://badge.fury.io/rb/solidus_me.svg)](https://badge.fury.io/rb/solidus_me)
 
-## Installation
+Extensão do Solidus para integração com a API do [Melhor Envio](https://melhorenvio.com.br/), permitindo:
 
-Adicionar solidus_me ao Gemfile:
+- Cálculo de frete em tempo real
+- Geração de etiquetas de envio
+- Gerenciamento de contas do Melhor Envio
+- Interface administrativa para controle de etiquetas
+
+## Requisitos
+
+- Ruby >= 2.7
+- Solidus >= 3.0
+- Rails >= 6.0
+
+## Instalação
+
+Adicione esta linha ao Gemfile da sua aplicação:
 
 ```ruby
 gem 'solidus_me'
 ```
 
-Executar:
+Execute:
+
+```bash
+$ bundle install
+```
+
+Execute o gerador de instalação:
+
+```bash
+$ rails generate solidus_me:install
+```
+
+Execute as migrações:
+
+```bash
+$ rails db:migrate
+```
+
+## Dependências
+
+Esta gem depende de outras gems que precisam ser configuradas antes do uso:
+
+### 1. SolidusTecEstimator
+
+Execute o gerador de instalação:
+
+```bash
+$ rails generate solidus_tec_estimator:install
+```
+
+Siga as instruções de configuração da gem **[solidus_tec_estimator](https://github.com/todasessascoisas/solidus_tec_estimator)**.
+
+### 2. SolidusBrazilianAdaptations
+
+Execute o gerador de instalação:
+
+```bash
+$ rails generate solidus_brazilian_adaptations:install
+```
+
+Siga as instruções de configuração da gem **[solidus_brazilian_adaptations](https://github.com/todasessascoisas/solidus_brazilian_adaptations)**.
+
+## Configuração
+
+### 1. Configuração da Conta do Melhor Envio
+
+Acesse o painel administrativo do Solidus e navegue até **Configurações > Contas Melhor Envio** para configurar suas credenciais da API.
 
-```shell
-bundle
-bin/rails generate solidus_me:install
+### 2. Configuração do Provider de Frete
+
+Configure o **TecEstimator** ou outro provider compatível para usar o "Melhor Envio" como provedor de frete.
+
+### 3. Configuração da Interface de Etiquetas
+
+Para exibir a aba "Etiqueta" nas ordens do painel administrativo, você precisa adicionar o seguinte código ao arquivo `app/views/spree/admin/shared/_order_submenu.html.erb`:
+
+```erb
+<% if @order.completed? %>
+  <% provider_id = @order.shipments.sole.selected_shipping_rate.shipping_method.provider_id %>
+  <% if provider_id && SolidusTecEstimator::Provider.find(provider_id).name == "Melhor Envio" %>
+    <% label = SolidusMe::Label.find_by(spree_order_id: @order.id) %>
+    <li class="tab" data-hook='admin_order_tabs_return_authorizations'>
+      <% if label %>
+        <a href="<%= admin_orders_label_path(order_number: @order.number, id: label.id) %>">Etiqueta</a>
+      <% else %>
+        <a href="<%= admin_orders_labels_path(order_number: @order.number) %>">Etiqueta</a>
+      <% end %>
+    </li>
+  <% end %>
+<% end %>
 ```
 
-Executar o comando para instalar a gem de dependências `solidus_brasilian_adaptations`:
+**Importante:** Se o arquivo `app/views/spree/admin/shared/_order_submenu.html.erb` não existir na sua aplicação, você deve criá-lo copiando o arquivo original do Solidus:
+
+👉 **[Baixar arquivo original do Solidus](https://github.com/solidusio/solidus/blob/main/backend/app/views/spree/admin/shared/_order_submenu.html.erb)**
+
+Após baixar, coloque o arquivo no caminho correto da sua aplicação e adicione o código da aba de etiqueta.
+
+## Funcionalidades
+
+### Gerenciamento de Contas
+
+- **Múltiplas contas**: Suporte a contas de teste e produção
+- **Autenticação OAuth2**: Integração segura com a API do Melhor Envio
+- **Sincronização automática**: Atualização de saldos e informações da conta
+
+### Etiquetas de Envio
+
+- **Geração de etiquetas**: Criação automática de etiquetas após finalização do pedido
+- **Rastreamento**: Acompanhamento do status de entrega
+- **Impressão**: Interface para impressão de etiquetas
+- **Histórico**: Controle completo do ciclo de vida das etiquetas
+
+### Interface Administrativa
+
+- **Dashboard de contas**: Visualização de saldos e status das contas
+- **Gestão de etiquetas**: Interface completa para gerenciar etiquetas por pedido
+- **Configurações**: Painel de configuração das integrações
+
+## Modelos
 
-```shell
-bin/rails generate solidus_brazilian_adaptations:install
+### SolidusMe::Account
+
+Representa uma conta do Melhor Envio configurada no sistema.
+
+```ruby
+# Buscar conta ativa em modo de teste
+account = SolidusMe::Account.first_active_test_mode
+
+# Verificar saldo da conta
+balance = account.get_balance
+
+# Obter dados da conta
+account_data = account.get_account_data
 ```
 
-Após, seguir o [tutorial](https://github.com/ulysses-bull/solidus_brazilian_adaptations) da gem `soluds_brazilian_adaptations`
+### SolidusMe::Label
 
-Adicionar no arquivo `/config/initilizers/spree.rb` 
+Representa uma etiqueta de envio gerada para um pedido.
 
 ```ruby
-Spree.config do |config|
-+++
-config.stock.estimator_class = "SolidusMe::ShippingEstimator"
-+++
-end
+# Buscar etiqueta por pedido
+label = SolidusMe::Label.find_by(spree_order_id: order.id)
+
+# Verificar status da etiqueta
+puts label.status
 ```
 
-No painel do admin será adiconado o item do `Melhor Envio` no menu lateral. Nesta página deverão ser preenchidos os seguintes campos para autenticação do aplicativo:
+## Configuração Avançada
 
-```text
-CEP de origem:
-Client ID:
-Client Secret:
-Redirect Url:
-State:
+### Inicializador
+
+O gerador cria um arquivo de configuração em `config/initializers/solidus_me.rb`:
+
+```ruby
+SolidusMe.configure do |config|
+  # Suas configurações personalizadas
+end
 ```
-Após salvar, o link completo para autenticação do aplicativo ficará disponível abaixo. A gem disponibiliza um endpoint (`HOST/admin/melhor_envio/authorize`) para receber o code e realizar a autenticação automaticamente. Uma vez autorizado, são gerados os `refresh_token` e `access_token`, e o sistema estará pronto para cotação dos fretes junto ao Melhor Envio.
 
-Por padrão, os serviços de entrega são os `SEDEX`, `PAC` e `MiniEnvios` dos CORREIOS. Porém, os serviços podem ser customizados de acordo com a necessidade. Basta adicioná-los aos `preferences` da `Spree::Store`:
+### Rotas
+
+As rotas são automaticamente montadas na aplicação:
 
 ```ruby
-# Por exemplo
-Spree::Store.first.update(preferences: { melhor_envio: { services: ["SEDEX", "PAC", "Mini Envios", ".Com", ".Package"] } })
+# config/routes.rb
+Rails.application.routes.draw do
+  mount SolidusMe::Engine => "/solidus_me"
+  # suas outras rotas...
+end
 ```

data/app/controller/spree/admin/orders/labels_controller.rb

@@ -0,0 +1,124 @@
+module Spree
+  module Admin
+    module Orders
+      class LabelsController < BaseController
+        before_action :load_order
+        before_action :set_label, only: [:show, :update, :step_payment, :step_generate, :step_print]
+
+        def index
+          @current_step = 1
+          labels = order_labels.recent
+          if labels.present?
+            @label = labels.first
+            redirect_to admin_orders_label_path(@order.number, @label.id)
+          end
+        end
+
+        def show
+          @current_step = @label.current_step
+          
+          unless @label.status == "completed_label"
+            redirect_to step_path
+          end
+        end
+
+        def step_payment
+          @balance = current_account.get_balance&.balance
+          @current_step = 2
+        end
+
+        def step_generate
+          @current_step = 3
+        end
+
+        def step_print
+          @current_step = 4
+        end
+
+        def create
+          @label = ::SolidusMe::Label.find_or_initialize_by(
+            spree_order_id: @order.id,
+            solidus_me_account_id: current_account.id,
+            status: "ready_to_add_to_cart"
+          )
+
+          @label.add_to_cart!
+          flash[:success] = "Etiqueta criada e adicionada ao carrinho com sucesso"
+          redirect_to admin_orders_step_payment_label_path(@order.number, @label.id)
+        rescue StandardError => e
+          Rails.logger.error "Failed to create label for order #{@order.number}: #{e.message}"
+          flash[:error] = "Erro ao processar etiqueta: #{e.message}"
+          redirect_to admin_orders_labels_path(@order.number)
+        end
+
+        def update
+          case @label.status
+          when "pending"
+            process_payment
+          when "paid"
+            process_generation
+          when "generated_label"
+            process_printing
+          else
+            flash[:error] = "Ação não permitida para status atual"
+            redirect_to admin_orders_label_path(@order.number, @label.id)
+          end
+        rescue StandardError => e
+          flash[:error] = "Erro ao processar: #{e.message}"
+          redirect_to admin_orders_label_path(@order.number, @label.id)
+        end
+
+        private
+
+        def load_order
+          @order = Spree::Order.find_by!(number: params[:order_number])
+        end
+
+        def set_label
+          @label = order_labels.find(params[:id])
+        end
+
+        def order_labels
+          @order.solidus_me_labels
+        end
+
+        def current_account
+          @current_account ||= ::SolidusMe::Account.active.first
+        end
+
+        def step_path
+          case @label.status
+            when "pending"
+              admin_orders_step_payment_label_path(@order.number, @label.id)
+            when "paid"
+              admin_orders_step_generate_label_path(@order.number, @label.id)
+            when "generated_label"
+              admin_orders_step_print_label_path(@order.number, @label.id)
+            when "completed_label"
+              admin_orders_label_path(@order.number, @label.id)
+            else
+              admin_orders_labels_path(@order.number)
+          end
+        end
+
+        def process_payment
+          @label.pay!
+          flash[:success] = "Etiqueta paga com sucesso"
+          redirect_to admin_orders_step_generate_label_path(@order.number, @label.id)
+        end
+
+        def process_generation
+          @label.generate!
+          flash[:success] = "Etiqueta gerada com sucesso"
+          redirect_to admin_orders_step_print_label_path(@order.number, @label.id)
+        end
+
+        def process_printing
+          @label.print!
+          flash[:success] = "Link de impressão gerado com sucesso"
+          redirect_to admin_orders_label_path(@order.number, @label.id)
+        end
+      end
+    end
+  end
+end

data/app/controller/spree/admin/solidus_me/accounts_controller.rb

@@ -44,22 +44,20 @@ module Spree
         def authorize
           code = params[:code]
           me_account = ::SolidusMe::Account.first
-          authorize_json = MeApi::Client.new.authorize(
-            client_id: me_account.client_id,
-            client_secret: me_account.client_secret,
+          authorize_response = MeApi::Client.new(client_id: me_account.client_id, client_secret: me_account.client_secret).authorize(
             code: code,
             redirect_url: me_account.redirect_url
-          ).json
+          )
           me_account.update(
-            access_token: authorize_json["access_token"],
-            refresh_token: authorize_json["refresh_token"],
-            token_expires_in: (DateTime.now + authorize_json["expires_in"].seconds).to_s
+            access_token: authorize_response.access_token,
+            refresh_token: authorize_response.refresh_token,
+            token_expires_at: (DateTime.now + authorize_response.expires_in.seconds).to_s
           )
           redirect_to edit_admin_solidus_me_account_path me_account
         end
 
         def update_from_api
-          @me_account.sync_with_api_data
+          @me_account.sync_with_api!
           flash[:success] = "Dados da conta atualizados a partir da API"
           redirect_to edit_admin_solidus_me_account_path(@me_account.id)
         rescue StandardError => e
@@ -71,7 +69,7 @@ module Spree
 
         def account_params
           params.require(:account).permit(
-            :client_id, :client_secret, :access_token, :refresh_token, :redirect_url, :state, :token_expires_in, :services, :postal_code_from, :name, :email, :tax_id, :phone, :address, :address_complement, :address_number, :address_district, :address_city, :address_state_abbr
+            :client_id, :client_secret, :access_token, :refresh_token, :redirect_url, :state, :token_expires_at, :services, :postal_code_from, :name, :email, :tax_id, :phone, :address, :address_complement, :address_number, :address_district, :address_city, :address_state_abbr, :test_mode
           )
         end
 

data/app/models/solidus_me/account.rb

@@ -1,53 +1,99 @@
 module SolidusMe
   class Account < ApplicationRecord
-    def check_token
-      return if client_id.blank? || client_secret.blank? || refresh_token.blank?
-      return if (token_expires_in - 1.day) > DateTime.now
-      refresh
-    end
-
-    def refresh
-      refresh_json = MeApi::Client.new.refresh_token(
-        client_id: client_id,
-        client_secret: client_secret,
-        refresh_token: refresh_token
-      ).json
-      access_token = refresh_json["access_token"]
-      refresh_token = refresh_json["refresh_token"]
-      token_expires_in = DateTime.now.utc + refresh_json["expires_in"].seconds
-      update(access_token: access_token, refresh_token: refresh_token, token_expires_in: token_expires_in)
-    end
-
-    def account_data
-      me_client.get_account_data
-    end
-
-    def balance
-      me_client.get_balance
-    end
-
-    def sync_with_api_data
-      data = account_data
-
-      update(
-        name: data.name,
-        email: data.email,
-        tax_id: data.document,
-        phone: data.phone.phone,
-        address: data.address&.address,
-        address_complement: data.address&.complement,
-        address_number: data.address&.number,
-        address_district: data.address&.district,
-        address_city: data.address&.city&.city,
-        address_state_abbr: data.address&.city&.state&.state_abbr,
-        postal_code_from: data.address&.postal_code
-      )
+    has_many :labels, class_name: "SolidusMe::Label", foreign_key: :solidus_me_account_id, dependent: :destroy
+
+    validates :client_id, :client_secret, presence: true
+    validate :only_one_production_account_active, if: :production_mode?
+
+    scope :active, -> { where.not(access_token: [nil, ""]) }
+    scope :production_mode, -> { where(test_mode: false) }
+    scope :test_mode, -> { where(test_mode: true) }
+
+    scope :first_active_test_mode, -> { test_mode.active.first }
+    scope :first_active_production_mode, -> { production_mode.active.first }
+
+    delegate :get_account_data, :get_balance, to: :me_client
+
+    def active?
+      access_token.present?
+    end
+
+    def test_mode?
+      test_mode
+    end
+
+    def production_mode?
+      !test_mode?
+    end
+
+    def address_complete?
+      [address, address_city, address_state_abbr, postal_code_from].all?(&:present?)
+    end
+
+    def mode_display
+      test_mode? ? "Teste" : "Produção"
+    end
+
+    def status_display
+      if active?
+        "Ativa (#{mode_display})"
+      else
+        "Inativa"
+      end
+    end
+
+    def sync_with_api!
+      transaction do
+        api_data = get_account_data
+        sync_with_api_data(api_data)
+        touch(:last_synced_at)
+      end
+    rescue StandardError => e
+      Rails.logger.error "Failed to sync account #{id}: #{e.message}"
+      raise
     end
 
     private
 
     def me_client
-      @me_client ||= MeApi::Client.new(access_token)
+      @me_client ||= MeClient.for_account(self)
+    end
+
+    def sync_profile_data(api_data)
+      assign_attributes(
+        name: api_data.name,
+        email: api_data.email,
+        tax_id: api_data.document,
+        phone: api_data.phone&.phone
+      )
+    end
+
+    def sync_address_data(api_address)
+      return if api_address.nil?
+      
+      assign_attributes(
+        address: api_address.address,
+        address_complement: api_address.complement,
+        address_number: api_address.number,
+        address_district: api_address.district,
+        address_city: api_address.city&.city,
+        address_state_abbr: api_address.city&.state&.state_abbr,
+        postal_code_from: api_address.postal_code
+      )
+    end
+
+    def sync_with_api_data(api_data)
+      sync_profile_data(api_data)
+      sync_address_data(api_data.address)
+    end
+
+    def only_one_production_account_active
+      return unless access_token.present? && production_mode?
+      
+      existing_production = self.class.production_mode.active.where.not(id: id)
+      if existing_production.exists?
+        errors.add(:test_mode, "Apenas uma conta de produção pode estar ativa por vez")
+      end
     end
   end
 end

data/app/models/solidus_me/label.rb

@@ -0,0 +1,155 @@
+module SolidusMe
+  class Label < ApplicationRecord
+    belongs_to :order, foreign_key: :spree_order_id, class_name: "::Spree::Order"
+    belongs_to :account, foreign_key: :solidus_me_account_id, class_name: "SolidusMe::Account"
+
+    validates :status, presence: true
+
+    scope :pending, -> { where(status: 'pending') }
+    scope :paid, -> { where(status: 'paid') }
+    scope :generated, -> { where(status: 'generated_label') }
+    scope :completed, -> { where(status: 'completed_label') }
+    scope :recent, -> { order(created_at: :desc) }
+
+    def pending?
+      status == 'pending'
+    end
+
+    def paid?
+      status == 'paid'
+    end
+
+    def generated?
+      status == 'generated_label'
+    end
+
+    def completed?
+      status == 'completed_label'
+    end
+
+    def can_pay?
+      pending?
+    end
+
+    def can_generate?
+      paid?
+    end
+
+    def can_print?
+      generated?
+    end
+
+    def current_step
+      case status
+      when "pending"
+        2
+      when "paid"
+        3
+      when "generated_label"
+        4
+      when "completed_label"
+        5
+      else
+        1
+      end
+    end
+
+    def add_to_cart!
+      cart_response = build_cart_request
+      update!(
+        external_id: cart_response.id,
+        price: cart_response.price,
+        status: cart_response.status
+      )
+    end
+
+    def pay!
+      raise "Cannot pay label in #{status} status" unless can_pay?
+      
+      payment_response = me_client.pay_label(external_id)
+      update!(
+        status: payment_response.purchase.status,
+        paid_at: payment_response.purchase.paid_at
+      )
+    end
+
+    def generate!
+      raise "Cannot generate label in #{status} status" unless can_generate?
+      
+      me_client.generate_label(external_id)
+      update!(status: 'generated_label')
+      touch(:generated_at)
+    end
+
+    def print!
+      raise "Cannot print label in #{status} status" unless can_print?
+    
+      print_response = me_client.print_label(external_id)
+      get_response = me_client.get_label(external_id)
+      
+      update!(
+        status: 'completed_label',
+        link: print_response.first,
+        tracking_code: get_response.self_tracking
+      )
+      touch(:completed_at)
+    end
+
+    private
+
+    def me_client
+      @me_client ||= MeClient.for_account(account)
+    end
+
+    def build_cart_request
+      order = Spree::Order.find(spree_order_id)
+      address = order.ship_address
+      package = Spree::Stock::SimpleCoordinator.new(order).send(:build_packages).sole
+      shipping_method = order.shipments.sole.selected_shipping_rate.shipping_method
+      service_data = MelhorEnvio::SHIPPING_METHODS.find { |m| m[:name] == shipping_method.name }
+      dimensions = PackageEstimator.new(package).estimate_dimensions
+      
+      me_client.add_label_to_cart(
+        service_id: service_data[:external_id],
+        from_name: account.name,
+        from_phone: account.phone,
+        from_email: account.email,
+        from_address: account.address,
+        from_address_complement: account.address_complement,
+        from_address_number: account.address_number,
+        from_address_district: account.address_district,
+        from_address_city: account.address_city,
+        from_postal_code: account.postal_code_from,
+        from_address_state_abbr: account.address_state_abbr,
+        from_tax_id: account.tax_id,
+        to_name: address.name,
+        to_phone: address.phone,
+        to_email: order.email,
+        to_address: address.address1,
+        to_address_complement: address.address2,
+        to_address_number: address.number,
+        to_address_district: address.district,
+        to_address_city: address.city,
+        to_postal_code: address.zipcode,
+        to_address_state_abbr: address.state.abbr,
+        to_tax_id: order.tax_id,
+        volumes: [
+          MeApi::Volume.new(
+            width_cm: dimensions[0],
+            height_cm: dimensions[1],
+            length_cm: dimensions[2],
+            weight_kg: package.weight / 1000
+          )
+        ],
+        products: order.line_items.map do |line_item|
+          MeApi::Product.new(
+            name: line_item.name,
+            quantity: line_item.quantity,
+            unitary_value: line_item.price
+          )
+        end,
+        insurance_value: order.total
+      )
+    end
+  end
+end