pg_rails 7.0.1

data/app/assets/stylesheets/pg_rails/pg_chosen.scss

@@ -0,0 +1,29 @@
+
+body .chosen-container-active.chosen-with-drop .chosen-single {
+  background: none;
+}
+body .chosen-container-single .chosen-single {
+  padding-top: 2px;
+  border: 1px solid #e5e6e7;
+  border: 1px solid #ced4da;
+  background: none;
+  box-shadow: none;
+}
+
+.chosen-container.chosen-with-drop .chosen-drop {
+  // margin-top: 0px;
+}
+.chosen-container-single a.chosen-single {
+  height: 36px;
+  line-height: 30px;
+}
+.chosen-container-single .chosen-single div {
+    padding-top: 5px;
+}
+.chosen-container-single .chosen-drop {
+  min-width: 190px;
+  margin-top: -3px;
+}
+.chosen-container.chosen-container-single .chosen-single {
+  border-radius: 4px;
+}

data/app/assets/stylesheets/pg_rails/pg_rails.scss

@@ -0,0 +1,199 @@
+// @import 'pg_rails/pg_chosen';
+
+// Google Maps Places API
+// Para que funcione en los modales
+.pac-container {
+  z-index: 1051 !important;
+}
+
+.simple_form {
+  .ocultar {
+    input, select, textarea {
+      display: none;
+    }
+  }
+}
+.form-group.asociacion_creable {
+  input.oculto {
+    visibility: hidden;
+    position: absolute;
+  }
+
+  &:not(.completado) {
+    .borrar_seleccion {
+      display: none;
+    }
+  }
+}
+// oculto la columna de actions
+.modal-seleccionar-asociado .listado th:last-child,
+  .modal-seleccionar-asociado .listado td:last-child {
+  display: none;
+}
+.modal-seleccionar-asociado .listado {
+  td {
+    cursor: pointer;
+  }
+}
+.modal-seleccionar-asociado .listado tr:hover {
+  background-color: lightgrey;
+}
+
+.listado {
+  td, th {
+    padding: 0.25rem 1rem;
+  }
+}
+.listado .btn-xs {
+  margin-right: 4px;
+}
+.listado .btn-sm {
+  min-width: 25px;
+  height: 25px;
+  padding: 1px;
+  margin-right: 4px;
+}
+
+.form-group.producto {
+  .form-control.selectize-control {
+    height: 36px;
+    // width: 200px;
+  }
+  .chosen-container {
+    // max-width: 200px;
+  }
+}
+// hay que agregar la clase pg-form a los forms que queremos afectar
+.pg-form {
+  max-width: 1000px;
+
+  .form-control {
+    font-size: 13px;
+  }
+
+  .form-control.selectize-control {
+    height: 36px;
+  }
+  .form-group {
+    /*transition: height .5s ease 0s;*/
+    transition: opacity .3s ease 0s;
+    opacity: 1;
+    max-width: 300px;
+    margin-bottom: 6px;
+
+    &.datetime {
+      max-width: 600px;
+    }
+
+    &.dependent_fields {
+      max-width: 600px;
+    }
+
+    &.ocultar {
+      /*height: 0px;*/
+      opacity: 0;
+    }
+  }
+
+  .form-control.error {
+    border: 1px solid red;
+  }
+
+  label.error {
+    color: red;
+  }
+}
+
+.filter {
+  display: inline-block;
+  // margin-right: 10px;
+  // margin-bottom: 10px;
+  vertical-align: top;
+  min-width: 200px;
+
+  .input-group {
+    width: 230px;
+  }
+}
+
+.dependent_fields select {
+  // width: calc(99% / 2);
+  // width: 500px;
+  display: block;
+  margin-bottom: 15px;
+}
+
+.dependent_fields label {
+  display: block;
+  text-align: left!important;
+}
+
+.dependent_fields {
+  // max-width: 400px;
+}
+
+.btn.exportar:hover {
+  cursor: pointer;
+}
+
+
+// Editar en lugar
+.editar_en_lugar_v2 {
+    cursor: pointer;
+    text-decoration: underline dotted lightgrey;
+}
+.editar_en_lugar_v2::after {
+  padding-left: 13px;
+  content: '✎';
+  opacity: 0;
+}
+.editar_en_lugar_v2:hover::after {
+  opacity: 1;
+}
+
+.editar_en_lugar_v2 form {
+  display: inline-block!important;
+}
+.editar_en_lugar_v2 input {
+  display: inline-block;
+}
+.editar_en_lugar_v2 input[type=submit] {
+  margin-left: 10px;
+}
+
+.pg_ajax_link {
+  cursor: pointer;
+  color: #337ab7;
+  text-decoration: none;
+}
+.pg_ajax_link:hover {
+  color: #23527c;
+  text-decoration: underline;
+}
+
+.pg-max-width-xxs {
+  max-width: 350px;
+}
+.pg-max-width-xs {
+  max-width: 450px;
+}
+.pg-max-width-sm {
+  max-width: 600px;
+}
+.pg-max-width {
+  max-width: 800px;
+}
+.pg-max-width-lg {
+  max-width: 1000px;
+}
+.pg-max-width-xl {
+  max-width: 1200px;
+}
+
+.pg-revert-width {
+  width: revert;
+}
+
+.pg-form input.date {
+  max-width: 140px;
+}

data/app/assets/stylesheets/pg_rails_b3.scss

@@ -0,0 +1,10 @@
+// estilos para Bootstrap 3
+
+@import 'pg_rails/pg_rails';
+
+.pg-form {
+  .dropdown-menu > li > a {
+    padding: 6px 20px;
+    font-size: 14px;
+  }
+}

data/app/assets/stylesheets/pg_rails_b4.scss

@@ -0,0 +1,12 @@
+// estilos para Bootstrap 4
+
+@import "bootstrap-4.4.1/bootstrap";
+@import 'pg_rails/pg_rails';
+
+.tooltip { pointer-events: none; }
+
+.form-group.asociacion_creable {
+  button {
+    font-size: 11px;
+  }
+}

data/app/assets/stylesheets/pg_rails_b5.scss

@@ -0,0 +1 @@
+@import 'pg_rails/pg_rails';

data/app/controllers/pg_rails/application_controller.rb

@@ -0,0 +1,316 @@
+# 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

@@ -0,0 +1,24 @@
+# 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/decorators/pg_rails/base_decorator.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module PgRails
+  class BaseDecorator < Draper::Decorator
+    include ActionView::Helpers
+    include PrintHelper
+    include FormHelper
+    include Pundit::Authorization
+
+    attr_accessor :output_buffer
+
+    delegate_all
+
+    def as_json(_options = {})
+      object.as_json.tap { |o| o[:to_s] = to_s }
+    end
+
+    # def method_missing(method_name, *args, &block) # rubocop:disable Style/MissingRespondToMissing
+    #   valor = object.attributes[method_name.to_s]
+    #   return super unless valor.present?
+
+    #   if valor.instance_of?(Date)
+    #     dmy(valor)
+    #   # elsif valor.class == ActiveSupport::TimeWithZone
+    #   #   dmy_time(valor)
+    #   else
+    #     super
+    #   end
+    # end
+
+    def destroy_link(message = '¿Estás seguro?')
+      return unless Pundit.policy!(helpers.send(PgRails.configuracion.current_user_method), object).destroy?
+
+      helpers.content_tag :span, rel: :tooltip, title: 'Eliminar' do
+        helpers.link_to object_url, data: { 'turbo-confirm': message, 'turbo-method': :delete },
+                                    class: "btn #{_config.clase_botones_chicos} btn-#{_config.boton_destroy}" do
+          helpers.content_tag :span, nil, class: clase_icono(_config.icono_destroy).to_s
+        end
+      end
+    end
+
+    def edit_link(texto = '')
+      return unless Pundit.policy!(helpers.send(PgRails.configuracion.current_user_method), object).edit?
+
+      helpers.content_tag :span, rel: :tooltip, title: 'Editar' do
+        helpers.link_to edit_object_url, data: { turbo_frame: :main },
+                        class: "btn #{_config.clase_botones_chicos} btn-#{_config.boton_edit}" do
+          helpers.content_tag(:span, nil, class: clase_icono(_config.icono_edit).to_s) + texto
+        end
+      end
+    end
+
+    def show_link(texto = '')
+      return unless Pundit.policy!(helpers.send(PgRails.configuracion.current_user_method), object).show?
+
+      helpers.content_tag :span, rel: :tooltip, title: 'Ver' do
+        helpers.link_to object_url, data: { turbo_frame: :main },
+                        class: "btn #{_config.clase_botones_chicos} btn-#{_config.boton_show}" do
+          helpers.content_tag(:span, nil, class: clase_icono(_config.icono_show).to_s) + texto
+        end
+      end
+    end
+
+    def export_link(url, texto = '')
+      return unless Pundit.policy!(helpers.send(PgRails.configuracion.current_user_method), object).export?
+
+      helpers.content_tag :span, rel: :tooltip, title: 'Exportar' do
+        helpers.content_tag :a, target: '_blank',
+                            class: "btn #{_config.clase_botones_chicos} btn-#{_config.boton_export}", href: url_change_format(url) do
+          "#{helpers.content_tag(:span, nil, class: clase_icono('file-earmark-excel-fill'))} #{texto}".html_safe
+        end
+      end
+    end
+
+    def new_link(options = {})
+      return unless Pundit.policy!(helpers.send(PgRails.configuracion.current_user_method), object).new?
+
+      helpers.content_tag :span, rel: :tooltip, title: 'Crear' do
+        helpers.link_to new_object_url, class: "btn #{_config.clase_botones_chicos} btn-primary", remote: options[:remote] do
+          helpers.content_tag(:span, nil,
+                              class: clase_icono('plus').to_s) + "<span class='d-none d-sm-inline'> Crear #{object.class.nombre_singular.downcase}</span>".html_safe
+        end
+      end
+    end
+
+    def edit_object_url
+      helpers.url_for([:edit, target_object].flatten)
+    end
+
+    def new_object_url
+      "#{helpers.url_for(target_index)}/new"
+    end
+
+    def object_url
+      helpers.url_for(target_object)
+    end
+
+    def target_object
+      default_module.present? ? [default_module, object] : object
+    end
+
+    def target_index
+      default_module.present? ? [default_module, object.class] : object.class
+    end
+
+    def default_module
+      nil
+    end
+
+    private
+
+      def _config
+        PgRails.configuracion
+      end
+
+      def clase_icono(icono)
+        "#{_config.sistema_iconos} #{_config.sistema_iconos}-#{icono}"
+      end
+  end
+end