log = logging.getLogger(__name__)

class BranchesController(BaseRepoController):

    @LoginRequired()

log = logging.getLogger(__name__)

class ChangelogController(BaseRepoController):

    @LoginRequired()

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

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

        c.total_cs = len(c.rhodecode_repo)

        self._graph(c.rhodecode_repo, c.total_cs, c.size, p)

        return render('changelog/changelog.html')

    def _graph(self, repo, repo_size, size, p):

        """

        Generates a DAG graph for mercurial

log = logging.getLogger(__name__)

class ChangesetController(BaseRepoController):

    @LoginRequired()

            except IndexError:

                changeset_parent = None

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

            # ADDED FILES

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

                    c.sum_added += node.size

                    if c.sum_added < self.cut_off_limit:

                        f_gitdiff = differ.get_gitdiff(filenode_old, node)

                    else:

                        c.cut_off = True

                        break

                cs1 = None

                cs2 = node.last_changeset.raw_id

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

            # CHANGED FILES

                    try:

                        filenode_old = changeset_parent.get_node(node.path)

                    except ChangesetError:

                    if filenode_old.is_binary or node.is_binary:

                        diff = wrap_to_table(_('binary file'))

                        if c.sum_removed < self.cut_off_limit:

                            f_gitdiff = differ.get_gitdiff(filenode_old, node)

                            if diff:

                                c.sum_removed += len(diff)

                        else:

                            c.cut_off = True

                            break

                    cs1 = filenode_old.last_changeset.raw_id

                    cs2 = node.last_changeset.raw_id

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

            # REMOVED FILES

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

            if not c.cut_off:

                for node in changeset.removed:

        if len(c.cs_ranges) == 1:

            c.changeset = c.cs_ranges[0]

                    diff = _('binary file') + '\n'

                else:

                    f_gitdiff = differ.get_gitdiff(filenode_old, node)

                cs1 = None

                cs2 = node.last_changeset.raw_id

                    diff = _('binary file')

                else:

                    f_gitdiff = differ.get_gitdiff(filenode_old, node)

                cs1 = filenode_old.last_changeset.raw_id

                cs2 = node.last_changeset.raw_id

        response.content_type = 'text/plain'

        if method == 'download':

        parent = True if len(c.changeset.parents) > 0 else False

        c.diffs = ''

        for x in c.changes:

import logging

import paste.fileapp

from pylons.i18n.translation import _

from pylons.middleware import  media_path

log = logging.getLogger(__name__)

class ErrorController(BaseController):

    """Generates error documents as and when they are required.

    """

    def __before__(self):

    def document(self):

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

        log.debug('### %s ###', resp.status)

        e = request.environ

        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.url_redirect = "/"

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

    def img(self, id):

        """Serve Pylons' stock images"""

        return self._serve_file(os.path.join(media_path, 'img', id))

            code = 500

        if code == 400:

        if code == 401:

            return _('Unauthorized access to resource')

        if code == 403:

        if code == 404:

            return _('The resource could not be found')

        if code == 500:

log = logging.getLogger(__name__)

class FeedController(BaseRepoController):

    @LoginRequired(api_access=True)

    def atom(self, repo_name):

        """Produce an atom-1.0 feed via feedgenerator module"""

        feed = Atom1Feed(title=self.title % repo_name,

                         description=self.description % repo_name,

                         language=self.language,

                         ttl=self.ttl)

        response.content_type = feed.mime_type

        return feed.writeString('utf-8')

    def rss(self, repo_name):

        """Produce an rss2 feed via feedgenerator module"""

        feed = Rss201rev2Feed(title=self.title % repo_name,

                         description=self.description % repo_name,

                         language=self.language,

                         ttl=self.ttl)

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

            redirect(h.url('files_home', repo_name=repo_name, revision='tip'))

    def __get_filenode_or_redirect(self, repo_name, cs, path):

        """

        Returns file_node, if error occurs or given path is directory,

        :param path: path to lookup

        """

        try:

            file_node = cs.get_node(path)

            if file_node.is_dir():

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

                         revision=cs.raw_id, f_path=f_path))

        c.changeset = self.__get_cs_or_redirect(revision, repo_name)

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

        c.f_path = f_path

            redirect(h.url('files_home', repo_name=repo_name,

                           revision=revision))

        return render('files/files.html')

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

        return cs.get_chunked_archive(stream=None, kind=fileformat)

    def diff(self, repo_name, f_path):

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

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

            return redirect(url('files_home',

                                repo_name=c.repo_name, f_path=f_path))

        if c.action == 'download':

            diff = differ.DiffProcessor(differ.get_gitdiff(node1, node2),

                                        format='gitdiff')

            if node1.is_binary or node2.is_binary:

                c.cur_diff = _('Binary file')

                c.cur_diff = _('Diff is too big to display')

            else:

                diff = differ.DiffProcessor(differ.get_gitdiff(node1, node2),

            #default option

            if node1.is_binary or node2.is_binary:

                c.cur_diff = _('Binary file')

                c.cur_diff = _('Diff is too big to display')

            else:

                diff = differ.DiffProcessor(differ.get_gitdiff(node1, node2),

log = logging.getLogger(__name__)

class HomeController(BaseController):

    @LoginRequired()

log = logging.getLogger(__name__)

class JournalController(BaseController):

    def __before__(self):

        super(JournalController, self).__before__()

        self.rhodecode_user = self.rhodecode_user

            return c.journal_data

        return render('journal/journal.html')

    def _get_daily_aggregate(self, journal):

        groups = []

        for k, g in groupby(journal, lambda x:x.action_as_day):

        return groups

    def _get_journal_data(self, following_repos):

        repo_ids = [x.follows_repository.repo_id for x in following_repos

                    if x.follows_repository is not None]

        else:

            journal = []

        return journal

    @LoginRequired()

                except:

                    raise HTTPBadRequest()

        log.debug('token mismatch %s vs %s', cur_token, token)

        raise HTTPBadRequest()

    @LoginRequired()

    def public_journal(self):

        # Return a rendered template

            return c.journal_data

        return render('journal/public_journal.html')

    @LoginRequired(api_access=True)

    def public_journal_atom(self):

        """

log = logging.getLogger(__name__)

class LoginController(BaseController):

    def __before__(self):

    def register(self):

        user_model = UserModel()

        c.auto_active = False

            if perm.permission.permission_name == 'hg.register.auto_activate':

                c.auto_active = True

                break

log = logging.getLogger(__name__)

class SearchController(BaseController):

    @LoginRequired()

                                      'repository':'repository'}\

                                      .get(c.cur_type, 'content')

        if c.cur_query:

            cur_query = c.cur_query.lower()

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

            highlight_items = set()

            try:

                searcher = idx.searcher()

                qp = QueryParser(search_type, schema=SCHEMA)

                                page=p, item_count=res_ln,

                                items_per_page=10, url=url_generator)

                except QueryParserError:

                    c.runtime = _('Invalid search query. Try quoting it.')

                searcher.close()

log = logging.getLogger(__name__)

class SettingsController(BaseRepoController):

    @LoginRequired()

    def update(self, repo_name):

        repo_model = RepoModel()

        changed_name = repo_name

        try:

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

            repo_model.update(repo_name, form_result)

        return redirect(url('repo_settings_home', repo_name=changed_name))

    @HasRepoPermissionAllDecorator('repository.admin')

    def delete(self, repo_name):

        """DELETE /repos/repo_name: Delete an existing item"""

log = logging.getLogger(__name__)

class ShortlogController(BaseRepoController):

    @LoginRequired()

    def index(self):

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

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

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

            return c.shortlog_data

    import simplejson as json

log = logging.getLogger(__name__)

class SummaryController(BaseRepoController):

    @LoginRequired()

        c.following = self.scm_model.is_following_repo(repo_name,

                                                       self.rhodecode_user.user_id)

        def url_generator(**kw):

            return url('shortlog_home', repo_name=repo_name, **kw)

        if self.rhodecode_user.username == 'default':

            #for default(anonymous) user we don't need to pass credentials

            username = str(self.rhodecode_user.username)

            password = '@'

                                        'user':username,

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

                                        'prefix':e.get('SCRIPT_NAME'),

                                        'repo_name':repo_name, }

        return render('summary/summary.html')

    def _get_download_links(self, repo):

        download_l = []

log = logging.getLogger(__name__)

class TagsController(BaseRepoController):

    @LoginRequired()