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)

        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 = []

            user_group = []

                l = list(g2)

                user_group.append((l[0].user, l))

        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()

            if user_id:

                try:

                    self.scm_model.toggle_following_user(user_id,

                    return 'ok'

                except:

                    raise HTTPBadRequest()

            if repo_id:

                try:

                    self.scm_model.toggle_following_repo(repo_id,

                    return 'ok'

                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()

        c.runtime = ''

        c.cur_query = request.GET.get('q', None)

        c.cur_type = request.GET.get('type', 'source')

                                      .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()

        #fill owner

        if c.repo_info.user:

        else:

            replacement_user = self.sa.query(User)\

            .filter(User.admin == True).first().username

        #fill repository users

        for p in c.repo_info.repo_to_perm:

    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)

        except formencode.Invalid, errors:

            c.repo_info = repo_model.get_by_repo_name(repo_name)

            c.users_array = repo_model.get_users_js()

            return htmlfill.render(

                render('settings/repo_settings.html'),

                defaults=errors.value,

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

    def fork_create(self, repo_name):

        repo_model = RepoModel()

        c.repo_info = repo_model.get_by_repo_name(repo_name)

        form_result = {}

        try:

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

            repo_model.create_fork(form_result, self.rhodecode_user)

            h.flash(_('forked %s repository as %s') \

                      % (repo_name, form_result['fork_name']),

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.dbrepo = dbrepo = Repository.by_repo_name(repo_name)

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

        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 = '@'

        c.clone_repo_url = uri

        c.repo_tags = OrderedDict()

        for name, hash in c.rhodecode_repo.tags.items()[:10]:

                                                c.repo_last_rev) * 100)

        else:

            c.commit_data = json.dumps({})

            c.trending_languages = json.dumps({})

            c.no_data = True

        return render('summary/summary.html')

    def _get_download_links(self, repo):

        download_l = []

log = logging.getLogger(__name__)

class TagsController(BaseRepoController):

    @LoginRequired()

        tags = [(name, c.rhodecode_repo.get_changeset(hash_)) for \

                 name, hash_ in c.rhodecode_repo.tags.items()]

        for name, cs_tag in ordered_tags:

            c.repo_tags[name] = cs_tag