unico-training 7.8.0

data/app/models/similarity_control.rb

@@ -0,0 +1,2 @@
+class SimilarityControl < Unico::SimilarityControl
+end

data/app/models/similarity_control_item.rb

@@ -0,0 +1,2 @@
+class SimilarityControlItem < Unico::SimilarityControlItem
+end

data/app/models/similarity_control_table.rb

@@ -0,0 +1,2 @@
+class SimilarityControlTable < Unico::SimilarityControlTable
+end

data/app/models/state.rb

@@ -0,0 +1,2 @@
+class State < InscriptioCursualis::State
+end

data/app/models/street.rb

@@ -0,0 +1,2 @@
+class Street < InscriptioCursualis::Street
+end

data/app/models/street_type.rb

@@ -0,0 +1,2 @@
+class StreetType < InscriptioCursualis::StreetType
+end

data/app/models/unico/agency.rb

@@ -0,0 +1,25 @@
+class Unico::Agency < Unico::Model
+  self.abstract_class = true
+  self.table_name = :unico_agencies
+
+  attr_modal :name, :number, :bank_id
+
+  belongs_to :bank, class_name: '::Bank'
+
+  has_many :bank_accounts, dependent: :restrict_with_exception
+
+  validates :name, :number, :digit, :bank, presence: true
+  validates :email, mail: true, allow_blank: true
+  validates :phone, :fax, mask: '(99) 9999-9999', allow_blank: true
+
+  orderize
+  filterize
+
+  def self.bank_id(bank_id)
+    where(bank_id: bank_id)
+  end
+
+  def to_s
+    name
+  end
+end

data/app/models/unico/bank.rb

@@ -0,0 +1,18 @@
+class Unico::Bank < Unico::Model
+  self.abstract_class = true
+  self.table_name = :unico_banks
+
+  has_many :agencies, dependent: :restrict_with_exception
+  has_many :bank_accounts, through: :agencies
+
+  validates :name, :acronym, presence: true
+  validates :name, uniqueness: { allow_blank: true }
+  validates :code, presence: true, length: { maximum: 5 }
+
+  filterize
+  orderize
+
+  def to_s
+    name
+  end
+end

data/app/models/unico/bank_account.rb

@@ -0,0 +1,31 @@
+class Unico::BankAccount < Unico::Model
+  extend EnumerateIt
+
+  self.abstract_class = true
+  self.table_name = :unico_bank_accounts
+
+  attr_writer :bank, :bank_id
+
+  attr_modal :description, :agency_id, :account_number
+
+  has_enumeration_for :status
+  has_enumeration_for :kind, with: BankAccountKind
+
+  belongs_to :agency, class_name: '::Agency'
+
+  has_one :bank, through: :agency
+
+  delegate :number, :digit, to: :agency, allow_nil: true, prefix: true
+  delegate :bank_id, to: :agency, allow_nil: true, prefix: false
+
+  validates :description, :agency, :kind, :account_number, :digit, presence: true
+  validates :account_number, numericality: true
+  validates :description, uniqueness: { scope: :agency_id }, allow_blank: true
+
+  orderize :account_number
+  filterize
+
+  def to_s
+    description
+  end
+end

data/app/models/unico/cnae.rb

@@ -0,0 +1,19 @@
+class Unico::Cnae < Unico::Model
+  self.abstract_class = true
+
+  acts_as_nested_set
+
+  belongs_to :risk_degree, class_name: '::RiskDegree'
+
+  validates :name, :code, presence: true
+
+  # TODO
+  # https://github.com/collectiveidea/awesome_nested_set/issues/217
+  def self.quoted_table_name
+    '"unico_cnaes"'
+  end
+
+  def to_s
+    name
+  end
+end

data/app/models/unico/communication_source.rb

@@ -0,0 +1,15 @@
+class Unico::CommunicationSource < Unico::Model
+  self.abstract_class = true
+  self.table_name = :unico_communication_sources
+
+  has_many :dissemination_sources, class_name: '::DisseminationSource', dependent: :restrict_with_exception
+
+  validates :description, presence: true, uniqueness: { allow_blank: true }
+
+  filterize
+  orderize :description
+
+  def to_s
+    description
+  end
+end

data/app/models/unico/creditor_balance.rb

@@ -0,0 +1,8 @@
+class Unico::CreditorBalance < Unico::Model
+  self.abstract_class = true
+
+  belongs_to :creditor, class_name: '::Creditor'
+
+  validates :fiscal_year, mask: '9999', allow_blank: true
+  validates :fiscal_year, :creditor, presence: true
+end

data/app/models/unico/creditor_bank_account.rb

@@ -0,0 +1,21 @@
+class Unico::CreditorBankAccount < Unico::Model
+  extend EnumerateIt
+
+  self.abstract_class = true
+  self.table_name = :unico_creditor_bank_accounts
+
+  has_enumeration_for :status
+  has_enumeration_for :account_type
+
+  belongs_to :creditor, class_name: '::Creditor'
+  belongs_to :agency, class_name: '::Agency'
+
+  delegate :bank, :bank_id, to: :agency, allow_nil: true
+
+  validates :creditor, :agency, :status, :account_type, :digit, presence: true
+  validates :number, presence: true, uniqueness: { scope: :agency_id }
+
+  def to_s
+    "#{number}-#{digit}"
+  end
+end

data/app/models/unico/creditor_document.rb

@@ -0,0 +1,37 @@
+class Unico::CreditorDocument < Unico::Model
+  extend EnumerateIt
+
+  self.abstract_class = true
+
+  has_enumeration_for :issuer
+
+  belongs_to :creditor, class_name: '::Creditor'
+  belongs_to :document_type, class_name: '::DocumentType'
+
+  delegate :description, to: :document_type, allow_nil: true
+
+  validates :document_type, :document_number, :emission_date, :validity, :issuer,
+            presence: true
+
+  validates :emission_date,
+            timeliness: {
+              on_or_before: :today,
+              type: :date,
+              on_or_before_message: :should_be_on_or_before_today
+            }, allow_blank: true
+  validates :validity,
+            timeliness: {
+              on_or_after: :emission_date,
+              type: :date,
+              on_or_after_message: :validity_should_be_on_or_after_emission_date
+            }, allow_blank: true
+
+  def self.by_habilitation_kind(kind)
+    joins(:document_type)
+      .where(DocumentType.arel_table[:habilitation_kind].eq kind)
+  end
+
+  def to_s
+    document_type
+  end
+end

data/app/models/unico/creditor_representative.rb

@@ -0,0 +1,19 @@
+class Unico::CreditorRepresentative < Unico::Model
+  self.abstract_class = true
+  self.table_name = :unico_creditor_representatives
+
+  belongs_to :creditor, class_name: '::Creditor'
+  belongs_to :representative_person, class_name: '::Person'
+
+  delegate :name, :identity_document, :phone, :email, :identity_number, :to_s,
+           to: :representative_person, allow_nil: true
+
+  orderize :id
+
+  def self.term(q)
+    person_table = ::Person.arel_table
+
+    joins(:representative_person)
+      .where(person_table[:name].matches("#{q}%"))
+  end
+end

data/app/models/unico/creditor_secondary_cnae.rb

@@ -0,0 +1,6 @@
+class Unico::CreditorSecondaryCnae < Unico::Model
+  self.abstract_class = true
+
+  belongs_to :creditor, class_name: '::Creditor'
+  belongs_to :cnae, class_name: '::Cnae'
+end

data/app/models/unico/currency.rb

@@ -0,0 +1,13 @@
+class Unico::Currency < Unico::Model
+  self.abstract_class = true
+
+  validates :name, :acronym, :precision, presence: true
+  validates :name, :acronym, uniqueness: true, allow_blank: true
+  validates :acronym, length: { maximum: 4 }, allow_blank: true
+  validates :precision, numericality: { greater_than_or_equal_to: 2, less_than_or_equal_to: 8 },
+                        allow_blank: true
+
+  def to_s
+    name
+  end
+end

data/app/models/unico/customer.rb

@@ -0,0 +1,25 @@
+class Unico::Customer < Unico::Model
+  self.abstract_class = true
+
+  serialize :database
+
+  validates :name, :domain, :database, presence: true
+  validates :name, :domain, uniqueness: { allow_blank: true }
+  validates :secret_token, uniqueness: true
+
+  before_create :generate_secret_token
+
+  def to_s
+    name
+  end
+
+  def using_connection(&block)
+    ActiveRecord::Base.using_connection(id, database, &block)
+  end
+
+  private
+
+  def generate_secret_token
+    self.secret_token = SecureRandom.hex
+  end
+end

data/app/models/unico/dissemination_source.rb

@@ -0,0 +1,19 @@
+class Unico::DisseminationSource < Unico::Model
+  self.abstract_class = true
+  self.table_name = :unico_dissemination_sources
+
+  belongs_to :communication_source, class_name: '::CommunicationSource'
+
+  has_and_belongs_to_many :regulatory_acts, join_table: :unico_dissemination_sources_unico_regulatory_acts
+
+  validates :description, :communication_source, presence: true
+  validates :description, uniqueness: { allow_blank: true }
+
+  def to_s
+    description
+  end
+
+  def destroyable?
+    regulatory_acts.empty?
+  end
+end

data/app/models/unico/document_type.rb

@@ -0,0 +1,21 @@
+class Unico::DocumentType < Unico::Model
+  extend EnumerateIt
+
+  self.abstract_class = true
+  self.table_name = :unico_document_types
+
+  has_enumeration_for :habilitation_kind
+
+  has_many :creditor_documents, class_name: '::CreditorDocument'
+
+  validates :validity, :description, presence: true
+  validates :description, uniqueness: { allow_blank: true }
+  validates :validity, numericality:  { allow_blank: true }
+
+  orderize :description
+  filterize
+
+  def to_s
+    description
+  end
+end

data/app/models/unico/material.rb

@@ -0,0 +1,33 @@
+class Unico::Material < Unico::Model
+  extend EnumerateIt
+
+  self.abstract_class = true
+  self.table_name = :unico_materials
+
+  attr_modal :description, :material_classification
+
+  attr_writer :autocomplete_material_class
+
+  has_enumeration_for :material_classification, with: MaterialClassificationType,
+                                                create_helpers: true, create_scopes: true
+
+  belongs_to :material_class, class_name: '::MaterialClass'
+  belongs_to :reference_unit, class_name: '::ReferenceUnit'
+
+  validates :material_class, :reference_unit, :material_classification, :detailed_description, presence: true
+  validates :code, :description, presence: true, uniqueness: { allow_blank: true }
+  validates :control_amount, inclusion: { in: [true, false] }
+
+  orderize :description
+  filterize
+
+  def to_s
+    "#{code} - #{description}"
+  end
+
+  def autocomplete_material_class
+    return '' unless material_class.present?
+
+    material_class.to_s
+  end
+end

data/app/models/unico/material_class.rb

@@ -0,0 +1,119 @@
+class Unico::MaterialClass < Unico::Model
+  self.abstract_class = true
+  self.table_name = :unico_material_classes
+
+  attr_accessor :parent_class_number, :number, :parent_number
+
+  attr_modal :class_number, :description
+
+  has_many :materials, dependent: :restrict_with_exception
+
+  validates :description, :masked_number, presence: true
+  validates :class_number, uniqueness: { allow_blank: true }
+  validates :number, numericality: { allow_blank: true }
+  validates :class_number, numericality: { greater_than: 0 }
+
+  before_validation :create_masked_number
+  before_validation :fill_class_number
+  after_save :update_parent_children
+  after_destroy :update_parent_children
+
+  orderize :description
+  filterize
+
+  def self.term(q)
+    class_number_condition = arel_table[:class_number].matches "#{q.delete('.')}%"
+    description_condition = arel_table[:description].matches "%#{q}%"
+
+    where(class_number_condition.or(description_condition))
+  end
+
+  def self.children(id, raw_class_number)
+    where(arel_table[:class_number].matches("#{raw_class_number}%"))
+      .where(arel_table[:id].not_eq(id))
+  end
+
+  def to_s
+    "#{masked_number} - #{description}"
+  end
+
+  def parent
+    self.class.find_by_class_number(raw_parent_class_number)
+  end
+
+  def editable?
+    !imported?
+  end
+
+  def children
+    return [] if class_number_level == levels
+
+    self.class.children(id, raw_class_number)
+  end
+
+  def class_number_level
+    splitted_masked_number_filled.size
+  end
+
+  def levels
+    mask.split('.').size
+  end
+
+  def update_has_children
+    update_column(:has_children, children.any?)
+  end
+
+  def splitted_masked_number
+    return [] unless masked_number.present?
+
+    masked_number.split('.')
+  end
+
+  def splitted_masked_number_filled
+    splitted_masked_number.select { |level| level.to_i > 0 }
+  end
+
+  private
+
+  def update_parent_children
+    parent.update_has_children if parent.present?
+
+    nil
+  end
+
+  def raw_parent_class_number
+    return '' if splitted_masked_number_filled.empty?
+
+    splitted_masked_number_filled[0, class_number_level - 1].join.ljust(mask_size, '0')
+  end
+
+  def fill_class_number
+    return unless masked_number.present?
+
+    self.class_number = masked_number.delete('.')
+  end
+
+  def raw_class_number
+    splitted_masked_number_filled.join
+  end
+
+  def create_masked_number
+    return unless parent_number && number
+
+    self.masked_number = if parent_number.present?
+                           [parent_number, number].join('.')
+                         else
+                           number
+                         end
+
+    mask.split('.').each_with_index do |level, index|
+      unless splitted_masked_number[index]
+        self.masked_number += '.' + '0' * level.size
+      end
+    end
+  end
+
+  def mask_size
+    mask.delete('.').size
+  end
+end