RepoModel().create(form_result, self.rhodecode_user)

            if form_result['clone_uri']:

                h.flash(_('created repository %s from %s') \

                    % (form_result['repo_name'], form_result['clone_uri']),

                    category='success')

            else:

                h.flash(_('created repository %s') % form_result['repo_name'],

                    category='success')

            if request.POST.get('user_created'):

                # created by regular non admin user

                action_logger(self.rhodecode_user, 'user_created_repo',

            else:

                action_logger(self.rhodecode_user, 'admin_created_repo',

            Session.commit()

        except formencode.Invalid, errors:

            c.new_repo = errors.value['repo_name']

            if request.POST.get('user_created'):

                r = render('admin/repos/repo_add_create_repository.html')

            else:

                r = render('admin/repos/repo_add.html')

            return htmlfill.render(

                r,

        repo_model = RepoModel()

        changed_name = repo_name

        _form = RepoForm(edit=True, old_data={'repo_name': repo_name},

                         repo_groups=c.repo_groups_choices)()

        try:

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

            repo = repo_model.update(repo_name, form_result)

            invalidate_cache('get_repo_cached_%s' % repo_name)

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

                    category='success')

            changed_name = repo.repo_name

            action_logger(self.rhodecode_user, 'admin_updated_repo',

            Session.commit()

        except formencode.Invalid, errors:

            defaults = self.__load_data(repo_name)

            defaults.update(errors.value)

            return htmlfill.render(

                render('admin/repos/repo_edit.html'),

                defaults=defaults,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

        repo_model = RepoModel()

        repo = repo_model.get_by_repo_name(repo_name)

        if not repo:

            h.flash(_('%s repository is not mapped to db perhaps'

                      ' it was moved or renamed  from the filesystem'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

            return redirect(url('repos'))

        try:

            action_logger(self.rhodecode_user, 'admin_deleted_repo',

            repo_model.delete(repo)

            invalidate_cache('get_repo_cached_%s' % repo_name)

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

            Session.commit()

        except IntegrityError, e:

            if e.message.find('repositories_fork_id_fkey') != -1:

                log.error(traceback.format_exc())

                h.flash(_('Cannot delete %s it still contains attached '

                          'forks') % repo_name,

                        category='warning')

            else:

                log.error(traceback.format_exc())

from pylons.i18n.translation import _

from rhodecode.lib.exceptions import DefaultUserException, \

    UserOwnsReposException

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.model.db import User, Permission

from rhodecode.model.forms import UserForm

from rhodecode.model.user import UserModel

from rhodecode.model.meta import Session

log = logging.getLogger(__name__)

class UsersController(BaseController):

    """REST Controller styled on the Atom Publishing Protocol"""

    # To properly map this controller, ensure your config/routing.py

    # file has a resource setup:

    #     map.resource('user', 'users')

    @LoginRequired()

    @HasPermissionAllDecorator('hg.admin')

        c.users_list = self.sa.query(User).all()

        return render('admin/users/users.html')

    def create(self):

        """POST /users: Create a new item"""

        # url('users')

        user_model = UserModel()

        user_form = UserForm()()

        try:

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

            user_model.create(form_result)

                    category='success')

            Session.commit()

        except formencode.Invalid, errors:

            return htmlfill.render(

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

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occurred during creation of user %s') \

                    % request.POST.get('username'), category='error')

        return redirect(url('users'))

        #    h.form(url('update_user', id=ID),

        #           method='put')

        # url('user', id=ID)

        user_model = UserModel()

        c.user = user_model.get(id)

        _form = UserForm(edit=True, old_data={'user_id': id,

                                              'email': c.user.email})()

        form_result = {}

        try:

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

            user_model.update(id, form_result)

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

            Session.commit()

        except formencode.Invalid, errors:

            e = errors.error_dict or {}

            perm = Permission.get_by_key('hg.create.repository')

            e.update({'create_repo_perm': user_model.has_perm(id, perm)})

            return htmlfill.render(

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

                defaults=errors.value,

                errors=e,

                prefix_error=False,

                encoding="UTF-8")

from rhodecode.lib import helpers as h

from rhodecode.lib.exceptions import UsersGroupsAssignedException

from rhodecode.lib.utils2 import safe_unicode

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.model.users_group import UsersGroupModel

from rhodecode.model.db import User, UsersGroup, Permission, UsersGroupToPerm

from rhodecode.model.forms import UsersGroupForm

from rhodecode.model.meta import Session

log = logging.getLogger(__name__)

class UsersGroupsController(BaseController):

    """REST Controller styled on the Atom Publishing Protocol"""

    # To properly map this controller, ensure your config/routing.py

    # file has a resource setup:

    #     map.resource('users_group', 'users_groups')

    @LoginRequired()

    @HasPermissionAllDecorator('hg.admin')

        c.users_groups_list = self.sa.query(UsersGroup).all()

        return render('admin/users_groups/users_groups.html')

    def create(self):

        """POST /users_groups: Create a new item"""

        # url('users_groups')

        users_group_form = UsersGroupForm()()

        try:

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

            UsersGroupModel().create(name=form_result['users_group_name'],

                                     active=form_result['users_group_active'])

            Session.commit()

        except formencode.Invalid, errors:

            return htmlfill.render(

                render('admin/users_groups/users_group_add.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occurred during creation of users group %s') \

                    % request.POST.get('users_group_name'), category='error')

        c.available_members = [(x.user_id, x.username) for x in

                               self.sa.query(User).all()]

        available_members = [safe_unicode(x[0]) for x in c.available_members]

        users_group_form = UsersGroupForm(edit=True,

                                          old_data=c.users_group.get_dict(),

                                          available_members=available_members)()

        try:

            form_result = users_group_form.to_python(request.POST)

            UsersGroupModel().update(c.users_group, form_result)

            Session.commit()

        except formencode.Invalid, errors:

            e = errors.error_dict or {}

            perm = Permission.get_by_key('hg.create.repository')

            e.update({'create_repo_perm':

                         UsersGroupModel().has_perm(id, perm)})

            return htmlfill.render(

                render('admin/users_groups/users_group_edit.html'),

                defaults=errors.value,

                errors=e,

from pylons import tmpl_context as c, url, request, response

from pylons.i18n.translation import _

from pylons.controllers.util import redirect

from pylons.decorators import jsonify

from rhodecode.lib.vcs.exceptions import RepositoryError, ChangesetError, \

    ChangesetDoesNotExistError

from rhodecode.lib.vcs.nodes import FileNode

import rhodecode.lib.helpers as h

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.compat import OrderedDict

from rhodecode.lib import diffs

from rhodecode.model.db import ChangesetComment

from rhodecode.model.comment import ChangesetCommentsModel

from rhodecode.model.meta import Session

from rhodecode.lib.diffs import wrapped_diff

from rhodecode.model.repo import RepoModel

log = logging.getLogger(__name__)

def _update_with_GET(params, GET):

        return render('changeset/raw_changeset.html')

    @jsonify

    def comment(self, repo_name, revision):

        comm = ChangesetCommentsModel().create(

            text=request.POST.get('text'),

            repo_id=c.rhodecode_db_repo.repo_id,

            user_id=c.rhodecode_user.user_id,

            revision=revision,

            f_path=request.POST.get('f_path'),

            line_no=request.POST.get('line')

        )

        Session.commit()

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

            return redirect(h.url('changeset_home', repo_name=repo_name,

                                  revision=revision))

        data = {

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

        }

        if comm:

            c.co = comm

            data.update(comm.get_dict())

            data.update({'rendered_text':

                         render('changeset/changeset_comment_block.html')})

            .options(joinedload(UserFollowing.follows_repository))\

            .all()

        journal = self._get_journal_data(c.following)

        feed = Atom1Feed(title=self.title % 'atom',

                         link=url('public_journal_atom', qualified=True),

                         description=_('Public journal'),

                         language=self.language,

                         ttl=self.ttl)

        for entry in journal[:self.feed_nr]:

            action, action_extra = h.action_parser(entry, feed=True)

            title = "%s - %s %s" % (entry.user.short_contact, action,

                                 entry.repository.repo_name)

            desc = action_extra()

            feed.add_item(title=title,

                          pubdate=entry.action_date,

                          link=url('', qualified=True),

                          author_email=entry.user.email,

                          author_name=entry.user.full_contact,

                          description=desc)

        response.content_type = feed.mime_type

            .options(joinedload(UserFollowing.follows_repository))\

            .all()

        journal = self._get_journal_data(c.following)

        feed = Rss201rev2Feed(title=self.title % 'rss',

                         link=url('public_journal_rss', qualified=True),

                         description=_('Public journal'),

                         language=self.language,

                         ttl=self.ttl)

        for entry in journal[:self.feed_nr]:

            action, action_extra = h.action_parser(entry, feed=True)

            title = "%s - %s %s" % (entry.user.short_contact, action,

                                 entry.repository.repo_name)

            desc = action_extra()

            feed.add_item(title=title,

                          pubdate=entry.action_date,

                          link=url('', qualified=True),

                          author_email=entry.user.email,

                          author_name=entry.user.full_contact,

                          description=desc)

        response.content_type = feed.mime_type

        _form = RepoSettingsForm(edit=True,

                                 old_data={'repo_name': repo_name},

                                 repo_groups=c.repo_groups_choices)()

        try:

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

            repo_model.update(repo_name, form_result)

            invalidate_cache('get_repo_cached_%s' % repo_name)

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

                    category='success')

            changed_name = form_result['repo_name_full']

            action_logger(self.rhodecode_user, 'user_updated_repo',

            Session.commit()

        except formencode.Invalid, errors:

            c.repo_info = repo_model.get_by_repo_name(repo_name)

            c.users_array = repo_model.get_users_js()

            errors.value.update({'user': c.repo_info.user.username})

            return htmlfill.render(

                render('settings/repo_settings.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

        repo_model = RepoModel()

        repo = repo_model.get_by_repo_name(repo_name)

        if not repo:

            h.flash(_('%s repository is not mapped to db perhaps'

                      ' it was moved or renamed  from the filesystem'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

            return redirect(url('home'))

        try:

            action_logger(self.rhodecode_user, 'user_deleted_repo',

            repo_model.delete(repo)

            invalidate_cache('get_repo_cached_%s' % repo_name)

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

            Session.commit()

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during deletion of %s') % repo_name,

                    category='error')

        return redirect(url('home'))

                morelinks += ', ...'

            cs_links.append(html_tmpl % (uniq_id, morelinks))

        if len(revs) > 1:

            cs_links.append(compare_view)

        return ''.join(cs_links)

    def get_fork_name():

        repo_name = action_params

        return _('fork name ') + str(link_to(action_params, url('summary_home',

                                          repo_name=repo_name,)))

    action_str = action_map.get(action, action)

    if feed:

        action = action_str[0].replace('[', '').replace(']', '')

    else:

        action = action_str[0]\

            .replace('[', '<span class="journal_highlight">')\

            .replace(']', '</span>')

    action_params_func = lambda: ""

    if callable(action_str[1]):

        action_params_func = action_str[1]

#==============================================================================

# PERMS

#==============================================================================

from rhodecode.lib.auth import HasPermissionAny, HasPermissionAll, \

HasRepoPermissionAny, HasRepoPermissionAll

#==============================================================================

# GRAVATAR URL

#==============================================================================

        elif isinstance(user, basestring):

            user_obj = User.get_by_username(user)

        else:

            raise Exception('You have to provide user object or username')

        if hasattr(repo, 'repo_id'):

            repo_obj = Repository.get(repo.repo_id)

            repo_name = repo_obj.repo_name

        elif  isinstance(repo, basestring):

            repo_name = repo.lstrip('/')

            repo_obj = Repository.get_by_repo_name(repo_name)

        else:

        user_log = UserLog()

        user_log.user_id = user_obj.user_id

        user_log.action = safe_unicode(action)

        user_log.repository_name = repo_name

        user_log.action_date = datetime.datetime.now()

        user_log.user_ip = ipaddr

        sa.add(user_log)

        log.info(

            'Adding user %s, action %s on %s' % (user_obj, action,

                                                 safe_unicode(repo))

        )

        if commit:

            sa.commit()

<table>

	<tr>

		<th class="left">${_('Username')}</th>

		<th class="left">${_('Action')}</th>

		<th class="left">${_('Repository')}</th>

		<th class="left">${_('Date')}</th>

		<th class="left">${_('From IP')}</th>

	</tr>

	%for cnt,l in enumerate(c.users_log):

	<tr class="parity${cnt%2}">

		<td>${h.link_to(l.user.username,h.url('edit_user', id=l.user.user_id))}</td>

		  <div class="journal_action_params">

		  ${h.literal(h.action_parser(l)[1]())}</div>

		</td>

		<td>

		%if l.repository:

		  ${h.link_to(l.repository.repo_name,h.url('summary_home',repo_name=l.repository.repo_name))}

		%else:

		  ${l.repository_name}

		%endif

		</td>

		<td>${l.action_date}</td>

%if c.journal_day_aggreagate:

    %for day,items in c.journal_day_aggreagate:

    <div class="journal_day">${day}</div>

        % for user,entries in items:

	        <div class="journal_container">

	            <div class="gravatar">

	                <img alt="gravatar" src="${h.gravatar_url(user.email,24)}"/>

	            </div>

	            <div class="journal_user">${user.name} ${user.lastname}</div>

	            <div class="journal_action_container">

	            % for entry in entries:

		            <div class="journal_repo">

		                <span class="journal_repo_name">

		                %if entry.repository is not None:

		                  ${h.link_to(entry.repository.repo_name,

		                              h.url('summary_home',repo_name=entry.repository.repo_name))}

		                %else:

		                  ${entry.repository_name}

		                %endif

		                </span>

		            </div>

		            <div class="journal_action_params">${h.literal(h.action_parser(entry)[1]())}</div>

		            <div class="date"><span class="tooltip" title="${entry.action_date}">${h.age(entry.action_date)}</span></div>