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

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

forks 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 23, 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 tg import request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPFound

import kallithea.lib.helpers as h

from kallithea.config.routing import url

from kallithea.lib.auth import HasPermissionAny, HasPermissionAnyDecorator, HasRepoPermissionLevel, HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseRepoController, render

from kallithea.lib.page import Page

from kallithea.lib.utils2 import safe_int

from kallithea.model.db import Repository, Ui, User, UserFollowing

from kallithea.model.forms import RepoForkForm

from kallithea.model.repo import RepoModel

from kallithea.model.scm import AvailableRepoGroupChoices, ScmModel

log = logging.getLogger(__name__)

class ForksController(BaseRepoController):

    def __load_defaults(self):

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

            repo_group_perm_level = 'write'

        else:

            repo_group_perm_level = 'admin'

        c.repo_groups = AvailableRepoGroupChoices(['hg.create.repository'], repo_group_perm_level)

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

        c.can_update = Ui.get_by_key('hooks', Ui.HOOK_UPDATE).ui_active

    def __load_data(self):

        """

        Load defaults settings for edit, and update

        """

        self.__load_defaults()

        c.repo_info = c.db_repo

        repo = c.db_repo.scm_instance

        if c.repo_info is None:

            h.not_mapped_error(c.repo_name)

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

        c.default_user_id = User.get_default_user().user_id

        c.in_public_journal = UserFollowing.query() \

            .filter(UserFollowing.user_id == c.default_user_id) \

            .filter(UserFollowing.follows_repository == c.repo_info).scalar()

        if c.repo_info.stats:

        else:

            last_rev = 0

        c.stats_revision = last_rev

        c.repo_last_rev = repo.count() if repo.revisions else 0

        if last_rev == 0 or c.repo_last_rev == 0:

            c.stats_percentage = 0

        else:

            c.stats_percentage = '%.2f' % ((float((last_rev)) /

                                            c.repo_last_rev) * 100)

        defaults = RepoModel()._get_defaults(c.repo_name)

        # alter the description to indicate a fork

        defaults['description'] = ('fork of repository: %s \n%s'

                                   % (defaults['repo_name'],

                                      defaults['description']))

        # add suffix to fork

        defaults['repo_name'] = '%s-fork' % defaults['repo_name']

        return defaults

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def forks(self, repo_name):

        p = safe_int(request.GET.get('page'), 1)

        repo_id = c.db_repo.repo_id

        d = []

        for r in Repository.get_repo_forks(repo_id):

            if not HasRepoPermissionLevel('read')(r.repo_name, 'get forks check'):

                continue

            d.append(r)

        c.forks_pager = Page(d, page=p, items_per_page=20)

        if request.environ.get('HTTP_X_PARTIAL_XHR'):

            return render('/forks/forks_data.html')

        return render('/forks/forks.html')

    @LoginRequired()

    @HasPermissionAnyDecorator('hg.admin', 'hg.fork.repository')

    @HasRepoPermissionLevelDecorator('read')

    def fork(self, repo_name):

        c.repo_info = Repository.get_by_repo_name(repo_name)

        if not c.repo_info:

            h.not_mapped_error(repo_name)

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

        defaults = self.__load_data()

        return htmlfill.render(

            render('forks/fork.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    @LoginRequired()

    @HasPermissionAnyDecorator('hg.admin', 'hg.fork.repository')

    @HasRepoPermissionLevelDecorator('read')

    def fork_create(self, repo_name):

        self.__load_defaults()

        c.repo_info = Repository.get_by_repo_name(repo_name)

        _form = RepoForkForm(old_data={'repo_type': c.repo_info.repo_type},

                             repo_groups=c.repo_groups,

                             landing_revs=c.landing_revs_choices)()

        form_result = {}

        task_id = None

        try:

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

            # an approximation that is better than nothing

            if not Ui.get_by_key('hooks', Ui.HOOK_UPDATE).ui_active:

                form_result['update_after_clone'] = False

            # create fork is done sometimes async on celery, db transaction

            # management is handled there.

            task = RepoModel().create_fork(form_result, request.authuser.user_id)

            task_id = task.task_id

        except formencode.Invalid as errors:

            return htmlfill.render(

                render('forks/fork.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())

            h.flash(_('An error occurred during repository forking %s') %

                    repo_name, category='error')

        raise HTTPFound(location=h.url('repo_creating_home',

                              repo_name=form_result['repo_name_full'],

                              task_id=task_id))

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

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

Home 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: Feb 18, 2010

:author: marcink

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

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

"""

import logging

from sqlalchemy import or_

from tg import request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPBadRequest

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

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

from kallithea.lib.utils import conditional_cache

from kallithea.model.db import RepoGroup, Repository, User, UserGroup

from kallithea.model.repo import RepoModel

from kallithea.model.scm import UserGroupList

log = logging.getLogger(__name__)

class HomeController(BaseController):

    def about(self):

        return render('/about.html')

    @LoginRequired(allow_default_user=True)

    def index(self):

        c.group = None

        repo_groups_list = self.scm_model.get_repo_groups()

        repos_list = Repository.query(sorted=True).filter_by(group=None).all()

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

                                               repo_groups_list=repo_groups_list,

                                               short_name=True)

        return render('/index.html')

    @LoginRequired(allow_default_user=True)

    @jsonify

    def repo_switcher_data(self):

        # wrapper for conditional cache

        def _c():

            log.debug('generating switcher repo/groups list')

            all_repos = Repository.query(sorted=True).all()

            repo_iter = self.scm_model.get_repos(all_repos)

            all_groups = RepoGroup.query(sorted=True).all()

            repo_groups_iter = self.scm_model.get_repo_groups(all_groups)

            res = [{

                    'text': _('Groups'),

                    'children': [

                       {'id': obj.group_name,

                        'text': obj.group_name,

                        'type': 'group',

                        'obj': {}}

                       for obj in repo_groups_iter

                    ],

                   },

                   {

                    'text': _('Repositories'),

                    'children': [

                       {'id': obj.repo_name,

                        'text': obj.repo_name,

                        'type': 'repo',

                        'obj': obj.get_dict()}

                       for obj in repo_iter

                    ],

                   }]

            data = {

                'more': False,

                'results': res,

            }

            return data

        if request.is_xhr:

            condition = False

            compute = conditional_cache('short_term', 'cache_desc',

                                        condition=condition, func=_c)

            return compute()

        else:

            raise HTTPBadRequest()

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    @jsonify

    def repo_refs_data(self, repo_name):

        repo = Repository.get_by_repo_name(repo_name).scm_instance

        res = []

        _branches = repo.branches.items()

        if _branches:

            res.append({

                'text': _('Branch'),

                'children': [{'id': rev, 'text': name, 'type': 'branch'} for name, rev in _branches]

            })

        _closed_branches = repo.closed_branches.items()

        if _closed_branches:

            res.append({

                'text': _('Closed Branches'),

                'children': [{'id': rev, 'text': name, 'type': 'closed-branch'} for name, rev in _closed_branches]

            })

        _tags = repo.tags.items()

        if _tags:

            res.append({

                'text': _('Tag'),

                'children': [{'id': rev, 'text': name, 'type': 'tag'} for name, rev in _tags]

            })

        _bookmarks = repo.bookmarks.items()

        if _bookmarks:

            res.append({

                'text': _('Bookmark'),

                'children': [{'id': rev, 'text': name, 'type': 'book'} for name, rev in _bookmarks]

            })

        data = {

            'more': False,

            'results': res

        }

        return data

    @LoginRequired()

    @jsonify

    def users_and_groups_data(self):

        """

        Returns 'results' with a list of users and user groups.

        You can either use the 'key' GET parameter to get a user by providing

        the exact user key or you can use the 'query' parameter to

        search for users by user key, first name and last name.

        'types' defaults to just 'users' but can be set to 'users,groups' to

        get both users and groups.

        No more than 500 results (of each kind) will be returned.

        """

        types = request.GET.get('types', 'users').split(',')

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

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

        results = []

        if 'users' in types:

            user_list = []

            if key:

                u = User.get_by_username(key)

                if u:

                    user_list = [u]

            elif query:

                user_list = User.query() \

                    .filter(User.is_default_user == False) \

                    .filter(User.active == True) \

                    .filter(or_(

                    )) \

                    .order_by(User.username) \

                    .limit(500) \

                    .all()

            for u in user_list:

                results.append({

                    'type': 'user',

                    'id': u.user_id,

                    'nname': u.username,

                    'fname': u.name,

                    'lname': u.lastname,

                    'gravatar_lnk': h.gravatar_url(u.email, size=28, default='default'),

                    'gravatar_size': 14,

                })

        if 'groups' in types:

            grp_list = []

            if key:

                grp = UserGroup.get_by_group_name(key)

                if grp:

                    grp_list = [grp]

            elif query:

                grp_list = UserGroup.query() \

                    .filter(UserGroup.users_group_active == True) \

                    .order_by(UserGroup.users_group_name) \

                    .limit(500) \

                    .all()

            for g in UserGroupList(grp_list, perm_level='read'):

                results.append({

                    'type': 'group',

                    'id': g.users_group_id,

                    'grname': g.users_group_name,

                })

        return dict(results=results)