# -*- coding: utf-8 -*-

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

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

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

"""

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

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

:created_on: Mar 6, 2012

:author: marcink

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

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

"""

import os

import click

import kallithea.bin.kallithea_cli_base as cli_base

from kallithea.lib.utils2 import ask_ok

@cli_base.register_command(needs_config_file=True)

def extensions_create(config):

    """Write template file for extending Kallithea in Python.

    Create a template `extensions.py` file next to the ini file. Local

    customizations in that file will survive upgrades. The file contains

    instructions on how it can be customized.

    """

    here = config['here']

    ext_file = os.path.join(here, 'extensions.py')

    if os.path.exists(ext_file):

        msg = ('Extension file %s already exists, do you want '

               'to overwrite it ? [y/n] ') % ext_file

        if not ask_ok(msg):

            click.echo('Nothing done, exiting...')

            return

    dirname = os.path.dirname(ext_file)

    if not os.path.isdir(dirname):

        os.makedirs(dirname)

    with open(ext_file, 'wb') as f:

        f.write(content)

        click.echo('Wrote new extensions file to %s' % ext_file)

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# 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.db

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

Database Models 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: Apr 08, 2010

:author: marcink

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

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

"""

import base64

import collections

import datetime

import functools

import hashlib

import logging

import os

import time

import traceback

import ipaddr

import sqlalchemy

import urlobject

from sqlalchemy import Boolean, Column, DateTime, Float, ForeignKey, Index, Integer, LargeBinary, String, Unicode, UnicodeText, UniqueConstraint

from sqlalchemy.ext.hybrid import hybrid_property

from sqlalchemy.orm import class_mapper, joinedload, relationship, validates

from tg.i18n import lazy_ugettext as _

from webob.exc import HTTPNotFound

import kallithea

from kallithea.lib import ext_json, ssh, webutils

from kallithea.lib.exceptions import DefaultUserException

from kallithea.lib.utils2 import (asbool, ascii_bytes, aslist, check_git_version, get_changeset_safe, get_clone_url, remove_prefix, safe_bytes, safe_int,

                                  safe_str, urlreadable)

from kallithea.lib.vcs import get_repo

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

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

from kallithea.model import meta

log = logging.getLogger(__name__)

    @classmethod

    def get_auth_settings(cls):

        ret = cls.query() \

                .filter(cls.app_settings_name.startswith('auth_')).all()

        fd = {}

        for row in ret:

            fd[row.app_settings_name] = row.app_settings_value

        return fd

    @classmethod

    def get_default_repo_settings(cls, strip_prefix=False):

        ret = cls.query() \

                .filter(cls.app_settings_name.startswith('default_')).all()

        fd = {}

        for row in ret:

            key = row.app_settings_name

            if strip_prefix:

                key = remove_prefix(key, prefix='default_')

            fd.update({key: row.app_settings_value})

        return fd

    @classmethod

    def get_server_info(cls):

        info = {

            'modules': sorted(mods, key=lambda k: k[0].lower()),

            'py_version': platform.python_version(),

            'platform': platform.platform(),

            'kallithea_version': kallithea.__version__,

            'git_version': str(check_git_version()),

            'git_path': kallithea.CONFIG.get('git_path')

        }

        return info

class Ui(meta.Base, BaseDbModel):

    __tablename__ = 'ui'

    __table_args__ = (

        Index('ui_ui_section_ui_key_idx', 'ui_section', 'ui_key'),

        UniqueConstraint('ui_section', 'ui_key'),

        _table_args_default_dict,

    )

    HOOK_UPDATE = 'changegroup.kallithea_update'

    HOOK_REPO_SIZE = 'changegroup.kallithea_repo_size'

    ui_id = Column(Integer(), primary_key=True)

    ui_section = Column(String(255), nullable=False)

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# 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.scm

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

Scm 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: Apr 9, 2010

:author: marcink

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

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

"""

import logging

import os

import posixpath

import re

import sys

import tempfile

import traceback

from tg.i18n import ugettext as _

import kallithea

from kallithea.lib import hooks

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

from kallithea.lib.exceptions import IMCCommitError, NonRelativePathError

from kallithea.lib.utils import get_filesystem_repos, make_ui

from kallithea.lib.utils2 import safe_bytes, safe_str, set_hook_environment, umask

from kallithea.lib.vcs import get_repo

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

from kallithea.lib.vcs.exceptions import RepositoryError, VCSError

from kallithea.lib.vcs.nodes import FileNode

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

from kallithea.model import db, meta, userlog

log = logging.getLogger(__name__)

class UserTemp(object):

    def __init__(self, user_id):

        self.user_id = user_id

    def __repr__(self):

        interpreter and in the right environment.

        """

        # Note: sys.executable might not point at a usable Python interpreter. For

        # example, when using uwsgi, it will point at the uwsgi program itself.

        # FIXME This may not work on Windows and may need a shell wrapper script.

        return (kallithea.CONFIG.get('git_hook_interpreter')

                or sys.executable

                or '/usr/bin/env python3')

    def install_git_hooks(self, repo, force=False):

        """

        Creates a kallithea hook inside a git repository

        :param repo: Instance of VCS repo

        :param force: Overwrite existing non-Kallithea hooks

        """

        hooks_path = os.path.join(repo.path, 'hooks')

        if not repo.bare:

            hooks_path = os.path.join(repo.path, '.git', 'hooks')

        if not os.path.isdir(hooks_path):

            os.makedirs(hooks_path)

        tmpl_post = b"#!%s\n" % safe_bytes(self._get_git_hook_interpreter())

        for h_type, tmpl in [('pre-receive', None), ('post-receive', tmpl_post)]:

            hook_file = os.path.join(hooks_path, h_type)

            other_hook = False

            log.debug('Installing git hook %s in repo %s', h_type, repo.path)

            if os.path.islink(hook_file):

                log.debug("Found symlink hook at %s", hook_file)

                other_hook = True

            elif os.path.isfile(hook_file):

                log.debug('hook file %s exists, checking if it is from kallithea', hook_file)

                with open(hook_file, 'rb') as f:

                    data = f.read()

                    matches = re.search(br'^KALLITHEA_HOOK_VER\s*=\s*(.*)$', data, flags=re.MULTILINE)

                    if matches:

                        ver = safe_str(matches.group(1))

                        log.debug('Found Kallithea hook - it has KALLITHEA_HOOK_VER %s', ver)

                    else:

                        log.debug('Found non-Kallithea hook at %s', hook_file)

                        other_hook = True

            elif os.path.exists(hook_file):

                log.debug("Found hook that isn't a regular file at %s", hook_file)

                other_hook = True

            if other_hook and not force:

                log.warning('skipping overwriting hook file %s', hook_file)

importlib

inspect

io

ipaddr

IPython

isapi_wsgi

itertools

json

kajiki

ldap

logging

mako

markdown

mimetypes

mock

msvcrt

multiprocessing

operator

os

paginate

paginate_sqlalchemy

pam

paste

pathlib

platform

posixpath

pprint

pwd

pyflakes

pytest

pytest_localserver

random

re

routes

setuptools

shlex

shutil

smtplib

socket

ssl

stat

string

struct

subprocess

sys

tarfile

tempfile

textwrap