user-account: expose membership of user groups to users.

- for review rules this might come in handy
- it's not a secret information about which groups user belongs too

rhodecode/templates/admin/my_account/my_account_user_group_membership.mako

@@ -0,0 +1,75 b''
+## -*- coding: utf-8 -*-
+
+<div class="panel panel-default">
+  <div class="panel-heading">
+    <h3 class="panel-title">${_('User Group Membership')}</h3>
+  </div>
+
+    <div class="panel-body">
+        <div class="groups_management">
+            <div id="repos_list_wrap">
+                <table id="user_group_list_table" class="display"></table>
+            </div>
+        </div>
+    </div>
+</div>
+
+
+<script>
+var api;
+$(document).ready(function() {
+
+    var get_datatable_count = function(){
+        $('#user_group_count').text(api.page.info().recordsDisplay);
+    };
+
+    $('#user_group_list_table').on('click', 'a.editor_remove', function (e) {
+        e.preventDefault();
+        var row = api.row($(this).closest('tr'));
+        row.remove().draw();
+    } );
+
+    $('#user_group_list_table').DataTable({
+      data: ${c.user_groups|n},
+      dom: 'rtp',
+      pageLength: ${c.visual.admin_grid_items},
+      order: [[ 0, "asc" ]],
+      columns: [
+         { data: {"_": "group_name",
+                  "sort": "group_name"}, title: "${_('Name')}", className: "td-componentname," ,
+            render: function (data,type,full,meta)
+                    {return '<div><i class="icon-group" title="User group">'+data+'</i></div>'}},
+
+         { data: {"_": "group_description",
+                  "sort": "group_description"}, title: "${_('Description')}", className: "td-description" },
+         { data: {"_": "users_group_id"}, className: "td-user",
+                 render: function (data,type,full,meta)
+                    {return '<input type="hidden" name="users_group_id" value="'+data+'">'}},
+         { data: {"_": "active",
+                  "sort": "active"}, title: "${_('Active')}", className: "td-active"},
+         { data: {"_": "owner_data"}, title: "${_('Owner')}", className: "td-user",
+             render: function (data,type,full,meta)
+                    {return '<div class="rc-user tooltip">'+
+                            '<img class="gravatar" src="'+ data.owner_icon +'" height="16" width="16">'+
+                             data.owner +'</div>'
+                    }
+         }
+      ],
+      language: {
+          paginate: DEFAULT_GRID_PAGINATION,
+          emptyTable: _gettext("No user groups available yet.")
+      },
+      "initComplete": function( settings, json ) {
+          var data_grid = $('#user_group_list_table').dataTable();
+          api = data_grid.api();
+          get_datatable_count();
+      }
+    });
+
+    // update the counter when doing search
+    $('#user_group_list_table').on( 'search.dt', function (e,settings) {
+        get_datatable_count();
+    });
+
+  });
+</script>
  No newline at end of file

rhodecode/apps/my_account/__init__.py

@@ -1,140 +1,145 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 from rhodecode.apps._base import ADMIN_PREFIX
 
 
 def includeme(config):
 
     config.add_route(
         name='my_account_profile',
         pattern=ADMIN_PREFIX + '/my_account/profile')
 
     # my account edit details
     config.add_route(
         name='my_account_edit',
         pattern=ADMIN_PREFIX + '/my_account/edit')
     config.add_route(
         name='my_account_update',
         pattern=ADMIN_PREFIX + '/my_account/update')
 
     # my account password
     config.add_route(
         name='my_account_password',
         pattern=ADMIN_PREFIX + '/my_account/password')
 
     config.add_route(
         name='my_account_password_update',
         pattern=ADMIN_PREFIX + '/my_account/password/update')
 
     # my account tokens
     config.add_route(
         name='my_account_auth_tokens',
         pattern=ADMIN_PREFIX + '/my_account/auth_tokens')
     config.add_route(
         name='my_account_auth_tokens_add',
         pattern=ADMIN_PREFIX + '/my_account/auth_tokens/new')
     config.add_route(
         name='my_account_auth_tokens_delete',
         pattern=ADMIN_PREFIX + '/my_account/auth_tokens/delete')
 
     # my account ssh keys
     config.add_route(
         name='my_account_ssh_keys',
         pattern=ADMIN_PREFIX + '/my_account/ssh_keys')
     config.add_route(
         name='my_account_ssh_keys_generate',
         pattern=ADMIN_PREFIX + '/my_account/ssh_keys/generate')
     config.add_route(
         name='my_account_ssh_keys_add',
         pattern=ADMIN_PREFIX + '/my_account/ssh_keys/new')
     config.add_route(
         name='my_account_ssh_keys_delete',
         pattern=ADMIN_PREFIX + '/my_account/ssh_keys/delete')
 
+    # my account user group membership
+    config.add_route(
+        name='my_account_user_group_membership',
+        pattern=ADMIN_PREFIX + '/my_account/user_group_membership')
+
     # my account emails
     config.add_route(
         name='my_account_emails',
         pattern=ADMIN_PREFIX + '/my_account/emails')
     config.add_route(
         name='my_account_emails_add',
         pattern=ADMIN_PREFIX + '/my_account/emails/new')
     config.add_route(
         name='my_account_emails_delete',
         pattern=ADMIN_PREFIX + '/my_account/emails/delete')
 
     config.add_route(
         name='my_account_repos',
         pattern=ADMIN_PREFIX + '/my_account/repos')
 
     config.add_route(
         name='my_account_watched',
         pattern=ADMIN_PREFIX + '/my_account/watched')
 
     config.add_route(
         name='my_account_perms',
         pattern=ADMIN_PREFIX + '/my_account/perms')
 
     config.add_route(
         name='my_account_notifications',
         pattern=ADMIN_PREFIX + '/my_account/notifications')
 
     config.add_route(
         name='my_account_notifications_toggle_visibility',
         pattern=ADMIN_PREFIX + '/my_account/toggle_visibility')
 
     # my account pull requests
     config.add_route(
         name='my_account_pullrequests',
         pattern=ADMIN_PREFIX + '/my_account/pull_requests')
     config.add_route(
         name='my_account_pullrequests_data',
         pattern=ADMIN_PREFIX + '/my_account/pull_requests/data')
 
     # notifications
     config.add_route(
         name='notifications_show_all',
         pattern=ADMIN_PREFIX + '/notifications')
 
     # notifications
     config.add_route(
         name='notifications_mark_all_read',
         pattern=ADMIN_PREFIX + '/notifications/mark_all_read')
 
     config.add_route(
         name='notifications_show',
         pattern=ADMIN_PREFIX + '/notifications/{notification_id}')
 
     config.add_route(
         name='notifications_update',
         pattern=ADMIN_PREFIX + '/notifications/{notification_id}/update')
 
     config.add_route(
         name='notifications_delete',
         pattern=ADMIN_PREFIX + '/notifications/{notification_id}/delete')
 
     # channelstream test
     config.add_route(
         name='my_account_notifications_test_channelstream',
         pattern=ADMIN_PREFIX + '/my_account/test_channelstream')
 
     # Scan module for configuration decorators.
     config.scan('.views', ignore='.tests')

rhodecode/apps/my_account/views/my_account.py

@@ -1,585 +1,599 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import logging
 import datetime
 
 import formencode
 import formencode.htmlfill
 from pyramid.httpexceptions import HTTPFound
 from pyramid.view import view_config
 from pyramid.renderers import render
 from pyramid.response import Response
 
 from rhodecode.apps._base import BaseAppView, DataGridAppView
 from rhodecode import forms
 from rhodecode.lib import helpers as h
 from rhodecode.lib import audit_logger
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.auth import LoginRequired, NotAnonymous, CSRFRequired
 from rhodecode.lib.channelstream import (
     channelstream_request, ChannelstreamException)
 from rhodecode.lib.utils2 import safe_int, md5, str2bool
 from rhodecode.model.auth_token import AuthTokenModel
 from rhodecode.model.comment import CommentsModel
 from rhodecode.model.db import (
     Repository, UserEmailMap, UserApiKeys, UserFollowing, joinedload,
     PullRequest)
 from rhodecode.model.forms import UserForm, UserExtraEmailForm
 from rhodecode.model.meta import Session
 from rhodecode.model.pull_request import PullRequestModel
 from rhodecode.model.scm import RepoList
 from rhodecode.model.user import UserModel
 from rhodecode.model.repo import RepoModel
+from rhodecode.model.user_group import UserGroupModel
 from rhodecode.model.validation_schema.schemas import user_schema
 
 log = logging.getLogger(__name__)
 
 
 class MyAccountView(BaseAppView, DataGridAppView):
     ALLOW_SCOPED_TOKENS = False
     """
     This view has alternative version inside EE, if modified please take a look
     in there as well.
     """
 
     def load_default_context(self):
         c = self._get_local_tmpl_context()
         c.user = c.auth_user.get_instance()
         c.allow_scoped_tokens = self.ALLOW_SCOPED_TOKENS
 
         return c
 
     @LoginRequired()
     @NotAnonymous()
     @view_config(
         route_name='my_account_profile', request_method='GET',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
     def my_account_profile(self):
         c = self.load_default_context()
         c.active = 'profile'
         return self._get_template_context(c)
 
     @LoginRequired()
     @NotAnonymous()
     @view_config(
         route_name='my_account_password', request_method='GET',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
     def my_account_password(self):
         c = self.load_default_context()
         c.active = 'password'
         c.extern_type = c.user.extern_type
 
         schema = user_schema.ChangePasswordSchema().bind(
             username=c.user.username)
 
         form = forms.Form(
             schema,
             action=h.route_path('my_account_password_update'),
             buttons=(forms.buttons.save, forms.buttons.reset))
 
         c.form = form
         return self._get_template_context(c)
 
     @LoginRequired()
     @NotAnonymous()
     @CSRFRequired()
     @view_config(
         route_name='my_account_password_update', request_method='POST',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
     def my_account_password_update(self):
         _ = self.request.translate
         c = self.load_default_context()
         c.active = 'password'
         c.extern_type = c.user.extern_type
 
         schema = user_schema.ChangePasswordSchema().bind(
             username=c.user.username)
 
         form = forms.Form(
             schema, buttons=(forms.buttons.save, forms.buttons.reset))
 
         if c.extern_type != 'rhodecode':
             raise HTTPFound(self.request.route_path('my_account_password'))
 
         controls = self.request.POST.items()
         try:
             valid_data = form.validate(controls)
             UserModel().update_user(c.user.user_id, **valid_data)
             c.user.update_userdata(force_password_change=False)
             Session().commit()
         except forms.ValidationFailure as e:
             c.form = e
             return self._get_template_context(c)
 
         except Exception:
             log.exception("Exception updating password")
             h.flash(_('Error occurred during update of user password'),
                     category='error')
         else:
             instance = c.auth_user.get_instance()
             self.session.setdefault('rhodecode_user', {}).update(
                 {'password': md5(instance.password)})
             self.session.save()
             h.flash(_("Successfully updated password"), category='success')
 
         raise HTTPFound(self.request.route_path('my_account_password'))
 
     @LoginRequired()
     @NotAnonymous()
     @view_config(
         route_name='my_account_auth_tokens', request_method='GET',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
     def my_account_auth_tokens(self):
         _ = self.request.translate
 
         c = self.load_default_context()
         c.active = 'auth_tokens'
         c.lifetime_values = AuthTokenModel.get_lifetime_values(translator=_)
         c.role_values = [
             (x, AuthTokenModel.cls._get_role_name(x))
             for x in AuthTokenModel.cls.ROLES]
         c.role_options = [(c.role_values, _("Role"))]
         c.user_auth_tokens = AuthTokenModel().get_auth_tokens(
             c.user.user_id, show_expired=True)
         c.role_vcs = AuthTokenModel.cls.ROLE_VCS
         return self._get_template_context(c)
 
     def maybe_attach_token_scope(self, token):
         # implemented in EE edition
         pass
 
     @LoginRequired()
     @NotAnonymous()
     @CSRFRequired()
     @view_config(
         route_name='my_account_auth_tokens_add', request_method='POST',)
     def my_account_auth_tokens_add(self):
         _ = self.request.translate
         c = self.load_default_context()
 
         lifetime = safe_int(self.request.POST.get('lifetime'), -1)
         description = self.request.POST.get('description')
         role = self.request.POST.get('role')
 
         token = AuthTokenModel().create(
             c.user.user_id, description, lifetime, role)
         token_data = token.get_api_data()
 
         self.maybe_attach_token_scope(token)
         audit_logger.store_web(
             'user.edit.token.add', action_data={
                 'data': {'token': token_data, 'user': 'self'}},
             user=self._rhodecode_user, )
         Session().commit()
 
         h.flash(_("Auth token successfully created"), category='success')
         return HTTPFound(h.route_path('my_account_auth_tokens'))
 
     @LoginRequired()
     @NotAnonymous()
     @CSRFRequired()
     @view_config(
         route_name='my_account_auth_tokens_delete', request_method='POST')
     def my_account_auth_tokens_delete(self):
         _ = self.request.translate
         c = self.load_default_context()
 
         del_auth_token = self.request.POST.get('del_auth_token')
 
         if del_auth_token:
             token = UserApiKeys.get_or_404(del_auth_token)
             token_data = token.get_api_data()
 
             AuthTokenModel().delete(del_auth_token, c.user.user_id)
             audit_logger.store_web(
                 'user.edit.token.delete', action_data={
                     'data': {'token': token_data, 'user': 'self'}},
                 user=self._rhodecode_user,)
             Session().commit()
             h.flash(_("Auth token successfully deleted"), category='success')
 
         return HTTPFound(h.route_path('my_account_auth_tokens'))
 
     @LoginRequired()
     @NotAnonymous()
     @view_config(
         route_name='my_account_emails', request_method='GET',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
     def my_account_emails(self):
         _ = self.request.translate
 
         c = self.load_default_context()
         c.active = 'emails'
 
         c.user_email_map = UserEmailMap.query()\
             .filter(UserEmailMap.user == c.user).all()
         return self._get_template_context(c)
 
     @LoginRequired()
     @NotAnonymous()
     @CSRFRequired()
     @view_config(
         route_name='my_account_emails_add', request_method='POST')
     def my_account_emails_add(self):
         _ = self.request.translate
         c = self.load_default_context()
 
         email = self.request.POST.get('new_email')
 
         try:
             form = UserExtraEmailForm(self.request.translate)()
             data = form.to_python({'email': email})
             email = data['email']
 
             UserModel().add_extra_email(c.user.user_id, email)
             audit_logger.store_web(
                 'user.edit.email.add', action_data={
                     'data': {'email': email, 'user': 'self'}},
                 user=self._rhodecode_user,)
 
             Session().commit()
             h.flash(_("Added new email address `%s` for user account") % email,
                     category='success')
         except formencode.Invalid as error:
             h.flash(h.escape(error.error_dict['email']), category='error')
         except Exception:
             log.exception("Exception in my_account_emails")
             h.flash(_('An error occurred during email saving'),
                     category='error')
         return HTTPFound(h.route_path('my_account_emails'))
 
     @LoginRequired()
     @NotAnonymous()
     @CSRFRequired()
     @view_config(
         route_name='my_account_emails_delete', request_method='POST')
     def my_account_emails_delete(self):
         _ = self.request.translate
         c = self.load_default_context()
 
         del_email_id = self.request.POST.get('del_email_id')
         if del_email_id:
             email = UserEmailMap.get_or_404(del_email_id).email
             UserModel().delete_extra_email(c.user.user_id, del_email_id)
             audit_logger.store_web(
                 'user.edit.email.delete', action_data={
                     'data': {'email': email, 'user': 'self'}},
                 user=self._rhodecode_user,)
             Session().commit()
             h.flash(_("Email successfully deleted"),
                     category='success')
         return HTTPFound(h.route_path('my_account_emails'))
 
     @LoginRequired()
     @NotAnonymous()
     @CSRFRequired()
     @view_config(
         route_name='my_account_notifications_test_channelstream',
         request_method='POST', renderer='json_ext')
     def my_account_notifications_test_channelstream(self):
         message = 'Test message sent via Channelstream by user: {}, on {}'.format(
             self._rhodecode_user.username, datetime.datetime.now())
         payload = {
             # 'channel': 'broadcast',
             'type': 'message',
             'timestamp': datetime.datetime.utcnow(),
             'user': 'system',
             'pm_users': [self._rhodecode_user.username],
             'message': {
                 'message': message,
                 'level': 'info',
                 'topic': '/notifications'
             }
         }
 
         registry = self.request.registry
         rhodecode_plugins = getattr(registry, 'rhodecode_plugins', {})
         channelstream_config = rhodecode_plugins.get('channelstream', {})
 
         try:
             channelstream_request(channelstream_config, [payload], '/message')
         except ChannelstreamException as e:
             log.exception('Failed to send channelstream data')
             return {"response": 'ERROR: {}'.format(e.__class__.__name__)}
         return {"response": 'Channelstream data sent. '
                             'You should see a new live message now.'}
 
     def _load_my_repos_data(self, watched=False):
         if watched:
             admin = False
             follows_repos = Session().query(UserFollowing)\
                 .filter(UserFollowing.user_id == self._rhodecode_user.user_id)\
                 .options(joinedload(UserFollowing.follows_repository))\
                 .all()
             repo_list = [x.follows_repository for x in follows_repos]
         else:
             admin = True
             repo_list = Repository.get_all_repos(
                 user_id=self._rhodecode_user.user_id)
             repo_list = RepoList(repo_list, perm_set=[
                 'repository.read', 'repository.write', 'repository.admin'])
 
         repos_data = RepoModel().get_repos_as_dict(
             repo_list=repo_list, admin=admin)
         # json used to render the grid
         return json.dumps(repos_data)
 
     @LoginRequired()
     @NotAnonymous()
     @view_config(
         route_name='my_account_repos', request_method='GET',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
     def my_account_repos(self):
         c = self.load_default_context()
         c.active = 'repos'
 
         # json used to render the grid
         c.data = self._load_my_repos_data()
         return self._get_template_context(c)
 
     @LoginRequired()
     @NotAnonymous()
     @view_config(
         route_name='my_account_watched', request_method='GET',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
     def my_account_watched(self):
         c = self.load_default_context()
         c.active = 'watched'
 
         # json used to render the grid
         c.data = self._load_my_repos_data(watched=True)
         return self._get_template_context(c)
 
     @LoginRequired()
     @NotAnonymous()
     @view_config(
         route_name='my_account_perms', request_method='GET',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
     def my_account_perms(self):
         c = self.load_default_context()
         c.active = 'perms'
 
         c.perm_user = c.auth_user
         return self._get_template_context(c)
 
     @LoginRequired()
     @NotAnonymous()
     @view_config(
         route_name='my_account_notifications', request_method='GET',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
     def my_notifications(self):
         c = self.load_default_context()
         c.active = 'notifications'
 
         return self._get_template_context(c)
 
     @LoginRequired()
     @NotAnonymous()
     @CSRFRequired()
     @view_config(
         route_name='my_account_notifications_toggle_visibility',
         request_method='POST', renderer='json_ext')
     def my_notifications_toggle_visibility(self):
         user = self._rhodecode_db_user
         new_status = not user.user_data.get('notification_status', True)
         user.update_userdata(notification_status=new_status)
         Session().commit()
         return user.user_data['notification_status']
 
     @LoginRequired()
     @NotAnonymous()
     @view_config(
         route_name='my_account_edit',
         request_method='GET',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
     def my_account_edit(self):
         c = self.load_default_context()
         c.active = 'profile_edit'
 
         c.perm_user = c.auth_user
         c.extern_type = c.user.extern_type
         c.extern_name = c.user.extern_name
 
         defaults = c.user.get_dict()
 
         data = render('rhodecode:templates/admin/my_account/my_account.mako',
                       self._get_template_context(c), self.request)
         html = formencode.htmlfill.render(
             data,
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False
         )
         return Response(html)
 
     @LoginRequired()
     @NotAnonymous()
     @CSRFRequired()
     @view_config(
         route_name='my_account_update',
         request_method='POST',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
     def my_account_update(self):
         _ = self.request.translate
         c = self.load_default_context()
         c.active = 'profile_edit'
 
         c.perm_user = c.auth_user
         c.extern_type = c.user.extern_type
         c.extern_name = c.user.extern_name
 
         _form = UserForm(self.request.translate, edit=True,
                          old_data={'user_id': self._rhodecode_user.user_id,
                                    'email': self._rhodecode_user.email})()
         form_result = {}
         try:
             post_data = dict(self.request.POST)
             post_data['new_password'] = ''
             post_data['password_confirmation'] = ''
             form_result = _form.to_python(post_data)
             # skip updating those attrs for my account
             skip_attrs = ['admin', 'active', 'extern_type', 'extern_name',
                           'new_password', 'password_confirmation']
             # TODO: plugin should define if username can be updated
             if c.extern_type != "rhodecode":
                 # forbid updating username for external accounts
                 skip_attrs.append('username')
 
             UserModel().update_user(
                 self._rhodecode_user.user_id, skip_attrs=skip_attrs,
                 **form_result)
             h.flash(_('Your account was updated successfully'),
                     category='success')
             Session().commit()
 
         except formencode.Invalid as errors:
             data = render(
                 'rhodecode:templates/admin/my_account/my_account.mako',
                 self._get_template_context(c), self.request)
 
             html = formencode.htmlfill.render(
                 data,
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8",
                 force_defaults=False)
             return Response(html)
 
         except Exception:
             log.exception("Exception updating user")
             h.flash(_('Error occurred during update of user %s')
                     % form_result.get('username'), category='error')
             raise HTTPFound(h.route_path('my_account_profile'))
 
         raise HTTPFound(h.route_path('my_account_profile'))
 
     def _get_pull_requests_list(self, statuses):
         draw, start, limit = self._extract_chunk(self.request)
         search_q, order_by, order_dir = self._extract_ordering(self.request)
         _render = self.request.get_partial_renderer(
             'rhodecode:templates/data_table/_dt_elements.mako')
 
         pull_requests = PullRequestModel().get_im_participating_in(
             user_id=self._rhodecode_user.user_id,
             statuses=statuses,
             offset=start, length=limit, order_by=order_by,
             order_dir=order_dir)
 
         pull_requests_total_count = PullRequestModel().count_im_participating_in(
             user_id=self._rhodecode_user.user_id, statuses=statuses)
 
         data = []
         comments_model = CommentsModel()
         for pr in pull_requests:
             repo_id = pr.target_repo_id
             comments = comments_model.get_all_comments(
                 repo_id, pull_request=pr)
             owned = pr.user_id == self._rhodecode_user.user_id
 
             data.append({
                 'target_repo': _render('pullrequest_target_repo',
                                        pr.target_repo.repo_name),
                 'name': _render('pullrequest_name',
                                 pr.pull_request_id, pr.target_repo.repo_name,
                                 short=True),
                 'name_raw': pr.pull_request_id,
                 'status': _render('pullrequest_status',
                                   pr.calculated_review_status()),
                 'title': _render(
                     'pullrequest_title', pr.title, pr.description),
                 'description': h.escape(pr.description),
                 'updated_on': _render('pullrequest_updated_on',
                                       h.datetime_to_time(pr.updated_on)),
                 'updated_on_raw': h.datetime_to_time(pr.updated_on),
                 'created_on': _render('pullrequest_updated_on',
                                       h.datetime_to_time(pr.created_on)),
                 'created_on_raw': h.datetime_to_time(pr.created_on),
                 'author': _render('pullrequest_author',
                                   pr.author.full_contact, ),
                 'author_raw': pr.author.full_name,
                 'comments': _render('pullrequest_comments', len(comments)),
                 'comments_raw': len(comments),
                 'closed': pr.is_closed(),
                 'owned': owned
             })
 
         # json used to render the grid
         data = ({
             'draw': draw,
             'data': data,
             'recordsTotal': pull_requests_total_count,
             'recordsFiltered': pull_requests_total_count,
         })
         return data
 
     @LoginRequired()
     @NotAnonymous()
     @view_config(
         route_name='my_account_pullrequests',
         request_method='GET',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
     def my_account_pullrequests(self):
         c = self.load_default_context()
         c.active = 'pullrequests'
         req_get = self.request.GET
 
         c.closed = str2bool(req_get.get('pr_show_closed'))
 
         return self._get_template_context(c)
 
     @LoginRequired()
     @NotAnonymous()
     @view_config(
         route_name='my_account_pullrequests_data',
         request_method='GET', renderer='json_ext')
     def my_account_pullrequests_data(self):
         self.load_default_context()
         req_get = self.request.GET
         closed = str2bool(req_get.get('closed'))
 
         statuses = [PullRequest.STATUS_NEW, PullRequest.STATUS_OPEN]
         if closed:
             statuses += [PullRequest.STATUS_CLOSED]
 
         data = self._get_pull_requests_list(statuses=statuses)
         return data
 
+    @LoginRequired()
+    @NotAnonymous()
+    @view_config(
+        route_name='my_account_user_group_membership',
+        request_method='GET',
+        renderer='rhodecode:templates/admin/my_account/my_account.mako')
+    def my_account_user_group_membership(self):
+        c = self.load_default_context()
+        c.active = 'user_group_membership'
+        groups = [UserGroupModel.get_user_groups_as_dict(group.users_group)
+                  for group in self._rhodecode_db_user.group_member]
+        c.user_groups = json.dumps(groups)
+        return self._get_template_context(c)

rhodecode/templates/admin/my_account/my_account.mako

@@ -1,53 +1,55 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.mako"/>
 
 <%def name="title()">
     ${_('My account')} ${c.rhodecode_user.username}
     %if c.rhodecode_name:
         &middot; ${h.branding(c.rhodecode_name)}
     %endif
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${_('My Account')}
 </%def>
 
 <%def name="menu_bar_nav()">
     ${self.menu_items(active='my_account')}
 </%def>
 
 <%def name="main()">
 <div class="box">
   <div class="title">
       ${self.breadcrumbs()}
   </div>
 
   <div class="sidebar-col-wrapper scw-small">
     ##main
     <div class="sidebar">
         <ul class="nav nav-pills nav-stacked">
           <li class="${'active' if c.active=='profile' or c.active=='profile_edit' else ''}"><a href="${h.route_path('my_account_profile')}">${_('Profile')}</a></li>
           <li class="${'active' if c.active=='password' else ''}"><a href="${h.route_path('my_account_password')}">${_('Password')}</a></li>
           <li class="${'active' if c.active=='auth_tokens' else ''}"><a href="${h.route_path('my_account_auth_tokens')}">${_('Auth Tokens')}</a></li>
           <li class="${'active' if c.active in ['ssh_keys', 'ssh_keys_generate'] else ''}"><a href="${h.route_path('my_account_ssh_keys')}">${_('SSH Keys')}</a></li>
+          <li class="${'active' if c.active=='user_group_membership' else ''}"><a href="${h.route_path('my_account_user_group_membership')}">${_('User Group Membership')}</a></li>
+
           ## TODO: Find a better integration of oauth views into navigation.
           <% my_account_oauth_url = h.route_path_or_none('my_account_oauth') %>
           % if my_account_oauth_url:
           <li class="${'active' if c.active=='oauth' else ''}"><a href="${my_account_oauth_url}">${_('OAuth Identities')}</a></li>
           % endif
           <li class="${'active' if c.active=='emails' else ''}"><a href="${h.route_path('my_account_emails')}">${_('Emails')}</a></li>
           <li class="${'active' if c.active=='repos' else ''}"><a href="${h.route_path('my_account_repos')}">${_('Repositories')}</a></li>
           <li class="${'active' if c.active=='watched' else ''}"><a href="${h.route_path('my_account_watched')}">${_('Watched')}</a></li>
           <li class="${'active' if c.active=='pullrequests' else ''}"><a href="${h.route_path('my_account_pullrequests')}">${_('Pull Requests')}</a></li>
           <li class="${'active' if c.active=='perms' else ''}"><a href="${h.route_path('my_account_perms')}">${_('Permissions')}</a></li>
           <li class="${'active' if c.active=='my_notifications' else ''}"><a href="${h.route_path('my_account_notifications')}">${_('Live Notifications')}</a></li>
         </ul>
     </div>
 
     <div class="main-content-full-width">
         <%include file="/admin/my_account/my_account_${c.active}.mako"/>
     </div>
   </div>
 </div>
 
 </%def>