demographic 0.8.6.RKM.89602.beta.0

data/app/services/demographic/helpers/import/create_or_update_user_values.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+module Demographic
+  module Helpers
+    module Import
+      class CreateOrUpdateUserValues
+        # optional = "{optional_id, optional_value_id, value:}"
+
+        def self.call(user:, optionals:, parent_module:, reference_id:)
+          return { success: false, message: 'error has not optionls!!!' } unless optionals.present?
+
+          adjustable = parent_model(parent_module).to_s.capitalize.classify.constantize.find_by!(id: reference_id)
+
+          optionals_array = []
+          optional_ids = optionals.map { |element| element[:optional_id] }.compact
+
+          optionals_hash = adjustable.optionals.where(id: optional_ids).select(:id, :input_type).index_by(&:id)
+
+          user_optionals_hash = user.user_optionals.where(optional_id: optional_ids).index_by(&:optional_id)
+
+          optional_value_ids = optionals.map { |element| element[:optional_value_id] }.compact
+          optional_values_hash = ::OptionalValue.where(id: optional_value_ids).select(:id, :value).index_by(&:id)
+          simple_inputs_hash = Demographic.simple_inputs.index_with { |_s| true }
+
+          optionals.each do |element|
+            next unless element[:optional_id].present?
+            optional_id = element[:optional_id].to_i
+            optional = optionals_hash[optional_id]
+            # exception for replace find_by!
+            raise StandardError, "Optional not found #{element}" unless optional.present?
+
+            user_optional = user_optionals_hash[optional_id]
+
+            if simple_inputs_hash[optional.input_type]
+              current_value = format_value(element[:value], optional)
+              optional_attrs = simple_input_v2(user.id, optional_id, user_optional, current_value)
+            else
+              optional_value = optional_values_hash[element[:optional_value_id]&.to_i]
+              optional_attrs = multiple_input_v2(user.id, optional_id, user_optional, optional_value)
+            end
+
+            optionals_array << optional_attrs
+          end
+
+          { success: true, message: 'Success!!!', optionals: optionals_array }
+        rescue StandardError => e
+          { success: false, message: e.to_s, optionals: [] }
+        end
+
+        private
+
+        def self.multiple_input(user, optional, element)
+          user_optional = user.user_optionals.find_by(optional_id: optional.id)
+
+          if user_optional.present? && !element[:optional_value_id].present?
+            user_optional.destroy!
+            return {}
+          end
+
+          return {} unless element[:optional_value_id].present?
+
+          optional_value = optional.optional_values.find_by(id: element[:optional_value_id])
+          return {} unless optional_value.present?
+
+          user_optional ||= user.user_optionals.new
+          user_optional.optional_id = optional.id
+          user_optional.optional_value_id = optional_value.id
+          user_optional.value = optional_value.value
+          user_optional.save!
+
+          { optional_user_id: user_optional.id, optional_value_id: optional_value.id }
+        end
+
+        def self.multiple_input_v2(user_id, optional_id, user_optional, optional_value)
+          if optional_value.nil?
+            user_optional&.destroy!
+            return {}
+          end
+
+          user_optional ||= UserOptional.new
+          user_optional.user_id = user_id
+          user_optional.optional_id = optional_id
+          user_optional.optional_value_id = optional_value.id
+          user_optional.value = optional_value.value
+          user_optional.save!
+
+          { optional_id: optional_id, optional_user_id: user_optional.id, optional_value_id: optional_value.id }
+        end
+
+        def self.simple_input(user, optional, element)
+          current_value = format_value(element[:value], optional)
+          user_optional = user.user_optionals.find_by(optional_id: optional.id)
+
+          if user_optional.present? && !current_value.present?
+            user_optional.destroy!
+            return {}
+          end
+
+          return {} unless current_value.present?
+
+          code = Demographic.generate_code(optional.id, current_value)
+          optional_value = optional.optional_values.find_or_create_by(slug: current_value.str_slug,
+                                                                      code: code) do |optional_value|
+            optional_value.token = Demographic.generate_token
+            optional_value.value = current_value
+            optional_value.value_translate.merge!({ I18n.locale => current_value })
+          end
+
+          user_optional ||= user.user_optionals.new
+          user_optional.optional_id = optional.id
+          user_optional.optional_value_id = optional_value.id
+          user_optional.value = optional_value.value
+          user_optional.save!
+
+          { optional_user_id: user_optional.id, optional_value_id: optional_value.id }
+        end
+
+        def self.simple_input_v2(user_id, optional_id, user_optional, current_value)
+          unless current_value.present?
+            user_optional&.destroy!
+            return {}
+          end
+
+          code = Demographic.generate_code(optional_id, current_value)
+          optional_value = ::OptionalValue.find_or_create_by(optional_id: optional_id,
+                                                             slug: current_value.str_slug,
+                                                             code: code) do |optional_value|
+            optional_value.token = Demographic.generate_token
+            optional_value.value = current_value
+            optional_value.value_translate.merge!({ I18n.locale => current_value })
+          end
+
+          # TODO: verificar impacto de quitar creacion de user_optinal para simple_input
+          user_optional ||= UserOptional.new
+          user_optional.user_id = user_id
+          user_optional.optional_id = optional_id
+          user_optional.optional_value_id = optional_value.id
+          user_optional.value = optional_value.value
+          user_optional.save!
+
+          { optional_id: optional_id, optional_user_id: user_optional.id, optional_value_id: optional_value.id }
+        end
+
+        def self.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 self.format_value(value, optional)
+          return unless value.present?
+
+          return value.to_s.to_date.strftime if optional.input_type.eql?('date')
+
+          value.to_s
+        rescue StandardError
+        end
+      end
+    end
+  end
+end

data/app/services/demographic/helpers/import/create_or_update_values.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Demographic
+  module Helpers
+    module Import
+      class CreateOrUpdateValues
+        def self.call(user_data:, parent_module:, reference_id:)
+          @permit_user_data = user_data.is_a?(Hash) ? user_data : user_data.to_unsafe_hash
+          return { success: false, message: 'User data not present', optionals: [] } unless @permit_user_data.present?
+
+          optionals = optional_hash
+          return { success: false, message: 'Optionals Empty!!!', optionals: [] } unless optionals.present?
+
+          optional_codes = optionals.map { |element| element[:code]&.downcase }.compact
+          optionals_query = Optional.unscoped.where('lower(code) IN (?)', optional_codes).order(id: :desc)
+          optionals_hash = optionals_query.index_by{|optional| optional.code.downcase }
+
+          records = optionals.map do |element|
+            current_value = element[:value]
+
+            optional = optionals_hash[element[:code]&.downcase]
+            return { success: false, message: "Optional not found #{element}", optionals: [] } unless optional.present?
+
+            next { optional_id: optional.id, optional_value_id: nil, value: nil } unless current_value.present?
+
+            value = value_valid(optional, current_value)
+            unless value.is_valid?
+              return { success: false, message: "The value is not valid #{current_value}", optionals: [] }
+            end
+
+            optional_value = find_or_create_by_value(optional, value.current)
+
+            { optional_id: optional.id, optional_value_id: optional_value.id, value: value.current }
+          end
+
+          { success: true, optionals: records.compact }
+        rescue StandardError => e
+          { success: false, message: e.to_s, optionals: [] }
+        end
+
+        private
+
+        def self.optional_hash
+          @permit_user_data.with_indifferent_access.map do |key, value|
+            code = key.to_s
+            next unless code.include?('optional_') && !key.nil?
+
+            name_type = code.gsub('optional_', '').split('#')
+            name = name_type.first
+
+            {
+              name: name,
+              code: name.parameterize.str_slug,
+              value: value
+            }
+          end.compact
+        end
+
+        def self.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 self.datetime?(d)
+          d.methods.include? :strftime
+        end
+
+        def self.value_valid(optional, value)
+          struct = Struct.new(:is_valid?, :current)
+
+          return struct.new(true, value) if optional.input_type.eql?('list') || optional.input_type.eql?('text')
+
+          return struct.new(value.to_s.is_numeric?, value) if optional.input_type.eql?('number')
+
+          return conversion_date(value, struct) if optional.input_type.eql?('date')
+
+          return conversion_bool(value, struct) if optional.input_type.eql?('bool')
+
+          struct.new(false, value.to_s)
+        end
+
+        def self.conversion_bool(value, struct)
+          bool_hash = { '0' => 'false', '1' => 'true' }
+
+          bool = bool_hash[value.to_i.to_s]
+
+          struct.new(bool.present?, bool)
+        end
+
+        def self.conversion_date(value, struct)
+          formats = %w[%Y-%m-%d %Y/%m/%d %y-%m-%d %y/%m/%d %d-%m-%Y %d/%m/%Y %d-%m-%y %d/%m/%y]
+
+          formats.each do |format|
+            date = format_date(value, format)
+            return struct.new(true, date) if date != false
+          end
+
+          struct.new(false, value.to_s)
+        end
+
+        def self.format_date(value, format)
+          Date.strptime(value, format).strftime
+        rescue StandardError
+          false
+        end
+
+        def self.find_or_create_by_value(optional, current_value)
+          code = Demographic.generate_code(optional.id, current_value.to_s)
+          optional.optional_values.find_or_create_by(slug: current_value.to_s.str_slug,
+                                                     code: code) do |optional_value|
+            optional_value.token = Demographic.generate_token
+            optional_value.value = current_value
+            optional_value.value_translate = { es: current_value }
+          end
+        rescue ActiveRecord::RecordNotUnique
+          code = Demographic.generate_code(optional.id, current_value.to_s)
+          optional.optional_values.where('code ILIKE ?', code).first
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module Demographic
+  module OptionalValues
+    class CreateList
+
+      attr_accessor :adjustable, :values, :optional
+
+      def initialize(adjustable:, optional:, values:)
+        @adjustable = adjustable
+        @optional = optional
+        @values = values
+      end
+
+      def call
+        return true unless values.present?
+
+        ActiveRecord::Base.transaction do
+          validation_values
+          create_values
+        end
+      end
+
+      private
+
+      def validation_values
+        values.each do |value|
+          if !value[:value_translate].present? || !value[:value_translate].values.any?{ |v| v.present? }
+            optional.errors.add(:value_translate, 'value_translate is empty')
+            raise ActiveRecord::RecordInvalid.new(optional)
+          end
+        end
+      end
+
+      def create_values
+
+        values.each do |value|
+          if value[:is_valid].present? && value[:is_valid].to_d == 0
+            next
+          end
+
+          current_value = current_value(value)
+          code = Demographic.generate_code(optional.id, current_value.str_slug)
+
+          optional.optional_values.find_or_create_by!(slug: current_value.str_slug,
+                                                      code: code) do |optional_value|
+            optional_value.token = Demographic.generate_token
+            optional_value.value = current_value
+            optional_value.value_translate = value[:value_translate]
+            optional_value.order_num = value[:order_num]
+          end
+        end
+      end
+
+      def current_value(value)
+        return value[:value_translate]['es'] if value[:value_translate]['es'].present?
+
+        value[:value_translate].values.detect{|v| v.present? }
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+module Demographic
+  module OptionalValues
+    class UpdateList
+
+      attr_accessor :adjustable, :values, :optional
+
+      def initialize(adjustable:, optional:, values:)
+        @adjustable = adjustable
+        @optional = optional
+        @values = values
+      end
+
+      def call
+        return true unless values.present?
+
+        ActiveRecord::Base.transaction do
+          validation_values
+          delete_values
+          update_values
+          create_values
+        end
+
+      end
+
+      private
+
+      def validation_values
+        values.each do |value|
+          if !value[:value_translate].present? || !value[:value_translate].values.any?{ |v| v.present? }
+            optional.errors.add(:value_translate, 'value_translate is empty')
+            raise ActiveRecord::RecordInvalid.new(optional)
+          end
+        end
+      end
+
+      def delete_values
+        values_ids = values.map{|v| v[:id] }.compact
+        return unless values_ids.present?
+
+        optional.optional_values.where.not(id: values_ids).destroy_all
+      end
+
+      def update_values
+        values_ids = values.map{|v| v[:id] }.compact
+        return unless values_ids.present?
+
+        current_values = optional.optional_values.where(id: values_ids)
+        return unless current_values.present?
+
+        current_values.each do |optional_value|
+          value = values.detect{|v| v[:id] == optional_value.id}
+          current_value = current_value(value)
+          optional_value.code = Demographic.generate_code(optional.id, current_value.str_slug)
+          optional_value.slug = current_value.str_slug
+          optional_value.value = current_value
+          optional_value.value_translate = value[:value_translate]
+          optional_value.order_num = value[:order_num]
+          optional_value.save!
+          update_user_values(optional_value, current_value)
+        end
+      end
+
+      def create_values
+        new_values = values.select{|v| !v[:id].present? }
+        return unless new_values.present?
+
+        ::Demographic::OptionalValues::CreateList.new(adjustable: adjustable,
+                                                      values: new_values,
+                                                      optional: optional).call
+      end
+
+      def current_value(value)
+        return value[:value_translate]['es'] if value[:value_translate]['es'].present?
+
+        value[:value_translate].values.detect{|v| v.present? }
+      end
+
+      def update_user_values(optional_value, current_value)
+        optional.user_optionals
+                .where(optional_value_id: optional_value.id)
+                .update_all(value: current_value)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+module Demographic
+  module Optionals
+    class BulkCreate
+      attr_reader :file, :adjustable, :optionals_by_code
+
+      def initialize(file:, adjustable:)
+        @file = file
+        @adjustable = adjustable
+        @optionals_by_code = adjustable.optionals.index_by(&:code)
+      end
+
+      def call
+        return response(validations.error.data, validations.error.status) if validations.error.present?
+
+        response(create_bulk_import, 200)
+      end
+
+      private
+
+      def validations
+        @validations ||= ::Demographic::Optionals::BulkCreateValidations.new(file: file).call
+      end
+
+      def create_bulk_import
+        return json_response.merge!(message: "No devuelve ids del bulk import") unless bulk_import.ids.present?
+
+        optionals = Optional.where(id: bulk_import.ids)
+        return json_response.merge!(message: "No devuelve optionals aun que tenemos los ids del bulk import") unless optionals.ids.present?
+
+        return json_response.merge!(message: "El module es incorrecto") unless change_module
+        run_create_callbacks(optionals)
+
+        json_response.merge!(message: "Success")
+      end
+
+      def bulk_import
+        @bulk_import ||= bulk_import_transaction
+      end
+
+      def bulk_import_transaction
+        current_bulk_import = Optional.bulk_import(data_hash.values,
+                                                   batch_size: 1000,
+                                                   on_duplicate_key_ignore: true,
+                                                   validate: true,
+                                                   returning: [:id, :name, :input_type])
+
+        delay_transaction
+        current_bulk_import
+      end
+
+      def json_response
+        @json_response ||= {
+          optionals_created: bulk_import.results
+        }
+      end
+
+      def run_create_callbacks(optionals)
+        optionals.each { |optional| optional.run_callbacks(:create) }
+      end
+
+      def data_hash
+        return @data_hash if @data_hash.present?
+
+        @data_hash = {}
+
+        validations.data.each do |row|
+          serialized_row = serialize_row(row)
+          @data_hash[serialized_row.code] = serialized_row
+        end
+
+        @data_hash
+      end
+
+      def serialize_row(row)
+        base_optional_hash = validations.headers.zip(row).to_h
+        code = base_optional_hash['name'].parameterize.str_slug
+
+        optional_hash = {}.tap do |hash|
+          hash[:name] = base_optional_hash['name']
+          hash[:input_type] = base_optional_hash['type']
+          hash[:code] = base_optional_hash['code'] || code
+          hash[:token] = Demographic.generate_token
+          hash[:name_translate] = { es: base_optional_hash['name'] }
+        end
+
+        optionals_by_code[code] || adjustable.optionals.new(optional_hash)
+      end
+
+      def delay_transaction
+        # We need to do this because the .bulk_import is causing issues on production, because in prod exists a delay
+        # for the bd replicas
+        sleep 1
+      end
+
+      def response(data, status)
+        Struct.new(:data,
+                   :status).new(data,
+                                status)
+      end
+
+      def change_module
+        if base_optional_hash['module'].present?
+          parent_model = Demographic.parent_model[base_optional_hash['module'].to_sym]
+          model_class = parent_model.to_s.capitalize.classify.constantize
+          if adjustable.id == "0"
+            #non-persisted object to avoid errors downstream
+            return adjustable = model_class.new(id: 0)
+          end
+
+          adjustable = model_class.find_by!(id: adjustable.id)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+module Demographic
+  module Optionals
+    class BulkCreateValidations
+      attr_reader :file
+      attr_accessor :data_hash, :headers, :xls
+
+      def initialize(file:)
+        @file = file
+      end
+
+      def call
+        response(validate_file)
+      end
+
+      private
+
+      def validate_file
+        excel_validation = valid_excel(file)
+        return excel_validation if excel_validation.respond_to?(:error)
+
+        headers_validation = validate_headers
+        return headers_validation if headers_validation.respond_to?(:error)
+
+        data_validation = validate_data
+        return data_validation if data_validation.respond_to?(:error)
+
+        data_hash
+      end
+
+      def valid_excel(excel_file)
+        ext = file.original_filename.split('.').last
+
+        unless %w[xls xlsx].include? ext
+          return wrong_file_format(excel_file.original_filename, 'Formato de archivo no válido. Solo XLSX y XLS')
+        end
+
+        xls = (Roo::Spreadsheet.open excel_file.tempfile.path, extension: ext) rescue nil
+
+        if xls.nil?
+          inverse_ext = ext.eql?('xls') ? 'xlsx' : 'xls'
+          xls = Roo::Spreadsheet.open excel_file.tempfile.path, extension: inverse_ext
+        end
+        # Importante: construir las filas manualmente para NO perder la primera fila (cabeceras).
+        # Algunos métodos de parseo de Roo omiten la fila de cabecera por defecto.
+        sheet = xls.sheet(0)
+        rows = []
+        (sheet.first_row..sheet.last_row).each do |row_index|
+          rows << sheet.row(row_index)
+        end
+        @xls = rows
+      end
+
+      def validate_headers
+        @headers = xls.shift
+        required_headers = ::Import::Templates::CreateOptionals::HEADERS
+        missing_headers = required_headers - headers
+        return missing_parameters("Faltan las siguientes cabeceras en el archivo: #{missing_headers.join(', ')}") unless missing_headers.empty?
+
+        @headers
+      end
+
+      def validate_data
+        return missing_parameters("El archivo está vacío") if xls.blank?
+
+        @data_hash = []
+        data_errors = []
+        type_index = headers.index('type')
+
+        xls.each do |row|
+          unless row.all?
+            data_errors << row
+            next
+          end
+
+          unless available_types.include?(row[type_index])
+            data_errors << row
+            next
+          end
+
+          @data_hash << row
+        end
+
+        return missing_parameters("El archivo contiene errores en: #{parse_row_error(data_errors)}") if data_errors.present?
+
+        @data_hash
+      end
+
+      def parse_row_error(rows)
+        rows.map { |pair| pair.join(': ') }.join(', ')
+      end
+
+      def available_types
+        Demographic.simple_inputs + Demographic.multiples_inputs
+      end
+
+      # Start Structs methods
+      def wrong_file_format(file_name, message)
+        data = { wrong_file_format?: true, file_name: file_name, message: message }
+        Struct.new(:data, :status, :error).new(data, 400, true)
+      end
+
+      def missing_parameters(message)
+        data = { missing_parameters?: true, message: message }
+        Struct.new(:data, :status, :error).new(data, 400, true)
+      end
+
+      def response(validations)
+        error = validations.respond_to?(:error)
+        params = {}.tap do |hash|
+          hash[:data] = error ? [] : data_hash
+          hash[:headers] = error ? [] : headers
+          hash[:error] = error ? validations : false
+        end
+
+        Struct.new(:data, :headers, :error).new(params[:data],
+                                                params[:headers],
+                                                params[:error])
+      end
+      # Ends Structs methods
+    end
+  end
+end