Redmine

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

    @workspaces = Workspace.sorted

    @workspace = Workspace.find_by_id(params[:workspace_id]) || Workspace.first

    @roles = Role.where(id: WorkflowTransition.where(workspace_id: @workspace.id).pluck(:role_id)).sorted.select(&:consider_workflow?)

    @trackers = Tracker.where(id: WorkflowTransition.where(workspace_id: @workspace.id).pluck(:tracker_id)).sorted

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

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

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

    if @roles && @trackers && @workspaces && params[:transitions]

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

    if @roles && @trackers && @workspaces

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

    if @roles && @trackers && @workspaces && params[:permissions]

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

    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)

        :source_role_id => @source_role,

        :source_workspace_id => @source_workspace

    @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 =

      if params[:target_workspace_ids].blank?

        nil

      else

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

      end

    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

    @used_workspaces_only = (params[:used_workspaces_only] == '0' ? false : true)

    if @used_statuses_only || @used_workspaces_only

      status_ids = WorkflowRule.where(:role_id => role_ids).where('old_status_id <> new_status_id')

      status_ids = status_ids.where(:tracker_id => @trackers.map(&:id)) if @trackers && @used_statuses_only

      status_ids = status_ids.where(:workspace_id => @workspaces.map(&:id)) if @workspaces && @used_workspaces_only

      status_ids = status_ids.distinct.pluck(:old_status_id, :new_status_id).flatten.uniq

      @statuses = IssueStatus.where(:id => status_ids).sorted.to_a

    else

      @statuses = IssueStatus.sorted.to_a

# 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 role_color_and_hide(role, project = nil)

    color_and_hide = ""

    if ! role.assignable

      color_and_hide += " style=color:darkblue"

    elsif ! project.nil? && ! role.workflow_rules.where(:workspace_id => project.workspace_id).any?

      color_and_hide += " class=unused style=color:darkred"

    end

    color_and_hide

  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

    WorkflowRule.pluck(:tracker_id, :workspace_id).uniq.group_by(&:first).map{|k,a| [k,a.map{|x| "ws-" + x.last.to_s}.join(" ")]}.to_h

  end

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

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

        :role_id => roles.map(&:id),

        :workspace_id => project&.workspace_id

      project.workspace_id,

    ) if project.present?

  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

    @rolled_up_workspaces = nil

  def rolled_up_workspaces(include_subprojects=true)

    if include_subprojects

      @rolled_up_workspaces ||= rolled_up_workspaces_base_scope.

      where("#{Project.table_name}.lft >= ? AND #{Project.table_name}.rgt <= ?", lft, rgt)

    else

      rolled_up_workspaces_base_scope.

      where(:projects => {:id => id})

    end

  end

  def rolled_up_workspaces_base_scope

    Workspace.

    joins(projects: :enabled_modules).

    where("#{Project.table_name}.status <> ?", STATUS_ARCHIVED).

    where(:enabled_modules => {:name => 'issue_tracking'}).

    distinct.

    sorted

  end

      where(:workspace_id => rolled_up_workspaces.map(&:id)).

    'workspace_id',

    QueryColumn.new(:created_on, :sortable => "#{Project.table_name}.created_on", :default_order => 'desc'),

    QueryColumn.new(:workspace, :sortable => "#{Project.table_name}.workspace")

    add_available_filter "workspace_id",

      :type => :list,

      :values => Workspace.where.not(id: 1).order(:name).map {|w| [w.name, w.id.to_s]}.

        unshift([Workspace.find(1).name, Workspace.find(1).id.to_s])

    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)

        "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

             " author, assignee, field_name, #{connection.quote_column_name 'rule'}, type, workspace_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 do |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 ["1", true].include?(transition)

                    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'

  # 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.where(workspace_id: id).map{|w| [w.old_status_id, w.new_status_id]}.flatten.uniq

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

  end

  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

    <strong>

      <%= l(:label_role_plural) %>

      (<a onclick="$(this).closest('form').children('div.unused').toggle();"><%= l(:label_all) %></a>):

    </strong>

  </p>

  <% @roles.each do |role| %>

    <div<%= role_color_and_hide(role, @project) %>>

    </div>

  <% end %>

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

      <label<%= role_color_and_hide(role, @project) %>><%= check_box_tag 'membership[role_ids][]', role.id, false, :id => nil %><%= role %></label>

    <strong>

      <%= l(:label_role_plural) %>

      (<a onclick="$(this).closest('form').children('div.unused').toggle();"><%= l(:label_all) %></a>):

    </strong>

  </p>

    <div<%= role_color_and_hide(role, @membership.project) %>>

    </div>

    <label<%= role_color_and_hide(role) %>>

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

<p><%= f.select :workspace_id, project_workspace_options(@project), {}, :onchange => "$('#project_trackers > label').hide(); $('#project_trackers > label.ws-' + this.value).show();" %></p>

<% end %>

      api.workspace   project.workspace.id

  <fieldset class="box tabular" id="project_trackers"><legend><%= toggle_checkboxes_link('#project_trackers input[type=checkbox]:enabled:visible') %><%= l(:label_tracker_plural)%> (<a onclick="ws='.ws-' + $('#project_workspace_id').val(); $('#project_trackers > label' + ws).show(); $('#project_trackers > label:not(' + ws + ')').toggle();"><%= l(:label_all) %></a>)</legend>

  <% uwbt=used_workspaces_by_tracker %>

    <label class="floating <%= uwbt[tracker.id].to_s %>"<% unless uwbt[tracker.id].to_s.match(/\b#{@project.workspace_id}\b/) %>style="display: none;"<% end %>>

  api.workspace(:id => @project.workspace.id, :name => @project.workspace.name) if User.current.admin?

  <% if User.current.admin? %>

    <li><span class="label"><%=l(:field_workspace)%>:</span> <%= @project.workspace.name %></li>

  <% end %>

<div class="autoscroll">

  <table class="list">

    <thead>

      <tr>

        <th>

        </th>

        <% @roles.each do |role| %>

          <% next unless @workflow_counts.select{|i,v| i[1]==role.id && i[2]==@workspace.id}.present? %>

          <th>

            <%= content_tag(role.builtin? ? 'em' : 'span', role.name) %>

          </th>

        <% end %>

      </tr>

    </thead>

    <tbody>

      <% @trackers.each do |tracker| -%>

      <% next unless @workflow_counts.select{|i,v| i[0]==tracker.id && i[2]==@workspace.id}.present? %>

        <tr>

          <td class="name"><%= tracker.name %></td>

          <% @roles.each do |role| -%>

          <% next unless @workflow_counts.select{|i,v| i[1]==role.id && i[2]==@workspace.id}.present? %>

            <td>

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

              <%= 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)) %>

            </td>

          <% end -%>

        </tr>

      <% end -%>

    </tbody>

  </table>

</div>

<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), edit_workflows_path(:role_id => @roles, :tracker_id => @trackers, :workspace_id => @workspaces), :class => 'selected' %></li>

    <li><%= link_to l(:label_fields_permissions), permissions_workflows_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' %>

  <span class="toggle-multiselect icon-only"></span>

  </label>

  <%= hidden_field_tag 'used_workspaces_only', '0', :id => nil %>

  <label><%= check_box_tag 'used_workspaces_only', '1', @used_workspaces_only %> <%= l(:label_display_used_workspaces_only) %></label>

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

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

    <%= hidden_field_tag 'used_workspaces_only', params[:used_workspaces_only], :id => nil %>

<% end %>

  <p class="nodata"><%= l(:label_no_data) %></p>

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

    <select id="workspace_id" class="expandable" onchange="location.href=location.href.split('?')[0] + '?workspace_id=' + this.options[this.selectedIndex].value;">

      <%= options_for_select(@workspaces.pluck(:name, :id), @workspace.id) %>

    </select>

  </label></p>

  <div class="autoscroll ws">

    <%= render :partial => 'index_table' %>

  </div>

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

    <li><%= link_to l(:label_fields_permissions), permissions_workflows_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' %>

  <span class="toggle-multiselect icon-only"></span>

  </label>

  <%= hidden_field_tag 'used_workspaces_only', '0', :id => nil %>

  <label><%= check_box_tag 'used_workspaces_only', '1', @used_workspaces_only %> <%= l(:label_display_used_workspaces_only) %></label>

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

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

    <%= hidden_field_tag 'used_workspaces_only', params[:used_workspaces_only], :id => nil %>

<%= 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          workspace.id

      api.name        workspace.name

      api.description workspace.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_display_used_workspaces_only: Only display statuses that are used by this 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

  label_display_used_workspaces_only: Somente situações deste espaço de trabalho

  resources :workspaces, :except => :show

    - workspace

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)