import logging

import os

from pylons import request, response, session, tmpl_context as c, url, app_globals as g

from pylons.controllers.util import abort, redirect

from pylons_app.lib.base import BaseController, render

from pylons_app.model import meta

from webhelpers.paginate import Page

from pylons_app.lib.utils import check_repo, invalidate_cache

log = logging.getLogger(__name__)

class AdminController(BaseController):

    def __before__(self):

    def index(self):

            sa = meta.Session

            users_log = sa.query(UserLogs)\

                .order_by(UserLogs.action_date.desc())

            p = int(request.params.get('page', 1))

            c.users_log = Page(users_log, page=p, items_per_page=10)

            c.log_data = render('admin/admin_log.html')

            if request.params.get('partial'):

                return c.log_data

        return render('admin/admin.html')

    def add_repo(self, new_repo):

        #extra check it can be add since it's the command

        if new_repo == '_admin':

            c.msg = 'DENIED'

            c.new_repo = ''

            return render('admin/add.html')

        new_repo = new_repo.replace(" ", "_")

        new_repo = new_repo.replace("-", "_")

        try:

            self._create_repo(new_repo)

            c.new_repo = new_repo

            c.msg = 'added repo'

            #clear our cached list for refresh with new repo

            invalidate_cache('cached_repo_list')

        except Exception as e:

            c.new_repo = 'Exception when adding: %s' % new_repo

            c.msg = str(e)

        return render('admin/add.html')

    def _create_repo(self, repo_name):

        if repo_name in [None, '', 'add']:

import logging

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

from pylons.controllers.util import abort, redirect

from pylons_app.lib.base import BaseController, render

from pylons_app.lib.utils import get_repo_slug

from pylons_app.model.hg_model import HgModel

log = logging.getLogger(__name__)

class BranchesController(BaseController):

    def __before__(self):

    def index(self):

        hg_model = HgModel()

        c.repo_info = hg_model.get_repo(c.repo_name)

        c.repo_branches = c.repo_info.branches

        return render('branches/branches.html')

import logging

import cgi

import os

import paste.fileapp

from pylons import tmpl_context as c, app_globals as g, request, config

from pylons.controllers.util import forward

from pylons.i18n.translation import _

from pylons_app.lib.base import BaseController, render

from pylons.middleware import  media_path

from pylons_app.lib.utils import check_repo

log = logging.getLogger(__name__)

class ErrorController(BaseController):

    """

    Generates error documents as and when they are required.

    The ErrorDocuments middleware forwards to ErrorController when error

    related status codes are returned from the application.

    This behaviour can be altered by changing the parameters to the

    ErrorDocuments middleware in your config/middleware.py file.

    """

    def document(self):

        resp = request.environ.get('pylons.original_response')

        log.debug(resp.status)

        e = request.environ

        c.serv_p = r'%(protocol)s://%(host)s/' % {

                                                'protocol': e.get('wsgi.url_scheme'),

                                                'host':e.get('HTTP_HOST'),

                                                }

        if resp.status_int == 404:

            if check_repo(c.repo_name, g.base_path):

                return render('/errors/error_404.html')

        c.error_message = cgi.escape(request.GET.get('code', str(resp.status)))

        c.error_explanation = self.get_error_explanation(resp.status_int)

        #redirect to when error with given seconds

        c.redirect_time = 0

        c.redirect_module = _('Home page')# name to what your going to be redirected

        c.url_redirect = "/"

import logging

from pylons import request, response, session, tmpl_context as c, url, config, app_globals as g

from pylons.controllers.util import abort, redirect

from pylons_app.lib.base import BaseController, render

from pylons_app.lib.utils import get_repo_slug

from pylons_app.model.hg_model import HgModel

from vcs.utils import diffs as differ

from vcs.exceptions import RepositoryError, ChangesetError

log = logging.getLogger(__name__)

class FilesController(BaseController):

    def __before__(self):

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

        hg_model = HgModel()

        c.repo = repo = hg_model.get_repo(c.repo_name)

        revision = request.POST.get('at_rev', None) or revision

        def get_next_rev(cur):

            max_rev = len(c.repo.revisions) - 1

            r = cur + 1

            if r > max_rev:

                r = max_rev

            return r

        def get_prev_rev(cur):

            r = cur - 1

            return r

        c.f_path = f_path

        try:

            cur_rev = repo.get_changeset(revision).revision

            prev_rev = repo.get_changeset(get_prev_rev(cur_rev)).raw_id

            next_rev = repo.get_changeset(get_next_rev(cur_rev)).raw_id

            try:

                c.file_msg = c.changeset.get_file_message(f_path)

            except:

                c.file_msg = None

            c.cur_rev = c.changeset.raw_id

            c.rev_nr = c.changeset.revision

            c.files_list = c.changeset.get_node(f_path)

            c.file_history = self._get_history(repo, c.files_list, f_path)

        except (RepositoryError, ChangesetError):

            c.files_list = None

        return render('files/files.html')

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

        hg_model = HgModel()

        c.repo = hg_model.get_repo(c.repo_name)

        file_node = c.repo.get_changeset(revision).get_node(f_path)

        response.content_type = file_node.mimetype

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

                                                    % f_path.split('/')[-1] 

        return file_node.content

    def archivefile(self, repo_name, revision, fileformat):

        return '%s %s %s' % (repo_name, revision, fileformat)

    def diff(self, repo_name, f_path):

        hg_model = HgModel()

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

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

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

        c.no_changes = diff1 == diff2

        c.f_path = f_path

        c.repo = hg_model.get_repo(c.repo_name)

        c.changeset_1 = c.repo.get_changeset(diff1)

        c.changeset_2 = c.repo.get_changeset(diff2)

        c.diff1 = 'r%s:%s' % (c.changeset_1.revision, c.changeset_1._short)

        c.diff2 = 'r%s:%s' % (c.changeset_2.revision, c.changeset_2._short)

        f_udiff = differ.get_udiff(c.changeset_1.get_node(f_path),

                            c.changeset_2.get_node(f_path))

        diff = differ.DiffProcessor(f_udiff)

        if action == 'download':

            diff_name = '%s_vs_%s.diff' % (diff1, diff2)

            response.content_type = 'text/plain'

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

    app_globals as g

from pylons.controllers.util import abort, redirect

from pylons_app.lib.base import BaseController, render

from pylons_app.lib.utils import get_repo_slug

from pylons_app.model.hg_model import HgModel

log = logging.getLogger(__name__)

class GraphController(BaseController):

    def __before__(self):

    def index(self):

        # Return a rendered template

        hg_model = HgModel()

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

            c.size = int(request.params.get('size', 20))

        else:

            c.size = int(request.params.get('size', 20))

        c.jsdata, c.canvasheight = self.graph(hg_model.get_repo(c.repo_name), c.size)

        return render('/graph.html')

    def graph(self, repo, size):

        revcount = size

        p = int(request.params.get('page', 1))

        c.pagination = Page(repo.revisions, page=p, item_count=len(repo.revisions), items_per_page=revcount)

        if not repo.revisions:return dumps([]), 0

        max_rev = repo.revisions[-1]

        offset = 1 if p == 1 else  ((p - 1) * revcount)

        rev_start = repo.revisions[(-1 * offset)]

        bg_height = 39

#!/usr/bin/python

# -*- coding: utf-8 -*-

import logging

from operator import itemgetter

from pylons import tmpl_context as c, request, config

from pylons_app.lib.base import BaseController, render

from pylons_app.lib.utils import get_repo_slug

from pylons_app.model.hg_model import HgModel

log = logging.getLogger(__name__)

class HgController(BaseController):

    def __before__(self):

    def index(self):

        c.current_sort = request.GET.get('sort', 'name')

        cs = c.current_sort

        c.cs_slug = cs.replace('-', '')

        sortables = ['name', 'description', 'last_change', 'tip', 'contact']

        if cs and c.cs_slug in sortables:

            sort_key = c.cs_slug + '_sort'

            if cs.startswith('-'):

                c.repos_list = sorted(c.cached_repo_list, key=itemgetter(sort_key), reverse=True)

            else:

                c.repos_list = sorted(c.cached_repo_list, key=itemgetter(sort_key), reverse=False)

        return render('/index.html')

import logging

import os

from pylons import request, response, session, tmpl_context as c, url, app_globals as g

from pylons.controllers.util import abort, redirect

from pylons_app.lib import auth

from pylons_app.lib.base import BaseController, render

from pylons_app.model.db import Users, UserLogs

from pylons_app.model.hg_model import HgModel

from operator import itemgetter

import shutil

from pylons_app.lib.utils import invalidate_cache

log = logging.getLogger(__name__)

class ReposController(BaseController):

    """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')

    def __before__(self):

        c.admin_user = session.get('admin_user')

        c.admin_username = session.get('admin_username')

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

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

        # url('repos')

        c.repos_list = c.cached_repo_list

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

    def create(self):

        """POST /repos: Create a new item"""

        # url('repos')

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

        """GET /repos/new: Form to create a new item"""

        # url('new_repo')

    def update(self, id):

        """PUT /repos/id: Update an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="PUT" />

        # Or using helpers:

        #    h.form(url('repo', id=ID),

        #           method='put')

        # url('repo', id=ID)

import logging

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

from pylons.controllers.util import abort, redirect

from pylons_app.lib.base import BaseController, render

from pylons_app.lib.utils import get_repo_slug

from pylons_app.model.hg_model import HgModel

from webhelpers.paginate import Page

log = logging.getLogger(__name__)

class ShortlogController(BaseController):

    def __before__(self):

    def index(self):

        hg_model = HgModel()

        p = int(request.params.get('page', 1))

        repo = hg_model.get_repo(c.repo_name)

        c.repo_changesets = Page(repo, page=p, items_per_page=20)

        c.shortlog_data = render('shortlog/shortlog_data.html')

        if request.params.get('partial'):

            return c.shortlog_data

        r = render('shortlog/shortlog.html')

        return r

from pylons.controllers.util import abort, redirect

from pylons_app.lib.base import BaseController, render

from pylons_app.lib.utils import get_repo_slug

from pylons_app.model.hg_model import HgModel

log = logging.getLogger(__name__)

class SummaryController(BaseController):

    def __before__(self):

    def index(self):

        hg_model = HgModel()

        c.repo_info = hg_model.get_repo(c.repo_name)

        c.repo_changesets = c.repo_info.get_changesets(10)

        e = request.environ

                                                'protocol': e.get('wsgi.url_scheme'),

                                                'host':e.get('HTTP_HOST'),

                                                'repo_name':c.repo_name,

                                                }

        c.repo_tags = c.repo_info.tags[:10]

        c.repo_branches = c.repo_info.branches[:10]

import logging

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

from pylons.controllers.util import abort, redirect

from pylons_app.lib.base import BaseController, render

from pylons_app.lib.utils import get_repo_slug

from pylons_app.model.hg_model import HgModel

log = logging.getLogger(__name__)

class TagsController(BaseController):

    def __before__(self):

    def index(self):

        hg_model = HgModel()

        c.repo_info = hg_model.get_repo(c.repo_name)

        c.repo_tags = c.repo_info.tags

        return render('tags/tags.html')

import logging

from pylons import request, response, session, tmpl_context as c, url, app_globals as g

from pylons.controllers.util import abort, redirect

from pylons_app.lib.base import BaseController, render

from formencode import htmlfill

from pylons_app.model.db import Users, UserLogs

import crypt

log = logging.getLogger(__name__)

class UsersController(BaseController):

    """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('user', 'users')

    def __before__(self):

        c.admin_user = session.get('admin_user')

        c.admin_username = session.get('admin_username')

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

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

        # url('users')

        c.users_list = self.sa.query(Users).all()     

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

    def create(self):

        """POST /users: Create a new item"""

        # url('users')

        params = dict(request.params)

        try:

            new_user = Users()

            new_user.active = params.get('active', False)

            new_user.username = params.get('username')

            new_user.password = crypt.crypt(params.get('password'), '6a')

            new_user.admin = False

            self.sa.add(new_user)

            self.sa.commit()

        except:

            self.sa.rollback()

            raise