from webob.exc import HTTPForbidden, HTTPFound

from kallithea import __platform__, is_unix, is_windows

from kallithea.config.routing import url

from kallithea.lib.caching_query import FromCache

from kallithea.lib.utils import conditional_cache, get_repo_group_slug, get_repo_slug, get_user_group_slug

from kallithea.lib.vcs.utils.lazy import LazyProperty

from kallithea.model.db import (

    Permission, RepoGroup, Repository, User, UserApiKeys, UserGroup, UserGroupMember, UserGroupRepoGroupToPerm, UserGroupRepoToPerm, UserGroupToPerm, UserGroupUserGroupToPerm, UserIpMap, UserToPerm)

from kallithea.model.meta import Session

from kallithea.model.user import UserModel

    :param password: password to hash

    """

    if is_windows:

        return hashlib.sha256(password).hexdigest()

    elif is_unix:

        import bcrypt

    else:

        raise Exception('Unknown or unsupported platform %s'

                        % __platform__)

def check_password(password, hashed):

    if is_windows:

        return hashlib.sha256(password).hexdigest() == hashed

    elif is_unix:

        import bcrypt

        try:

        except ValueError as e:

            # bcrypt will throw ValueError 'Invalid hashed_password salt' on all password errors

            log.error('error from bcrypt checking password: %s', e)

            return False

    else:

        raise Exception('Unknown or unsupported platform %s'

from decorator import decorator

from tg import config

from kallithea import CELERY_EAGER, CELERY_ON

from kallithea.lib.pidlock import DaemonLock, LockHeld

from kallithea.model import meta

log = logging.getLogger(__name__)

    params = list(fargs)

    params.extend(['%s-%s' % ar for ar in fkwargs.items()])

    func_name = str(func.__name__) if hasattr(func, '__name__') else str(func)

    lockkey = 'task_%s.lock' % \

    return lockkey

def locked_task(func):

    def __wrapper(func, *fargs, **fkwargs):

        lockkey = __get_lockkey(func, *fargs, **fkwargs)

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

from kallithea.lib.auth import HasPermissionAny, HasRepoGroupPermissionLevel, HasRepoPermissionLevel

from kallithea.lib.markup_renderer import url_re

from kallithea.lib.pygmentsutils import get_custom_lexer

from kallithea.lib.utils2 import MENTIONS_REGEX, AttributeDict

from kallithea.lib.utils2 import age as _age

from kallithea.lib.vcs.backends.base import BaseChangeset, EmptyChangeset

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError

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

# SCM FILTERS available via h.

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

from kallithea.lib.vcs.utils import author_email, author_name

    it's safe to use in urls

    :param raw_id:

    :param path:

    """

class _FilesBreadCrumbs(object):

    def __call__(self, repo_name, rev, paths):

        if isinstance(paths, str):

    if email_address == _def:

        return default

    parsed_url = urlparse.urlparse(url.current(qualified=True))

    url = (c.visual.gravatar_url or User.DEFAULT_GRAVATAR_URL) \

               .replace('{email}', email_address) \

               .replace('{netloc}', parsed_url.netloc) \

               .replace('{scheme}', parsed_url.scheme) \

               .replace('{size}', str(size))

    return url

middleware to handle permanent repo URLs, replacing PATH_INFO '/_123/yada' with

'/name/of/repo/yada' after looking 123 up in the database.

"""

from kallithea.lib.utils import fix_repo_id_name

class PermanentRepoUrl(object):

    def __init__(self, app, config):

        self.application = app

    def __call__(self, environ, start_response):

        # Extract path_info as get_path_info does, but do it explicitly because

        # we also have to do the reverse operation when patching it back in

        path_info = safe_unicode(environ['PATH_INFO'])

        if path_info.startswith('/'): # it must

        return self.application(environ, start_response)

    baseui._ucfg = config.config()

    baseui._tcfg = config.config()

    sa = meta.Session()

    for ui_ in sa.query(Ui).all():

        if ui_.ui_active:

            log.debug('config from db: [%s] %s=%r', ui_.ui_section,

                      ui_.ui_key, ui_val)

            baseui.setconfig(ascii_bytes(ui_.ui_section), ascii_bytes(ui_.ui_key),

                             ui_val)

    # force set push_ssl requirement to False, Kallithea handles that

import time

from dulwich import objects

from kallithea.lib.vcs.backends.base import BaseInMemoryChangeset

from kallithea.lib.vcs.exceptions import RepositoryError

class GitInMemoryChangeset(BaseInMemoryChangeset):

    def commit(self, message, author, parents=None, branch=None, date=None,

               **kwargs):

        # Create tree and populates it with blobs

        commit_tree = self.parents[0] and repo[self.parents[0]._commit.tree] or \

            objects.Tree()

        for node in self.added + self.changed:

            # Compute subdirs if needed

            dirpath, nodename = posixpath.split(node.path)

            parent = commit_tree

            ancestors = [('', parent)]

            # Tries to dig for the deepest existing tree

            while dirnames:

                curdir = dirnames.pop(0)

        object_store.add_object(commit_tree)

        # Create commit

        commit = objects.Commit()

        commit.tree = commit_tree.id

        commit.parents = [p._commit.id for p in self.parents if p]

        commit.encoding = ENCODING

        # Compute date

        if date is None:

            date = time.time()

        elif isinstance(date, datetime.datetime):

            date = time.mktime(date.timetuple())

        location at given clone_point. Additionally it'll make update to

        working copy accordingly to ``update_after_clone`` flag

        """

        try:

            if src_url:

                opts = {}

                if not update_after_clone:

                    opts.update({'noupdate': True})

                MercurialRepository._check_url(url, self.baseui)

                clone(self.baseui, url, self.path, **opts)

            raise BranchDoesNotExistError(msg)

        if end_pos is not None:

            end_pos += 1

        # filter branches

        filter_ = []

        if branch_name:

        if start_date:

            filter_.append(b'date(">%s")' % start_date)

        if end_date:

            filter_.append(b'date("<%s")' % end_date)

        if filter_ or max_revisions:

            if filter_:

from mercurial import hg

from mercurial.wireprotoserver import sshserver

from kallithea.lib.utils import make_ui

from kallithea.lib.vcs.backends.ssh import BaseSshHandler

log = logging.getLogger(__name__)

class MercurialSshHandler(BaseSshHandler):

        # Note: we want a repo with config based on .hg/hgrc and can thus not use self.db_repo.scm_instance._repo.ui

        baseui = make_ui(repo_path=self.db_repo.repo_full_path)

        if not self.allow_push:

            baseui.setconfig(b'hooks', b'pretxnopen._ssh_reject', b'python:kallithea.lib.hooks.rejectpush')

            baseui.setconfig(b'hooks', b'prepushkey._ssh_reject', b'python:kallithea.lib.hooks.rejectpush')

        log.debug("Starting Mercurial sshserver for %s", self.db_repo.repo_full_path)

        sshserver(baseui, repo).serve_forever()

        HOME_ = tempfile.gettempdir()

VCSRC_PATH = VCSRC_PATH or abspath(HOME_, '.vcsrc')

if os.path.isdir(VCSRC_PATH):

    VCSRC_PATH = os.path.join(VCSRC_PATH, '__init__.py')

DEFAULT_ENCODINGS = aslist('utf-8')

# path to git executable run by run_git_command function

GIT_EXECUTABLE_PATH = 'git'

# can be also --branches --tags

GIT_REV_FILTER = '--all'

from webob.exc import HTTPNotFound

import kallithea

from kallithea.lib.caching_query import FromCache

from kallithea.lib.compat import json

from kallithea.lib.exceptions import DefaultUserException

from kallithea.lib.vcs import get_backend

from kallithea.lib.vcs.backends.base import EmptyChangeset

from kallithea.lib.vcs.utils.helpers import get_scm

from kallithea.lib.vcs.utils.lazy import LazyProperty

from kallithea.model.meta import Base, Session

log = logging.getLogger(__name__)

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

# BASE CLASSES

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

class BaseDbModel(object):

    """

    Base Model for all classes

    """

    __tablename__ = 'settings'

    __table_args__ = (

        _table_args_default_dict,

    )

    SETTINGS_TYPES = {

        'int': safe_int,

        'unicode': safe_unicode,

        'bool': str2bool,

        'list': functools.partial(aslist, sep=',')

    }

    DEFAULT_UPDATE_URL = ''