klastera 1.5.2.4 → 1.5.3

data/db/migrate/20200330221601_add_order_field_to_clusters.rb

@@ -1,5 +0,0 @@
-class AddOrderFieldToClusters < ActiveRecord::Migration
-  def change
-    add_column :clusters, :order, :integer
-  end
-end

data/db/migrate/20200518142609_create_klastera_cluster_entities.rb

@@ -1,8 +0,0 @@
-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/db/migrate/20200908180057_add_cluster_config_to_organization.rb

@@ -1,5 +0,0 @@
-class AddClusterConfigToOrganization < ActiveRecord::Migration
-  def change
-    add_column :organizations, :cluster_config, :text
-  end
-end

data/db/migrate/20220602222332_add_unique_index_to_cluster_entities.rb

@@ -1,5 +0,0 @@
-class AddUniqueIndexToClusterEntities < ActiveRecord::Migration[5.2]
-  def change
-  	 add_index :cluster_entities, %i[cluster_id entity_id entity_type], unique: true, name: :index_on_cluster_id_and_entity_id_and_entity_type
-  end
-end

data/lib/klastera/engine.rb

@@ -1,5 +0,0 @@
-module Klastera
-  class Engine < ::Rails::Engine
-    isolate_namespace Klastera
-  end
-end

data/lib/klastera/version.rb

@@ -1,3 +0,0 @@
-module Klastera
-  VERSION = "1.5.2.4"
-end

data/lib/klastera.rb

@@ -1,236 +0,0 @@
-require "klastera/engine"
-
-module Klastera
-  mattr_accessor :organization_class
-
-  extend ActiveSupport::Concern
-
-  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
-
-    ##
-     # 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)
-      object
-    end
-
-    ##
-     # Returns which clusters a user can see avoiding unnecessary queries if the cluster restraint doesn't apply
-     #
-    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.to_a.append(
-          ::Cluster.new({nid: UNCLUSTERED_ENTITY, name: I18n.t("klastera.#{UNCLUSTERED_ENTITY}"), order: UNCLUSTERED_POSITION })
-        )
-      end
-      active_record_collection
-    end
-
-    ##
-     # Return a string with cluster attribute separated by separator argument
-     # A array of cluster ids can be passed fo filter the result
-     #
-    def entity_clusters_string_list!(cluster_entities,separator,attribute=:name,allowed_cluster_ids=nil)
-      _cluster_entities = cluster_entities.reject(&:nil?)
-      if allowed_cluster_ids.is_a?(Array)
-        _cluster_entities.select!{|ce| allowed_cluster_ids.include?(ce.cluster_id)}
-      end
-      _cluster_entities.map do |ce|
-        ce.cluster.try(attribute)
-      end.compact.sort.join(separator)
-    end
-
-    ##
-     # 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_list!(organization,user)
-      self.entity_clusters_string_list!(cluster_entities, separator, attribute, @clusters_session.map(&:id))
-    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 should_clusterize_scope?(user, organization, cluster_filter=nil, force_cluster_clause=false)
-      should = false # I don't know if this is a good idea
-      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
-          # 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
-          should = true
-        end
-      end
-      yield(should,cluster_ids)
-    end
-
-    #
-    # The cleanest and fast way to clusterize a entity!
-    #
-    def cluster_scope!(scope_klass, user, organization, cluster_filter=nil, force_cluster_clause=false)
-      scope = scope_class(scope_klass)
-      should_clusterize_scope?(user,organization,cluster_filter,force_cluster_clause) do |should,cluster_ids|
-        if should
-          scope = scope.eager_load(:organization,cluster_entities: :cluster).where( cluster_entities: { cluster_id: cluster_ids } )
-        end
-      end
-      scope.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_filter=nil, force_cluster_clause=false)
-      unclusterized_scope = scope_class(scope_klass)
-
-      if organization.is_in_cluster_mode? && ( force_cluster_clause || user.cannot_skip_cluster_clause? )
-        unclusterized_scope = unclusterized_scope.joins(relation).joins(Klastera::ClusterEntity.left_join_sources_of(cluster_entity_klass))
-      end
-
-      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
-
-    #
-    # 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.compact, 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)
-      cluster_entities_arel_table = Klastera::ClusterEntity.arel_table
-      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(Klastera::ClusterEntity.left_join_sources_of(scope_klass)).joins(cluster_entities_cluster)
-    end
-  end
-
-  ##################################################################################################################################################
-
-  def cluster_user
-    current_user
-  end
-
-  def cluster_organization
-    current_organization
-  end
-
-  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_list(include_unclustered=true)
-    Klastera.cluster_list!(cluster_organization, cluster_user, include_unclustered)
-  end
-
-  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_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 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)
-  end
-
-  def cluster_scope_left_join(scope_klass)
-    Klastera.cluster_scope_left_join!(scope_klas,cluster_organization)
-  end
-
-  included do
-    Klastera::KLSTR_HELPERS.each do |action|
-      if respond_to?(:helper_method)
-        helper_method(action)
-      end
-      if respond_to?(:hide_action)
-        hide_action(helper)
-        hide_action("#{helper}=")
-      end
-    end
-  end
-end

data/lib/tasks/klastera_tasks.rake

@@ -1,32 +0,0 @@
-# desc "Explaining what the task does"
-# task :klastera do
-#   # Task goes here
-# end
-
-
-namespace :klastera do
-  namespace :seed do
-    
-    desc "Move cluster_id to cluster_entities"
-    task :cluster_entities, [:entity] => :environment do |task,args|
-      begin
-        klass = args.entity.constantize
-        ActiveRecord::Base.transaction do
-          klass.where.not(cluster_id: nil).each do |entity|
-            if entity.cluster.blank?
-              puts "Cluster ID #{entity.cluster_id} was not found!"
-              puts "skip..."
-              next
-            end
-            Klastera::ClusterEntity.create(entity: entity, cluster: entity.cluster)
-          end
-        end
-      rescue NameError => ne
-        puts "NameError Exception: #{ne}"
-      rescue ActiveRecord::StatementInvalid => asi
-        puts "ActiveRecord::StatementInvalid Exception #{asi}"
-      end
-    end
-
-  end
-end

data/test/controllers/klastera/clusters_controller_test.rb

@@ -1,52 +0,0 @@
-require 'test_helper'
-
-module Klastera
-  class ClustersControllerTest < ActionController::TestCase
-    setup do
-      @cluster = klastera_clusters(:one)
-      @routes = Engine.routes
-    end
-
-    test "should get index" do
-      get :index
-      assert_response :success
-      assert_not_nil assigns(:clusters)
-    end
-
-    test "should get new" do
-      get :new
-      assert_response :success
-    end
-
-    test "should create cluster" do
-      assert_difference('Cluster.count') do
-        post :create, cluster: { color: @cluster.color, name: @cluster.name, nid: @cluster.nid }
-      end
-
-      assert_redirected_to cluster_path(assigns(:cluster))
-    end
-
-    test "should show cluster" do
-      get :show, id: @cluster
-      assert_response :success
-    end
-
-    test "should get edit" do
-      get :edit, id: @cluster
-      assert_response :success
-    end
-
-    test "should update cluster" do
-      patch :update, id: @cluster, cluster: { color: @cluster.color, name: @cluster.name, nid: @cluster.nid }
-      assert_redirected_to cluster_path(assigns(:cluster))
-    end
-
-    test "should destroy cluster" do
-      assert_difference('Cluster.count', -1) do
-        delete :destroy, id: @cluster
-      end
-
-      assert_redirected_to clusters_path
-    end
-  end
-end

data/test/fixtures/klastera/cluster_users.yml

@@ -1,9 +0,0 @@
-# Read about fixtures at http://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html
-
-one:
-  user_id: 1
-  cluster_id: MyString
-
-two:
-  user_id: 1
-  cluster_id: MyString

data/test/fixtures/klastera/clusters.yml

@@ -1,11 +0,0 @@
-# Read about fixtures at http://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html
-
-one:
-  nid: MyString
-  name: MyText
-  color: MyString
-
-two:
-  nid: MyString
-  name: MyText
-  color: MyString

data/test/integration/navigation_test.rb

@@ -1,8 +0,0 @@
-require 'test_helper'
-
-class NavigationTest < ActionDispatch::IntegrationTest
-  # test "the truth" do
-  #   assert true
-  # end
-end
-

data/test/klastera_test.rb

@@ -1,7 +0,0 @@
-require 'test_helper'
-
-class KlasteraTest < ActiveSupport::TestCase
-  test "truth" do
-    assert_kind_of Module, Klastera
-  end
-end

data/test/models/klastera/cluster_test.rb

@@ -1,9 +0,0 @@
-require 'test_helper'
-
-module Klastera
-  class ClusterTest < ActiveSupport::TestCase
-    # test "the truth" do
-    #   assert true
-    # end
-  end
-end

data/test/models/klastera/cluster_user_test.rb

@@ -1,9 +0,0 @@
-require 'test_helper'
-
-module Klastera
-  class ClusterUserTest < ActiveSupport::TestCase
-    # test "the truth" do
-    #   assert true
-    # end
-  end
-end

data/test/test_helper.rb

@@ -1,21 +0,0 @@
-# Configure Rails Environment
-ENV["RAILS_ENV"] = "test"
-
-require File.expand_path("../../test/dummy/config/environment.rb",  __FILE__)
-ActiveRecord::Migrator.migrations_paths = [File.expand_path("../../test/dummy/db/migrate", __FILE__)]
-ActiveRecord::Migrator.migrations_paths << File.expand_path('../../db/migrate', __FILE__)
-require "rails/test_help"
-
-# Filter out Minitest backtrace while allowing backtrace from other libraries
-# to be shown.
-Minitest.backtrace_filter = Minitest::BacktraceFilter.new
-
-# Load support files
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
-
-# Load fixtures from the engine
-if ActiveSupport::TestCase.respond_to?(:fixture_path=)
-  ActiveSupport::TestCase.fixture_path = File.expand_path("../fixtures", __FILE__)
-  ActionDispatch::IntegrationTest.fixture_path = ActiveSupport::TestCase.fixture_path
-  ActiveSupport::TestCase.fixtures :all
-end