SoundSoftware Code Site

# Redmine - project management software

# Copyright (C) 2006-2014  Jean-Philippe Lang

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

require "digest/md5"

require "fileutils"

class Attachment < ActiveRecord::Base

  belongs_to :container, :polymorphic => true

  belongs_to :author, :class_name => "User", :foreign_key => "author_id"

  validates_presence_of :filename, :author

  validates_length_of :filename, :maximum => 255

  validates_length_of :disk_filename, :maximum => 255

  validates_length_of :description, :maximum => 255

  validate :validate_max_file_size

  acts_as_event :title => :filename,

                :url => Proc.new {|o| {:controller => 'attachments', :action => 'download', :id => o.id, :filename => o.filename}}

  acts_as_activity_provider :type => 'files',

                            :permission => :view_files,

                            :author_key => :author_id,

                            :find_options => {:select => "#{Attachment.table_name}.*",

                                              :joins => "LEFT JOIN #{Version.table_name} ON #{Attachment.table_name}.container_type='Version' AND #{Version.table_name}.id = #{Attachment.table_name}.container_id " +

                                                        "LEFT JOIN #{Project.table_name} ON #{Version.table_name}.project_id = #{Project.table_name}.id OR ( #{Attachment.table_name}.container_type='Project' AND #{Attachment.table_name}.container_id = #{Project.table_name}.id )"}

  acts_as_activity_provider :type => 'documents',

                            :permission => :view_documents,

                            :author_key => :author_id,

                            :find_options => {:select => "#{Attachment.table_name}.*",

                                              :joins => "LEFT JOIN #{Document.table_name} ON #{Attachment.table_name}.container_type='Document' AND #{Document.table_name}.id = #{Attachment.table_name}.container_id " +

                                                        "LEFT JOIN #{Project.table_name} ON #{Document.table_name}.project_id = #{Project.table_name}.id"}

  cattr_accessor :storage_path

  @@storage_path = Redmine::Configuration['attachments_storage_path'] || File.join(Rails.root, "files")

  cattr_accessor :thumbnails_storage_path

  @@thumbnails_storage_path = File.join(Rails.root, "tmp", "thumbnails")

  before_save :files_to_final_location

  after_destroy :delete_from_disk

  # Returns an unsaved copy of the attachment

  def copy(attributes=nil)

    copy = self.class.new

    copy.attributes = self.attributes.dup.except("id", "downloads")

    copy.attributes = attributes if attributes

    copy

  end

  def validate_max_file_size

    if @temp_file && self.filesize > Setting.attachment_max_size.to_i.kilobytes

      errors.add(:base, l(:error_attachment_too_big, :max_size => Setting.attachment_max_size.to_i.kilobytes))

    end

  end

  def file=(incoming_file)

    unless incoming_file.nil?

      @temp_file = incoming_file

      if @temp_file.size > 0

        if @temp_file.respond_to?(:original_filename)

          self.filename = @temp_file.original_filename

          self.filename.force_encoding("UTF-8") if filename.respond_to?(:force_encoding)

        end

        if @temp_file.respond_to?(:content_type)

          self.content_type = @temp_file.content_type.to_s.chomp

        end

        if content_type.blank? && filename.present?

          self.content_type = Redmine::MimeType.of(filename)

        end

        self.filesize = @temp_file.size

      end

    end

  end

  def file

    nil

  end

  def filename=(arg)

    write_attribute :filename, sanitize_filename(arg.to_s)

    filename

  end

  # Copies the temporary file to its final location

  # and computes its MD5 hash

  def files_to_final_location

    if @temp_file && (@temp_file.size > 0)

      self.disk_directory = target_directory

      self.disk_filename = Attachment.disk_filename(filename, disk_directory)

      logger.info("Saving attachment '#{self.diskfile}' (#{@temp_file.size} bytes)") if logger

      path = File.dirname(diskfile)

      unless File.directory?(path)

        FileUtils.mkdir_p(path)

      end

      md5 = Digest::MD5.new

      File.open(diskfile, "wb") do |f|

        if @temp_file.respond_to?(:read)

          buffer = ""

          while (buffer = @temp_file.read(8192))

            f.write(buffer)

            md5.update(buffer)

          end

        else

          f.write(@temp_file)

          md5.update(@temp_file)

        end

      end

      self.digest = md5.hexdigest

    end

    @temp_file = nil

    # Don't save the content type if it's longer than the authorized length

    if self.content_type && self.content_type.length > 255

      self.content_type = nil

    end

  end

  # Deletes the file from the file system if it's not referenced by other attachments

  def delete_from_disk

    if Attachment.where("disk_filename = ? AND id <> ?", disk_filename, id).empty?

      delete_from_disk!

    end

  end

  # Returns file's location on disk

  def diskfile

    File.join(self.class.storage_path, disk_directory.to_s, disk_filename.to_s)

  end

  def title

    title = filename.to_s

    if description.present?

      title << " (#{description})"

    end

    title

  end

  def increment_download

    increment!(:downloads)

  end

  def project

    container.try(:project)

  end

  def visible?(user=User.current)

    if container_id

      container && container.attachments_visible?(user)

    else

      author == user

    end

  end

  def deletable?(user=User.current)

    if container_id

      container && container.attachments_deletable?(user)

    else

      author == user

    end

  end

  def image?

    !!(self.filename =~ /\.(bmp|gif|jpg|jpe|jpeg|png)$/i)

  end

  def thumbnailable?

    image?

  end

  # Returns the full path the attachment thumbnail, or nil

  # if the thumbnail cannot be generated.

  def thumbnail(options={})

    if thumbnailable? && readable?

      size = options[:size].to_i

      if size > 0

        # Limit the number of thumbnails per image

        size = (size / 50) * 50

        # Maximum thumbnail size

        size = 800 if size > 800

      else

        size = Setting.thumbnails_size.to_i

      end

      size = 100 unless size > 0

      target = File.join(self.class.thumbnails_storage_path, "#{id}_#{digest}_#{size}.thumb")

      begin

        Redmine::Thumbnail.generate(self.diskfile, target, size)

      rescue => e

        logger.error "An error occured while generating thumbnail for #{disk_filename} to #{target}\nException was: #{e.message}" if logger

        return nil

      end

    end

  end

  # Deletes all thumbnails

  def self.clear_thumbnails

    Dir.glob(File.join(thumbnails_storage_path, "*.thumb")).each do |file|

      File.delete file

    end

  end

  def is_text?

    Redmine::MimeType.is_type?('text', filename)

  end

  def is_diff?

    self.filename =~ /\.(patch|diff)$/i

  end

  # Returns true if the file is readable

  def readable?

    File.readable?(diskfile)

  end

  # Returns the attachment token

  def token

    "#{id}.#{digest}"

  end

  # Finds an attachment that matches the given token and that has no container

  def self.find_by_token(token)

    if token.to_s =~ /^(\d+)\.([0-9a-f]+)$/

      attachment_id, attachment_digest = $1, $2

      attachment = Attachment.where(:id => attachment_id, :digest => attachment_digest).first

      if attachment && attachment.container.nil?

        attachment

      end

    end

  end

  # Bulk attaches a set of files to an object

  #

  # Returns a Hash of the results:

  # :files => array of the attached files

  # :unsaved => array of the files that could not be attached

  def self.attach_files(obj, attachments)

    result = obj.save_attachments(attachments, User.current)

    obj.attach_saved_attachments

    result

  end

  def self.latest_attach(attachments, filename)

    attachments.sort_by(&:created_on).reverse.detect {

      |att| att.filename.downcase == filename.downcase

     }

  end

  def self.prune(age=1.day)

    Attachment.where("created_on < ? AND (container_type IS NULL OR container_type = '')", Time.now - age).destroy_all

  end

  # Moves an existing attachment to its target directory

  def move_to_target_directory!

    return unless !new_record? & readable?

    src = diskfile

    self.disk_directory = target_directory

    dest = diskfile

    return if src == dest

    if !FileUtils.mkdir_p(File.dirname(dest))

      logger.error "Could not create directory #{File.dirname(dest)}" if logger

      return

    end

    if !FileUtils.mv(src, dest)

      logger.error "Could not move attachment from #{src} to #{dest}" if logger

      return

    end

    update_column :disk_directory, disk_directory

  end

  # Moves existing attachments that are stored at the root of the files

  # directory (ie. created before Redmine 2.3) to their target subdirectories

  def self.move_from_root_to_target_directory

    Attachment.where("disk_directory IS NULL OR disk_directory = ''").find_each do |attachment|

      attachment.move_to_target_directory!

    end

  end

  private

  # Physically deletes the file from the file system

  def delete_from_disk!

    if disk_filename.present? && File.exist?(diskfile)

      File.delete(diskfile)

    end

  end

  def sanitize_filename(value)

    # get only the filename, not the whole path

    just_filename = value.gsub(/\A.*(\\|\/)/m, '')

    # Finally, replace invalid characters with underscore

    @filename = just_filename.gsub(/[\/\?\%\*\:\|\"\'<>\n\r]+/, '_')

  end

  # Returns the subdirectory in which the attachment will be saved

  def target_directory

    time = created_on || DateTime.now

    time.strftime("%Y/%m")

  end

  # Returns an ASCII or hashed filename that do not

  # exists yet in the given subdirectory

  def self.disk_filename(filename, directory=nil)

    timestamp = DateTime.now.strftime("%y%m%d%H%M%S")

    ascii = ''

    if filename =~ %r{^[a-zA-Z0-9_\.\-]*$}

      ascii = filename

    else

      ascii = Digest::MD5.hexdigest(filename)

      # keep the extension if any

      ascii << $1 if filename =~ %r{(\.[a-zA-Z0-9]+)$}

    end

    while File.exist?(File.join(storage_path, directory.to_s, "#{timestamp}_#{ascii}"))

      timestamp.succ!

    end

    "#{timestamp}_#{ascii}"

  end

end

# Redmine - project management software

# Copyright (C) 2006-2014  Jean-Philippe Lang

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

# Generic exception for when the AuthSource can not be reached

# (eg. can not connect to the LDAP)

class AuthSourceException < Exception; end

class AuthSourceTimeoutException < AuthSourceException; end

class AuthSource < ActiveRecord::Base

  include Redmine::SubclassFactory

  include Redmine::Ciphering

  has_many :users

  validates_presence_of :name

  validates_uniqueness_of :name

  validates_length_of :name, :maximum => 60

  def authenticate(login, password)

  end

  def test_connection

  end

  def auth_method_name

    "Abstract"

  end

  def account_password

    read_ciphered_attribute(:account_password)

  end

  def account_password=(arg)

    write_ciphered_attribute(:account_password, arg)

  end

  def searchable?

    false

  end

  def self.search(q)

    results = []

    AuthSource.all.each do |source|

      begin

        if source.searchable?

          results += source.search(q)

        end

      rescue AuthSourceException => e

        logger.error "Error while searching users in #{source.name}: #{e.message}"

      end

    end

    results

  end

  def allow_password_changes?

    self.class.allow_password_changes?

  end

  # Does this auth source backend allow password changes?

  def self.allow_password_changes?

    false

  end

  # Try to authenticate a user not yet registered against available sources

  def self.authenticate(login, password)

    AuthSource.where(:onthefly_register => true).each do |source|

      begin

        logger.debug "Authenticating '#{login}' against '#{source.name}'" if logger && logger.debug?

        attrs = source.authenticate(login, password)

      rescue => e

        logger.error "Error during authentication: #{e.message}"

        attrs = nil

      end

      return attrs if attrs

    end

    return nil

  end

end

# Redmine - project management software

# Copyright (C) 2006-2014  Jean-Philippe Lang

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

require 'net/ldap'

require 'net/ldap/dn'

require 'timeout'

class AuthSourceLdap < AuthSource

  validates_presence_of :host, :port, :attr_login

  validates_length_of :name, :host, :maximum => 60, :allow_nil => true

  validates_length_of :account, :account_password, :base_dn, :filter, :maximum => 255, :allow_blank => true

  validates_length_of :attr_login, :attr_firstname, :attr_lastname, :attr_mail, :maximum => 30, :allow_nil => true

  validates_numericality_of :port, :only_integer => true

  validates_numericality_of :timeout, :only_integer => true, :allow_blank => true

  validate :validate_filter

  before_validation :strip_ldap_attributes

  def initialize(attributes=nil, *args)

    super

    self.port = 389 if self.port == 0

  end

  def authenticate(login, password)

    return nil if login.blank? || password.blank?

    with_timeout do

      attrs = get_user_dn(login, password)

      if attrs && attrs[:dn] && authenticate_dn(attrs[:dn], password)

        logger.debug "Authentication successful for '#{login}'" if logger && logger.debug?

        return attrs.except(:dn)

      end

    end

  rescue Net::LDAP::LdapError => e

    raise AuthSourceException.new(e.message)

  end

  # test the connection to the LDAP

  def test_connection

    with_timeout do

      ldap_con = initialize_ldap_con(self.account, self.account_password)

      ldap_con.open { }

    end

  rescue Net::LDAP::LdapError => e

    raise AuthSourceException.new(e.message)

  end

  def auth_method_name

    "LDAP"

  end

  # Returns true if this source can be searched for users

  def searchable?

    !account.to_s.include?("$login") && %w(login firstname lastname mail).all? {|a| send("attr_#{a}?")}

  end

  # Searches the source for users and returns an array of results

  def search(q)

    q = q.to_s.strip

    return [] unless searchable? && q.present?

    results = []

    search_filter = base_filter & Net::LDAP::Filter.begins(self.attr_login, q)

    ldap_con = initialize_ldap_con(self.account, self.account_password)

    ldap_con.search(:base => self.base_dn,

                    :filter => search_filter,

                    :attributes => ['dn', self.attr_login, self.attr_firstname, self.attr_lastname, self.attr_mail],

                    :size => 10) do |entry|

      attrs = get_user_attributes_from_ldap_entry(entry)

      attrs[:login] = AuthSourceLdap.get_attr(entry, self.attr_login)

      results << attrs

    end

    results

  rescue Net::LDAP::LdapError => e

    raise AuthSourceException.new(e.message)

  end

  private

  def with_timeout(&block)

    timeout = self.timeout

    timeout = 20 unless timeout && timeout > 0

    Timeout.timeout(timeout) do

      return yield

    end

  rescue Timeout::Error => e

    raise AuthSourceTimeoutException.new(e.message)

  end

  def ldap_filter

    if filter.present?

      Net::LDAP::Filter.construct(filter)

    end

  rescue Net::LDAP::LdapError

    nil

  end

  def base_filter

    filter = Net::LDAP::Filter.eq("objectClass", "*")

    if f = ldap_filter

      filter = filter & f

    end

    filter

  end

  def validate_filter

    if filter.present? && ldap_filter.nil?

      errors.add(:filter, :invalid)

    end

  end

  def strip_ldap_attributes

    [:attr_login, :attr_firstname, :attr_lastname, :attr_mail].each do |attr|

      write_attribute(attr, read_attribute(attr).strip) unless read_attribute(attr).nil?

    end

  end

  def initialize_ldap_con(ldap_user, ldap_password)

    options = { :host => self.host,

                :port => self.port,

                :encryption => (self.tls ? :simple_tls : nil)

              }

    options.merge!(:auth => { :method => :simple, :username => ldap_user, :password => ldap_password }) unless ldap_user.blank? && ldap_password.blank?

    Net::LDAP.new options

  end

  def get_user_attributes_from_ldap_entry(entry)

    {

     :dn => entry.dn,

     :firstname => AuthSourceLdap.get_attr(entry, self.attr_firstname),

     :lastname => AuthSourceLdap.get_attr(entry, self.attr_lastname),

     :mail => AuthSourceLdap.get_attr(entry, self.attr_mail),

     :auth_source_id => self.id

    }

  end

  # Return the attributes needed for the LDAP search.  It will only

  # include the user attributes if on-the-fly registration is enabled

  def search_attributes

    if onthefly_register?

      ['dn', self.attr_firstname, self.attr_lastname, self.attr_mail]

    else

      ['dn']

    end

  end

  # Check if a DN (user record) authenticates with the password

  def authenticate_dn(dn, password)

    if dn.present? && password.present?

      initialize_ldap_con(dn, password).bind

    end

  end

  # Get the user's dn and any attributes for them, given their login

  def get_user_dn(login, password)

    ldap_con = nil

    if self.account && self.account.include?("$login")

      ldap_con = initialize_ldap_con(self.account.sub("$login", Net::LDAP::DN.escape(login)), password)

    else

      ldap_con = initialize_ldap_con(self.account, self.account_password)

    end

    attrs = {}

    search_filter = base_filter & Net::LDAP::Filter.eq(self.attr_login, login)

    ldap_con.search( :base => self.base_dn,

                     :filter => search_filter,

                     :attributes=> search_attributes) do |entry|

      if onthefly_register?

        attrs = get_user_attributes_from_ldap_entry(entry)

      else

        attrs = {:dn => entry.dn}

      end

      logger.debug "DN found for #{login}: #{attrs[:dn]}" if logger && logger.debug?

    end

    attrs

  end

  def self.get_attr(entry, attr_name)

    if !attr_name.blank?

      entry[attr_name].is_a?(Array) ? entry[attr_name].first : entry[attr_name]

    end

  end

end

# Redmine - project management software

# Copyright (C) 2006-2014  Jean-Philippe Lang

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

class Board < ActiveRecord::Base

  include Redmine::SafeAttributes

  belongs_to :project

  has_many :topics, :class_name => 'Message', :conditions => "#{Message.table_name}.parent_id IS NULL", :order => "#{Message.table_name}.created_on DESC"

  has_many :messages, :dependent => :destroy, :order => "#{Message.table_name}.created_on DESC"

  belongs_to :last_message, :class_name => 'Message', :foreign_key => :last_message_id

  acts_as_tree :dependent => :nullify

  acts_as_list :scope => '(project_id = #{project_id} AND parent_id #{parent_id ? "= #{parent_id}" : "IS NULL"})'

  acts_as_watchable

  validates_presence_of :name, :description

  validates_length_of :name, :maximum => 30

  validates_length_of :description, :maximum => 255

  validate :validate_board

  scope :visible, lambda {|*args|

    includes(:project).where(Project.allowed_to_condition(args.shift || User.current, :view_messages, *args))

  }

  safe_attributes 'name', 'description', 'parent_id', 'move_to'

  def visible?(user=User.current)

    !user.nil? && user.allowed_to?(:view_messages, project)

  end

  def reload(*args)

    @valid_parents = nil

    super

  end

  def to_s

    name

  end

  def valid_parents

    @valid_parents ||= project.boards - self_and_descendants

  end

  def reset_counters!

    self.class.reset_counters!(id)

  end

  # Updates topics_count, messages_count and last_message_id attributes for +board_id+

  def self.reset_counters!(board_id)

    board_id = board_id.to_i

    where(["id = ?", board_id]).

      update_all("topics_count = (SELECT COUNT(*) FROM #{Message.table_name} WHERE board_id=#{board_id} AND parent_id IS NULL)," +

               " messages_count = (SELECT COUNT(*) FROM #{Message.table_name} WHERE board_id=#{board_id})," +

               " last_message_id = (SELECT MAX(id) FROM #{Message.table_name} WHERE board_id=#{board_id})")

  end

  def self.board_tree(boards, parent_id=nil, level=0)

    tree = []

    boards.select {|board| board.parent_id == parent_id}.sort_by(&:position).each do |board|

      tree << [board, level]

      tree += board_tree(boards, board.id, level+1)

    end

    if block_given?

      tree.each do |board, level|

        yield board, level

      end

    end

    tree

  end

  protected

  def validate_board

    if parent_id && parent_id_changed?

      errors.add(:parent_id, :invalid) unless valid_parents.include?(parent)

    end

  end

end

# Redmine - project management software

# Copyright (C) 2006-2014  Jean-Philippe Lang

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

class Change < ActiveRecord::Base

  belongs_to :changeset

  validates_presence_of :changeset_id, :action, :path

  before_save :init_path

  before_validation :replace_invalid_utf8_of_path

  def relative_path

    changeset.repository.relative_path(path)

  end

  def replace_invalid_utf8_of_path

    self.path      = Redmine::CodesetUtil.replace_invalid_utf8(self.path)

    self.from_path = Redmine::CodesetUtil.replace_invalid_utf8(self.from_path)

  end

  def init_path

    self.path ||= ""

  end

end

# Redmine - project management software

# Copyright (C) 2006-2014  Jean-Philippe Lang

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

class Changeset < ActiveRecord::Base

  belongs_to :repository

  belongs_to :user

  has_many :filechanges, :class_name => 'Change', :dependent => :delete_all

  has_and_belongs_to_many :issues

  has_and_belongs_to_many :parents,

                          :class_name => "Changeset",

                          :join_table => "#{table_name_prefix}changeset_parents#{table_name_suffix}",

                          :association_foreign_key => 'parent_id', :foreign_key => 'changeset_id'

  has_and_belongs_to_many :children,

                          :class_name => "Changeset",

                          :join_table => "#{table_name_prefix}changeset_parents#{table_name_suffix}",

                          :association_foreign_key => 'changeset_id', :foreign_key => 'parent_id'

  acts_as_event :title => Proc.new {|o| o.title},

                :description => :long_comments,

                :datetime => :committed_on,

                :url => Proc.new {|o| {:controller => 'repositories', :action => 'revision', :id => o.repository.project, :repository_id => o.repository.identifier_param, :rev => o.identifier}}

  acts_as_searchable :columns => 'comments',

                     :include => {:repository => :project},

                     :project_key => "#{Repository.table_name}.project_id",

                     :date_column => 'committed_on'

  acts_as_activity_provider :timestamp => "#{table_name}.committed_on",

                            :author_key => :user_id,

                            :find_options => {:include => [:user, {:repository => :project}]}

  validates_presence_of :repository_id, :revision, :committed_on, :commit_date

  validates_uniqueness_of :revision, :scope => :repository_id

  validates_uniqueness_of :scmid, :scope => :repository_id, :allow_nil => true

  scope :visible, lambda {|*args|

    includes(:repository => :project).where(Project.allowed_to_condition(args.shift || User.current, :view_changesets, *args))

  }

  after_create :scan_for_issues

  before_create :before_create_cs

  def revision=(r)

    write_attribute :revision, (r.nil? ? nil : r.to_s)

  end

  # Returns the identifier of this changeset; depending on repository backends

  def identifier

    if repository.class.respond_to? :changeset_identifier

      repository.class.changeset_identifier self

    else

      revision.to_s

    end

  end

  def committed_on=(date)

    self.commit_date = date

    super

  end

  # Returns the readable identifier

  def format_identifier

    if repository.class.respond_to? :format_changeset_identifier

      repository.class.format_changeset_identifier self

    else

      identifier

    end

  end

  def project

    repository.project

  end

  def author

    user || committer.to_s.split('<').first

  end

  def before_create_cs

    self.committer = self.class.to_utf8(self.committer, repository.repo_log_encoding)

    self.comments  = self.class.normalize_comments(

                       self.comments, repository.repo_log_encoding)

    self.user = repository.find_committer_user(self.committer)

  end

  def scan_for_issues

    scan_comment_for_issue_ids

  end

  TIMELOG_RE = /

    (

    ((\d+)(h|hours?))((\d+)(m|min)?)?

    |

    ((\d+)(h|hours?|m|min))

    |

    (\d+):(\d+)

    |

    (\d+([\.,]\d+)?)h?

    )

    /x

  def scan_comment_for_issue_ids

    return if comments.blank?

    # keywords used to reference issues

    ref_keywords = Setting.commit_ref_keywords.downcase.split(",").collect(&:strip)

    ref_keywords_any = ref_keywords.delete('*')

    # keywords used to fix issues

    fix_keywords = Setting.commit_update_keywords_array.map {|r| r['keywords']}.flatten.compact

    kw_regexp = (ref_keywords + fix_keywords).collect{|kw| Regexp.escape(kw)}.join("|")

    referenced_issues = []

    comments.scan(/([\s\(\[,-]|^)((#{kw_regexp})[\s:]+)?(#\d+(\s+@#{TIMELOG_RE})?([\s,;&]+#\d+(\s+@#{TIMELOG_RE})?)*)(?=[[:punct:]]|\s|<|$)/i) do |match|

      action, refs = match[2].to_s.downcase, match[3]

      next unless action.present? || ref_keywords_any

      refs.scan(/#(\d+)(\s+@#{TIMELOG_RE})?/).each do |m|

        issue, hours = find_referenced_issue_by_id(m[0].to_i), m[2]

        if issue

          referenced_issues << issue

          # Don't update issues or log time when importing old commits

          unless repository.created_on && committed_on && committed_on < repository.created_on

            fix_issue(issue, action) if fix_keywords.include?(action)

            log_time(issue, hours) if hours && Setting.commit_logtime_enabled?

          end

        end

      end

    end

    referenced_issues.uniq!

    self.issues = referenced_issues unless referenced_issues.empty?

  end

  def short_comments

    @short_comments || split_comments.first

  end

  def long_comments

    @long_comments || split_comments.last

  end

  def text_tag(ref_project=nil)

    repo = ""

    if repository && repository.identifier.present?

      repo = "#{repository.identifier}|"

    end

    tag = if scmid?

      "commit:#{repo}#{scmid}"

    else

      "#{repo}r#{revision}"

    end

    if ref_project && project && ref_project != project

      tag = "#{project.identifier}:#{tag}"

    end

    tag

  end

  # Returns the title used for the changeset in the activity/search results

  def title

    repo = (repository && repository.identifier.present?) ? " (#{repository.identifier})" : ''

    comm = short_comments.blank? ? '' : (': ' + short_comments)

    "#{l(:label_revision)} #{format_identifier}#{repo}#{comm}"

  end

  # Returns the previous changeset

  def previous

    @previous ||= Changeset.where(["id < ? AND repository_id = ?", id, repository_id]).order('id DESC').first

  end

  # Returns the next changeset

  def next

    @next ||= Changeset.where(["id > ? AND repository_id = ?", id, repository_id]).order('id ASC').first

  end

  # Creates a new Change from it's common parameters

  def create_change(change)

    Change.create(:changeset     => self,

                  :action        => change[:action],

                  :path          => change[:path],

                  :from_path     => change[:from_path],

                  :from_revision => change[:from_revision])

  end

  # Finds an issue that can be referenced by the commit message

  def find_referenced_issue_by_id(id)

    return nil if id.blank?

    issue = Issue.includes(:project).where(:id => id.to_i).first

    if Setting.commit_cross_project_ref?

      # all issues can be referenced/fixed

    elsif issue

      # issue that belong to the repository project, a subproject or a parent project only

      unless issue.project &&

                (project == issue.project || project.is_ancestor_of?(issue.project) ||

                 project.is_descendant_of?(issue.project))

        issue = nil

      end

    end

    issue

  end

  private

  # Updates the +issue+ according to +action+

  def fix_issue(issue, action)

    # the issue may have been updated by the closure of another one (eg. duplicate)

    issue.reload

    # don't change the status is the issue is closed

    return if issue.status && issue.status.is_closed?

    journal = issue.init_journal(user || User.anonymous,

                                 ll(Setting.default_language,

                                    :text_status_changed_by_changeset,

                                    text_tag(issue.project)))

    rule = Setting.commit_update_keywords_array.detect do |rule|

      rule['keywords'].include?(action) &&

        (rule['if_tracker_id'].blank? || rule['if_tracker_id'] == issue.tracker_id.to_s)

    end

    if rule

      issue.assign_attributes rule.slice(*Issue.attribute_names)

    end

    Redmine::Hook.call_hook(:model_changeset_scan_commit_for_issue_ids_pre_issue_update,

                            { :changeset => self, :issue => issue, :action => action })

    unless issue.save

      logger.warn("Issue ##{issue.id} could not be saved by changeset #{id}: #{issue.errors.full_messages}") if logger

    end

    issue

  end

  def log_time(issue, hours)

    time_entry = TimeEntry.new(

      :user => user,

      :hours => hours,

      :issue => issue,

      :spent_on => commit_date,

      :comments => l(:text_time_logged_by_changeset, :value => text_tag(issue.project),

                     :locale => Setting.default_language)

      )

    time_entry.activity = log_time_activity unless log_time_activity.nil?

    unless time_entry.save

      logger.warn("TimeEntry could not be created by changeset #{id}: #{time_entry.errors.full_messages}") if logger

    end

    time_entry

  end

  def log_time_activity

    if Setting.commit_logtime_activity_id.to_i > 0

      TimeEntryActivity.find_by_id(Setting.commit_logtime_activity_id.to_i)

    end

  end

  def split_comments

    comments =~ /\A(.+?)\r?\n(.*)$/m

    @short_comments = $1 || comments

    @long_comments = $2.to_s.strip

    return @short_comments, @long_comments

  end

  public

  # Strips and reencodes a commit log before insertion into the database

  def self.normalize_comments(str, encoding)

    Changeset.to_utf8(str.to_s.strip, encoding)

  end

  def self.to_utf8(str, encoding)

    Redmine::CodesetUtil.to_utf8(str, encoding)

  end

end

# Redmine - project management software

# Copyright (C) 2006-2014  Jean-Philippe Lang

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

class Comment < ActiveRecord::Base

  include Redmine::SafeAttributes

  belongs_to :commented, :polymorphic => true, :counter_cache => true

  belongs_to :author, :class_name => 'User', :foreign_key => 'author_id'

  validates_presence_of :commented, :author, :comments

  after_create :send_notification

  safe_attributes 'comments'

  private

  def send_notification

    mailer_method = "#{commented.class.name.underscore}_comment_added"

    if Setting.notified_events.include?(mailer_method)

      Mailer.send(mailer_method, self).deliver

    end