@celerylib.dbsession

def create_repo(form_data, cur_user):

    from kallithea.model.repo import RepoModel

    from kallithea.model.db import Setting

    DBS = celerylib.get_session()

    owner = cur_user

    repo_name = form_data['repo_name']

    :param cur_user:

    """

    from kallithea.model.repo import RepoModel

    DBS = celerylib.get_session()

    base_path = Repository.base_path()

    repo_name = form_data['repo_name']  # fork in this case

    repo_name_full = form_data['repo_name_full']

from kallithea.lib.utils2 import generate_api_key

from kallithea.model.base import BaseModel

from kallithea.model.meta import Session

log = logging.getLogger(__name__)

        :param description: description of ApiKey

        :param lifetime: expiration time in seconds

        """

        new_api_key = UserApiKeys()

        new_api_key.api_key = generate_api_key()

        api_key = UserApiKeys.query().filter(UserApiKeys.api_key == api_key)

        if user is not None:

            api_key = api_key.filter(UserApiKeys.user_id == user.user_id)

        api_key = api_key.scalar()

        Session().delete(api_key)

    def get_api_keys(self, user, show_expired=True):

        user_api_keys = UserApiKeys.query() \

            .filter(UserApiKeys.user_id == user.user_id)

        if not show_expired:

        else:

            self.sa = meta.Session()

    def _get_repo(self, repository):

        """

        Helper method to get repository by ID, or repository name

from sqlalchemy.orm import joinedload

from kallithea.model.base import BaseModel

from kallithea.lib.exceptions import StatusChangeOnClosedPullRequestError

log = logging.getLogger(__name__)

        for rev in revisions:

            new_status = ChangesetStatus()

            new_status.version = 0 # default

            new_status.repo = self._get_repo(repo)

            new_status.status = status

            new_status.comment = comment

            return None

        repo = self._get_repo(repo)

        comment = ChangesetComment()

        comment.repo = repo

        comment.author = author

    time_to_datetime, AttributeDict

from kallithea.lib.compat import json

from kallithea.model.base import BaseModel

from kallithea.model.repo import RepoModel

from kallithea.model.scm import ScmModel

        :param gist_type: type of gist private/public

        :param lifetime: in minutes, -1 == forever

        """

        gist_id = safe_unicode(unique_id(20))

        lifetime = safe_int(lifetime, -1)

        gist_expires = time.time() + (lifetime * 60) if lifetime != -1 else -1

        if recipients and not getattr(recipients, '__iter__', False):

            raise Exception('recipients must be a list or iterable')

        recipients_objs = []

        if recipients:

            for u in recipients:

                if obj is not None:

                    recipients_objs.append(obj)

                else:

        # we don't want to remove actual notification just the assignment

        try:

            notification = Notification.guess_instance(notification)

            if notification and user:

                obj = UserNotification.query() \

                        .filter(UserNotification.user == user) \

        :param user:

        :param filter:

        """

        q = UserNotification.query() \

            .filter(UserNotification.user == user) \

    def mark_read(self, user, notification):

        try:

            notification = Notification.guess_instance(notification)

            if notification and user:

                obj = UserNotification.query() \

                        .filter(UserNotification.user == user) \

            raise

    def mark_all_read_for_user(self, user, filter_=None):

        q = UserNotification.query() \

            .filter(UserNotification.user == user) \

            .filter(UserNotification.read == False) \

            obj.read = True

    def get_unread_cnt_for_user(self, user):

        return UserNotification.query() \

                .filter(UserNotification.read == False) \

                .filter(UserNotification.user == user).count()

    def get_unread_for_user(self, user):

        return [x.notification for x in UserNotification.query() \

                .filter(UserNotification.read == False) \

                .filter(UserNotification.user == user).all()]

    def get_user_notification(self, user, notification):

        notification = Notification.guess_instance(notification)

        return UserNotification.query() \

        :param user:

        """

        def _make_perm(perm):

            new_perm = UserToPerm()

        specified, or if a given ID or username does not match any user.

        """

        for user_spec in seq:

            if user is None or user.username == User.DEFAULT_USER:

                raise UserInvalidException(user_spec)

            yield user

        :param user:

        """

        from kallithea.lib.auth import AuthUser

        repos = AuthUser(dbuser=user).permissions['repositories']

        access_check = lambda r: r[1] in ['repository.read',

                                          'repository.write',

        """

        from kallithea.model.scm import ScmModel

        fork_of = self._get_repo(fork_of)

        repo_group = self._get_repo_group(repo_group)

        try:

        :param user: Instance of User, user_id or username

        :param perm: Instance of Permission, or permission_name

        """

        repo = self._get_repo(repo)

        permission = self._get_perm(perm)

        :param user: Instance of User, user_id or username

        """

        repo = self._get_repo(repo)

        obj = self.sa.query(UserRepoToPerm) \

    def create(self, group_name, group_description, owner, parent=None,

               just_db=False, copy_permissions=False):

        try:

            parent_group = self._get_repo_group(parent)

            new_repo_group = RepoGroup()

            new_repo_group.owner = owner

        """

        repo_group = self._get_repo_group(repo_group)

        permission = self._get_perm(perm)

        # check if we have that permission already

        """

        repo_group = self._get_repo_group(repo_group)

        obj = self.sa.query(UserRepoGroupToPerm) \

            .filter(UserRepoGroupToPerm.user == user) \

import logging

from kallithea.model.base import BaseModel

    Permission

log = logging.getLogger(__name__)

    def get_user_permission(self, repository, user):

        repository = self._get_repo(repository)

        return UserRepoToPerm.query() \

                .filter(UserRepoToPerm.user == user) \

        :param repo: a db_repo.scm_instance

        """

        IMC = self._get_IMC_module(repo.alias)

        # decoding here will force that we have proper encoded values

        :returns: new committed changeset

        """

        scm_instance = repo.scm_instance_no_cache()

        processed_nodes = []

        """

        Commits specified nodes to repo. Again.

        """

        scm_instance = repo.scm_instance_no_cache()

        message = safe_unicode(message)

        :returns: new committed changeset after deletion

        """

        scm_instance = repo.scm_instance_no_cache()

        processed_nodes = []

        return user.get(user_id)

    def get_user(self, user):

    def create(self, form_data, cur_user=None):

        if not cur_user:

    def update_user(self, user, **kwargs):

        from kallithea.lib.auth import get_crypt_password

        if user.username == User.DEFAULT_USER:

            raise DefaultUserException(

                _("You can't edit this user since it's"

    def delete(self, user, cur_user=None):

        if cur_user is None:

            cur_user = getattr(get_current_authuser(), 'username', None)

        if user.username == User.DEFAULT_USER:

            raise DefaultUserException(

    def has_perm(self, user, perm):

        perm = self._get_perm(perm)

        return UserToPerm.query().filter(UserToPerm.user == user) \

            .filter(UserToPerm.permission == perm).scalar() is not None

        :param user:

        :param perm:

        """

        perm = self._get_perm(perm)

        # if this permission is already granted skip it

        _perm = UserToPerm.query() \

        :param user:

        :param perm:

        """

        perm = self._get_perm(perm)

        UserToPerm.query().filter(

        from kallithea.model import forms

        form = forms.UserExtraEmailForm()()

        data = form.to_python(dict(email=email))

        obj = UserEmailMap()

        obj.user = user

        :param user:

        :param email_id:

        """

        obj = UserEmailMap.query().get(email_id)

        if obj is not None:

            self.sa.delete(obj)

        from kallithea.model import forms

        form = forms.UserExtraIpForm()()

        data = form.to_python(dict(ip=ip))

        obj = UserIpMap()

        obj.user = user

        :param user:

        :param ip_id:

        """

        obj = UserIpMap.query().get(ip_id)

        if obj:

            self.sa.delete(obj)

    def create(self, name, description, owner, active=True, group_data=None):

        try:

            new_user_group = UserGroup()

            new_user_group.users_group_name = name

            new_user_group.user_group_description = description

            new_user_group.users_group_active = active

    def add_user_to_group(self, user_group, user):

        user_group = self._get_user_group(user_group)

        for m in user_group.members:

            u = m.user

    def remove_user_from_group(self, user_group, user):

        user_group = self._get_user_group(user_group)

        user_group_member = None

        for m in user_group.members:

        """

        user_group = self._get_user_group(user_group)

        permission = self._get_perm(perm)

        # check if we have that permission already

        """

        user_group = self._get_user_group(user_group)

        obj = self.sa.query(UserUserGroupToPerm) \

            .filter(UserUserGroupToPerm.user == user) \

            log.debug('Revoked perm on %s on %s', target_user_group, user_group)

    def enforce_groups(self, user, groups, extern_type=None):

        log.debug('Enforcing groups %s on user %s', user, groups)

        current_groups = user.group_member

        # find the external created groups