unico-training 7.8.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: af0edd9a1ff714b066b5fdcb118e9adf8b50598480fda78831f01111e958a0f2
+  data.tar.gz: 0739758bd006366d4c5963361976770efe3b74b1722d7663b4e93e2f083dcb0f
+SHA512:
+  metadata.gz: 4699833b5b43a75f5e1489c896bf5e7ff71071cba2a3667b75b17599bb18bd6ece0130eaa9a0f62483f0d19e0c2bd76424b0e5939788a85408904b6bd33a4157
+  data.tar.gz: d48ed1e15024a7644af6bb86119f11b82d25010dfff04b39be2b0186ceda3db920c9734cfb55dfda5f1e6108fbd0eeadb0ab7d6c2aa636552ec5c375391bb5d5

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+*.rvmrc
+.bundle
+.config
+.yardoc
+.ruby-version
+Gemfile.lock
+InstalledFiles
+_yardoc
+bin/
+config/database.yml
+coverage
+doc/
+lib/bundler/man
+log
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1 @@
+--colour

data/.rubocop.yml

@@ -0,0 +1,13 @@
+Metrics/BlockLength:
+  Exclude:
+    - '*.gemspec'
+    - 'spec/**/*'
+
+Metrics/LineLength:
+  Enabled: false
+
+Style/AsciiComments:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 nohup brasil
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,35 @@
+# Unico [![Build Status](https://semaphoreapp.com/api/v1/projects/18c36e3b-5184-40ee-baa9-855266c4572b/176779/badge.png)](https://semaphoreapp.com/integragrp/unico)
+
+Common resources for nobe projects like countries, states, cities, people, etc.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'unico'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install unico
+
+## Usage
+
+If you need to add an association and a validation on person model, you could do that:
+
+    class Person < Unico::Person
+      has_many :payments, :dependent => :restrict_with_exception
+
+      validates :birthdate, :presence => true
+    end
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,43 @@
+require 'bundler/gem_tasks'
+
+task :environment do
+  ENV['RAILS_ENV'] ||= 'test'
+
+  # foreigner only works with a rails application due to load implementation
+  require 'rails'
+  require 'unico'
+  require 'inscriptio_cursualis'
+  require 'active_model'
+  require 'mask_validator'
+  require 'action_controller/railtie'
+  require 'active_record/railtie'
+  require 'foreigner'
+
+  module Unico
+    class Application < Rails::Application
+      config.active_support.deprecation = :stderr
+    end
+  end
+
+  Unico::Application.initialize!
+end
+
+namespace :db do
+  task create: :environment do
+    config = ActiveRecord::Base.connection_config
+    encoding = config[:encoding] || ENV['CHARSET'] || 'utf8'
+
+    begin
+      ActiveRecord::Base.establish_connection(config.merge(database: 'postgres', schema_search_path: 'public'))
+      ActiveRecord::Base.connection.create_database(config[:database], config.merge(encoding: encoding))
+      ActiveRecord::Base.establish_connection(config)
+    rescue Exception => e
+      $stderr.puts e, *e.backtrace
+      $stderr.puts "Couldn't create database for #{config.inspect}"
+    end
+  end
+
+  task migrate: :environment do
+    ActiveRecord::Migrator.migrate(Unico::Application.paths['db/migrate'].existent)
+  end
+end

data/app/business/material_code_generator.rb

@@ -0,0 +1,43 @@
+class MaterialCodeGenerator
+  attr_accessor :material_object, :material_repository
+
+  delegate :material_class_id_changed?, :material_class_id?, :material_class, to: :material_object
+
+  def initialize(material_object, material_repository = Material)
+    self.material_object = material_object
+    self.material_repository = material_repository
+  end
+
+  def generate!
+    return unless materials_code_can_changed?
+
+    material_object.code = material_code
+  end
+
+  protected
+
+  def material_code
+    [material_class.masked_number, next_code].join('.')
+  end
+
+  def next_code
+    code = previous_material_code
+  end
+
+  def previous_material_code
+    return 1 if previous_material.blank?
+
+    previous_material.code.gsub("#{material_class.masked_number}.", '').to_i + 1
+  end
+
+  def previous_material
+    @previous_material ||= material_repository
+                           .by_material_class_id(material_class.id)
+                           .reorder(:code)
+                           .last
+  end
+
+  def materials_code_can_changed?
+    material_class_id_changed? && material_class_id?
+  end
+end

data/app/business/similarity_control_adjuster.rb

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

data/app/business/similarity_control_checker.rb

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

data/app/business/unico/similarity_control_adjuster.rb

@@ -0,0 +1,129 @@
+class Unico::SimilarityControlAdjuster
+  def initialize(similarity_control, options = {})
+    @similarity_control = similarity_control
+
+    @connection = options.delete(:connection) { ActiveRecord::Base.connection }
+    @similarity_control_table_repository = options.delete(:similarity_control_table_repository) { ::SimilarityControlTable }
+  end
+
+  def self.inactivate!(*attr)
+    new(*attr).inactivate!
+  end
+
+  def inactivate!
+    return unless similarity_control.can_edit?
+
+    similarity_control.transaction do
+      iterate_items do |item|
+        update_record(item.field_id, item.agglutinate?)
+      end
+
+      destiny_tables.each do |table_name|
+        record = similarity_control_table_repository.new
+        record.similarity_control = similarity_control
+        record.table_name = table_name
+        record.save!
+
+        fix_table!(record)
+      end
+    end
+  end
+
+  protected
+
+  attr_reader :similarity_control, :connection, :similarity_control_table_repository
+
+  def iterate_items
+    similarity_control.similarity_control_items.group_by(&:code).each do |_, items|
+      principal = items.detect(&:principal?)
+
+      next if principal.blank?
+
+      items.each do |item|
+        next if item.principal?
+
+        yield(item, principal)
+      end
+    end
+  end
+
+  def update_record(item_id, agglutinate)
+    sql = <<-SQL
+      UPDATE #{similarity_control.table_name} SET inactive = #{agglutinate}
+      WHERE id = #{item_id}
+    SQL
+
+    connection.execute(sql)
+
+    extra_updates_for_person_record(item_id, agglutinate) if similarity_control.table_name == 'unico_people'
+  end
+
+  def extra_updates_for_person_record(item_id, agglutinate)
+    if agglutinate
+      person_to_update = ::Person.find(item_id)
+
+      if person_to_update.individual?
+        person_to_update.update_column(:cpf_cnpj, '000.000.000-00')
+        person_to_update.personable.update_column(:cpf, '000.000.000-00')
+      else
+        person_to_update.update_column(:cpf_cnpj, '00.000.000/0000-00')
+        person_to_update.personable.update_column(:cnpj, '00.000.000/0000-00')
+      end
+    end
+  end
+
+  # Tabelas que possuem referência
+  def destiny_tables
+    tables = []
+
+    return [] if similarity_control.similarity_control_tables.any?
+
+    connection.tables.sort.each do |table_name|
+      columns = connection.columns(table_name).map(&:name)
+
+      if columns.include?(similarity_control.reference_column)
+        tables << table_name
+      end
+    end
+
+    tables
+  end
+
+  def fix_table!(similarity_control_table)
+    return if similarity_control_table.fixed?
+
+    iterate_items do |item, principal|
+      next unless item.agglutinate?
+
+      next if duplicated_record?(similarity_control_table, principal)
+
+      sql = <<-SQL
+        UPDATE #{similarity_control_table.table_name}
+        SET #{similarity_control.reference_column} = #{principal.field_id}
+        WHERE #{similarity_control.reference_column} = #{item.field_id}
+      SQL
+
+      connection.execute(sql)
+    end
+
+    similarity_control_table.update_column(:fixed, true)
+  end
+
+  # Tabelas com restrição de duplicidade
+  def duplicated_record?(record, principal)
+    tables = %w(unico_neighborhoods_unico_streets)
+
+    if tables.include? record.table_name
+      check_sql = <<-SQL
+        SELECT * FROM #{record.table_name}
+        WHERE #{similarity_control.reference_column} = #{principal.field_id}
+      SQL
+
+      check = connection.execute(check_sql)
+
+      check.count > 0
+    else
+      false
+    end
+  end
+end

data/app/business/unico/similarity_control_checker.rb

@@ -0,0 +1,96 @@
+class Unico::SimilarityControlChecker
+  def initialize(similarity_control, options = {})
+    @similarity_control = similarity_control
+    @column = similarity_control.column_name
+    @scope_column1 = similarity_control.scope_column1
+    @scope_column2 = similarity_control.scope_column2
+    @table = similarity_control.table_name
+    @search = similarity_control.search
+
+    @similarity_control_item_repository = options.delete(:similarity_control_item_repository) { ::SimilarityControlItem }
+    @connection = options.delete(:connection) { ActiveRecord::Base.connection }
+  end
+
+  def self.do!(*attr)
+    new(*attr).do!
+  end
+
+  def do!
+    code = nil
+
+    query.each_with_index do |result, index|
+      id1 = result['id1'].to_i
+      id2 = result['id2'].to_i
+
+      code = get_code(result, index, code)
+
+      check_and_create_item(id1, result['field1'], result['scope_x1'], result['scope_x2'], code)
+      check_and_create_item(id2, result['field2'], result['scope_y1'], result['scope_y2'], code)
+    end
+  end
+
+  protected
+
+  attr_reader :similarity_control, :column, :scope_column1, :scope_column2, :table,
+    :similarity_control_item_repository, :connection, :search
+
+  def item(id)
+    similarity_control_item_repository.find_by(similarity_control: similarity_control, field_id: id)
+  end
+
+  # Evitar criar duplicações
+  def check_and_create_item(id, description, scope_value1, scope_value2, code)
+    return if item(id).present?
+
+    record = similarity_control_item_repository.new
+    record.similarity_control = similarity_control
+    record.code = code
+    record.field_id = id
+    record.field_description = description
+    record.scope_value1 = scope_value1
+    record.scope_value2 = scope_value2
+    record.save!
+  end
+
+  # Faz com que as similaridades tenham o mesmo 'code'
+  def get_code(result, index, code)
+    return code if code == result['id2']
+
+    record = item(result['id1'])
+    return record.code if record
+
+    record = item(result['id2'])
+    return record.code if record
+
+    code = result['id1']
+
+    code = result['id2'] if query[index + 1] && result['id2'] == query[index + 1]['id2']
+
+    code
+  rescue IndexError
+    code
+  end
+
+  def query
+    @query ||= connection.execute(sql)
+  end
+
+  def sql
+    scope1 = scope_column1.present? ? "x.#{scope_column1} = y.#{scope_column1} and " : ''
+    scope2 = scope_column2.present? ? "x.#{scope_column2} = y.#{scope_column2} and " : ''
+    scope_select1 = scope_column1.present? ? ", x.#{scope_column1} as scope_x1, y.#{scope_column1} as scope_y1" : ''
+    scope_select2 = scope_column2.present? ? ", x.#{scope_column2} as scope_x2, y.#{scope_column2} as scope_y2" : ''
+    filter = search.present? ? " and (x.#{column} like '%#{search}%' or y.#{column} like '%#{search}%')" : ''
+
+    @sql ||= <<-SQL
+      select x.id as id1, x.#{column} as field1, y.id as id2, y.#{column} as field2
+      #{scope_select1} #{scope_select2}
+      from #{table} x, #{table} y
+      where #{scope1} #{scope2} x.id != y.id
+      and x.inactive = false and y.inactive = false
+      and similarity(x.#{column}, y.#{column}) >= #{similarity_control.similarity_percent} #{filter}
+      order by id1 desc, field1 desc, id2 desc, field2 desc
+      limit 100;
+    SQL
+  end
+end

data/app/controllers/agencies_controller.rb

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

data/app/controllers/bank_accounts_controller.rb

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