klastera 1.1.6.1 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d99d98acb9cb221ce9fad3b71ba9ae14aec4aa13a2a8a09438ace17a56e4187
-  data.tar.gz: c6f76aea020ba9562ec5a7256c38663612ca3f5da4a8ebb3e96f6de16f4057f3
+  metadata.gz: f1d1b4ee48b85521c4f7b9b085877a8138ac3f267b275cd09974102d1c55e488
+  data.tar.gz: ff0bd6762b86cc3aa0bcf0f97302322175f2dca25797f7f4a413cd8b0a32f01c
 SHA512:
-  metadata.gz: c975d640c103a49604984952afc7f3e3fe7a568f6db070a7afdbb59301dba0d4d13e41f02dd737ccf7bbad9a4673e61b8bcd460a5c929db818f9281907b8886d
-  data.tar.gz: c39540a4125b3be5302df5af564758bcb04f1faa68aed596f9617aeaf17021b8bed569890d213c60209dcb64ef631dc3c296b2fa460b61ae230d1c8be85c4e06
+  metadata.gz: e3c25e15d17ce5a8f3a3ac621efff40ee0056794dea067c5db85b19b2ecca87badae22632f0d2358ddff397bcabdd1e0f1fe54a1795f9f6fc0a1806fc9a6d88d
+  data.tar.gz: b0f03f444cc382dea3f8988e015eb88635b4b707344896a2f07063b0d1a996d5f939c37fed19a08bb3b9a4eee3c6e3a2aeb3b7ad75e264c156d795fc3845d03a

data/app/assets/stylesheets/klastera/clusters.css.scss

@@ -0,0 +1,11 @@
+.nested-cluster-user,
+.nested-cluster-entity {
+  .panel {
+    margin: 0;
+    border-bottom: 0;
+    .panel-heading {
+      padding: 10px 12px 10px 15px;
+      background: none;
+    }
+  }
+}

data/app/models/klastera/cluster_entity.rb

@@ -0,0 +1,5 @@
+module Klastera
+  class ClusterEntity < ActiveRecord::Base
+    include Klastera::Concerns::ClusterEntity
+  end
+end

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

@@ -0,0 +1,12 @@
+module Klastera::Concerns::ClusterEntity
+  extend ActiveSupport::Concern
+
+  included do
+    self.table_name = 'cluster_entities'
+    belongs_to :entity, polymorphic: true
+    belongs_to :cluster, class_name: ::Cluster
+  end
+  
+  module ClassMethods
+  end
+end

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

@@ -10,7 +10,7 @@ module Klastera::Concerns::ClusterUser
     validates :cluster_id, presence: true
 
     scope :of, -> (user,organization) {
-      Rails.logger.warn("DON'T USE THIS SCOPE DIRECTLY: Use ::ClusterUser.get_from class method instead!")
+      Rails.logger.warn("DON'T USE THIS SCOPE DIRECTLY: Use ::ClusterUser.clusters_from class method instead!")
       includes(:cluster).where(user_id: user, "clusters.organization_id": organization)
     }
   end
@@ -20,13 +20,13 @@ module Klastera::Concerns::ClusterUser
     ##
     # Returns a hash with the users with cluster relation
     #
-    def get_user_clusters_from(organization)
+    def user_clusters_from(organization)
       users_hash = {}
       organization_cluster_ids = ::Cluster.of(organization).map(&:id)
-      ::ClusterUser.includes(:user).where(cluster_id: organization_cluster_ids).each do |cluster|
-        user_id = cluster.try(:user).try(:id) || :uncluster
-        users_hash[user_id] ||= [];
-        users_hash[user_id] << cluster.id
+      ::ClusterUser.includes(:user).where(cluster_id: organization_cluster_ids).each do |cluster_user|
+        user_id = cluster_user.user_id || :uncluster
+        users_hash[user_id] ||= []
+        users_hash[user_id] << cluster_user.cluster_id
       end
       users_hash
     end
@@ -35,7 +35,7 @@ module Klastera::Concerns::ClusterUser
      # Returns a Cluster::ActiveRecord_Relation
      #
      ##
-    def get_clusters_from(user,organization)
+    def clusters_from(user,organization)
       clusters = []
       unless user.can_admin_clusters?
         # We could return cu.clusters but you may quering this result and a array can't handle order, where and etc.

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

@@ -4,16 +4,36 @@ module Klastera::Concerns::Clusterizable
     attr_accessor :lonely_cluster
     belongs_to :cluster
 
-    validates :cluster_id, presence: true, if: proc { self.organization.required_suborganization_mode? }
+    has_many :cluster_entities, as: :entity, class_name: Klastera::ClusterEntity
+    accepts_nested_attributes_for :cluster_entities, reject_if: :all_blank, allow_destroy: true
+
+    validates :cluster_id, presence: true, if: proc { self.try(:cluster_id) && self.organization.required_suborganization_mode? }
+    validate :at_least_one_cluster_entity, if: proc { self.organization.required_suborganization_mode? }
 
     scope :related_clusters, ->() {
-      includes(:cluster).where("#{self.table_name}.cluster_id IS NOT NULL")
+      includes(:cluster_entities).where("cluster_entities.entity_id = #{self.table_name}.id")
     }
+
+    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'))
+      end
+    end
+
+    def clusters_string_separated_by(separator,attribute=:name)
+      self.cluster_entities.map{|ce|ce.cluster.send(attribute)}.join(separator)
+    end
+
+    def has_one_cluster_entity
+      if cluster_entities.length > 1
+        return errors.add(:cluster_entities, I18n.t('klastera.messages.has_one_cluster_entity'))
+      end
+    end
   end
   
   module ClassMethods
-    def cluster_params
-      [ :cluster_id, :lonely_cluster ]
+    def cluster_entity_params
+      [ :cluster_id, :lonely_cluster, { cluster_entities_attributes: [:id, :cluster_id, :_destroy] } ]
     end
   end
 end

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

@@ -33,20 +33,25 @@ module Klastera::Concerns::User
       self.organization.is_in_cluster_mode? && ( self.is_a_cluster_admin? || self.is_a_cluster_root? )
     end
 
+    #
     # We will try to create a cluster_user record whether
-    # the organization is using force mode (if cluster_id isn't present,
-    # will raise a validation error) or cluster_id is present
-    # (on organizations with show/use mode).
-    def try_to_clusterify!(role,cluster_id)
+    # the organization is using force mode (if cluster_id isn't present, it will raise a validation error) 
+    # or
+    # cluster_id is present (on show/use mode organizations).
+    #
+    def try_to_clusterify!(role,cluster_ids)
       if self.try(:organization).try(:is_in_cluster_mode?)
         self.cluster_role = role
-        if self.try(:organization).try(:required_suborganization_mode?) || cluster_id.present?
-          self.cluster_users_attributes = {
-            DateTime.now.to_i => {
+        if self.try(:organization).try(:required_suborganization_mode?) || cluster_ids.present?
+          timestamp = DateTime.now.to_i
+          nested_attributes = {}
+          cluster_ids.each do |cluster_id|
+            nested_attributes["#{cluster_id}_#{timestamp}"] = {
               cluster_id: cluster_id,
               _destroy: false
             }
-          }
+          end
+          self.cluster_users_attributes = nested_attributes
         end
       end
     end

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

@@ -0,0 +1,10 @@
+<tr class="nested-fields">
+  <td class="field">
+    <%= f.select :cluster_id, cluster_clusters.map{|c|[c.name,c.id]}, { include_blank: true }, { class: 'form-control' } %>
+  </td>
+  <td class="action vertical-align-middle text-center" width="44">
+    <%= link_to_remove_association f, class: 'btn btn-danger btn-xs text-danger' do %>
+      <i class="fa fa-trash"></i>
+    <% end %>
+  </td>
+</tr>

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

@@ -4,7 +4,7 @@
     <%= button_tag(t('klastera.actions.filter'), class: 'btn btn-primary btn-sm float-right', data: { disable_with: "<i class='fa fa-spinner spin'></i>" }) %>
   </div>
 
-  <%=yield(f)%>
+  <%=yield(f) if block_given? %>
 
   <% if cluster_organization.is_in_cluster_mode? %>
     <% cluster_collection = cluster_clusters.map{|c|[c.name,(c.id||c.nid)]} %>

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

@@ -1,8 +1,8 @@
 <tr class="nested-fields">
   <td class="field">
     <%= f.select :cluster_id, @user.organization.clusters.map{|c|[c.name,c.id]}, { include_blank: true }, { class: 'form-control' } %>
-    </td>
-  <td class="action vertical-align-middle" width="44">
+  </td>
+  <td class="action vertical-align-middle text-center" width="44">
     <%= link_to_remove_association f, class: 'btn btn-danger btn-xs text-danger' do %>
       <i class="fa fa-trash"></i>
     <% end %>

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

@@ -0,0 +1,41 @@
+<% if cluster_organization.is_in_cluster_mode? && cluster_user.can_admin_clusters? %>
+  <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)%>">
+        <label class="text" for="<%=f.object.class.name.parameterize%>_cluster_entity">
+          <%=t('klastera.clusters.title')%>
+          <% if cluster_organization.required_suborganization_mode? %>
+            <abbr title="required">*</abbr>
+          <% end %>
+        </label>
+    <% end %>
+  
+      <div class="nested-cluster-entity">
+        <div class="panel panel-default">
+          <div class="panel-heading<%=' custom-required' if cluster_organization.required_suborganization_mode? %>">
+            <h4 class="panel-title">
+              <% unless hide_title||=false %>
+                <div class="float-left" style="line-height: 20px"><%=t('klastera.clusters.title')%></div>
+              <% end %>
+              <%= link_to_add_association f, :cluster_entities, partial: 'layouts/klastera/cluster_entity_fields', data: { 'association-insertion-node': :'tbody.cluster-entity-rows', 'association-insertion-method': :append }, class: 'btn btn-success btn-xs float-right color-white' do %>
+                <i class="fa fa-plus"></i>
+              <% end %>
+              <div class="clearfix"></div>
+            </h4>
+          </div>
+          <table id="cluster-entities" class="table table-striped">
+            <tbody class="cluster-entity-rows">
+              <%= f.fields_for :cluster_entities do |cluster_entity|%>
+                <%= render 'layouts/klastera/cluster_entity_fields', f: cluster_entity %>
+              <% end %>
+            </body>
+          </table>
+        </div>
+      </div>
+
+      <% if hide_title||=false %>
+          <div class="invalid-feedback"><%=f.object.try(:errors)&.[](:cluster_entities).try(:first)%></div>
+        </div>
+      <% end %>
+  </div>
+<% end %>

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

@@ -1,20 +1,22 @@
 <% if @user.try(:is_a_cluster_user?) %>
-  <div class="panel panel-default">
-    <div class="panel-heading">
-      <h4 class="panel-title">
-        <div class="float-left" style="line-height: 20px"><%=t('klastera.clusters.title')%></div>
-        <%= link_to_add_association f, :cluster_users, partial: 'layouts/klastera/cluster_user_fields', data: { 'association-insertion-node': :'tbody.cluster-user-rows', 'association-insertion-method': :append }, class: 'btn btn-success btn-xs float-right color-white' do %>
-          <i class="fa fa-plus"></i>
-        <% end %>
-        <div class="clearfix">
-      </h4>
+  <div class="nested-cluster-user">
+    <div class="panel panel-default">
+      <div class="panel-heading">
+        <h4 class="panel-title">
+          <div class="float-left" style="line-height: 20px"><%=t('klastera.clusters.title')%></div>
+          <%= link_to_add_association f, :cluster_users, partial: 'layouts/klastera/cluster_user_fields', data: { 'association-insertion-node': :'tbody.cluster-user-rows', 'association-insertion-method': :append }, class: 'btn btn-success btn-xs float-right color-white' do %>
+            <i class="fa fa-plus"></i>
+          <% end %>
+          <div class="clearfix"></div>
+        </h4>
+      </div>
+      <table id="cluster-users" class="table table-striped">
+        <tbody class="cluster-user-rows">
+          <%= f.fields_for :cluster_users do |cluster_user|%>
+            <%= render 'layouts/klastera/cluster_user_fields', f: cluster_user %>
+          <% end %>
+        </body>
+      </table>
     </div>
-    <table id="cluster-users" class="table">
-      <tbody class="cluster-user-rows">
-        <%= f.fields_for :cluster_users do |cluster_user|%>
-          <%= render 'layouts/klastera/cluster_user_fields', f: cluster_user %>
-        <% end %>
-      </body>
-    </table>
   </div>
 <% end %>

data/config/locales/es.yml

@@ -57,6 +57,8 @@ es:
       created: Creado
       updated: Actualizado
     messages:
+      has_one_cluster_entity: Está permitido agregar un sólo cluster
+      at_least_one_cluster_entity: Debe agregar al menos un cluster
       record_action_successfully: Registro %{a} exitosamente
       cant_delete_the_last_record_in_required_suborganization_mode: No se puede eliminar el único cluster de esta organización
       new_cluster_id:

data/db/migrate/20200518142609_create_klastera_cluster_entities.rb

@@ -0,0 +1,8 @@
+class CreateKlasteraClusterEntities < ActiveRecord::Migration
+  def change
+    create_table :cluster_entities do |t|
+      t.integer :cluster_id, index: true
+      t.references :entity, polymorphic: true, index: true
+    end
+  end
+end

data/lib/klastera.rb

@@ -3,41 +3,117 @@ require "klastera/engine"
 module Klastera
   mattr_accessor :organization_class
 
-  class RelatedClusterEntityComplianceError < StandardError; end
   extend ActiveSupport::Concern
 
   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
+
+    #
+    # I like to wrap methods
+    #
+    def cluster_scope_filtered!(scope,cluster_id,user,organization,includes=[])
+      self.filter_clusterized_collection_with!(
+        organization,
+        cluster_id,
+        self.cluster_scope!(user,organization,scope,includes)
+      )
+    end
+
+    #
+    # In order to this works, active_record_collection argument
+    # should be passed through cluster_scope! method before.
+    #
+    def filter_clusterized_collection_with!(cluster_organization,cluster_id,active_record_collection)
+      if cluster_organization.is_in_cluster_mode?
+        if cluster_id.present?
+          cluster_array = [cluster_id]
+          # Based on force/use/show definition we don't really need this validation.
+          # A force cluster organization won't return an entity out of a cluster, but
+          # we don't know if the clusterized entities are fully definition-compliant.
+          cluster_array << nil if cluster_organization.optional_suborganization_mode?
+          active_record_collection = active_record_collection.joins(:cluster_entities).where("cluster_entities.cluster_id": cluster_array)
+        end
+        # you may use a block only with clusterizable data
+        yield(active_record_collection) if block_given?
+      end
+      active_record_collection
+    end
+
+    #
+    #
+    #
+    def set_collection_before_group_by_entity!(cluster_organization,active_record_collection,model_class,entity_params)
+      entity_params_keys = [:entity_name,:entity_attribute,:entity_id,:entity_id_attribute,:unamed]
+      entity_params = entity_params.slice(*entity_params_keys).values
+      if model_class.try(:reflections).try(:keys).try(:include?,entity_params[0])
+        entity_params << "#{entity_params[0]}_id".to_sym
+        if entity_params[0] == 'cluster'
+          entity_params << :unclustered if cluster_organization.is_in_cluster_mode?
+          active_record_collection = Klastera.filter_clusterized_collection_with!(
+            cluster_organization,
+            entity_params[2],
+            active_record_collection
+          )
+        end
+        yield(
+          active_record_collection,
+          entity_params_keys.zip(entity_params).to_h)
+      end
+    end
+
     ##
      # Returns a ::Cluster::ActiveRecord_Relation from a given scope
      #
     def clusters_from!(user,organization,scope,includes=[])
-      _scope_result = scope.respond_to?(:map) ? scope : cluster_scope!(user,organization,scope,includes)
-      ::Cluster.where(id: _scope_result.related_clusters.map(&:cluster_id))
+      cluster_scope!(user,organization,scope,includes).related_clusters
     end
 
     ##
-     # Returns a scope with filtered by clusters or
-     # the scope filterd its organization if
-     # the organization haven't active the cluster mode
-     #
+     # Returns a scope filtered by clusters or its
+     # organization if the cluster mode is not active.
      #
     def cluster_scope!(user,organization,scope,includes=[])
-      scope_klass = scope_class(scope)
-      raise RelatedClusterEntityComplianceError, "attribute cluster_id was not found in #{scope_klass}" unless scope_klass.try(:column_names).try(:include?,'cluster_id')
-      scope_klass = scope_klass.includes(includes) if includes.present?
-      scope_klass = scope_klass.where(organization_id: organization)
-
+      scope_klass = scope_class(scope).where(organization_id: organization)
       session_clusters(user,organization) do |clusters|
-        if organization.required_suborganization_mode?
-          scope_klass = scope_klass.where("#{scope.table_name}.cluster_id IN (?)",clusters)
-        elsif organization.optional_mode? && user.is_a_cluster_user?
-          with_clusters = clusters.present? ? "#{scope.table_name}.cluster_id IN (#{clusters.map(&:id).join(',')})" : nil
-          without_clusters = "#{with_clusters.blank? ? '' : ' OR ' }#{scope.table_name}.cluster_id IS NULL"
-          scope_klass = scope_klass.where("#{with_clusters}#{without_clusters}")
+        if organization.is_in_cluster_mode?
+          scope_klass = scope_klass.select("DISTINCT ON (#{scope.table_name}.id) #{scope.table_name}.id, #{scope.table_name}.*")
+          scope_klass = scope_klass.includes(includes) if includes.present?
+          cluster_ids = clusters.map(&:id)
+          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 SQL clashes due to DISTINCT ON clause
+          scope_klass = scope_class(scope).where(organization_id: organization).where(id: scope_klass.map(&:id))
         end
       end
-
       scope_klass
     end
 
@@ -45,6 +121,7 @@ module Klastera
      # TODO:
      # Implement a validation to ensure that
      # object is a ActiveRecord::Base class
+     # (or just try to guess how to retrieve the argument class)
      #
      ##
     def scope_class(object)
@@ -59,7 +136,7 @@ module Klastera
      #
      ##
     def session_clusters(user,organization)
-      clusters = organization.is_in_cluster_mode? ? ::ClusterUser.get_clusters_from(user,organization) : []
+      clusters = organization.is_in_cluster_mode? ? ::ClusterUser.clusters_from(user,organization) : []
       if block_given?
         clusters = clusters.reject{|c|c.id.blank?}
         yield(clusters)
@@ -75,7 +152,7 @@ module Klastera
       helper_method :cluster_user
       helper_method :cluster_organization
       helper_method :cluster_clusters
-      # helper_method :cluster_clusters_ids
+      helper_method :cluster_scope_filtered
       helper_method :user_has_more_than_one_cluster
       helper_method :clusters_from
     end
@@ -90,8 +167,8 @@ module Klastera
       hide_action :cluster_organization=
       hide_action :cluster_clusters
       hide_action :cluster_clusters=
-      # hide_action :cluster_clusters_ids
-      # hide_action :cluster_clusters_ids=
+      hide_action :cluster_scope_filtered
+      hide_action :cluster_scope_filtered=
       hide_action :user_has_more_than_one_cluster
       hide_action :user_has_more_than_one_cluster=
       hide_action :clusters_from
@@ -125,9 +202,15 @@ module Klastera
     Klastera.session_clusters(cluster_user,cluster_organization)
   end
 
-  # def cluster_clusters_ids
-  #   cluster_clusters.map(&:id)
-  # end
+  def cluster_scope_filtered(scope,cluster_id,includes=[])
+    Klastera.cluster_scope_filtered!(
+      scope,
+      cluster_id,
+      cluster_user,
+      cluster_organization,
+      includes
+    )
+  end
 
   def user_has_more_than_one_cluster
     @cluster_clusters ||= cluster_clusters