klastera 1.3.3.1 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7fae7d83f8b939309532cb345a38bc9c4f76bfca455b16ccda6ad17283f6851e
-  data.tar.gz: f62a4b00a2c526c47b95464263dcca6de69d880b6095fdba41204fd14eff66b2
+  metadata.gz: f45dc24f8870c8dc07dc2e7702f6021b66b5c71b97529ca4aece12ce47399348
+  data.tar.gz: 1c8673aaef5fb0d562376e80cdf787e302601672e4a4285066f3be4da04fb925
 SHA512:
-  metadata.gz: 591f79de0e4332c44454b172eee9aea5491cfbee45ed2d942f67841a6918ff22323d0f0219e15ee60709672de8e190e9d466a822b96eb82b213dfecec5b22647
-  data.tar.gz: bb1b6e5ec7c8c4795f1662f7d0d9e58a758f0594547bd2ac64408efcb77a02fef103a0f1c349a6243d0023620f2fc23c631761f78ea5ced6a2c9640428b215eb
+  metadata.gz: c59493dadf8ac3a4b52a235f3a4f96c52cef9668ec215bf9f857bad90c72241ad8564fe11c86f3a212587fba37440c87230487ce10da9bdd09519be907a433ca
+  data.tar.gz: 838347a85ffdfb1144dad6cf83094ff11fa9a8d78398e70f382a65e51df31d80bc557b3022175e7d13a8ddcbd88567f5c8af1b8a7ca6056194f475ed5d57b12d

data/app/models/klastera/concerns/cluster.rb

@@ -8,7 +8,9 @@ module Klastera::Concerns::Cluster
     
     attr_reader :last_record
 
-    MODES = [ :required_suborganization, :optional_suborganization, :optional_filter ].freeze
+    REQUIRED_MODE = :required_suborganization.freeze
+    OPTIONAL_MODE = :optional_suborganization.freeze
+    MODES = [ REQUIRED_MODE, OPTIONAL_MODE ].freeze
 
     belongs_to :organization, class_name: Klastera.organization_class
     has_many :cluster_users
@@ -56,7 +58,7 @@ module Klastera::Concerns::Cluster
     end
 
     def display_name_nid
-      "#{name} (#{nid})"
+      "#{name} (#{nid==Klastera::UNCLUSTERED_ENTITY ? I18n.t("klastera.#{ Klastera::UNCLUSTERED_ENTITY}") : nid})"
     end
   end
   

data/app/models/klastera/concerns/cluster_user.rb

@@ -14,7 +14,7 @@ module Klastera::Concerns::ClusterUser
      #
     def clusters_of(organization,and_user=nil)
       and_user_id = and_user.present? ? { users: { id: and_user } }  : {}
-      ::Cluster.eager_load(cluster_users: :user).where({ organization_id: organization }.merge(and_user_id) )
+      ::Cluster.eager_load(cluster_users: :user).where({ organization_id: organization }.merge(and_user_id) ).order(order: :asc)
     end
 
     ##

data/app/models/klastera/concerns/clusterizable.rb

@@ -1,7 +1,6 @@
 module Klastera::Concerns::Clusterizable
   extend ActiveSupport::Concern
   included do
-    attr_accessor :lonely_cluster
     belongs_to :cluster
 
     has_many :cluster_entities, as: :entity, class_name: Klastera::ClusterEntity
@@ -11,6 +10,8 @@ module Klastera::Concerns::Clusterizable
     validate :at_least_one_cluster_entity, if: proc { self.organization.required_suborganization_mode? }
     validate :uniqueness_of_cluster_entity_record
 
+    scope :includes_cluster, -> { includes(cluster_entities: :cluster) }
+
     def at_least_one_cluster_entity
       if cluster_entities.length == 0 || cluster_entities.reject{|cluster_entity| cluster_entity._destroy == true}.empty?
         return errors.add(:cluster_entities, I18n.t('klastera.messages.at_least_one_cluster_entity'))
@@ -43,7 +44,7 @@ module Klastera::Concerns::Clusterizable
   
   module ClassMethods
     def cluster_entity_params
-      [ :cluster_id, :lonely_cluster, { cluster_entities_attributes: [:id, :cluster_id, :_destroy] } ]
+      [ :cluster_id, { cluster_entities_attributes: [:id, :cluster_id, :_destroy] } ]
     end
   end
 end

data/app/models/klastera/concerns/organization.rb

@@ -22,19 +22,11 @@ module Klastera::Concerns::Organization
     end
 
     def required_suborganization_mode?
-      cluster_mode == ::Cluster::MODES.first
+      cluster_mode == ::Cluster::REQUIRED_MODE
     end
 
     def optional_suborganization_mode?
-      cluster_mode == ::Cluster::MODES.second
-    end
-
-    def optional_filter_mode?
-      cluster_mode == ::Cluster::MODES.third
-    end
-
-    def optional_mode?
-      optional_suborganization_mode? || optional_filter_mode?
+      cluster_mode == ::Cluster::OPTIONAL_MODE
     end
   end
   

data/app/models/klastera/concerns/user.rb

@@ -21,10 +21,6 @@ module Klastera::Concerns::User
     def is_a_cluster_admin?; self.cluster_role == CLUSTER_ADMIN; end
     def is_a_cluster_user?; self.cluster_role == CLUSTER_USER; end
 
-    def is_not_a_cluster_root?; ! self.is_a_cluster_root?; end
-    def is_not_a_cluster_admin?; ! self.is_a_cluster_admin?; end
-    def is_not_a_cluster_user?; ! self.is_a_cluster_user?; end
-
     def need_cluster_assignation?
       self.try(:organization).try(:required_suborganization_mode?) && self.is_a_cluster_user?
     end
@@ -33,6 +29,13 @@ module Klastera::Concerns::User
       self.organization.is_in_cluster_mode? && ( self.is_a_cluster_admin? || self.is_a_cluster_root? )
     end
 
+    #
+    # It tells if this user should see what they cluster role or organization dictates
+    # Adminers and users from show cluster modes skip cluster clause
+    def cannot_skip_cluster_clause?
+      ! ( self.is_a_cluster_admin? || self.is_a_cluster_root? || ( self.organization.optional_suborganization_mode? && self.cluster_users.blank? ) )
+    end
+
     #
     # We will try to create a cluster_user record whether
     # the organization is using force mode (if cluster_id isn't present, it will raise a validation error) 

data/app/views/layouts/klastera/_cluster_filter.html.erb

@@ -1,4 +1,4 @@
-<%= simple_form_for(@filter, url: url, remote: true) do |f| %>
+<%= simple_form_for(@cluster_filter, url: url, remote: true) do |f| %>
 
   <div class="inline-buttons-block top">
     <%= button_tag(t('klastera.actions.filter'), class: 'btn btn-primary btn-sm float-right', data: { disable_with: "<i class='fa fa-spinner spin'></i>" }) %>
@@ -7,7 +7,7 @@
   <%=yield(f) if block_given? %>
 
   <% if cluster_organization.is_in_cluster_mode? %>
-    <% cluster_collection = cluster_of_my_own.map{|c|[c.name,(c.id||c.nid)]} %>
+    <% cluster_collection = cluster_list.map{|c|[c.name,(c.id||c.nid)]} %>
     <% if cluster_collection.size > 1 %>
       <div class="inline-label-control-block">
         <%= f.input :cluster_id, collection: cluster_collection, prompt: t('klastera.clusters.all'), label: false, wrapper: false %>

data/app/views/layouts/klastera/_cluster_role.html.erb

@@ -1,8 +1,27 @@
-<% user_cluster_roles = user_cluster_roles.nil? ? User::CLUSTER_ROLES : user_cluster_roles %>
-<% other_visibility_reason = other_visibility_reason.nil? ? false : other_visibility_reason %>
+<%
+  user_cluster_roles = user_cluster_roles.nil? ? User::CLUSTER_ROLES : user_cluster_roles
+  other_visibility_reason = other_visibility_reason.nil? ? false : other_visibility_reason
+  if @user.try(:organization).present?
+    normal_user_help = @user.try(:organization).optional_suborganization_mode? ? :optional : :required
+  else
+    normal_user_help = :new
+  end
+%>
 <% if @user.try(:organization).try(:is_in_cluster_mode?) || other_visibility_reason %>
   <div class="form-group">
     <%= f.label t('klastera.cluster_role') %>
+    <span
+      class="klastera-user-cluster-rol"
+      data-title="<%= t('klastera.help.popover.title')%>"
+      data-toggle="popover"
+      data-content="<%=
+        t('klastera.help.popover.content.cluster_role',
+          m1: t('klastera.help.roles.description', r: t('klastera.roles.admin'), d: t('klastera.help.roles.admin')),
+          m2: t('klastera.help.roles.description', r: t('klastera.roles.user'), d: t("klastera.help.roles.user.#{normal_user_help}"))
+      )%>"
+    >
+      <%= fa_icon 'info-circle', class: 'btn-link' %>
+    </span>
     <%= f.select :cluster_role, user_cluster_roles.map{|r|[t("klastera.roles.#{r}"),r]}, { include_blank: true }, { class: 'form-control' } %>
   </div>
 
@@ -23,5 +42,7 @@
         });
       }
     });
+    var popoverTemplate = '<div class="popover" role="tooltip"><div class="arrow"></div><h3 class="popover-title"></h3><div class="popover-content"></div></div>'
+    $('.klastera-user-cluster-rol').popover({ template: popoverTemplate, html: true, trigger: 'click', });
   </script>
 <% end %>

data/app/views/layouts/klastera/_cluster_selector.html.erb

@@ -4,26 +4,18 @@
 %>
 <% if cluster_organization.is_in_cluster_mode? || other_visibility_reason %>
   <% 
-    cluster_collection = @clusters_session || cluster_of_my_own
+    cluster_collection = @clusters_session || cluster_list
     label = t('klastera.cluster.title')
   %>
   <% if f.nil? %>
     <%= label_tag(:cluster_id, label, class: 'control-label') %>
     <%= select_tag(:cluster_id, options_from_collection_for_select(cluster_collection, 'id', 'display_name_nid'), class: 'form-control', prompt: 'Seleccione') %>
   <% elsif f.is_a?(SimpleForm::FormBuilder) %>
-    <% if cluster_collection.size == 1 %>
-      <%= f.input :lonely_cluster, as: :hidden, html_input: { value: true } %>
-    <% else %>
-      <%= f.input :cluster_id, collection: cluster_collection.map{|c|[c.name,c.id]}, label: label %>
-    <% end %>
+    <%= f.input :cluster_id, collection: cluster_collection.map{|c|[c.name,c.id]}, label: label %>
   <% else %>
-    <% if cluster_collection.size == 1 %>
-      <%= f.hidden_field :lonely_cluster, value: true %>
-    <% else %>
-      <div class="form-group">
-        <%= f.label label %>
-        <%= f.select :cluster_id, cluster_collection.map{|c|[c.name,c.id]}, { include_blank: true }, { class: 'form-control' } %>
-      </div>
-    <% end %>
+    <div class="form-group">
+      <%= f.label label %>
+      <%= f.select :cluster_id, cluster_collection.map{|c|[c.name,c.id]}, { include_blank: true }, { class: 'form-control' } %>
+    </div>
   <% end %>
 <% end %>

data/app/views/layouts/klastera/_nested_cluster_entity.html.erb

@@ -1,5 +1,5 @@
 <% if cluster_organization.is_in_cluster_mode? %>
-  <% @clusters_session = cluster_of_my_own %>
+  <% @clusters_session = cluster_list(false) %>
   <div class="col-xs-12">
     <% if hide_title||=false %>
       <div class="form-group file required <%=f.object.class.name.parameterize%>_cluster_entity<%=' has-error' if f.object.errors.has_key?(:cluster_entities)%>">

data/app/views/layouts/klastera/_options.html.erb

@@ -5,10 +5,9 @@
     data-title="<%= t('klastera.help.popover.title')%>"
     data-toggle="popover"
     data-content="<%= 
-      t('klastera.help.popover.content',
+      t('klastera.help.popover.content.user_as_cluster_as',
         m1:t('klastera.help.required_suborganization', t: t('klastera.required_suborganization'), e: t('klastera.clusters.entities')),
-        m2:t('klastera.help.optional_suborganization', t: t('klastera.optional_suborganization'), e: t('klastera.clusters.entities')),
-        m3:t('klastera.help.optional_filter', t: t('klastera.optional_filter'), e: t('klastera.clusters.entities'))
+        m2:t('klastera.help.optional_suborganization', t: t('klastera.optional_suborganization'), e: t('klastera.clusters.entities'))
       )%>"
   >
     <%= fa_icon 'info-circle', class: 'btn-link' %>

data/config/locales/es.yml

@@ -9,24 +9,23 @@ es:
       you_need_add_at_least_one_cluster: Esta organización usa clusters en modo obligatorio. Asigne un cluster al usuario por favor.
       assign_cluster_role: Asignar role
       cluster_root_asignation: 
-        title: Asignación Routing Super Admin
-        text: Este rol es sólo para usuarios Routing
+        title: Asignación Super Admin
+        text: Este rol es sólo para usuarios super admin
     roles:
-      root: Routing Super Admin
-      admin: Admin Cliente [ Ignora asignación, ve todos los clusters ]
-      user: Usuario normal [ Ve sólo los clusters asignados ]
+      root: Super Admin
+      admin: Admin Cluster
+      user: Usuario Cluster
     using_cluster_as: Usando cluster como
     cluster_order: Orden
     cluster_id: ID
-    cluster_role: Cluster rol
+    cluster_role: Rol de clusters
     cluster_name: Nombre
     cluster_nid: Código
     cluster_color: Color
     organization_name: Organización
-    use_cluster_as: Activar y usar cluster como
-    required_suborganization: Sub-organización Obligatorio
-    optional_suborganization: Sub-organización Opcional
-    optional_filter: Filtro opcional
+    use_cluster_as: Activar y usar cluster en modo
+    required_suborganization: Obligatorio
+    optional_suborganization: Opcional
     clusters:
       all: Todos
       title: Clusters
@@ -71,10 +70,18 @@ es:
     help:
       popover:
         title: Descripción de cada opción
-        content: "<ul class='klastera-option-help'><li>%{m1}</li><li>%{m2}</li><li>%{m3}</li></ul>"
-      required_suborganization: "<b>%{t}</b>: Obliga definir un cluster en las entidades %{e} ."
-      optional_suborganization: "<b>%{t}</b>: Permite definir un cluster en las entidades %{e}."
-      optional_filter: "<b>%{t}</b>: Permite definir un cluster en las entidades %{e} de forma opcional."
+        content:
+          user_as_cluster_as: "<ul class='klastera-option-help'><li>%{m1}</li><li>%{m2}</li></ul>"
+      required_suborganization: "<b>%{t}</b>: Obliga asignar un cluster a las entidades %{e} ."
+      optional_suborganization: "<b>%{t}</b>: Permite asociar un cluster a las entidades %{e}."
+      roles:
+        description: "<b>%{r}</b>: %{d}."
+        root: Ve todos los clusters y no necesita asignación
+        admin: Ve todos los clusters y no necesita asignación
+        user:
+          new: Usuario al que se le puede restringir la cosas que puede ver a través de su asignación con los clusters
+          required: Necesita que se le asigne uno o más clusters, de lo contrario no verá las entidades clusterizadas.
+          optional: Si no tiene clusters asignados verá todas la entidades CON y SIN clusters. Si se le asigna un cluster, verá las entidades de ese cluster + las entidades SIN cluster.
   activemodel:
     attributes:
       'klastera/transfer':

data/lib/klastera.rb

@@ -5,154 +5,12 @@ module Klastera
 
   extend ActiveSupport::Concern
 
-  UNCLUSTERED_ENTITY = 'without_cluster'
-  KLSTR_HELPERS = %i[
-    cluster_user cluster_organization user_has_more_than_one_cluster cluster_scope cluster_of_my_own
-    user_clusters_string_list set_collection_before_group_by_entity same_cluster_scope
-    cluster_scope_through_of
-  ]
+  UNCLUSTERED_POSITION = 9999
+  UNCLUSTERED_ENTITY = 'without_cluster'.freeze
+  KLSTR_HELPERS = %i[ cluster_user cluster_organization cluster_list cluster_scope cluster_scope_through_of user_clusters_string_list cluster_scope_left_join ].freeze
 
   class << self
 
-    ##
-     #
-     #
-    def set_cluster_entities_attributes!(entity,array_cluster_ids)
-      cluster_entities_attributes = {}
-      entity_cluster_entities = entity.try(:cluster_entities) || []
-      entity_clusters = entity_cluster_entities.map(&:cluster_id).sort
-      array_cluster_ids = array_cluster_ids.map(&:id).sort
-      if array_cluster_ids != entity_clusters
-        now = DateTime.now
-        entity_cluster_entities.each_with_index do |ec,index|
-          remove_cluster = true
-          if array_cluster_ids.include?(ec.cluster_id)
-            remove_cluster = false
-            array_cluster_ids.delete(ec.cluster_id)
-          end
-          cluster_entities_attributes[index] = { id: ec.id, cluster_id: ec.cluster_id, _destroy: remove_cluster }
-        end
-        array_cluster_ids.each_with_index do |cluster_id,index|
-          cluster_entities_attributes[now.to_i+index] = { cluster_id: cluster_id, _destroy: false }
-        end
-      end
-      cluster_entities_attributes
-    end
-
-    ##
-     #
-     #
-    def set_collection_before_group_by_entity!(active_record_collection,entity_params,organization,include_nil_by_rule=true)
-      entity_params_keys = [:entity_name,:entity_attribute,:entity_id,:entity_id_attribute,:unamed]
-      entity_params[:entity_id] ||= nil #Ensures the entity_id attribute presence even if there is no filter
-      entity_params = entity_params.slice(*entity_params_keys).values
-      model_class = active_record_collection.model.base_class
-      model_relations = model_class.reflections.keys
-      if model_relations.include?(entity_params[0])
-        entity_params << "#{entity_params[0]}_id".to_sym
-        if entity_params[0] == 'cluster'
-          entity_params << I18n.t("klastera.#{UNCLUSTERED_ENTITY}") if organization.is_in_cluster_mode?
-          active_record_collection = Klastera.filter_clusterized!(
-            active_record_collection,
-            entity_params[2],
-            organization,
-            include_nil_by_rule
-          )
-        end
-        yield( active_record_collection, entity_params_keys.zip(entity_params).to_h )
-      end
-    end
-
-    #
-    # In order to this work, the active_record_collection argument should be a cluster_scope! return.
-    #
-    def filter_clusterized!(active_record_collection,cluster_id,organization,include_nil_by_rule=true)
-      if organization.is_in_cluster_mode? && cluster_id.present?
-          # Ensures that an array of ids is used in the statement
-          cluster_array = cluster_id.is_a?(Array) ? cluster_id.dup : [cluster_id]
-          # If we receive a UNCLUSTERED_ENTITY request, it means that we should filter by entities without clusters.
-          # The optional_mode?(show/use) condition add to this method an ambivalent use,
-          # where you can filter a unique value or multiple including NULL ones.
-          cluster_array << nil if include_nil_by_rule || cluster_id == UNCLUSTERED_ENTITY && ( cluster_array.delete(UNCLUSTERED_ENTITY) || organization.optional_mode? )
-          active_record_collection = active_record_collection.where(cluster_entities: { cluster_id: cluster_array.uniq })
-          # You should use a block with clusterable data only
-          yield(active_record_collection) if block_given?
-      end
-      active_record_collection
-    end
-
-    ##
-     # If the cluster mode is not active, this returns a scope filtered by clusters of its organization/users/cluster
-     #
-    def cluster_scope!(scope,user,organization,cluster_id=nil)
-      scope_klass = scope_class(scope).where(organization_id: organization)
-      if organization.is_in_cluster_mode?
-
-        if cluster_id.present?
-          # Ensures that an array of id is used in the statement
-          cluster_ids = cluster_id.is_a?(Array) ? cluster_id : [cluster_id]
-        else
-          clusters = cluster_of!(organization,user)
-          cluster_ids = clusters.map(&:id).compact
-        end
-
-        scope_klass = scope_klass.select("DISTINCT ON (#{scope.table_name}.id) #{scope.table_name}.id, #{scope.table_name}.*")
-
-        if organization.required_suborganization_mode?
-          scope_klass = scope_klass.joins(:cluster_entities).where( cluster_entities: { cluster_id: cluster_ids } )
-        else
-          or_these_cluster_ids = cluster_ids.present? ? " OR cluster_entities.cluster_id IN (#{cluster_ids.join(",")})" : ""
-          scope_klass = scope_klass.joins("
-            LEFT OUTER JOIN cluster_entities
-              ON entity_id = #{scope.table_name}.id
-              AND entity_type = '#{scope}'
-          ").where("cluster_entities.id IS NULL#{or_these_cluster_ids}")
-        end
-
-        # Provisional fix to avoid unresolved SQL clashes with the main application due to DISTINCT ON clause
-        scope_klass = scope_class(scope).eager_load(:cluster_entities).where(id: scope_klass.map(&:id), organization_id: organization)
-      end
-      scope_klass
-    end
-
-    # 
-    # Optimized version of cluster_scope!
-    #
-    def same_cluster_scope!(scope,user,organization,cluster_id=nil)
-      scope_klass = scope_class(scope)
-      if organization.is_in_cluster_mode?
-        scope_klass = scope_klass.eager_load(:organization,cluster_entities: :cluster)
-
-        if cluster_id.present?
-          cluster_ids = cluster_id.is_a?(Array) ? cluster_id : [cluster_id]
-        else
-          clusters = cluster_of!(organization,user)
-          cluster_ids = clusters.map(&:id).compact.sort
-        end
-
-        if organization.required_suborganization_mode?# || cluster_id # If cluster_id is passed NULL clusters are expected, rigth?
-          scope_klass = scope_klass.where( cluster_entities: { cluster_id: cluster_ids } )
-        else
-          or_these_cluster_ids = cluster_ids.present? ? " OR cluster_entities.cluster_id IN (#{cluster_ids.join(",")})" : ""
-          scope_klass = scope_klass.where("cluster_entities.id IS NULL#{or_these_cluster_ids}")
-        end
-      end
-
-      scope_klass.where(organization_id: organization)
-    end
-
-    # 
-    # Filter non-clustered entity through a clusterized one
-    #
-    def cluster_scope_through_of!(relation,cluster_entity_klass,scope_klass,user,organization,cluster_id=nil)
-      scope_class(scope_klass).joins(relation => :cluster_entities).where(
-        organization_id: organization,
-        "#{relation}_id" => same_cluster_scope!(
-          cluster_entity_klass, user, organization, cluster_id
-        )
-      )
-    end
-
     ##
      # TODO:
      # Implement a validation to ensure that
@@ -165,19 +23,22 @@ module Klastera
     end
 
     ##
-     # Returns a Cluster::ActiveRecord_Relation if the organization is using the cluster mode.
-     # Use this only to get current_user/organization clusters
+     # Returns which clusters a user can see avoiding unnecessary queries if the cluster restraint doesn't apply
      #
-    def cluster_of!(organization,user)
-      # A cluster user with role Root or Admin retrieve every cluster of its organizations
-      # Thats why we pass a nil object to avoid user filter, but if you pass a nil user as argument
-      # The result is the same as if the user was a admin, BE CAREFUL!
-      and_this_user = user.try(:can_admin_clusters?) ? nil : user
-      # We weill return a cluster active record collection that can be filtered
-      active_record_collection = ::ClusterUser.clusters_of(organization,and_this_user)
-      # Add a empty cluster instance to handle models without a cluster assignation.
-      if organization.optional_mode? # For use and show modes only
-        active_record_collection << ::Cluster.new({nid: UNCLUSTERED_ENTITY, name: I18n.t("klastera.#{UNCLUSTERED_ENTITY}")})
+    def cluster_list!(organization,user,include_unclustered=true)
+      # Only the cluster mode on and the mandatory user-cluster relation will use a join clause to get the clusters list
+      if organization.is_in_cluster_mode? && user.cannot_skip_cluster_clause?
+        active_record_collection = ::ClusterUser.clusters_of(organization,user)
+      else
+        active_record_collection = ::Cluster.where({ organization_id: organization }).order(order: :asc)
+      end
+
+      active_record_collection = active_record_collection.order(order: :asc)
+
+      if include_unclustered && organization.optional_suborganization_mode? # For show and use modes only
+        active_record_collection.append(
+          ::Cluster.new({nid: UNCLUSTERED_ENTITY, name: I18n.t("klastera.#{UNCLUSTERED_ENTITY}")}, order: UNCLUSTERED_POSITION )
+        )
       end
       active_record_collection
     end
@@ -197,82 +58,163 @@ module Klastera
     end
 
     ##
-     # cluster_of! needs a user and a organization. that why we perfomed this logic here
+     # cluster_list! needs a user and a organization. that why we perfomed this logic here
      #
     def user_clusters_string_list!(user,organization,cluster_entities,separator,attribute=:name)
-      @clusters_session ||= Klastera.cluster_of!(organization,user)
+      @clusters_session ||= Klastera.cluster_list!(organization,user)
       self.entity_clusters_string_list!(cluster_entities, separator, attribute, @clusters_session.map(&:id))
     end
-  end
 
-  def cluster_user
-    current_user
-  end
+    #
+    # We will try to avoid cluster clause except when:
+    # 1.- cluster mode is active
+    # AND
+    #   2a.- cluster_filter is present (someone wants to filter by cluster)
+    # OR
+    #   2b.- the current user has some limitations and must checks they cluster relation
+    #         - User is having clusters in optional_suborganization mode
+    #         - User IS NOT having clusters in required_suborganization mode
+    #
+    # For the other hand, with force_cluster_clause we can skip the previous logic if
+    # cluster_filter_id is present when the optional_suborganization mode is on. BUT!
+    # Be aware that if the cluster_filter is not present, the value of force_cluster_clause
+    # will be overridden by the returned value of cannot_skip_cluster_clause? method.
+    #
+    def cluster_scope!(scope_klass, user, organization, cluster_filter=nil, force_cluster_clause=false)
+      scope_klass = scope_class(scope_klass)
+      if organization.is_in_cluster_mode? && ( cluster_filter.present? || force_cluster_clause = user.cannot_skip_cluster_clause? ) # yes, this is an assignation
+        cluster_ids = []
+        # Set another variable as array to get the cluster id(s)
+        if cluster_filter.present?
+          cluster_ids = cluster_filter.is_a?(Array) ? cluster_filter : [cluster_filter]
+        elsif force_cluster_clause
+          cluster_ids = ::ClusterUser.clusters_of(organization,user).map(&:id)
+        end
+        # We will avoid the query unless cluster_ids is having values OR force_cluster_clause is set (see method description)
+        if cluster_ids.present? || force_cluster_clause
+          scope_klass = scope_klass.eager_load(:organization,cluster_entities: :cluster)
+          # We add the unclustered if the value of cluster_filter have the special without_cluster string or as method description says
+          if cluster_ids.delete(UNCLUSTERED_ENTITY) || ( force_cluster_clause && organization.optional_suborganization_mode? )
+            cluster_ids << nil
+          end
+          scope_klass = scope_klass.where( cluster_entities: { cluster_id: cluster_ids } )
+        end
+      end
+      scope_klass.where(organization_id: organization)
+    end
 
-  def cluster_organization
-    current_organization
-  end
+    # 
+    # Filter non-clustered entity through a clusterized one
+    #
+    def cluster_scope_through_of!(relation, cluster_entity_klass, scope_klass, user, organization, cluster_filter=nil, force_cluster_clause=false)
+      unclusterized_scope = scope_class(scope_klass)
 
-  def user_has_more_than_one_cluster
-    @clusters_session ||= cluster_of_my_own
-    @clusters_session.size > 1
-  end
+      if organization.is_in_cluster_mode? && ( force_cluster_clause || user.cannot_skip_cluster_clause? )
+        unclusterized_scope = unclusterized_scope.joins(relation => :cluster_entities)
+      end
 
-  def set_the_lonely_cluster
-    form_model = @form_record ? model_name_from_record_or_class(@form_record).param_key : params[:controller].singularize
-    parameters = params.require( form_model ) rescue nil
-    lonely_cluster = parameters.blank? ? false : parameters.permit( :lonely_cluster ).present?
-    if lonely_cluster
-      params[form_model][:cluster_id] = cluster_of_my_own.first.try(:id)
+      if scope_klass.respond_to?(:organization)
+        unclusterized_scope = unclusterized_scope.where(organization_id: organization)
+      end
+
+      unclusterized_scope.where("#{relation}_id" => cluster_scope!(cluster_entity_klass, user, organization, cluster_filter, force_cluster_clause))
     end
-  end
 
-  def set_cluster_filter
-    @filter = ::ClusterFilter.new(cluster_filter_params)
+    #
+    # Returns an array with a clusterized scoped result and its grouped version
+    #
+    def group_by_cluster_scope!(scope_klass, user, organization, cluster_filter=[], scope_scopes=[])
+      cluster_ids = cluster_filter.is_a?(Array) ? cluster_filter : [cluster_filter]
+      kluster_scope = cluster_scope!(scope_klass, user, organization, cluster_ids, organization.is_in_cluster_mode? )
+
+      scope_scopes.each do |tuple_scope|
+        scope_name, scope_arg = tuple_scope
+        kluster_scope = scope_arg.present? ? kluster_scope.send(scope_name,scope_arg) : kluster_scope.send(scope_name)
+      end
+
+      group_by_block = ->(o) {
+        if organization.is_in_cluster_mode?
+          o.cluster.present? ? o.cluster.name : UNCLUSTERED_POSITION
+        else
+          I18n.t("klastera.group_by_cluster_scope.#{scope_klass.model_name.plural}")
+        end
+      }
+
+      grouped_cluster_scope = kluster_scope.group_by(&group_by_block).sort_by{|k,v|k.to_s}
+
+      grouped_cluster_scope.dup.each do |group|
+        if group.first == UNCLUSTERED_POSITION
+          grouped_cluster_scope.delete(group)
+          group[0] = I18n.t("klastera.#{UNCLUSTERED_ENTITY}")
+          grouped_cluster_scope.append(group)
+        end
+      end
+
+      [ kluster_scope, grouped_cluster_scope ]
+    end
+
+    #
+    # A helper that returns a CLUSTER SCOPE to build queries that need explicit LEFT OUTER JOIN clause,
+    # instead of the default INNER JOIN provide by ActiveRecord's joins method
+    #
+    def cluster_scope_left_join!(scope_klass,organization)
+      scope_klass_arel_table        = scope_klass.arel_table
+      cluster_entities_arel_table   = Klastera::ClusterEntity.arel_table
+
+      scope_klass_cluster_entities  = scope_klass_arel_table.join(cluster_entities_arel_table, Arel::Nodes::OuterJoin).on(
+        scope_klass_arel_table[:id].eq(cluster_entities_arel_table[:entity_id]), cluster_entities_arel_table[:entity_type].eq(scope_klass.name)
+      ).join_sources
+
+      cluster_arel_table            = ::Cluster.arel_table
+      cluster_entities_cluster      = cluster_entities_arel_table.join(cluster_arel_table, Arel::Nodes::OuterJoin).on(
+        cluster_entities_arel_table[:cluster_id].eq(cluster_arel_table[:id]),
+      ).join_sources
+
+      scope_class(scope_klass).where(organization_id: organization).joins(scope_klass_cluster_entities).joins(cluster_entities_cluster)
+    end
   end
 
-  def cluster_filter_params
-    parameters = params.require(:cluster_filter) rescue nil
-    return {} if parameters.blank?
-    parameters.permit(*cluster_filter_permit_params)
+  ##################################################################################################################################################
+
+  def cluster_user
+    current_user
   end
 
-  def cluster_filter_permit_params
-    [ :cluster_id ].concat( ::ClusterFilter.attributes )
+  def cluster_organization
+    current_organization
   end
 
-  def filter_clusterized(active_record_collection,cluster_id,include_nil_by_rule=true)
-    Klastera.filter_clusterized!(active_record_collection, cluster_id, cluster_organization, include_nil_by_rule)
+  def set_cluster_filter
+    cluster_filter_params = params.require(:cluster_filter) rescue {}
+    @cluster_filter = ::ClusterFilter.new(
+      cluster_filter_params.present? ? cluster_filter_params.permit(
+        [ :cluster_id ].concat( ::ClusterFilter.attributes )
+      ) : {}
+    )
   end
 
-  def cluster_scope(scope,cluster_id=nil)
-    Klastera.cluster_scope!(scope, cluster_user, cluster_organization, cluster_id)
+  def cluster_list(include_unclustered=true)
+    Klastera.cluster_list!(cluster_organization, cluster_user, include_unclustered)
   end
 
-  def same_cluster_scope(scope,cluster_id=nil)
-    Klastera.same_cluster_scope!(scope, cluster_user, cluster_organization, cluster_id)
+  def cluster_scope(scope_klass, cluster_filter=nil, force_cluster_clause=false)
+    Klastera.cluster_scope!(scope_klass, cluster_user, cluster_organization, cluster_filter, force_cluster_clause)
   end
 
-  def cluster_scope_through_of(relation,cluster_entity_klass,scope_klass,cluster_id=nil)
-    Klastera.cluster_scope_through_of!(relation, cluster_entity_klass, scope_klass, cluster_user, cluster_organization, cluster_id )
+  def cluster_scope_through_of(relation, cluster_entity_klass, scope_klass, cluster_filter=nil, force_cluster_clause=false)
+    Klastera.cluster_scope_through_of!(relation, cluster_entity_klass, scope_klass, cluster_user, cluster_organization, cluster_filter, force_cluster_clause)
   end
 
-  def cluster_of_my_own
-    Klastera.cluster_of!(cluster_organization,cluster_user)
+  def group_by_cluster_scope(scope_klass, cluster_filter=[], scope_scopes=[])
+    Klastera.group_by_cluster_scope!(scope_klass, cluster_user, cluster_organization, cluster_filter, scope_scopes)
   end
 
-  def user_clusters_string_list(object_entity,separator,attribute=:name)
-    Klastera.user_clusters_string_list!(
-      cluster_user,
-      cluster_organization,
-      object_entity.try(:cluster_entities),
-      separator,
-      attribute
-    )
+  def user_clusters_string_list(object_entity, separator, attribute=:name)
+    Klastera.user_clusters_string_list!(cluster_user, cluster_organization, object_entity.try(:cluster_entities), separator, attribute)
   end
 
-  def set_collection_before_group_by_entity(active_record_collection,entity_params,include_nil_by_rule=true,&block)
-    Klastera.set_collection_before_group_by_entity!(active_record_collection, params, cluster_organization, include_nil_by_rule, &block)
+  def cluster_scope_left_join(scope_klass)
+    Klastera.cluster_scope_left_join!(scope_klas,cluster_organization)
   end
 
   included do
@@ -285,6 +227,5 @@ module Klastera
         hide_action("#{helper}=")
       end
     end
-    before_action :set_the_lonely_cluster, only: %i[ create update ]
   end
 end

data/lib/klastera/version.rb

@@ -1,3 +1,3 @@
 module Klastera
-  VERSION = "1.3.3.1"
+  VERSION = "1.4.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: klastera
 version: !ruby/object:Gem::Version
-  version: 1.3.3.1
+  version: 1.4.1
 platform: ruby
 authors:
 - Gino Barahona
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-22 00:00:00.000000000 Z
+date: 2020-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -127,7 +127,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Clusterization Engine