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 7, 2010

:author: marcink

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

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

"""

import logging

import traceback

import celery.result

import formencode

from formencode import htmlfill

from tg import request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPForbidden, HTTPFound, HTTPInternalServerError, HTTPNotFound

import kallithea

from kallithea.lib import webutils

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired, NotAnonymous

from kallithea.lib.base import BaseRepoController, jsonify, render

from kallithea.lib.exceptions import AttachedForksError

from kallithea.lib.utils2 import safe_int

from kallithea.lib.vcs import RepositoryError

from kallithea.lib.webutils import url

from kallithea.model.forms import RepoFieldForm, RepoForm, RepoPermsForm

from kallithea.model.repo import RepoModel

from kallithea.model.scm import AvailableRepoGroupChoices, RepoList, ScmModel

log = logging.getLogger(__name__)

class ReposController(BaseRepoController):

    @LoginRequired(allow_default_user=True)

    def _before(self, *args, **kwargs):

        super(ReposController, self)._before(*args, **kwargs)

    def _load_repo(self):

        repo_obj = c.db_repo

        if repo_obj is None:

            raise HTTPNotFound()

        return repo_obj

    def __load_defaults(self, repo=None):

        extras = [] if repo is None else [repo.group]

        self.__load_defaults(c.repo_info)

        c.active = 'settings'

        c.repo_fields = db.RepositoryField.query() \

            .filter(db.RepositoryField.repository == c.repo_info).all()

        repo_model = RepoModel()

        changed_name = repo_name

        repo = db.Repository.get_by_repo_name(repo_name)

        old_data = {

            'repo_name': repo_name,

            'repo_group': repo.group.get_dict() if repo.group else {},

            'repo_type': repo.repo_type,

        }

        _form = RepoForm(edit=True, old_data=old_data,

                         repo_groups=c.repo_groups,

                         landing_revs=c.landing_revs_choices)()

        try:

            form_result = _form.to_python(dict(request.POST))

            repo = repo_model.update(repo_name, **form_result)

            ScmModel().mark_for_invalidation(repo_name)

            webutils.flash(_('Repository %s updated successfully') % repo_name,

                    category='success')

            changed_name = repo.repo_name

                changed_name, request.ip_addr)

            meta.Session().commit()

        except formencode.Invalid as errors:

            log.info(errors)

            defaults = self.__load_data()

            defaults.update(errors.value)

            return htmlfill.render(

                render('admin/repos/repo_edit.html'),

                defaults=defaults,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

            webutils.flash(_('Error occurred during update of repository %s')

                    % repo_name, category='error')

        raise HTTPFound(location=url('edit_repo', repo_name=changed_name))

    @HasRepoPermissionLevelDecorator('admin')

    def delete(self, repo_name):

        repo_model = RepoModel()

        repo = repo_model.get_by_repo_name(repo_name)

        if not repo:

            raise HTTPNotFound()

        try:

            _forks = repo.forks.count()

            handle_forks = None

            if _forks and request.POST.get('forks'):

                do = request.POST['forks']

                if do == 'detach_forks':

                    handle_forks = 'detach'

                    webutils.flash(_('Detached %s forks') % _forks, category='success')

                elif do == 'delete_forks':

                    handle_forks = 'delete'

                    webutils.flash(_('Deleted %s forks') % _forks, category='success')

            repo_model.delete(repo, forks=handle_forks)

                repo_name, request.ip_addr)

            ScmModel().mark_for_invalidation(repo_name)

            webutils.flash(_('Deleted repository %s') % repo_name, category='success')

            meta.Session().commit()

        except AttachedForksError:

            webutils.flash(_('Cannot delete repository %s which still has forks')

                        % repo_name, category='warning')

        except Exception:

            log.error(traceback.format_exc())

            webutils.flash(_('An error occurred during deletion of %s') % repo_name,

                    category='error')

        if repo.group:

            raise HTTPFound(location=url('repos_group_home', group_name=repo.group.group_name))

        raise HTTPFound(location=url('repos'))

    @HasRepoPermissionLevelDecorator('admin')

    def edit(self, repo_name):

        defaults = self.__load_data()

        c.repo_fields = db.RepositoryField.query() \

            .filter(db.RepositoryField.repository == c.repo_info).all()

        c.active = 'settings'

        return htmlfill.render(

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

:created_on: Jan 25, 2011

:author: marcink

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

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

"""

import logging

import traceback

import formencode

from formencode import htmlfill

from sqlalchemy.orm import joinedload

from sqlalchemy.sql.expression import func

from tg import app_globals, request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPFound, HTTPInternalServerError

import kallithea.lib.helpers as h

from kallithea.lib import webutils

from kallithea.lib.auth import HasPermissionAnyDecorator, HasUserGroupPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseController, render

from kallithea.lib.exceptions import RepoGroupAssignmentError, UserGroupsAssignedException

from kallithea.lib.utils2 import safe_int, safe_str

from kallithea.lib.webutils import url

from kallithea.model.forms import CustomDefaultPermissionsForm, UserGroupForm, UserGroupPermsForm

from kallithea.model.scm import UserGroupList

from kallithea.model.user_group import UserGroupModel

log = logging.getLogger(__name__)

class UserGroupsController(BaseController):

    @LoginRequired(allow_default_user=True)

    def _before(self, *args, **kwargs):

        super(UserGroupsController, self)._before(*args, **kwargs)

    def __load_data(self, user_group_id):

        c.group_members_obj = sorted((x.user for x in c.user_group.members),

                                     key=lambda u: u.username.lower())

        c.group_members = [(x.user_id, x.username) for x in c.group_members_obj]

        c.available_members = sorted(((x.user_id, x.username) for x in

                                      db.User.query().all()),

                                     key=lambda u: u[1].lower())

    def __load_defaults(self, user_group_id):

                "active": h.boolicon(user_gr.users_group_active),

                "owner": h.person(user_gr.owner.username),

                "action": user_group_actions(user_gr.users_group_id, user_gr.users_group_name)

            })

        c.data = {

            "sort": None,

            "dir": "asc",

            "records": user_groups_data

        }

        return render('admin/user_groups/user_groups.html')

    @HasPermissionAnyDecorator('hg.admin', 'hg.usergroup.create.true')

    def create(self):

        users_group_form = UserGroupForm()()

        try:

            form_result = users_group_form.to_python(dict(request.POST))

            ug = UserGroupModel().create(name=form_result['users_group_name'],

                                         description=form_result['user_group_description'],

                                         owner=request.authuser.user_id,

                                         active=form_result['users_group_active'])

            gr = form_result['users_group_name']

                          'admin_created_users_group:%s' % gr,

                          None, request.ip_addr)

            webutils.flash(webutils.HTML(_('Created user group %s')) % webutils.link_to(gr, url('edit_users_group', id=ug.users_group_id)),

                category='success')

            meta.Session().commit()

        except formencode.Invalid as errors:

            return htmlfill.render(

                render('admin/user_groups/user_group_add.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

            webutils.flash(_('Error occurred during creation of user group %s')

                    % request.POST.get('users_group_name'), category='error')

        raise HTTPFound(location=url('users_groups'))

    @HasPermissionAnyDecorator('hg.admin', 'hg.usergroup.create.true')

    def new(self, format='html'):

        return render('admin/user_groups/user_group_add.html')

    @HasUserGroupPermissionLevelDecorator('admin')

    def update(self, id):

        c.user_group = db.UserGroup.get_or_404(id)

        c.active = 'settings'

        self.__load_data(id)

        available_members = [safe_str(x[0]) for x in c.available_members]

        users_group_form = UserGroupForm(edit=True,

                                         old_data=c.user_group.get_dict(),

                                         available_members=available_members)()

        try:

            form_result = users_group_form.to_python(request.POST)

            UserGroupModel().update(c.user_group, form_result)

            gr = form_result['users_group_name']

                          'admin_updated_users_group:%s' % gr,

                          None, request.ip_addr)

            webutils.flash(_('Updated user group %s') % gr, category='success')

            meta.Session().commit()

        except formencode.Invalid as errors:

            ug_model = UserGroupModel()

            defaults = errors.value

            e = errors.error_dict or {}

            defaults.update({

                'create_repo_perm': ug_model.has_perm(id,

                                                      'hg.create.repository'),

                'fork_repo_perm': ug_model.has_perm(id,

                                                    'hg.fork.repository'),

            })

            return htmlfill.render(

                render('admin/user_groups/user_group_edit.html'),

                defaults=defaults,

                errors=e,

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

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

:created_on: Apr 4, 2010

:author: marcink

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

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

"""

import logging

import traceback

import formencode

from formencode import htmlfill

from sqlalchemy.sql.expression import func

from tg import app_globals, request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPFound, HTTPNotFound

import kallithea

import kallithea.lib.helpers as h

from kallithea.lib import auth_modules, webutils

from kallithea.lib.auth import AuthUser, HasPermissionAnyDecorator, LoginRequired

from kallithea.lib.base import BaseController, IfSshEnabled, render

from kallithea.lib.exceptions import DefaultUserException, UserCreationError, UserOwnsReposException

from kallithea.lib.utils2 import datetime_to_time, fmt_date, generate_api_key, safe_int

from kallithea.lib.webutils import url

from kallithea.model.api_key import ApiKeyModel

from kallithea.model.forms import CustomDefaultPermissionsForm, UserForm

from kallithea.model.ssh_key import SshKeyModel, SshKeyModelException

from kallithea.model.user import UserModel

log = logging.getLogger(__name__)

class UsersController(BaseController):

    @LoginRequired()

    @HasPermissionAnyDecorator('hg.admin')

    def _before(self, *args, **kwargs):

        super(UsersController, self)._before(*args, **kwargs)

    def index(self, format='html'):

        c.users_list = db.User.query().order_by(db.User.username) \

                        .filter_by(is_default_user=False) \

                        .order_by(func.lower(db.User.username)) \

                        .all()

        users_data = []

        _tmpl_lookup = app_globals.mako_lookup

                "last_login_raw": datetime_to_time(user.last_login),

                "active": h.boolicon(user.active),

                "admin": h.boolicon(user.admin),

                "extern_type": user.extern_type,

                "extern_name": user.extern_name,

                "action": user_actions(user.user_id, user.username),

            })

        c.data = {

            "sort": None,

            "dir": "asc",

            "records": users_data

        }

        return render('admin/users/users.html')

    def create(self):

        c.default_extern_type = db.User.DEFAULT_AUTH_TYPE

        c.default_extern_name = ''

        user_model = UserModel()

        user_form = UserForm()()

        try:

            form_result = user_form.to_python(dict(request.POST))

            user = user_model.create(form_result)

                          None, request.ip_addr)

            webutils.flash(_('Created user %s') % user.username,

                    category='success')

            meta.Session().commit()

        except formencode.Invalid as errors:

            return htmlfill.render(

                render('admin/users/user_add.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except UserCreationError as e:

            webutils.flash(e, 'error')

        except Exception:

            log.error(traceback.format_exc())

            webutils.flash(_('Error occurred during creation of user %s')

                    % request.POST.get('username'), category='error')

        raise HTTPFound(location=url('edit_user', id=user.user_id))

    def new(self, format='html'):

        c.default_extern_type = db.User.DEFAULT_AUTH_TYPE

        c.default_extern_name = ''

        return render('admin/users/user_add.html')

    def update(self, id):

        user_model = UserModel()

        user = user_model.get(id)

        _form = UserForm(edit=True, old_data={'user_id': id,

                                              'email': user.email})()

        form_result = {}

        try:

            form_result = _form.to_python(dict(request.POST))

            skip_attrs = ['extern_type', 'extern_name',

                         ] + auth_modules.get_managed_fields(user)

            user_model.update(id, form_result, skip_attrs=skip_attrs)

            usr = form_result['username']

                          None, request.ip_addr)

            webutils.flash(_('User updated successfully'), category='success')

            meta.Session().commit()

        except formencode.Invalid as errors:

            defaults = errors.value

            e = errors.error_dict or {}

            defaults.update({

                'create_repo_perm': user_model.has_perm(id,

                                                        'hg.create.repository'),

                'fork_repo_perm': user_model.has_perm(id, 'hg.fork.repository'),

            })

            return htmlfill.render(

                self._render_edit_profile(user),

                defaults=defaults,

                errors=e,

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

            webutils.flash(_('Error occurred during update of user %s')

                    % form_result.get('username'), category='error')

        raise HTTPFound(location=url('edit_user', id=id))

"""

kallithea.controllers.api.api

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

API controller 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: Aug 20, 2011

:author: marcink

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

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

"""

import logging

import traceback

from datetime import datetime

from tg import request

from kallithea.controllers.api import JSONRPCController, JSONRPCError

from kallithea.lib.auth import (AuthUser, HasPermissionAny, HasPermissionAnyDecorator, HasRepoGroupPermissionLevel, HasRepoPermissionLevel,

                                HasUserGroupPermissionLevel)

from kallithea.lib.exceptions import DefaultUserException, UserGroupsAssignedException

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

from kallithea.lib.vcs.exceptions import EmptyRepositoryError

from kallithea.model.changeset_status import ChangesetStatusModel

from kallithea.model.comment import ChangesetCommentsModel

from kallithea.model.gist import GistModel

from kallithea.model.pull_request import PullRequestModel

from kallithea.model.repo import RepoModel

from kallithea.model.repo_group import RepoGroupModel

from kallithea.model.scm import ScmModel, UserGroupList

from kallithea.model.user import UserModel

from kallithea.model.user_group import UserGroupModel

log = logging.getLogger(__name__)

def store_update(updates, attr, name):

    """

    Stores param in updates dict if it's not None (i.e. if user explicitly set

    a parameter). This allows easy updates of passed in params.

    """

    if attr is not None:

        updates[name] = attr

def get_user_or_error(userid):

        if pull_request is None:

            raise JSONRPCError('pull request `%s` does not exist' % (pull_request_id,))

        if (not HasRepoPermissionLevel('read')(pull_request.org_repo.repo_name)):

            raise JSONRPCError('No permission to add comment. User needs at least reading permissions'

                               ' to the source repository.')

        owner = apiuser.user_id == pull_request.owner_id

        reviewer = apiuser.user_id in [reviewer.user_id for reviewer in pull_request.reviewers]

        if close_pr and not (apiuser.admin or owner):

            raise JSONRPCError('No permission to close pull request. User needs to be admin or owner.')

        if status and not (apiuser.admin or owner or reviewer):

            raise JSONRPCError('No permission to change pull request status. User needs to be admin, owner or reviewer.')

        if pull_request.is_closed():

            raise JSONRPCError('pull request is already closed')

        comment = ChangesetCommentsModel().create(

            text=comment_msg,

            repo=pull_request.org_repo.repo_id,

            author=apiuser.user_id,

            pull_request=pull_request.pull_request_id,

            f_path=None,

            line_no=None,

            status_change=db.ChangesetStatus.get_status_lbl(status),

            closing_pr=close_pr

        )

                      'user_commented_pull_request:%s' % pull_request_id,

                      pull_request.org_repo, request.ip_addr)

        if status:

            ChangesetStatusModel().set_status(

                pull_request.org_repo_id,

                status,

                apiuser.user_id,

                comment,

                pull_request=pull_request_id

            )

        if close_pr:

            PullRequestModel().close_pull_request(pull_request_id)

                          'user_closed_pull_request:%s' % pull_request_id,

                          pull_request.org_repo, request.ip_addr)

        meta.Session().commit()

        return True

    # permission check inside

    def edit_reviewers(self, pull_request_id, add=None, remove=None):

        """

        Add and/or remove one or more reviewers to a pull request, by username

        or user ID. Reviewers are specified either as a single-user string or

        as a JSON list of one or more strings.

        """

        if add is None and remove is None:

            raise JSONRPCError('''Invalid request. Neither 'add' nor 'remove' is specified.''')

        pull_request = db.PullRequest.get(pull_request_id)

        if pull_request is None:

            raise JSONRPCError('pull request `%s` does not exist' % (pull_request_id,))

        apiuser = get_user_or_error(request.authuser.user_id)

        is_owner = apiuser.user_id == pull_request.owner_id

        is_repo_admin = HasRepoPermissionLevel('admin')(pull_request.other_repo.repo_name)

        if not (apiuser.admin or is_repo_admin or is_owner):

            raise JSONRPCError('No permission to edit reviewers of this pull request. User needs to be admin or pull request owner.')

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 25, 2010

:author: marcink

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

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

"""

import binascii

import logging

import traceback

from collections import OrderedDict

from tg import request, response

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPBadRequest, HTTPForbidden, HTTPNotFound

import kallithea.lib.helpers as h

from kallithea.lib import auth, diffs, webutils

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseRepoController, jsonify, render

from kallithea.lib.graphmod import graph_data

from kallithea.lib.utils2 import ascii_str, safe_str

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

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError, EmptyRepositoryError, RepositoryError

from kallithea.model.changeset_status import ChangesetStatusModel

from kallithea.model.comment import ChangesetCommentsModel

from kallithea.model.pull_request import PullRequestModel

log = logging.getLogger(__name__)

def create_cs_pr_comment(repo_name, revision=None, pull_request=None, allowed_to_change_status=True):

    """

    Add a comment to the specified changeset or pull request, using POST values

    from the request.

    Comments can be inline (when a file path and line number is specified in

    POST) or general comments.

    A comment can be accompanied by a review status change (accepted, rejected,

    etc.). Pull requests can be closed or deleted.

    Parameter 'allowed_to_change_status' is used for both status changes and

    closing of pull requests. For deleting of pull requests, more specific

    checks are done.

    """

    assert request.environ.get('HTTP_X_PARTIAL_XHR')

        repo=c.db_repo.repo_id,

        author=request.authuser.user_id,

        revision=revision,

        pull_request=pull_request_id,

        f_path=f_path or None,

        line_no=line_no or None,

        status_change=db.ChangesetStatus.get_status_lbl(status) if status else None,

        closing_pr=close_pr,

    )

    if status:

        ChangesetStatusModel().set_status(

            c.db_repo.repo_id,

            status,

            request.authuser.user_id,

            comment,

            revision=revision,

            pull_request=pull_request_id,

        )

    if pull_request:

        action = 'user_commented_pull_request:%s' % pull_request_id

    else:

        action = 'user_commented_revision:%s' % revision

    if pull_request and close_pr:

        PullRequestModel().close_pull_request(pull_request_id)

                      'user_closed_pull_request:%s' % pull_request_id,

                      c.db_repo, request.ip_addr)

    meta.Session().commit()

    data = {

       'target_id': webutils.safeid(request.POST.get('f_path')),

    }

    if comment is not None:

        c.comment = comment

        data.update(comment.get_dict())

        data.update({'rendered_text':

                     render('changeset/changeset_comment_block.html')})

    return data

def delete_cs_pr_comment(repo_name, comment_id):

    """Delete a comment from a changeset or pull request"""

    co = db.ChangesetComment.get_or_404(comment_id)

    if co.repo.repo_name != repo_name:

        raise HTTPNotFound()

    if co.pull_request and co.pull_request.is_closed():

        # don't allow deleting comments on closed pull request

        raise HTTPForbidden()

:author: marcink

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

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

"""

import logging

import os

import posixpath

import shutil

import tempfile

import traceback

from collections import OrderedDict

from tg import request, response

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPFound, HTTPNotFound

import kallithea

import kallithea.lib.helpers as h

from kallithea.lib import diffs, webutils

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseRepoController, jsonify, render

from kallithea.lib.exceptions import NonRelativePathError

from kallithea.lib.utils2 import asbool, convert_line_endings, detect_mode, safe_str

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

from kallithea.lib.vcs.conf import settings

from kallithea.lib.vcs.exceptions import (ChangesetDoesNotExistError, ChangesetError, EmptyRepositoryError, ImproperArchiveTypeError, NodeAlreadyExistsError,

                                          NodeDoesNotExistError, NodeError, RepositoryError, VCSError)

from kallithea.lib.vcs.nodes import FileNode

from kallithea.lib.vcs.utils import author_email

from kallithea.lib.webutils import url

from kallithea.model.repo import RepoModel

from kallithea.model.scm import ScmModel

log = logging.getLogger(__name__)

class FilesController(BaseRepoController):

    def _before(self, *args, **kwargs):

        super(FilesController, self)._before(*args, **kwargs)

    def __get_cs(self, rev, silent_empty=False):

        """

        Safe way to get changeset if error occur it redirects to tip with

        proper message

        :param rev: revision to fetch

        :silent_empty: return None if repository is empty

        """

        try:

            return c.db_repo_scm_instance.get_changeset(rev)

        except EmptyRepositoryError as e:

            # generate new archive

            fd, archive_path = tempfile.mkstemp()

            log.debug('Creating new temp archive in %s', archive_path)

            with os.fdopen(fd, 'wb') as stream:

                cs.fill_archive(stream=stream, kind=fileformat, subrepos=subrepos)

                # stream (and thus fd) has been closed by cs.fill_archive

            if cached_archive_path is not None:

                # we generated the archive - move it to cache

                log.debug('Storing new archive in %s', cached_archive_path)

                shutil.move(archive_path, cached_archive_path)

                archive_path = cached_archive_path

        def get_chunked_archive(archive_path):

            stream = open(archive_path, 'rb')

            while True:

                data = stream.read(16 * 1024)

                if not data:

                    break

                yield data

            stream.close()

            if archive_path != cached_archive_path:

                log.debug('Destroying temp archive %s', archive_path)

                os.remove(archive_path)

                      action='user_downloaded_archive:%s' % (archive_name),

                      repo=repo_name, ipaddr=request.ip_addr, commit=True)

        response.content_disposition = str('attachment; filename=%s' % (archive_name))

        response.content_type = str(content_type)

        return get_chunked_archive(archive_path)

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def diff(self, repo_name, f_path):

        ignore_whitespace_diff = h.get_ignore_whitespace_diff(request.GET)

        diff_context_size = h.get_diff_context_size(request.GET)

        diff2 = request.GET.get('diff2', '')

        diff1 = request.GET.get('diff1', '') or diff2

        c.action = request.GET.get('diff')

        c.no_changes = diff1 == diff2

        c.f_path = f_path

        c.big_diff = False

        fulldiff = request.GET.get('fulldiff')

        c.changes = OrderedDict()

        c.changes[diff2] = []

        # special case if we want a show rev only, it's impl here

        # to reduce JS and callbacks

:created_on: Oct 6, 2010

:author: marcink

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

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

"""

import email.mime.multipart

import email.mime.text

import email.utils

import os

import smtplib

import time

import traceback

from collections import OrderedDict

from operator import itemgetter

from time import mktime

import celery.utils.log

from tg import config

import kallithea

import kallithea.lib.helpers as h

from kallithea.lib import celerylib, conf, ext_json, hooks

from kallithea.lib.indexers.daemon import WhooshIndexingDaemon

from kallithea.lib.utils2 import asbool, ascii_bytes

from kallithea.lib.vcs.utils import author_email

from kallithea.model.repo import RepoModel

__all__ = ['whoosh_index', 'get_commits_stats', 'send_email']

log = celery.utils.log.get_task_logger(__name__)

@celerylib.task

@celerylib.locked_task

@celerylib.dbsession

def whoosh_index(repo_location, full_index):

    celerylib.get_session() # initialize database connection

    index_location = config['index_dir']

    WhooshIndexingDaemon(index_location=index_location,

                         repo_location=repo_location) \

                         .run(full_index=full_index)

# for js data compatibility cleans the key for person from '

def akc(k):

    return h.person(k).replace('"', '')

    # repo creation defaults, private and repo_type are filled in form

    defs = db.Setting.get_default_repo_settings(strip_prefix=True)

    enable_statistics = defs.get('repo_enable_statistics')

    enable_downloads = defs.get('repo_enable_downloads')

    try:

        repo = RepoModel()._create_repo(

            repo_name=repo_name_full,

            repo_type=repo_type,

            description=description,

            owner=owner,

            private=private,

            clone_uri=clone_uri,

            repo_group=repo_group,

            landing_rev=landing_rev,

            fork_of=fork_of,

            copy_fork_permissions=copy_fork_permissions,

            copy_group_permissions=copy_group_permissions,