yeshoua_crm 1.0.0

data/lib/yeshoua_crm/acts_as_taggable/rcrm_acts_as_taggable.rb

@@ -0,0 +1,350 @@
+require 'active_record'
+
+module YeshouaCrm
+  module ActsAsTaggable #:nodoc:
+    module Taggable #:nodoc:
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def taggable?
+          false
+        end
+
+        def rcrm_acts_as_taggable
+          has_many :taggings, :as => :taggable, :dependent => :destroy, :class_name => '::YeshouaCrm::ActsAsTaggable::Tagging'
+          has_many :tags, :through => :taggings, :class_name => '::YeshouaCrm::ActsAsTaggable::Tag'
+
+          before_save :save_cached_tag_list
+
+          after_create :save_tags
+          after_update :save_tags
+
+          include YeshouaCrm::ActsAsTaggable::Taggable::InstanceMethods
+          extend YeshouaCrm::ActsAsTaggable::Taggable::SingletonMethods
+
+          alias_method :reload_without_tag_list, :reload
+          alias_method :reload, :reload_with_tag_list
+
+          class_eval do
+            def self.taggable?
+              true
+            end
+          end
+        end
+
+        def cached_tag_list_column_name
+          'cached_tag_list'
+        end
+
+        def set_cached_tag_list_column_name(value = nil, &block)
+          define_attr_method :cached_tag_list_column_name, value, &block
+        end
+
+        # Create the taggable tables
+        # === Options hash:
+        # * <tt>:table_name</tt> - use a table name other than viewings
+        # To be used during migration, but can also be used in other places
+        def create_taggable_table(options = {})
+          tag_name_table = options[:tags] || :tags
+
+          if !self.connection.table_exists?(tag_name_table)
+            self.connection.create_table(tag_name_table) do |t|
+              t.column :name, :string
+            end
+          end
+
+          taggings_name_table = options[:taggings] || :taggings
+          if !self.connection.table_exists?(taggings_name_table)
+            self.connection.create_table(taggings_name_table) do |t|
+              t.column :tag_id, :integer
+              t.column :taggable_id, :integer
+
+              # You should make sure that the column created is
+              # long enough to store the required class names.
+              t.column :taggable_type, :string
+
+              t.column :created_at, :datetime
+            end
+
+            self.connection.add_index :taggings, :tag_id
+            self.connection.add_index :taggings, [:taggable_id, :taggable_type]
+          end
+        end
+
+        def drop_taggable_table(options = {})
+          tag_name_table = options[:tags] || :tags
+          if self.connection.table_exists?(tag_name_table)
+            self.connection.drop_table tag_name_table
+          end
+
+          taggings_name_table = options[:taggings] || :taggings
+          if self.connection.table_exists?(taggings_name_table)
+            self.connection.drop_table taggings_name_table
+          end
+        end
+      end
+
+      module SingletonMethods
+        #Return all avalible tags for a cell or global
+        #Example: Question.available_tags(:cell => @cell_id )
+        def available_tags(options = {})
+          cell = options[:cell]
+          limit = options[:limit].to_i.zero? ? 30 : options[:limit].to_i
+          scope = Tag.where({})
+          class_name = quote_string_value(base_class.name)
+          join = []
+          join << "JOIN #{Tagging.table_name} ON #{Tagging.table_name}.tag_id = #{Tag.table_name}.id "
+          join << "JOIN #{table_name} ON #{table_name}.id = #{Tagging.table_name}.taggable_id
+            AND #{Tagging.table_name}.taggable_type = #{class_name} "
+          if attribute_names.include?('cell_id') && cell
+            join << "JOIN #{Cell.table_name} ON #{Cell.table_name}.id = #{table_name}.cell_id"
+            scope = scope.where("#{table_name}.cell_id = ?", cell.id)
+          end
+
+          if options[:name_like]
+            scope = scope.where("LOWER(#{Tag.table_name}.name) LIKE LOWER(?)", "%#{options[:name_like]}%")
+          end
+
+          group_fields = ''
+          group_fields << ", #{Tag.table_name}.created_at" if Tag.respond_to?(:created_at)
+          group_fields << ", #{Tag.table_name}.updated_at" if Tag.respond_to?(:updated_at)
+
+          scope = scope.joins(join.join(' '))
+          scope = scope.select("#{Tag.table_name}.*, COUNT(DISTINCT #{Tagging.table_name}.taggable_id) AS count")
+          scope = scope.group("#{Tag.table_name}.id, #{Tag.table_name}.name #{group_fields}")
+          scope = scope.having('COUNT(*) > 0')
+          scope = scope.order("#{Tag.table_name}.name")
+          scope = scope.limit(limit)
+          scope
+        end
+        # Returns an array of related tags.
+        # Related tags are all the other tags that are found on the models tagged with the provided tags.
+        #
+        # Pass either a tag, string, or an array of strings or tags.
+        #
+        # Options:
+        #   :order - SQL Order how to order the tags. Defaults to "count DESC, tags.name".
+        def find_related_tags(tags, options = {})
+          tags = tags.is_a?(Array) ? TagList.new(tags.map(&:to_s)) : TagList.from(tags)
+
+          related_models = find_tagged_with(tags)
+
+          return [] if related_models.blank?
+
+          related_ids = related_models.map{|c| c.id }.join(",")
+          Tag.select(
+            "#{Tag.table_name}.*, COUNT(#{Tag.table_name}.id) AS count").joins(
+            "JOIN #{Tagging.table_name} ON #{Tagging.table_name}.taggable_type = '#{base_class.name}'
+              AND  #{Tagging.table_name}.taggable_id IN (#{related_ids})
+              AND  #{Tagging.table_name}.tag_id = #{Tag.table_name}.id").order(
+            options[:order] || "count DESC, #{Tag.table_name}.name").group(
+            "#{Tag.table_name}.id, #{Tag.table_name}.name HAVING #{Tag.table_name}.name NOT IN (#{tags.map { |n| quote_string_value(n) }.join(",")})")
+        end
+
+        # Pass either a tag, string, or an array of strings or tags.
+        #
+        # Options:
+        #   :exclude - Find models that are not tagged with the given tags
+        #   :match_all - Find models that match all of the given tags, not just one
+        #   :conditions - A piece of SQL conditions to add to the query
+        def find_tagged_with(*args)
+          options = find_options_for_find_tagged_with(*args)
+          options.blank? ? [] : select(options[:select]).where(options[:conditions]).joins(options[:joins]).order(options[:order]).to_a
+        end
+
+        alias_method :tagged_with, :find_tagged_with
+
+        def find_options_for_find_tagged_with(tags, options = {})
+          tags = tags.is_a?(Array) ? TagList.new(tags.map(&:to_s)) : TagList.from(tags)
+          options = options.dup
+
+          return {} if tags.empty?
+
+          conditions = []
+          conditions << sanitize_sql(options.delete(:conditions)) if options[:conditions]
+
+          taggings_alias, tags_alias = "#{table_name}_taggings", "#{table_name}_tags"
+
+          joins = [
+            "INNER JOIN #{Tagging.table_name} #{taggings_alias} ON #{taggings_alias}.taggable_id = #{table_name}.#{primary_key} AND #{taggings_alias}.taggable_type = #{quote_string_value(base_class.name)}",
+            "INNER JOIN #{Tag.table_name} #{tags_alias} ON #{tags_alias}.id = #{taggings_alias}.tag_id"
+          ]
+
+          if options.delete(:exclude)
+            conditions << <<-END
+              #{table_name}.id NOT IN
+                (SELECT #{Tagging.table_name}.taggable_id FROM #{Tagging.table_name}
+                 INNER JOIN #{Tag.table_name} ON #{Tagging.table_name}.tag_id = #{Tag.table_name}.id
+                 WHERE #{tags_condition(tags)} AND #{Tagging.table_name}.taggable_type = #{quote_string_value(base_class.name)})
+            END
+          else
+            if options.delete(:match_all)
+              joins << joins_for_match_all_tags(tags)
+            else
+              conditions << tags_condition(tags, tags_alias)
+            end
+          end
+
+          { :select => "DISTINCT #{table_name}.* ",
+            :joins => joins.join(" "),
+            :conditions => conditions.join(" AND ")
+          }.reverse_merge!(options)
+        end
+
+        def joins_for_match_all_tags(tags)
+          joins = []
+
+          tags.each_with_index do |tag, index|
+            taggings_alias, tags_alias = "taggings_#{index}", "tags_#{index}"
+
+            join = <<-END
+              INNER JOIN #{Tagging.table_name} #{taggings_alias} ON
+                #{taggings_alias}.taggable_id = #{table_name}.#{primary_key} AND
+                #{taggings_alias}.taggable_type = #{quote_string_value(base_class.name)}
+
+              INNER JOIN #{Tag.table_name} #{tags_alias} ON
+                #{taggings_alias}.tag_id = #{tags_alias}.id AND
+                #{tags_alias}.name = ?
+            END
+
+            joins << sanitize_sql([join, tag])
+          end
+
+          joins.join(' ')
+        end
+
+        # Calculate the tag counts for all tags.
+        #
+        # See Tag.counts for available options.
+        def tag_counts(options = {})
+          # Tag.find(:all, find_options_for_tag_counts(options))
+          opt = find_options_for_tag_counts(options)
+          Tag.select(opt[:select]).where(opt[:conditions]).joins(opt[:joins]).group(opt[:group]).having(opt[:having]).order(opt[:order]).limit(options[:limit])
+        end
+        alias_method :all_tag_counts, :tag_counts
+
+        def find_options_for_tag_counts(options = {})
+          options = options.dup
+          scope = scope_attributes
+          # scope(:find)
+
+          conditions = []
+          conditions << send(:sanitize_sql_for_assignment, options.delete(:conditions)) if options[:conditions]
+          conditions << send(:sanitize_sql_for_assignment, scope) if scope
+          conditions << "#{Tagging.table_name}.taggable_type = #{quote_string_value(base_class.name)}"
+          conditions << type_condition unless descends_from_active_record?
+          conditions.delete('')
+          conditions.compact!
+          conditions = conditions.join(" AND ")
+
+          joins = ["INNER JOIN #{table_name} ON #{table_name}.#{primary_key} = #{Tagging.table_name}.taggable_id"]
+          joins << options.delete(:joins) if options[:joins].present?
+          # joins << scope[:joins] if scope && scope[:joins].present?
+          joins = joins.join(" ")
+
+          options = { :conditions => conditions, :joins => joins }.update(options)
+
+          Tag.options_for_counts(options)
+        end
+
+        def caching_tag_list?
+          column_names.include?(cached_tag_list_column_name)
+        end
+
+        private
+
+        def quote_string_value(object)
+          connection.quote(object)
+        end
+
+        def tags_condition(tags, table_name = Tag.table_name)
+          condition = tags.map { |t| sanitize_sql(["#{table_name}.name LIKE ?", t]) }.join(" OR ")
+          "(" + condition + ")" unless condition.blank?
+        end
+
+        def merge_conditions(*conditions)
+          segments = []
+
+          conditions.each do |condition|
+            unless condition.blank?
+              sql = sanitize_sql(condition)
+              segments << sql unless sql.blank?
+            end
+          end
+
+          "(#{segments.join(') AND (')})" unless segments.empty?
+        end
+      end
+
+      module InstanceMethods
+        def tag_list
+          return @tag_list if @tag_list ||= nil
+
+          if self.class.caching_tag_list? && !(cached_value = send(self.class.cached_tag_list_column_name)).nil?
+            @tag_list = TagList.from(cached_value)
+          else
+            @tag_list = TagList.new(*tags.map(&:name))
+          end
+        end
+
+        def tag_list=(value)
+          @tag_list = TagList.from(value)
+        end
+
+        def save_cached_tag_list
+          if self.class.caching_tag_list?
+            self[self.class.cached_tag_list_column_name] = tag_list.to_s
+          end
+        end
+
+        #build list from related tags
+        def all_tags_list
+          tags.pluck(:name)
+        end
+
+        def save_tags
+          return unless @tag_list
+
+          new_tag_names = @tag_list - tags.map(&:name)
+          old_tags = tags.reject { |tag| @tag_list.include?(tag.name) }
+
+          self.class.transaction do
+            if old_tags.any?
+              taggings.where("tag_id IN (?)", old_tags.map(&:id)).each(&:destroy)
+              taggings.reset
+            end
+            new_tag_names.each do |new_tag_name|
+              tags << Tag.find_or_create_with_like_by_name(new_tag_name)
+            end
+          end
+
+          true
+        end
+
+        # Calculate the tag counts for the tags used by this model.
+        #
+        # The possible options are the same as the tag_counts class method.
+        def tag_counts(options = {})
+          return [] if tag_list.blank?
+
+          options[:conditions] = self.class.send(:merge_conditions, options[:conditions], self.class.send(:tags_condition, tag_list))
+          self.class.tag_counts(options)
+        end
+
+        def reload_with_tag_list(*args) #:nodoc:
+          @tag_list = nil
+          reload_without_tag_list(*args)
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, YeshouaCrm::ActsAsTaggable::Taggable)
+
+# Class aliases
+YeshouaCrm::Tag = YeshouaCrm::ActsAsTaggable::Tag
+YeshouaCrm::TagList = YeshouaCrm::ActsAsTaggable::TagList
+YeshouaCrm::Tagging = YeshouaCrm::ActsAsTaggable::Tagging

data/lib/yeshoua_crm/acts_as_taggable/tag.rb

@@ -0,0 +1,81 @@
+module YeshouaCrm
+  module ActsAsTaggable #:nodoc:
+    class Tag < ActiveRecord::Base #:nodoc:
+      has_many :taggings, :dependent => :destroy
+
+      validates_presence_of :name
+      validates :name, :uniqueness => { :message => " not uniq tag" }
+      validates :name, :presence => true
+      cattr_accessor :destroy_unused
+      self.destroy_unused = false
+
+      attr_accessible :name if defined?(ActiveModel::MassAssignmentSecurity)
+
+      # LIKE is used for cross-database case-insensitivity
+      def self.find_or_create_with_like_by_name(name)
+        # find(:first, :conditions => ["name LIKE ?", name]) || create(:name => name)
+        where("LOWER(name) LIKE LOWER(?)", name).first || create(:name => name)
+      end
+
+      def ==(object)
+        super || (object.is_a?(Tag) && name == object.name)
+      end
+
+      def to_s
+        name
+      end
+
+      def count
+        read_attribute(:count).to_i
+      end
+
+      class << self
+        # Calculate the tag counts for all tags.
+        #  :start_at - Restrict the tags to those created after a certain time
+        #  :end_at - Restrict the tags to those created before a certain time
+        #  :conditions - A piece of SQL conditions to add to the query
+        #  :limit - The maximum number of tags to return
+        #  :order - A piece of SQL to order by. Eg 'count desc' or 'taggings.created_at desc'
+        #  :at_least - Exclude tags with a frequency less than the given value
+        #  :at_most - Exclude tags with a frequency greater than the given value
+        def counts(options = {})
+          opt = options_for_counts(options)
+          select(opt[:select]).where(opt[:conditions]).joins(opt[:joins]).group(opt[:group])
+        end
+
+        def options_for_counts(options = {})
+          options.assert_valid_keys :start_at, :end_at, :conditions, :at_least, :at_most, :order, :limit, :joins
+          options = options.dup
+
+          start_at = sanitize_sql(["#{Tagging.table_name}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
+          end_at = sanitize_sql(["#{Tagging.table_name}.created_at <= ?", options.delete(:end_at)]) if options[:end_at]
+
+          conditions = [
+            (sanitize_sql(options.delete(:conditions)) if options[:conditions]),
+            start_at,
+            end_at
+          ].compact
+
+          conditions = conditions.join(' AND ') if conditions.any?
+
+          joins = ["INNER JOIN #{Tagging.table_name} ON #{Tag.table_name}.id = #{Tagging.table_name}.tag_id"]
+          joins << options.delete(:joins) if options[:joins]
+
+          at_least  = sanitize_sql(['COUNT(*) >= ?', options.delete(:at_least)]) if options[:at_least]
+          at_most   = sanitize_sql(['COUNT(*) <= ?', options.delete(:at_most)]) if options[:at_most]
+          having    = 'COUNT(*) > 0'
+          having    = [having, at_least, at_most].compact.join(' AND ')
+          group_by  = "#{Tag.table_name}.id, #{Tag.table_name}.name"
+          # group_by << " AND #{having}" unless having.blank?
+
+          { :select     => "#{Tag.table_name}.id, #{Tag.table_name}.name, COUNT(*) AS count",
+            :joins      => joins.join(" "),
+            :conditions => conditions,
+            :group      => group_by,
+            :having     => having
+          }.update(options)
+        end
+      end
+    end
+  end
+end

data/lib/yeshoua_crm/acts_as_taggable/tag_list.rb

@@ -0,0 +1,111 @@
+module YeshouaCrm
+  module ActsAsTaggable #:nodoc:
+    class TagList < Array #:nodoc:
+      cattr_accessor :delimiter
+      self.delimiter = ','
+
+      def initialize(*args)
+        add(*args)
+      end
+
+      # Add tags to the tag_list. Duplicate or blank tags will be ignored.
+      #
+      #   tag_list.add("Fun", "Happy")
+      #
+      # Use the <tt>:parse</tt> option to add an unparsed tag string.
+      #
+      #   tag_list.add("Fun, Happy", :parse => true)
+      def add(*names)
+        extract_and_apply_options!(names)
+        concat(names)
+        clean!
+        self
+      end
+
+      # Remove specific tags from the tag_list.
+      #
+      #   tag_list.remove("Sad", "Lonely")
+      #
+      # Like #add, the <tt>:parse</tt> option can be used to remove multiple tags in a string.
+      #
+      #   tag_list.remove("Sad, Lonely", :parse => true)
+      def remove(*names)
+        extract_and_apply_options!(names)
+        delete_if { |name| names.include?(name) }
+        self
+      end
+
+      # Toggle the presence of the given tags.
+      # If a tag is already in the list it is removed, otherwise it is added.
+      def toggle(*names)
+        extract_and_apply_options!(names)
+
+        names.each do |name|
+          include?(name) ? delete(name) : push(name)
+        end
+
+        clean!
+        self
+      end
+
+      # Transform the tag_list into a tag string suitable for edting in a form.
+      # The tags are joined with <tt>TagList.delimiter</tt> and quoted if necessary.
+      #
+      #   tag_list = TagList.new("Round", "Square,Cube")
+      #   tag_list.to_s # 'Round, "Square,Cube"'
+      def to_s
+        clean!
+
+        map do |name|
+          name.include?(delimiter) ? "\"#{name}\"" : name
+        end.join(delimiter.ends_with?(" ") ? delimiter : "#{delimiter} ")
+      end
+
+     private
+      # Remove whitespace, duplicates, and blanks.
+      def clean!
+        reject!(&:blank?)
+        map!(&:strip)
+        uniq!
+      end
+
+      def extract_and_apply_options!(args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        options.assert_valid_keys :parse
+
+        args.map! { |a| self.class.from(a) } if options[:parse]
+
+        args.flatten!
+      end
+
+      class << self
+        # Returns a new TagList using the given tag string.
+        #
+        #   tag_list = TagList.from("One , Two,  Three")
+        #   tag_list # ["One", "Two", "Three"]
+        def from(source)
+          tag_list = new
+
+          case source
+          when Array
+            tag_list.add(source)
+          else
+            string = source.to_s.dup
+
+            # Parse the quoted tags
+            [
+              /\s*#{delimiter}\s*(['"])(.*?)\1\s*/,
+              /^\s*(['"])(.*?)\1\s*#{delimiter}?/
+            ].each do |re|
+              string.gsub!(re) { tag_list << $2; "" }
+            end
+
+            tag_list.add(string.split(delimiter))
+          end
+
+          tag_list
+        end
+      end
+    end
+  end
+end