mail_port, ssl, tls, debug=debug)

        m.send(recipients, subject, body, html_body, headers=headers)

    except:

        log.error('Mail sending failed')

        log.error(traceback.format_exc())

        return False

    return True

@celerylib.task

@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']

    repo_name_full = form_data['repo_name_full']

    repo_type = form_data['repo_type']

    description = form_data['repo_description']

    private = form_data['repo_private']

    clone_uri = form_data.get('clone_uri')

    repo_group = form_data['repo_group']

    landing_rev = form_data['repo_landing_rev']

    copy_fork_permissions = form_data.get('copy_permissions')

    copy_group_permissions = form_data.get('repo_copy_permissions')

@celerylib.task

@celerylib.dbsession

def create_repo_fork(form_data, cur_user):

    """

    Creates a fork of repository using interval VCS methods

    :param form_data:

    :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']

    repo_type = form_data['repo_type']

    owner = cur_user

    private = form_data['private']

    clone_uri = form_data.get('clone_uri')

    repo_group = form_data['repo_group']

    landing_rev = form_data['landing_rev']

    copy_fork_permissions = form_data.get('copy_permissions')

:created_on: Sep 8, 2013

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import time

import logging

from sqlalchemy import or_

from kallithea.lib.utils2 import generate_api_key

from kallithea.model.base import BaseModel

from kallithea.model.meta import Session

log = logging.getLogger(__name__)

class ApiKeyModel(BaseModel):

    def create(self, user, description, lifetime=-1):

        """

        :param user: user or user_id

        :param description: description of ApiKey

        :param lifetime: expiration time in seconds

        """

        new_api_key = UserApiKeys()

        new_api_key.api_key = generate_api_key()

        new_api_key.user_id = user.user_id

        new_api_key.description = description

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

        Session().add(new_api_key)

        return new_api_key

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

        """

        Deletes given api_key, if user is set it also filters the object for

        deletion by given user.

        """

        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:

            user_api_keys = user_api_keys \

                .filter(or_(UserApiKeys.expires == -1,

                            UserApiKeys.expires >= time.time()))

        return user_api_keys

    Base Model for all Kallithea models, it adds sql alchemy session

    into instance of model

    :param sa: If passed it reuses this session instead of creating a new one

    """

    def __init__(self, sa=None):

        if sa is not None:

            self.sa = sa

        else:

            self.sa = meta.Session()

    def _get_repo(self, repository):

        """

        Helper method to get repository by ID, or repository name

        :param repository: RepoID, repository name or Repository Instance

        """

        from kallithea.model.db import Repository

        return Repository.guess_instance(repository)

    def _get_perm(self, permission):

        """

        Helper method to get permission by ID, or permission name

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Apr 30, 2012

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

from sqlalchemy.orm import joinedload

from kallithea.model.base import BaseModel

from kallithea.lib.exceptions import StatusChangeOnClosedPullRequestError

log = logging.getLogger(__name__)

class ChangesetStatusModel(BaseModel):

    def _get_status_query(self, repo, revision, pull_request,

                          with_revisions=False):

        repo = self._get_repo(repo)

        q = ChangesetStatus.query() \

                'Changing status on closed pull request is not allowed'

            )

        #update all current statuses with older version

        for st in cur_statuses:

            st.version += 1

            self.sa.add(st)

        new_statuses = []

        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

            new_status.revision = rev

            new_status.pull_request = pull_request

            new_statuses.append(new_status)

            self.sa.add(new_status)

        return new_statuses

               send_email=True):

        """

        Creates a new comment for either a changeset or a pull request.

        status_change and closing_pr is only for the optional email.

        Returns the created comment.

        """

        if not status_change and not text:

            log.warning('Missing text for comment, skipping...')

            return None

        repo = self._get_repo(repo)

        comment = ChangesetComment()

        comment.repo = repo

        comment.author = author

        comment.text = text

        comment.f_path = f_path

        comment.line_no = line_no

        if revision is not None:

            comment.revision = revision

        elif pull_request is not None:

            pull_request = PullRequest.guess_instance(pull_request)

            comment.pull_request = pull_request

"""

import os

import time

import logging

import traceback

import shutil

from kallithea.lib.utils2 import safe_unicode, unique_id, safe_int, \

    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

log = logging.getLogger(__name__)

GIST_STORE_LOC = '.rc_gist_store'

GIST_METADATA_FILE = '.rc_gist_metadata'

class GistModel(BaseModel):

    def _get_gist(self, gist):

        return cs, [n for n in cs.get_node('/')]

    def create(self, description, owner, gist_mapping,

               gist_type=Gist.GIST_PUBLIC, lifetime=-1):

        """

        :param description: description of the gist

        :param owner: user who created this gist

        :param gist_mapping: mapping {filename:{'content':content},...}

        :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

        log.debug('set GIST expiration date to: %s',

                  time_to_datetime(gist_expires)

                   if gist_expires != -1 else 'forever')

        #create the Database version

        gist = Gist()

        gist.gist_description = description

        gist.gist_access_id = gist_id

        gist.owner_id = owner.user_id

        gist.gist_expires = gist_expires

        :param body:

        :param recipients: list of int, str or User objects, when None

            is given send to all admins

        :param type_: type of notification

        :param with_email: send email with this notification

        :param email_kwargs: additional dict to pass as args to email template

        """

        from kallithea.lib.celerylib import tasks

        email_kwargs = email_kwargs or {}

        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:

                    # TODO: inform user that requested operation couldn't be completed

                    log.error('cannot email unknown user %r', u)

            recipients_objs = set(recipients_objs)

            log.debug('sending notifications %s to %s',

                type_, recipients_objs

            )

        elif recipients is None:

            # empty recipients means to all admins

            recipients_objs = User.query().filter(User.admin == True).all()

            email_html_body = EmailNotificationModel() \

                                .get_email_tmpl(type_, 'html', **html_kwargs)

            tasks.send_email([rec.email], email_subject, email_txt_body,

                     email_html_body, headers, author=created_by_obj)

        return notif

    def delete(self, user, notification):

        # 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) \

                        .filter(UserNotification.notification

                                == notification) \

                        .one()

                Session().delete(obj)

                return True

        except Exception:

            log.error(traceback.format_exc())

            raise

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

        """

        Get notifications for given user, filter them if filter dict is given

        :param user:

        :param filter:

        """

        q = UserNotification.query() \

            .filter(UserNotification.user == user) \

            .join((Notification, UserNotification.notification_id ==

                                 Notification.notification_id)) \

            .options(joinedload('notification')) \

            .options(subqueryload('notification.created_by_user')) \

            .order_by(Notification.created_on.desc())

        if filter_:

            q = q.filter(Notification.type_.in_(filter_))

        return q

    def mark_read(self, user, notification):

        try:

            notification = Notification.guess_instance(notification)

            if notification and user:

                obj = UserNotification.query() \

                        .filter(UserNotification.user == user) \

                        .filter(UserNotification.notification

                                == notification) \

                        .one()

                obj.read = True

                return True

        except Exception:

            log.error(traceback.format_exc())

            raise

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

        q = UserNotification.query() \

            .filter(UserNotification.user == user) \

            .filter(UserNotification.read == False) \

            .join((Notification, UserNotification.notification_id ==

                                 Notification.notification_id))

        if filter_:

            q = q.filter(Notification.type_.in_(filter_))

        # this is a little inefficient but sqlalchemy doesn't support

        # update on joined tables :(

        for obj in q:

            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() \

            .filter(UserNotification.notification == notification) \

            .filter(UserNotification.user == user).scalar()

    def make_description(self, notification, show_age=True):

        """

        Creates a human readable description based on properties

        of notification object

        """

        #alias

                new_perm = Permission()

                new_perm.permission_name = p[0]

                self.sa.add(new_perm)

    def create_default_permissions(self, user, force=False):

        """

        Create missing default permissions for user. If force is set, the default

        permissions for the user are reset, otherwise only missing permissions are

        created.

        :param user:

        """

        def _make_perm(perm):

            new_perm = UserToPerm()

            new_perm.user = user

            new_perm.permission = Permission.get_by_key(perm)

            return new_perm

        def _get_group(perm_name):

            return '.'.join(perm_name.split('.')[:1])

        perms = UserToPerm.query().filter(UserToPerm.user == user).all()

        defined_perms_groups = map(_get_group,

log = logging.getLogger(__name__)

class PullRequestModel(BaseModel):

    def _get_valid_reviewers(self, seq):

        """ Generate User objects from a sequence of user IDs, usernames or

        User objects. Raises UserInvalidException if the DEFAULT user is

        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

    def create(self, created_by, org_repo, org_ref, other_repo, other_ref,

               revisions, title, description, reviewers):

        pr = PullRequest()

        pr.org_repo = org_repo

        pr.org_ref = org_ref

        pr.other_repo = other_repo

        pr.other_ref = other_ref

        pr.revisions = revisions

        if cache:

            repo = repo.options(FromCache("sql_cache_short",

                                          "get_repo_%s" % repo_name))

        return repo.scalar()

    def get_all_user_repos(self, user):

        """

        Gets all repositories that user have at least read access

        :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',

                                          'repository.admin']

        repos = [x[0] for x in filter(access_check, repos.items())]

        return Repository.query().filter(Repository.repo_name.in_(repos))

    def get_users_js(self):

        users = self.sa.query(User) \

            .filter(User.active == True) \

            .order_by(User.name, User.lastname) \

            .all()

                     private=False, clone_uri=None, repo_group=None,

                     landing_rev='rev:tip', fork_of=None,

                     copy_fork_permissions=False, enable_statistics=False,

                     enable_locking=False, enable_downloads=False,

                     copy_group_permissions=False, state=Repository.STATE_PENDING):

        """

        Create repository inside database with PENDING state. This should only be

        executed by create() repo, with exception of importing existing repos.

        """

        from kallithea.model.scm import ScmModel

        fork_of = self._get_repo(fork_of)

        repo_group = self._get_repo_group(repo_group)

        try:

            repo_name = safe_unicode(repo_name)

            description = safe_unicode(description)

            # repo name is just a name of repository

            # while repo_name_full is a full qualified name that is combined

            # with name and path of group

            repo_name_full = repo_name

            repo_name = repo_name.split(self.URL_SEPARATOR)[-1]

            new_repo = Repository()

                log.error(traceback.format_exc())

                raise

    def grant_user_permission(self, repo, user, perm):

        """

        Grant permission for user on given repository, or update existing one

        if found

        :param repo: Instance of Repository, repository_id, or repository name

        :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)

        # check if we have that permission already

        obj = self.sa.query(UserRepoToPerm) \

            .filter(UserRepoToPerm.user == user) \

            .filter(UserRepoToPerm.repository == repo) \

            .scalar()

        if obj is None:

            # create new !

            obj = UserRepoToPerm()

        obj.repository = repo

        self.sa.add(obj)

        log.debug('Granted perm %s to %s on %s', perm, user, repo)

        return obj

    def revoke_user_permission(self, repo, user):

        """

        Revoke permission for user on given repository

        :param repo: Instance of Repository, repository_id, or repository name

        :param user: Instance of User, user_id or username

        """

        repo = self._get_repo(repo)

        obj = self.sa.query(UserRepoToPerm) \

            .filter(UserRepoToPerm.repository == repo) \

            .filter(UserRepoToPerm.user == user) \

            .scalar()

        if obj is not None:

            self.sa.delete(obj)

            log.debug('Revoked perm on %s on %s', repo, user)

    def grant_user_group_permission(self, repo, group_name, perm):

        """

                shutil.rmtree(rm_path)

            else:

                #archive that group`

                _now = datetime.datetime.now()

                _ms = str(_now.microsecond).rjust(6, '0')

                _d = 'rm__%s_GROUP_%s' % (_now.strftime('%Y%m%d_%H%M%S_' + _ms),

                                          group.name)

                shutil.move(rm_path, os.path.join(self.repos_path, _d))

    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

            new_repo_group.group_description = group_description or group_name

            new_repo_group.parent_group = parent_group

            new_repo_group.group_name = new_repo_group.get_new_name(group_name)

            self.sa.add(new_repo_group)

            # create an ADMIN permission for owner except if we're super admin,

            # later owner should go into the owner field of groups

            if not owner.is_admin:

    def grant_user_permission(self, repo_group, user, perm):

        """

        Grant permission for user on given repository group, or update

        existing one if found

        :param repo_group: Instance of RepoGroup, repositories_group_id,

            or repositories_group name

        :param user: Instance of User, user_id or username

        :param perm: Instance of Permission, or permission_name

        """

        repo_group = self._get_repo_group(repo_group)

        permission = self._get_perm(perm)

        # check if we have that permission already

        obj = self.sa.query(UserRepoGroupToPerm) \

            .filter(UserRepoGroupToPerm.user == user) \

            .filter(UserRepoGroupToPerm.group == repo_group) \

            .scalar()

        if obj is None:

            # create new !

            obj = UserRepoGroupToPerm()

        obj.group = repo_group

        obj.user = user

        return obj

    def revoke_user_permission(self, repo_group, user):

        """

        Revoke permission for user on given repository group

        :param repo_group: Instance of RepoGroup, repositories_group_id,

            or repositories_group name

        :param user: Instance of User, user_id or username

        """

        repo_group = self._get_repo_group(repo_group)

        obj = self.sa.query(UserRepoGroupToPerm) \

            .filter(UserRepoGroupToPerm.user == user) \

            .filter(UserRepoGroupToPerm.group == repo_group) \

            .scalar()

        if obj is not None:

            self.sa.delete(obj)

            log.debug('Revoked perm on %s on %s', repo_group, user)

    def grant_user_group_permission(self, repo_group, group_name, perm):

        """

        Grant permission for user group on given repository group, or update

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

repository permission model for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Oct 1, 2011

:author: nvinot, marcink

"""

import logging

from kallithea.model.base import BaseModel

    Permission

log = logging.getLogger(__name__)

class RepositoryPermissionModel(BaseModel):

    def get_user_permission(self, repository, user):

        repository = self._get_repo(repository)

        return UserRepoToPerm.query() \

                .filter(UserRepoToPerm.user == user) \

                .filter(UserRepoToPerm.repository == repository) \

                .scalar()

    def update_user_permission(self, repository, user, permission):

        permission = Permission.get_by_key(permission)

        current = self.get_user_permission(repository, user)

        if current:

            if not current.permission is permission:

                current.permission = permission

            self.mark_for_invalidation(repo_name)

        except Exception:

            log.error(traceback.format_exc())

            raise

    def commit_change(self, repo, repo_name, cs, user, author, message,

                      content, f_path):

        """

        Commit a change to a single file

        :param repo: a db_repo.scm_instance

        """

        IMC = self._get_IMC_module(repo.alias)

        # decoding here will force that we have proper encoded values

        # in any other case this will throw exceptions and deny commit

        content = safe_str(content)

        path = safe_str(f_path)

        # message and author needs to be unicode

        # proper backend should then translate that into required type

        message = safe_unicode(message)

        author = safe_unicode(author)

        imc = IMC(repo)

        imc.change(FileNode(path, content, mode=cs.get_file_mode(f_path)))

        :param user: Kallithea User object or user_id, the committer

        :param repo: Kallithea Repository object

        :param message: commit message

        :param nodes: mapping {filename:{'content':content},...}

        :param parent_cs: parent changeset, can be empty than it's initial commit

        :param author: author of commit, cna be different that committer only for git

        :param trigger_push_hook: trigger push hooks

        :returns: new committed changeset

        """

        scm_instance = repo.scm_instance_no_cache()

        processed_nodes = []

        for f_path in nodes:

            content = nodes[f_path]['content']

            f_path = self._sanitize_path(f_path)

            f_path = safe_str(f_path)

            # decoding here will force that we have proper encoded values

            # in any other case this will throw exceptions and deny commit

            if isinstance(content, (basestring,)):

                content = safe_str(content)

            elif isinstance(content, (file, cStringIO.OutputType,)):

            self._handle_push(scm_instance,

                              username=user.username,

                              action='push_local',

                              repo_name=repo.repo_name,

                              revisions=[tip.raw_id])

        return tip

    def update_nodes(self, user, repo, message, nodes, parent_cs=None,

                     author=None, trigger_push_hook=True):

        """

        Commits specified nodes to repo. Again.

        """

        scm_instance = repo.scm_instance_no_cache()

        message = safe_unicode(message)

        committer = user.full_contact

        author = safe_unicode(author) if author else committer

        imc_class = self._get_IMC_module(scm_instance.alias)

        imc = imc_class(scm_instance)

        if not parent_cs:

            parent_cs = EmptyChangeset(alias=scm_instance.alias)

        :param user: Kallithea User object or user_id, the committer

        :param repo: Kallithea Repository object

        :param message: commit message

        :param nodes: mapping {filename:{'content':content},...}

        :param parent_cs: parent changeset, can be empty than it's initial commit

        :param author: author of commit, cna be different that committer only for git

        :param trigger_push_hook: trigger push hooks

        :returns: new committed changeset after deletion

        """

        scm_instance = repo.scm_instance_no_cache()

        processed_nodes = []

        for f_path in nodes:

            f_path = self._sanitize_path(f_path)

            # content can be empty but for compatibility it allows same dicts