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::GroupsTest < ActionController::IntegrationTest

  fixtures :users, :groups_users

  def setup

    Setting.rest_api_enabled = '1'

  end

  context "GET /groups" do

    context ".xml" do

      should "require authentication" do

        get '/groups.xml'

        assert_response 401

      end

      should "return groups" do

        get '/groups.xml', {}, credentials('admin')

        assert_response :success

        assert_equal 'application/xml', response.content_type

        assert_select 'groups' do

          assert_select 'group' do

            assert_select 'name', :text => 'A Team'

            assert_select 'id', :text => '10'

          end

        end

      end

    end

    context ".json" do

      should "require authentication" do

        get '/groups.json'

        assert_response 401

      end

      should "return groups" do

        get '/groups.json', {}, credentials('admin')

        assert_response :success

        assert_equal 'application/json', response.content_type

        json = MultiJson.load(response.body)

        groups = json['groups']

        assert_kind_of Array, groups

        group = groups.detect {|g| g['name'] == 'A Team'}

        assert_not_nil group

        assert_equal({'id' => 10, 'name' => 'A Team'}, group)

      end

    end

  end

  context "GET /groups/:id" do

    context ".xml" do

      should "return the group with its users" do

        get '/groups/10.xml', {}, credentials('admin')

        assert_response :success

        assert_equal 'application/xml', response.content_type

        assert_select 'group' do

          assert_select 'name', :text => 'A Team'

          assert_select 'id', :text => '10'

        end

      end

      should "include users if requested" do

        get '/groups/10.xml?include=users', {}, credentials('admin')

        assert_response :success

        assert_equal 'application/xml', response.content_type

        assert_select 'group' do

          assert_select 'users' do

            assert_select 'user', Group.find(10).users.count

            assert_select 'user[id=8]'

          end

        end

      end

      should "include memberships if requested" do

        get '/groups/10.xml?include=memberships', {}, credentials('admin')

        assert_response :success

        assert_equal 'application/xml', response.content_type

        assert_select 'group' do

          assert_select 'memberships'

        end

      end

    end

  end

  context "POST /groups" do

    context "with valid parameters" do

      context ".xml" do

        should "create groups" do

          assert_difference('Group.count') do

            post '/groups.xml', {:group => {:name => 'Test', :user_ids => [2, 3]}}, credentials('admin')

            assert_response :created

            assert_equal 'application/xml', response.content_type

          end

          group = Group.order('id DESC').first

          assert_equal 'Test', group.name

          assert_equal [2, 3], group.users.map(&:id).sort

          assert_select 'group' do

            assert_select 'name', :text => 'Test'

          end

        end

      end

    end

    context "with invalid parameters" do

      context ".xml" do

        should "return errors" do

          assert_no_difference('Group.count') do

            post '/groups.xml', {:group => {:name => ''}}, credentials('admin')

          end

          assert_response :unprocessable_entity

          assert_equal 'application/xml', response.content_type

          assert_select 'errors' do

            assert_select 'error', :text => /Name can't be blank/

          end

        end

      end

    end

  end

  context "PUT /groups/:id" do

    context "with valid parameters" do

      context ".xml" do

        should "update the group" do

          put '/groups/10.xml', {:group => {:name => 'New name', :user_ids => [2, 3]}}, credentials('admin')

          assert_response :ok

          assert_equal '', @response.body

          group = Group.find(10)

          assert_equal 'New name', group.name

          assert_equal [2, 3], group.users.map(&:id).sort

        end

      end

    end

    context "with invalid parameters" do

      context ".xml" do

        should "return errors" do

          put '/groups/10.xml', {:group => {:name => ''}}, credentials('admin')

          assert_response :unprocessable_entity

          assert_equal 'application/xml', response.content_type

          assert_select 'errors' do

            assert_select 'error', :text => /Name can't be blank/

          end

        end

      end

    end

  end

  context "DELETE /groups/:id" do

    context ".xml" do

      should "delete the group" do

        assert_difference 'Group.count', -1 do

          delete '/groups/10.xml', {}, credentials('admin')

          assert_response :ok

          assert_equal '', @response.body

        end

      end

    end

  end

  context "POST /groups/:id/users" do

    context ".xml" do

      should "add user to the group" do

        assert_difference 'Group.find(10).users.count' do

          post '/groups/10/users.xml', {:user_id => 5}, credentials('admin')

          assert_response :ok

          assert_equal '', @response.body

        end

        assert_include User.find(5), Group.find(10).users

      end

    end

  end

  context "DELETE /groups/:id/users/:user_id" do

    context ".xml" do

      should "remove user from the group" do

        assert_difference 'Group.find(10).users.count', -1 do

          delete '/groups/10/users/8.xml', {}, credentials('admin')

          assert_response :ok

          assert_equal '', @response.body

        end

        assert_not_include User.find(8), Group.find(10).users

      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 File.expand_path('../../../test_helper', __FILE__)

class RoutingWatchersTest < ActionController::IntegrationTest

  def test_watchers

    assert_routing(

        { :method => 'get', :path => "/watchers/new" },

        { :controller => 'watchers', :action => 'new' }

      )

    assert_routing(

        { :method => 'post', :path => "/watchers/append" },

        { :controller => 'watchers', :action => 'append' }

      )

    assert_routing(

        { :method => 'post', :path => "/watchers" },

        { :controller => 'watchers', :action => 'create' }

      )

    assert_routing(

        { :method => 'post', :path => "/watchers/destroy" },

        { :controller => 'watchers', :action => 'destroy' }

      )

    assert_routing(

        { :method => 'get', :path => "/watchers/autocomplete_for_user" },

        { :controller => 'watchers', :action => 'autocomplete_for_user' }

      )

    assert_routing(

        { :method => 'post', :path => "/watchers/watch" },

        { :controller => 'watchers', :action => 'watch' }

      )

    assert_routing(

        { :method => 'post', :path => "/watchers/unwatch" },

        { :controller => 'watchers', :action => 'unwatch' }

      )

  end

end

<%= board_breadcrumb(@message) %>

<div class="contextual">

    <%= watcher_tag(@topic, User.current) %>

    <%= link_to(

          l(:button_quote),

          {:action => 'quote', :id => @topic},

          :remote => true,

          :method => 'get',

          :class => 'icon icon-comment',

          :remote => true) if !@topic.locked? && authorize_for('messages', 'reply') %>

    <%= link_to(

          l(:button_edit),

          {:action => 'edit', :id => @topic},

          :class => 'icon icon-edit'

        ) if @message.editable_by?(User.current) %>

    <%= link_to(

          l(:button_delete),

          {:action => 'destroy', :id => @topic},

          :method => :post,

          :data => {:confirm => l(:text_are_you_sure)},

          :class => 'icon icon-del'

         ) if @message.destroyable_by?(User.current) %>

</div>

<h2><%= avatar(@topic.author, :size => "24") %><%=h @topic.subject %></h2>

<div class="message">

<p><span class="author"><%= authoring @topic.created_on, @topic.author %></span></p>

<div class="wiki">

<%= textilizable(@topic, :content) %>

</div>

<%= link_to_attachments @topic, :author => false %>

</div>

<br />

<% unless @replies.empty? %>

<h3 class="comments"><%= l(:label_reply_plural) %> (<%= @reply_count %>)</h3>

<% @replies.each do |message| %>

  <div class="message reply" id="<%= "message-#{message.id}" %>">

    <div class="contextual">

      <%= link_to(

            image_tag('comment.png'),

            {:action => 'quote', :id => message},

            :remote => true,

            :method => 'get',

            :title => l(:button_quote)) if !@topic.locked? && authorize_for('messages', 'reply') %>

      <%= link_to(

            image_tag('edit.png'),

            {:action => 'edit', :id => message},

            :title => l(:button_edit)

          ) if message.editable_by?(User.current) %>

      <%= link_to(

            image_tag('delete.png'),

            {:action => 'destroy', :id => message},

            :method => :post,

            :data => {:confirm => l(:text_are_you_sure)},

            :title => l(:button_delete)

          ) if message.destroyable_by?(User.current) %>

    </div>

  <h4>

    <%= avatar(message.author, :size => "24") %>

    <%= link_to h(message.subject), { :controller => 'messages', :action => 'show', :board_id => @board, :id => @topic, :r => message, :anchor => "message-#{message.id}" } %>

    -

    <%= authoring message.created_on, message.author %>

  </h4>

  <div class="wiki"><%= textilizable message, :content, :attachments => message.attachments %></div>

  <%= link_to_attachments message, :author => false %>

  </div>

<% end %>

<p class="pagination"><%= pagination_links_full @reply_pages, @reply_count, :per_page_links => false %></p>

<% end %>

<% if !@topic.locked? && authorize_for('messages', 'reply') %>

<p><%= toggle_link l(:button_reply), "reply", :focus => 'message_content' %></p>

<div id="reply" style="display:none;">

<%= form_for @reply, :as => :reply, :url => {:action => 'reply', :id => @topic}, :html => {:multipart => true, :id => 'message-form'} do |f| %>

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

  <%= submit_tag l(:button_submit) %>

  <%= preview_link({:controller => 'messages', :action => 'preview', :board_id => @board}, 'message-form') %>

<% end %>

<div id="preview" class="wiki"></div>

</div>

<% end %>

<% html_title @topic.subject %>

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

module Redmine

  module Helpers

    # Simple class to compute the start and end dates of a calendar

    class Calendar

      include Redmine::I18n

      attr_reader :startdt, :enddt

      def initialize(date, lang = current_language, period = :month)

        @date = date

        @events = []

        @ending_events_by_days = {}

        @starting_events_by_days = {}

        set_language_if_valid lang

        case period

        when :month

          @startdt = Date.civil(date.year, date.month, 1)

          @enddt = (@startdt >> 1)-1

          # starts from the first day of the week

          @startdt = @startdt - (@startdt.cwday - first_wday)%7

          # ends on the last day of the week

          @enddt = @enddt + (last_wday - @enddt.cwday)%7

        when :week

          @startdt = date - (date.cwday - first_wday)%7

          @enddt = date + (last_wday - date.cwday)%7

        else

          raise 'Invalid period'

        end

      end

      # Sets calendar events

      def events=(events)

        @events = events

        @ending_events_by_days = @events.group_by {|event| event.due_date}

        @starting_events_by_days = @events.group_by {|event| event.start_date}

      end

      # Returns events for the given day

      def events_on(day)

        ((@ending_events_by_days[day] || []) + (@starting_events_by_days[day] || [])).uniq

      end

      # Calendar current month

      def month

        @date.month

      end

      # Return the first day of week

      # 1 = Monday ... 7 = Sunday

      def first_wday

        case Setting.start_of_week.to_i

        when 1

          @first_dow ||= (1 - 1)%7 + 1

        when 6

          @first_dow ||= (6 - 1)%7 + 1

        when 7

          @first_dow ||= (7 - 1)%7 + 1

        else

          @first_dow ||= (l(:general_first_day_of_week).to_i - 1)%7 + 1

        end

      end

      def last_wday

        @last_dow ||= (first_wday + 5)%7 + 1

      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.

module Redmine

  module WikiFormatting

    module Macros

      module Definitions

        # Returns true if +name+ is the name of an existing macro

        def macro_exists?(name)

          Redmine::WikiFormatting::Macros.available_macros.key?(name.to_sym)

        end

        def exec_macro(name, obj, args, text)

          macro_options = Redmine::WikiFormatting::Macros.available_macros[name.to_sym]

          return unless macro_options

          method_name = "macro_#{name}"

          unless macro_options[:parse_args] == false

            args = args.split(',').map(&:strip)

          end

          begin

            if self.class.instance_method(method_name).arity == 3

              send(method_name, obj, args, text)

            elsif text

              raise "This macro does not accept a block of text"

            else

              send(method_name, obj, args)

            end

          rescue => e

            "<div class=\"flash error\">Error executing the <strong>#{h name}</strong> macro (#{h e.to_s})</div>".html_safe

          end

        end

        def extract_macro_options(args, *keys)

          options = {}

          while args.last.to_s.strip =~ %r{^(.+?)\=(.+)$} && keys.include?($1.downcase.to_sym)

            options[$1.downcase.to_sym] = $2

            args.pop

          end

          return [args, options]

        end

      end

      @@available_macros = {}

      mattr_accessor :available_macros

      class << self

        # Plugins can use this method to define new macros:

        #

        #   Redmine::WikiFormatting::Macros.register do

        #     desc "This is my macro"

        #     macro :my_macro do |obj, args|

        #       "My macro output"

        #     end

        #   

        #     desc "This is my macro that accepts a block of text"

        #     macro :my_macro do |obj, args, text|

        #       "My macro output"

        #     end

        #   end

        def register(&block)

          class_eval(&block) if block_given?

        end

        # Defines a new macro with the given name, options and block.

        #

        # Options:

        # * :desc - A description of the macro

        # * :parse_args => false - Disables arguments parsing (the whole arguments 

        #   string is passed to the macro)

        #

        # Macro blocks accept 2 or 3 arguments:

        # * obj: the object that is rendered (eg. an Issue, a WikiContent...)

        # * args: macro arguments

        # * text: the block of text given to the macro (should be present only if the

        #   macro accepts a block of text). text is a String or nil if the macro is

        #   invoked without a block of text.  

        #

        # Examples:

        # By default, when the macro is invoked, the coma separated list of arguments

        # is split and passed to the macro block as an array. If no argument is given

        # the macro will be invoked with an empty array:

        #

        #   macro :my_macro do |obj, args|

        #     # args is an array

        #     # and this macro do not accept a block of text

        #   end

        #

        # You can disable arguments spliting with the :parse_args => false option. In

        # this case, the full string of arguments is passed to the macro:

        #

        #   macro :my_macro, :parse_args => false do |obj, args|

        #     # args is a string

        #   end

        #

        # Macro can optionally accept a block of text:

        #

        #   macro :my_macro do |obj, args, text|

        #     # this macro accepts a block of text

        #   end

        #

        # Macros are invoked in formatted text using double curly brackets. Arguments

        # must be enclosed in parenthesis if any. A new line after the macro name or the

        # arguments starts the block of text that will be passe to the macro (invoking

        # a macro that do not accept a block of text with some text will fail).

        # Examples:

        #

        #   No arguments:

        #   {{my_macro}}

        #

        #   With arguments:

        #   {{my_macro(arg1, arg2)}}

        #

        #   With a block of text:

        #   {{my_macro

        #   multiple lines

        #   of text

        #   }}

        #

        #   With arguments and a block of text

        #   {{my_macro(arg1, arg2)

        #   multiple lines

        #   of text

        #   }}

        #

        # If a block of text is given, the closing tag }} must be at the start of a new line.

        def macro(name, options={}, &block)

          options.assert_valid_keys(:desc, :parse_args)

          unless name.to_s.match(/\A\w+\z/)

            raise "Invalid macro name: #{name} (only 0-9, A-Z, a-z and _ characters are accepted)"

          end

          unless block_given?

            raise "Can not create a macro without a block!"

          end

          name = name.to_s.downcase.to_sym

          available_macros[name] = {:desc => @@desc || ''}.merge(options)

          @@desc = nil

          Definitions.send :define_method, "macro_#{name}", &block

        end

        # Sets description for the next macro to be defined

        def desc(txt)

          @@desc = txt

        end

      end

      # Builtin macros

      desc "Sample macro."

      macro :hello_world do |obj, args, text|

        h("Hello world! Object: #{obj.class.name}, " + 

          (args.empty? ? "Called with no argument" : "Arguments: #{args.join(', ')}") +

          " and " + (text.present? ? "a #{text.size} bytes long block of text." : "no block of text.")

        )

      end

      desc "Displays a list of all available macros, including description if available."

      macro :macro_list do |obj, args|

        out = ''.html_safe

        @@available_macros.each do |macro, options|

          out << content_tag('dt', content_tag('code', macro.to_s))

          out << content_tag('dd', textilizable(options[:desc]))

        end

        content_tag('dl', out)

      end

      desc "Displays a list of child pages. With no argument, it displays the child pages of the current wiki page. Examples:\n\n" +

             "  !{{child_pages}} -- can be used from a wiki page only\n" +

             "  !{{child_pages(depth=2)}} -- display 2 levels nesting only\n"

             "  !{{child_pages(Foo)}} -- lists all children of page Foo\n" +

             "  !{{child_pages(Foo, parent=1)}} -- same as above with a link to page Foo"

      macro :child_pages do |obj, args|

        args, options = extract_macro_options(args, :parent, :depth)

        options[:depth] = options[:depth].to_i if options[:depth].present?

        page = nil

        if args.size > 0

          page = Wiki.find_page(args.first.to_s, :project => @project)

        elsif obj.is_a?(WikiContent) || obj.is_a?(WikiContent::Version)

          page = obj.page

        else

          raise 'With no argument, this macro can be called from wiki pages only.'

        end

        raise 'Page not found' if page.nil? || !User.current.allowed_to?(:view_wiki_pages, page.wiki.project)

        pages = page.self_and_descendants(options[:depth]).group_by(&:parent_id)

        render_page_hierarchy(pages, options[:parent] ? page.parent_id : page.id)

      end

      desc "Include a wiki page. Example:\n\n  !{{include(Foo)}}\n\nor to include a page of a specific project wiki:\n\n  !{{include(projectname:Foo)}}"

      macro :include do |obj, args|

        page = Wiki.find_page(args.first.to_s, :project => @project)

        raise 'Page not found' if page.nil? || !User.current.allowed_to?(:view_wiki_pages, page.wiki.project)

        @included_wiki_pages ||= []

        raise 'Circular inclusion detected' if @included_wiki_pages.include?(page.title)

        @included_wiki_pages << page.title

        out = textilizable(page.content, :text, :attachments => page.attachments, :headings => false)

        @included_wiki_pages.pop

        out

      end

      desc "Inserts of collapsed block of text. Example:\n\n  {{collapse(View details...)\nThis is a block of text that is collapsed by default.\nIt can be expanded by clicking a link.\n}}"

      macro :collapse do |obj, args, text|

        html_id = "collapse-#{Redmine::Utils.random_hex(4)}"

        show_label = args[0] || l(:button_show)

        hide_label = args[1] || args[0] || l(:button_hide)

        js = "$('##{html_id}-show, ##{html_id}-hide').toggle(); $('##{html_id}').fadeToggle(150);"

        out = ''.html_safe

        out << link_to_function(show_label, js, :id => "#{html_id}-show", :class => 'collapsible collapsed')

        out << link_to_function(hide_label, js, :id => "#{html_id}-hide", :class => 'collapsible', :style => 'display:none;')

        out << content_tag('div', textilizable(text, :object => obj), :id => html_id, :class => 'collapsed-text', :style => 'display:none;')

        out

      end

      desc "Displays a clickable thumbnail of an attached image. Examples:\n\n<pre>{{thumbnail(image.png)}}\n{{thumbnail(image.png, size=300, title=Thumbnail)}}</pre>"

      macro :thumbnail do |obj, args|

        args, options = extract_macro_options(args, :size, :title)

        filename = args.first

        raise 'Filename required' unless filename.present?

        size = options[:size]

        raise 'Invalid size parameter' unless size.nil? || size.match(/^\d+$/)

        size = size.to_i

        size = nil unless size > 0

        if obj && obj.respond_to?(:attachments) && attachment = Attachment.latest_attach(obj.attachments, filename)

          title = options[:title] || attachment.title

          img = image_tag(url_for(:controller => 'attachments', :action => 'thumbnail', :id => attachment, :size => size), :alt => attachment.filename)

          link_to(img, url_for(:controller => 'attachments', :action => 'show', :id => attachment), :class => 'thumbnail', :title => title)

        else

          raise "Attachment #{filename} not found"

        end

      end

    end

  end

end