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-2017  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'

  self.main_menu = false

  before_action :require_admin, :except => :index

  before_action :require_admin_or_api_request, :only => :index

  accept_api_auth :index

  def index

    @workspaces = Workspace.sorted.to_a

    respond_to do |format|

      format.html { render :layout => false if request.xhr? }

      format.api

    end

  end

  def new

    @workspace = Workspace.new

  end

  def create

    @workspace = Workspace.new

    @workspace.safe_attributes = 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])

    @workspace.safe_attributes = params[:workspace]

    if @workspace.save

      respond_to do |format|

        format.html {

          flash[:notice] = l(:notice_successful_update)

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

        }

        format.js { head 200 }

      end

    else

      respond_to do |format|

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

        format.js { head 422 }

      end

    end

  end

  def destroy

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

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

    else

      flash[:error] = l(:error_unable_delete_workspace)

    end

    redirect_to workspaces_path

  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

    if selected

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

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

    workflow_permissions = WorkflowPermission.where(:tracker_id => tracker_id, :old_status_id => status_id, :role_id => roles.map(&:id), :workspace_id => project.workspace_id).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

    'workspace_id',

    WorkflowRule.copy(nil, source_role, nil, nil, self, nil)

    WorkflowRule.copy(source_tracker, nil, nil, self, 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

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

                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, given: #{source_tracker.class.name}, #{source_role.class.name} and #{source_workspace.class.name}")

    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_role.is_a?(Role) && !target_role.new_record? &&

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

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

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

        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-2017  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

  include Redmine::SafeAttributes

  before_destroy :check_integrity

  has_many :projects

  has_many :workflow_rules, :dependent => :delete_all

  acts_as_positioned

  validates_presence_of :name

  validates_uniqueness_of :name

  validates_length_of :name, :maximum => 30

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

  safe_attributes 'name',

    'description',

    'position'

  def <=>(workspace)

    position <=> workspace.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>

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

<p><%= f.select :workspace_id, project_workspace_options(@project) %></p>

<% end %>

<p>

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

  <%= select_tag('source_role_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(@roles, 'id', 'name', @source_role && @source_role.id)) %>

</p>

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

  <%= select_tag('source_workspace_id',

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

<p>

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

  <%= select_tag 'target_role_ids',

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

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

</p>

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

  <%= select_tag 'target_workspace_ids',

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

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

    <li><%= link_to l(:label_fields_permissions), workflows_permissions_path(:role_id => @roles, :tracker_id => @trackers, :workspace_id => @workspaces, :used_statuses_only => @used_statuses_only ? 1 : 0) %></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>

<table class="list collapsed">

    <th onclick='expand_table();'><i><span class='tip_exp_off'><%= l(:button_expand_all) %></span><span class='tip_exp_on'><%= l(:button_collapse_all) %></span></i></th>

      <% 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},

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

        </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");

      collapse_table();

    }

    function expand_table() {

      $('table').toggleClass("collapsed");

      collapse_table();

    }

    function collapse_table() {

      i = $('#workspace_id').val();

      var x = !$('table').hasClass("collapsed");

      if (x) {

        $('.tip_exp_on').css("display", "");

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

      } else {

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

        $('.tip_exp_off').css("display", "");

      }

      $('th, td, tr').toggle(true);

      for (var j = 2; j <= $('thead > tr > th').length; j++) {

        if ($('tbody > tr > td:nth-child(' + j + ') > span:visible > a:not(:has(span))').length == 0) {

          $('tbody > tr > td:nth-child(' + j + ')').toggle(x);

          $('thead > tr > th:nth-child(' + j + ')').toggle(x);

        }

      }

      for (var j = 1; j <= $('tbody > tr').length; j++) {

        if ($('tbody > tr:nth-child(' + j + ') > td > span:visible > a:not(:has(span))').length == 0) {

          $('tbody > tr:nth-child(' + j + ')').toggle(x);

        }

      }

    }

    refresh_table($('#workspace_id').val());

  </script>

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

    <li><%= link_to l(:label_fields_permissions), workflows_permissions_path(:role_id => @roles, :tracker_id => @trackers, :workspace_id => @workspaces, :used_statuses_only => @used_statuses_only ? 1 : 0), :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"><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 %>

<%= 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 workspaces">

  <thead><tr>

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

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

  <th></th>

  </tr></thead>

  <tbody>

<% for workspace in @workspaces %>

  <tr class="<%= workspace.id == 1 ? "builtin" : "givable" %>">

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

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

  <td class="buttons">

    <%= reorder_handle(workspace) unless workspace.id == 1 %>

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

  </td>

  </tr>

<% end %>

  </tbody>

</table>

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

<%= javascript_tag do %>

  $(function() { $("table.workspaces tbody").positionedItems({items: ".givable"}); });

<% end %>

<%= 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[4.2]

  def self.up

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

  end

  def self.down

    remove_column :projects, :workspace_id

  end

end

class AddWorkspaceToWorkflows < ActiveRecord::Migration[4.2]

  def self.up

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

  end

  def self.down

    remove_column :workflows, :workspace_id

  end

end

class CreateWorkspaces < ActiveRecord::Migration[4.2]

  def self.up

    create_table :workspaces do |t|

      t.string :name

      t.string :description

      t.integer :position, :default => nil, :null => true

    end

    # create default workspace

    unless Workspace.exists?(1)

      Workspace.create(:name => "Default", :description => "Default workspace", :position => 1)

    end

  end

  def self.down

    drop_table :workspaces

  end

end

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

            :html => {:class => 'icon icon-multiple'}

span.tip_exp_on {font-weight:bold; position:relative; color:#fff; background:#9DB9D5; padding:0px 6px 1px 6px; border-radius:3px; margin-left:4px;}

span.tip_exp_off {font-weight:bold; position:relative; color:#fff; background:#9DB9D5; padding:0px 6px 1px 6px; border-radius:3px; margin-left:4px;}