jro_apps/redmine Commit - r15768:3c005719aeeb

1

# Redmine - project management software

1

# Redmine - project management software

2

3

#

3

#

4

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

4

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

5

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

5

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

6

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

6

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

7

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

7

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

8

#

8

#

9

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

9

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

10

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

10

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

11

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

12

# GNU General Public License for more details.

12

# GNU General Public License for more details.

13

#

13

#

14

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

14

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

15

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

15

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

16

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

16

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

17

18

class Member < ActiveRecord::Base

18

class Member < ActiveRecord::Base

19

belongs_to :user

19

belongs_to :user

20

belongs_to :principal, :foreign_key => 'user_id'

20

belongs_to :principal, :foreign_key => 'user_id'

21

has_many :member_roles, :dependent => :destroy

21

has_many :member_roles, :dependent => :destroy

22

has_many :roles, lambda { distinct }, :through => :member_roles

22

has_many :roles, lambda { distinct }, :through => :member_roles

23

belongs_to :project

23

belongs_to :project

24

25

validates_presence_of :principal, :project

25

validates_presence_of :principal, :project

26

validates_uniqueness_of :user_id, :scope => :project_id

26

validates_uniqueness_of :user_id, :scope => :project_id

27

validate :validate_role

27

validate :validate_role

28

attr_protected :id

28

attr_protected :id

29

30

before_destroy :set_issue_category_nil

30

before_destroy :set_issue_category_nil

31

32

scope :active, lambda { joins(:principal).where(:users => {:status => Principal::STATUS_ACTIVE})}

32

scope :active, lambda { joins(:principal).where(:users => {:status => Principal::STATUS_ACTIVE})}

33

34

# Sort by first role and principal

34

# Sort by first role and principal

35

scope :sorted, lambda {

35

scope :sorted, lambda {

36

includes(:member_roles, :roles, :principal).

36

includes(:member_roles, :roles, :principal).

37

reorder("#{Role.table_name}.position").

37

reorder("#{Role.table_name}.position").

38

order(Principal.fields_for_order_statement)

38

order(Principal.fields_for_order_statement)

39

}

39

}

40

scope :sorted_by_project, lambda {

41

includes(:project).

42

reorder("#{Project.table_name}.lft")

43

}

40

44

41

alias :base_reload :reload

45

alias :base_reload :reload

42

def reload(*args)

46

def reload(*args)

43

@managed_roles = nil

47

@managed_roles = nil

44

base_reload(*args)

48

base_reload(*args)

45

end

49

end

46

50

47

def role

51

def role

48

end

52

end

49

53

50

def role=

54

def role=

51

end

55

end

52

56

53

def name

57

def name

54

self.user.name

58

self.user.name

55

end

59

end

56

60

57

alias :base_role_ids= :role_ids=

61

alias :base_role_ids= :role_ids=

58

def role_ids=(arg)

62

def role_ids=(arg)

59

ids = (arg || []).collect(&:to_i) - [0]

63

ids = (arg || []).collect(&:to_i) - [0]

60

# Keep inherited roles

64

# Keep inherited roles

61

ids += member_roles.select {|mr| !mr.inherited_from.nil?}.collect(&:role_id)

65

ids += member_roles.select {|mr| !mr.inherited_from.nil?}.collect(&:role_id)

62

66

63

new_role_ids = ids - role_ids

67

new_role_ids = ids - role_ids

64

# Add new roles

68

# Add new roles

65

new_role_ids.each {|id| member_roles << MemberRole.new(:role_id => id, :member => self) }

69

new_role_ids.each {|id| member_roles << MemberRole.new(:role_id => id, :member => self) }

66

# Remove roles (Rails' #role_ids= will not trigger MemberRole#on_destroy)

70

# Remove roles (Rails' #role_ids= will not trigger MemberRole#on_destroy)

67

member_roles_to_destroy = member_roles.select {|mr| !ids.include?(mr.role_id)}

71

member_roles_to_destroy = member_roles.select {|mr| !ids.include?(mr.role_id)}

68

if member_roles_to_destroy.any?

72

if member_roles_to_destroy.any?

69

member_roles_to_destroy.each(&:destroy)

73

member_roles_to_destroy.each(&:destroy)

70

end

74

end

71

end

75

end

72

76

73

def <=>(member)

77

def <=>(member)

74

a, b = roles.sort, member.roles.sort

78

a, b = roles.sort, member.roles.sort

75

if a == b

79

if a == b

76

if principal

80

if principal

77

principal <=> member.principal

81

principal <=> member.principal

78

else

82

else

79

1

83

1

80

end

84

end

81

elsif a.any?

85

elsif a.any?

82

b.any? ? a <=> b : -1

86

b.any? ? a <=> b : -1

83

else

87

else

84

1

88

1

85

end

89

end

86

end

90

end

87

91

88

# Set member role ids ignoring any change to roles that

92

# Set member role ids ignoring any change to roles that

89

# user is not allowed to manage

93

# user is not allowed to manage

90

def set_editable_role_ids(ids, user=User.current)

94

def set_editable_role_ids(ids, user=User.current)

91

ids = (ids || []).collect(&:to_i) - [0]

95

ids = (ids || []).collect(&:to_i) - [0]

92

editable_role_ids = user.managed_roles(project).map(&:id)

96

editable_role_ids = user.managed_roles(project).map(&:id)

93

untouched_role_ids = self.role_ids - editable_role_ids

97

untouched_role_ids = self.role_ids - editable_role_ids

94

touched_role_ids = ids & editable_role_ids

98

touched_role_ids = ids & editable_role_ids

95

self.role_ids = untouched_role_ids + touched_role_ids

99

self.role_ids = untouched_role_ids + touched_role_ids

96

end

100

end

97

101

98

# Returns true if one of the member roles is inherited

102

# Returns true if one of the member roles is inherited

99

def any_inherited_role?

103

def any_inherited_role?

100

member_roles.any? {|mr| mr.inherited_from}

104

member_roles.any? {|mr| mr.inherited_from}

101

end

105

end

102

106

103

# Returns true if the member has the role and if it's inherited

107

# Returns true if the member has the role and if it's inherited

104

def has_inherited_role?(role)

108

def has_inherited_role?(role)

105

member_roles.any? {|mr| mr.role_id == role.id && mr.inherited_from.present?}

109

member_roles.any? {|mr| mr.role_id == role.id && mr.inherited_from.present?}

106

end

110

end

107

111

108

# Returns true if the member's role is editable by user

112

# Returns true if the member's role is editable by user

109

def role_editable?(role, user=User.current)

113

def role_editable?(role, user=User.current)

110

if has_inherited_role?(role)

114

if has_inherited_role?(role)

111

false

115

false

112

else

116

else

113

user.managed_roles(project).include?(role)

117

user.managed_roles(project).include?(role)

114

end

118

end

115

end

119

end

116

120

117

# Returns true if the member is deletable by user

121

# Returns true if the member is deletable by user

118

def deletable?(user=User.current)

122

def deletable?(user=User.current)

119

if any_inherited_role?

123

if any_inherited_role?

120

false

124

false

121

else

125

else

122

roles & user.managed_roles(project) == roles

126

roles & user.managed_roles(project) == roles

123

end

127

end

124

end

128

end

125

129

126

# Destroys the member

130

# Destroys the member

127

def destroy

131

def destroy

128

member_roles.reload.each(&:destroy_without_member_removal)

132

member_roles.reload.each(&:destroy_without_member_removal)

129

super

133

super

130

end

134

end

131

135

132

# Returns true if the member is user or is a group

136

# Returns true if the member is user or is a group

133

# that includes user

137

# that includes user

134

def include?(user)

138

def include?(user)

135

if principal.is_a?(Group)

139

if principal.is_a?(Group)

136

!user.nil? && user.groups.include?(principal)

140

!user.nil? && user.groups.include?(principal)

137

else

141

else

138

self.principal == user

142

self.principal == user

139

end

143

end

140

end

144

end

141

145

142

def set_issue_category_nil

146

def set_issue_category_nil

143

if user_id && project_id

147

if user_id && project_id

144

# remove category based auto assignments for this member

148

# remove category based auto assignments for this member

145

IssueCategory.where(["project_id = ? AND assigned_to_id = ?", project_id, user_id]).

149

IssueCategory.where(["project_id = ? AND assigned_to_id = ?", project_id, user_id]).

146

update_all("assigned_to_id = NULL")

150

update_all("assigned_to_id = NULL")

147

end

151

end

148

end

152

end

149

153

150

# Returns the roles that the member is allowed to manage

154

# Returns the roles that the member is allowed to manage

151

# in the project the member belongs to

155

# in the project the member belongs to

152

def managed_roles

156

def managed_roles

153

@managed_roles ||= begin

157

@managed_roles ||= begin

154

if principal.try(:admin?)

158

if principal.try(:admin?)

155

Role.givable.to_a

159

Role.givable.to_a

156

else

160

else

157

members_management_roles = roles.select do |role|

161

members_management_roles = roles.select do |role|

158

role.has_permission?(:manage_members)

162

role.has_permission?(:manage_members)

159

end

163

end

160

if members_management_roles.empty?

164

if members_management_roles.empty?

161

[]

165

[]

162

elsif members_management_roles.any?(&:all_roles_managed?)

166

elsif members_management_roles.any?(&:all_roles_managed?)

163

Role.givable.to_a

167

Role.givable.to_a

164

else

168

else

165

members_management_roles.map(&:managed_roles).reduce(&:|)

169

members_management_roles.map(&:managed_roles).reduce(&:|)

166

end

170

end

167

end

171

end

168

end

172

end

169

end

173

end

170

174

171

# Creates memberships for principal with the attributes

175

# Creates memberships for principal with the attributes

172

# * project_ids : one or more project ids

176

# * project_ids : one or more project ids

173

# * role_ids : ids of the roles to give to each membership

177

# * role_ids : ids of the roles to give to each membership

174

#

178

#

175

# Example:

179

# Example:

176

# Member.create_principal_memberships(user, :project_ids => [2, 5], :role_ids => [1, 3]

180

# Member.create_principal_memberships(user, :project_ids => [2, 5], :role_ids => [1, 3]

177

def self.create_principal_memberships(principal, attributes)

181

def self.create_principal_memberships(principal, attributes)

178

members = []

182

members = []

179

if attributes

183

if attributes

180

project_ids = Array.wrap(attributes[:project_ids] || attributes[:project_id])

184

project_ids = Array.wrap(attributes[:project_ids] || attributes[:project_id])

181

role_ids = attributes[:role_ids]

185

role_ids = attributes[:role_ids]

182

project_ids.each do |project_id|

186

project_ids.each do |project_id|

183

members << Member.new(:principal => principal, :role_ids => role_ids, :project_id => project_id)

187

members << Member.new(:principal => principal, :role_ids => role_ids, :project_id => project_id)

184

end

188

end

185

principal.members << members

189

principal.members << members

186

end

190

end

187

members

191

members

188

end

192

end

189

193

190

# Finds or initilizes a Member for the given project and principal

194

# Finds or initilizes a Member for the given project and principal

191

def self.find_or_new(project, principal)

195

def self.find_or_new(project, principal)

192

project_id = project.is_a?(Project) ? project.id : project

196

project_id = project.is_a?(Project) ? project.id : project

193

principal_id = principal.is_a?(Principal) ? principal.id : principal

197

principal_id = principal.is_a?(Principal) ? principal.id : principal

194

198

195

member = Member.find_by_project_id_and_user_id(project_id, principal_id)

199

member = Member.find_by_project_id_and_user_id(project_id, principal_id)

196

member ||= Member.new(:project_id => project_id, :user_id => principal_id)

200

member ||= Member.new(:project_id => project_id, :user_id => principal_id)

197

member

201

member

198

end

202

end

199

203

200

protected

204

protected

201

205

202

def validate_role

206

def validate_role

203

errors.add(:role, :empty) if member_roles.empty? && roles.empty?

207

errors.add(:role, :empty) if member_roles.empty? && roles.empty?

204

end

208

end

205

end

209

end

+            <% memberships = principal.memberships.preload(:member_roles => :role).sorted_by_project.to_a %>
             <p><%= link_to l(:label_add_projects), new_principal_membership_path(principal), :remote => true, :class => "icon icon-add" %></p>
-            <% if principal.memberships.any? %>
+            <% if memberships.any? %>
             <table class="list memberships">
               <thead><tr>
                 <th><%= l(:label_project) %></th>
                 <th><%= l(:label_role_plural) %></th>
                 <th style="width:15%"></th>
                   <%= call_table_header_hook principal %>
               </tr></thead>
               <tbody>
-              <% principal.memberships.preload(:member_roles => :role).each do |membership| %>
+              <% memberships.each do |membership| %>
               <% next if membership.new_record? %>
               <tr id="member-<%= membership.id %>" class="<%= cycle 'odd', 'even' %> class">
               <td class="project name">
                 <%= link_to_project membership.project %>
               </td>
               <td class="roles">
                 <span id="member-<%= membership.id %>-roles"><%=h membership.roles.sort.collect(&:to_s).join(', ') %></span>
                 <div id="member-<%= membership.id %>-form"></div>
               </td>
               <td class="buttons">
                   <%= link_to l(:button_edit),
                               edit_principal_membership_path(principal, membership),
                               :remote => true,
                               :class => 'icon icon-edit'
                       %>
                   <%= delete_link principal_membership_path(principal, membership), :remote => true if membership.deletable? %>
               </td>
                   <%= call_table_row_hook principal, membership %>
               </tr>
               <% end; reset_cycle %>
               </tbody>
             </table>
             <% else %>
             <p class="nodata"><%= l(:label_no_data) %></p>
             <% end %>

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages

             # Redmine - project management software
             # Copyright (C) 2006-2016  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 Member < ActiveRecord::Base
               belongs_to :user
               belongs_to :principal, :foreign_key => 'user_id'
               has_many :member_roles, :dependent => :destroy
               has_many :roles, lambda { distinct }, :through => :member_roles
               belongs_to :project
               validates_presence_of :principal, :project
               validates_uniqueness_of :user_id, :scope => :project_id
               validate :validate_role
               attr_protected :id
               before_destroy :set_issue_category_nil
               scope :active, lambda { joins(:principal).where(:users => {:status => Principal::STATUS_ACTIVE})}
             	# Sort by first role and principal
               scope :sorted, lambda {
                 includes(:member_roles, :roles, :principal).
                   reorder("#{Role.table_name}.position").
                   order(Principal.fields_for_order_statement)
               }
+              scope :sorted_by_project, lambda {
+                includes(:project).
+                  reorder("#{Project.table_name}.lft")
+              }
               alias :base_reload :reload
               def reload(*args)
                 @managed_roles = nil
                 base_reload(*args)
               end
               def role
               end
               def role=
               end
               def name
                 self.user.name
               end
               alias :base_role_ids= :role_ids=
               def role_ids=(arg)
                 ids = (arg || []).collect(&:to_i) - [0]
                 # Keep inherited roles
                 ids += member_roles.select {|mr| !mr.inherited_from.nil?}.collect(&:role_id)
                 new_role_ids = ids - role_ids
                 # Add new roles
                 new_role_ids.each {|id| member_roles << MemberRole.new(:role_id => id, :member => self) }
                 # Remove roles (Rails' #role_ids= will not trigger MemberRole#on_destroy)
                 member_roles_to_destroy = member_roles.select {|mr| !ids.include?(mr.role_id)}
                 if member_roles_to_destroy.any?
                   member_roles_to_destroy.each(&:destroy)
                 end
               end
               def <=>(member)
                 a, b = roles.sort, member.roles.sort
                 if a == b
                   if principal
                     principal <=> member.principal
                   else
                   end
                 elsif a.any?
                   b.any? ? a <=> b : -1
                 else
                 end
               end
               # Set member role ids ignoring any change to roles that
               # user is not allowed to manage
               def set_editable_role_ids(ids, user=User.current)
                 ids = (ids || []).collect(&:to_i) - [0]
                 editable_role_ids = user.managed_roles(project).map(&:id)
                 untouched_role_ids = self.role_ids - editable_role_ids
                 touched_role_ids = ids & editable_role_ids
                 self.role_ids = untouched_role_ids + touched_role_ids
               end
               # Returns true if one of the member roles is inherited
               def any_inherited_role?
                 member_roles.any? {|mr| mr.inherited_from}
               end
               # Returns true if the member has the role and if it's inherited
               def has_inherited_role?(role)
                 member_roles.any? {|mr| mr.role_id == role.id && mr.inherited_from.present?}
               end
               # Returns true if the member's role is editable by user
               def role_editable?(role, user=User.current)
                 if has_inherited_role?(role)
                   false
                 else
                   user.managed_roles(project).include?(role)
                 end
               end
               # Returns true if the member is deletable by user
               def deletable?(user=User.current)
                 if any_inherited_role?
                   false
                 else
                   roles & user.managed_roles(project) == roles
                 end
               end
               # Destroys the member
               def destroy
                 member_roles.reload.each(&:destroy_without_member_removal)
                 super
               end
               # Returns true if the member is user or is a group
               # that includes user
               def include?(user)
                 if principal.is_a?(Group)
                   !user.nil? && user.groups.include?(principal)
                 else
                   self.principal == user
                 end
               end
               def set_issue_category_nil
                 if user_id && project_id
                   # remove category based auto assignments for this member
                   IssueCategory.where(["project_id = ? AND assigned_to_id = ?", project_id, user_id]).
                     update_all("assigned_to_id = NULL")
                 end
               end
               # Returns the roles that the member is allowed to manage
               # in the project the member belongs to
               def managed_roles
                 @managed_roles ||= begin
                   if principal.try(:admin?)
                     Role.givable.to_a
                   else
                     members_management_roles = roles.select do |role|
                       role.has_permission?(:manage_members)
                     end
                     if members_management_roles.empty?
                       []
                     elsif members_management_roles.any?(&:all_roles_managed?)
                       Role.givable.to_a
                     else
                       members_management_roles.map(&:managed_roles).reduce(&:|)
                     end
                   end
                 end
               end
               # Creates memberships for principal with the attributes
               # * project_ids : one or more project ids
               # * role_ids : ids of the roles to give to each membership
               #
               # Example:
               #   Member.create_principal_memberships(user, :project_ids => [2, 5], :role_ids => [1, 3]
               def self.create_principal_memberships(principal, attributes)
                 members = []
                 if attributes
                   project_ids = Array.wrap(attributes[:project_ids] || attributes[:project_id])
                   role_ids = attributes[:role_ids]
                   project_ids.each do |project_id|
                     members << Member.new(:principal => principal, :role_ids => role_ids, :project_id => project_id)
                   end
                   principal.members << members
                 end
                 members
               end
               # Finds or initilizes a Member for the given project and principal
               def self.find_or_new(project, principal)
                 project_id = project.is_a?(Project) ? project.id : project
                 principal_id = principal.is_a?(Principal) ? principal.id : principal
                 member = Member.find_by_project_id_and_user_id(project_id, principal_id)
                 member ||= Member.new(:project_id => project_id, :user_id => principal_id)
                 member
               end
               protected
               def validate_role
                 errors.add(:role, :empty) if member_roles.empty? && roles.empty?
               end
             end