klastera 1.5.3 → 1.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 26024cfbeac47db7de270c9281e98d197b377f53c4122fb4a6eec246dae615cb
-  data.tar.gz: f452de2debec0cc4c34549ec98f5dcd387cbb8d32102ed6924ff06ccc89b90cd
+  metadata.gz: 1f9a474c54506a3e2a3b92ce5961de94a71dd28699354b671be08337b4bdfac5
+  data.tar.gz: 01db2dd1040338587462593e22ef1103f3c7ecd6ce13e48656dcd47eb7cf31c9
 SHA512:
-  metadata.gz: '096e198a76a0d1f12b83339d76d9fc6f83c64ac3b893b5dafc5ef1b77f4179aee49b146e1be92d2f9ae9b572c4d108dbc3bb9ba80c78a6404459850a1dcd4265'
-  data.tar.gz: 416ef7b6a278be2686cf613b5ea5382bd728a480486217f2a2b3511677d93b4631a0818cc08a1a94f74bcf7bc57c7598a3f871a901f14f116b817f8b4ec1dcfe
+  metadata.gz: a54cf22f075c58094950f74345fe924686f79ab8454ca6afc4b80555bbe26367d56500867b1fbf83f3f270d9f0effe9d9907ceacdbc18f02f32f35654abf237d
+  data.tar.gz: d197f19bc4c590359364cbd965295fb981dedfc22f0e33cf02673c75bfc5228b50f6543d316ee2de887437deec92ceb65bcadc617f1d6a4b1af3f2e44f53ae05

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2020 Gino Barahona
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,3 @@
+= Klastera
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,37 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Klastera'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+load 'rails/tasks/statistics.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/assets/javascripts/klastera/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/app/assets/javascripts/klastera/clusters.js

@@ -0,0 +1,2 @@
+// Place all the behaviors and hooks related to the matching controller here.
+// All this logic will automatically be available in application.js.

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

@@ -0,0 +1,46 @@
+.nested-cluster-user,
+.nested-cluster-entity {
+  .panel {
+    margin: 0;
+    border-bottom: 0;
+    .panel-heading {
+      padding: 10px 12px 10px 15px;
+      background: none;
+    }
+  }
+}
+
+#cluster-remote-table {
+  .cluster-id { width: 70px; }
+  .cluster-order { width: 70px; }
+  .cluster-color { width: 70px; }
+  .odd .colorless { color: #F9F9F9 }
+  .even .colorless { color: #FFF }
+  tr:hover .colorless { color: #444; opacity: 0.2;}
+}
+
+#cluster-remote-form {
+  h4.blank-modal-title {
+    margin: 0;
+    line-height: 28px;
+    letter-spacing: 0.05rem;
+    font-size: 21px;
+    font-weight: 400;
+    color: #666;
+  }
+}
+
+
+ul.klastera-option-help {
+  padding-left: 20px;
+  list-style-type: disc;
+}
+
+ul.klastera-option-help li {
+  margin-bottom: 10px;
+  padding-bottom: 5px;
+  border-bottom: 1px solid #DDD;
+}
+
+ul.klastera-option-help li b { color: #8A8A8A; font-weight: 400; }
+ul.klastera-option-help li b:first-child { color: #2E5F9B; font-weight: bold; }

data/app/controllers/klastera/application_controller.rb

@@ -0,0 +1,29 @@
+module Klastera
+  class ApplicationController < ::ApplicationController
+    protect_from_forgery with: :exception
+    layout :disable_in_xhr_requests
+    before_action :set_xhr_render_session
+    before_action :check_access_to_cluster_admin
+
+    def check_access_to_cluster_admin
+      unless cluster_user.can_admin_clusters?
+        redirect_to main_app.root_path, flash: { alert: t('klastera.messages.access_cluster_admin') }
+      end
+    end
+
+    if respond_to?(:skip_after_action)
+      skip_after_action :verify_authorized
+    end
+
+    private
+    def disable_in_xhr_requests
+      request.xhr? ? false : nil
+    end
+
+    def set_xhr_render_session
+      return unless request.get?
+      # request.xhr? return nil when this is not a XHR request, but we need a boolean
+      session[:xhr_render] = request.xhr?.present?
+    end
+  end
+end

data/app/controllers/klastera/clusters_controller.rb

@@ -0,0 +1,60 @@
+require_dependency "klastera/application_controller"
+
+module Klastera
+  class ClustersController < ApplicationController
+    before_action :set_cluster, only: %i[ edit update destroy transfer ]
+    before_action :set_clusters, only: %i[ index ]
+
+    def index; end
+
+    def new
+      @cluster = ::Cluster.new
+    end
+
+    def edit; end
+
+    def transfer
+      @transfer = Transfer.new
+    end
+
+    def create
+      @cluster = ::Cluster.new(cluster_params)
+      if @cluster.save
+        @cluster = ::Cluster.new
+        set_clusters
+      end
+    end
+
+    def update
+      if @cluster.update(cluster_params)
+        set_clusters
+      end
+    end
+
+    def destroy
+      new_cluster_id = params.require(:transfer).permit(:new_cluster_id).values.first rescue nil
+      @transfer = Transfer.new( current_cluster: @cluster, new_cluster_id: new_cluster_id )
+      if @transfer.valid?
+        if @transfer.apply!
+          @cluster.destroy
+        end
+        set_clusters
+      end
+    end
+
+    private
+      def set_cluster
+        @cluster = ::Cluster.find(params[:id])
+      end
+
+      def set_clusters
+        @clusters = cluster_organization.clusters
+      end
+
+      def cluster_params
+        parameters = params.require(:cluster).permit(:nid, :name, :color, :order)
+        parameters[:organization_id]=cluster_organization.id
+        parameters
+      end
+  end
+end

data/app/helpers/klastera/application_helper.rb

@@ -0,0 +1,40 @@
+module Klastera
+  module ApplicationHelper
+    def ac_errors_as_html_list(errors)
+      array_as_html_list(
+        errors.messages.inject([]) do |array,(attr,errors_array)|
+          array.concat(errors_array)
+          array
+        end
+      )
+    end
+
+    def array_as_html_list(array)
+      "<ul style='padding:0;'><li>#{array.join("</li><li>")}</li></ul>".html_safe
+    end
+
+    def method_missing(method, *args, &block)
+      if method.to_s.end_with?('_path') or method.to_s.end_with?('_url')
+        if main_app.respond_to?(method)
+          main_app.send(method, *args)
+        else
+          super
+        end
+      else
+        super
+      end
+    end
+
+    def respond_to?(method, include_priv=false)
+      if method.to_s.end_with?('_path') or method.to_s.end_with?('_url')
+        if main_app.respond_to?(method,include_priv)
+          true
+        else
+          super
+        end
+      else
+        super
+      end
+    end
+  end
+end

data/app/models/klastera/cluster.rb

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

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/cluster_filter.rb

@@ -0,0 +1,5 @@
+module Klastera
+  class ClusterFilter
+    include Klastera::Concerns::ClusterFilter
+  end
+end

data/app/models/klastera/cluster_user.rb

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

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

@@ -0,0 +1,67 @@
+module Klastera::Concerns::Cluster
+  extend ActiveSupport::Concern
+  # 'included do' causes the included code to be evaluated in the
+  # context where it is included (cluster.rb), rather than being
+  # executed in the module's context (klastera/concerns/models/cluster).
+  included do
+    self.table_name = 'clusters'
+    
+    attr_reader :last_record
+
+    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
+    has_many :cluster_entities, dependent: :destroy
+
+    scope :of, -> (organization,except_ids=[]) {
+      _scope = where(organization: organization)
+      _scope = _scope.where.not(id: except_ids) unless except_ids.blank?
+      _scope
+    }
+
+    validates :name, presence: true
+    validates :nid, presence: true
+    validates :organization_id, presence: true
+
+    validates_uniqueness_of :nid, scope: [:nid, :organization_id]
+
+    before_destroy do |record|
+      self.can_transfer_and_destroy?
+    end
+
+    def siblings
+      ::Cluster.of(self.organization,[self.id])
+    end
+
+    def is_the_last_record_in_required_suborganization_mode?
+      self.organization.required_suborganization_mode? && self.siblings.blank?
+    end
+
+    def required_transfer?
+      self.organization.required_suborganization_mode?
+    end
+
+    def has_related_entities_using_it?
+      self.cluster_entities.size > 0
+    end
+
+    def can_transfer_and_destroy?
+      can_destroy = true
+      if is_the_last_record_in_required_suborganization_mode?
+        errors.add(:last_record, I18n.t('klastera.messages.cant_delete_the_last_record_in_required_suborganization_mode'))
+        can_destroy = false
+      end
+      can_destroy
+    end
+
+    def display_name_nid
+      "#{name} (#{nid==Klastera::UNCLUSTERED_ENTITY ? I18n.t("klastera.#{ Klastera::UNCLUSTERED_ENTITY}") : nid})"
+    end
+  end
+  
+  module ClassMethods
+  end
+end

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

@@ -0,0 +1,18 @@
+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
+    def left_join_sources_of(scope_klass)
+      scope_klass_arel_table = scope_klass.arel_table
+      scope_klass_arel_table.join(arel_table, Arel::Nodes::OuterJoin).on(
+        scope_klass_arel_table[:id].eq(arel_table[:entity_id]), arel_table[:entity_type].eq(scope_klass.name)
+      ).join_sources
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Klastera::Concerns::ClusterFilter
+  extend ActiveSupport::Concern
+
+  included do
+    include ActiveModel::Model
+    include ActiveModel::Validations::Callbacks
+
+    attr_accessor :cluster_id
+  end
+  
+  module ClassMethods
+    def attr_accessor(*vars)
+      @attributes ||= []
+      @attributes.concat vars
+      super(*vars)
+    end
+
+    def attributes
+      @attributes
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Klastera::Concerns::ClusterUser
+  extend ActiveSupport::Concern
+
+  included do
+    self.table_name = 'cluster_users'
+    belongs_to :user
+    belongs_to :cluster
+    validates :cluster_id, presence: true
+  end
+  
+  module ClassMethods
+    ##
+     # Return a Cluster::ActiveRecord_Relation of organization (and) user
+     #
+    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) ).order(order: :asc)
+    end
+
+    ##
+     # Return a User::ActiveRecord_Relation of organization (and) user
+     #
+    def users_of(organization)
+      ::User.eager_load(:cluster_users).where(users: { organization_id: organization } )
+    end
+
+    ##
+     # Return a hash of users and its clusters
+     #
+    def users_hash_of(organization)
+      users = {}
+      rows = self.users_of(organization).pluck("users.id AS user_id","cluster_users.cluster_id").uniq
+      rows.each do |row|
+        user_id = row.first
+        users[user_id] ||= []
+        users[user_id] << row.last
+      end
+      users
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+module Klastera::Concerns::Clusterizable
+  extend ActiveSupport::Concern
+
+  included do
+    class MutipleClustersOperationError < StandardError; end
+
+    belongs_to :cluster
+
+    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: -> { cluster_id.present? && organization.present? && organization.required_suborganization_mode? }
+    validate :at_least_one_cluster_entity, if: -> { organization.present? && organization.required_suborganization_mode? }
+    validate :uniqueness_of_cluster_entity_record
+
+    scope :includes_cluster, -> { includes(cluster_entities: :cluster) }
+    scope :with_clusters, -> { 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'))
+      end
+    end
+
+    def allow_multiple_clusters?(default=:one)
+      organization.present? && organization.cluster_cardinality_of(self.class, default: default) == :many
+    end
+
+    ##
+     # This method has been optimized to use preloaded associations when available
+     # Falls back to efficient single-query approach when associations aren't preloaded
+     ##
+    def clusters_string_separated_by(separator, attribute=:name)
+      # Use Rails cache for frequently accessed cluster strings
+      cache_key = [self.cache_key_with_version, :clusters_string, separator, attribute]
+      
+      Rails.cache.fetch(cache_key, expires_in: 30.minutes) do
+        Klastera.entity_clusters_string_list!(
+          cluster_entities, separator, attribute
+        )
+      end
+    end
+
+    ##
+     # Optimized version without cache for real-time updates
+     ##
+    def clusters_string_separated_by_uncached(separator, attribute=:name)
+      Klastera.entity_clusters_string_list!(
+        cluster_entities, separator, attribute
+      )
+    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
+
+    def uniqueness_of_cluster_entity_record
+      if cluster_entities.map(&:cluster_id).uniq.size != cluster_entities.size
+        return errors.add(:cluster_entities, I18n.t('klastera.messages.duplicated_cluster_entity') )
+      end
+    end
+  end
+  
+  module ClassMethods
+    def cluster_entity_params
+      [ :cluster_id, { cluster_entities_attributes: [:id, :cluster_id, :_destroy] } ]
+    end
+
+    ##
+     # Efficiently preload clusters for a collection of entities
+     # This prevents N+1 queries when calling clusters_string_separated_by on multiple entities
+     ##
+    def preload_clusters(collection)
+      return collection if collection.empty?
+      
+      ActiveRecord::Associations::Preloader.new.preload(
+        collection, 
+        cluster_entities: :cluster
+      )
+      collection
+    end
+
+    ##
+     # Batch update cluster assignments for multiple entities
+     # More efficient than individual updates
+     ##
+    def batch_assign_clusters(entity_ids, cluster_ids)
+      return if entity_ids.empty? || cluster_ids.empty?
+
+      # Clear existing assignments
+      Klastera::ClusterEntity.where(
+        entity_type: self.name,
+        entity_id: entity_ids
+      ).destroy_all
+
+      # Create new assignments
+      cluster_assignments = []
+      entity_ids.each do |entity_id|
+        cluster_ids.each do |cluster_id|
+          cluster_assignments << {
+            entity_type: self.name,
+            entity_id: entity_id,
+            cluster_id: cluster_id,
+            created_at: Time.current,
+            updated_at: Time.current
+          }
+        end
+      end
+
+      Klastera::ClusterEntity.insert_all(cluster_assignments) if cluster_assignments.any?
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Klastera::Concerns::Organization
+  extend ActiveSupport::Concern
+  included do
+    serialize :cluster_config
+    has_many :clusters
+    
+    validates :use_cluster_as, inclusion: { in: ::Cluster::MODES.map{|m|m.to_s}, message: I18n.t('klastera.clusters.wrong_option') }, if: proc{ use_cluster_as.present? }
+
+    # Return a symbol version of use_cluster_as value
+    def cluster_mode
+      self.use_cluster_as.to_s.to_sym
+    end
+
+    def cluster_cardinality_of(entity, default: :many)
+      if cluster_config.is_a?(Hash)
+        entities_cardinality = cluster_config[:entities]&.[](:cardinality)||{}
+        entity = entity.to_s.to_sym
+        if entities_cardinality.has_key?(entity)
+          default = entities_cardinality[entity]
+        end
+      end
+      default.to_s.to_sym
+    end
+
+    ##
+     # Return a boolean if one of three of options was set in organization
+     # As useless option you can retrieve the value passing false as argument.
+     #
+     ##
+    def is_in_cluster_mode?(return_the_mode=false)
+      is_active = cluster_mode.present? && ::Cluster::MODES.include?(cluster_mode)
+      ( return_the_mode ? ( is_active ? cluster_mode : false ) : is_active )
+    end
+
+    def required_suborganization_mode?
+      cluster_mode == ::Cluster::REQUIRED_MODE
+    end
+
+    def optional_suborganization_mode?
+      cluster_mode == ::Cluster::OPTIONAL_MODE
+    end
+  end
+  
+  module ClassMethods
+    def cluster_params
+      [ :use_cluster_as ]
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+
+
+module Klastera::Concerns::Transfer
+  extend ActiveSupport::Concern
+
+  included do
+    include ActiveModel::Model
+    include ActiveModel::Validations::Callbacks
+
+    attr_accessor :current_cluster, :new_cluster_id
+
+    validates :current_cluster, presence: true
+    validates :new_cluster_id, presence: true, if: proc { self.required_transfer? }
+
+    validate do
+      new_cluster = ::Cluster.find(self.new_cluster_id.to_i) rescue nil
+
+      if current_cluster.class.name != 'Cluster' || current_cluster.try(:is_the_last_record_in_required_suborganization_mode?)
+        errors.add(:current_cluster, I18n.t('klastera.messages.current_cluster.cant_transfer'))
+      elsif self.required_transfer? && new_cluster_id.present? && new_cluster.nil?
+        errors.add(:new_cluster_id, I18n.t('klastera.messages.new_cluster_id.nil'))
+      elsif current_cluster.id == new_cluster.try(:id)
+        errors.add(:new_cluster_id, I18n.t('klastera.messages.new_cluster_id.same'))
+      elsif new_cluster.present? && current_cluster.organization_id != new_cluster.organization_id
+        # Clusters from another organization do not exist
+        errors.add(:new_cluster_id, I18n.t('klastera.messages.new_cluster_id.nil'))
+      end
+    end
+
+    def required_transfer?
+      self.current_cluster.required_transfer? && self.current_cluster.has_related_entities_using_it?
+    end
+
+    ##
+    # A returned boolean is expected. It should always be true even nothing is
+    # transfered, and it only will return false if creation fails.
+    #
+    def apply!
+      Klastera::ClusterEntity.create(current_cluster.cluster_entities.map{ |relation|
+        next if self.new_cluster_id.blank?
+        { cluster_id: self.new_cluster_id, entity_id: relation.entity_id, entity_type: relation.entity_type }
+      }.compact)
+    end
+  end
+end