# -*- 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/>.

"""

kallithea.controllers.admin.repos

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

Repositories 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: 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 formencode

from formencode import htmlfill

from webob.exc import HTTPInternalServerError, HTTPForbidden, HTTPNotFound

from pylons import request, tmpl_context as c, url

from pylons.controllers.util import redirect

from pylons.i18n.translation import _

from sqlalchemy.sql.expression import func

from kallithea.lib import helpers as h

from kallithea.lib.auth import LoginRequired, HasPermissionAllDecorator, \

    HasRepoPermissionAllDecorator, NotAnonymous, HasPermissionAny, HasPermissionAll, \

    HasRepoGroupPermissionAny, HasRepoPermissionAnyDecorator

from kallithea.lib.base import BaseRepoController, render

from kallithea.lib.utils import action_logger, repo_name_slug, jsonify

from kallithea.lib.vcs import RepositoryError

from kallithea.model.meta import Session

from kallithea.model.db import User, Repository, UserFollowing, RepoGroup,\

    Setting, RepositoryField

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

from kallithea.model.repo import RepoModel

from kallithea.lib.compat import json

from kallithea.lib.exceptions import AttachedForksError

from kallithea.lib.utils2 import safe_int

log = logging.getLogger(__name__)

class ReposController(BaseRepoController):

    """

    REST Controller styled on the Atom Publishing Protocol"""

    # To properly map this controller, ensure your config/routing.py

    # file has a resource setup:

    #     map.resource('repo', 'repos')

    @LoginRequired()

    def __before__(self):

        super(ReposController, self).__before__()

    def _load_repo(self, repo_name):

        repo_obj = Repository.get_by_repo_name(repo_name)

        if repo_obj is None:

            h.not_mapped_error(repo_name)

            return redirect(url('repos'))

        return repo_obj

    def __load_defaults(self, repo=None):

        top_perms = ['hg.create.repository']

        repo_group_perms = ['group.admin']

        if HasPermissionAny('hg.create.write_on_repogroup.true')():

            repo_group_perms.append('group.write')

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

        c.repo_groups_choices = [rg[0] for rg in c.repo_groups]

        c.landing_revs_choices, c.landing_revs = ScmModel().get_repo_landing_revs(repo)

    def __load_data(self, repo_name=None):

        """

        Load defaults settings for edit, and update

        :param repo_name:

        """

        c.repo_info = self._load_repo(repo_name)

        self.__load_defaults(c.repo_info)

        defaults = RepoModel()._get_defaults(repo_name)

        defaults['clone_uri'] = c.repo_info.clone_uri_hidden # don't show password

        return defaults

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

        """GET /repos: All items in the collection"""

        # url('repos')

        _list = Repository.query()\

                        .order_by(func.lower(Repository.repo_name))\

                        .all()

        c.repos_list = RepoList(_list, perm_set=['repository.admin'])

        repos_data = RepoModel().get_repos_as_dict(repos_list=c.repos_list,

                                                   admin=True,

                                                   super_user_actions=True)

        #json used to render the grid

        c.data = json.dumps(repos_data)

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

    @NotAnonymous()

    def create(self):

        """

        POST /repos: Create a new item"""

        # url('repos')

        self.__load_defaults()

        form_result = {}

        task_id = None

        try:

            # CanWriteGroup validators checks permissions of this POST

            form_result = RepoForm(repo_groups=c.repo_groups_choices,

                                   landing_revs=c.landing_revs_choices)()\

                            .to_python(dict(request.POST))

            # create is done sometimes async on celery, db transaction

            # management is handled there.

            task = RepoModel().create(form_result, self.authuser.user_id)

            from celery.result import BaseAsyncResult

            if isinstance(task, BaseAsyncResult):

                task_id = task.task_id

        except formencode.Invalid, errors:

            log.info(errors)

            return htmlfill.render(

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

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                force_defaults=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            msg = (_('Error creating repository %s')

                   % form_result.get('repo_name'))

            h.flash(msg, category='error')

            return redirect(url('home'))

        return redirect(h.url('repo_creating_home',

                              repo_name=form_result['repo_name_full'],

                              task_id=task_id))

    @NotAnonymous()

    def create_repository(self):

        """GET /_admin/create_repository: Form to create a new item"""

        self.__load_defaults()

        if not c.repo_groups:

            raise HTTPForbidden

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

        ## apply the defaults from defaults page

        defaults = Setting.get_default_repo_settings(strip_prefix=True)

        if parent_group:

            prg = RepoGroup.get(parent_group)

            if prg is None or not any(rgc[0] == prg.group_id

                                      for rgc in c.repo_groups):

                raise HTTPForbidden

            defaults.update({'repo_group': parent_group})

        return htmlfill.render(

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

            defaults=defaults,

# -*- 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/>.

"""

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.

"""

from __future__ import with_statement

import os

import re

import time

import traceback

import logging

import cStringIO

import pkg_resources

from os.path import join as jn

from sqlalchemy import func

from pylons.i18n.translation import _

import kallithea

from kallithea.lib.vcs import get_backend

from kallithea.lib.vcs.exceptions import RepositoryError

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

from kallithea.lib.vcs.nodes import FileNode

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

from kallithea import BACKENDS

from kallithea.lib import helpers as h

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

    _set_extras

from kallithea.lib.auth import HasRepoPermissionAny, HasRepoGroupPermissionAny,\

from kallithea.lib.utils import get_filesystem_repos, make_ui, \

    action_logger

from kallithea.model import BaseModel

from kallithea.model.db import Repository, Ui, CacheInvalidation, \

    UserFollowing, UserLog, User, RepoGroup, PullRequest

from kallithea.lib.hooks import log_push_action

from kallithea.lib.exceptions import NonRelativePathError, IMCCommitError

log = logging.getLogger(__name__)

class UserTemp(object):

    def __init__(self, user_id):

        self.user_id = user_id

    def __repr__(self):

        return "<%s('id:%s')>" % (self.__class__.__name__, self.user_id)

class RepoTemp(object):

    def __init__(self, repo_id):

        self.repo_id = repo_id

    def __repr__(self):

        return "<%s('id:%s')>" % (self.__class__.__name__, self.repo_id)

class CachedRepoList(object):

    """

    Cached repo list. Uses super-fast in-memory cache after initialization.

    """

    def __init__(self, db_repo_list, repos_path, order_by=None, perm_set=None):

        self.db_repo_list = db_repo_list

        self.repos_path = repos_path

        self.order_by = order_by

        self.reversed = (order_by or '').startswith('-')

        if not perm_set:

            perm_set = ['repository.read', 'repository.write',

                        'repository.admin']

        self.perm_set = perm_set

    def __len__(self):

        return len(self.db_repo_list)

    def __repr__(self):

        return '<%s (%s)>' % (self.__class__.__name__, self.__len__())

    def __iter__(self):

        # pre-propagated valid_cache_keys to save executing select statements

        # for each repo

        valid_cache_keys = CacheInvalidation.get_valid_cache_keys()

        for dbr in self.db_repo_list:

            scmr = dbr.scm_instance_cached(valid_cache_keys)

            # check permission at this level

            if not HasRepoPermissionAny(

                *self.perm_set)(dbr.repo_name, 'get repo check'):

                continue

            try:

                last_change = scmr.last_change

                tip = h.get_changeset_safe(scmr, 'tip')

            except Exception:

                log.error(

                    '%s this repository is present in database but it '

                    'cannot be created as an scm instance, org_exc:%s'

                    % (dbr.repo_name, traceback.format_exc())

                )

                continue

            tmp_d = {}

            tmp_d['name'] = dbr.repo_name

            tmp_d['name_sort'] = tmp_d['name'].lower()

            tmp_d['raw_name'] = tmp_d['name'].lower()

            tmp_d['description'] = dbr.description

            tmp_d['description_sort'] = tmp_d['description'].lower()

            tmp_d['last_change'] = last_change

            tmp_d['last_change_sort'] = time.mktime(last_change.timetuple())

            tmp_d['tip'] = tip.raw_id

            tmp_d['tip_sort'] = tip.revision

            tmp_d['rev'] = tip.revision

            tmp_d['contact'] = dbr.user.full_contact

            tmp_d['contact_sort'] = tmp_d['contact']

            tmp_d['owner_sort'] = tmp_d['contact']

            tmp_d['repo_archives'] = list(scmr._get_archives())

            tmp_d['last_msg'] = tip.message

            tmp_d['author'] = tip.author

            tmp_d['dbrepo'] = dbr.get_dict()

            tmp_d['dbrepo_fork'] = dbr.fork.get_dict() if dbr.fork else {}

            yield tmp_d

class SimpleCachedRepoList(CachedRepoList):

    """

    Lighter version of CachedRepoList without the scm initialisation

                              revisions=[tip.raw_id])

        return tip

    def get_unread_journal(self):

        return self.sa.query(UserLog).count()

    def get_repo_landing_revs(self, repo=None):

        """

        Generates select option with tags branches and bookmarks (for hg only)

        grouped by type

        :param repo:

        """

        hist_l = []

        choices = []

        repo = self.__get_repo(repo)

        hist_l.append(['rev:tip', _('latest tip')])

        choices.append('rev:tip')

        if not repo:

            return choices, hist_l

        repo = repo.scm_instance

        branches_group = ([(u'branch:%s' % k, k) for k, v in

                           repo.branches.iteritems()], _("Branches"))

        hist_l.append(branches_group)

        choices.extend([x[0] for x in branches_group[0]])

        if repo.alias == 'hg':

            bookmarks_group = ([(u'book:%s' % k, k) for k, v in

                                repo.bookmarks.iteritems()], _("Bookmarks"))

            hist_l.append(bookmarks_group)

            choices.extend([x[0] for x in bookmarks_group[0]])

        tags_group = ([(u'tag:%s' % k, k) for k, v in

                       repo.tags.iteritems()], _("Tags"))

        hist_l.append(tags_group)

        choices.extend([x[0] for x in tags_group[0]])

        return choices, hist_l

    def install_git_hook(self, repo, force_create=False):

        """

        Creates a kallithea hook inside a git repository

        :param repo: Instance of VCS repo

        :param force_create: Create even if same name hook exists

        """

        loc = jn(repo.path, 'hooks')

        if not repo.bare:

            loc = jn(repo.path, '.git', 'hooks')

        if not os.path.isdir(loc):

            os.makedirs(loc)

        tmpl_post = pkg_resources.resource_string(

            'kallithea', jn('config', 'post_receive_tmpl.py')

        )

        tmpl_pre = pkg_resources.resource_string(

            'kallithea', jn('config', 'pre_receive_tmpl.py')

        )

        for h_type, tmpl in [('pre', tmpl_pre), ('post', tmpl_post)]:

            _hook_file = jn(loc, '%s-receive' % h_type)

            has_hook = False

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

            if os.path.exists(_hook_file):

                # let's take a look at this hook, maybe it's kallithea ?

                log.debug('hook exists, checking if it is from kallithea')

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

                    data = f.read()

                    matches = re.compile(r'(?:%s)\s*=\s*(.*)'

                                         % 'KALLITHEA_HOOK_VER').search(data)

                    if matches:

                        try:

                            ver = matches.groups()[0]

                            log.debug('got %s it is kallithea' % (ver))

                            has_hook = True

                        except Exception:

                            log.error(traceback.format_exc())

            else:

                # there is no hook in this dir, so we want to create one

                has_hook = True

            if has_hook or force_create:

                log.debug('writing %s hook file !' % (h_type,))

                try:

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

                        tmpl = tmpl.replace('_TMPL_', kallithea.__version__)

                        f.write(tmpl)

                    os.chmod(_hook_file, 0755)

                except IOError, e:

                    log.error('error writing %s: %s' % (_hook_file, e))

            else:

                log.debug('skipping writing hook file')