group_description=form_result['group_description'],

                parent=form_result['parent_group_id'],

                owner=request.authuser.user_id, # TODO: make editable

                copy_permissions=form_result['group_copy_permissions']

            )

            Session().commit()

        except formencode.Invalid as errors:

            return htmlfill.render(

                render('admin/repo_groups/repo_group_add.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

            new_gr = RepoGroupModel().update(group_name, form_result)

            Session().commit()

            h.flash(_('Updated repository group %s') \

                    % form_result['group_name'], category='success')

            # we now have new name !

            group_name = new_gr.group_name

        except formencode.Invalid as errors:

            c.active = 'settings'

            return htmlfill.render(

                render('admin/repo_groups/repo_group_edit.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

        try:

            RepoGroupModel().delete(group_name)

            Session().commit()

            h.flash(_('Removed repository group %s') % group_name,

                    category='success')

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('Error occurred during deletion of repository group %s')

                    % group_name, category='error')

        if gr.parent_group:

        RepoGroupModel()._update_permissions(c.repo_group,

                                             form_result['perms_new'],

                                             form_result['perms_updates'],

                                             recursive)

        #TODO: implement this

        #action_logger(request.authuser, 'admin_changed_repo_permissions',

        Session().commit()

        h.flash(_('Repository group permissions updated'), category='success')

        raise HTTPFound(location=url('edit_repo_group_perms', group_name=group_name))

    @HasRepoGroupPermissionLevelDecorator('admin')

    def delete_perms(self, group_name):

            repo = repo_model.update(repo_name, **form_result)

            ScmModel().mark_for_invalidation(repo_name)

            h.flash(_('Repository %s updated successfully') % repo_name,

                    category='success')

            changed_name = repo.repo_name

            action_logger(request.authuser, 'admin_updated_repo',

            Session().commit()

        except formencode.Invalid as errors:

            log.info(errors)

            defaults = self.__load_data()

            defaults.update(errors.value)

            c.users_array = repo_model.get_users_js()

                    h.flash(_('Detached %s forks') % _forks, category='success')

                elif do == 'delete_forks':

                    handle_forks = 'delete'

                    h.flash(_('Deleted %s forks') % _forks, category='success')

            repo_model.delete(repo, forks=handle_forks)

            action_logger(request.authuser, 'admin_deleted_repo',

            ScmModel().mark_for_invalidation(repo_name)

            h.flash(_('Deleted repository %s') % repo_name, category='success')

            Session().commit()

        except AttachedForksError:

            h.flash(_('Cannot delete repository %s which still has forks')

                        % repo_name, category='warning')

    def edit_permissions_update(self, repo_name):

        form = RepoPermsForm()().to_python(request.POST)

        RepoModel()._update_permissions(repo_name, form['perms_new'],

                                        form['perms_updates'])

        #TODO: implement this

        #action_logger(request.authuser, 'admin_changed_repo_permissions',

        Session().commit()

        h.flash(_('Repository permissions updated'), category='success')

        raise HTTPFound(location=url('edit_repo_perms', repo_name=repo_name))

    def edit_permissions_revoke(self, repo_name):

        try:

            elif obj_type == 'user_group':

                RepoModel().revoke_user_group_permission(

                    repo=repo_name, group_name=obj_id

                )

            #TODO: implement this

            #action_logger(request.authuser, 'admin_revoked_repo_permissions',

            Session().commit()

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during revoking of permission'),

                    category='error')

            raise HTTPInternalServerError()

                                         owner=request.authuser.user_id,

                                         active=form_result['users_group_active'])

            gr = form_result['users_group_name']

            action_logger(request.authuser,

                          'admin_created_users_group:%s' % gr,

            h.flash(h.literal(_('Created user group %s') % h.link_to(h.escape(gr), url('edit_users_group', id=ug.users_group_id))),

                category='success')

            Session().commit()

        except formencode.Invalid as errors:

            return htmlfill.render(

                render('admin/user_groups/user_group_add.html'),

        try:

            form_result = users_group_form.to_python(request.POST)

            UserGroupModel().update(c.user_group, form_result)

            gr = form_result['users_group_name']

            action_logger(request.authuser,

                          'admin_updated_users_group:%s' % gr,

            h.flash(_('Updated user group %s') % gr, category='success')

            Session().commit()

        except formencode.Invalid as errors:

            ug_model = UserGroupModel()

            defaults = errors.value

            e = errors.error_dict or {}

                                                 form['perms_updates'])

        except RepoGroupAssignmentError:

            h.flash(_('Target group cannot be the same'), category='error')

            raise HTTPFound(location=url('edit_user_group_perms', id=id))

        #TODO: implement this

        #action_logger(request.authuser, 'admin_changed_repo_permissions',

        Session().commit()

        h.flash(_('User group permissions updated'), category='success')

        raise HTTPFound(location=url('edit_user_group_perms', id=id))

    @HasUserGroupPermissionLevelDecorator('admin')

    def delete_perms(self, id):

        user_model = UserModel()

        user_form = UserForm()()

        try:

            form_result = user_form.to_python(dict(request.POST))

            user = user_model.create(form_result)

            action_logger(request.authuser, 'admin_created_user:%s' % user.username,

            h.flash(_('Created user %s') % user.username,

                    category='success')

            Session().commit()

        except formencode.Invalid as errors:

            return htmlfill.render(

                render('admin/users/user_add.html'),

            skip_attrs = ['extern_type', 'extern_name',

                         ] + auth_modules.get_managed_fields(user)

            user_model.update(id, form_result, skip_attrs=skip_attrs)

            usr = form_result['username']

            action_logger(request.authuser, 'admin_updated_user:%s' % usr,

            h.flash(_('User updated successfully'), category='success')

            Session().commit()

        except formencode.Invalid as errors:

            defaults = errors.value

            e = errors.error_dict or {}

            defaults.update({

            except StatusChangeOnClosedPullRequestError:

                log.debug('cannot change status on %s with closed pull request', revision)

                raise HTTPBadRequest()

        action_logger(request.authuser,

                      'user_commented_revision:%s' % revision,

        Session().commit()

        data = {

           'target_id': h.safeid(h.safe_unicode(request.POST.get('f_path'))),

        }

            line_no=line_no,

            closing_pr=close_pr,

        )

        action_logger(request.authuser,

                      'user_commented_pull_request:%s' % pull_request_id,

        if status:

            ChangesetStatusModel().set_status(

                c.db_repo.repo_id,

                status,

                request.authuser.user_id,

            )

        if close_pr:

            PullRequestModel().close_pull_request(pull_request_id)

            action_logger(request.authuser,

                          'user_closed_pull_request:%s' % pull_request_id,

        Session().commit()

        if not request.environ.get('HTTP_X_PARTIAL_XHR'):

            raise HTTPFound(location=pull_request.url())

            enable_locking=enable_locking,

            enable_downloads=enable_downloads,

            state=state

        )

        action_logger(cur_user, 'user_created_repo',

        DBS.commit()

        # now create this repo on Filesystem

        RepoModel(DBS)._create_filesystem_repo(

            repo_name=repo_name,

            repo_type=repo_type,

            repo_group=repo_group,

            landing_rev=landing_rev,

            fork_of=fork_of,

            copy_fork_permissions=copy_fork_permissions

        )

        action_logger(cur_user, 'user_forked_repo:%s' % repo_name_full,

        DBS.commit()

        update_after_clone = form_data['update_after_clone'] # FIXME - unused!

        source_repo_path = os.path.join(base_path, fork_of.repo_name)

        # now create this repo on Filesystem

        if repo:

            # TODO: return repo instead of reponame? or would that be a layering violation?

            return repo.repo_name

    return None

    """

    Action logger for various actions made by users

    :param user: user that made this action, can be a unique username string or

        object containing user_id attribute

    :param action: action to log, should be on of predefined unique actions for

        easy translations

    :param repo: string name of repository or object containing repo_id,

        that action was made on

    :param ipaddr: optional IP address from what the action was made

    """

    # if we don't get explicit IP address try to get one from registered user

    # in tmpl context var

    if not ipaddr:

        ipaddr = getattr(get_current_authuser(), 'ip_addr', '')

    if getattr(user, 'user_id', None):

    user_log.repository = repo_obj

    user_log.repository_name = repo_name

    user_log.action_date = datetime.datetime.now()

    user_log.user_ip = ipaddr

    log.info('Logging action:%s on %s by user:%s ip:%s',

             action, safe_unicode(repo), user_obj, ipaddr)

    if commit:

def get_filesystem_repos(path):

    """

    Scans given path for repos and return (name,(type,path)) tuple