SoundSoftware Code Site

  validates_presence_of :container, :filename, :author

  validates_length_of :filename, :maximum => 255

  validates_length_of :disk_filename, :maximum => 255

  acts_as_event :title => :filename,

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

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

  cattr_accessor :storage_path

    if self.filesize > Setting.attachment_max_size.to_i.kilobytes

      errors.add(:base, :too_long, :count => Setting.attachment_max_size.to_i.kilobytes)

    end

  # Copies the temporary file to its final location

  # and computes its MD5 hash

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

      md5 = Digest::MD5.new

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

        buffer = ""

      end

      self.digest = md5.hexdigest

    end

    # 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

  # Deletes file on the disk

    File.delete(diskfile) if !filename.blank? && File.exist?(diskfile)

  end

  end

  def image?

  end

  def is_text?

                              :file => file,

                              :description => attachment['description'].to_s.strip,

                              :author => User.current)

        if a.new_record?

          obj.unsaved_attachments ||= []

    {:files => attached, :unsaved => obj.unsaved_attachments}

  end

private

  def sanitize_filename(value)

    # get only the filename, not the whole path

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

  end

  # Returns an ASCII or hashed filename

#

# 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 AuthSource < ActiveRecord::Base

  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

#

# 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 'iconv'

  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, :maximum => 255, :allow_nil => true

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

  validates_numericality_of :port, :only_integer => true

  before_validation :strip_ldap_attributes

  def after_initialize

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

  end

  def authenticate(login, password)

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

    attrs = get_user_dn(login)

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

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

      return attrs.except(:dn)

  rescue  Net::LDAP::LdapError => text

    raise "LdapError: " + text

  end

  def auth_method_name

    "LDAP"

  end

  private

  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,

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

  def get_user_dn(login)

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

    attrs = {}

                     :attributes=> search_attributes) do |entry|

      if onthefly_register?

    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]

#

# 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.

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

  acts_as_list :scope => :project_id

  acts_as_watchable

  validates_presence_of :name, :description

  validates_length_of :name, :maximum => 30

  validates_length_of :description, :maximum => 255

  def visible?(user=User.current)

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

  end

  def to_s

    name

  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

  validates_presence_of :changeset_id, :action, :path

  before_save :init_path

  def relative_path

    changeset.repository.relative_path(path)

  end

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

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

  end

  belongs_to :user

  has_many :changes, :dependent => :delete_all

  has_and_belongs_to_many :issues

  acts_as_event :title => Proc.new {|o| "#{l(:label_revision)} #{o.format_identifier}" + (o.short_comments.blank? ? '' : (': ' + o.short_comments))},

                :description => :long_comments,

  named_scope :visible, lambda {|*args| { :include => {:repository => :project},

                                          :conditions => Project.allowed_to_condition(args.shift || User.current, :view_changesets, *args) } }

  def revision=(r)

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

  end

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

  end

    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

    scan_comment_for_issue_ids

  end

  def fix_issue(issue)

    status = IssueStatus.find_by_id(Setting.commit_fix_status_id.to_i)

    if status.nil?

      return issue

    end

  end

  def self.to_utf8(str, encoding)

  end

end

#

# 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.

# 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.

# 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.

  has_many :custom_values, :dependent => :delete_all

  acts_as_list :scope => 'type = \'#{self.class}\''

  serialize :possible_values

  validates_presence_of :name, :field_format

  validates_uniqueness_of :name, :scope => :type

  validates_length_of :name, :maximum => 30

  validates_inclusion_of :field_format, :in => Redmine::CustomFieldFormat.available_formats

  def initialize(attributes = nil)

    super

    self.possible_values ||= []

  end

  def before_validation

    # make sure these fields are not searchable

    self.searchable = false if %w(int float date bool).include?(field_format)

    true

  end

    if self.field_format == "list"

      errors.add(:possible_values, :blank) if self.possible_values.nil? || self.possible_values.empty?

      errors.add(:possible_values, :invalid) unless self.possible_values.is_a? Array

    end

    # validate default value

    v = CustomValue.new(:custom_field => self.clone, :value => default_value, :customized => nil)

    v.custom_field.is_required = false

    errors.add(:default_value, :invalid) unless v.valid?

  end

  def possible_values_options(obj=nil)

    case field_format

    when 'user', 'version'

        when 'user'

          obj.project.users.sort.collect {|u| [u.to_s, u.id.to_s]}

        when 'version'

        end

      elsif obj.is_a?(Array)

        obj.collect {|o| possible_values_options(o)}.inject {|memo, v| memo & v}

      read_attribute :possible_values

    end

  end

  def possible_values(obj=nil)

    case field_format

    when 'user', 'version'

      read_attribute :possible_values

    end

  end

  # Makes possible_values accept a multiline string

  def possible_values=(arg)

    if arg.is_a?(Array)

      self.possible_values = arg.to_s.split(/[\n\r]+/)

    end

  end

  def cast_value(value)

    casted = nil

    unless value.blank?

    end

    casted

  end

  # Returns a ORDER BY clause that can used to sort customized

  # objects by their value of the custom field.

  # Returns false, if the custom field can not be used for sorting.

    case field_format

      when 'string', 'text', 'list', 'date', 'bool'

        # COALESCE is here to make sure that blank and NULL values are sorted equally

          " WHERE cv_sort.customized_type='#{self.class.customized_class.name}'" +

          " AND cv_sort.customized_id=#{self.class.customized_class.table_name}.id" +

          " AND cv_sort.custom_field_id=#{id} LIMIT 1), '')"

        # Make the database cast values into numeric

        # Postgresql will raise an error if a value can not be casted!

        # CustomValue validations should ensure that it doesn't occur

          " WHERE cv_sort.customized_type='#{self.class.customized_class.name}'" +

          " AND cv_sort.customized_id=#{self.class.customized_class.table_name}.id" +

          " AND cv_sort.custom_field_id=#{id} AND cv_sort.value <> '' AND cv_sort.value IS NOT NULL LIMIT 1)"

  def <=>(field)

    position <=> field.position

  end

  def self.customized_class

    self.name =~ /^(.+)CustomField$/

    begin; $1.constantize; rescue nil; end

  end

  # to move in project_custom_field

  def self.for_all

    find(:all, :conditions => ["is_for_all=?", true], :order => 'position')

  end

  def type_name

    nil

  end

#

# 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.

  belongs_to :custom_field

  belongs_to :customized, :polymorphic => true

  def after_initialize

    if new_record? && custom_field && (customized_type.blank? || (customized && customized.new_record?))

      self.value ||= custom_field.default_value

    end

  end

  # Returns true if the boolean custom value is true

  def true?

    self.value == '1'

  end

  def editable?

    custom_field.editable?

  end

  def visible?

    custom_field.visible?

  end

  def required?

    custom_field.is_required?

  end

  def to_s

    value.to_s

  end

protected

    if value.blank?

    else

      errors.add(:value, :invalid) unless custom_field.regexp.blank? or value =~ Regexp.new(custom_field.regexp)

      errors.add(:value, :too_short, :count => custom_field.min_length) if custom_field.min_length > 0 and value.length < custom_field.min_length

      errors.add(:value, :too_long, :count => custom_field.max_length) if custom_field.max_length > 0 and value.length > custom_field.max_length

      # Format specific validations

      case custom_field.field_format

      when 'int'

      when 'float'

        begin; Kernel.Float(value); rescue; errors.add(:value, :invalid) end

      when 'date'

      when 'list'

        errors.add(:value, :inclusion) unless custom_field.possible_values.include?(value)

      end

#

# 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 Enumeration < ActiveRecord::Base

  default_scope :order => "#{Enumeration.table_name}.position ASC"

  belongs_to :project

  acts_as_list :scope => 'type = \'#{type}\''

  acts_as_customizable

  acts_as_tree :order => 'position ASC'

  before_destroy :check_integrity

  validates_presence_of :name

  validates_uniqueness_of :name, :scope => [:type, :project_id]

  validates_length_of :name, :maximum => 30

      find(:first, :conditions => { :is_default => true })

    end

  end

  # Overloaded on concrete classes

  def option_name

    nil

  end

    if is_default? && is_default_changed?

      Enumeration.update_all("is_default = #{connection.quoted_false}", {:type => type})

    end

  end

  # Overloaded on concrete classes

  def objects_count

    0

  end

  def in_use?

    self.objects_count != 0

  end

  def is_override?

    !self.parent.nil?

  end

  alias :destroy_without_reassign :destroy

  # Destroy the enumeration

  # If a enumeration is specified, objects are reassigned

  def destroy(reassign_to = nil)

    end

    destroy_without_reassign

  end

  def <=>(enumeration)

    position <=> enumeration.position

  end

  def to_s; name end

  # Returns the Subclasses of Enumeration.  Each Subclass needs to be

    return true

  end

  # Are the new and previous fields equal?

  def self.same_active_state?(new, previous)

    new = (new == "1" ? true : false)

    return new == previous

  end

private

  def check_integrity

    raise "Can't delete enumeration" if self.in_use?

# Redmine - project management software

#

# 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 Group < Principal

  has_and_belongs_to_many :users, :after_add => :user_added,

                                  :after_remove => :user_removed

  acts_as_customizable

  validates_presence_of :lastname

  validates_uniqueness_of :lastname, :case_sensitive => false

  validates_length_of :lastname, :maximum => 30

  def to_s

    lastname.to_s

  end

  def user_added(user)

    members.each do |member|

      next if member.project.nil?

      user_member.save!

    end

  end

  def user_removed(user)

    members.each do |member|

      MemberRole.find(:all, :include => :member,

                            :conditions => ["#{Member.table_name}.user_id = ? AND #{MemberRole.table_name}.inherited_from IN (?)", user.id, member.member_role_ids]).each(&:destroy)

    end

  end

end

# Redmine - project management software

#

# 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.

  belongs_to :tracker

  belongs_to :status, :class_name => 'IssueStatus', :foreign_key => 'status_id'

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

  belongs_to :fixed_version, :class_name => 'Version', :foreign_key => 'fixed_version_id'

  belongs_to :priority, :class_name => 'IssuePriority', :foreign_key => 'priority_id'

  belongs_to :category, :class_name => 'IssueCategory', :foreign_key => 'category_id'

  has_many :relations_to, :class_name => 'IssueRelation', :foreign_key => 'issue_to_id', :dependent => :delete_all

  acts_as_nested_set :scope => 'root_id', :dependent => :destroy

  acts_as_customizable

  acts_as_watchable

  acts_as_searchable :columns => ['subject', "#{table_name}.description", "#{Journal.table_name}.notes"],

  validates_length_of :subject, :maximum => 255

  validates_inclusion_of :done_ratio, :in => 0..100

  validates_numericality_of :estimated_hours, :allow_nil => true

  named_scope :visible, lambda {|*args| { :include => :project,

                                          :conditions => Issue.visible_condition(args.shift || User.current, *args) } }

      when 'all'

        nil

      when 'default'

      when 'own'

      else

        '1=0'

      end

      when 'all'

        true

      when 'default'

      when 'own'

      else

        false

      end

    @custom_field_values = nil

    result

  end

  def description=(arg)

    if arg.is_a?(String)

      arg = arg.gsub(/(\r\n|\n|\r)/, "\r\n")

    Setting.issue_done_ratio == 'issue_field'

  end

    if self.due_date.nil? && @attributes['due_date'] && !@attributes['due_date'].empty?

      errors.add :due_date, :not_a_date

    end

      if !assignable_versions.include?(fixed_version)

        errors.add :fixed_version_id, :inclusion

      elsif reopened? && fixed_version.closed?

      end

    end

  def assignable_users

    users = project.assignable_users

    users << author if author

    users.uniq.sort

  end

    # Author and assignee are always notified unless they have been

    # locked or don't want to be notified

    notified << author if author && author.active? && author.notify_about?(self)

    notified.uniq!

    # Remove users that can not view the issue

    notified.reject! {|user| !visible?(user)}

  end

  def relations

  end

  def all_dependent_issues(except=[])

        @time_entry.project = project

        @time_entry.issue = self

        @time_entry.user = User.current

        @time_entry.attributes = params[:time_entry]

        self.time_entries << @time_entry

      end

      if valid?

        attachments = Attachment.attach_files(self, params[:attachments])

        # TODO: Rename hook

        Redmine::Hook.call_hook(:controller_issues_edit_before_save, { :params => params, :issue => self, :time_entry => @time_entry, :journal => @current_journal})

        begin

          end

        rescue ActiveRecord::StaleObjectError

          attachments[:files].each(&:destroy)

          raise ActiveRecord::Rollback

        end

      end

  end

  # Callback on attachment deletion

  def attachment_removed(obj)

    journal = init_journal(User.current)

    journal.details << JournalDetail.new(:property => 'attachment',

# 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 IssueCategory < ActiveRecord::Base

  belongs_to :project

  has_many :issues, :foreign_key => 'category_id', :dependent => :nullify

  validates_presence_of :name

  validates_uniqueness_of :name, :scope => [:project_id]

  validates_length_of :name, :maximum => 30

  named_scope :named, lambda {|arg| { :conditions => ["LOWER(#{table_name}.name) = LOWER(?)", arg.to_s.strip]}}

  alias :destroy_without_reassign :destroy

  # Destroy the category

  # If a category is specified, issues are reassigned to this category

  def destroy(reassign_to = nil)

    end

    destroy_without_reassign

  end

  def <=>(category)

    name <=> category.name

  end

  def to_s; name end

end

#

# 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.

  has_and_belongs_to_many :projects, :join_table => "#{table_name_prefix}custom_fields_projects#{table_name_suffix}", :foreign_key => "custom_field_id"

  has_and_belongs_to_many :trackers, :join_table => "#{table_name_prefix}custom_fields_trackers#{table_name_suffix}", :foreign_key => "custom_field_id"

  has_many :issues, :through => :issue_custom_values

  def type_name

    :label_issue_plural

  end

#

# 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.

#

# 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.

#

# 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.

#

# 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 IssueRelation < ActiveRecord::Base

  belongs_to :issue_from, :class_name => 'Issue', :foreign_key => 'issue_from_id'

  belongs_to :issue_to, :class_name => 'Issue', :foreign_key => 'issue_to_id'

  TYPE_RELATES      = "relates"

  TYPE_DUPLICATES   = "duplicates"

  TYPE_DUPLICATED   = "duplicated"

  TYPE_BLOCKED      = "blocked"

  TYPE_PRECEDES     = "precedes"

  TYPE_FOLLOWS      = "follows"

  TYPES = { TYPE_RELATES =>     { :name => :label_relates_to, :sym_name => :label_relates_to, :order => 1, :sym => TYPE_RELATES },

            TYPE_DUPLICATES =>  { :name => :label_duplicates, :sym_name => :label_duplicated_by, :order => 2, :sym => TYPE_DUPLICATED },

            TYPE_DUPLICATED =>  { :name => :label_duplicated_by, :sym_name => :label_duplicates, :order => 3, :sym => TYPE_DUPLICATES, :reverse => TYPE_DUPLICATES },

            TYPE_PRECEDES =>    { :name => :label_precedes, :sym_name => :label_follows, :order => 6, :sym => TYPE_FOLLOWS },

            TYPE_FOLLOWS =>     { :name => :label_follows, :sym_name => :label_precedes, :order => 7, :sym => TYPE_PRECEDES, :reverse => TYPE_PRECEDES }

          }.freeze

  validates_presence_of :issue_from, :issue_to, :relation_type

  validates_inclusion_of :relation_type, :in => TYPES.keys

  validates_numericality_of :delay, :allow_nil => true

  validates_uniqueness_of :issue_to_id, :scope => :issue_from_id

  attr_protected :issue_from_id, :issue_to_id

    if issue_from && issue_to

      errors.add :issue_to_id, :invalid if issue_from_id == issue_to_id

      errors.add :issue_to_id, :not_same_project unless issue_from.project_id == issue_to.project_id || Setting.cross_project_issue_relations?

      #detect circular dependencies depending wether the relation should be reversed

      if TYPES.has_key?(relation_type) && TYPES[relation_type][:reverse]

      else

      end

    end

  end

  def other_issue(issue)

    (self.issue_from_id == issue.id) ? issue_to : issue_from

  end

  # Returns the relation type for +issue+

  def relation_type_for(issue)

    if TYPES[relation_type]

      end

    end

  end

  def label_for(issue)

    TYPES[relation_type] ? TYPES[relation_type][(self.issue_from_id == issue.id) ? :name : :sym_name] : :unknow

  end

    reverse_if_needed

    if TYPE_PRECEDES == relation_type

      self.delay ||= 0

    else

    end

    set_issue_to_dates

  end

  def set_issue_to_dates

    soonest_start = self.successor_soonest_start

    if soonest_start && issue_to

      issue_to.reschedule_after(soonest_start)

    end

  end

  def successor_soonest_start

    if (TYPE_PRECEDES == self.relation_type) && delay && issue_from && (issue_from.start_date || issue_from.due_date)

      (issue_from.due_date || issue_from.start_date) + 1 + delay

    end

  end

  def <=>(relation)

    TYPES[self.relation_type][:order] <=> TYPES[relation.relation_type][:order]

  end

  private

  # Reverses the relation if needed so that it gets stored in the proper way

  def reverse_if_needed

    if TYPES.has_key?(relation_type) && TYPES[relation_type][:reverse]

      issue_tmp = issue_to

#

# 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 IssueStatus < ActiveRecord::Base

  has_many :workflows, :foreign_key => "old_status_id"

  acts_as_list

  before_destroy :delete_workflows

  validates_presence_of :name

  validates_uniqueness_of :name

  validates_length_of :name, :maximum => 30

  validates_inclusion_of :default_done_ratio, :in => 0..100, :allow_nil => true

  named_scope :named, lambda {|arg| { :conditions => ["LOWER(#{table_name}.name) = LOWER(?)", arg.to_s.strip]}}

    IssueStatus.update_all("is_default=#{connection.quoted_false}", ['id <> ?', id]) if self.is_default?

  # Returns the default status for new issues

  def self.default

    find(:first, :conditions =>["is_default=?", true])

  end

  # Update all the +Issues+ setting their done_ratio to the value of their +IssueStatus+

  def self.update_issue_done_ratios

    if Issue.use_status_for_done_ratio?

      role_ids = roles.collect(&:id)

      transitions = workflows.select do |w|

        role_ids.include?(w.role_id) &&