redmineup 1.0.2

data/lib/redmineup/acts_as_taggable/up_acts_as_taggable.rb

@@ -0,0 +1,357 @@
+require 'active_record'
+
+module Redmineup
+  module ActsAsTaggable #:nodoc:
+    module Taggable #:nodoc:
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def taggable?
+          false
+        end
+
+        def up_acts_as_taggable
+          has_many :taggings, :as => :taggable, :dependent => :destroy, :class_name => '::Redmineup::ActsAsTaggable::Tagging'
+          has_many :tags, :through => :taggings, :class_name => '::Redmineup::ActsAsTaggable::Tag'
+
+          before_save :save_cached_tag_list
+
+          after_create :save_tags
+          after_update :save_tags
+
+          include Redmineup::ActsAsTaggable::Taggable::InstanceMethods
+          extend Redmineup::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 project or global
+        #Example: Question.available_tags(:project => @project_id )
+        def available_tags(options = {})
+          projects = [[options[:project]], options[:projects]].flatten.compact
+          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?('project_id') && projects.any?
+            join << "JOIN #{Project.table_name} ON #{Project.table_name}.id = #{table_name}.project_id"
+            scope = scope.where("#{table_name}.project_id IN (%s)", projects.map(&:id).join(','))
+          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)
+
+          if base_class.respond_to?(:visible_condition)
+            visible_condition = base_class.visible_condition(User.current)
+            if visible_condition.include?('project_id') && join.all? { |jn| jn.exclude?('JOIN projects') }
+              join << "JOIN #{Project.table_name} ON #{Project.table_name}.id = #{table_name}.project_id"
+            end
+            scope = scope.where(visible_condition)
+          end
+          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, Redmineup::ActsAsTaggable::Taggable)
+
+# Class aliases
+Redmineup::Tag = Redmineup::ActsAsTaggable::Tag
+Redmineup::TagList = Redmineup::ActsAsTaggable::TagList
+Redmineup::Tagging = Redmineup::ActsAsTaggable::Tagging

data/lib/redmineup/acts_as_viewed/up_acts_as_viewed.rb

@@ -0,0 +1,274 @@
+# Copyright (c) 2008 Damian Martinelli
+#
+# 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.
+module Redmineup
+  module ActsAsViewed #:nodoc:
+    # == acts_as_viewed
+    # Adds views count capabilities to any ActiveRecord object.
+    # It has the ability to work with objects that have or don't special fields to keep a tally of the
+    # viewings for each object.
+    # In addition it will by default use the User model as the viewer object and keep the viewings per-user.
+    # It can be configured to use another class.
+    # The IP address are used to not repeat views from the same ip. Only one view are count by user or IP.
+    #
+    # Special methods are provided to create the viewings table and if needed, to add the special fields needed
+    # to keep per-objects viewings fast for access to viewed objects. Can be easily used in migrations.
+    #
+    # == Example of usage:
+    #
+    #   class Video < ActiveRecord::Base
+    #     acts_as_viewed
+    #   end
+    #
+    #   In a controller:
+    #
+    #   bill = User.find_by_name 'bill'
+    #   batman = Video.find_by_title 'Batman'
+    #   toystory  = Video.find_by_title 'Toy Story'
+    #
+    #   batman.view request.remote_addr, bill
+    #   toystory.view  request.remote_addr, bill
+    #
+    #   batman.view_count     # => 1
+    #
+    #
+    module Viewed
+      class ViewedError < RuntimeError; end
+
+      def self.included(base) #:nodoc:
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        # Make the model viewable.
+        # The Viewing model, holding the details of the viewings, will be created dynamically if it doesn't exist.
+        #
+        # * Adds a <tt>has_many :viewings</tt> association to the model for easy retrieval of the detailed viewings.
+        # * Adds a <tt>has_many :viewers</tt> association to the object.
+        # * Adds a <tt>has_many :viewings</tt> associations to the viewer class.
+        #
+        # === Options
+        # * <tt>:viewing_class</tt> -
+        #   class of the model used for the viewings. Defaults to Viewing. This class will be dynamically created if not already defined.
+        #   If the class is predefined, it must have in it the following definitions:
+        #   <tt>belongs_to :viewed, :polymorphic => true</tt>
+        #   <tt>belongs_to :viewer, :class_name => 'User', :foreign_key => :viewer_id</tt> replace user with the viewer class if needed.
+        # * <tt>:viewer_class</tt> -
+        #   class of the model that creates the viewing.
+        #   Defaults to User This class will NOT be created, so it must be defined in the app.
+        #   Use the IP address to prevent multiple viewings from the same client.
+        #
+        def up_acts_as_viewed(options = {})
+          # don't allow multiple calls
+          return if self.included_modules.include?(ActsAsViewed::Viewed::ViewMethods)
+          send :include, ActsAsViewed::Viewed::ViewMethods
+
+          # Create the model for ratings if it doesn't yet exist
+          viewing_class = options[:viewing_class] || 'Viewing'
+          viewer_class  = options[:viewer_class]  || 'User'
+
+          unless Object.const_defined?(viewing_class)
+            Object.class_eval <<-EOV
+              class #{viewing_class} < ActiveRecord::Base
+                belongs_to :viewed, polymorphic: true
+                belongs_to :viewer, class_name: '#{viewer_class}', foreign_key: :viewer_id
+              end
+            EOV
+          end
+
+          # Rails < 3
+          # write_inheritable_attribute( :acts_as_viewed_options ,
+          #                                { :viewing_class => viewing_class,
+          #                                  :viewer_class => viewer_class } )
+          # class_inheritable_reader :acts_as_viewed_options
+
+          # Rails >= 3
+          class_attribute :acts_as_viewed_options
+          self.acts_as_viewed_options = { :viewing_class => viewing_class,
+                                          :viewer_class => viewer_class }
+          class_eval do
+            has_many :viewings, as: :viewed, dependent: :delete_all, class_name: viewing_class.to_s
+            has_many :viewers, through: :viewings, class_name: viewer_class.to_s
+
+            before_create :init_viewing_fields
+          end
+
+          # Add to the User (or whatever the viewer is) a has_many viewings
+          viewer_as_class = viewer_class.constantize
+          return if viewer_as_class.instance_methods.include?('find_in_viewings')
+          viewer_as_class.class_eval do
+            has_many :viewings, foreign_key: :viewer_id, class_name: viewing_class.to_s, dependent: :delete_all
+          end
+        end
+      end
+
+      module ViewMethods
+        def self.included(base) #:nodoc:
+          base.extend ClassMethods
+        end
+
+        # Is this object viewed already?
+        def viewed?
+          return (!self.views.nil? && self.views > 0) if attributes.has_key? 'views'
+          !viewings.first.nil?
+        end
+
+        # Get the number of viewings for this object based on the views field,
+        # or with a SQL query if the viewed objects doesn't have the views field
+        def view_count
+          return ("#{self.total_views}(#{self.views})" || 0) if attributes.has_key? 'views'
+          viewings.count
+        end
+
+        # Change views count (total_views and views) if it's existing in object
+        # If options[:only_total] == true count of unique views doesn't change
+        def increase_views_count(options)
+          if attributes.has_key?('views') && attributes.has_key?('total_views')
+            target = self
+            target.views = ((target.views || 0) + 1) unless options[:only_total]
+            target.total_views = ((target.total_views || 0) + 1)
+            target.record_timestamps = false
+            target.save(:validate => false, :touch => false)
+          end
+        end
+
+        # View the object with or without a viewer - create new or update as needed
+        #
+        # * <tt>ip</tt> - the viewer ip
+        # * <tt>viewer</tt> - an object of the viewer class. Must be valid and with an id to be used. Or nil
+        def view(ip, viewer = nil)
+          # Sanity checks for the parameters
+          viewing_class = acts_as_viewed_options[:viewing_class].constantize
+          if viewer && !(acts_as_viewed_options[:viewer_class].constantize === viewer)
+            raise ViewedError, "the viewer object must be the one used when defining acts_as_viewed (or a descendent of it). other objects are not acceptable"
+          end
+
+          viewing_class.transaction do
+            if !viewed_by? ip, viewer
+              view = viewing_class.new
+              view.viewer_id = viewer.id if viewer && !viewer.id.nil?
+              view.ip = ip
+              viewings << view
+              view.save
+              increase_views_count(:only_total => false)
+            else
+              increase_views_count(:only_total => true)
+            end
+            true
+          end
+        end
+
+        # Check if an item was already viewed by the given viewer
+        def viewed_by?(ip, viewer = nil)
+          if viewer && !viewer.nil? && !(acts_as_viewed_options[:viewer_class].constantize === viewer)
+            raise ViewedError, "the viewer object must be the one used when defining acts_as_viewed (or a descendent of it). other objects are not acceptable"
+          end
+          if viewer && !viewer.id.nil? && !viewer.anonymous?
+            return viewings.where("viewer_id = '#{viewer.id}'").any?
+          else
+            return viewings.where("ip = :ip", ip: ip).any?
+          end
+        end
+
+        private
+
+        def init_viewing_fields #:nodoc:
+          self.views ||= 0 if attributes.has_key?('views')
+        end
+      end
+
+      module ClassMethods
+        # Generate the viewings columns on a table, to be used when creating the table
+        # in a migration. This is the preferred way to do in a migration that creates
+        # new tables as it will make it as part of the table creation, and not generate
+        # ALTER TABLE calls after the fact
+        def generate_viewings_columns(table)
+          table.column :views, :integer # uniq views
+          table.column :total_views, :integer
+        end
+
+        # Create the needed columns for acts_as_viewed.
+        # To be used during migration, but can also be used in other places.
+        def add_viewings_columns
+          if !self.content_columns.find { |c| 'views' == c.name }
+            self.connection.add_column table_name, :views, :integer, :default => '0'
+            self.connection.add_column table_name, :total_views, :integer, :default => '0'
+            self.reset_column_information
+          end
+        end
+
+        # Remove the acts_as_viewed specific columns added with add_viewings_columns
+        # To be used during migration, but can also be used in other places
+        def remove_viewings_columns
+          if self.content_columns.find { |c| 'views' == c.name }
+            self.connection.remove_column table_name, :views
+            self.connection.remove_column table_name, :total_views
+            self.reset_column_information
+          end
+        end
+
+        # Create the viewings table
+        # === 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_viewings_table(options = {})
+          name = options[:table_name] || :viewings
+          if !self.connection.table_exists?(name)
+            self.connection.create_table(name) do |t|
+              t.column :viewer_id,   :integer
+              t.column :viewed_id,   :integer
+              t.column :viewed_type, :string
+              t.column :ip, :string, :limit => '24'
+              t.column :created_at, :datetime
+            end
+
+            self.connection.add_index(name, :viewer_id)
+            self.connection.add_index(name, [:viewed_type, :viewed_id])
+          end
+        end
+
+        # Drop the viewings table.
+        # === Options hash:
+        # * <tt>:table_name</tt> - the name of the viewings table, defaults to viewings
+        # To be used during migration, but can also be used in other places
+        def drop_viewings_table(options = {})
+          name = options[:table_name] || :viewings
+          if self.connection.table_exists?(name)
+            self.connection.drop_table(name)
+          end
+        end
+
+        # Find all viewings for a specific viewer.
+        def find_viewed_by(viewer)
+          viewing_class = acts_as_viewed_options[:viewing_class].constantize
+          if !(acts_as_viewed_options[:viewer_class].constantize === viewer)
+            raise ViewedError, "The viewer object must be the one used when defining acts_as_viewed (or a descendent of it). other objects are not acceptable"
+          end
+          raise ViewedError, 'Viewer must be a valid and existing object' if viewer.nil? || viewer.id.nil?
+          raise ViewedError, 'Viewer must be a valid viewer' if !viewing_class.column_names.include?('viewer_id')
+          conds = ['viewed_type = ? AND viewer_id = ?', self.name, viewer.id]
+          acts_as_viewed_options[:viewing_class].constantize.where(conds).collect { |r| r.viewed_type.constantize.find_by_id r.viewed.id }
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send :include, Redmineup::ActsAsViewed::Viewed