Perguntas[ruby-on-rails](coding)

Tenho um modelo Entityque pode ter offerse invoices. O usuário pode criar formatos de número personalizados para exibir o número da fatura. Por exemplo, o número da fatura interna 23pode se tornar 2025INV00000023ou algo assim. Agora, para offers, precisamos ser capazes de usar um formato de número diferente. 23pode se tornar 2025OFF00000023.

Fiz isso criando uma NumberFormatclasse onde o usuário pode configurar formatos de números de várias maneiras. Os formatos de números são anexados a entidades porque todas as faturas de uma entidade precisam ter numeração uniforme/consistente para fins fiscais/contábeis.

Meu Entitymodelo começa assim:

class Entity < ApplicationRecord
  has_many :invoices, dependent: :restrict_with_error
  has_many :offers, dependent: :restrict_with_error

alguns mais não relacionadoshas_many

  belongs_to :invoice_number_format, class_name: 'NumberFormat'
  belongs_to :offer_number_format, class_name: 'NumberFormat'

Agora minha NumberFormatclasse precisa ter a outra ponta do belongs_torelacionamento. Mas não tenho certeza se a duplicação ali é a abordagem correta para evitar que dependent: :restrict_with_erroro usuário exclua formatos de números que ainda estão em uso. O autoformatador do VSCode apenas exclui o segundo ao salvar. Posso, é claro, salvar sem formatar (e tomar muito cuidado para não esquecer sempre que editar este arquivo) e, após testes preliminares, parece que funciona, mas estou pensando se minha abordagem talvez não seja a ideal?

  has_many :entities, inverse_of: :invoice_number_format,
                      dependent: :restrict_with_error
  # This line gets deleted on save
  has_many :entities, inverse_of: :offer_number_format,
                      dependent: :restrict_with_error

Eu tenho um método "destroy" do controlador que verifica vários objetos dependentes e falha com mensagens de alerta correspondentes. A exclusão também é impedida no lado do banco de dados, has_many :invoices, dependent: :restrict_with_errormas falha silenciosamente para o usuário.

Rubocop acha que "Tamanho da Condição de Ramificação de Atribuição é muito alto" e eu gostaria de refatorar isso também porque parece meio repetitivo. No entanto, tenho dificuldades com os retornos. Quando movo verificações para uma função privada, o retorno retorna da função, mas também preciso que ele encerre o método "destroy". Preciso de um retorno duplo.

def destroy
    unless Current.user.default_entity.owner == Current.user ||
           Current.user.default_entity.user_privileged?('manage_contacts')

      redirect_back(fallback_location: contacts_path, alert: t('errors.no_access_rights')) and return
    end

    unless @contact.invoices.count.zero?
      redirect_back(fallback_location: contacts_path,
                    alert: t('errors.cant_delete_contact_with_invoices')) and return
    end

    unless @contact.offers.count.zero?
      redirect_back(fallback_location: contacts_path,
                    alert: t('errors.cant_delete_contact_with_offers')) and return
    end

    @contact.destroy

    redirect_to contacts_path, status: :see_other
  end

Tenho métodos semelhantes em outros controladores em toda a minha aplicação. Talvez haja um padrão para refatorar esses tipos de métodos?

Quero exportar meus dados de vendas para um arquivo CSV em uma tarefa rake. A tabela de vendas tem aproximadamente 100 milhões de entradas. Como posso otimizar esse código? Ele parece ficar mais lento quanto mais tempo é executado.

sales = Sales.where(year: 2024)
BATCH_SIZE = 10_000
header_names = %w[user_id article_id amount currency date]
batch = []
File.open(filepath, 'w') do |file|
  sales.find_each(batch_size: BATCH_SIZE)do |sale|
    batch << sale.slice(*header_names).values.join(';')
    if batch.size >= BATCH_SIZE

      file.puts batch.join("\n")
      batch.clear
    end
  end
  file.puts batch.join("\n") unless batch.empty?
end

Isso me leva aproximadamente 23 minutos para exportar 17 milhões de entradas.

Tenho um aplicativo Rails 8 que usa Inertia.js e Vue. Não tenho certeza de como implementar uma redirect_to()solicitação usando Inertia.js dentro do Rails. Minhas tentativas não estão funcionando. Estou usando https://github.com/skryukov/inertia_rails-contriba integração do Inertia.js no Rails.

O repositório do Github está emhttps://github.com/Chrisgo-75/rails8_inertiajs_vuejs

O fluxo de trabalho é

a) O botão HTML "Adicionar ao carrinho" pode ser encontrado em /app/frontend/pages/Store/Index.vue.

# /app/frontend/pages/Store/Index.vue

<template>
  <button
    @click="addToCart(product.id)"
    class="ml-4 rounded-lg py-1 px-2 text-white bg-green-600"
    >
    Add to Cart
  </button>
</template>

<script setup lang="ts">
import axios from "axios";
import { router } from '@inertiajs/vue3';

const addToCart = async (productId: number) => {
  try {
    const response = await axios.post('/line_items',
        { product_id: productId },
        { headers: { 'X-CSRF-Token': csrfToken } } // Include CSRF token
    );

    alert('Product added to cart!');

    // Extract the cart ID from the response.
    const cartId = response.data.cart_id;

    router.visit(`/carts/${cartId}`);
  } catch (error) {
    console.error('Error adding to cart: ', error);
    alert('Failed to add product to cart.');
  }
};
</script>

b) Clicar no botão "Adicionar ao carrinho" vai para a /app/controllers/line_items_controller.rbação Criar controlador.

• Não consegui fazer o Inertia.js funcionar dentro desta ação de criação, usando um Rails redirect_to().
• Então, atualmente estou cart_idretornando para o Vue como JSON.

# line_items_controller.rb

def create
    product = Product.find(params[:product_id])
    @line_item = @cart.line_items.build(product: product)

    if @line_item.save
      # redirect_to @line_item.cart, notice: "Line item was successfully created."
      # redirect_to @cart, notice: "Cart was successfully updated."
      # redirect_to inertia: cart_path(@cart), notice: "Cart was successfully updated."
      render json: { cart_id: @cart.id }
    else
      # redirect_to new_line_item_url, inertia: { errors: @line_item.errors }
      # render inertia: "Carts/Show", props: { cart: @cart, errors: @line_item.errors }
      render json: { errors: @line_item.errors.full_messages },
             status: :unprocessable_entity
    end
end # END def create

c) A ação Criar do Controlador LineItems cart_idretorna para /app/frontend/pages/Store/Index.vueonde ela executa router.visit('/carts/${cartId}').

Alguém tem uma solução para implementar uma redirect_to()requisição Inertia.js dentro do Rails?

Tenho uma aplicação Rails usando Postgres como banco de dados.

O Postrgres não aceita strings contendo bytes nulos (exemplo: "a \u0000 b"). Tentar salvar esses dados leva ao seguinte erro:

ActiveRecord::StatementInvalid
PG::UntranslatableCharacter: ERROR:  unsupported Unicode escape sequence

Gostaria de configurar uma regra que funcionasse para todos os meus modelos ActiveRecord, garantindo que cada atributo de string removesse bytes nulos dele antes de salvar. Estou pensando em algo que poderia ter um efeito semelhante ao exemplo abaixo:

class MyModel < ApplicationRecord
  before_save :remove_null_bytes

  private

  def remove_null_bytes
    my_field.delete!("\u0000")
  end
end

Mas aplicado a cada atributo de string de cada modelo sem ser forçado a defini-lo repetidamente.

O motivo pelo qual quero que isso seja limitado aos atributos de string do Active Record é que o aplicativo também manipula uploads binários e webhooks de e-mail. Eles podem conter bytes nulos legítimos, e não quero que sejam afetados pela nova regra.

Tenho dois modelos:

class Product
  belongs_to :storage_box
end

class StorageBox
  validates :key
            presence: true,
            uniqueness: { scope: %i[kind] }

  validates :kind
            presence: true
  def code
    "#{key}#{kind.to_s.rjust(4, '0')}"
  end
end

Gostaria de poder definir a storage_boxrelação com base no codemétodo:

Product.new(storage_box: '150001')

Como devo proceder para conseguir isso? Não tenho certeza se o Productdeve lidar com isso (parece que não é "rails" fazer isso lá) ou instruir o StorageBoxcomo encontrar a base no code.

Qual é a diferença entre isso:

User.includes(:sites).where("sites.name = 'test'").references(:sites)

e isto:

User.joins(:sites).where(sites: { name: "test"} )

Existe um consenso geral sobre o uso de um método em vez do outro?

Tenho uma pasta Rails com dois arquivos:

app/hub_spot/client.rb:
module HubSpot
  class Client

app/hub_spot/create_contact_form.rb:
module HubSpot
  class CreateContactForm

quando executo a verificação zeitwerk recebo:

expected file app/hub_spot/client.rb to define constant Client, but didn't

se eu adicionar:

config.autoload_paths << Rails.root.join("app/hub_spot")
config.eager_load_paths << Rails.root.join("app/hub_spot")

então recebo um novo erro:

expected file app/hub_spot/create_contact_form.rb to define constant CreateContactForm, but didn't

parece reclamar sobre ambos os arquivos de forma diferente? Tem alguma maneira de dizer ao Zeitwerk para olhar a pasta para o nome do módulo?

# frozen_string_literal: true

class UserUploader < ApplicationUploader
  include CarrierWave::MiniMagick

  def generate_image(text)
    tmp_path = File.join(Dir.tmpdir, "#{SecureRandom.hex}.png")

    MiniMagick::Tool::Convert.new do |img|
      img.size "500x200"
      img.xc "white"            # Background color
      img.gravity "Center"      # Center the text
      img.pointsize "36"        # Font size
      img.fill "black"          # Text color
      img.draw "text 0,0 '#{text}'"
      img.font "#{Rails.root.join('public', 'font', 'Franklin_Gothic_Heavy_Regular.ttf')}"
      img << tmp_path           # Save image to this path
    end

    File.open(tmp_path)  # Return file handle
  end
end

Estou enviando parâmetros do frontend e a fonte que estou usando no frontend é Franklin_Gothic_Heavy_Regular.ttf definida em app/assets/fonts/Franklin_Gothic_Heavy_Regular.ttf

Para usá-lo no carregador, adicionei o mesmo arquivo de fonte em public/font/Franklin_Gothic_Heavy_Regular.ttf, mas quando a imagem é armazenada, ela não mostra a fonte correta.

Estou usando vuejs no front-end e rails no back-end. Por favor, me ajude a consertar isso.

Informações do ImageMagick

Version: ImageMagick 7.1.0-58 Q16-HDRI x86_64 20802 https://imagemagick.org
Copyright: (C) 1999 ImageMagick Studio LLC
License: https://imagemagick.org/script/license.php
Features: Cipher DPC HDRI Modules OpenMP(5.0) 
Delegates (built-in): bzlib fontconfig freetype gslib heic jng jp2 jpeg jxl lcms lqr ltdl lzma openexr png ps raw tiff webp xml zlib
Compiler: gcc (4.2)

coloca img.command.join(" ") retorna

magick convert -size 500x200 xc:white -gravity Center -pointsize 36 -fill black -draw text 0,0 'Testing Font' -font /Users/Documents/work/company/public/font/Franklin_Gothic_Heavy_Regular.ttf /var/folders/tc/3b0wh1xs7z7dms5rxj1l23_00000gn/T/74a90ba3c194bda014cb2706a3fcdd32.png

Preciso acessar uma constante ActiveRecord de um módulo incluído em um aplicativo Rails.

class User < ApplicationRecord
  include ModOne
  
  OPTIONS = {a: 1}.freeze

  ...
end

Module ModOne
  extend ActiveSupport::Concern

  included do
    do_semething(self::OPTIONS)
  end

  class_methods do
   def do_something(opts)
     ...
   end
  end
end

Mas eu entendo

NameError: constante não inicializada Usuário (chame 'User.connection' para estabelecer uma conexão)::OPTIONS Você quis dizer? Usuário::OPTIONS

O que estou perdendo aqui?

Também tentei substituir selfpor base_classe evento User, mas recebo o mesmo erro.