unico-training 7.8.0

data/db/migrate/20170727174947_add_occupation_base_group_to_occupation_classifications.rb

@@ -0,0 +1,6 @@
+class AddOccupationBaseGroupToOccupationClassifications < ActiveRecord::Migration
+  def change
+    add_column :unico_occupation_classifications, :occupation_base_group_id, :integer
+    add_index :unico_occupation_classifications, :occupation_base_group_id, name: :idx_occupation_classifications_on_occupation_base_group_id
+  end
+end

data/db/migrate/20170728135645_add_type_to_unico_occupation_classifications.rb

@@ -0,0 +1,5 @@
+class AddTypeToUnicoOccupationClassifications < ActiveRecord::Migration
+  def change
+    add_column :unico_occupation_classifications, :cbo_type, :string
+  end
+end

data/db/migrate/20170728135646_drop_constraint_on_unico_occupation_classifications.rb

@@ -0,0 +1,5 @@
+class DropConstraintOnUnicoOccupationClassifications < ActiveRecord::Migration
+  def change
+    remove_index :unico_occupation_classifications, :code
+  end
+end

data/db/migrate/20170728135647_remove_lft_rgt_from_occupation_classifications.rb

@@ -0,0 +1,13 @@
+class RemoveLftRgtFromOccupationClassifications < ActiveRecord::Migration
+  def up
+    remove_column :unico_occupation_classifications, :lft
+    remove_column :unico_occupation_classifications, :rgt
+    remove_column :unico_occupation_classifications, :parent_id
+  end
+
+  def down
+    add_column :unico_occupation_classifications, :lft, :integer
+    add_column :unico_occupation_classifications, :rgt, :integer
+    add_column :unico_occupation_classifications, :parent_id, :integer
+  end
+end

data/lib/active_record/block.rb

@@ -0,0 +1,44 @@
+module ActiveRecord
+  module Block
+    # Block destroy and update just overwriting destroyable? and updateable?
+    # methods
+    #
+    def self.included(base)
+      base.extend(ClassMethods)
+
+      base.load_cant_be_updated_validate
+      base.load_cant_be_destroyed_callback
+    end
+
+    module ClassMethods
+      def load_cant_be_updated_validate
+        validate do
+          if persisted? && !updateable?
+            attribute_names.each do |attr|
+              errors.add(attr, :cant_be_updated) if send("#{attr}_changed?")
+            end
+          end
+        end
+      end
+
+      def load_cant_be_destroyed_callback
+        before_destroy :cant_be_destroyed, if: -> { !destroyable? }
+      end
+    end
+
+    def destroyable?
+      true
+    end
+
+    def updateable?
+      true
+    end
+
+    private
+
+    def cant_be_destroyed
+      errors.add(:base, :cant_be_destroyed)
+      false
+    end
+  end
+end

data/lib/active_record/filter.rb

@@ -0,0 +1,63 @@
+module ActiveRecord
+  module Filter
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def filterize(attributes = modal_attributes_with_options, options = {})
+        if attributes.is_a?(Hash)
+          options = attributes
+          attributes = accessible_attributes
+        end
+
+        attributes = Array(attributes)
+
+        class_eval(<<-eoruby, __FILE__, __LINE__ + 1)
+          def self.filter(params)
+            Filters::Filter.new(self, #{attributes}, #{options}).call(params)
+          end
+        eoruby
+      end
+
+      def orderize(*attributes)
+        options = attributes.extract_options!
+
+        if options.any?
+          include_table = options.fetch(:on)
+          table_name = include_table.to_s.classify.constantize.table_name
+          attributes = "#{table_name}.#{attributes.first}" if include_table.present?
+        else
+          attributes = [:name] if attributes.empty?
+
+          attributes.map! do |attribute|
+            # Converte symbols para Arel::Nodes::Ordering
+            attribute = arel_table[attribute].asc if attribute.is_a?(Symbol)
+
+            if attribute.is_a?(Arel::Attributes::Attribute)
+              attribute = attribute.asc
+            end
+
+            if attribute.class < Arel::Nodes::Ordering
+              # Converte Arel::Nodes::Ordering para string com prefixo
+              # da tabela e quoted
+              arel_table.engine.connection.visitor.accept attribute
+            else
+              attribute
+            end
+          end
+
+          attributes = attributes.join(', ')
+        end
+
+        class_eval(<<-eoruby, __FILE__, __LINE__ + 1)
+          def self.ordered
+            query = order('#{attributes}')
+
+            #{"query = query.joins(:#{include_table})" if include_table.present?}
+
+            query
+          end
+        eoruby
+      end
+    end
+  end
+end

data/lib/active_record/filters/base.rb

@@ -0,0 +1,38 @@
+module ActiveRecord
+  module Filters
+    module Base
+      def scoped
+        @scoped ||= if association
+                      klass.joins(association.name)
+                    else
+                      klass.all
+        end
+      end
+
+      def association
+        @association ||= klass.reflect_on_association(options[:using]) if association?
+      end
+
+      def association?
+        options.key?(:using)
+      end
+
+      def find_column(klass, name)
+        column_name = name.is_a?(Hash) ? name.keys.first : name
+
+        table_column = klass.arel_table.engine.columns.detect { |column| column.name.to_sym == column_name.to_sym }
+
+        column_struct(table_column, name) if table_column
+      end
+
+      def column_struct(column, name)
+        type     = name.is_a?(Hash) ? name.values.first : column.type
+        relation = column.try :relation
+
+        OpenStruct.new(relation: relation,
+                       name: column.name,
+                       type: type)
+      end
+    end
+  end
+end

data/lib/active_record/filters/filter.rb

@@ -0,0 +1,65 @@
+module ActiveRecord
+  module Filters
+    class Filter
+      include ActiveRecord::Filters::Base
+
+      attr_accessor :klass
+      attr_accessor :attributes
+      attr_accessor :options
+
+      def initialize(klass, attributes, options)
+        self.klass      = klass
+        self.attributes = attributes
+        self.options    = options
+      end
+
+      def call(params)
+        relation = scoped
+
+        columns.inject(relation) do |relation, column|
+          # TODO: have a better way to compare this?
+          param = if association? && relation.arel_table != column.relation
+                    key = "#{association.name}_attributes"
+                    params[key][column.name] if params[key]
+                  else
+                    params[column.name]
+          end
+
+          next relation if param.blank?
+
+          column_name = klass.arel_table[column.name]
+
+          case column.type
+          when :string
+            relation.where(column_name.matches("#{param}%"))
+          when :decimal, :float, :integer
+            relation.where(column_name.eq(I18n::Alchemy::NumericParser.parse(param)))
+          when :time
+            # TODO: why arel uses arel/attributes/time for date columns?
+            relation.where(column_name.eq(I18n::Alchemy::DateParser.parse(param)))
+          else
+            relation.where(column_name.eq(param))
+          end
+        end
+      end
+
+      protected
+
+      def columns
+        @columns ||= begin
+          columns = attributes.map do |attribute|
+            find_column(klass, attribute)
+          end
+
+          if association
+            columns += association.klass.accessible_attributes.map do |attribute|
+              find_column(association.klass, attribute)
+            end
+          end
+
+          columns.compact
+        end
+      end
+    end
+  end
+end

data/lib/active_record/modal.rb

@@ -0,0 +1,42 @@
+module ActiveRecord
+  module Modal
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_modal_attributes
+    end
+
+    module ClassMethods
+      def attr_modal(*attributes)
+        self._modal_attributes = Set.new(attrs_map(*attributes)) + (_modal_attributes || [])
+      end
+
+      def modal_attributes
+        modal_attributes_with_options.map { |attr| attr.is_a?(Hash) ? attr.keys.first : attr }
+      end
+
+      def modal_attributes_with_options
+        _modal_attributes || allowed_modal_attributes
+      end
+
+      private
+
+      def attrs_map(*attributes)
+        options    = attributes.extract_options!
+        attributes = attributes.map(&:to_s)
+
+        options.stringify_keys!
+
+        attributes.tap { |attr| attr.push options if options.any? }
+      end
+
+      def allowed_modal_attributes
+        if respond_to?(:accessible_attributes)
+          accessible_attributes.to_set.reject do |a|
+            a.ends_with?('_attributes') || a.ends_with?('_ids')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/belongs_to_resource.rb

@@ -0,0 +1,111 @@
+# Atua como se fosse um belongs_to do active_record, mas ao invés de manter um
+# relacionamento com um model do active_record, mantem um relacionamento com um
+# model do active_resource.
+#
+# Ex:
+#
+# class BudgetStructure < ActiveResource::Base
+#   ...
+# end
+#
+# class Contract < ActiveRecord::Base
+#   include BelongsToResource
+#
+#   belongs_to_resource :budget_structure
+#   belongs_to_resource :budget_allocation
+#
+#   private
+#
+#   def budget_allocation_params
+#     { includes: :expense_nature, methods: :amount }
+#   end
+# end
+#
+# c = Contract.last
+#
+# c.budget_structure_id
+# => 3
+# c.buget_allocation.expense_nature.id
+# => 1
+# c.buget_allocation.amount
+# => 500.0
+#
+# c.budget_structure
+# => consulta faz find na API
+# => <#BudgetStructure teste>
+#
+# c.budget_structure = BudgetStucture.last
+# c.budget_structure
+# => não precisa fazer consulta na API e já atualiza o id
+# => <#BudgetStructure novo>
+#
+# c.budget_structure(false)
+# => não usa o cache, ou seja força o find na API
+# => <#BudgetStructure novo>
+#
+# c.budget_structure_id = 34
+# c.budget_structure
+# => vai fazer a consulta na API pra atualizar o cache, porque mudou o id
+# => <#BudgetStructure outro>
+module BelongsToResource
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def belongs_to_resource(resource_name, options = {})
+      resource_class = options.fetch(:resource_class) { resource_name.to_s.camelize.constantize }
+      resource_id    = options.fetch(:resource_id, "#{resource_name}_id")
+
+      create_reflection :belongs_to, resource_name, { foreign_key: resource_id }, self
+
+      send(:class_eval, <<-eoruby, __FILE__, __LINE__ + 1)
+        def #{resource_name}(use_cache = true)
+          return unless #{resource_id}
+
+          if use_cache
+            #{resource_name}_cached
+          else
+            #{resource_class}.find(#{resource_id}, params: #{resource_name}_params)
+          end
+        end
+
+        def #{resource_name}=(new_resource)
+          self.#{resource_id}         = new_resource.try(:id)
+          self.old_#{resource_id}     = #{resource_id}
+          self.#{resource_name}_cache = new_resource
+        end
+
+        def #{resource_id}=(new_id)
+          self.old_#{resource_id} = #{resource_id}
+
+          if self.class.superclass <= ActiveResource::Base
+            self.attributes[:#{resource_id}] = new_id
+          else
+            super
+          end
+        end
+
+        private
+
+        attr_accessor :old_#{resource_id}
+        attr_accessor :#{resource_name}_cache
+
+        def #{resource_name}_cached
+          if #{resource_id}
+            if old_#{resource_id} != #{resource_id}
+              self.#{resource_name}_cache = #{resource_class}.find(#{resource_id}, params: #{resource_name}_params)
+              self.old_#{resource_id} = #{resource_id}
+            end
+          else
+            self.#{resource_name}_cache = nil
+          end
+
+          #{resource_name}_cache
+        end
+
+        def #{resource_name}_params
+          {}
+        end
+      eoruby
+    end
+  end
+end

data/lib/custom_data.rb

@@ -0,0 +1,131 @@
+module Unico
+  module CustomData
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def reload_custom_data
+        return unless custom_data
+
+        custom_data.each do |data|
+          define_method(data.method_name) do
+            custom_data[data.method_name]
+          end
+
+          if data.select?
+            define_method("#{data.method_name}_humanize") do
+              data.humanized_option(custom_data[data.method_name])
+            end
+          end
+
+          define_method("#{data.method_name}=") do |value|
+            self.custom_data = custom_data.merge(data.method_name => value)
+          end
+
+          next unless data.modal?
+          define_method(data.normalized_data) do
+            if send(data.method_name).present?
+              data.modal_entity.classify.constantize.send(:find, send(data.method_name))
+            end
+          end
+        end
+      end
+
+      def custom_attributes
+        return unless custom_data
+
+        custom_data.map(&:method_name)
+      end
+
+      def custom_data
+        class_name = name.underscore
+        current_state = ::Prefecture.last.state_acronym
+
+        Customization.new(current_state, class_name).data
+      rescue
+        {}
+      end
+    end
+
+    def custom_data
+      attributes['custom_data'] || {}
+    end
+
+    def validate_custom_data
+      self.class.reload_custom_data
+      presence_validator
+      dependency_validator
+    end
+
+    private
+
+    delegate :normalized_data, to: :customization_data, allow_nil: true
+
+    def presence_validator
+      return unless self.class.custom_data
+
+      self.class.custom_data.each do |item|
+        date_validator(item)
+
+        next unless item.required && dependency_requirement_fulfilled?(item)
+        string_presence_validator(item)
+        numeric_presence_validator(item)
+        date_presence_validator(item)
+      end
+    end
+
+    def dependency_validator
+      self.class.custom_data.each do |item|
+        next unless item.dependency_name.present?
+
+        if send(item.method_name).present? && !dependency_requirement_fulfilled?(item)
+          errors.add(item.method_name.to_sym, :should_be_blank)
+        end
+      end
+    end
+
+    def dependency_requirement_fulfilled?(item)
+      return true if item.dependency_name.nil?
+
+      if item.dependency_value.present?
+        send(item.dependency_name) == item.dependency_value
+      else
+        send(item.dependency_name).present?
+      end
+    end
+
+    def string_presence_validator(item)
+      return unless item.string? || item.text? || item.select? || item.modal?
+
+      if custom_data[item.method_name].nil? || custom_data[item.method_name].empty?
+        errors.add(item.normalized_data.to_sym, :blank)
+      end
+    end
+
+    def numeric_presence_validator(item)
+      return unless item.decimal? || item.integer?
+
+      if BigDecimal(custom_data[item.normalized_data] || '0') == BigDecimal('0')
+        errors.add(item.normalized_data.to_sym, :blank)
+      end
+    end
+
+    def date_presence_validator(item)
+      return unless item.date?
+
+      if custom_data[item.normalized_data].empty?
+        errors.add(item.normalized_data.to_sym, :blank)
+      end
+    end
+
+    def date_validator(item)
+      return unless item.date?
+      return if custom_data.blank?
+
+      begin
+        custom_data[item.normalized_data].to_date
+      rescue ArgumentError
+        errors.add(item.normalized_data.to_sym, :invalid)
+      end
+    end
+  end
+end