log = logging.getLogger(__name__)

def init_model(engine):

    """

    Initializes db session, bind the engine with the metadata,

    Call this before using any of the tables or classes in the model,

    preferably once in application start

    :param engine: engine to bind to

    """

    engine_str = obfuscate_url_pw(str(engine.url))

    log.info("initializing db for %s", engine_str)

    meta.Base.metadata.bind = engine

class BaseModel(object):

    """

    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_instance(self, cls, instance, callback=None):

        """

        Gets instance of given cls using some simple lookup mechanism.

        :param cls: class to fetch

        :param instance: int or Instance

        :param callback: callback to call if all lookups failed

        """

        if isinstance(instance, cls):

            return instance

        elif isinstance(instance, (int, long)) or safe_str(instance).isdigit():

            return cls.get(instance)

        else:

            if instance is not None:

                if callback is None:

                    raise Exception(

                        'given object must be int, long or Instance of %s '

API key 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: 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 import BaseModel

from kallithea.model.db import UserApiKeys

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

        """

        user = self._get_user(user)

        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)

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

Changeset status controller

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 import BaseModel

from kallithea.model.db import ChangesetStatus, PullRequest

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

            .filter(ChangesetStatus.repo == repo)

        if not with_revisions:

            # only report the latest vote across all users! TODO: be smarter!

            q = q.filter(ChangesetStatus.version == 0)

        if revision:

            q = q.filter(ChangesetStatus.revision == revision)

        elif pull_request:

            pull_request = self._get_instance(PullRequest, pull_request)

            q = q.filter(ChangesetStatus.pull_request == pull_request)

        else:

            raise Exception('Please specify revision or pull_request')

        q = q.order_by(ChangesetStatus.version.asc())

        return q

    def _calculate_status(self, statuses):

        """

        Given a list of statuses, calculate the resulting status, according to

        the policy: approve if consensus, reject when at least one reject.

:created_on: Nov 11, 2011

:author: marcink

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

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

"""

import logging

from pylons.i18n.translation import _

from collections import defaultdict

from kallithea.lib.utils2 import extract_mentioned_users, safe_unicode

from kallithea.lib import helpers as h

from kallithea.model import BaseModel

from kallithea.model.db import ChangesetComment, User, \

    Notification, PullRequest

from kallithea.model.notification import NotificationModel

from kallithea.model.meta import Session

log = logging.getLogger(__name__)

class ChangesetCommentsModel(BaseModel):

    def _get_notification_data(self, repo, comment, user, comment_text,

                               line_no=None, revision=None, pull_request=None,

                               status_change=None, closing_pr=False):

        """

        :returns: tuple (subj,body,recipients,notification_type,email_kwargs)

        """

        # make notification

        body = comment_text  # text of the comment

        line = ''

        if line_no:

            line = _('on line %s') % line_no

        #changeset

        if revision:

            notification_type = Notification.TYPE_CHANGESET_COMMENT

            cs = repo.scm_instance.get_changeset(revision)

            desc = cs.short_id

            threading = ['%s-rev-%s@%s' % (repo.repo_name, revision, h.canonical_hostname())]

            if line_no: # TODO: url to file _and_ line number

                threading.append('%s-rev-%s-line-%s@%s' % (repo.repo_name, revision, line_no,

                                                           h.canonical_hostname()))

            comment_url = h.canonical_url('changeset_home',

                repo_name=repo.repo_name,

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

"""

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 import BaseModel

from kallithea.model.db import Gist

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

        """

        Helper method to get gist by ID, or gist_access_id as a fallback

        :param gist: GistID, gist_access_id, or Gist instance

        """

        return self._get_instance(Gist, gist, callback=Gist.get_by_access_id)

    def __delete_gist(self, gist):

        """

        removes gist from filesystem

        :param gist: gist object

        """

        root_path = RepoModel().repos_path

        rm_path = os.path.join(root_path, GIST_STORE_LOC, gist.gist_access_id)

        log.info("Removing %s", rm_path)

        shutil.rmtree(rm_path)

    def _store_metadata(self, repo, gist_id, gist_access_id, user_id, gist_type,

                        gist_expires):

        """

        store metadata inside the gist, this can be later used for imports

:author: marcink

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

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

"""

import logging

import traceback

from pylons import tmpl_context as c

from pylons.i18n.translation import _

from sqlalchemy.orm import joinedload, subqueryload

import kallithea

from kallithea.lib import helpers as h

from kallithea.lib.utils2 import safe_unicode

from kallithea.model import BaseModel

from kallithea.model.db import Notification, User, UserNotification

from kallithea.model.meta import Session

log = logging.getLogger(__name__)

class NotificationModel(BaseModel):

    def create(self, created_by, subject, body, recipients=None,

               type_=Notification.TYPE_MESSAGE, with_email=True,

               email_kwargs=None, repo_name=None):

        """

        Creates notification of given type

        :param created_by: int, str or User instance. User who created this

            notification

        :param subject:

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

        email_kwargs = email_kwargs or {}

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

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

        created_by_obj = self._get_user(created_by)

:author: marcink

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

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

"""

import logging

import traceback

from sqlalchemy.exc import DatabaseError

from kallithea.model import BaseModel

from kallithea.model.db import User, Permission, UserToPerm, UserRepoToPerm, \

    UserRepoGroupToPerm, UserUserGroupToPerm

from kallithea.lib.utils2 import str2bool

log = logging.getLogger(__name__)

class PermissionModel(BaseModel):

    """

    Permissions model for Kallithea

    """

    def create_permissions(self):

        """

        Create permissions for whole system

        """

        for p in Permission.PERMS:

            if not Permission.get_by_key(p[0]):

                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:

        """

        user = self._get_user(user)

        def _make_perm(perm):

            new_perm = UserToPerm()

            new_perm.user = user

            new_perm.permission = Permission.get_by_key(perm)

"""

import logging

import datetime

from pylons.i18n.translation import _

from sqlalchemy.orm import joinedload

from kallithea.model.meta import Session

from kallithea.lib import helpers as h

from kallithea.lib.exceptions import UserInvalidException

from kallithea.model import BaseModel

from kallithea.model.db import PullRequest, PullRequestReviewers, Notification, \

    ChangesetStatus, User

from kallithea.model.notification import NotificationModel

from kallithea.lib.utils2 import extract_mentioned_users, safe_unicode

log = logging.getLogger(__name__)

class PullRequestModel(BaseModel):

    def get_pullrequest_cnt_for_user(self, user):

        return PullRequest.query() \

                                .join(PullRequestReviewers) \

                                .filter(PullRequestReviewers.user_id == user) \

                                .filter(PullRequest.status != PullRequest.STATUS_CLOSED) \

                                .count()

    def get_all(self, repo_name, from_=False, closed=False):

        """Get all PRs for repo.

        Default is all PRs to the repo, PRs from the repo if from_.

        Closed PRs are only included if closed is true."""

        repo = self._get_repo(repo_name)

        q = PullRequest.query()

        if from_:

            q = q.filter(PullRequest.org_repo == repo)

        else:

            q = q.filter(PullRequest.other_repo == repo)

        if not closed:

            q = q.filter(PullRequest.status != PullRequest.STATUS_CLOSED)

        return q.order_by(PullRequest.created_on.desc()).all()

    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

from kallithea.lib.utils import make_ui

from kallithea.lib.vcs.backends import get_backend

from kallithea.lib.compat import json

from kallithea.lib.utils2 import LazyProperty, safe_str, safe_unicode, \

    remove_prefix, obfuscate_url_pw, get_current_authuser

from kallithea.lib.caching_query import FromCache

from kallithea.lib.hooks import log_delete_repository

from kallithea.model import BaseModel

from kallithea.model.db import Repository, UserRepoToPerm, UserGroupRepoToPerm, \

    UserRepoGroupToPerm, UserGroupRepoGroupToPerm, User, Permission, \

    Statistics, UserGroup, Ui, RepoGroup, RepositoryField

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasRepoPermissionAny, HasUserGroupPermissionAny

from kallithea.lib.exceptions import AttachedForksError

from kallithea.model.scm import UserGroupList

log = logging.getLogger(__name__)

class RepoModel(BaseModel):

    URL_SEPARATOR = Repository.url_sep()

    def _get_user_group(self, users_group):

        return self._get_instance(UserGroup, users_group,

                                  callback=UserGroup.get_by_group_name)

    def _get_repo_group(self, repo_group):

        return self._get_instance(RepoGroup, repo_group,

                                  callback=RepoGroup.get_by_group_name)

    def _create_default_perms(self, repository, private):

        # create default permission

        default = 'repository.read'

        def_user = User.get_default_user()

        for p in def_user.user_perms:

            if p.permission.permission_name.startswith('repository.'):

                default = p.permission.permission_name

                break

        default_perm = 'repository.none' if private else default

        repo_to_perm = UserRepoToPerm()

        repo_to_perm.permission = Permission.get_by_key(default_perm)

:created_on: Jan 25, 2011

:author: marcink

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

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

"""

import os

import logging

import traceback

import shutil

import datetime

from kallithea.lib.utils2 import LazyProperty

from kallithea.model import BaseModel

from kallithea.model.db import RepoGroup, Ui, UserRepoGroupToPerm, \

    User, Permission, UserGroupRepoGroupToPerm, UserGroup, Repository

log = logging.getLogger(__name__)

class RepoGroupModel(BaseModel):

    def _get_user_group(self, users_group):

        return self._get_instance(UserGroup, users_group,

                                  callback=UserGroup.get_by_group_name)

    def _get_repo_group(self, repo_group):

        return self._get_instance(RepoGroup, repo_group,

                                  callback=RepoGroup.get_by_group_name)

    @LazyProperty

    def repos_path(self):

        """

        Gets the repositories root path from database

        """

        q = Ui.get_by_key('paths', '/')

        return q.ui_value

    def _create_default_perms(self, new_group):

        # create default permission

        default_perm = 'group.read'

        def_user = User.get_default_user()

        for p in def_user.user_perms:

            if p.permission.permission_name.startswith('group.'):

                default_perm = p.permission.permission_name

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""

kallithea.model.repo_permission

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

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 import BaseModel

from kallithea.model.db import UserRepoToPerm, UserGroupRepoToPerm, \

    Permission

log = logging.getLogger(__name__)

class RepositoryPermissionModel(BaseModel):

    def get_user_permission(self, repository, user):

        repository = self._get_repo(repository)

        user = self._get_user(user)

        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

        else:

            p = UserRepoToPerm()

            p.user = user

            p.repository = repository

            p.permission = permission

            self.sa.add(p)

    def delete_user_permission(self, repository, user):

        current = self.get_user_permission(repository, user)

import traceback

from pylons import config

from pylons.i18n.translation import _

from sqlalchemy.exc import DatabaseError

from kallithea import EXTERN_TYPE_INTERNAL

from kallithea.lib.utils2 import safe_str, generate_api_key, get_current_authuser

from kallithea.lib.caching_query import FromCache

from kallithea.model import BaseModel

from kallithea.model.db import User, UserToPerm, Notification, \

    UserEmailMap, UserIpMap

from kallithea.lib.exceptions import DefaultUserException, \

    UserOwnsReposException

from kallithea.model.meta import Session

log = logging.getLogger(__name__)

class UserModel(BaseModel):

    password_reset_token_lifetime = 86400 # 24 hours

    def get(self, user_id, cache=False):

        user = self.sa.query(User)

        if cache:

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

                                          "get_user_%s" % user_id))

        return user.get(user_id)

    def get_user(self, user):

        return self._get_user(user)

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

        if not cur_user:

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

        from kallithea.lib.hooks import log_create_user, \

            check_allowed_create_user

        _fd = form_data

        user_data = {

            'username': _fd['username'],

            'password': _fd['password'],

            'email': _fd['email'],

            'firstname': _fd['firstname'],

            'lastname': _fd['lastname'],

            'active': _fd['active'],

user group 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

import traceback

from kallithea.model import BaseModel

from kallithea.model.db import UserGroupMember, UserGroup, \

    UserGroupRepoToPerm, Permission, UserGroupToPerm, User, UserUserGroupToPerm, \

    UserGroupUserGroupToPerm

from kallithea.lib.exceptions import UserGroupsAssignedException, \

    RepoGroupAssignmentError

log = logging.getLogger(__name__)

class UserGroupModel(BaseModel):

    def _get_user_group(self, user_group):

        return self._get_instance(UserGroup, user_group,

                                  callback=UserGroup.get_by_group_name)

    def _create_default_perms(self, user_group):

        # create default permission

        default_perm = 'usergroup.read'

        def_user = User.get_default_user()

        for p in def_user.user_perms:

            if p.permission.permission_name.startswith('usergroup.'):

                default_perm = p.permission.permission_name

                break

        user_group_to_perm = UserUserGroupToPerm()

        user_group_to_perm.permission = Permission.get_by_key(default_perm)

        user_group_to_perm.user_group = user_group

        user_group_to_perm.user_id = def_user.user_id

        return user_group_to_perm

    def _update_permissions(self, user_group, perms_new=None,

                            perms_updates=None):

        from kallithea.lib.auth import HasUserGroupPermissionAny

        if not perms_new:

        if 'skip_if_exists' in kwargs:

            del kwargs['skip_if_exists']

            gr = UserGroup.get_by_group_name(group_name=name)

            if gr:

                return gr

        form_data = self._get_user_group_create_params(name, **kwargs)

        owner = kwargs.get('cur_user', TEST_USER_ADMIN_LOGIN)

        user_group = UserGroupModel().create(

            name=form_data['users_group_name'],

            description=form_data['user_group_description'],

            owner=owner, active=form_data['users_group_active'],

            group_data=form_data['user_group_data'])

        Session().commit()

        user_group = UserGroup.get_by_group_name(user_group.users_group_name)

        return user_group

    def destroy_user_group(self, usergroupid):

        UserGroupModel().delete(user_group=usergroupid, force=True)

        Session().commit()

    def create_gist(self, **kwargs):

        form_data = {

            'description': u'new-gist',

            'owner': TEST_USER_ADMIN_LOGIN,

            'lifetime': -1,

            'gist_mapping': {'filename1.txt':{'content':'hello world'},}

        }

        form_data.update(kwargs)

        gist = GistModel().create(

            description=form_data['description'],owner=form_data['owner'],

            gist_mapping=form_data['gist_mapping'], gist_type=form_data['gist_type'],

            lifetime=form_data['lifetime']

        )

        Session().commit()

        return gist

    def destroy_gists(self, gistid=None):

        for g in Gist.get_all():

            if gistid:

                if gistid == g.gist_access_id:

                    GistModel().delete(g)

            else:

                GistModel().delete(g)

        Session().commit()

    def load_resource(self, resource_name, strip=True):

        with open(os.path.join(FIXTURES, resource_name), 'rb') as f: