klastera 1.5.2.5 → 1.5.3

data/config/locales/es.yml

@@ -1,96 +0,0 @@
-es:
-  klastera:
-    without_cluster: Sin cluster
-    cluster:
-      title: Cluster
-      id: Cluster ID
-    user:
-      add_cluster: Agregar cluster
-      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 Super Admin
-        text: Este rol es sólo para usuarios super admin
-    roles:
-      root: Super Admin
-      admin: Admin Cluster
-      user: Usuario Cluster
-    using_cluster_as: Usando cluster como
-    cluster_order: Orden
-    cluster_id: ID
-    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 en modo
-    required_suborganization: Obligatorio
-    optional_suborganization: Opcional
-    clusters:
-      all: Todos
-      title: Clusters
-      siblings: Seleccione un cluster
-      cant_delete: No se puede eliminar
-      wrong_option: "%{value} es una opción inválida"
-      entities: "[agregar entidades]"
-      index:
-        title: Gestión de clusters
-      new:
-        title: Nuevo Cluster
-      edit:
-        title: Editar Cluster %{cluster_nid}
-      destroy:
-        title: Eliminar Cluster %{cluster_nid}
-      transfer:
-        title: Eliminar Cluster %{cluster_nid}
-        required: Para eliminar el Cluster es necesario asignar las entidades asociadas a un nuevo Cluster
-        optional: Entidades asociadas al Cluster pueden quedar sin asignar o ser asignadas a un nuevo Cluster
-    actions:
-      filter: Filtrar
-      cancel: Cancelar
-      add: Agregar
-      delete: Eliminar
-      create: Crear
-      update: Actualizar
-      deleted: Eliminado
-      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
-      duplicated_cluster_entity: Hay un cluster duplicado
-      new_cluster_id:
-        nil: Cluster no existe
-        same: Cluster no puede ser el mismo
-      current_cluster:
-        cant_transfer: No se puede eliminar ni mover el cluster
-      access_cluster_admin: No puede acceder a esta página
-    help:
-      popover:
-        title: Descripción de cada opción
-        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':
-        new_cluster_id: Cluster a transferir
-  activerecord:
-    models:
-      'klastera/cluster':
-        one: Cluster
-        other: Clusters
-    attributes:
-      organization:
-        use_cluster_as: Activar y usar cluster como

data/config/routes.rb

@@ -1,7 +0,0 @@
-Klastera::Engine.routes.draw do
-  resources :clusters, except: [:show] do
-    member do
-      get :transfer
-    end
-  end
-end

data/db/migrate/20200324203929_create_klastera_clusters.rb

@@ -1,12 +0,0 @@
-class CreateKlasteraClusters < ActiveRecord::Migration
-  def change
-    create_table :clusters do |t|
-      t.references :organization
-      t.text :name
-      t.string :nid
-      t.string :color
-
-      t.timestamps null: false
-    end
-  end
-end

data/db/migrate/20200326111219_add_cluster_options_to_organizations.rb

@@ -1,6 +0,0 @@
-class AddClusterOptionsToOrganizations < ActiveRecord::Migration
-  def change
-    add_column :organizations, :use_cluster_as, :string
-    add_index :organizations, :use_cluster_as, using: :btree
-  end
-end

data/db/migrate/20200330010551_create_klastera_cluster_users.rb

@@ -1,9 +0,0 @@
-class CreateKlasteraClusterUsers < ActiveRecord::Migration
-  def change
-    create_table :cluster_users do |t|
-      t.integer :user_id, null: false
-      t.integer :cluster_id, null: false
-    end
-    add_column :users, :cluster_role, :string
-  end
-end

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/db/migrate/20250429110829_add_entity_id_index_to_cluster_entities.rb

@@ -1,6 +0,0 @@
-class AddEntityIdIndexToClusterEntities < ActiveRecord::Migration[5.2]
-  disable_ddl_transaction!
-  def change
-    add_index :cluster_entities, :entity_id, algorithm: :concurrently
-  end
-end

data/db/migrate/20250429110830_add_entity_id_index_and_entity_type_index_to_cluster_entities.klastera.rb

@@ -1,7 +0,0 @@
-# This migration comes from klastera (originally 20250429110947)
-class AddEntityIdIndexAndEntityTypeIndexToClusterEntities < ActiveRecord::Migration[5.2]
-  disable_ddl_transaction!
-  def change
-    add_index :cluster_entities, [:entity_id,:entity_type], algorithm: :concurrently
-  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.5"
-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