def _load_changelog_summary():

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

    size = safe_int(request.GET.get('size'), 10)

    def url_generator(**kw):

        return url('changelog_summary_home',

                   repo_name=c.db_repo.repo_name, size=size, **kw)

    collection = c.db_repo_scm_instance

    c.repo_changesets = RepoPage(collection, page=p,

                                 items_per_page=size,

                                 url=url_generator)

    page_revisions = [x.raw_id for x in list(c.repo_changesets)]

    c.comments = c.db_repo.get_comments(page_revisions)

    c.statuses = c.db_repo.statuses(page_revisions)

class ChangelogController(BaseRepoController):

    def __before__(self):

        super(ChangelogController, self).__before__()

        c.affected_files_cut_off = 60

        """

        :param rev: revision to fetch

        :param repo: repo instance

        """

        try:

            return c.db_repo_scm_instance.get_changeset(rev)

        except EmptyRepositoryError, e:

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

        except RepositoryError, e:

            log.error(traceback.format_exc())

    @LoginRequired()

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

                                   'repository.admin')

    def index(self, repo_name, revision=None, f_path=None):

        limit = 100

        default = 20

        if request.GET.get('size'):

            c.size = max(min(safe_int(request.GET.get('size')), limit), 1)

            session['changelog_size'] = c.size

            session.save()

        else:

            c.size = int(session.get('changelog_size', default))

        # min size must be 1

        c.size = max(c.size, 1)

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

        branch_name = request.GET.get('branch', None)

        if (branch_name and

            branch_name not in c.db_repo_scm_instance.branches and

            branch_name not in c.db_repo_scm_instance.closed_branches and

            not revision):

            return redirect(url('changelog_file_home', repo_name=c.repo_name,

                                    revision=branch_name, f_path=f_path or ''))

        if revision == 'tip':

            revision = None

        c.changelog_for_path = f_path

        try:

            if f_path:

                log.debug('generating changelog for path %s' % f_path)

                # get the history for the file !

                tip_cs = c.db_repo_scm_instance.get_changeset()

                try:

                    collection = tip_cs.get_file_history(f_path)

                except (NodeDoesNotExistError, ChangesetError):

                    #this node is not present at tip !

                    try:

                        collection = cs.get_file_history(f_path)

                    except RepositoryError, e:

                        h.flash(safe_str(e), category='warning')

                        redirect(h.url('changelog_home', repo_name=repo_name))

                collection = list(reversed(collection))

            else:

                collection = c.db_repo_scm_instance.get_changesets(start=0, end=revision,

                                                        branch_name=branch_name)

            c.total_cs = len(collection)

            c.pagination = RepoPage(collection, page=p, item_count=c.total_cs,

                                    items_per_page=c.size, branch=branch_name,)

            page_revisions = [x.raw_id for x in c.pagination]

            c.comments = c.db_repo.get_comments(page_revisions)

            c.statuses = c.db_repo.statuses(page_revisions)

        except (EmptyRepositoryError), e:

            h.flash(safe_str(e), category='warning')

            return redirect(url('summary_home', repo_name=c.repo_name))

        except (RepositoryError, ChangesetDoesNotExistError, Exception), e:

            log.error(traceback.format_exc())

            h.flash(safe_str(e), category='error')

            return redirect(url('changelog_home', repo_name=c.repo_name))

from pylons.i18n.translation import _

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

from kallithea.lib.vcs.utils import safe_str

from kallithea.lib.vcs.utils.hgcompat import unionrepo

from kallithea.lib import helpers as h

from kallithea.lib.base import BaseRepoController, render

from kallithea.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from kallithea.lib import diffs

from kallithea.model.db import Repository

from kallithea.lib.diffs import LimitedDiffContainer

from kallithea.controllers.changeset import anchor_url, _ignorews_url,\

    _context_url, get_line_ctx, get_ignore_ws

from kallithea.lib.graphmod import graph_data

from kallithea.lib.compat import json

log = logging.getLogger(__name__)

class CompareController(BaseRepoController):

    def __before__(self):

        super(CompareController, self).__before__()

        """

        """

        rev = ref[1] # default and used for git

        if repo.scm_instance.alias == 'hg':

            # lookup up the exact node id

            _revset_predicates = {

                    'branch': 'branch',

                    'book': 'bookmark',

                    'tag': 'tag',

                    'rev': 'id',

                }

            rev_spec = "max(%s(%%s))" % _revset_predicates[ref[0]]

            revs = repo.scm_instance._repo.revs(rev_spec, safe_str(ref[1]))

            if revs:

                rev = revs[-1]

            # else: TODO: just report 'not found'

        try:

            return repo.scm_instance.get_changeset(rev).raw_id

        except EmptyRepositoryError, e:

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

        except RepositoryError, e:

            log.error(traceback.format_exc())

            raise HTTPBadRequest()

    @staticmethod

    def _get_changesets(alias, org_repo, org_rev, other_repo, other_rev):

        """

        Returns lists of changesets that can be merged from org_repo@org_rev

        to other_repo@other_rev

        ... and the other way

        ... and the ancestor that would be used for merge

        :param org_repo: repo object, that is most likely the orginal repo we forked from

        :param org_rev: the revision we want our compare to be made

        :param other_repo: repo object, mostl likely the fork of org_repo. It hass

            all changesets that we need to obtain

        :param other_rev: revision we want out compare to be made on other_repo

        """

        ancestor = None

        if org_rev == other_rev:

            org_changesets = []

            other_changesets = []

            ancestor = org_rev

        elif alias == 'hg':

            #case two independent repos

        ignore_whitespace = request.GET.get('ignorews') == '1'

        line_context = request.GET.get('context', 3)

        org_repo = Repository.get_by_repo_name(org_repo)

        other_repo = Repository.get_by_repo_name(other_repo)

        if org_repo is None:

            msg = 'Could not find org repo %s' % org_repo

            log.error(msg)

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

            return redirect(url('compare_home', repo_name=c.repo_name))

        if other_repo is None:

            msg = 'Could not find other repo %s' % other_repo

            log.error(msg)

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

            return redirect(url('compare_home', repo_name=c.repo_name))

        if org_repo.scm_instance.alias != other_repo.scm_instance.alias:

            msg = 'compare of two different kind of remote repos not available'

            log.error(msg)

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

            return redirect(url('compare_home', repo_name=c.repo_name))

        c.compare_home = False

        c.org_repo = org_repo

        c.other_repo = other_repo

        c.org_ref_name = org_ref_name

        c.other_ref_name = other_ref_name

        c.org_ref_type = org_ref_type

        c.other_ref_type = other_ref_type

        c.cs_ranges, c.cs_ranges_org, c.ancestor = self._get_changesets(

            org_repo.scm_instance.alias, org_repo.scm_instance, c.org_rev,

            other_repo.scm_instance, c.other_rev)

        c.statuses = c.db_repo.statuses(

            [x.raw_id for x in c.cs_ranges])

        revs = [ctx.revision for ctx in reversed(c.cs_ranges)]

        c.jsdata = json.dumps(graph_data(c.other_repo.scm_instance, revs))

        c.statuses = c.db_repo.statuses([x.raw_id for x in

                                                   c.cs_ranges])

        if partial:

            return render('compare/compare_cs.html')

        if merge and c.ancestor:

    ChangesetDoesNotExistError, EmptyRepositoryError, \

    ImproperArchiveTypeError, VCSError, NodeAlreadyExistsError,\

    NodeDoesNotExistError, ChangesetError, NodeError

from kallithea.lib.vcs.nodes import FileNode

from kallithea.model.repo import RepoModel

from kallithea.model.scm import ScmModel

from kallithea.model.db import Repository

from kallithea.controllers.changeset import anchor_url, _ignorews_url,\

    _context_url, get_line_ctx, get_ignore_ws

from webob.exc import HTTPNotFound

from kallithea.lib.exceptions import NonRelativePathError, IMCCommitError

log = logging.getLogger(__name__)

class FilesController(BaseRepoController):

    def __before__(self):

        super(FilesController, self).__before__()

        c.cut_off_limit = self.cut_off_limit

        """

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

        proper message

        :param rev: revision to fetch

        """

        try:

            return c.db_repo_scm_instance.get_changeset(rev)

        except EmptyRepositoryError, e:

                return None

            url_ = url('files_add_home',

                       repo_name=c.repo_name,

                       revision=0, f_path='', anchor='edit')

            add_new = h.link_to(_('Click here to add new file'), url_, class_="alert-link")

            h.flash(h.literal(_('There are no files yet. %s') % add_new),

                    category='warning')

        except(ChangesetDoesNotExistError, LookupError), e:

            log.error(traceback.format_exc())

            msg = _('Such revision does not exist for this repository')

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

            raise HTTPNotFound()

        except RepositoryError, e:

            h.flash(safe_str(e), category='error')

            raise HTTPNotFound()

        """

        :param cs: given changeset

        :param path: path to lookup

        """

        try:

            file_node = cs.get_node(path)

            if file_node.is_dir():

                raise RepositoryError('given path is a directory')

        except(ChangesetDoesNotExistError,), e:

            log.error(traceback.format_exc())

            msg = _('Such revision does not exist for this repository')

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

            raise HTTPNotFound()

        except RepositoryError, e:

            h.flash(safe_str(e), category='error')

            raise HTTPNotFound()

        return file_node

    @LoginRequired()

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

                                   'repository.admin')

    def index(self, repo_name, revision, f_path, annotate=False):

        # redirect to given revision from form if given

        post_revision = request.POST.get('at_rev', None)

        if post_revision:

        c.revision = revision

        c.branch = request.GET.get('branch', None)

        c.f_path = f_path

        c.annotate = annotate

        cur_rev = c.changeset.revision

        # prev link

        try:

            prev_rev = c.db_repo_scm_instance.get_changeset(cur_rev).prev(c.branch)

            c.url_prev = url('files_home', repo_name=c.repo_name,

                         revision=prev_rev.raw_id, f_path=f_path)

            if c.branch:

                c.url_prev += '?branch=%s' % c.branch

        except (ChangesetDoesNotExistError, VCSError):

            c.url_prev = '#'

        # next link

        try:

            next_rev = c.db_repo_scm_instance.get_changeset(cur_rev).next(c.branch)

            c.url_next = url('files_home', repo_name=c.repo_name,

                     revision=next_rev.raw_id, f_path=f_path)

            if c.branch:

                c.url_next += '?branch=%s' % c.branch

        except (ChangesetDoesNotExistError, VCSError):

            c.url_next = '#'

                _hist = []

                c.file_history = []

                if c.load_full_history:

                    c.file_history, _hist = self._get_node_history(c.changeset, f_path)

                c.authors = []

                for a in set([x.author for x in _hist]):

                    c.authors.append((h.email(a), h.person(a)))

            else:

                c.authors = c.file_history = []

        except RepositoryError, e:

            h.flash(safe_str(e), category='error')

            raise HTTPNotFound()

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

            return render('files/files_ypjax.html')

        return render('files/files.html')

    @LoginRequired()

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

                                   'repository.admin')

    @jsonify

    def history(self, repo_name, revision, f_path):

        f_path = f_path

        _file = changeset.get_node(f_path)

        if _file.is_file():

            file_history, _hist = self._get_node_history(changeset, f_path)

            res = []

            for obj in file_history:

                res.append({

                    'text': obj[1],

                    'children': [{'id': o[0], 'text': o[1]} for o in obj[0]]

                })

            data = {

                'more': False,

                'results': res

            }

            return data

    @LoginRequired()

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

                                   'repository.admin')

    def authors(self, repo_name, revision, f_path):

        f_path = f_path

        _file = changeset.get_node(f_path)

        if _file.is_file():

            file_history, _hist = self._get_node_history(changeset, f_path)

            c.authors = []

            for a in set([x.author for x in _hist]):

                c.authors.append((h.email(a), h.person(a)))

            return render('files/files_history_box.html')

    @LoginRequired()

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

                                   'repository.admin')

    def rawfile(self, repo_name, revision, f_path):

        response.content_disposition = 'attachment; filename=%s' % \

            safe_str(f_path.split(Repository.url_sep())[-1])

        response.content_type = file_node.mimetype

        return file_node.content

    @LoginRequired()

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

                                   'repository.admin')

    def raw(self, repo_name, revision, f_path):

        raw_mimetype_mapping = {

            # map original mimetype to a mimetype used for "show as raw"

            # you can also provide a content-disposition to override the

            # default "attachment" disposition.

            # orig_type: (new_type, new_dispo)

            # show images inline:

            'image/x-icon': ('image/x-icon', 'inline'),

            'image/png': ('image/png', 'inline'),

            'image/gif': ('image/gif', 'inline'),

            'image/jpeg': ('image/jpeg', 'inline'),

            'image/svg+xml': ('image/svg+xml', 'inline'),

        }

        mimetype = file_node.mimetype

        try:

            mimetype, dispo = raw_mimetype_mapping[mimetype]

        except KeyError:

            # we don't know anything special about this, handle it safely

            if file_node.is_binary:

                # do same as download raw for binary files

                mimetype, dispo = 'application/octet-stream', 'attachment'

            else:

    @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')

    def delete(self, repo_name, revision, f_path):

        repo = c.db_repo

        if repo.enable_locking and repo.locked[0]:

            h.flash(_('This repository is has been locked by %s on %s')

                % (h.person_by_id(repo.locked[0]),

                   h.fmt_date(h.time_to_datetime(repo.locked[1]))),

                'warning')

            return redirect(h.url('files_home',

                                  repo_name=repo_name, revision='tip'))

        # check if revision is a branch identifier- basically we cannot

        # create multiple heads via file editing

        _branches = repo.scm_instance.branches

        # check if revision is a branch name or branch hash

        if revision not in _branches.keys() + _branches.values():

            h.flash(_('You can only delete files with revision '

                      'being a valid branch '), category='warning')

            return redirect(h.url('files_home',

                                  repo_name=repo_name, revision='tip',

                                  f_path=f_path))

        r_post = request.POST

        c.default_message = _('Deleted file %s via Kallithea') % (f_path)

        c.f_path = f_path

        node_path = f_path

        author = self.authuser.full_contact

        if r_post:

            message = r_post.get('message') or c.default_message

            try:

                nodes = {

                    node_path: {

                        'content': ''

                    }

                }

                self.scm_model.delete_nodes(

                    user=c.authuser.user_id, repo=c.db_repo,

                    message=message,

                    nodes=nodes,

                    parent_cs=c.cs,

                    author=author,

                )

                h.flash(_('Successfully deleted file %s') % f_path,

    @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')

    def edit(self, repo_name, revision, f_path):

        repo = c.db_repo

        if repo.enable_locking and repo.locked[0]:

            h.flash(_('This repository is has been locked by %s on %s')

                % (h.person_by_id(repo.locked[0]),

                   h.fmt_date(h.time_to_datetime(repo.locked[1]))),

                'warning')

            return redirect(h.url('files_home',

                                  repo_name=repo_name, revision='tip'))

        # check if revision is a branch identifier- basically we cannot

        # create multiple heads via file editing

        _branches = repo.scm_instance.branches

        # check if revision is a branch name or branch hash

        if revision not in _branches.keys() + _branches.values():

            h.flash(_('You can only edit files with revision '

                      'being a valid branch '), category='warning')

            return redirect(h.url('files_home',

                                  repo_name=repo_name, revision='tip',

                                  f_path=f_path))

        r_post = request.POST

        if c.file.is_binary:

            return redirect(url('files_home', repo_name=c.repo_name,

                            revision=c.cs.raw_id, f_path=f_path))

        c.default_message = _('Edited file %s via Kallithea') % (f_path)

        c.f_path = f_path

        if r_post:

            old_content = c.file.content

            sl = old_content.splitlines(1)

            first_line = sl[0] if sl else ''

            # modes:  0 - Unix, 1 - Mac, 2 - DOS

            mode = detect_mode(first_line, 0)

            content = convert_line_endings(r_post.get('content', ''), mode)

            message = r_post.get('message') or c.default_message

            author = self.authuser.full_contact

            if content == old_content:

                h.flash(_('No changes'), category='warning')

                return redirect(url('changeset_home', repo_name=c.repo_name,

                                    revision='tip'))

            try:

                h.flash(_('Successfully committed to %s') % f_path,

                        category='success')

            except Exception:

                log.error(traceback.format_exc())

                h.flash(_('Error occurred during commit'), category='error')

            return redirect(url('changeset_home',

                                repo_name=c.repo_name, revision='tip'))

        return render('files/files_edit.html')

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')

    def add(self, repo_name, revision, f_path):

        repo = Repository.get_by_repo_name(repo_name)

        if repo.enable_locking and repo.locked[0]:

            h.flash(_('This repository is has been locked by %s on %s')

                % (h.person_by_id(repo.locked[0]),

                   h.fmt_date(h.time_to_datetime(repo.locked[1]))),

                  'warning')

            return redirect(h.url('files_home',

                                  repo_name=repo_name, revision='tip'))

        r_post = request.POST

        if c.cs is None:

            c.cs = EmptyChangeset(alias=c.db_repo_scm_instance.alias)

        c.default_message = (_('Added file via Kallithea'))

        c.f_path = f_path

        if r_post:

            unix_mode = 0

            content = convert_line_endings(r_post.get('content', ''), unix_mode)

            message = r_post.get('message') or c.default_message

            filename = r_post.get('filename')

            location = r_post.get('location', '')

            file_obj = r_post.get('upload_file', None)

            if file_obj is not None and hasattr(file_obj, 'filename'):

                filename = file_obj.filename

                content = file_obj.file

                if hasattr(content, 'file'):

                    # non posix systems store real file under file attr

                    content = content.file

            if not content:

                h.flash(_('No content'), category='warning')

        _hg = cs.repository.alias == 'hg'

        for chs in changesets:

            #_branch = '(%s)' % chs.branch if _hg else ''

            _branch = chs.branch

            n_desc = '%s (%s)' % (h.show_id(chs), _branch)

            changesets_group[0].append((chs.raw_id, n_desc,))

        hist_l.append(changesets_group)

        for name, chs in c.db_repo_scm_instance.branches.items():

            branches_group[0].append((chs, name),)

        hist_l.append(branches_group)

        for name, chs in c.db_repo_scm_instance.tags.items():

            tags_group[0].append((chs, name),)

        hist_l.append(tags_group)

        return hist_l, changesets

    @LoginRequired()

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

                                   'repository.admin')

    @jsonify

    def nodelist(self, repo_name, revision, f_path):

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

            _d, _f = ScmModel().get_nodes(repo_name, cs.raw_id, f_path,

                                          flat=False)

            return {'nodes': _d + _f}

# 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.lib.base

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

The base Controller API

Provides the BaseController class for subclassing. And usage in different

controllers

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: Oct 06, 2010

:author: marcink

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

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

"""

import logging

import time

import traceback

from paste.auth.basic import AuthBasicAuthenticator

from paste.httpheaders import WWW_AUTHENTICATE, AUTHORIZATION

from pylons import config, tmpl_context as c, request, session, url

from pylons.controllers import WSGIController

from pylons.controllers.util import redirect

from pylons.templating import render_mako as render  # don't remove this import

from kallithea import __version__, BACKENDS

from kallithea.lib.utils2 import str2bool, safe_unicode, AttributeDict,\

    safe_str, safe_int

from kallithea.lib import auth_modules

from kallithea.lib.auth import AuthUser, HasPermissionAnyMiddleware, CookieStoreWrapper

from kallithea.lib.utils import get_repo_slug

from kallithea.lib.exceptions import UserCreationError

from kallithea.model import meta

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

from kallithea.model.notification import NotificationModel

from kallithea.model.scm import ScmModel

from kallithea.model.meta import Session

from kallithea.model.pull_request import PullRequestModel

log = logging.getLogger(__name__)

def _filter_proxy(ip):

    """

    HEADERS can have multiple ips inside the left-most being the original

    client, and each successive proxy that passed the request adding the IP

        if c.repo_name:  # extracted from routes

            _dbr = Repository.get_by_repo_name(c.repo_name)

            if not _dbr:

                return

            log.debug('Found repository in database %s with state `%s`'

                      % (safe_unicode(_dbr), safe_unicode(_dbr.repo_state)))

            route = getattr(request.environ.get('routes.route'), 'name', '')

            # allow to delete repos that are somehow damages in filesystem

            if route in ['delete_repo']:

                return

            if _dbr.repo_state in [Repository.STATE_PENDING]:

                if route in ['repo_creating_home']:

                    return

                check_url = url('repo_creating_home', repo_name=c.repo_name)

                return redirect(check_url)

            dbr = c.db_repo = _dbr

            c.db_repo_scm_instance = c.db_repo.scm_instance

            if c.db_repo_scm_instance is None:

                log.error('%s this repository is present in database but it '

                          'cannot be created as an scm instance', c.repo_name)

            # some globals counter for menu

            c.repository_followers = self.scm_model.get_followers(dbr)

            c.repository_forks = self.scm_model.get_forks(dbr)

            c.repository_pull_requests = self.scm_model.get_pull_requests(dbr)

            c.repository_following = self.scm_model.is_following_repo(

                                    c.repo_name, self.authuser.user_id)