demographic 0.8.6.RKM.89602.beta.0

data/app/services/demographic/optionals/create.rb

@@ -0,0 +1,90 @@
+module Demographic
+  module Optionals
+    class Create
+      attr_accessor :adjustable, :data, :optional
+
+      def initialize(adjustable:, data:)
+        @adjustable = adjustable
+        @data = data
+        @optional = Optional.new
+      end
+
+      def call
+        ActiveRecord::Base.transaction do
+          validation_optional
+          add_adjustable
+          create_optional
+          create_values_list
+        end
+
+        optional
+      end
+
+      private
+
+      def validation_optional
+        unless data[:input_type].present?
+          optional.errors.add(:input_type, 'input_type is empty')
+          raise ActiveRecord::RecordInvalid, optional
+        end
+
+        if !data[:name_translate].present? || !data[:name_translate].values.any? { |v| v.present? }
+          optional.errors.add(:name_translate, 'name_translate is empty')
+          raise ActiveRecord::RecordInvalid, optional
+        end
+
+        if data[:input_type] == 'list' && !any_valid?
+          optional.errors.add(:values, 'values is empty')
+          raise ActiveRecord::RecordInvalid, optional
+        end
+      end
+
+      def create_optional
+        optional.adjustable_id = adjustable.id
+        optional.adjustable_type = adjustable.class.name
+        optional.name = name
+        optional.code = code
+        optional.token = Demographic.generate_token
+        optional.input_type = data[:input_type]
+        optional.min_value = data[:min_value]
+        optional.max_value = data[:max_value]
+        optional.name_translate = data[:name_translate]
+        optional.order = data[:order_num] || 1
+        optional.save!
+      end
+
+      def add_adjustable
+        return unless optional.attributes.key?('enterprise_process_id')
+
+        optional.enterprise_process_id = adjustable.try(:enterprise_process_id).presence || adjustable.id
+      end
+
+      def create_values_list
+        ::Demographic::OptionalValues::CreateList.new(adjustable: adjustable,
+                                                      values: data[:values],
+                                                      optional: optional).call
+      end
+
+      def name
+        return data[:name_translate]['es'] if data[:name_translate]['es'].present?
+
+        data[:name_translate].values.detect { |v| v.present? }
+      end
+
+      def any_valid?
+        return false if data[:values].blank?
+        data[:values].any? { |value| value[:is_valid].to_d == 1 }
+      end
+
+      private
+
+      def code
+        if data[:code].is_a?(String) && data[:code].parameterize.str_slug.present?
+          data[:code].parameterize.str_slug
+        else
+          name.parameterize.str_slug
+        end
+      end
+    end
+  end
+end

data/app/services/demographic/optionals/list.rb

@@ -0,0 +1,51 @@
+module Demographic
+  module Optionals
+    class List
+      attr_accessor :adjustable, :page, :term, :per_page
+
+      def initialize(adjustable:, page:, term:, per_page:)
+        @adjustable = adjustable
+        @page = page || 1
+        @term = term.try(:downcase)
+        @per_page = per_page || 20
+      end
+
+      def to_json
+        search(is_json: true)
+      rescue ActiveRecord::StatementInvalid
+        search(is_json: false)
+      end
+
+      private
+
+      def search(is_json:)
+        optionals = adjustable ? adjustable.optionals : Optional
+        optionals = search_term(optionals, is_json)
+        optionals = optionals.page(page).per(per_page)
+        struct_json(optionals)
+      end
+
+      def search_term(optionals, is_json = true)
+        return optionals unless term.present?
+        return optionals.where("name LIKE ?", "%#{term}%") unless is_json
+
+        optionals.where("LOWER(name_translate->>'#{I18n.locale.to_s}') ILIKE LOWER(?) OR name ILIKE LOWER(?)", "%#{term}%", "%#{term}%")
+      end
+
+      def struct_json(optionals)
+        {
+          limit_value: optionals.limit_value,
+          current_page: optionals.current_page,
+          total_pages: optionals.total_pages,
+          total_objects: optionals.total_count,
+          optionals: serializer(optionals)
+        }
+      end
+
+      def serializer(optionals)
+        ActiveModelSerializers::SerializableResource.new(optionals,
+                                                         each_serializer: ::Demographic::Optionals::ListSerializer)
+      end
+    end
+  end
+end

data/app/services/demographic/optionals/optional_values.rb

@@ -0,0 +1,52 @@
+module Demographic
+  module Optionals
+    class OptionalValues
+      attr_accessor :adjustable, :optional, :page, :term, :per_page
+
+      def initialize(adjustable:, optional:, page:, term:, per_page:)
+        @adjustable = adjustable
+        @optional = optional
+        @page = page || 1
+        @term = term.try(:downcase)
+        @per_page = per_page || 20
+      end
+
+      def call
+        search(is_json: true)
+      rescue ActiveRecord::StatementInvalid
+        search(is_json: false)
+      end
+
+      private
+
+      def search(is_json:)
+        values = optional.optional_values
+        values = search_term(values, is_json)
+        values = values.page(page).per(per_page)
+        struct_json(values)
+      end
+
+      def search_term(values, is_json = true)
+        return values unless term.present?
+        return values.where("value LIKE ?", "%#{term}%") unless is_json
+
+        values.where("LOWER(value) ILIKE LOWER(?)", "%#{term}%")
+      end
+
+      def struct_json(values)
+        {
+          limit_value: values.limit_value,
+          current_page: values.current_page,
+          total_pages: values.total_pages,
+          total_objects: values.total_count,
+          values: serializer(values)
+        }
+      end
+
+      def serializer(values)
+        ActiveModelSerializers::SerializableResource.new(values,
+                                                         each_serializer: ::Demographic::Optionals::ValueSerializer)
+      end
+    end
+  end
+end

data/app/services/demographic/optionals/update.rb

@@ -0,0 +1,100 @@
+module Demographic
+  module Optionals
+    class Update
+
+      attr_accessor :optional, :data, :adjustable
+
+      def initialize(adjustable:, optional:, data:)
+        @data = data
+        @optional = optional
+        @adjustable = adjustable
+      end
+
+      def call
+        ActiveRecord::Base.transaction do
+          validation_optional
+          validation_type
+          update_optional
+          update_values_list
+        end
+
+        optional
+      end
+
+      private
+
+      def validation_optional
+        unless data[:input_type].present?
+          optional.errors.add(:input_type, 'input_type is empty')
+          raise ActiveRecord::RecordInvalid.new(optional)
+        end
+
+        if !data[:name_translate].present? || !data[:name_translate].values.any?{ |v| v.present? }
+          optional.errors.add(:name_translate, 'name_translate is empty')
+          raise ActiveRecord::RecordInvalid.new(optional)
+        end
+
+        if data[:input_type] == 'list' && !any_valid?
+          optional.errors.add(:values, 'values is empty')
+          raise ActiveRecord::RecordInvalid, optional
+        end
+      end
+
+      def validation_type
+        if Demographic.simple_inputs.include?(optional.input_type)
+          unless Demographic.simple_inputs.include?(data[:input_type])
+            optional.errors.add(:input_type, 'input_type error, must be simple_input')
+            raise ActiveRecord::RecordInvalid.new(optional)
+          end
+        end
+
+        if Demographic.multiples_inputs.include?(optional.input_type)
+          unless Demographic.multiples_inputs.include?(data[:input_type])
+            optional.errors.add(:input_type, 'input_type error, must be multiple_input')
+            raise ActiveRecord::RecordInvalid.new(optional)
+          end
+        end
+      end
+
+      def update_optional
+        optional.name = name
+        optional.code = code
+        optional.input_type = data[:input_type]
+        optional.min_value = data[:min_value]
+        optional.max_value = data[:max_value]
+        optional.name_translate = data[:name_translate]
+        optional.order = data[:order_num] || 1
+        optional.save!
+      end
+
+
+      def update_values_list
+        Demographic::OptionalValues::UpdateList.new(adjustable: adjustable,
+                                                    values: data[:values],
+                                                    optional: optional).call
+      end
+
+      def name
+        return data[:name_translate]['es'] if data[:name_translate]['es'].present?
+
+        data[:name_translate].values.detect{|v| v.present? }
+      end
+
+      def any_valid?
+        return false if data[:values].blank?
+        data[:values].any? { |value| value[:is_valid].to_d == 1 }
+      end
+
+      private
+
+      def code
+        if data[:code].is_a?(String)
+          data[:code].parameterize.str_slug
+        else
+          name.parameterize.str_slug
+        end
+      end
+    end
+  end
+end
+

data/app/services/demographic/parse/data_serializer.rb

@@ -0,0 +1,87 @@
+module Demographic
+  module Parse
+    class DataSerializer
+      attr_reader :users_data, :adjustable, :optionals_by_code, :initialize_error, :user_ids_by_token
+
+      KEY_REGEX = /^optional_/
+
+      def initialize(users_data:, parent_module:, reference_id:)
+        @users_data = users_data
+        @adjustable = find_adjustable(parent_module, reference_id)
+        @optionals_by_code ||= @adjustable.optionals.all.index_by(&:code)
+        @user_ids_by_token = build_user_ids_by_token(@users_data)
+      rescue => e
+        @initialize_error = e
+      end
+
+      def call
+        return response_instance(success: false, message: initialize_error, data: []) if initialize_error.present?
+
+        data = users_data.reduce([]) do |formatted_optional_values, user_data|
+          next formatted_optional_values if user_data['token'].blank?
+          next formatted_optional_values if user_ids_by_token[user_data['token']].blank?
+
+          optionals = user_data.select { |key, _value| KEY_REGEX.match?(key) }
+
+          next formatted_optional_values if optionals.blank?
+
+          formatted_optional_values + get_optionals_values(optionals, user_data['token'])
+        end
+
+        response_instance(success: true, message: '', data: data)
+      rescue => error
+        response_instance(success: false, message: error, data: [])
+      end
+
+      private
+
+      def find_adjustable(parent_module, reference_id)
+        parent_model(parent_module).to_s.capitalize.classify.constantize.find_by!(id: reference_id)
+      end
+
+      def parent_model(parent_module)
+        parent = Demographic.parent_model[parent_module.to_sym]
+        raise 'init Demographic parent_model error param :module!!!' unless parent.present?
+
+        parent
+      end
+
+      def get_optionals_values(optionals, user_token)
+        optionals.reduce([]) do |optional_values, (key, value)|
+          optional_code = key.to_s.gsub('optional_', '')
+          optional = optionals_by_code[optional_code]
+
+          next optional_values unless optional.present?
+
+          format_value = ::Demographic::Parse::Types::Values.new(optional: optional,
+                                                                 value: value,
+                                                                 user_id: user_ids_by_token[user_token]).call
+          next optional_values unless format_value.is_valid?
+
+          optional_values << format_value.value
+        end
+      end
+
+      def response_instance(success:, message:, data:)
+        Struct.new(:success, :message, :data)
+              .new(success, message, data)
+      end
+
+      def build_user_ids_by_token(users_data)
+        user_ids = {}
+        users_data.each_slice(1000).map do |users_data_slice|
+          users_tokens = users_data_slice.map { |user_data| user_data['token'] }.compact.uniq
+
+          user_ids.merge!(get_user_ids_by_token(users_tokens))
+        end
+
+        user_ids
+      end
+
+      def get_user_ids_by_token(users_tokens)
+        return adjustable.users.where(token: users_tokens).pluck(:token, :id).to_h if adjustable.respond_to?(:users)
+        User.where(token: users_tokens).pluck(:token, :id).to_h
+      end
+    end
+  end
+end

data/app/services/demographic/parse/types/values.rb

@@ -0,0 +1,99 @@
+module Demographic
+  module Parse
+    module Types
+      class Values
+        attr_reader :optional, :value, :user_id
+
+        STRUCT = Struct.new(:is_valid?, :value)
+        DATE_FORMATS = %w[%d-%m-%Y %d/%m/%Y %Y-%m-%d %Y/%m/%d]
+        BOOL_HASH = { '0' => 'false', '1' => 'true' }
+
+        def initialize(optional:, value:, user_id:)
+          @optional = optional
+          @value = value
+          @user_id = user_id
+        end
+
+        def call
+          build_value
+        end
+
+        private
+
+        def build_value
+          return struct_instance unless struct_instance.is_valid?
+
+          parse_value
+        end
+
+        def struct_instance
+          @struct_instance ||= build_struct
+        end
+
+        def build_struct
+          return STRUCT.new(false, value.to_s) unless value.to_s.present?
+
+          return build_text_or_list_struct if optional.input_type.eql?('list') || optional.input_type.eql?('text')
+
+          return build_number_struct if optional.input_type.eql?('number')
+
+          return build_date_struct if optional.input_type.eql?('date')
+
+          return build_bool_struct if optional.input_type.eql?('bool')
+
+          STRUCT.new(false, value.to_s)
+        end
+
+        def build_text_or_list_struct
+          STRUCT.new(true, value)
+        end
+
+        def build_number_struct
+          STRUCT.new(value.to_s.is_numeric?, value)
+        end
+
+        def build_date_struct
+          DATE_FORMATS.each do |date_format|
+            date = format_date(date_format)
+            return STRUCT.new(true, date) if date != false
+          end
+
+          STRUCT.new(false, value.to_s)
+        end
+
+        def format_date(date_format)
+          date = Date.strptime(value, date_format)
+          return false if date.year.to_s.length != 4
+          date.strftime
+        rescue StandardError => e
+          false
+        end
+
+        def build_bool_struct
+          bool = BOOL_HASH[value.to_i.to_s]
+
+          STRUCT.new(bool.present?, bool)
+        end
+
+        def parse_value
+          struct_value = struct_instance.value.to_s
+          slug = struct_value.str_slug
+          code = Demographic.generate_code(optional.id, slug)
+
+          parsed_value = {
+            user_id: user_id,
+            optional_id: optional.id,
+            token: Demographic.generate_token,
+            value: struct_value,
+            value_translate: { es: struct_value },
+            code: code,
+            slug: slug
+          }
+
+          struct_instance.value = parsed_value
+          struct_instance
+        end
+      end
+    end
+  end
+end

data/app/services/demographic/user_optionals/list.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Demographic
+  module UserOptionals
+    class List
+      attr_accessor :user, :adjustable
+
+      def initialize(user:, adjustable:)
+        @user = user
+        @adjustable = adjustable
+      end
+
+      def perform
+        { optionals: list_optionals }
+      end
+
+      private
+
+      def list_optionals
+        optionals = adjustable.optionals.includes(:optional_values)
+        optionals.map do |optional|
+          hash = {
+            id: optional.id,
+            code: optional.code,
+            token: optional.token,
+            name: optional.name_translate[I18n.locale.to_s] || optional.name,
+            input_type: optional.input_type,
+            selected_text: '',
+            values: []
+          }
+
+          hash[:selected_text] = selected_text(optional) if Demographic.simple_inputs.include?(optional.input_type)
+          hash[:values] = selected_values(optional) if Demographic.multiples_inputs.include?(optional.input_type)
+          hash
+        end
+      end
+
+      def selected_text(optional)
+        result = user_optionals[optional.id]
+        result&.optional_value&.value_translate&.dig(I18n.locale.to_s) || result&.value
+      end
+
+      def selected_values(optional)
+        optional.optional_values.map do |value|
+          {
+            id: value.id,
+            slug: value.slug,
+            code: value.code,
+            value: value.value_translate[I18n.locale.to_s],
+            selected: user_optionals[optional.id]&.optional_value_id == value.id
+          }
+        end
+      end
+
+      def user_optionals
+        @user_optionals ||= user.user_optionals.index_by(&:optional_id)
+      end
+    end
+  end
+end

data/app/services/import/templates/create_optionals.rb

@@ -0,0 +1,26 @@
+module Import
+  module Templates
+    class CreateOptionals
+      FILE_NAME = 'create_optionals_template.xlsx'
+      HEADERS = %w[name type module code].freeze
+
+      def call
+        xlsx_service.create_temp_file
+      end
+
+      private
+
+      def xlsx_service
+        @xlsx_service ||= Import::Templates::Xlsx.new(sheets: sheets, file_name: FILE_NAME)
+      end
+
+      def sheets
+        [{ name: 'optionals', headers: HEADERS, style_headers: { b: true, sz: 14, bg_color: "E2F0D9" }, rows: rows }]
+      end
+
+      def rows
+        [%w[Antigüedad list position antigüedad-001], %w[edad number master edad-001], ['fecha de ingreso', 'date', 'master', 'fecha-ingreso-001']]
+      end
+    end
+  end
+end

data/app/services/import/templates/xlsx.rb

@@ -0,0 +1,44 @@
+module Import
+  module Templates
+    class Xlsx
+      attr_reader :sheets, :xlsx, :workbook, :file_name
+
+      def initialize(sheets:, file_name:)
+        @sheets = sheets
+        @file_name = file_name
+        @xlsx = Axlsx::Package.new
+        @workbook = xlsx.workbook
+      end
+
+      def create_temp_file
+        add_worksheets
+
+        temp_file
+      end
+
+      private
+
+      def add_worksheets
+        sheets.each do |sheet_data|
+          workbook.add_worksheet(name: sheet_data[:name]) do |sheet|
+            sheet.add_row(sheet_data[:headers], style: workbook.styles.add_style(sheet_data[:style_headers]), height: 17)
+
+            sheet_data[:rows].each do |row|
+              sheet.add_row row
+            end
+          end
+        end
+      end
+
+      def temp_file
+        return @temp_file if @temp_file.present?
+
+        @temp_file = Tempfile.new(file_name)
+        xlsx.use_shared_strings = true
+        xlsx.serialize(temp_file.path)
+
+        @temp_file
+      end
+    end
+  end
+end

data/config/initializers/custom_classes/string.rb

@@ -0,0 +1,11 @@
+class String
+
+  def str_slug
+    self.downcase.strip.gsub(/\s+/, ' ').gsub(' ', '-').gsub(/[^\w-]/, '')
+  end
+
+  def is_numeric?
+    Float(self) != nil rescue false
+  end
+end
+

data/config/routes.rb

@@ -0,0 +1,38 @@
+Demographic::Engine.routes.draw do
+  resources :optionals, path: '', only: [] do
+    collection do
+      get 'optionals/list' => 'optionals#index', defaults: { adjustable_id: nil }
+      get ':module/optionals/list/:adjustable_id' => 'optionals#index'
+      get 'optionals/options' => 'optionals#options'
+      get ':module/optionals/:optional_id/show/:adjustable_id' => 'optionals#show'
+      post ':module/optionals/create/:adjustable_id' => 'optionals#create'
+      put ':module/optionals/:optional_id/update/:adjustable_id' => 'optionals#update'
+      delete ':module/optionals/:optional_id/update/:adjustable_id' => 'optionals#destroy'
+      get ':module/optionals/filterList/:adjustable_id' => 'optionals#filter_list'
+      get ':module/optionals/:optional_token/optionalValues/:adjustable_id' => 'optionals#optional_values'
+    end
+  end
+
+  scope path: ':module' do
+    scope path: 'optionals_bulk' do
+      scope path: ':adjustable_id' do
+        resources :optionals_bulk, path: '', only: [] do
+          collection do
+            get 'create_template' => 'optionals_bulk#create_template'
+            post 'create' => 'optionals_bulk#create'
+          end
+        end
+      end
+    end
+  end
+
+  resources :optionals_types, path: 'optionalTypes', only: [:index]
+
+  resources :user_optionals, path: '', only: [] do
+    collection do
+      get ':module/userOptionals/list/:adjustable_id' => 'user_optionals#index'
+    end
+  end
+
+  get ':module/customParameterValues/index/:adjustable_id' => 'custom_parameter_values#index'
+end

data/db/migrate/20201207181535_create_demographic_optionals.rb

@@ -0,0 +1,18 @@
+class CreateDemographicOptionals < ActiveRecord::Migration[6.0]
+  def change
+    create_table :optionals do |t|
+      t.integer :adjustable_id, null: false
+      t.string :adjustable_type, null: false
+      t.string :name
+      t.json :name_translate, default: {}
+      t.string :code, null: false
+      t.string :input_type, default: 'list'
+      t.integer :order, default: 1
+      t.string :min_value
+      t.string :max_value
+      t.timestamps
+    end
+
+    add_index :optionals, [:adjustable_id, :adjustable_type], :name => 'index_adjustable_type_and_adjustable_id'
+  end
+end

data/db/migrate/20201207184210_create_users.rb

@@ -0,0 +1,12 @@
+class CreateUsers < ActiveRecord::Migration[6.0]
+  def change
+    create_table :users do |t|
+      t.string :name
+      t.string :lastname
+      t.string :email
+      t.string :identifier
+      t.string :rut
+      t.timestamps
+    end
+  end
+end