Redmine

    @workspaces = Hash[Workspace.pluck(:id, :name)]

    @workspaces = Workspace.sorted

    @workflow_counts = WorkflowTransition.group(:tracker_id, :role_id, :workspace_id).count

    if request.post? && @roles && @trackers && @workspaces && params[:transitions]

      WorkflowTransition.replace_transitions(@trackers, @roles, transitions, @workspaces)

    if @trackers && @roles && @workspaces && @statuses.any?

        where(:role_id => @roles.map(&:id), :tracker_id => @trackers.map(&:id), :workspace_id => @workspaces.map(&:id)).

    if request.post? && @roles && @trackers && @workspaces && params[:permissions]

      WorkflowPermission.replace_permissions(@trackers, @roles, permissions, @workspaces)

    if @roles && @trackers && @workspaces

      @permissions = WorkflowPermission.rules_by_status_id(@trackers, @roles, @workspaces)

    @workspaces = Workspace.sorted

    if params[:source_workspace_id].blank? || params[:source_workspace_id] == 'any'

      @source_workspace = nil

    else

      @source_workspace = Workspace.find_by_id(params[:source_workspace_id].to_i)

    end

    @target_workspaces = params[:target_workspace_ids].blank? ?

        nil : Workspace.where(:id => params[:target_workspace_ids]).to_a

      if params[:source_tracker_id].blank? || params[:source_role_id].blank? || params[:source_workspace_id].blank? || (@source_tracker.nil? && @source_role.nil? && @source_workspace.nil?)

      elsif @target_trackers.blank? || @target_roles.blank? || @target_workspaces.blank?

        WorkflowRule.copy(@source_tracker, @source_role, @source_workspace, @target_trackers, @target_roles, @target_workspaces)

        redirect_to workflows_copy_path(:source_tracker_id => @source_tracker, :source_role_id => @source_role, :source_workspace_id => @source_workspace)

    find_workspaces

  def find_workspaces

    ids = Array.wrap(params[:workspace_id])

    if ids == ['all']

      @workspaces = Workspace.sorted.to_a

    elsif ids.present?

      @workspaces = Workspace.where(:id => ids).to_a

    end

    @workspaces = nil if @workspaces.blank?

  end

# Redmine - project management software

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

#

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

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

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

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

#

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

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

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

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

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

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

class WorkspacesController < ApplicationController

  layout 'admin'

  before_filter :require_admin, :except => :index

  before_filter :require_admin_or_api_request, :only => :index

  accept_api_auth :index

  def index

    respond_to do |format|

      format.html {

        @workspace_pages, @workspaces = paginate Workspace.sorted, :per_page => 25

        render :action => "index", :layout => false if request.xhr?

      }

      format.api {

        @workspaces = Workspace.order('position').to_a

      }

    end

  end

  def new

    @workspace = Workspace.new

  end

  def create

    @workspace = Workspace.new(params[:workspace])

    if @workspace.save

      flash[:notice] = l(:notice_successful_create)

      redirect_to workspaces_path

    else

      render :action => 'new'

    end

  end

  def edit

    @workspace = Workspace.find(params[:id])

  end

  def update

    @workspace = Workspace.find(params[:id])

    if @workspace.update_attributes(params[:workspace])

      flash[:notice] = l(:notice_successful_update)

      redirect_to workspaces_path(:page => params[:page])

    else

      render :action => 'edit'

    end

  end

  def destroy

    unless Project.where(:workspace_id => params[:id]).any? || params[:id] == "1"

      Workspace.find(params[:id]).destroy

      redirect_to workspaces_path

    else

      flash[:error] = l(:error_unable_delete_workspace)

      redirect_to workspaces_path

    end

  end

end

  def project_workspace_options(project)

    grouped = Hash.new {|h,k| h[k] = []}

    Workspace.all.sorted.each do |workspace|

      grouped[workspace.name] = workspace.id

    end

    options_for_select(grouped, project.workspace_id)

  end

  def used_workspaces_by_tracker(tracker)

    WorkflowTransition.where(:tracker_id => tracker).map{|t| "ws-" + t.workspace_id.to_s}.uniq.join(" ")

  end

      if perm.uniq.size > 1 || perm.size < @roles.size * @trackers.size * @workspaces.size

    if w == 0 || w == @roles.size * @trackers.size * @workspaces.size

    workspace = Project.where(:id => project).pluck(:workspace_id)

    workflow_permissions = WorkflowPermission.where(:tracker_id => tracker_id, :old_status_id => status_id, :role_id => roles.map(&:id), :workspace_id => workspace).to_a

        project.workspace_id,

  def new_statuses_allowed_to(roles, tracker, workspace_id, author=false, assignee=false)

    self.class.new_statuses_allowed(self, roles, tracker, workspace_id, author, assignee)

  def self.new_statuses_allowed(status, roles, tracker, workspace_id, author=false, assignee=false)

    if roles.present? && tracker && workspace_id

        where(:workflows => {:old_status_id => status_id, :role_id => roles.map(&:id), :tracker_id => tracker.id, :workspace_id => workspace_id})

  belongs_to :workspace

    'default_version_id',

    'workspace_id'

      WorkflowRule.copy(nil, source_role, nil, nil, proxy_association.owner, nil)

      WorkflowRule.copy(source_tracker, nil, nil, proxy_association.owner, nil, nil)

  # Returns the workflow permissions for the given trackers, roles and workspaces

  #   WorkflowPermission.rules_by_status_id trackers, roles, workspaces

  def self.rules_by_status_id(trackers, roles, workspaces)

    WorkflowPermission.where(:tracker_id => trackers.map(&:id), :role_id => roles.map(&:id), :workspace_id => workspaces.map(&:id)).inject({}) do |h, w|

  # Replaces the workflow permissions for the given trackers, roles and workspaces

  #   WorkflowPermission.replace_permissions trackers, roles, {'1' => {'start_date' => 'required', 'due_date' => 'readonly'}}, workspaces

  def self.replace_permissions(trackers, roles, permissions, workspaces)

    workspaces = Array.wrap workspaces

          destroy_all(:tracker_id => trackers.map(&:id), :role_id => roles.map(&:id), :old_status_id => status_id, :field_name => field, :workspace_id => workspaces.map(&:id))

                workspaces.each do |workspace|

                  WorkflowPermission.create(:role_id => role.id, :tracker_id => tracker.id, :old_status_id => status_id, :field_name => field, :rule => rule, :workspace_id => workspace.id)

                end

  belongs_to :workspace

  validates_presence_of :role, :tracker, :workspace

  def self.copy(source_tracker, source_role, source_workspace, target_trackers, target_roles, target_workspaces)

    unless source_tracker.is_a?(Tracker) || source_role.is_a?(Role) || source_workspace.is_a?(Workspace)

      raise ArgumentError.new("source_tracker, source_role or source_workspace must be specified")

    target_workspaces = [target_workspaces].flatten.compact

    target_workspaces = Workspace.sorted.to_a if target_workspaces.empty?

        target_workspaces.each do |target_workspace|

          copy_one(source_tracker || target_tracker,

                     source_role || target_role,

                     source_workspace || target_workspace,

                     target_tracker,

                     target_role,

                     target_workspace)

        end

  def self.copy_one(source_tracker, source_role, source_workspace, target_tracker, target_role, target_workspace)

      source_workspace.is_a?(Workspace) && !source_workspace.new_record? &&

      target_workspace.is_a?(Workspace) && !target_workspace.new_record?

    if source_tracker == target_tracker && source_role == target_role && source_workspace == target_workspace

        delete_all :tracker_id => target_tracker.id, :role_id => target_role.id, :workspace_id => target_workspace.id

        connection.insert "INSERT INTO #{WorkflowRule.table_name} (tracker_id, role_id, old_status_id, new_status_id, author, assignee, field_name, #{connection.quote_column_name 'rule'}, type, workspace_id)" +

                          " SELECT #{target_tracker.id}, #{target_role.id}, old_status_id, new_status_id, author, assignee, field_name, #{connection.quote_column_name 'rule'}, type, #{target_workspace.id}" +

                          " WHERE tracker_id = #{source_tracker.id} AND role_id = #{source_role.id} AND workspace_id = #{source_workspace.id}"

  def self.replace_transitions(trackers, roles, transitions, workspaces)

    workspaces = Array.wrap workspaces

      records = WorkflowTransition.where(:tracker_id => trackers.map(&:id), :role_id => roles.map(&:id), :workspace_id => workspaces.map(&:id)).to_a

                workspaces.each do |workspace|

                  w = records.select {|r|

                    r.old_status_id == old_status_id.to_i &&

                    r.new_status_id == new_status_id.to_i &&

                    r.tracker_id == tracker.id &&

                    r.role_id == role.id &&

                    r.workspace_id == workspace.id &&

                    !r.destroyed?

                  }

                    w = w.select {|r| !r.author && !r.assignee}

                  else

                    w = w.select {|r| r.author || r.assignee}

                  end

                  if w.size > 1

                    w[1..-1].each(&:destroy)

                  end

                  w = w.first

                  if transition == "1" || transition == true

                    unless w

                      w = WorkflowTransition.new(:old_status_id => old_status_id, :new_status_id => new_status_id, :tracker_id => tracker.id, :role_id => role.id, :workspace_id => workspace.id)

                      records << w

                    w.author = true if rule == "author"

                    w.assignee = true if rule == "assignee"

                    w.save if w.changed?

                  elsif w

                    if rule == 'always'

                    elsif rule == 'author'

                      if w.assignee

                        w.author = false

                        w.save if w.changed?

                      else

                        w.destroy

                      end

                    elsif rule == 'assignee'

                      if w.author

                        w.assignee = false

                        w.save if w.changed?

                      else

                        w.destroy

                      end

# Redmine - project management software

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

#

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

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

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

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

#

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

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

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

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

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

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

class Workspace < ActiveRecord::Base

  before_destroy :check_integrity

  has_many :projects

  has_many :workflow_rules, :dependent => :delete_all do

    def copy(source_workflow)

      WorkflowRule.copy(nil, nil, source_tracker, nil, nil, proxy_association.owner)

    end

  end

  acts_as_list

  validates_presence_of :name

  validates_uniqueness_of :name

  validates_length_of :name, :maximum => 30

  attr_protected :id

  scope :sorted, lambda { order(:position) }

  scope :named, lambda {|arg| where("LOWER(#{table_name}.name) = LOWER(?)", arg.to_s.strip)}

  # Returns an array of IssueStatus that are used

  # in the tracker's workflows

  def issue_statuses

    if @issue_statuses

      return @issue_statuses

    elsif new_record?

      return []

    end

    ids = WorkflowTransition.

      connection.select_rows("SELECT DISTINCT old_status_id, new_status_id FROM #{WorkflowTransition.table_name} WHERE workspace_id = #{id} AND type = 'WorkflowTransition'").

      flatten.

      uniq

    @issue_statuses = IssueStatus.where(:id => ids).all.sort

  end

  def <=>(status)

    position <=> status.position

  end

  def to_s; name end

private

  def check_integrity

    raise Exception.new("Cannot delete workspace") if Project.where(:workspace_id => self.id).any?

  end

end

  <th><%=l(:field_workspace)%></th>

  <td><%= @workspaces[project.workspace_id] %></td>

  <legend><%= l(:label_role_plural) %> (<a onclick='$(".unused").toggleClass("show");'><%= l(:label_all) %></a>) <%= toggle_checkboxes_link('.roles-selection input') %></legend>

      <label<%= " class=unused" unless WorkflowTransition.where(:role_id => role.id, :workspace_id => @project.workspace_id).any? || ! role.assignable %>><%= check_box_tag 'membership[role_ids][]', role.id, false, :id => nil %> <%= role %></label>

<% if @project.safe_attribute? 'workspace_id' %>

<p><%= f.select :workspace_id, project_workspace_options(@project), {}, {:onChange=>"displaytrackers(this);"} %></p>

<% end %>

<fieldset class="box tabular" id="project_trackers"><legend><%=l(:label_tracker_plural)%> (<a onclick="$('#project_trackers').toggleClass('showall'); displaytrackers(document.getElementById('project_workspace_id'));"><%= l(:label_all) %></a>)</legend>

    <label class="floating <%= used_workspaces_by_tracker(tracker.id) %>">

<script>

  function displaytrackers(sel) {

    $('#project_trackers').children('label').each( function() {

      if ($(this).hasClass('ws-' + sel.value) || $('#project_trackers').hasClass('showall'))

      {

        $(this).show();

      } else {

        $(this).hide();

      }

    });

  };

  displaytrackers(document.getElementById('project_workspace_id'));

</script>

      <th><%= l(:label_role_plural) %> (<a onclick='$(".unused").toggle();'><%= l(:label_all) %></a>)</th>

          <div<%= " class=unused" unless WorkflowTransition.where(:role_id => role.id, :workspace_id => @project.workspace_id).any? || ! role.assignable %>> 

            <label>

              <%= check_box_tag('membership[role_ids][]',

                                role.id, member.roles.include?(role),

                                :id => nil,

                                :disabled => !member.role_editable?(role)) %> <%= role %>

            </label><br />

          </div>

<p>

  <label><%= l(:label_workspace) %></label>

  <%= select_tag('source_workspace_id',

                  content_tag('option', "--- #{l(:actionview_instancetag_blank_option)} ---", :value => '') +

                  content_tag('option', "--- #{ l(:label_copy_same_as_target) } ---", :value => 'any') +

                  options_from_collection_for_select(@workspaces, 'id', 'name', @source_workspace && @source_workspace.id)) %>

</p>

<p>

  <label><%= l(:label_workspace) %></label>

  <%= select_tag 'target_workspace_ids',

                  content_tag('option', "--- #{l(:actionview_instancetag_blank_option)} ---", :value => '', :disabled => true) +

                  options_from_collection_for_select(@workspaces, 'id', 'name', @target_workspaces && @target_workspaces.map(&:id)), :multiple => true %>

</p>

    <li><%= link_to l(:label_status_transitions), workflows_edit_path(:role_id => @roles, :tracker_id => @trackers, :workspace_id => @workspaces), :class => 'selected' %></li>

    <li><%= link_to l(:label_fields_permissions), workflows_permissions_path(:role_id => @roles, :tracker_id => @trackers, :workspace_id => @workspaces) %></li>

  <label><%=l(:label_workspace)%>:

  <%= options_for_workflow_select 'workspace_id[]', Workspace.sorted, @workspaces, :id => 'workspace_id', :class => 'expandable' %>

  </label>

  <a href="#" data-expands="#workspace_id"><span class="toggle-multiselect"></span></a>

<% if @trackers && @roles && @workspaces && @statuses.any? %>

    <%= @workspaces.map {|workspace| hidden_field_tag 'workspace_id[]', workspace.id, :id => nil}.join.html_safe %>

<p><label><%=l(:label_workspace)%>:

<%= options_for_workflow_select 'workspace_id[]', Workspace.sorted, @workspaces, :id => 'workspace_id', :class => 'expandable', :onchange=>'refresh_table(this.value);' %>

</label></p>

      <% countall = 0 %>

      <% @workspaces.each do |workspace| %>

        <% count = @workflow_counts[[tracker.id, role.id, workspace.id]] || 0 %>

        <% countall += count %>

        <span class="ws ws<%= workspace.id%>" style="display: none;">

          <%= link_to((count > 0 ? count : content_tag(:span, nil, :class => 'icon-only icon-not-ok')),

                  {:action => 'edit', :role_id => role, :tracker_id => tracker, :workspace_id => workspace},

        </span>

      <% end %>

      <span class="ws wsall" style="display: none;">

        <%= link_to((countall > 0 ? countall : content_tag(:span, nil, :class => 'icon-only icon-not-ok')),

                    {:action => 'edit', :role_id => role, :tracker_id => tracker, :workspace_id => 'all'},

                    :title => l(:button_edit)) %>

      </span>

<script>

  function refresh_table(value) {

    $('.ws').css("display","none");

    $('.ws' + value).css("display","inline");

  }

  refresh_table(document.getElementById('workspace_id').value);

</script>

    <li><%= link_to l(:label_status_transitions), workflows_edit_path(:role_id => @roles, :tracker_id => @trackers, :workspace_id => @workspaces) %></li>

    <li><%= link_to l(:label_fields_permissions), workflows_permissions_path(:role_id => @roles, :tracker_id => @trackers, :workspace_id => @workspaces), :class => 'selected' %></li>

  <label><%=l(:label_workspace)%>:

  <%= options_for_workflow_select 'workspace_id[]', Workspace.sorted, @workspaces, :id => 'workspace_id', :class => 'expandable' %>

  </label>

  <a href="#" data-expands="#workspace_id"><%= image_tag 'bullet_toggle_plus.png' %></a>

<% if @trackers && @roles && @workspaces && @statuses.any? %>

    <%= @workspaces.map {|workspace| hidden_field_tag 'workspace_id[]', workspace.id, :id => nil}.join.html_safe %>

<%= error_messages_for 'workspace' %>

<div class="box tabular">

<p><%= f.text_field :name, :required => true %></p>

<p><%= f.text_field :description %></p>

<%= call_hook(:view_workspaces_form, :workspace => @workspace) %>

</div>

<%= title [l(:label_workspace_plural), workspaces_path], @workspace.name %>

<%= labelled_form_for @workspace do |f| %>

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

  <%= submit_tag l(:button_save) %>

<% end %>

api.array :workspaces do

  @workspaces.each do |workspace|

    api.workspace do

      api.id status.id

      api.name status.name

      api.description status.description

    end

  end

end

<div class="contextual">

<%= link_to l(:label_workspace_new), new_workspace_path, :class => 'icon icon-add' %>

</div>

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

<table class="list">

  <thead><tr>

  <th><%=l(:field_name)%></th>

  <th><%=l(:field_description)%></th>

  <th><%=l(:button_sort)%></th>

  <th></th>

  </tr></thead>

  <tbody>

<% for status in @workspaces %>

  <tr class="<%= cycle("odd", "even") %>">

  <td class="name"><%= link_to status.name, edit_workspace_path(status) %></td>

  <td class="description"><%= link_to status.description, edit_workspace_path(status) %></td>

  <td class="reorder"><%= reorder_links('workspace', {:action => 'update', :id => status, :page => params[:page]}, :put) %></td>

  <td class="buttons">

    <%= delete_link workspace_path(status) unless status.id == 1 %>

  </td>

  </tr>

<% end %>

  </tbody>

</table>

<span class="pagination"><%= pagination_links_full @workspace_pages %></span>

<% html_title(l(:label_workspace_plural)) -%>

<%= title [l(:label_workspace_plural), workspaces_path], l(:label_workspace_new) %>

<%= labelled_form_for @workspace do |f| %>

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

  <%= submit_tag l(:button_create) %>

<% end %>

  label_workspace: Workspace

  label_workspace_plural: Workspaces

  label_workspace_new: New workspace

  error_unable_delete_workspace: Unable to delete workspace

  field_workspace: Workspace

  label_workspace: Espaço de trabalho

  label_workspace_plural: Espaços de trabalho

  label_workspace_new: Novo espaço de trabalho

  error_unable_delete_workspace: Não foi possível excluir espaço de trabalho

  field_workspace: Espaço de trabalho

  resources :workspaces, :except => :show

class AddWorkspaceToProjects < ActiveRecord::Migration

  def self.up

    unless ActiveRecord::Base.connection.column_exists?(:projects, :workspace_id)

      add_column :projects, :workspace_id, :integer, :default => 1

    end

  end

end

class AddWorkspaceToWorkflows < ActiveRecord::Migration

  def self.up

    unless ActiveRecord::Base.connection.column_exists?(:workflows, :workspace_id)

      add_column :workflows, :workspace_id, :integer, :default => 1

    end

  end

end

class CreateWorkspaces < ActiveRecord::Migration

  class Workspace < ActiveRecord::Base; end

  def self.up

    unless ActiveRecord::Base.connection.table_exists?('workspaces')

      create_table :workspaces do |t|

        t.string :name

        t.string :description

        t.integer :position

      end

      # create default workspace

      workspace = Workspace.new :name => "Default",

                                :description => "Default workspace",

                                :position => "1"

      workspace.save

    end

  end

end

class FixWorkspacesAllowNullPosition < ActiveRecord::Migration

  def self.up

    # removes the 'not null' constraint on position fields

    change_column :workspaces, :position, :integer, :default => 1, :null => true

  end

  def self.down

    # nothing to do

  end

end

  menu.push :workspaces, {:controller => 'workspaces'}, :caption => :label_workspace_plural

#admin-menu a.workspaces { background-image: url(../images/table_multiple.png); }

.roles-selection .unused {display:none;}

.roles-selection .unused.show {display:inline-block;}

.unused {display:none;}