demographic 0.8.6.RKM.89602.beta.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c0c4c96874175a3b508170ae59787fa3caaeab6f0e89047d9fe25d60da7e5058
+  data.tar.gz: 12c3c0acf0a5c2140de1229d1d9197e4a955ab385bbe07680d783209e915e3e4
+SHA512:
+  metadata.gz: 4af1830835024b8bda5ecaa75028f2d990951fd3d982bffc18dbc49ef2e8087587b5d32f0b109f31689f24350f6efdb6822650e34d44812bdd57dfa74f74e408
+  data.tar.gz: c370e1bda98ea8045f0f70cb0091a2230da46fa69e67cfc3d5e1995b50e605be4cb7cdb888b03834ff91ebd3dfd3e849b54ac74603a4918bebdbb970dc2895a9

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2020 jrojasetiner
+
+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,479 @@
+# Demographic
+
+Es un motor de rails que permite agregar atributos demograficos por tipos a los usuarios y luego ser usados para su
+respectivo filtro
+
+### Documentacion para la creacion y carga
+
+https://intercom.help/rankmi/es/articles/5345051-creacion-carga-y-actualizacion-de-opcionales
+
+## Instalación
+
+seguir cada paso:
+
+```ruby
+gem 'demographic'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install demographic
+```
+
+Genera el setting para los tipos de octionales, la seguridad
+y genera los modelos a usar en el proyecto.
+
+Se agregan los archivos de config
+
+```
+  rails g init demographic
+```
+
+- config/initializers/init_demographic.rb
+- app/middleware/policy_demographic.rb
+
+Se agregan los siguientes modelos (solo si desea trabajar con ellos)
+
+```
+  rails g init_model demographic
+```
+
+- users
+- optionals
+- optional_values
+- user_optionals
+
+Config migraciones: copia las migraciones al proyecto (solo si desea trabajar con ellos)
+
+```bash
+  rake demographic:install:migrations
+  rake db:migrate
+```
+
+Nota:
+
+* Para relacionar el modelo padre con optionals se debe
+  agregar la siguiente linea solo si usas los modelos del motor
+
+```
+   has_many :optionals, as: :adjustable
+
+   Ejemplo:
+   class Survey < ApplicationRecord
+     has_many :optionals, as: :adjustable
+   end
+```
+
+ACTUALIZACIÓN:
+
+* En el caso de los proyectos que ya implementan el engine, para agregar el campo "token"
+  en Optionals y OptionalValues, se debe de ejeuctar el siguiente comando
+
+```
+  rails g init_manual_update demographic
+```
+
+Corre las migraciones
+
+* Si se produce algun error ArgumentError: Unknown migration version "6.0";
+  de version solo basta con cambiarla en los migrates a la version correspondiente
+
+```
+rake db:migrate
+```
+
+Actualizar tokens en Optionals y OptionalsValues
+
+```
+rake demographic:update_tokens
+```
+
+En el caso de proyectos como Rankmi Forms, el cual implementa multiples tenants, se
+debe de ejecutar el siguiente comando en lugar del anterior
+
+```
+rake demographic:update_tokens_by_tenants
+```
+
+Config rutas: agregar en el routes.rb
+(el adjustable_id es el id del survey, process o empresa)
+
+```
+  mount Demographic::Engine => "/demographic"
+```
+
+Parametros de las rutas:
+
+- module: puede ser (performance, engagement, talent, csi ...)
+- adjustable_id: (process_id, survey_id) el id al que pertenece el o los opcionales
+
+EPs:
+
+- GET demographic/optionalTypes
+
+```
+    {
+        "types": [
+            "checkbox",
+            "radio",
+            "list",
+            "text",
+            "date",
+            "number",
+            "boolean"
+        ]
+    }
+```
+
+- GET demographic/:module/optionals/list/:adjustable_id?page=1&term='optional'
+
+```
+ {
+     "limit_value": 20,
+     "current_page": 1,
+     "total_pages": 2,
+     "total_objects": 30,
+     "optionals": [
+         {
+             "key": id,
+             "id": 61,
+             "code": "twyla",
+             "name_translate": {
+                 "es": "Twyla"
+             },
+             "input_type": "text",
+             "created_at": "11-12-2020",
+             "module": "position"
+         }]
+ }
+```
+
+- POST demographic/:module/optionals/create/:adjustable_id
+
+```
+ body:
+
+      {
+          'optional': {
+              'name_translate': {es: '', en: ''},
+              'input_type': types.sample(random: SecureRandom),
+              'min_value': '',
+              'max_value': '',
+              'values':  [
+                {'order_num': 1, 'value_translate': {es: '', en: ''} },
+                {'order_num': 2, 'value_translate': {es: '', en: ''} },
+                {'order_num': 3, 'value_translate': {es: '', en: ''} },
+              ],
+              code: 'optional_code
+          }
+      }
+
+ response 200:
+
+      {
+          'optional': {
+              'id': 0,
+              'name_translate': {es: '', en: ''},
+              'input_type': types.sample(random: SecureRandom),
+              'min_value': '',
+              'max_value': '',
+              'values':  [
+                {'id': 0, order_num': 1, 'value_translate': {es: '', en: ''} },
+                {'id': 0,'order_num': 2, 'value_translate': {es: '', en: ''} },
+                {'id': 0,'order_num': 3, 'value_translate': {es: '', en: ''} },
+              ],
+              'module': 'enterprise',
+          }
+      }
+
+  response 404 / 422:
+    { success: false, message: '' }
+```
+
+- DELETE demographic/:module/optionals/:optional_id/update/:adjustable_id
+
+```
+response 200:
+  { success: true }
+
+response 404 / 422:
+    { success: false, message: '' }
+```
+
+- GET demographic/:module/optionals/:optional_id/show/:adjustable_id
+
+```
+response 200:
+    {
+       'optional': {
+           'id': 0,
+           'name_translate': {es: '', en: ''},
+           'input_type': types.sample(random: SecureRandom),
+           'min_value': '',
+           'max_value': '',
+           'values':  [
+             {'id': 0, order_num': 1, 'value_translate': {es: '', en: ''} },
+             {'id': 0,'order_num': 2, 'value_translate': {es: '', en: ''} },
+             {'id': 0,'order_num': 3, 'value_translate': {es: '', en: ''} },
+           ]
+           'module': 'enterprise',
+       }
+    }
+
+response 404 / 422:
+    { success: false, message: '' }
+```
+
+- PUT demographic/:module/optionals/:optional_id/update/:adjustable_id
+
+```
+response 200:
+    {
+       'optional': {
+           'id': 0,
+           'name_translate': {es: '', en: ''},
+           'input_type': types.sample(random: SecureRandom),
+           'min_value': '',
+           'max_value': '',
+           'values':  [
+             {'id': 0, order_num': 1, 'value_translate': {es: '', en: ''} },
+             {'id': 0,'order_num': 2, 'value_translate': {es: '', en: ''} },
+             {'id': 0,'order_num': 3, 'value_translate': {es: '', en: ''} },
+           ],
+           'module': 'enterprise',
+       }
+    }
+
+- GET demographic/:module/userOptionals/list/:adjustable_id?user_token=
+    - Nota: puede enviar el id o el token del usuario en el parametro user_token
+
+```
+response 200:
+    {
+       optionals: [
+         {
+            id: optional.id,
+            code: optional.code,
+            name: optional.name,
+            input_type: optional.input_type,
+            selected_text: 'texto o valor campos libres',
+            values: [
+              {
+                id: value.id,
+                slug: value.slug,
+                code: value.code,
+                value: value.value,
+                selected: true / false
+              }, ...
+            ]
+         }, ...
+       ],
+    }
+
+response 404 / 422:
+    { success: false, message: '' }
+```
+
+- GET demographic/:module/optionals/filterList/:adjustable_id
+
+```
+response 200:
+    {
+       optionals: [
+         {
+            label: optional.name,
+            value: optional.id,
+            type: optional.input_type,
+            list: [
+              {
+                label: value.value
+                value: value.id,
+              }, ...
+            ]
+         }, ...
+       ]
+    }
+
+response 404 / 422:
+    { success: false, message: '' }
+```
+
+GET demographic/optionals/options
+
+```
+response 200:
+  {
+    "master":"Users","position":"Positions"
+  }
+
+```
+
+## Helpers
+
+### Tipos de opcionales
+
+| Tipo de Opcional | Descripción | Ejemplo      |
+| --- | --- |--------------|
+| list | Acepta cualquier formato, excepto vacío | "naranja"    |
+| text | Acepta cualquier formato, excepto vacío | "Hola mundo" |
+| number | Acepta cualquier número, excepto vacío | 42           |
+| date | Acepta estos formatos: %d-%m-%Y %d/%m/%Y %Y-%m-%d %Y/%m/%d, excepto vacío | "01-01-2022" |
+| bool | Acepta 0 y 1 | 1            |
+
+- crea los optionals
+
+```
+     file_headers = ["optional_lista#list", "optional_numerico#num", "optional_fecha#date"]
+
+     reference_id = id del modelo a buscar (survey.id, process.id, etc)
+     parent_module = referencia al producto (:performance, :engagement, etc)
+
+    ::Demographic::Helpers::Import::CreateOptionalsList.call(file_headers: file_headers,
+                                                             parent_module: :engagement,
+                                                             reference_id: survey.id)
+
+     caso ok: { success: true, message: 'Success!!!' }
+     caso error: { success: false, message: 'mensaje con el error' }
+```
+
+- crea valores de los opcionales
+
+```
+     optionals = { "optional_fecha#date": "1988-09-27",
+                   "optional_lista#list": "test 1",
+                   "optional_numerico#num": "1"}
+
+     reference_id = id del modelo a buscar (survey.id, process.id, etc)
+     parent_module = referencia al producto (:performance, :engagement, etc)
+
+     Demographic::Helpers::CreateOrUpdateValues.call(optionals:, parent_module:, reference_id:)
+
+     caso ok: { success: true, message: 'Success!!!', optionals: [{optional_id:'',optional_value_id: '', value: ''}] }
+     caso error: { success: false, message: 'mensaje con el error', optionals: [] }
+```
+
+- asignar valores en los usuarios, recibe un objeto user y un hash con los opcionales
+
+```
+     optionals = [
+       { optional_id, optional_value_id, value }, ...
+     ]
+
+     reference_id = id del modelo a buscar (survey.id, process.id, etc)
+     parent_module = referencia al producto (:performance, :engagement, etc)
+
+     Demographic::Helpers::CreateOrUpdateUserValues.call(user:, optionals:, parent_module:, reference_id:)
+
+     caso ok: { success: true, message: 'Success!!!', optionals: [{optional_id:'', optional_user_id: '',optional_value_id: ''}] }
+     caso error: { success: false, message: 'mensaje con el error', optionals: [] }
+```
+
+- `Demographic::Helpers::Import::Bulk::BuildOptionals`: Este servicio se encarga de la creacion de `OptionalValue` y
+  `UserOptional` de manera masiva a traves de la data extraida previamente por un excel de opcionales. El servicio
+  tambien se encarga de validar que los datos sean correctos y que no existan duplicados. En caso de no ser
+  correctos, se hace skip del item. Tambien se encarga de validar que los usuarios tengan relacion con el adjustable
+  para evitar modifcar usuarios pertenecientes a otros adjustables, esto siempre y cuando exista una relacion con
+  `users` desde ese adjustable, si no existe dicha relacion, se busca desde todos los usuarios, por lo que se
+  tendrian que validar los usarios antes de enviarlos a este servicio.
+  <br/>
+  <br/>
+    - Parametros: Para instanciar este servicio, se necesitará:
+        1. `parent_module`: Es el módulo en el que se esta ejecuntando el servicio, por ejemplo: `'performance'`,
+           `'engaament'`
+        2. `reference_id`: El id del modelo al que se le asignarán los opcionales. Este modelo cambiará según el
+           `parent_module`
+        3. `users_data`: Estructura que viene de los excels, por ejemplo:
+           ```ruby
+           [
+             {
+               "token": "hgsi1323",
+               "optional_fecha": "2023-05-31",
+               "optional_lista": "test 1",
+               "optional_numerico": "1"
+             },
+             {
+               "token": "hgsi1323",
+               "optional_fecha": "2023-05-31",
+               "optional_lista": "test 1",
+               "optional_numerico": "1"
+             }
+           ]
+           ```
+    - Respuesta: Siempre va a retornar una estructura de este tipo: `Struct.new(:success, :message)`
+      <br/>
+      <br/>
+        - Cuando no hay error:
+          ```ruby
+          #<struct  success=true, message="">
+          ```
+        - Cuando hay error:
+          ```ruby
+          #<struct  success=false, message=#<RuntimeError: Error message>>
+          ```
+    - Uso:
+      ```ruby
+      parent_module = 'performance'
+      reference_id = 1
+      users_data = [{ "token" => "7939511-0-150",
+                      "optional_lajuana" => "0_5709e2c973",
+                      "optional_elaine" => "1_d373ecf4fa",
+                      "optional_elsy" => "2_7199378ff3",
+                      "optional_sheilah" => "3_f92cee5eb2",
+                      "optional_monty" => "4_a6e231e928" },
+                    { "token" => "21579056-8-26",
+                      "optional_lajuana" => "0_cf64882943",
+                      "optional_elaine" => "1_fd86709937",
+                      "optional_elsy" => "2_739f413c42",
+                      "optional_sheilah" => "3_9a9853e0b9",
+                      "optional_monty" => "4_218f8ef272" }]
+
+      ::Demographic::Helpers::Import::Bulk::BuildOptionals.new(parent_module: parent_module,
+                                                               reference_id: reference_id,
+                                                               users_data: users_data).call
+      ```
+
+## Correr los test
+
+ejecutar
+
+```
+rspec ./spec/requests
+```
+
+## Publicando la gema:
+
+Es importante asegurarse que al momento de ejecutar el comando gem push, se realice modificando el tagueo con la version
+recien generada luego del gembuild
+
+ejecutar
+
+```
+gem build demographic.gemspec
+```
+
+el cual resultara en una salida del tipo:
+` Successfully built RubyGem
+Name: demographic
+Version: 0.1.3
+File: demographic-0.1.3.gem
+`
+La publicacion debe hacerse con la version indiciada en el paso anterior(0.1.1)
+
+```
+gem push --key github --host https://rubygems.pkg.github.com/Rankmi demographic-0.1.1.gem
+```
+
+## Contributing
+
+Contribution directions go here.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,22 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Demographic'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'

data/app/controllers/demographic/application_controller.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Demographic
+  class ApplicationController < ActionController::API
+    # protect_from_forgery with: :exception
+    before_action :has_config?
+
+    rescue_from NoMethodError, with: :not_method_error
+    rescue_from ActiveRecord::RecordNotFound, with: :not_found
+    rescue_from ActiveRecord::RecordInvalid, with: :record_invalid
+    rescue_from ActiveRecord::RecordNotUnique, with: :not_found
+
+    private
+
+    def has_config?
+      Demographic.attributes.each do |attr|
+        raise NoMethodError, "init Demographic.#{attr} error!!!" unless Demographic.send(attr).present?
+      end
+
+      i18n_setup
+    end
+
+    def not_method_error(invalid)
+      render json: { success: false, message: invalid.to_s }, status: 404
+    end
+
+    def not_found(invalid)
+      render json: { success: false, message: invalid.to_s }, status: :not_found
+    end
+
+    def record_invalid(invalid)
+      render json: { success: false, message: invalid.record.errors.messages }, status: :unprocessable_entity
+    end
+
+    def adjustable
+      parent_model = Demographic.parent_model[params[:module]&.to_sym]
+
+      return if parent_model.blank?
+
+      model_class = parent_model.to_s.capitalize.classify.constantize
+
+      if params[:adjustable_id] == "0"
+        #non-persisted object to avoid errors downstream
+        return @adjustable = model_class.new(id: 0)
+      end
+
+      @adjustable = model_class.find_by!(id: params[:adjustable_id])
+    end
+
+    def optional
+      @optional ||= Optional.find!(params[:optional_id])
+    end
+
+    def user
+      return @user if @user.present?
+
+      if params[:user_token].present?
+        raise ActiveRecord::RecordNotFound, 'User not found' unless User.new.attributes.key?('token')
+
+        @user = User.find_by!(token: params[:user_token])
+        return @user
+      end
+
+      @user = User.find(params[:user_id])
+    end
+
+    def optional_adjustable
+      @optional_adjustable ||= params[:optional_token].present? ? Optional.find_by!(token: params[:optional_token]) : Optional.find_by!(id: params[:optional_id])
+    end
+
+    def i18n_setup
+      return I18n.locale unless request.headers['Authorization'].present?
+
+      token = request.headers['Authorization'].split(' ')[1]
+      decode = JWT.decode(token, Demographic.jwt_password, true, { algorithm:  'HS256'} )
+      return I18n.locale unless decode.present?
+      RequestStore.store[:jwt] = decode[0]
+      I18n.locale = decode[0]['lang']&.to_sym || :es
+    rescue JWT::DecodeError, JWT::ExpiredSignature, StandardError
+      I18n.locale
+    end
+
+    def per_page
+      @per_page ||= params[:per_page].present? ? params[:per_page].to_i : Demographic.per_page.present? ? Demographic.per_page.to_i : 20
+    end
+  end
+end

data/app/controllers/demographic/custom_parameter_values_controller.rb

@@ -0,0 +1,25 @@
+require_dependency "demographic/application_controller"
+
+module Demographic
+  class CustomParameterValuesController < ApplicationController
+    # record passed should have a token uuid!
+    # GET demographic/:module/customParameterValues/index/:adjustable_id?record_token=
+    def index
+      render json: Demographic::CustomParameterValues::Index.new(record: record, adjustable: adjustable, page: params[:page], per_page: per_page).call, status: :ok
+    end
+
+    def create
+      service = Demographic::CustomParameterValues::Create.new(record: record, adjustable: adjustable, params: create_params)
+      render json: service.call, status: :created
+    end
+
+    private
+    def create_params
+      params.require(:custom_parameter_values).permit(:optional_id, :value)
+    end
+
+    def record
+      @record = adjustable.class.find_by_token!(params[:record_token])
+    end
+  end
+end

data/app/controllers/demographic/optionals_bulk_controller.rb

@@ -0,0 +1,33 @@
+require_dependency "demographic/application_controller"
+
+module Demographic
+  class OptionalsBulkController < ApplicationController
+    # POST /:module/optionals_bulk/:adjustable_id/create
+    def create
+      response = bulk_create_service.call
+
+      render json: response.data, status: response.status
+    end
+
+    # GET /:module/optionals_bulk/:adjustable_id/create_template
+    def create_template
+      xlsx_file = template_service.call
+
+      send_file xlsx_file.path, filename: template_class::FILE_NAME, disposition: 'attachment'
+    end
+
+    private
+
+    def bulk_create_service
+      @bulk_create_service ||= ::Demographic::Optionals::BulkCreate.new(file: params[:file], adjustable: adjustable)
+    end
+
+    def template_service
+      @template_service ||= template_class.new
+    end
+
+    def template_class
+      @template_class ||= Import::Templates::CreateOptionals
+    end
+  end
+end