Merge branch 'feature/users_groups' into 6-0-dev

app/assets/javascripts/dispatcher.js.coffee

@@ -32,6 +32,8 @@ class Dispatcher
         new Wall(project_id)
       when 'teams:members:index'
         new TeamMembers()
+      when 'groups:people'
+        new GroupMembers()
 
     switch path.first()
       when 'admin' then new Admin()

app/assets/javascripts/groups.js.coffee

@@ -0,0 +1,6 @@
+class GroupMembers
+  constructor: ->
+    $('li.users_group').bind 'ajax:success', ->
+      $(this).fadeOut()
+
+@GroupMembers = GroupMembers

app/assets/stylesheets/gitlab_bootstrap/lists.scss

@@ -16,6 +16,12 @@
       color: #888;
     }
 
+    &.unstyled {
+      &:hover {
+        background: none;
+      }
+    }
+
     &.smoke { background-color: #f5f5f5; }
 
     &:hover {

app/controllers/admin/groups_controller.rb

@@ -66,14 +66,12 @@ def remove_project
   end
 
   def project_teams_update
-    @group.add_users_to_project_teams(params[:user_ids].split(','), params[:project_access])
+    @group.add_users(params[:user_ids].split(','), params[:group_access])
 
     redirect_to [:admin, @group], notice: 'Users were successfully added.'
   end
 
   def destroy
-    @group.truncate_teams
-
     @group.destroy
 
     redirect_to admin_groups_path, notice: 'Group was successfully deleted.'

app/controllers/dashboard_controller.rb

@@ -34,11 +34,12 @@ def projects
                   @projects
                 end
 
-    @projects = @projects.tagged_with(params[:label]) if params[:label].present?
     @projects = @projects.search(params[:search]) if params[:search].present?
-    @projects = @projects.page(params[:page]).per(30)
 
     @labels = Project.where(id: @projects.map(&:id)).tags_on(:labels)
+
+    @projects = @projects.tagged_with(params[:label]) if params[:label].present?
+    @projects = @projects.page(params[:page]).per(30)
   end
 
   # Get authored or assigned open merge requests

app/controllers/graphs_controller.rb

@@ -10,7 +10,7 @@ def show
       format.js do
         @repo = @project.repository
         @stats = Gitlab::Git::GitStats.new(@repo.raw, @repo.root_ref)
-        @log = @stats.parsed_log.to_json
+        @log = @stats.parsed_log.to_json rescue []
       end
     end
   end

app/controllers/groups_controller.rb

@@ -1,6 +1,6 @@
 class GroupsController < ApplicationController
   respond_to :html
-  before_filter :group, except: [:new, :create]
+  before_filter :group, except: [:new, :create, :people]
 
   # Authorize
   before_filter :authorize_read_group!, except: [:new, :create]
@@ -63,27 +63,16 @@ def issues
 
   def people
     @project = group.projects.find(params[:project_id]) if params[:project_id]
-    @users = @project ? @project.users : group.users
-    @users.sort_by!(&:name)
-
-    if @project
-      @team_member = @project.users_projects.new
-    else
-      @team_member = UsersProject.new
-    end
-  end
-
-  def team_members
-    @group.add_users_to_project_teams(params[:user_ids].split(','), params[:project_access])
-    redirect_to people_group_path(@group), notice: 'Users were successfully added.'
+    @members = group.users_groups.order('group_access DESC')
+    @users_group = UsersGroup.new
   end
 
   def edit
   end
 
   def update
     group_params = params[:group].dup
-    owner_id =group_params.delete(:owner_id)
+    owner_id = group_params.delete(:owner_id)
 
     if owner_id
       @group.owner = User.find(owner_id)

app/controllers/issues_controller.rb

@@ -23,7 +23,7 @@ def index
 
     assignee_id, milestone_id = params[:assignee_id], params[:milestone_id]
 
-    @assignee = @project.users.find(assignee_id) if assignee_id.present? && !assignee_id.to_i.zero?
+    @assignee = @project.team.find(assignee_id) if assignee_id.present? && !assignee_id.to_i.zero?
     @milestone = @project.milestones.find(milestone_id) if milestone_id.present? && !milestone_id.to_i.zero?
 
     respond_to do |format|

app/controllers/team_members_controller.rb

@@ -4,10 +4,8 @@ class TeamMembersController < ProjectResourceController
   before_filter :authorize_admin_project!, except: [:index, :show]
 
   def index
-    @team = @project.users_projects.scoped
-    @team = @team.send(params[:type]) if %w(masters developers reporters guests).include?(params[:type])
-    @team = @team.sort_by(&:project_access).reverse.group_by(&:project_access)
-
+    @group = @project.group
+    @users_projects = @project.users_projects.order('project_access DESC')
     @assigned_teams = @project.user_team_project_relationships
   end
 

app/controllers/users_controller.rb

@@ -3,7 +3,7 @@ class UsersController < ApplicationController
 
   def show
     @user = User.find_by_username!(params[:username])
-    @projects = @user.authorized_projects.where('projects.id in (?)', current_user.authorized_projects.map(&:id))
+    @projects = @user.authorized_projects.where('projects.id in (?)', current_user.authorized_projects.map(&:id)).order('namespace_id DESC')
     @events = @user.recent_events.where(project_id: @projects.map(&:id)).limit(20)
 
     @title = @user.name

app/controllers/users_groups_controller.rb

@@ -0,0 +1,40 @@
+class UsersGroupsController < ApplicationController
+  before_filter :group
+
+  # Authorize
+  before_filter :authorize_admin_group!
+
+  layout 'group'
+
+  def create
+    @group.add_users(params[:user_ids].split(','), params[:group_access])
+
+    redirect_to people_group_path(@group), notice: 'Users were successfully added.'
+  end
+
+  def update
+    # TODO: implement
+  end
+
+  def destroy
+    @users_group = @group.users_groups.find(params[:id])
+    @users_group.destroy
+
+    respond_to do |format|
+      format.html { redirect_to  people_group_path(@group), notice: 'User was  successfully removed from group.' }
+      format.js { render nothing: true }
+    end
+  end
+
+  protected
+
+  def group
+    @group ||= Group.find_by_path(params[:group_id])
+  end
+
+  def authorize_admin_group!
+    unless can?(current_user, :manage_group, group)
+      return render_404
+    end
+  end
+end

app/helpers/groups_helper.rb

@@ -14,4 +14,8 @@ def group_filter_path(entity, options={})
       merge_requests_group_path(@group, options)
     end
   end
+
+  def remove_user_from_group_message(group, user)
+    "You are going to remove #{user.name} from #{group.name} Group. Are you sure?"
+  end
 end

app/models/ability.rb

@@ -50,6 +50,10 @@ def project_abilities(user, project)
         rules << project_admin_rules
       end
 
+      if project.group && project.group.owners.include?(user)
+        rules << project_admin_rules
+      end
+
       rules.flatten
     end
 
@@ -132,7 +136,7 @@ def group_abilities user, group
       rules = []
 
       # Only group owner and administrators can manage group
-      if group.owner == user || user.admin?
+      if group.owners.include?(user) || user.admin?
         rules << [
           :manage_group,
           :manage_namespace

app/models/group.rb

@@ -13,26 +13,28 @@
 #
 
 class Group < Namespace
+  has_many :users_groups, dependent: :destroy
+  has_many :users, through: :users_groups
 
-  def add_users_to_project_teams(user_ids, project_access)
-    UsersProject.add_users_into_projects(
-      projects.map(&:id),
-      user_ids,
-      project_access
-    )
+  after_create :add_owner
+
+  def human_name
+    name
   end
 
-  def users
-    users = User.joins(:users_projects).where(users_projects: {project_id: project_ids})
-    users = users << owner
-    users.uniq
+  def owners
+    @owners ||= (users_groups.owners.map(&:user) << owner)
   end
 
-  def human_name
-    name
+  def add_users(user_ids, group_access)
+    user_ids.compact.each do |user_id|
+      self.users_groups.create(user_id: user_id, group_access: group_access)
+    end
   end
 
-  def truncate_teams
-    UsersProject.truncate_teams(project_ids)
+  private
+
+  def add_owner
+    self.add_users([owner.id], UsersGroup::OWNER)
   end
 end

app/models/project_team.rb

@@ -21,6 +21,16 @@ def << args
     end
   end
 
+  def find user_id
+    user = project.users.find_by_id(user_id)
+
+    if group
+      user ||= group.users.find_by_id(user_id)
+    end
+
+    user
+  end
+
   def get_tm user_id
     project.users_projects.find_by_user_id(user_id)
   end
@@ -47,23 +57,23 @@ def truncate
   end
 
   def members
-    project.users_projects
+    fetch_members
   end
 
   def guests
-    members.guests.map(&:user)
+    @guests ||= fetch_members(:guests)
   end
 
   def reporters
-    members.reporters.map(&:user)
+    @reporters ||= fetch_members(:reporters)
   end
 
   def developers
-    members.developers.map(&:user)
+    @developers ||= fetch_members(:developers)
   end
 
   def masters
-    members.masters.map(&:user)
+    @masters ||= fetch_members(:masters)
   end
 
   def import(source_project)
@@ -96,4 +106,22 @@ def import(source_project)
   rescue
     false
   end
+
+  private
+
+  def fetch_members(level = nil)
+    project_members = project.users_projects
+    group_members = group ? group.users_groups : []
+
+    if level
+      project_members = project_members.send(level)
+      group_members = group_members.send(level) if group
+    end
+
+    (project_members + group_members).map(&:user).uniq
+  end
+
+  def group
+    project.group
+  end
 end

app/models/user.rb

@@ -71,7 +71,9 @@ class User < ActiveRecord::Base
   has_many :keys, dependent: :destroy
 
   # Groups
-  has_many :groups, class_name: "Group", foreign_key: :owner_id
+  has_many :own_groups, class_name: "Group", foreign_key: :owner_id
+  has_many :users_groups, dependent: :destroy
+  has_many :groups, through: :users_groups
 
   # Teams
   has_many :own_teams,                       dependent: :destroy, class_name: "UserTeam", foreign_key: :owner_id
@@ -230,7 +232,7 @@ def namespace_uniq
 
   # Groups where user is an owner
   def owned_groups
-    groups
+    own_groups
   end
 
   def owned_teams
@@ -239,14 +241,14 @@ def owned_teams
 
   # Groups user has access to
   def authorized_groups
-    @group_ids ||= (groups.pluck(:id) + authorized_projects.pluck(:namespace_id))
+    @group_ids ||= (groups.pluck(:id) + own_groups.pluck(:id) + authorized_projects.pluck(:namespace_id))
     Group.where(id: @group_ids)
   end
 
 
   # Projects user has access to
   def authorized_projects
-    @project_ids ||= (owned_projects.pluck(:id) + projects.pluck(:id)).uniq
+    @project_ids ||= (owned_projects.pluck(:id) + groups.map(&:projects).flatten.map(&:id) + projects.pluck(:id)).uniq
     Project.where(id: @project_ids)
   end