pg_rails 7.0.1 → 7.0.2

data/app/controllers/pg_rails/application_controller.rb

@@ -1,316 +0,0 @@
-# frozen_string_literal: true
-
-module PgRails
-  class ApplicationController < ActionController::Base
-    include ApplicationHelper
-    include Pundit::Authorization
-    # include SmartListing::Helper::ControllerExtensions
-    # helper  SmartListing::Helper
-    include PrintHelper
-    include PostgresHelper
-
-    rescue_from PrintHelper::FechaInvalidaError, with: :fecha_invalida
-    rescue_from Pundit::NotAuthorizedError, with: :not_authorized
-
-    layout :setear_layout
-
-    def self.inherited(klass)
-      super
-      # incluyo los helpers de /app/helpers de la main_app
-      klass.helper :all
-    end
-
-    helper_method :mobile_device?
-
-    def mobile_device?
-      request.user_agent =~ /Mobile|webOS/
-    end
-
-    helper_method :any_filter?
-
-    def any_filter?
-      params.keys.reject { |a| a.in? ["controller", "action", "page", "page_size", "order_by", "order_direction"] }.any?
-    end
-
-
-    helper_method :current_page_size
-
-    def current_page_size
-      if params[:page_size].present?
-        session[:page_size] = params[:page_size]
-        params[:page_size].to_i
-      else
-        default_page_size
-      end
-    end
-
-    def default_page_size
-      session[:page_size].present? ? session[:page_size].to_i : 10
-    end
-
-
-    protected
-
-      def pg_respond_update(object: nil, extra_js: nil)
-        object ||= instancia_modelo
-        respond_to do |format|
-          if (@saved = object.save)
-            format.html do
-              redirect_to object.decorate.target_object
-            end
-            format.json { render json: object.decorate }
-          else
-            format.turbo_stream do
-              flash.now[:error] = object.errors.full_messages.join(', ')
-              render turbo_stream: render_turbo_stream_flash_messages
-            end
-            format.html { render :edit, status: :unprocessable_entity }
-            format.json { render json: object.errors, status: :unprocessable_entity }
-          end
-          format.js do
-            render '_cerrar_modal', locals: {
-              contenido: 'form', extra_js: ['modal_ajax_form', extra_js]
-            }
-          end
-        end
-      end
-
-      def pg_respond_create(object: nil, extra_js: nil)
-        object ||= instancia_modelo
-        respond_to do |format|
-          if (@saved = object.save)
-            format.html do
-              if params[:save_and_next] == 'true'
-                new_path = url_for(@clase_modelo) + "/new"
-                redirect_to new_path, notice: "#{@clase_modelo.nombre_singular} creado."
-              else
-                redirect_to object.decorate.target_object
-              end
-            end
-            format.json { render json: object.decorate }
-          else
-            format.turbo_stream do
-              flash.now[:error] = object.errors.full_messages.join(', ')
-              render turbo_stream: render_turbo_stream_flash_messages
-            end
-            format.html { render :new, status: :unprocessable_entity }
-            format.json { render json: object.errors.full_messages, status: :unprocessable_entity }
-          end
-          format.js do
-            render '_cerrar_modal', locals: {
-              contenido: 'form', extra_js: ['modal_ajax_form', extra_js]
-            }
-          end
-        end
-      end
-
-      def pg_respond_index(collection)
-        respond_to do |format|
-          format.json { render json: collection }
-          format.js { render_smart_listing }
-          format.html { render_smart_listing }
-          format.xlsx do
-            render xlsx: 'download',
-                   filename: "#{@clase_modelo.nombre_plural.gsub(' ', '-').downcase}" \
-                             "-#{Time.zone.now.strftime("%Y-%m-%d-%H.%M.%S")}.xlsx"
-          end
-        end
-      end
-
-      def pg_respond_show(object = nil)
-        respond_to do |format|
-          format.json { render json: object || instancia_modelo }
-          format.html
-        end
-      end
-
-      def pg_respond_destroy(model, redirect_url = nil)
-        if destroy_model(model)
-          respond_to do |format|
-            format.html do
-              if redirect_url.present?
-                redirect_to redirect_url, notice: 'Elemento borrado.', status: 303
-              else
-                redirect_back(fallback_location: root_path, notice: 'Elemento borrado.', status: 303)
-              end
-            end
-            format.json { head :no_content }
-          end
-        else
-          respond_to do |format|
-            format.html do
-              if model.respond_to?(:associated_elements) && model.associated_elements.present?
-                @model = model
-                render destroy_error_details_view
-              else
-                flash[:error] = @error_message
-                # if redirect_url.present?
-                #   redirect_to redirect_url
-                # else
-                redirect_back(fallback_location: root_path, status: 303)
-                # end
-              end
-            end
-            format.json { render json: { error: @error_message }, status: :unprocessable_entity }
-          end
-        end
-      end
-
-      # destroy_and_respond DEPRECADO
-      alias_method :destroy_and_respond, :pg_respond_destroy
-
-      def destroy_error_details_view
-        'destroy_error_details'
-      end
-
-      def destroy_model(model)
-        @error_message = 'No se pudo eliminar el registro'
-        begin
-          destroy_method = model.respond_to?(:discard) ? :discard : :destroy
-          return true if model.send(destroy_method)
-
-          @error_message = model.errors.full_messages.join(', ')
-          false
-        rescue ActiveRecord::InvalidForeignKey => e
-          # class_name = /from table \"(?<table_name>[\p{L}_]*)\"/.match(e.message)[:table_name].singularize.camelcase
-          # # pk_id = /from table \"(?<pk_id>[\p{L}_]*)\"/.match(e.message)[:pk_id].singularize.camelcase
-          # clazz = Object.const_get class_name
-          # objects = clazz.where(model.class.table_name.singularize => model)
-          model_name = t("activerecord.models.#{model.class.name.underscore}")
-          @error_message = "#{model_name} no se pudo borrar porque tiene elementos asociados."
-          logger.debug e.message
-        end
-        false
-      end
-
-      def render_smart_listing
-        raise 'implementar en subclase'
-      end
-
-      def buscar_instancia
-        if Object.const_defined?('FriendlyId') && @clase_modelo.is_a?(FriendlyId)
-          @clase_modelo.friendly.find(params[:id])
-        else
-          @clase_modelo.find(params[:id])
-        end
-      end
-
-      def set_instancia_modelo
-        if action_name.in? %w[new create]
-          self.instancia_modelo = @clase_modelo.new(modelo_params)
-        else
-          self.instancia_modelo = buscar_instancia
-
-          instancia_modelo.assign_attributes(modelo_params) if action_name.in? %w[update]
-        end
-
-        instancia_modelo.current_user = send(PgRails.configuracion.current_user_method)
-
-        authorize instancia_modelo
-
-        self.instancia_modelo = instancia_modelo.decorate if action_name.in? %w[show edit new]
-      end
-
-      def instancia_modelo=(val)
-        instance_variable_set("@#{nombre_modelo}".to_sym, val)
-      end
-
-      def instancia_modelo
-        instance_variable_get("@#{nombre_modelo}".to_sym)
-      end
-
-      def modelo_params
-        if action_name == 'new'
-          params.permit(atributos_permitidos)
-        else
-          params.require(nombre_modelo).permit(atributos_permitidos)
-        end
-      end
-
-      def nombre_modelo
-        @clase_modelo.name.underscore
-      end
-
-      def default_url_options(options = {})
-        if Rails.env.production?
-          options.merge(protocol: 'https')
-        else
-          options
-        end
-      end
-
-      def setear_layout
-        if params[:sin_layout] == 'true'
-          false
-        else
-          'application'
-        end
-      end
-
-      def clase_modelo
-        # agarro la variable o intento con el nombre del controller
-        @clase_modelo ||= self.class.name.singularize.gsub('Controller', '').constantize
-      end
-
-      def filtros_y_policy(campos)
-        @filtros = PgRails::FiltrosBuilder.new(
-          self, clase_modelo, campos
-        )
-        scope = policy_scope(clase_modelo)
-
-        @filtros.filtrar(scope)
-      end
-
-      def do_sort(scope, field, direction)
-        unless scope.model.column_names.include? field.to_s
-          return scope
-        end
-        scope = scope.order(field => direction)
-        instance_variable_set(:"@field", field)
-        instance_variable_set(:"@direction", direction)
-        scope
-      rescue ArgumentError => e
-        Utils::Logueador.warning(e.to_s)
-        scope
-      end
-
-      def sort_collection(scope, options = {})
-        if params[:order_by].present?
-          field = params[:order_by]
-          direction = params[:order_direction]
-          do_sort(scope, field, direction)
-        elsif options[:default].present?
-          field = options[:default].first[0]
-          direction = options[:default].first[1]
-          do_sort(scope, field, direction)
-        else
-          scope
-        end
-      end
-
-      def fecha_invalida
-        respond_to do |format|
-          format.json do
-            render json: { error: 'Formato de fecha inválido' }, status: :unprocessable_entity
-          end
-          format.js { render inline: 'showToast("error", "Formato de fecha inválido")' }
-          format.html { go_back('Formato de fecha inválido') }
-        end
-      end
-
-      def not_authorized
-        respond_to do |format|
-          format.json do
-            render json: { error: 'Not authorized' }, status: :unprocessable_entity
-          end
-          # format.js { render inline: 'showToast("error", "Formato de fecha inválido")' }
-          format.html { go_back('Not authorized') }
-        end
-      end
-
-      def go_back(message)
-        flash[:error] = message
-        redirect_back fallback_location: root_path
-      end
-  end
-end

data/app/controllers/pg_rails/editar_en_lugar_controller.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module PgRails
-  class EditarEnLugarController < ::ApplicationController
-    def actualizar
-      key_modelo = params.keys[1]
-      modelo = Kernel.const_get(key_modelo)
-      objeto = modelo.find params[:id]
-      authorize objeto, :editar_en_lugar?
-      object_params = request.parameters[key_modelo]
-      objeto.current_user = current_user
-      objeto.update(object_params)
-      respond_with_bip(objeto, param: key_modelo)
-    rescue Pundit::NotAuthorizedError
-      objeto.errors.add(:base, 'no autorizado')
-      respond_with_bip(objeto)
-    rescue Pundit::Error => e
-      Rollbar.error(e)
-      logger.error(e.message)
-      objeto.errors.add(:base, e.message)
-      respond_with_bip(objeto)
-    end
-  end
-end

data/app/helpers/pg_rails/editar_en_lugar_helper.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-module PgRails
-  module EditarEnLugarHelper
-    def editar_en_lugar(objeto, atributo, tipo = :input, url = nil, collection = nil)
-      url = pg_rails.editar_en_lugar_path(objeto) if url.nil?
-      if tipo == :checkbox
-        best_in_place objeto, atributo, url: url, as: tipo, collection: %w[No Si],
-                                        param: objeto.model_name.name
-      elsif tipo == :date
-        best_in_place objeto, atributo, url: url, as: tipo, display_with: lambda { |v|
-                                                                            dmy(v)
-                                                                          }, param: objeto.model_name.name
-        # best_in_place objeto, atributo, url: editar_en_lugarurl(objeto), as: tipo, display_with: lambda { |v| dmy(v) }, class: 'datefield'
-      elsif tipo == :textarea
-        funcion = lambda do |valor|
-          return unless valor.present?
-
-          valor.gsub!("\r\n", '<br>')
-          valor.gsub!("\n", '<br>')
-          valor.html_safe
-        end
-        best_in_place objeto, atributo, url: url, as: tipo, display_with: funcion,
-                                        param: objeto.model_name.name
-      elsif tipo == :select && collection.present?
-        best_in_place objeto, atributo, url: url, as: tipo, collection: collection,
-                                        param: objeto.model_name.name, value: objeto.send(atributo), inner_class: 'form-control'
-      else
-        best_in_place objeto, atributo, url: url, as: tipo, param: objeto.model_name.name
-      end
-    end
-
-    # Versión mejorada de editar_en_lugar, pero le pongo v2 por retrocompatibilidad
-    # La diferencia es que recibe un hash "options" y se le pueden agregar cualquiera de las options
-    # que admite best_in_place
-    def editar_en_lugar_v2(objeto, atributo, tipo = :input, options = {})
-      options[:url] = pg_rails.editar_en_lugar_path(objeto) if options[:url].nil?
-      options[:as] = tipo
-      options[:param] = objeto.model_name.name
-      options[:inner_class] = 'form-control' if options[:inner_class].nil?
-      options[:class] = 'editar_en_lugar_v2'
-      options[:html_attrs] = { autocomplete: :off }
-      # url = pg_rails.editar_en_lugar_path(objeto) if url.nil?
-      if tipo == :checkbox
-        options[:collection] = %w[No Si]
-
-      elsif tipo == :date
-        options[:display_with] = ->(v) { dmy(v) } if options[:display_with].nil?
-
-      elsif tipo == :textarea
-        funcion = lambda do |valor|
-          return unless valor.present?
-
-          valor.gsub!("\r\n", '<br>')
-          valor.gsub!("\n", '<br>')
-          valor.html_safe
-        end
-        options[:display_with] = funcion if options[:display_with].nil?
-
-      elsif tipo == :select && options[:collection].present?
-        options[:value] = objeto.send(atributo)
-      end
-
-      best_in_place objeto, atributo, options
-    end
-
-    # TODO: mover a otro helper
-    def encabezado(campo, options = {})
-      clase = (options[:clase] || @clase_modelo)
-      if options[:ordenable]
-        field = controller.instance_variable_get(:"@field")
-        direction = controller.instance_variable_get(:"@direction")
-        uri = URI.parse(request.url)
-        if uri.query.present?
-          cgi = CGI.parse(uri.query)
-        else
-          cgi = {}
-        end
-        cgi["order_by"] = campo
-        cgi["order_direction"] =
-          if field.to_s == campo.to_s && direction.to_s == 'asc'
-            'desc'
-          else
-            'asc'
-          end
-
-        if field.to_s == campo.to_s
-          symbol =
-            if direction.to_s == 'asc'
-              '<i class="bi bi-sort-down-alt" />'
-            elsif direction.to_s == 'desc'
-              '<i class="bi bi-sort-up" />'
-            end
-        else
-          symbol = ''
-        end
-
-        uri.query = cgi.map {|a,b| [a, (b.length == 1 ? b.first : b)]}.to_h.to_query
-
-        link_to(clase.human_attribute_name(campo), uri.to_s) + " #{symbol}".html_safe
-      else
-        clase.human_attribute_name(campo)
-      end
-    end
-  end
-end

data/app/helpers/pg_rails/form_helper.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module PgRails
-  module FormHelper
-    def pg_form_for(object, *args, &block)
-      options = args.extract_options!
-
-      options[:builder] = PgFormBuilder
-      options[:html] ||= {}
-      options[:html][:class] = if options[:html].key?(:class)
-                                 ['pg-form', options[:html][:class]].compact
-                               else
-                                 'pg-form'
-                               end
-
-      simple_form_for(object, *(args << options), &block)
-    end
-
-    def url_change_format(url)
-      uri = URI.parse(url)
-      uri.path = "#{uri.path}.xlsx"
-      uri.to_s
-    end
-  end
-end

data/app/inputs/pg_rails/asociacion_creable_input.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module PgRails
-  class AsociacionCreableInput < SimpleForm::Inputs::StringInput
-    include ActionView::Helpers::FormTagHelper
-
-    def boton(wrapper_options = {})
-      if PgRails.config.bootstrap_version >= 4
-        button_tag('', wrapper_options)
-      else
-        button_tag('<span class="caret">'.html_safe, wrapper_options)
-      end
-    end
-
-    def hidden_input(wrapper_options = {})
-      merged_input_options = merge_wrapper_options(input_html_options, wrapper_options)
-      merged_input_options = merge_wrapper_options(merged_input_options, { class: 'oculto' })
-      @builder.text_field(attribute_name, merged_input_options)
-    end
-
-    def input(wrapper_options = nil)
-      unless string?
-        input_html_classes.unshift('string')
-        input_html_options[:type] ||= input_type if html5?
-      end
-
-      merged_input_options = merge_wrapper_options(input_html_options, wrapper_options)
-      merged_input_options = merge_wrapper_options(merged_input_options, { class: 'keep-disabled' })
-
-      text_field_tag(nil, object.send(reflection.name).to_s, merged_input_options)
-    end
-
-    def seleccionar_asociado(wrapper_options = {})
-      icon = content_tag :span, nil, class: 'fa fa-hand-pointer'
-      merged_input_options = merge_wrapper_options(wrapper_options,
-                                                   { class: 'seleccionar_asociado dropdown-item', href: 'javascript:void(0)',
-                                                     data: { url: options[:url_seleccionar] } })
-      anchor = content_tag :a, "#{icon} Seleccionar".html_safe, merged_input_options
-      if PgRails.config.bootstrap_version >= 4
-        anchor
-      else
-        "<li>#{anchor}</li>".html_safe
-      end
-    end
-
-    def crear_asociado(wrapper_options = {})
-      icon = content_tag :span, nil, class: 'fa fa-plus-square'
-      merged_input_options = merge_wrapper_options(wrapper_options,
-                                                   { class: 'crear_asociado dropdown-item', href: 'javascript:void(0)',
-                                                     data: { url: options[:url_crear] } })
-      anchor = content_tag :a, "#{icon} Crear".html_safe, merged_input_options
-      if PgRails.config.bootstrap_version >= 4
-        anchor
-      else
-        "<li>#{anchor}</li>".html_safe
-      end
-    end
-
-    def borrar_seleccion(wrapper_options = {})
-      icon = content_tag :span, nil, class: 'fa fa-trash'
-      merged_input_options = merge_wrapper_options(wrapper_options,
-                                                   { class: 'borrar_seleccion dropdown-item',
-                                                     href: 'javascript:void(0)' })
-      anchor = content_tag :a, "#{icon} Borrar selección".html_safe, merged_input_options
-      if PgRails.config.bootstrap_version >= 4
-        anchor
-      else
-        "<li>#{anchor}</li>".html_safe
-      end
-    end
-  end
-end

data/app/inputs/pg_rails/fecha_input.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module PgRails
-  class FechaInput < SimpleForm::Inputs::StringInput
-    def input(wrapper_options = nil)
-      # esto es porque si no Rails llama a value_before_type_cast
-      if object.is_a? Draper::Decorator
-        # Salteo el decorator para que me tome la fecha con formato inglés
-        value = object.object.public_send(attribute_name)
-      else
-        value = object.public_send(attribute_name)
-      end
-      @input_type = 'date'
-
-      options = merge_wrapper_options({ value: value, class: '', autocomplete: 'off' },
-                                      wrapper_options)
-      super(options)
-    end
-  end
-end

data/app/inputs/pg_rails/selects_dependientes_input.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module PgRails
-  class SelectsDependientesInput < SimpleForm::Inputs::CollectionSelectInput
-    include ActionView::Helpers::FormOptionsHelper
-
-    # TODO
-  end
-end

data/app/lib/pg_form_builder.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-# TODO: fix hackeo
-# class PgFormBuilder < NestedForm::SimpleBuilder
-class PgFormBuilder < SimpleForm::FormBuilder
-  def mensajes_de_error
-    return unless object.errors.present?
-
-    errors = object.errors.full_messages.map { |m| "<li>#{m}</li>" }.join
-    "<div class='alert alert-danger'>#{errors}</div>".html_safe
-  end
-
-  map_type :date, to: PgRails::FechaInput
-  # map_type :datetime, to: PgRails::FechaInput
-
-  def asociacion_creable(atributo, url_seleccionar, url_crear, options = {})
-    options[:as] = 'pg_rails/asociacion_creable'
-    options[:wrapper] = :asociacion_creable
-    options[:url_seleccionar] = url_seleccionar
-    options[:url_crear] = url_crear
-    options[:wrapper_html] = { class: 'completado' } if object.send(atributo).present?
-    association atributo, options
-  end
-
-  def submit_button(*args, &block)
-    options = args.extract_options!.dup
-    options[:class] = ['btn-primary', options[:class]].compact
-    args << options
-    send(:submit, *args, &block)
-  end
-end

data/app/models/pg_rails/application_record.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module PgRails
-  class ApplicationRecord < ActiveRecord::Base
-    extend Enumerize
-    include PrintHelper
-    include PostgresHelper
-
-    self.abstract_class = true
-
-    attr_accessor :current_user
-
-    before_create :setear_creado_y_actualizado_por
-    before_update :setear_actualizado_por
-
-    def self.nombre_plural
-      model_name.human(count: 2)
-    end
-
-    def self.nombre_singular
-      model_name.human(count: 1)
-    end
-
-    def to_s
-      %i[nombre name].each do |campo|
-        return send(campo) if try(campo).present?
-      end
-      if id.present?
-        "#{self.class.nombre_singular} ##{id}"
-      else
-        super
-      end
-    end
-
-    private
-
-      def setear_creado_y_actualizado_por
-        setear_si_existe :creado_por, current_user
-        setear_si_existe :actualizado_por, current_user
-      end
-
-      def setear_actualizado_por
-        setear_si_existe :actualizado_por, current_user
-      end
-
-      def setear_si_existe(campo, valor)
-        metodo = "#{campo}="
-        send(metodo, valor) if respond_to?(metodo) && valor.present?
-      end
-  end
-end

data/app/views/application/_abrir_modal.js.erb

@@ -1,14 +0,0 @@
-$(function() {
-  var modal = $('<%= j render contenido %>').modal();
-
-  <% if defined? extra_js %>
-    <% [extra_js].flatten.each do |partial| %>
-      <%= render partial: partial %>
-    <% end %>
-  <% end %>
-  $(modal).on('hidden.bs.modal', function () {
-    $(this).data('bs.modal', null);
-    $(this).remove();
-  });
-  PgRails.bindear('.modal')
-});

data/app/views/application/_actualizar_smart_listing.html.slim

@@ -1,3 +0,0 @@
-= smart_listing_update(smart_listing_key)
-
-| PgRails.bindear('##{smart_listing_key}');

data/app/views/application/_cerrar_modal.js.erb

@@ -1,8 +0,0 @@
-$(function() {
-  $('.modal').modal('hide');
-  <% if @saved %>
-    $('.smart-listing').smart_listing().reload();
-  <% else %>
-    <%= render partial: 'abrir_modal', locals: { contenido: contenido, extra_js: extra_js } %>
-  <% end %>
-});