pg_rails 7.0.1 → 7.0.2

data/pg_associable/lib/pg_associable/simple_form_initializer.rb

@@ -0,0 +1,34 @@
+SimpleForm.setup do |config|
+  config.wrappers :pg_associable, tag: 'div', class: 'pg_associable mb-3', html: { data: { controller: 'asociable', 'asociable-modal-outlet': '.modal' } },
+                                  error_class: 'form-group-invalid', valid_class: 'form-group-valid' do |b|
+    b.use :html5
+    b.optional :readonly
+    b.use :label, class: 'form-control-label'
+    b.use :hidden_input
+    b.wrapper tag: 'div', class: 'position-relative' do |ba|
+      ba.use :input, class: 'form-control', disabled: true, placeholder: 'Clic para seleccionar...',
+                     error_class: 'is-invalid'
+      ba.use :pencil
+      ba.use :modal_link
+      ba.use :limpiar
+    end
+    b.use :full_error, wrap_with: { tag: 'div', class: 'invalid-feedback d-block' }
+    b.use :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
+  end
+
+  config.wrappers :pg_associable_inline, tag: 'div', class: 'pg_associable_inline mb-3', html: { data: { controller: 'asociable_inline' } },
+                                         error_class: 'form-group-invalid', valid_class: 'form-group-valid' do |b|
+    b.use :html5
+    b.optional :readonly
+    b.use :label, class: 'form-control-label'
+    b.use :hidden_input
+    b.wrapper tag: 'div', class: 'search-box position-relative' do |ba|
+      ba.use :search_form, error_class: 'is-invalid'
+      ba.use :limpiar
+      ba.use :pencil
+      # ba.use :input, class: 'form-control', placeholder: 'Buscar...'
+    end
+    b.use :full_error, wrap_with: { tag: 'div', class: 'invalid-feedback d-block' }
+    b.use :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
+  end
+end

data/pg_associable/lib/pg_associable.rb

@@ -0,0 +1,5 @@
+require_relative 'pg_associable/engine'
+
+module PgAssociable
+  # Your code goes here...
+end

data/{lib/tasks/pg_rails_tasks.rake → pg_associable/lib/tasks/pg_associable_tasks.rake}

@@ -1,5 +1,4 @@
-# frozen_string_literal: true
 # desc "Explaining what the task does"
-# task :pg_rails do
+# task :pg_associable do
 #   # Task goes here
 # end

data/pg_engine/app/assets/stylesheets/pg_rails_b5.scss

@@ -0,0 +1,74 @@
+@use 'sass:color';
+
+:root,
+[data-bs-theme=light] {
+  --bs-form-invalid-color: #b50000;
+  --bs-form-invalid-border-color: #b50000;
+}
+
+
+// FORMS
+// .pg-form {
+  // max-width: 300px;
+
+  input[disabled] {
+    background-color: #e9e9ed;
+    color: black;
+  }
+
+  .form-control,
+  .form-select {
+    width: 100%;
+    height: 35px;
+    border: 1px solid #a7b7bb;
+    border-radius: 3px;
+
+    &.form-control-sm,
+    &.form-select-sm {
+      height: 29px;
+    }
+
+    &.is-invalid {
+      background-image: none!important; /* override bootstrap forms */
+      padding-right: 0; /* override bootstrap forms */
+    }
+
+    &:focus, &:focus-visible {
+      outline: 1px solid color.adjust(#a7b7bb, $saturation: +30%);
+    }
+  }
+  select[multiple] {
+    height: inherit;
+  }
+  .form-control:focus {
+    box-shadow: none!important; /* override bootstrap forms */
+  }
+
+  input[type=date] {
+    max-width: 170px;
+  }
+// }
+
+// LISTADOS
+.listado {
+  td, th {
+    padding: 0.25rem 1rem;
+  }
+}
+.listado .btn-sm {
+  min-width: 25px;
+  height: 25px;
+  padding: 1px;
+  margin-right: 4px;
+}
+
+// FILTROS
+.filter {
+  display: inline-block;
+  vertical-align: top;
+  min-width: 200px;
+
+  .input-group {
+    width: 230px;
+  }
+}

data/pg_engine/app/controllers/pg_engine/base_controller.rb

@@ -0,0 +1,365 @@
+# frozen_string_literal: true
+
+module PgEngine
+  # rubocop:disable Rails/ApplicationController
+  class BaseController < ActionController::Base
+    # rubocop:enable Rails/ApplicationController
+    include Pundit::Authorization
+    include PrintHelper
+    include PostgresHelper
+    include FlashHelper
+    include RouteHelper
+    include PgAssociable::Helpers
+
+    protect_from_forgery with: :exception
+
+    rescue_from PrintHelper::FechaInvalidaError, with: :fecha_invalida
+    rescue_from Pundit::NotAuthorizedError, with: :not_authorized
+
+    helper_method :mobile_device?
+    helper_method :atributos_para_listar
+    helper_method :atributos_para_mostrar
+
+    layout 'pg_layout/layout'
+
+    # Los flash_types resultantes serían:
+    # [:alert, :notice, :warning, :success]
+    add_flash_types :warning, :success
+
+    before_action do
+      @breakpoint_navbar_expand = 'md'
+      @navbar_opened_class = if cookies[:navbar_expand] == 'false' || !user_signed_in?
+                               ''
+                             else
+                               'opened'
+                             end
+      @navbar = Navbar.new(current_user)
+    end
+
+    # Public endpoints
+    def abrir_modal
+      pg_respond_abrir_modal
+    end
+
+    def buscar
+      pg_respond_buscar
+    end
+
+    def index
+      @collection = filtros_y_policy atributos_para_buscar
+      @collection = sort_collection(@collection)
+      pg_respond_index
+    end
+
+    def show
+      add_breadcrumb instancia_modelo, instancia_modelo.target_object
+
+      pg_respond_show
+    end
+
+    def new
+      add_breadcrumb "Crear #{@clase_modelo.nombre_singular.downcase}"
+    end
+
+    def edit
+      add_breadcrumb instancia_modelo, instancia_modelo.target_object
+      add_breadcrumb 'Editando'
+    end
+
+    def create
+      pg_respond_create
+    end
+
+    def update
+      pg_respond_update
+    end
+
+    def destroy
+      url = namespaced_path(@clase_modelo)
+      pg_respond_destroy(instancia_modelo, url)
+    end
+
+    # End public endpoints
+
+    def mobile_device?
+      request.user_agent =~ /Mobile|webOS/
+    end
+
+    helper_method :any_filter?
+
+    def any_filter?
+      params.keys.reject { |a| a.in? %w[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)
+      object ||= instancia_modelo
+      respond_to do |format|
+        if (@saved = object.save)
+          format.html { redirect_to object.decorate.target_object }
+          format.json { render json: object.decorate }
+        else
+          format.html { render :edit, status: :unprocessable_entity }
+          format.json { render json: object.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    def pg_respond_create(object: nil)
+      object ||= instancia_modelo
+      respond_to do |format|
+        if (@saved = object.save)
+          if params[:asociable]
+            format.turbo_stream do
+              render turbo_stream:
+                turbo_stream.update('pg-associable-form', <<~HTML
+                  <div data-modal-target="response" data-response='#{object.decorate.to_json}'></div>
+                HTML
+                )
+            end
+          end
+          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
+          if params[:asociable]
+            format.turbo_stream do
+              render turbo_stream:
+                turbo_stream.update('pg-associable-form', partial: 'form', locals: { asociable: true })
+            end
+          end
+          format.html { render :new, status: :unprocessable_entity }
+          format.json { render json: object.errors.full_messages, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    def pg_respond_index
+      respond_to do |format|
+        format.json { render json: @collection }
+        format.html { render_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: :see_other
+            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[:alert] = @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
+
+    # TODO: crear esta vista en pg_rails
+    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_listing
+      @collection = @collection.page(params[:page]).per(current_page_size)
+    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(PgEngine.configuracion.current_user_method)
+
+      authorize instancia_modelo
+
+      # TODO: problema en create y update cuando falla la validacion
+      self.instancia_modelo = instancia_modelo.decorate if action_name.in? %w[show edit new]
+    end
+
+    def instancia_modelo=(val)
+      instance_variable_set(:"@#{nombre_modelo}", val)
+    end
+
+    def instancia_modelo
+      instance_variable_get(:"@#{nombre_modelo}")
+    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 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 = PgEngine::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
+        Utils::Logueador.warning("No existe el campo \"#{field}\"")
+        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.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.html do
+          if request.path == root_path
+            render plain: 'Not authorized'
+          else
+            go_back('Not authorized')
+          end
+        end
+      end
+    end
+
+    def go_back(message)
+      flash[:alert] = message
+      redirect_back fallback_location: root_path
+    end
+  end
+end

data/pg_engine/app/controllers/pg_engine/devise_controller.rb

@@ -0,0 +1,9 @@
+module PgEngine
+  class DeviseController < ApplicationController
+    layout 'pg_layout/devise'
+
+    before_action do
+      render(layout: 'pg_layout/layout') if controller_name == 'registrations' && action_name == 'edit'
+    end
+  end
+end

data/pg_engine/app/controllers/pg_engine/signed_in_controller.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module PgEngine
+  class SignedInController < BaseController
+    before_action :authenticate_user!
+  end
+end

data/{app/decorators/pg_rails → pg_engine/app/decorators/pg_engine}/base_decorator.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
-module PgRails
+module PgEngine
   class BaseDecorator < Draper::Decorator
     include ActionView::Helpers
     include PrintHelper
     include FormHelper
+    include RouteHelper
     include Pundit::Authorization
 
     attr_accessor :output_buffer
@@ -15,7 +16,7 @@ module PgRails
       object.as_json.tap { |o| o[:to_s] = to_s }
     end
 
-    # def method_missing(method_name, *args, &block) # rubocop:disable Style/MissingRespondToMissing
+    # def method_missing(method_name, *args, &block)
     #   valor = object.attributes[method_name.to_s]
     #   return super unless valor.present?
 
@@ -29,7 +30,7 @@ module PgRails
     # end
 
     def destroy_link(message = '¿Estás seguro?')
-      return unless Pundit.policy!(helpers.send(PgRails.configuracion.current_user_method), object).destroy?
+      return unless Pundit.policy!(helpers.send(PgEngine.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 },
@@ -40,43 +41,44 @@ module PgRails
     end
 
     def edit_link(texto = '')
-      return unless Pundit.policy!(helpers.send(PgRails.configuracion.current_user_method), object).edit?
+      return unless Pundit.policy!(helpers.send(PgEngine.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
+                                         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?
+      return unless Pundit.policy!(helpers.send(PgEngine.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
+                                    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?
+      return unless Pundit.policy!(helpers.send(PgEngine.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
+                                class: "btn #{_config.clase_botones_chicos} btn-#{_config.boton_export}", href: url_change_format(url, 'xlsx') 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?
+      return unless Pundit.policy!(helpers.send(PgEngine.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.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
@@ -96,25 +98,21 @@ module PgRails
     end
 
     def target_object
-      default_module.present? ? [default_module, object] : object
+      pg_namespace.present? ? [pg_namespace, object] : object
     end
 
     def target_index
-      default_module.present? ? [default_module, object.class] : object.class
-    end
-
-    def default_module
-      nil
+      pg_namespace.present? ? [pg_namespace, object.class] : object.class
     end
 
     private
 
-      def _config
-        PgRails.configuracion
-      end
+    def _config
+      PgEngine.configuracion
+    end
 
-      def clase_icono(icono)
-        "#{_config.sistema_iconos} #{_config.sistema_iconos}-#{icono}"
-      end
+    def clase_icono(icono)
+      "#{_config.sistema_iconos} #{_config.sistema_iconos}-#{icono}"
+    end
   end
 end

data/pg_engine/app/helpers/pg_engine/flash_helper.rb

@@ -0,0 +1,26 @@
+module PgEngine
+  module FlashHelper
+    def render_turbo_stream_flash_messages
+      turbo_stream.prepend 'flash', partial: 'layouts/flash'
+    end
+
+    def render_turbo_stream_title
+      turbo_stream.update 'title', "#{breadcrumbs.last&.name} - #{Rails.application.class.module_parent_name}"
+    end
+
+    def flash_type_to_class(flash_type)
+      case flash_type
+      when 'notice'
+        'info'
+      when 'error'
+        'danger'
+      when 'alert'
+        'warning'
+      when 'success'
+        'success'
+      else
+        flash_type
+      end
+    end
+  end
+end

data/pg_engine/app/helpers/pg_engine/form_helper.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module PgEngine
+  module FormHelper
+    def pg_form_for(object, *args, &)
+      if object.is_a? PgEngine::BaseDecorator
+        object = object.target_object
+      elsif object.is_a?(PgEngine::BaseRecord) &&
+            object.decorator_class.present? &&
+            object.decorator_class < PgEngine::BaseDecorator
+        object = object.decorate.target_object
+      end
+      # byebug
+      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), &)
+    end
+
+    def url_change_format(url, formato)
+      uri = URI.parse(url)
+      uri.path = "#{uri.path}.#{formato}"
+      uri.to_s
+    end
+  end
+end