unico-training 7.8.0

data/app/models/inscriptio_cursualis/street_type.rb

@@ -0,0 +1,18 @@
+class InscriptioCursualis::StreetType < InscriptioCursualis::Model
+  self.abstract_class = true
+
+  has_paper_trail
+
+  has_many :streets, class_name: '::Street', dependent: :restrict_with_exception
+
+  validates :name, :acronym, presence: true
+  validates :name, :acronym, uniqueness: true, allow_blank: true
+
+  def self.active
+    where(inactive: false)
+  end
+
+  def to_s
+    name
+  end
+end

data/app/models/land_subdivision.rb

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

data/app/models/legal_nature.rb

@@ -0,0 +1,2 @@
+class LegalNature < Persona::LegalNature
+end

data/app/models/material.rb

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

data/app/models/material_class.rb

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

data/app/models/neighborhood.rb

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

data/app/models/occupation_base_group.rb

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

data/app/models/occupation_classification.rb

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

data/app/models/occupation_group.rb

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

data/app/models/occupation_main_group.rb

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

data/app/models/occupation_subgroup.rb

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

data/app/models/partner.rb

@@ -0,0 +1,2 @@
+class Partner < Persona::Partner
+end

data/app/models/person.rb

@@ -0,0 +1,2 @@
+class Person < Persona::Person
+end

data/app/models/persona/company.rb

@@ -0,0 +1,71 @@
+class Persona::Company < Persona::Model
+  extend EnumerateIt
+
+  self.abstract_class = true
+
+  has_enumeration_for :uf_state_registration, with: StateList, create_helpers: true
+
+  has_paper_trail
+
+  belongs_to :legal_nature, class_name: '::LegalNature'
+  belongs_to :responsible, class_name: '::Person', foreign_key: :person_id
+  belongs_to :company_size, class_name: '::CompanySize'
+
+  has_one :person, as: :personable, class_name: '::Person', dependent: :destroy
+
+  has_many :partners, class_name: '::Partner', inverse_of: :company, dependent: :destroy
+
+  accepts_nested_attributes_for :partners, allow_destroy: true
+
+  validates :cnpj, presence: true
+  validates :cnpj, cnpj: true, if: :cnpj_is_not_zeros?
+  validates :cnpj, mask: '99.999.999/9999-99', allow_blank: true
+  validates :cnpj, uniqueness: { if: :validate_cnpj_uniqueness? }, allow_blank: true, if: :cnpj_is_not_zeros?
+
+  validate :hundred_percent_for_partners
+  validate :uniqueness_of_person
+
+  def to_s
+    person.name
+  end
+
+  protected
+
+  def hundred_percent_for_partners
+    return if partners.empty?
+
+    return if partners.reject(&:marked_for_destruction?).map(&:percentage).compact.sum == 100
+
+    # FIXME: rails issue, see: https://github.com/rails/rails/issues/5061
+    errors.add(:partners, :hundred_percent)
+  end
+
+  def uniqueness_of_person
+    countable = {}
+
+    partners.each do |partner|
+      if partner.person_id.blank?
+        partner.errors.add(:person_id, :blank)
+      else
+        countable[partner.person_id] ||= 0
+        countable[partner.person_id] = countable[partner.person_id].to_i + 1
+      end
+    end
+
+    partners.each do |partner|
+      next unless countable[partner.person_id].to_i > 1
+      # FIXME: rails issue, see: https://github.com/rails/rails/issues/5061
+      errors.add(:partners, :invalid)
+
+      partner.errors.add(:person_id, :taken)
+    end
+  end
+
+  def validate_cnpj_uniqueness?
+    true
+  end
+
+  def cnpj_is_not_zeros?
+    cnpj != '00.000.000/0000-00'
+  end
+end

data/app/models/persona/company_size.rb

@@ -0,0 +1,12 @@
+class Persona::CompanySize < Persona::Model
+  self.abstract_class = true
+
+  has_many :companies, class_name: '::Company', dependent: :restrict_with_exception
+
+  validates :name, :number, :acronym, presence: true
+  validates :name, :number, :acronym, uniqueness: true, allow_blank: true
+
+  def to_s
+    name
+  end
+end

data/app/models/persona/creditor.rb

@@ -0,0 +1,102 @@
+class Persona::Creditor < Persona::Model
+  extend EnumerateIt
+  include Unico::CustomData
+  reload_custom_data
+
+  self.abstract_class = true
+
+  self.table_name = :unico_creditors
+
+  attr_accessor :name, :cpf, :cnpj
+
+  attr_modal :name, :cpf, :cnpj
+
+  has_enumeration_for :organ_responsible_for_registration, with: OrganResponsible
+
+  belongs_to :main_cnae, class_name: '::Cnae'
+  belongs_to :occupation_classification, class_name: '::OccupationClassification'
+  belongs_to :person, class_name: '::Person'
+
+  has_one :user, as: :authenticable
+
+  has_many :accounts, class_name: '::CreditorBankAccount', inverse_of: :creditor, dependent: :destroy
+  has_many :agencies, through: :accounts
+  has_many :banks, through: :accounts, source: :agency
+  has_many :creditor_secondary_cnaes, dependent: :destroy, class_name: '::CreditorSecondaryCnae'
+  has_many :cnaes, through: :creditor_secondary_cnaes
+  has_many :representatives, -> { order(:id) }, class_name: '::CreditorRepresentative', dependent: :destroy
+  has_many :representative_people, through: :representatives, source: :representative_person, class_name: '::Person'
+  has_many :creditor_balances, dependent: :destroy, class_name: '::CreditorBalance', inverse_of: :creditor
+  has_many :document_types, through: :documents
+  has_many :documents, -> { order(:id) }, class_name: '::CreditorDocument', dependent: :destroy
+  has_many :regularization_or_administrative_sanctions, dependent: :destroy, inverse_of: :creditor
+  has_many :registration_cadastral_certificates, dependent: :destroy
+
+  delegate :personable_type, :cnpj, :state_registration, :responsible,
+           :identity_document, :company?, :phone, :fax, :benefited, :address,
+           :city, :zip_code, :company_size, :choose_simple, :legal_nature,
+           :commercial_registration_number, :commercial_registration_date,
+           :personable_type_humanize, :company_partners, :uf_state_registration,
+           :individual?, to: :person, allow_nil: true
+  delegate :email, to: :person, allow_nil: true, prefix: true
+  delegate :identity_document, to: :responsible, prefix: true, allow_nil: true
+  delegate :name, to: :person, allow_nil: true
+  delegate :neighborhood, :state, :country, :zip_code, to: :address, allow_nil: true
+  delegate :bank_id, to: :accounts, allow_nil: true
+  delegate :materials_class, to: :materials, allow_nil: true
+  delegate :login, :email, to: :user, allow_nil: true
+  delegate :code, to: :main_cnae, prefix: true, allow_nil: true
+
+  accepts_nested_attributes_for :accounts, allow_destroy: true
+  accepts_nested_attributes_for :creditor_balances, allow_destroy: true
+  accepts_nested_attributes_for :representatives, allow_destroy: true
+  accepts_nested_attributes_for :user
+  accepts_nested_attributes_for :documents, allow_destroy: true
+  accepts_nested_attributes_for :regularization_or_administrative_sanctions, allow_destroy: true
+
+  validates :person, presence: true
+  validates :contract_start_date, timeliness: { type: :date }, allow_blank: true
+  validate :validate_custom_data
+
+  orderize :name, on: :person
+  filterize
+
+  def self.filter(params)
+    person_table = ::Person.arel_table
+    company_table = ::Company.arel_table
+    individual_table = ::Individual.arel_table
+
+    person_join = arel_table.join(person_table, Arel::Nodes::OuterJoin)
+                            .on(person_table[:id].eq(arel_table[:person_id]))
+
+    company_join = person_join.join(company_table, Arel::Nodes::OuterJoin)
+                              .on(person_table[:personable_type].eq('Company').and(person_table[:personable_id].eq(company_table[:id])))
+                              .join_sources
+
+    individual_join = person_join.join(individual_table, Arel::Nodes::OuterJoin)
+                                 .on(person_table[:personable_type].eq('Individual').and(person_table[:personable_id].eq(individual_table[:id])))
+                                 .join_sources
+
+    query = all
+
+    query = query.joins(individual_join) if params[:cpf].present?
+    query = query.joins(company_join) if params[:cnpj].present?
+    query = query.where(person_table[:name].matches("#{params[:name]}%")) if params[:name].present?
+    query = query.where(individual_table[:cpf].eq(params[:cpf])) if params[:cpf].present?
+    query = query.where(company_table[:cnpj].eq(params[:cnpj])) if params[:cnpj].present?
+
+    query
+  end
+
+  def to_s
+    person.to_s
+  end
+
+  def selected_cnaes
+    cnae_ids | [main_cnae_id]
+  end
+
+  def user?
+    user.present? && user.persisted?
+  end
+end

data/app/models/persona/identity.rb

@@ -0,0 +1,14 @@
+class Persona::Identity < Persona::Model
+  extend EnumerateIt
+
+  self.abstract_class = true
+
+  attr_readonly :person_id
+
+  has_enumeration_for :issuer
+
+  belongs_to :individual, class_name: '::Individual'
+  belongs_to :state, class_name: '::State'
+
+  validates :issue, timeliness: { before: :today, type: :date }, allow_blank: true
+end

data/app/models/persona/individual.rb

@@ -0,0 +1,40 @@
+class Persona::Individual < Persona::Model
+  extend EnumerateIt
+
+  self.abstract_class = true
+
+  mount_uploader :image, IndividualImageUploader
+
+  has_enumeration_for :gender, create_helpers: true
+  has_enumeration_for :marital_status
+  has_enumeration_for :nationality
+
+  has_paper_trail
+
+  belongs_to :place_of_birth, class_name: '::City'
+  belongs_to :country_of_birth, class_name: '::Country'
+
+  has_one :identity, class_name: '::Identity', dependent: :destroy
+  has_one :person, as: :personable, class_name: '::Person'
+
+  accepts_nested_attributes_for :identity, reject_if: :all_blank
+
+  validates :gender, presence: true
+  validates :cpf, cpf: true, mask: '999.999.999-99', allow_blank: true, if: :cpf_is_not_zeros?
+  validates :cpf, uniqueness: { if: :validate_cpf_uniqueness? }, allow_blank: true, if: :cpf_is_not_zeros?
+  validates :birthdate, timeliness: { before: :today, type: :date }, allow_blank: true
+
+  def to_s
+    person.name
+  end
+
+  protected
+
+  def validate_cpf_uniqueness?
+    true
+  end
+
+  def cpf_is_not_zeros?
+    cpf != '000.000.000-00'
+  end
+end

data/app/models/persona/legal_nature.rb

@@ -0,0 +1,21 @@
+class Persona::LegalNature < Persona::Model
+  extend EnumerateIt
+
+  self.abstract_class = true
+
+  has_enumeration_for :level_of_nature, with: LegalNatureLevel
+
+  acts_as_nested_set
+
+  validates :name, :code, presence: true
+
+  # TODO
+  # https://github.com/collectiveidea/awesome_nested_set/issues/217
+  def self.quoted_table_name
+    '"unico_legal_natures"'
+  end
+
+  def to_s
+    name
+  end
+end

data/app/models/persona/partner.rb

@@ -0,0 +1,13 @@
+class Persona::Partner < Persona::Model
+  self.abstract_class = true
+
+  belongs_to :company, class_name: '::Company', inverse_of: :partners
+  belongs_to :person, class_name: '::Person'
+
+  validates :person, :percentage, presence: true
+  validates :percentage, numericality: { greater_than: 0, less_than_or_equal_to: 100 }, allow_blank: true
+
+  def to_s
+    person.to_s
+  end
+end

data/app/models/persona/person.rb

@@ -0,0 +1,57 @@
+class Persona::Person < Persona::Model
+  extend EnumerateIt
+
+  self.abstract_class = true
+
+  has_enumeration_for :personable_type, create_helpers: true, create_scopes: true
+
+  has_paper_trail
+
+  belongs_to :personable, polymorphic: true, autosave: true
+
+  has_one :address, -> { where(correspondence: false) }, as: :addressable, class_name: '::Address', dependent: :destroy
+  has_one :correspondence_address, -> { where(correspondence: true) }, as: :addressable, class_name: '::Address', dependent: :destroy
+
+  accepts_nested_attributes_for :address, reject_if: :all_blank
+  accepts_nested_attributes_for :correspondence_address, reject_if: :all_blank
+
+  before_save :set_cpf_cnpj
+  before_save :normalize_name!
+
+  validates :name, :personable, presence: true
+  validates :personable, associated: true, allow_blank: true
+  validates :email, mail: true, allow_blank: true
+  validates :phone, :fax, mask: '(99) 9999-9999', allow_blank: true
+  validates :mobile, mask: '(99) 99999-9999', allow_blank: true
+
+  def cpf
+    personable.cpf if personable.respond_to?(:cpf)
+  end
+
+  def cnpj
+    personable.cnpj if personable.respond_to?(:cnpj)
+  end
+
+  def state_registration
+    personable.state_registration if personable.respond_to?(:state_registration)
+  end
+
+  def responsible
+    personable.responsible if personable.respond_to?(:responsible)
+  end
+
+  def to_s
+    name
+  end
+
+  private
+
+  def set_cpf_cnpj
+    self.cpf_cnpj = personable.respond_to?(:cpf) ? cpf : cnpj
+  end
+
+  def normalize_name!
+    return unless name
+    self.normalized_name = I18n.transliterate(name).downcase
+  end
+end

data/app/models/prefecture.rb

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

data/app/models/reference_unit.rb

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

data/app/models/registration_cadastral_certificate.rb

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

data/app/models/regularization_or_administrative_sanction.rb

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

data/app/models/regularization_or_administrative_sanction_reason.rb

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

data/app/models/regulatory_act.rb

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

data/app/models/risk_degree.rb

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