SoundSoftware Code Site

# Redmine - project management software

# Copyright (C) 2006-2012  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 File.expand_path('../../../test_helper', __FILE__)

class ApiTest::MembershipsTest < ActionController::IntegrationTest

  fixtures :projects, :users, :roles, :members, :member_roles

  def setup

    Setting.rest_api_enabled = '1'

  end

  context "/projects/:project_id/memberships" do

    context "GET" do

      context "xml" do

        should "return memberships" do

          get '/projects/1/memberships.xml', {}, credentials('jsmith')

          assert_response :success

          assert_equal 'application/xml', @response.content_type

          assert_tag :tag => 'memberships',

            :attributes => {:type => 'array'},

            :child => {

              :tag => 'membership',

              :child => {

                :tag => 'id',

                :content => '2',

                :sibling => {

                  :tag => 'user',

                  :attributes => {:id => '3', :name => 'Dave Lopper'},

                  :sibling => {

                    :tag => 'roles',

                    :child => {

                      :tag => 'role',

                      :attributes => {:id => '2', :name => 'Developer'}

                    }

                  }

                }

              }

            }

        end

      end

      context "json" do

        should "return memberships" do

          get '/projects/1/memberships.json', {}, credentials('jsmith')

          assert_response :success

          assert_equal 'application/json', @response.content_type

          json = ActiveSupport::JSON.decode(response.body)

          assert_equal({

            "memberships" =>

              [{"id"=>1,

                "project" => {"name"=>"eCookbook", "id"=>1},

                "roles" => [{"name"=>"Manager", "id"=>1}],

                "user" => {"name"=>"John Smith", "id"=>2}},

               {"id"=>2,

                "project" => {"name"=>"eCookbook", "id"=>1},

                "roles" => [{"name"=>"Developer", "id"=>2}],

                "user" => {"name"=>"Dave Lopper", "id"=>3}}],

           "limit" => 25,

           "total_count" => 2,

           "offset" => 0},

           json)

        end

      end

    end

    context "POST" do

      context "xml" do

        should "create membership" do

          assert_difference 'Member.count' do

            post '/projects/1/memberships.xml', {:membership => {:user_id => 7, :role_ids => [2,3]}}, credentials('jsmith')

            assert_response :created

          end

        end

        should "return errors on failure" do

          assert_no_difference 'Member.count' do

            post '/projects/1/memberships.xml', {:membership => {:role_ids => [2,3]}}, credentials('jsmith')

            assert_response :unprocessable_entity

            assert_equal 'application/xml', @response.content_type

            assert_tag 'errors', :child => {:tag => 'error', :content => "Principal can't be blank"}

          end

        end

      end

    end

  end

  context "/memberships/:id" do

    context "GET" do

      context "xml" do

        should "return the membership" do

          get '/memberships/2.xml', {}, credentials('jsmith')

          assert_response :success

          assert_equal 'application/xml', @response.content_type

          assert_tag :tag => 'membership',

            :child => {

              :tag => 'id',

              :content => '2',

              :sibling => {

                :tag => 'user',

                :attributes => {:id => '3', :name => 'Dave Lopper'},

                :sibling => {

                  :tag => 'roles',

                  :child => {

                    :tag => 'role',

                    :attributes => {:id => '2', :name => 'Developer'}

                  }

                }

              }

            }

        end

      end

      context "json" do

        should "return the membership" do

          get '/memberships/2.json', {}, credentials('jsmith')

          assert_response :success

          assert_equal 'application/json', @response.content_type

          json = ActiveSupport::JSON.decode(response.body)

          assert_equal(

            {"membership" => {

              "id" => 2,

              "project" => {"name"=>"eCookbook", "id"=>1},

              "roles" => [{"name"=>"Developer", "id"=>2}],

              "user" => {"name"=>"Dave Lopper", "id"=>3}}

            },

            json)

        end

      end

    end

    context "PUT" do

      context "xml" do

        should "update membership" do

          assert_not_equal [1,2], Member.find(2).role_ids.sort

          assert_no_difference 'Member.count' do

            put '/memberships/2.xml', {:membership => {:user_id => 3, :role_ids => [1,2]}}, credentials('jsmith')

            assert_response :ok

            assert_equal '', @response.body

          end

          member = Member.find(2)

          assert_equal [1,2], member.role_ids.sort

        end

        should "return errors on failure" do

          put '/memberships/2.xml', {:membership => {:user_id => 3, :role_ids => [99]}}, credentials('jsmith')

          assert_response :unprocessable_entity

          assert_equal 'application/xml', @response.content_type

          assert_tag 'errors', :child => {:tag => 'error', :content => /member_roles is invalid/}

        end

      end

    end

    context "DELETE" do

      context "xml" do

        should "destroy membership" do

          assert_difference 'Member.count', -1 do

            delete '/memberships/2.xml', {}, credentials('jsmith')

            assert_response :ok

            assert_equal '', @response.body

          end

          assert_nil Member.find_by_id(2)

        end

        should "respond with 422 on failure" do

          assert_no_difference 'Member.count' do

            # A membership with an inherited role can't be deleted

            Member.find(2).member_roles.first.update_attribute :inherited_from, 99

            delete '/memberships/2.xml', {}, credentials('jsmith')

            assert_response :unprocessable_entity

          end

        end

      end

    end

  end

end

# Redmine - project management software

# Copyright (C) 2006-2012  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 'iconv'

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| { :include => {:repository => :project},

                                          :conditions => 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_fix_keywords.downcase.split(",").collect(&:strip)

    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], 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

          fix_issue(issue) if fix_keywords.include?(action.to_s.downcase)

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

        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)

    tag = if scmid?

      "commit:#{scmid}"

    else

      "r#{revision}"

    end

    if repository && repository.identifier.present?

      tag = "#{repository.identifier}|#{tag}"

    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.find_by_id(id.to_i, :include => :project)

    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

  def fix_issue(issue)

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

    if status.nil?

      logger.warn("No status matches commit_fix_status_id setting (#{Setting.commit_fix_status_id})") if logger

      return issue

    end

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

    issue.status = status

    unless Setting.commit_fix_done_ratio.blank?

      issue.done_ratio = Setting.commit_fix_done_ratio.to_i

    end

    Redmine::Hook.call_hook(:model_changeset_scan_commit_for_issue_ids_pre_issue_update,

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

    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-2012  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 'diff'

# The WikiController follows the Rails REST controller pattern but with

# a few differences

#

# * index - shows a list of WikiPages grouped by page or date

# * new - not used

# * create - not used

# * show - will also show the form for creating a new wiki page

# * edit - used to edit an existing or new page

# * update - used to save a wiki page update to the database, including new pages

# * destroy - normal

#

# Other member and collection methods are also used

#

# TODO: still being worked on

class WikiController < ApplicationController

  default_search_scope :wiki_pages

  before_filter :find_wiki, :authorize

  before_filter :find_existing_or_new_page, :only => [:show, :edit, :update]

  before_filter :find_existing_page, :only => [:rename, :protect, :history, :diff, :annotate, :add_attachment, :destroy, :destroy_version]

  accept_api_auth :index, :show, :update, :destroy

  helper :attachments

  include AttachmentsHelper

  helper :watchers

  include Redmine::Export::PDF

  # List of pages, sorted alphabetically and by parent (hierarchy)

  def index

    load_pages_for_index

    respond_to do |format|

      format.html {

        @pages_by_parent_id = @pages.group_by(&:parent_id)

      }

      format.api

    end

  end

  # List of page, by last update

  def date_index

    load_pages_for_index

    @pages_by_date = @pages.group_by {|p| p.updated_on.to_date}

  end

  # display a page (in editing mode if it doesn't exist)

  def show

    if @page.new_record?

      if User.current.allowed_to?(:edit_wiki_pages, @project) && editable? && !api_request?

        edit

        render :action => 'edit'

      else

        render_404

      end

      return

    end

    if params[:version] && !User.current.allowed_to?(:view_wiki_edits, @project)

      deny_access

      return

    end

    @content = @page.content_for_version(params[:version])

    if User.current.allowed_to?(:export_wiki_pages, @project)

      if params[:format] == 'pdf'

        send_data(wiki_page_to_pdf(@page, @project), :type => 'application/pdf', :filename => "#{@page.title}.pdf")

        return

      elsif params[:format] == 'html'

        export = render_to_string :action => 'export', :layout => false

        send_data(export, :type => 'text/html', :filename => "#{@page.title}.html")

        return

      elsif params[:format] == 'txt'

        send_data(@content.text, :type => 'text/plain', :filename => "#{@page.title}.txt")

        return

      end

    end

    @editable = editable?

    @sections_editable = @editable && User.current.allowed_to?(:edit_wiki_pages, @page.project) &&

      @content.current_version? &&

      Redmine::WikiFormatting.supports_section_edit?

    respond_to do |format|

      format.html

      format.api

    end

  end

  # edit an existing page or a new one

  def edit

    return render_403 unless editable?

    if @page.new_record?

      @page.content = WikiContent.new(:page => @page)

      if params[:parent].present?

        @page.parent = @page.wiki.find_page(params[:parent].to_s)

      end

    end

    @content = @page.content_for_version(params[:version])

    @content.text = initial_page_content(@page) if @content.text.blank?

    # don't keep previous comment

    @content.comments = nil

    # To prevent StaleObjectError exception when reverting to a previous version

    @content.version = @page.content.version

    @text = @content.text

    if params[:section].present? && Redmine::WikiFormatting.supports_section_edit?

      @section = params[:section].to_i

      @text, @section_hash = Redmine::WikiFormatting.formatter.new(@text).get_section(@section)

      render_404 if @text.blank?

    end

  end

  # Creates a new page or updates an existing one

  def update

    return render_403 unless editable?

    was_new_page = @page.new_record?

    @page.content = WikiContent.new(:page => @page) if @page.new_record?

    @page.safe_attributes = params[:wiki_page]

    @content = @page.content

    content_params = params[:content]

    if content_params.nil? && params[:wiki_page].is_a?(Hash)

      content_params = params[:wiki_page].slice(:text, :comments, :version)

    end

    content_params ||= {}

    @content.comments = content_params[:comments]

    @text = content_params[:text]

    if params[:section].present? && Redmine::WikiFormatting.supports_section_edit?

      @section = params[:section].to_i

      @section_hash = params[:section_hash]

      @content.text = Redmine::WikiFormatting.formatter.new(@content.text).update_section(params[:section].to_i, @text, @section_hash)

    else

      @content.version = content_params[:version] if content_params[:version]

      @content.text = @text

    end

    @content.author = User.current

    if @page.save_with_content

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

      render_attachment_warning_if_needed(@page)

      call_hook(:controller_wiki_edit_after_save, { :params => params, :page => @page})

      respond_to do |format|

        format.html { redirect_to :action => 'show', :project_id => @project, :id => @page.title }

        format.api {

          if was_new_page

            render :action => 'show', :status => :created, :location => url_for(:controller => 'wiki', :action => 'show', :project_id => @project, :id => @page.title)

          else

            render_api_ok

          end

        }

      end

    else

      respond_to do |format|

        format.html { render :action => 'edit' }

        format.api { render_validation_errors(@content) }

      end

    end

  rescue ActiveRecord::StaleObjectError, Redmine::WikiFormatting::StaleSectionError

    # Optimistic locking exception

    respond_to do |format|

      format.html {

        flash.now[:error] = l(:notice_locking_conflict)

        render :action => 'edit'

      }

      format.api { render_api_head :conflict }

    end

  rescue ActiveRecord::RecordNotSaved

    respond_to do |format|

      format.html { render :action => 'edit' }

      format.api { render_validation_errors(@content) }

    end

  end

  # rename a page

  def rename

    return render_403 unless editable?

    @page.redirect_existing_links = true

    # used to display the *original* title if some AR validation errors occur

    @original_title = @page.pretty_title

    if request.post? && @page.update_attributes(params[:wiki_page])

      flash[:notice] = l(:notice_successful_update)

      redirect_to :action => 'show', :project_id => @project, :id => @page.title

    end

  end

  def protect

    @page.update_attribute :protected, params[:protected]

    redirect_to :action => 'show', :project_id => @project, :id => @page.title

  end

  # show page history

  def history

    @version_count = @page.content.versions.count

    @version_pages = Paginator.new self, @version_count, per_page_option, params['page']

    # don't load text

    @versions = @page.content.versions.find :all,

                                            :select => "id, author_id, comments, updated_on, version",

                                            :order => 'version DESC',

                                            :limit  =>  @version_pages.items_per_page + 1,

                                            :offset =>  @version_pages.current.offset

    render :layout => false if request.xhr?

  end

  def diff

    @diff = @page.diff(params[:version], params[:version_from])

    render_404 unless @diff

  end

  def annotate

    @annotate = @page.annotate(params[:version])

    render_404 unless @annotate

  end

  # Removes a wiki page and its history

  # Children can be either set as root pages, removed or reassigned to another parent page

  def destroy

    return render_403 unless editable?

    @descendants_count = @page.descendants.size

    if @descendants_count > 0

      case params[:todo]

      when 'nullify'

        # Nothing to do

      when 'destroy'

        # Removes all its descendants

        @page.descendants.each(&:destroy)

      when 'reassign'

        # Reassign children to another parent page

        reassign_to = @wiki.pages.find_by_id(params[:reassign_to_id].to_i)

        return unless reassign_to

        @page.children.each do |child|

          child.update_attribute(:parent, reassign_to)

        end

      else

        @reassignable_to = @wiki.pages - @page.self_and_descendants

        # display the destroy form if it's a user request

        return unless api_request?

      end

    end

    @page.destroy

    respond_to do |format|

      format.html { redirect_to :action => 'index', :project_id => @project }

      format.api { render_api_ok }

    end

  end

  def destroy_version

    return render_403 unless editable?

    @content = @page.content_for_version(params[:version])

    @content.destroy

    redirect_to_referer_or :action => 'history', :id => @page.title, :project_id => @project

  end

  # Export wiki to a single pdf or html file

  def export

    @pages = @wiki.pages.all(:order => 'title', :include => [:content, {:attachments => :author}])

    respond_to do |format|

      format.html {

        export = render_to_string :action => 'export_multiple', :layout => false

        send_data(export, :type => 'text/html', :filename => "wiki.html")

      }

      format.pdf {

        send_data(wiki_pages_to_pdf(@pages, @project), :type => 'application/pdf', :filename => "#{@project.identifier}.pdf")

      }

    end

  end

  def preview

    page = @wiki.find_page(params[:id])

    # page is nil when previewing a new page

    return render_403 unless page.nil? || editable?(page)

    if page

      @attachements = page.attachments

      @previewed = page.content

    end

    @text = params[:content][:text]

    render :partial => 'common/preview'

  end

  def add_attachment

    return render_403 unless editable?

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

    render_attachment_warning_if_needed(@page)

    redirect_to :action => 'show', :id => @page.title, :project_id => @project

  end

private

  def find_wiki

    @project = Project.find(params[:project_id])

    @wiki = @project.wiki

    render_404 unless @wiki

  rescue ActiveRecord::RecordNotFound

    render_404

  end

  # Finds the requested page or a new page if it doesn't exist

  def find_existing_or_new_page

    @page = @wiki.find_or_new_page(params[:id])

    if @wiki.page_found_with_redirect?

      redirect_to params.update(:id => @page.title)

    end

  end

  # Finds the requested page and returns a 404 error if it doesn't exist

  def find_existing_page

    @page = @wiki.find_page(params[:id])

    if @page.nil?

      render_404

      return

    end

    if @wiki.page_found_with_redirect?

      redirect_to params.update(:id => @page.title)

    end

  end

  # Returns true if the current user is allowed to edit the page, otherwise false

  def editable?(page = @page)

    page.editable_by?(User.current)

  end

  # Returns the default content of a new wiki page

  def initial_page_content(page)

    helper = Redmine::WikiFormatting.helper_for(Setting.text_formatting)

    extend helper unless self.instance_of?(helper)

    helper.instance_method(:initial_page_content).bind(self).call(page)

  end

  def load_pages_for_index

    @pages = @wiki.pages.with_updated_on.order("#{WikiPage.table_name}.title").includes(:wiki => :project).includes(:parent).all

  end

end

# encoding: utf-8

#

# Helpers to sort tables using clickable column headers.

#

# Author:  Stuart Rackham <srackham@methods.co.nz>, March 2005.

#          Jean-Philippe Lang, 2009

# License: This source code is released under the MIT license.

#

# - Consecutive clicks toggle the column's sort order.

# - Sort state is maintained by a session hash entry.

# - CSS classes identify sort column and state.

# - Typically used in conjunction with the Pagination module.

#

# Example code snippets:

#

# Controller:

#

#   helper :sort

#   include SortHelper

#

#   def list

#     sort_init 'last_name'

#     sort_update %w(first_name last_name)

#     @items = Contact.find_all nil, sort_clause

#   end

#

# Controller (using Pagination module):

#

#   helper :sort

#   include SortHelper

#

#   def list

#     sort_init 'last_name'

#     sort_update %w(first_name last_name)

#     @contact_pages, @items = paginate :contacts,

#       :order_by => sort_clause,

#       :per_page => 10

#   end

#

# View (table header in list.rhtml):

#

#   <thead>

#     <tr>

#       <%= sort_header_tag('id', :title => 'Sort by contact ID') %>

#       <%= sort_header_tag('last_name', :caption => 'Name') %>

#       <%= sort_header_tag('phone') %>

#       <%= sort_header_tag('address', :width => 200) %>

#     </tr>

#   </thead>

#

# - Introduces instance variables: @sort_default, @sort_criteria

# - Introduces param :sort

#

module SortHelper

  class SortCriteria

    def initialize

      @criteria = []

    end

    def available_criteria=(criteria)

      unless criteria.is_a?(Hash)

        criteria = criteria.inject({}) {|h,k| h[k] = k; h}

      end

      @available_criteria = criteria

    end

    def from_param(param)

      @criteria = param.to_s.split(',').collect {|s| s.split(':')[0..1]}

      normalize!

    end

    def criteria=(arg)

      @criteria = arg

      normalize!

    end

    def to_param

      @criteria.collect {|k,o| k + (o ? '' : ':desc')}.join(',')

    end

    def to_sql

      sql = @criteria.collect do |k,o|

        if s = @available_criteria[k]

          (o ? s.to_a : s.to_a.collect {|c| append_desc(c)}).join(', ')

        end

      end.compact.join(', ')

      sql.blank? ? nil : sql

    end

    def to_a

      @criteria.dup

    end

    def add!(key, asc)

      @criteria.delete_if {|k,o| k == key}

      @criteria = [[key, asc]] + @criteria

      normalize!

    end

    def add(*args)

      r = self.class.new.from_param(to_param)

      r.add!(*args)

      r

    end

    def first_key

      @criteria.first && @criteria.first.first

    end

    def first_asc?

      @criteria.first && @criteria.first.last

    end

    def empty?

      @criteria.empty?

    end

    private

    def normalize!

      @criteria ||= []

      @criteria = @criteria.collect {|s| s = s.to_a; [s.first, (s.last == false || s.last == 'desc') ? false : true]}

      @criteria = @criteria.select {|k,o| @available_criteria.has_key?(k)} if @available_criteria

      @criteria.slice!(3)

      self

    end

    # Appends DESC to the sort criterion unless it has a fixed order

    def append_desc(criterion)

      if criterion =~ / (asc|desc)$/i

        criterion

      else

        "#{criterion} DESC"

      end

    end

  end

  def sort_name

    controller_name + '_' + action_name + '_sort'

  end

  # Initializes the default sort.

  # Examples:

  #

  #   sort_init 'name'

  #   sort_init 'id', 'desc'

  #   sort_init ['name', ['id', 'desc']]

  #   sort_init [['name', 'desc'], ['id', 'desc']]

  #

  def sort_init(*args)

    case args.size

    when 1

      @sort_default = args.first.is_a?(Array) ? args.first : [[args.first]]

    when 2

      @sort_default = [[args.first, args.last]]

    else

      raise ArgumentError

    end

  end

  # Updates the sort state. Call this in the controller prior to calling

  # sort_clause.

  # - criteria can be either an array or a hash of allowed keys

  #

  def sort_update(criteria, sort_name=nil)

    sort_name ||= self.sort_name

    @sort_criteria = SortCriteria.new

    @sort_criteria.available_criteria = criteria

    @sort_criteria.from_param(params[:sort] || session[sort_name])

    @sort_criteria.criteria = @sort_default if @sort_criteria.empty?

    session[sort_name] = @sort_criteria.to_param

  end

  # Clears the sort criteria session data

  #

  def sort_clear

    session[sort_name] = nil

  end

  # Returns an SQL sort clause corresponding to the current sort state.

  # Use this to sort the controller's table items collection.

  #

  def sort_clause()

    @sort_criteria.to_sql

  end

  def sort_criteria

    @sort_criteria

  end

  # Returns a link which sorts by the named column.

  #

  # - column is the name of an attribute in the sorted record collection.

  # - the optional caption explicitly specifies the displayed link text.

  # - 2 CSS classes reflect the state of the link: sort and asc or desc

  #

  def sort_link(column, caption, default_order)

    css, order = nil, default_order

    if column.to_s == @sort_criteria.first_key

      if @sort_criteria.first_asc?

        css = 'sort asc'

        order = 'desc'

      else

        css = 'sort desc'

        order = 'asc'

      end

    end

    caption = column.to_s.humanize unless caption

    sort_options = { :sort => @sort_criteria.add(column.to_s, order).to_param }

    url_options = params.merge(sort_options)

     # Add project_id to url_options

    url_options = url_options.merge(:project_id => params[:project_id]) if params.has_key?(:project_id)

    link_to_content_update(h(caption), url_options, :class => css)

  end

  # Returns a table header <th> tag with a sort link for the named column

  # attribute.

  #

  # Options:

  #   :caption     The displayed link name (defaults to titleized column name).

  #   :title       The tag's 'title' attribute (defaults to 'Sort by :caption').

  #

  # Other options hash entries generate additional table header tag attributes.

  #

  # Example:

  #

  #   <%= sort_header_tag('id', :title => 'Sort by contact ID', :width => 40) %>

  #

  def sort_header_tag(column, options = {})

    caption = options.delete(:caption) || column.to_s.humanize

    default_order = options.delete(:default_order) || 'asc'

    options[:title] = l(:label_sort_by, "\"#{caption}\"") unless options[:title]

    content_tag('th', sort_link(column, caption, default_order), options)

  end

end

<h2><%=l(:label_password_lost)%></h2>

<%= error_messages_for 'user' %>

<%= form_tag(lost_password_path) do %>

  <%= hidden_field_tag 'token', @token.value %>

  <div class="box tabular">

    <p>

      <label for="new_password"><%=l(:field_new_password)%> <span class="required">*</span></label>

      <%= password_field_tag 'new_password', nil, :size => 25 %>

      <em class="info"><%= l(:text_caracters_minimum, :count => Setting.password_min_length) %></em>

    </p>

    <p>

      <label for="new_password_confirmation"><%=l(:field_password_confirmation)%> <span class="required">*</span></label>

      <%= password_field_tag 'new_password_confirmation', nil, :size => 25 %>

    </p>

  </div>

  <p><%= submit_tag l(:button_save) %></p>

<% end %>

<h2><%= l(:label_spent_time) %></h2>

<%= labelled_form_for @time_entry, :url => time_entries_path do |f| %>

  <%= hidden_field_tag 'project_id', params[:project_id] if params[:project_id] %>

  <%= render :partial => 'form', :locals => {:f => f} %>

  <%= submit_tag l(:button_create) %>

  <%= submit_tag l(:button_create_and_continue), :name => 'continue' %>

<% end %>

# Redmine - project management software

# Copyright (C) 2006-2012  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 File.expand_path('../../../test_helper', __FILE__)

require 'pp'

class ApiTest::NewsTest < ActionController::IntegrationTest

  fixtures :projects, :trackers, :issue_statuses, :issues,

           :enumerations, :users, :issue_categories,

           :projects_trackers,

           :roles,

           :member_roles,

           :members,

           :enabled_modules,

           :workflows,

           :news

  def setup

    Setting.rest_api_enabled = '1'

  end

  context "GET /news" do

    context ".xml" do

      should "return news" do

        get '/news.xml'

        assert_tag :tag => 'news',

          :attributes => {:type => 'array'},

          :child => {

            :tag => 'news',

            :child => {

              :tag => 'id',

              :content => '2'

            }

          }

      end

    end

    context ".json" do

      should "return news" do

        get '/news.json'

        json = ActiveSupport::JSON.decode(response.body)

        assert_kind_of Hash, json

        assert_kind_of Array, json['news']

        assert_kind_of Hash, json['news'].first

        assert_equal 2, json['news'].first['id']

      end

    end

  end

  context "GET /projects/:project_id/news" do

    context ".xml" do

      should_allow_api_authentication(:get, "/projects/onlinestore/news.xml")

      should "return news" do

        get '/projects/ecookbook/news.xml'

        assert_tag :tag => 'news',

          :attributes => {:type => 'array'},

          :child => {

            :tag => 'news',

            :child => {

              :tag => 'id',

              :content => '2'

            }

          }

      end

    end

    context ".json" do

      should_allow_api_authentication(:get, "/projects/onlinestore/news.json")

      should "return news" do

        get '/projects/ecookbook/news.json'

        json = ActiveSupport::JSON.decode(response.body)

        assert_kind_of Hash, json

        assert_kind_of Array, json['news']

        assert_kind_of Hash, json['news'].first

        assert_equal 2, json['news'].first['id']

      end

    end

  end

end