demographic 0.8.6.RKM.89602.beta.0

data/app/controllers/demographic/optionals_controller.rb

@@ -0,0 +1,68 @@
+require_dependency "demographic/application_controller"
+
+module Demographic
+  class OptionalsController < ApplicationController
+
+    # GET /:module/optionals/list/:adjustable_id
+    def index
+      optionals = ::Demographic::Optionals::List.new(adjustable: adjustable,
+                                                     page: params[:page],
+                                                     term: params[:term],
+                                                     per_page: per_page)
+      render json: optionals.to_json, status: 200
+    end
+
+    # POST /:module/optionals/create/:adjustable_id
+    def create
+      optional = ::Demographic::Optionals::Create.new(adjustable: adjustable, data: allowed_params)
+      render json: optional.call, root: 'optional',
+             serializer: ::Demographic::Optionals::OptionalSerializer,
+             adapter: :json, status: 200
+    end
+
+    # GET ':module/optionals/:optional_id/show/:adjustable_id'
+    def show
+      render json: optional_adjustable, root: 'optional',
+             serializer: ::Demographic::Optionals::OptionalSerializer, adapter: :json, status: 200
+    end
+
+    # PUT /:module/optionals/:optional_id/update/:adjustable_id
+    def update
+      optional = ::Demographic::Optionals::Update.new(adjustable: adjustable,
+                                                      optional: optional_adjustable,
+                                                      data: allowed_params)
+
+      render json: optional.call, root: 'optional',
+             serializer: ::Demographic::Optionals::OptionalSerializer, adapter: :json, status: 200
+    end
+
+    # DELETE /:module/optionals/:optional_id/update/:adjustable_id
+    def destroy
+      render json: optional_adjustable.destroy!, root: 'optional',
+             serializer: ::Demographic::Optionals::OptionalSerializer, adapter: :json, status: 200
+    end
+
+    # GET /:module/optionals/filterList/:adjustable_id
+    def filter_list
+      render json: adjustable.optionals, root: 'optionals',
+             each_serializer: ::Demographic::Optionals::FilterListSerializer, adapter: :json, status: 200
+    end
+
+    # GET /:module/optionals/:optional_token/optionalValues/:adjustable_id
+    def optional_values
+      service = ::Demographic::Optionals::OptionalValues.new(adjustable: adjustable, optional: optional_adjustable, page: params[:page], term: params[:term], per_page: per_page)
+      render json: service.call, status: 200
+    end
+
+    # GET /:module/optionals/options
+    def options
+      render json: ::Demographic::Helpers::AssociationLocalizer.translations_for, status: 200
+    end
+
+    private
+
+    def allowed_params
+      params.require(:optional).permit!
+    end
+  end
+end

data/app/controllers/demographic/optionals_types_controller.rb

@@ -0,0 +1,17 @@
+require_dependency "demographic/application_controller"
+
+module Demographic
+  class OptionalsTypesController < ApplicationController
+
+    # GET demographic/optionalTypes
+    def index
+      render json: optional_types, status: 200
+    end
+
+    private
+
+    def optional_types
+      {types: Demographic.multiples_inputs | Demographic.simple_inputs}
+    end
+  end
+end

data/app/controllers/demographic/user_optionals_controller.rb

@@ -0,0 +1,12 @@
+require_dependency "demographic/application_controller"
+
+module Demographic
+  class UserOptionalsController < ApplicationController
+
+    # GET demographic/:module/userOptionals/list/:adjustable_id?user_token=
+    def index
+      service = Demographic::UserOptionals::List.new(user: user, adjustable: adjustable)
+      render json: service.perform
+    end
+  end
+end

data/app/jobs/demographic/application_job.rb

@@ -0,0 +1,4 @@
+module Demographic
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/demographic/application_mailer.rb

@@ -0,0 +1,6 @@
+module Demographic
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'from@example.com'
+    layout 'mailer'
+  end
+end

data/app/serializers/demographic/optionals/filter_list_serializer.rb

@@ -0,0 +1,34 @@
+module Demographic
+  class Optionals::FilterListSerializer < ActiveModel::Serializer
+    attributes :label, :value, :type, :module
+
+    attribute :list
+
+    def value
+      object.id.to_s
+    end
+
+    def label
+      object.name_translate[I18n.locale.to_s] || object.name
+    end
+
+    def type
+      object.input_type
+    end
+    def module
+      {::Demographic.parent_model.invert[object.adjustable_type.underscore.to_sym] => I18n.t("activerecord.errors.models.#{object.adjustable_type.underscore}.optional") }
+    end
+
+    def list
+      return [] if Demographic.simple_inputs.include?(object.input_type)
+
+      object.optional_values.map do |value|
+        {
+          label: value.value_translate[I18n.locale.to_s] || value.value,
+          value: value.id.to_s,
+          color: ''
+        }
+      end
+    end
+  end
+end

data/app/serializers/demographic/optionals/list_serializer.rb

@@ -0,0 +1,17 @@
+module Demographic
+  class Optionals::ListSerializer < ActiveModel::Serializer
+    attributes :id, :code, :name_translate, :input_type, :created_at, :order, :key, :module, :token
+
+    def created_at
+      object.created_at.strftime('%d-%m-%Y')
+    end
+
+    def key
+      object.id
+    end
+
+    def module
+      {::Demographic.parent_model.invert[object.adjustable_type.underscore.to_sym] => I18n.t("activerecord.errors.models.#{object.adjustable_type.underscore}.optional") }
+    end
+  end
+end

data/app/serializers/demographic/optionals/optional_serializer.rb

@@ -0,0 +1,20 @@
+module Demographic
+  class Optionals::OptionalSerializer < ActiveModel::Serializer
+    attributes :id, :code, :name_translate, :input_type, :order, :min_value, :max_value, :created_at, :module
+
+    attribute :values
+
+    def created_at
+      object.created_at.strftime('%d-%m-%Y')
+    end
+
+    def values
+      return [] if Demographic.simple_inputs.include?(object.input_type)
+
+      object.optional_values.map{ |value| Optionals::ValueSerializer.new(value) }
+    end
+    def module
+      {::Demographic.parent_model.invert[object.adjustable_type.underscore.to_sym] => I18n.t("activerecord.errors.models.#{object.adjustable_type.underscore}.optional") }
+    end
+  end
+end

data/app/serializers/demographic/optionals/value_serializer.rb

@@ -0,0 +1,5 @@
+module Demographic
+  class Optionals::ValueSerializer < ActiveModel::Serializer
+    attributes :id, :optional_id, :slug, :code, :order_num, :value_translate
+  end
+end

data/app/services/demographic/custom_parameter_values/index.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Demographic
+  module CustomParameterValues
+    class Index
+      attr_accessor :record, :adjustable, :page, :per_page
+
+      def initialize(record:, adjustable:, page:, per_page:)
+        @record = record
+        @adjustable = adjustable
+        @page = page || 1
+        @per_page = per_page || 20
+      end
+
+      def call
+        optional_structure
+      end
+
+      private
+
+      def optional_structure
+        custom_parameter_values_ids = record.custom_parameter_values.pluck(:id)
+
+        optionals.map do |optional|
+          mapped_value = optional.custom_parameter_values.select do |value|
+            custom_parameter_values_ids.include?(value.id)
+          end
+
+          {
+            id: optional.id,
+            code: optional.code,
+            name: optional.name,
+            token: optional.token,
+            input_type: optional.input_type,
+            values: mapped_value.map do |custom_parameter_value|
+              {
+                id: custom_parameter_value.id,
+                value: custom_parameter_value&.optional_value&.value || custom_parameter_value&.value
+              }
+            end
+          }
+        end
+      end
+
+      def optionals
+        @optionals ||= Optional.includes(:custom_parameter_values)
+                               .where(adjustable_id: adjustable.id, adjustable_type: adjustable.class.name)
+                               .page(page).per(@per_page)
+                               .order(:created_at)
+      end
+    end
+  end
+end

data/app/services/demographic/helpers/association_localizer.rb

@@ -0,0 +1,13 @@
+module Demographic
+  module Helpers
+    class AssociationLocalizer
+      def self.translations_for
+        Rails.application.eager_load!
+
+        Demographic.parent_model.each_with_object({}) do |(key, value), hash|
+          hash[key] = I18n.t("activerecord.errors.models.#{value}.optional", default: key.to_s)
+        end
+      end
+    end
+  end
+end

data/app/services/demographic/helpers/import/bulk/build_optionals.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Demographic
+  module Helpers
+    module Import
+      module Bulk
+        class BuildOptionals
+          attr_reader :users_data, :parent_module, :reference_id
+
+          def initialize(users_data:, parent_module:, reference_id:)
+            @users_data = users_data
+            @parent_module = parent_module
+            @reference_id = reference_id
+          end
+
+          def call
+            ActiveRecord::Base.transaction do
+              data_optionals = data_optionals_service.call
+              return data_optionals unless data_optionals.success
+
+              optional_values_service(data_optionals[:data]).call
+              user_optionals_service(data_optionals[:data]).call
+            end
+
+            response_instance(success: true, message: '')
+          rescue => e
+            response_instance(success: false, message: e)
+          end
+
+          private
+
+          def data_optionals_service
+            Demographic::Parse::DataSerializer.new(users_data: users_data,
+                                                   parent_module: parent_module,
+                                                   reference_id: reference_id)
+          end
+
+          def optional_values_service(data_optionals)
+            CreateOptionalValues.new(data_optionals: data_optionals)
+          end
+
+          def user_optionals_service(data_optionals)
+            CreateOrUpdateUserOptionals.new(data_optionals: data_optionals)
+          end
+
+          def response_instance(success:, message:)
+            Struct.new(:success, :message)
+                  .new(success, message)
+          end
+        end
+      end
+    end
+  end
+end

data/app/services/demographic/helpers/import/bulk/create_optional_values.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Demographic
+  module Helpers
+    module Import
+      module Bulk
+        class CreateOptionalValues
+          attr_reader :optional_values, :data_optionals
+
+          def initialize(data_optionals:)
+            @data_optionals = data_optionals
+            @optional_values = @data_optionals.map { |data_optional| data_optional.except(:user_id) }
+          end
+
+          def call
+            create_optional_values
+          end
+
+          private
+
+          def create_optional_values
+            OptionalValue.bulk_import(optional_values,
+                                      batch_size: 1000,
+                                      on_duplicate_key_ignore: true,
+                                      validate: false,
+                                      returning: :code)
+          end
+        end
+      end
+    end
+  end
+end

data/app/services/demographic/helpers/import/bulk/create_or_update_user_optionals.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Demographic
+  module Helpers
+    module Import
+      module Bulk
+        class CreateOrUpdateUserOptionals
+          attr_reader :data_optionals
+          attr_accessor :optional_values_codes, :optionals_ids,
+                        :optionals_values_ids_by_code, :user_optionals_ids
+
+          def initialize(data_optionals:)
+            @data_optionals = data_optionals
+          end
+
+          def call
+            data_optionals.each_slice(1000) do |data_optionals_slice|
+              build_metadata(data_optionals_slice)
+              serialized_data = build_serialized_data(data_optionals_slice)
+              bulk_create(serialized_data[:to_create])
+              bulk_update(serialized_data[:to_update])
+            end
+          end
+
+          private
+
+          def build_metadata(data_optionals_slice)
+            build_basic_data(data_optionals_slice)
+            build_optionals_values_ids_by_code
+            build_user_optionals_ids(data_optionals_slice)
+          end
+
+          def build_basic_data(data_optionals_slice)
+            @optional_values_codes = []
+            @optionals_ids = []
+
+            data_optionals_slice.each { |data_optional|
+              @optional_values_codes << data_optional[:code]
+              @optionals_ids << data_optional[:optional_id]
+            }
+
+            @optional_values_codes = @optional_values_codes.uniq
+            @optionals_ids = @optionals_ids.uniq
+          end
+
+          def build_optionals_values_ids_by_code
+            @optionals_values_ids_by_code = OptionalValue.where(code: optional_values_codes)
+                                                         .pluck(:code, :id).to_h
+          end
+
+          def build_user_optionals_ids(data_optionals_slice)
+            user_ids = data_optionals_slice.map { |data_optional| data_optional[:user_id] }.uniq
+
+            @user_optionals_ids = UserOptional.where(optional_id: optionals_ids, user_id: user_ids)
+                                              .pluck(:optional_id, :user_id, :id, :optional_value_id)
+                                              .to_h { |(optional_id, user_id, id, optional_value_id)|
+                                                [[optional_id, user_id], { id: id, optional_value_id: optional_value_id }]
+                                              }
+          end
+
+          def build_serialized_data(data_optionals_slice)
+            data_optionals_slice.reduce({ to_create: [], to_update: [] }) do |serialized_data_optionals, data_optional|
+              user_id = data_optional[:user_id]
+              next serialized_data_optionals if user_id.blank?
+
+              optional_value_id = optionals_values_ids_by_code[data_optional[:code]]
+              next serialized_data_optionals if optional_value_id.blank?
+
+              user_optional = user_optionals_ids[[data_optional[:optional_id], user_id]]
+              user_optional_data = {
+                user_id: user_id,
+                optional_id: data_optional[:optional_id],
+                optional_value_id: optional_value_id,
+                value: data_optional[:value]
+              }
+
+              if user_optional.present?
+                if user_optional[:optional_value_id] != optional_value_id
+                  serialized_data_optionals[:to_update] << user_optional_data.merge(id: user_optional[:id])
+                end
+
+                next serialized_data_optionals
+              end
+
+              serialized_data_optionals[:to_create] << user_optional_data
+
+              serialized_data_optionals
+            end
+          end
+
+          def bulk_create(data)
+            return unless data.present?
+
+            UserOptional.bulk_import(data, batch_size: 1000, validate: false)
+          end
+
+          def bulk_update(data)
+            return unless data.present?
+
+            UserOptional.bulk_import(data,
+                                     batch_size: 1000,
+                                     validate: false,
+                                     on_duplicate_key_update: { conflict_target: [:id],
+                                                                columns: [:value, :optional_value_id] })
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Demographic
+  module Helpers
+    module Import
+      class CreateOptionalsList
+        def self.call(file_headers:, parent_module:, reference_id:, sheet_name: 'es')
+          @adjustable = parent_model(parent_module).to_s.capitalize.classify.constantize.find_by!(id: reference_id)
+
+          file_headers.grep(/optional_/).each do |optional_header|
+            name = optional_header.gsub('optional_', '').split('#').first
+            value_type = type(optional_header.split('#').last)
+
+            optional = @adjustable.optionals.find_by(code: name.parameterize.str_slug)
+
+            optional ||= @adjustable.optionals.create(attr_hash(name, sheet_name, value_type))
+
+            optional
+          end
+
+          { success: true, message: 'success!!!' }
+        rescue StandardError => e
+          { success: false, message: e.to_s }
+        end
+
+        private
+
+        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.attr_hash(name, sheet_name, value_type)
+          hash = { name: name,
+                   code: name.parameterize.str_slug,
+                   token: Demographic.generate_token,
+                   name_translate: { sheet_name => name },
+                   input_type: value_type }
+
+          hash.merge!(monolithe)
+        end
+
+        def self.monolithe
+          return {} unless Optional.new.attributes.key?('enterprise_process_id')
+          return {} unless @adjustable.try(:enterprise_process_id).present?
+
+          { enterprise_process_id: @adjustable.try(:enterprise_process_id) }
+        end
+
+        def self.type(key)
+          key ||= 'list'
+          hash = Demographic.input_types_allowed
+          hash[key.downcase] || :list
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+module Demographic
+  module Helpers
+    module Import
+      class CreateOrUpdateCustomParameterValues
+        def self.call(record:, optionals:, parent_module:, reference_id:)
+          return { success: false, message: 'error has not optionls!!!' } unless optionals.present?
+          optionals = optionals.to_unsafe_h if optionals.is_a?(ActionController::Parameters)
+
+          optionals_array = []
+
+          optionals.each do |element|
+            next unless element[:optional_id].present?
+
+            optional = Optional.find_by!(id: element[:optional_id])
+            hash = { optional_id: optional.id }
+
+            if Demographic.simple_inputs.include?(optional.input_type)
+              hash.merge!(simple_input(record, optional, element))
+              next optionals_array << hash
+            end
+
+            optionals_array << hash.merge!(multiple_input(record, optional, element))
+          end
+
+          { success: true, message: 'Success!!!', optionals: optionals_array }
+        rescue StandardError => e
+          { success: false, message: e.to_s, optionals: [] }
+        end
+
+        private
+
+        def self.multiple_input(record, optional, element)
+          record_optional = record.custom_parameter_values.find_by(optional_id: optional.id)
+
+          if record_optional.present? && !element[:optional_value_id].present?
+            record_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?
+
+          record_optional ||= record.custom_parameter_values.new
+          record_optional.optional_id = optional.id
+          record_optional.optional_value_id = optional_value.id
+          record_optional.value = optional_value.value
+          record_optional.save!
+
+          { optional_user_id: record_optional.id, optional_value_id: optional_value.id }
+        end
+
+        def self.simple_input(record, optional, element)
+          current_value = format_value(element[:value], optional)
+          record_optional = record.custom_parameter_values.find_by(optional_id: optional.id)
+
+          if record_optional.present? && !element[:optional_value_id].present?
+            record_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?
+
+          record_optional ||= record.custom_parameter_values.new
+          record_optional.optional_id = optional.id
+          record_optional.optional_value_id = optional_value.id
+          record_optional.value = optional_value.value
+          record_optional.save!
+
+          { custom_parameter_value_id: record_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