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

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

pull requests controller for Kallithea for initializing pull requests

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: May 7, 2012

:author: marcink

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

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

"""

import logging

import traceback

import formencode

from webob.exc import HTTPNotFound, HTTPForbidden

from collections import defaultdict

from itertools import groupby

from pylons import request, tmpl_context as c, url

from pylons.controllers.util import redirect

from pylons.i18n.translation import _

from kallithea.lib.compat import json

from kallithea.lib.base import BaseRepoController, render

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

    NotAnonymous

from kallithea.lib.helpers import Page

from kallithea.lib import helpers as h

from kallithea.lib import diffs

from kallithea.lib.utils import action_logger, jsonify

from kallithea.lib.vcs.utils import safe_str

from kallithea.lib.vcs.exceptions import EmptyRepositoryError

from kallithea.lib.diffs import LimitedDiffContainer

from kallithea.model.db import  PullRequest, ChangesetStatus, ChangesetComment

from kallithea.model.pull_request import PullRequestModel

from kallithea.model.meta import Session

from kallithea.model.repo import RepoModel

from kallithea.model.comment import ChangesetCommentsModel

from kallithea.model.changeset_status import ChangesetStatusModel

from kallithea.model.forms import PullRequestForm

from kallithea.lib.utils2 import safe_int

log = logging.getLogger(__name__)

class PullrequestsController(BaseRepoController):

    def __before__(self):

        super(PullrequestsController, self).__before__()

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.user_groups_array = repo_model.get_user_groups_js()

    def _get_repo_refs(self, repo, rev=None, branch=None, branch_rev=None):

        """return a structure with repo's interesting changesets, suitable for

        the selectors in pullrequest.html

        rev: a revision that must be in the list somehow and selected by default

        branch: a branch that must be in the list and selected by default - even if closed

        branch_rev: a revision of which peers should be preferred and available."""

        # list named branches that has been merged to this named branch - it should probably merge back

        peers = []

        if rev:

            rev = safe_str(rev)

        if branch:

            branch = safe_str(branch)

        if branch_rev:

            branch_rev = safe_str(branch_rev)

            # not restricting to merge() would also get branch point and be better

            # (especially because it would get the branch point) ... but is currently too expensive

            otherbranches = {}

            for i in repo._repo.revs(

                "sort(parents(branch(id(%s)) and merge()) - branch(id(%s)))",

                branch_rev, branch_rev):

                cs = repo.get_changeset(i)

                otherbranches[cs.branch] = cs.raw_id

            for abranch, node in otherbranches.iteritems():

                selected = 'branch:%s:%s' % (abranch, node)

                peers.append((selected, abranch))

        selected = None

        branches = []

        for abranch, branchrev in repo.branches.iteritems():

            n = 'branch:%s:%s' % (abranch, branchrev)

            branches.append((n, abranch))

            if rev == branchrev:

                selected = n

            if branch == abranch:

                selected = n

                branch = None

        if branch:  # branch not in list - it is probably closed

            revs = repo._repo.revs('max(branch(%s))', branch)

            if revs:

                cs = repo.get_changeset(revs[0])

                selected = 'branch:%s:%s' % (branch, cs.raw_id)

                branches.append((selected, branch))

        bookmarks = []

        for bookmark, bookmarkrev in repo.bookmarks.iteritems():

            n = 'book:%s:%s' % (bookmark, bookmarkrev)

            bookmarks.append((n, bookmark))

            if rev == bookmarkrev:

                selected = n

        tags = []

        for tag, tagrev in repo.tags.iteritems():

            n = 'tag:%s:%s' % (tag, tagrev)

            tags.append((n, tag))

            if rev == tagrev and tag != 'tip':  # tip is not a real tag - and its branch is better

                selected = n

        # prio 1: rev was selected as existing entry above

        # prio 2: create special entry for rev; rev _must_ be used

        specials = []

        if rev and selected is None:

            selected = 'rev:%s:%s' % (rev, rev)

            specials = [(selected, '%s: %s' % (_("Changeset"), rev[:12]))]

        # prio 3: most recent peer branch

        if peers and not selected:

            selected = peers[0][0][0]

        # prio 4: tip revision

        if not selected:

            if h.is_hg(repo):

                selected = 'tag:tip:%s' % repo.tags['tip']

            else:

                if 'master' in repo.branches:

                    selected = 'branch:master:%s' % repo.branches['master']

                else:

                    k, v = repo.branches.items()[0]

                    selected = 'branch:%s:%s' % (k, v)

        groups = [(specials, _("Special")),

                  (peers, _("Peer branches")),

                  (bookmarks, _("Bookmarks")),

                  (branches, _("Branches")),

                  (tags, _("Tags")),

                  ]

        return [g for g in groups if g[0]], selected

    def _get_is_allowed_change_status(self, pull_request):

        owner = self.authuser.user_id == pull_request.user_id

        reviewer = self.authuser.user_id in [x.user_id for x in

                                                   pull_request.reviewers]

        return self.authuser.admin or owner or reviewer

    def _load_compare_data(self, pull_request, enable_comments=True):

        """

        Load context data needed for generating compare diff

        :param pull_request:

        """

        org_repo = pull_request.org_repo

        (org_ref_type,

         org_ref_name,

         org_ref_rev) = pull_request.org_ref.split(':')

        other_repo = org_repo

        (other_ref_type,

         other_ref_name,

         other_ref_rev) = pull_request.other_ref.split(':')

        # despite opening revisions for bookmarks/branches/tags, we always

        # convert this to rev to prevent changes after bookmark or branch change

        org_ref = ('rev', org_ref_rev)

        other_ref = ('rev', other_ref_rev)

        c.org_repo = org_repo

        c.other_repo = other_repo

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

        c.cs_ranges = [org_repo.get_changeset(x) for x in pull_request.revisions]

        c.statuses = org_repo.statuses([x.raw_id for x in c.cs_ranges])

        c.org_ref = org_ref[1]

        c.org_ref_type = org_ref[0]

        c.other_ref = other_ref[1]

        c.other_ref_type = other_ref[0]

        diff_limit = self.cut_off_limit if not fulldiff else None

        # we swap org/other ref since we run a simple diff on one repo

        log.debug('running diff between %s and %s in %s'

                  % (other_ref, org_ref, org_repo.scm_instance.path))

        txtdiff = org_repo.scm_instance.get_diff(rev1=safe_str(other_ref[1]), rev2=safe_str(org_ref[1]))

        diff_processor = diffs.DiffProcessor(txtdiff or '', format='gitdiff',

                                             diff_limit=diff_limit)

        _parsed = diff_processor.prepare()

        c.limited_diff = False

        if isinstance(_parsed, LimitedDiffContainer):

            c.limited_diff = True

        c.files = []

        c.changes = {}

        c.lines_added = 0

        c.lines_deleted = 0

        for f in _parsed:

            st = f['stats']

            c.lines_added += st['added']

            c.lines_deleted += st['deleted']

            fid = h.FID('', f['filename'])

            c.files.append([fid, f['operation'], f['filename'], f['stats']])

            htmldiff = diff_processor.as_html(enable_comments=enable_comments,

                                              parsed_lines=[f])

            c.changes[fid] = [f['operation'], f['filename'], htmldiff]

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def show_all(self, repo_name):

        c.from_ = request.GET.get('from_') or ''

        c.closed = request.GET.get('closed') or ''

        c.pull_requests = PullRequestModel().get_all(repo_name, from_=c.from_, closed=c.closed)

        c.repo_name = repo_name

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

        c.pullrequests_pager = Page(c.pull_requests, page=p, items_per_page=10)

        c.pullrequest_data = render('/pullrequests/pullrequest_data.html')

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

            return c.pullrequest_data

        return render('/pullrequests/pullrequest_show_all.html')

    @LoginRequired()

    @NotAnonymous()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def index(self):

        org_repo = c.db_repo

        try:

            org_repo.scm_instance.get_changeset()

        except EmptyRepositoryError, e:

            h.flash(h.literal(_('There are no changesets yet')),

                    category='warning')

            redirect(url('summary_home', repo_name=org_repo.repo_name))

        org_rev = request.GET.get('rev_end')

        # rev_start is not directly useful - its parent could however be used

        # as default for other and thus give a simple compare view

        #other_rev = request.POST.get('rev_start')

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

        c.org_repos = []

        c.org_repos.append((org_repo.repo_name, org_repo.repo_name))

        c.default_org_repo = org_repo.repo_name

        c.org_refs, c.default_org_ref = self._get_repo_refs(org_repo.scm_instance, rev=org_rev, branch=branch)

        c.other_repos = []

        other_repos_info = {}

        def add_other_repo(repo, branch_rev=None):

            if repo.repo_name in other_repos_info: # shouldn't happen

                return

            c.other_repos.append((repo.repo_name, repo.repo_name))

            other_refs, selected_other_ref = self._get_repo_refs(repo.scm_instance, branch_rev=branch_rev)

            other_repos_info[repo.repo_name] = {

                'user': dict(user_id=repo.user.user_id,

                             username=repo.user.username,

                             firstname=repo.user.firstname,

                             lastname=repo.user.lastname,

                             gravatar_link=h.gravatar_url(repo.user.email, 14)),

                'description': repo.description.split('\n', 1)[0],

                'revs': h.select('other_ref', selected_other_ref, other_refs, class_='refs')

            }

        # add org repo to other so we can open pull request against peer branches on itself

        add_other_repo(org_repo, branch_rev=org_rev)

        c.default_other_repo = org_repo.repo_name

        # gather forks and add to this list ... even though it is rare to

        # request forks to pull from their parent

        for fork in org_repo.forks:

            add_other_repo(fork)

        # add parents of this fork also, but only if it's not empty

        if org_repo.parent and org_repo.parent.scm_instance.revisions:

            add_other_repo(org_repo.parent)

            c.default_other_repo = org_repo.parent.repo_name

        c.default_other_repo_info = other_repos_info[c.default_other_repo]

        c.other_repos_info = json.dumps(other_repos_info)

        return render('/pullrequests/pullrequest.html')

    @LoginRequired()

    @NotAnonymous()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def create(self, repo_name):

        repo = RepoModel()._get_repo(repo_name)

        try:

            _form = PullRequestForm(repo.repo_id)().to_python(request.POST)

        except formencode.Invalid, errors:

            log.error(traceback.format_exc())

            if errors.error_dict.get('revisions'):

                msg = 'Revisions: %s' % errors.error_dict['revisions']

            elif errors.error_dict.get('pullrequest_title'):

                msg = _('Pull request requires a title with min. 3 chars')

            else:

                msg = _('Error creating pull request: %s') % errors.msg

            h.flash(msg, 'error')

            return redirect(url('pullrequest_home', repo_name=repo_name)) ## would rather just go back to form ...

        org_repo = _form['org_repo']

        org_ref = _form['org_ref'] # will end with merge_rev but have symbolic name

        other_repo = _form['other_repo']

        other_ref = 'rev:ancestor:%s' % _form['ancestor_rev'] # could be calculated from other_ref ...

        revisions = [x for x in reversed(_form['revisions'])]

        reviewers = _form['review_members']

        title = _form['pullrequest_title']

        if not title:

            title = '%s#%s to %s' % (org_repo, org_ref.split(':', 2)[1], other_repo)

        description = _form['pullrequest_desc']

        try:

            pull_request = PullRequestModel().create(

                self.authuser.user_id, org_repo, org_ref, other_repo,

                other_ref, revisions, reviewers, title, description

            )

            Session().commit()

            h.flash(_('Successfully opened new pull request'),

                    category='success')

        except Exception:

                    category='error')

            log.error(traceback.format_exc())

            return redirect(url('pullrequest_home', repo_name=repo_name))

        return redirect(url('pullrequest_show', repo_name=other_repo,

                            pull_request_id=pull_request.pull_request_id))

    @LoginRequired()

    @NotAnonymous()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    @jsonify

    def update(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        if pull_request.is_closed():

            raise HTTPForbidden()

        #only owner or admin can update it

        owner = pull_request.author.user_id == c.authuser.user_id

        repo_admin = h.HasRepoPermissionAny('repository.admin')(c.repo_name)

        if h.HasPermissionAny('hg.admin') or repo_admin or owner:

            reviewers_ids = map(int, filter(lambda v: v not in [None, ''],

                request.POST.get('reviewers_ids', '').split(',')))

            PullRequestModel().update_reviewers(pull_request_id, reviewers_ids)

            Session().commit()

            return True

        raise HTTPForbidden()

    @LoginRequired()

    @NotAnonymous()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    @jsonify

    def delete(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        #only owner can delete it !

        if pull_request.author.user_id == c.authuser.user_id:

            PullRequestModel().delete(pull_request)

            Session().commit()

            h.flash(_('Successfully deleted pull request'),

                    category='success')

            return redirect(url('my_account_pullrequests'))

        raise HTTPForbidden()

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def show(self, repo_name, pull_request_id):

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.user_groups_array = repo_model.get_user_groups_js()

        c.pull_request = PullRequest.get_or_404(pull_request_id)

        c.allowed_to_change_status = self._get_is_allowed_change_status(c.pull_request)

        cc_model = ChangesetCommentsModel()

        cs_model = ChangesetStatusModel()

        _cs_statuses = cs_model.get_statuses(c.pull_request.org_repo,

                                            pull_request=c.pull_request,

                                            with_revisions=True)

        cs_statuses = defaultdict(list)

        for st in _cs_statuses:

            cs_statuses[st.author.username] += [st]

        c.pull_request_reviewers = []

        c.pull_request_pending_reviewers = []

        for o in c.pull_request.reviewers:

            st = cs_statuses.get(o.user.username, None)

            if st:

                sorter = lambda k: k.version

                st = [(x, list(y)[0])

                      for x, y in (groupby(sorted(st, key=sorter), sorter))]

            else:

                c.pull_request_pending_reviewers.append(o.user)

            c.pull_request_reviewers.append([o.user, st])

        # pull_requests repo_name we opened it against

        # ie. other_repo must match

        if repo_name != c.pull_request.other_repo.repo_name:

            raise HTTPNotFound

        # load compare data into template context

        enable_comments = not c.pull_request.is_closed()

        self._load_compare_data(c.pull_request, enable_comments=enable_comments)

        # inline comments

        c.inline_cnt = 0

        c.inline_comments = cc_model.get_inline_comments(

                                c.db_repo.repo_id,

                                pull_request=pull_request_id)

        # count inline comments

        for __, lines in c.inline_comments:

            for comments in lines.values():

                c.inline_cnt += len(comments)

        # comments

        c.comments = cc_model.get_comments(c.db_repo.repo_id,

                                           pull_request=pull_request_id)

        # (badly named) pull-request status calculation based on reviewer votes

        c.current_changeset_status = cs_model.calculate_status(

                                        c.pull_request_reviewers,

                                         )

        c.changeset_statuses = ChangesetStatus.STATUSES

        c.as_form = False

        c.ancestor = None # there is one - but right here we don't know which

        return render('/pullrequests/pullrequest_show.html')

    @LoginRequired()

    @NotAnonymous()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    @jsonify

    def comment(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        if pull_request.is_closed():

            raise HTTPForbidden()

        status = request.POST.get('changeset_status')

        change_status = request.POST.get('change_changeset_status')

        text = request.POST.get('text')

        close_pr = request.POST.get('save_close')

        allowed_to_change_status = self._get_is_allowed_change_status(pull_request)

        if status and change_status and allowed_to_change_status:

            _def = (_('Status change -> %s')

                            % ChangesetStatus.get_status_lbl(status))

            if close_pr:

                _def = _('Closing with') + ' ' + _def

            text = text or _def

        comm = ChangesetCommentsModel().create(

            text=text,

            repo=c.db_repo.repo_id,

            user=c.authuser.user_id,

            pull_request=pull_request_id,

            f_path=request.POST.get('f_path'),

            line_no=request.POST.get('line'),

            status_change=(ChangesetStatus.get_status_lbl(status)

                           if status and change_status

                           and allowed_to_change_status else None),

            closing_pr=close_pr

        )

        action_logger(self.authuser,

                      'user_commented_pull_request:%s' % pull_request_id,

                      c.db_repo, self.ip_addr, self.sa)

        if allowed_to_change_status:

            # get status if set !

            if status and change_status:

                ChangesetStatusModel().set_status(

                    c.db_repo.repo_id,

                    status,

                    c.authuser.user_id,

                    comm,

                    pull_request=pull_request_id

                )

            if close_pr:

                if status in ['rejected', 'approved']:

                    PullRequestModel().close_pull_request(pull_request_id)

                    action_logger(self.authuser,

                              'user_closed_pull_request:%s' % pull_request_id,

                              c.db_repo, self.ip_addr, self.sa)

                else:

                    h.flash(_('Closing pull request on other statuses than '

                              'rejected or approved forbidden'),

                            category='warning')

        Session().commit()

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

            return redirect(h.url('pullrequest_show', repo_name=repo_name,

                                  pull_request_id=pull_request_id))

        data = {

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

        }

        if comm:

            c.co = comm

            data.update(comm.get_dict())

            data.update({'rendered_text':

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

        return data

    @LoginRequired()

    @NotAnonymous()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    @jsonify

    def delete_comment(self, repo_name, comment_id):

        co = ChangesetComment.get(comment_id)

        if co.pull_request.is_closed():

            #don't allow deleting comments on closed pull request

            raise HTTPForbidden()

        owner = co.author.user_id == c.authuser.user_id

        repo_admin = h.HasRepoPermissionAny('repository.admin')(c.repo_name)

        if h.HasPermissionAny('hg.admin') or repo_admin or owner:

            ChangesetCommentsModel().delete(comment=co)

            Session().commit()

            return True

        else:

            raise HTTPForbidden()

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

import time

import logging

import datetime

import traceback

import hashlib

import collections

import functools

from sqlalchemy import *

from sqlalchemy.ext.hybrid import hybrid_property

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

from sqlalchemy.exc import DatabaseError

from beaker.cache import cache_region, region_invalidate

from webob.exc import HTTPNotFound

from pylons.i18n.translation import lazy_ugettext as _

from kallithea import DB_PREFIX

from kallithea.lib.vcs import get_backend

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

from kallithea.lib.vcs.exceptions import VCSError

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

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

from kallithea.lib.utils2 import str2bool, safe_str, get_changeset_safe, \

    safe_unicode, remove_prefix, time_to_datetime, aslist, Optional, safe_int, \

    get_clone_url

from kallithea.lib.compat import json

from kallithea.lib.caching_query import FromCache

from kallithea.model.meta import Base, Session

URL_SEP = '/'

log = logging.getLogger(__name__)

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

# BASE CLASSES

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

_hash_key = lambda k: hashlib.md5(safe_str(k)).hexdigest()

class BaseModel(object):

    """

    Base Model for all classess

    """

    @classmethod

    def _get_keys(cls):

        """return column names for this model """

        return class_mapper(cls).c.keys()

    def get_dict(self):

        """

        return dict with keys and values corresponding

        to this model data """

        d = {}

        for k in self._get_keys():

            d[k] = getattr(self, k)

        # also use __json__() if present to get additional fields

        _json_attr = getattr(self, '__json__', None)

        if _json_attr:

            # update with attributes from __json__

            if callable(_json_attr):

                _json_attr = _json_attr()

            for k, val in _json_attr.iteritems():

                d[k] = val

        return d

    def get_appstruct(self):

        """return list with keys and values tupples corresponding

        to this model data """

        l = []

        for k in self._get_keys():

            l.append((k, getattr(self, k),))

        return l

    def populate_obj(self, populate_dict):

        """populate model with data from given populate_dict"""

        for k in self._get_keys():

            if k in populate_dict:

                setattr(self, k, populate_dict[k])

    @classmethod

    def query(cls):

        return Session().query(cls)

    @classmethod

    def get(cls, id_):

        if id_:

            return cls.query().get(id_)

    @classmethod

    def get_or_404(cls, id_):

        try:

            id_ = int(id_)

        except (TypeError, ValueError):

            raise HTTPNotFound

        res = cls.query().get(id_)

        if not res:

            raise HTTPNotFound

        return res

    @classmethod

    def getAll(cls):

        # deprecated and left for backward compatibility

        return cls.get_all()

    @classmethod

    def get_all(cls):

        return cls.query().all()

    @classmethod

    def delete(cls, id_):

        obj = cls.query().get(id_)

        Session().delete(obj)

    def __repr__(self):

        if hasattr(self, '__unicode__'):

            # python repr needs to return str

            try:

                return safe_str(self.__unicode__())

            except UnicodeDecodeError:

                pass

        return '<DB:%s>' % (self.__class__.__name__)

class Setting(Base, BaseModel):

    __tablename__ = DB_PREFIX + 'settings'

    __table_args__ = (

        UniqueConstraint('app_settings_name'),

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

    )

    SETTINGS_TYPES = {

        'str': safe_str,

        'int': safe_int,

        'unicode': safe_unicode,

        'bool': str2bool,

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

    }

    DEFAULT_UPDATE_URL = ''

    app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    app_settings_name = Column("app_settings_name", String(255, convert_unicode=False), nullable=True, unique=None, default=None)

    _app_settings_value = Column("app_settings_value", String(4096, convert_unicode=False), nullable=True, unique=None, default=None)

    _app_settings_type = Column("app_settings_type", String(255, convert_unicode=False), nullable=True, unique=None, default=None)

    def __init__(self, key='', val='', type='unicode'):

        self.app_settings_name = key

        self.app_settings_value = val

        self.app_settings_type = type

    @validates('_app_settings_value')

    def validate_settings_value(self, key, val):

        assert type(val) == unicode

        return val

    @hybrid_property

    def app_settings_value(self):

        v = self._app_settings_value

        _type = self.app_settings_type

        converter = self.SETTINGS_TYPES.get(_type) or self.SETTINGS_TYPES['unicode']

        return converter(v)

    @app_settings_value.setter

    def app_settings_value(self, val):

        """

        Setter that will always make sure we use unicode in app_settings_value

        :param val:

        """

        self._app_settings_value = safe_unicode(val)

    @hybrid_property

    def app_settings_type(self):

        return self._app_settings_type

    @app_settings_type.setter

    def app_settings_type(self, val):

        if val not in self.SETTINGS_TYPES:

            raise Exception('type must be one of %s got %s'

                            % (self.SETTINGS_TYPES.keys(), val))

        self._app_settings_type = val

    def __unicode__(self):

        return u"<%s('%s:%s[%s]')>" % (

            self.__class__.__name__,

            self.app_settings_name, self.app_settings_value, self.app_settings_type

        )

    @classmethod

    def get_by_name(cls, key):

        return cls.query()\

            .filter(cls.app_settings_name == key).scalar()

    @classmethod

    def get_by_name_or_create(cls, key, val='', type='unicode'):

        res = cls.get_by_name(key)

        if not res:

            res = cls(key, val, type)

        return res

    @classmethod

    def create_or_update(cls, key, val=Optional(''), type=Optional('unicode')):

        """

        Creates or updates Kallithea setting. If updates is triggered it will only

        update parameters that are explicityl set Optional instance will be skipped

        :param key:

        :param val:

        :param type:

        :return:

        """

        res = cls.get_by_name(key)

        if not res:

            val = Optional.extract(val)

            type = Optional.extract(type)

            res = cls(key, val, type)

        else:

            res.app_settings_name = key

            if not isinstance(val, Optional):

                # update if set

                res.app_settings_value = val

            if not isinstance(type, Optional):

                # update if set

                res.app_settings_type = type

        return res

    @classmethod

    def get_app_settings(cls, cache=False):

        ret = cls.query()

        if cache:

            ret = ret.options(FromCache("sql_cache_short", "get_hg_settings"))

        if not ret:

            raise Exception('Could not get application settings !')

        settings = {}

        for each in ret:

            settings[each.app_settings_name] = \

                each.app_settings_value

        return settings

    @classmethod

    def get_auth_plugins(cls, cache=False):

        auth_plugins = cls.get_by_name("auth_plugins").app_settings_value

        return auth_plugins

    @classmethod

    def get_auth_settings(cls, cache=False):

        ret = cls.query()\

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

        fd = {}

        for row in ret:

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

        return fd

    @classmethod

    def get_default_repo_settings(cls, cache=False, 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})