Redmine

                link = link_to_project(p, {:only_path => only_path}, :class => 'project')

              end

            when 'user'

              link = link_to_user(u, :only_path => only_path) if u

            end

          elsif sep == ':'

                link = link_to_project(p, {:only_path => only_path}, :class => 'project')

              end

            when 'user'

              link = link_to_user(u, :only_path => only_path) if u

            end

          elsif sep == "@"

            name = remove_double_quotes(identifier)

            link = link_to_user(u, :only_path => only_path) if u

          end

        end

  def self.find_by_token(token)

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

      attachment_id, attachment_digest = $1, $2

      if attachment && attachment.container.nil?

        attachment

      end

  end

  def visible?(user=User.current)

  end

  # Returns true if the principal is a member of project

    return nil if name.blank?

    s = name.to_s

    if s.match(/^\d*$/)

    else

      changesets.where("revision LIKE ?", s + '%').first

    end

    return false if v.nil?

    v.to_s != '0'

  end

  def report_last_commit=(arg)

    merge_extra_info "extra_report_last_commit" => arg

  end

  def find_changeset_by_name(name)

    if name.present?

        changesets.where('scmid LIKE ?', "#{name}%").first

    end

  end

    if /[^\d]/ =~ s or s.size > 8

      cs = changesets.where(:scmid => s).first

    else

    end

    return cs if cs

    changesets.where('scmid LIKE ?', "#{s}%").first

  end

  def self.find_or_create_system_role(builtin, name)

    if role.nil?

      role = unscoped.create(:name => name) do |r|

        r.builtin = builtin

    key = key.to_s

    return nil unless action.present? && key =~ /\A[a-z0-9]+\z/i

    if token && (token.action == action) && (token.value == key) && token.user

      if validity_days.nil? || (token.created_on > validity_days.days.ago)

        token

      user = where(:login => login).detect {|u| u.login == login}

      unless user

        # Fail over to case-insensitive if none was found

      end

      user

    end

    # eg. project.children.visible(user)

    Project.unscoped do

      return @project_ids_by_role if @project_ids_by_role

      group_class = anonymous? ? GroupAnonymous : GroupNonMember

      group_id = group_class.pluck(:id).first

      members = Member.joins(:project, :member_roles).

        where("#{Project.table_name}.status <> 9").

        where("#{Member.table_name}.user_id = ? OR (#{Project.table_name}.is_public = ? AND #{Member.table_name}.user_id = ?)", self.id, true, group_id).

        pluck(:user_id, :role_id, :project_id)

      hash = {}

      members.each do |user_id, role_id, project_id|

        # Ignore the roles of the builtin group if the user is a member of the project

        next if user_id != id && project_ids.include?(project_id)

        hash[role_id] ||= []

        hash[role_id] << project_id

      end

      result = Hash.new([])

      if hash.present?

        roles = Role.where(:id => hash.keys).to_a

  # Returns the anonymous user.  If the anonymous user does not exist, it is created.  There can be only

  # one anonymous user per database.

  def self.anonymous

    if anonymous_user.nil?

      anonymous_user = AnonymousUser.unscoped.create(:lastname => 'Anonymous', :firstname => '', :login => '', :status => 0)

      raise 'Unable to create the anonymous user.' if anonymous_user.new_record?

    @page_found_with_redirect = false

    title = start_page if title.blank?

    title = Wiki.titleize(title)

    if page.nil? && options[:with_redirect] != false

      # search for a redirect

      redirect = redirects.where("LOWER(title) = LOWER(?)", title).first

      def target_class

        nil

      end

      def possible_custom_value_options(custom_value)

        possible_values_options(custom_value.custom_field, custom_value.customized)

      end

          value ||= label

          checked = (custom_value.value.is_a?(Array) && custom_value.value.include?(value)) || custom_value.value.to_s == value

          tag = view.send(tag_method, tag_name, value, checked, :id => nil)

        end

        if custom_value.custom_field.multiple?

          s << view.hidden_field_tag(tag_name, '', :id => nil)

      def reset_target_class

        @target_class = nil

      end

      def possible_custom_value_options(custom_value)

        options = possible_values_options(custom_value.custom_field, custom_value.customized)

        missing = [custom_value.value_was].flatten.reject(&:blank?) - options.map(&:last)

    class EnumerationFormat < RecordList

      add 'enumeration'

      self.form_partial = 'custom_fields/formats/enumeration'

      def label

        "label_field_format_enumeration"

      end

          end

        else

          if custom_value.value.present?

            extensions = custom_value.custom_field.extensions_allowed

            if attachment && extensions.present? && !attachment.extension_in?(extensions)

              errors << "#{::I18n.t('activerecord.errors.messages.invalid')} (#{l(:setting_attachment_extensions_allowed)}: #{extensions})"

      def after_save_custom_value(custom_field, custom_value)

        if custom_value.saved_change_to_value?

          if custom_value.value.present?

            if attachment

              attachment.container = custom_value

              attachment.save!

            end

          end

          if custom_value.value_before_last_save.present?

            if attachment

              attachment.destroy

            end

        puts

        # Trac 'resolution' field as a Redmine custom field

        r = IssueCustomField.new(:name => 'Resolution',

                                 :field_format => 'list',

                                 :is_filter => true) if r.nil?