Ricky883249's questions

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?

Estou tentando configurar 2 modelos (Entidades, Usuários) onde cada usuário pode trabalhar com várias entidades e cada entidade pode ter vários usuários trabalhando com elas. Quero que os relacionamentos sejam únicos, ou seja, um usuário não pode trabalhar 2 vezes com a mesma entidade e uma entidade não pode ter o mesmo usuário duas vezes.

Estou usando um relacionamento has_many e estou armazenando informações extras, como direitos de acesso, na classe "through".

class Entity < ApplicationRecord
  has_many :user_entity_roles, dependent: :destroy
  accepts_nested_attributes_for :user_entity_roles
  has_many :users, through: :user_entity_roles, dependent: :restrict_with_error
end

class User < ApplicationRecord
  has_many :user_entity_roles, dependent: :destroy
  has_many :entities, through: :user_entity_roles, dependent: :restrict_with_error
end

class UserEntityRole < ApplicationRecord
  belongs_to :entity, touch: true
  belongs_to :user
end

Agora, por meio de um erro em um formulário que eu estava construindo, criei um relacionamento duplicado. Claro que posso tentar evitar isso não tendo erros em meus formulários, mas me pergunto se há uma maneira de forçar apenas combinações únicas de Usuários e Entidades?

Estou tentando escrever um teste para um controlador. A ação "criar" espera dados do formulário e rejeita como "entidade não processável" se os dados do formulário não forem validados:

Failure:
ContactsControllerTest#test_should_post_create [test/controllers/contacts_controller_test.rb:36]:
Expected response to be a <3XX: redirect>, but was a <422: Unprocessable Entity>

Estou incluindo modelo, controlador, controlador de teste e acessórios abaixo. A autorização ainda está pronta para uso, mas não deve ser um fator aqui (outros testes funcionam bem).

Suspeito que as chaves estrangeiras nos parâmetros sejam as culpadas aqui, mas não sei como verificar isso. Também tentei @saluation.id e @debitor.id nos parâmetros de teste.

Modelo

class Contact < ApplicationRecord
    validates :last_name, presence: true
    validates :email, format: {
        with: URI::MailTo::EMAIL_REGEXP
    }
    belongs_to :salutation
    belongs_to :debitor

Controlador

class ContactsController < ApplicationController

  def create
      @contact = Contact.new(contact_params)
      @debitors = Debitor.all
      @salutations = Salutation.all
    
      if @contact.save 
        redirect_to contacts_path
      else
        render :new, status: :unprocessable_entity
      end
  end

  private
  def contact_params
    params.require(:contact).permit(:last_name, :first_name, :email, :salutation_id, :debitor_id)
  end

end

Teste

require "test_helper"

class ContactsControllerTest < ActionDispatch::IntegrationTest
  setup do
    @user = users(:lazaro_nixon)
    @contact = contacts(:one)
    @salutation = salutations(:one)
    @debitor = debitors(:one)
  end


  test "should post create" do
    sign_in_as @user

    post contacts_url, :params => { :contact => { last_name: "Lastname", first_name: "Firstname", email: "[email protected]", salutation: @salutation, debitor: @debitor }}
    assert_response :redirect
    follow_redirect!
    assert_response :success
  end

end

Luminárias - contatos

one:
  last_name: MyString
  first_name: MyString
  email: MyString
  salutation: one
  debitor: one

Jogos - saudações

one:
  salutation: MyString

Jogos - devedores

one:
  company: MyString
  street: MyString
  house_number: MyString
  zip: 1
  city: MyString
  payment_terms: one