#ADMIN REPOS GROUP REST ROUTES

    routes_map.resource('repos_group', 'repos_groups', controller='admin/repos_groups', path_prefix='/_admin')

    #ADMIN USERS REST ROUTES

import logging

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

from pylons.controllers.util import abort, redirect

from rhodecode.lib.base import BaseController, render

log = logging.getLogger(__name__)

class ReposGroupsController(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('repos_group', 'repos_groups')

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

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

        # url('repos_groups')

    def create(self):

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

        # url('repos_groups')

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

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

        # url('new_repos_group')

    def update(self, id):

        """PUT /repos_groups/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('repos_group', id=ID),

        #           method='put')

        # url('repos_group', id=ID)

    def delete(self, id):

        """DELETE /repos_groups/id: Delete an existing item"""

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

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

        # Or using helpers:

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

        #           method='delete')

        # url('repos_group', id=ID)

    def show(self, id, format='html'):

        """GET /repos_groups/id: Show a specific item"""

        # url('repos_group', id=ID)

    def edit(self, id, format='html'):

        """GET /repos_groups/id/edit: Form to edit an existing item"""

        # url('edit_repos_group', id=ID)

from rhodecode.model.db import Statistics, Repository

from rhodecode.model.repo import RepoModel

    def index(self, repo_name):

        e = request.environ

        c.dbrepo = dbrepo = Repository.by_repo_name(repo_name)

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

                                                       self.rhodecode_user.user_id)

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

        c.repo_changesets = RepoPage(c.rhodecode_repo, page=1, items_per_page=10,

                                        'repo_name':repo_name, }

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

                c.repo_tags[name] = c.rhodecode_repo.get_changeset(hash)

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

                c.repo_branches[name] = c.rhodecode_repo.get_changeset(hash)

            run_task(get_commits_stats, c.dbrepo.repo_name, ts_min_y, ts_max_y)

            c.download_options = self._get_download_links(c.rhodecode_repo)

def pygmentize_annotation(repo_name, filenode, **kwargs):

    def url_func(repo_name):

        def _url_func(changeset):

            tooltip_html = "<div style='font-size:0.8em'><b>Author:</b>" + \

            " %s<br/><b>Date:</b> %s</b><br/><b>Message:</b> %s<br/></div>"

            tooltip_html = tooltip_html % (changeset.author,

                                                   changeset.date,

                                                   tooltip(changeset.message))

            lnk_format = '%5s:%s' % ('r%s' % changeset.revision,

                                     short_id(changeset.raw_id))

            uri = link_to(

                    lnk_format,

                    url('changeset_home', repo_name=repo_name,

                        revision=changeset.raw_id),

                    style=get_color_string(changeset.raw_id),

                    class_='tooltip',

                    title=tooltip_html

                  )

            uri += '\n'

            return uri

        return _url_func

    return literal(annotate_highlight(filenode, url_func(repo_name), **kwargs))

            return link_to(group.group_name, url('repos_group', id=group.group_id))

                    filtered_repo_paths[repo_name] = repo

    def add_doc(self, writer, path, repo, repo_name):

                        repository=safe_unicode(repo_name),

        for repo_name, repo in self.repo_paths.items():

                self.add_doc(writer, idx_path, repo, repo_name)

        for repo_name, repo in self.repo_paths.items():

                    self.add_doc(writer, path, repo, repo_name)

		            ${h.link_to(repo['name'], h.url('summary_home',repo_name=repo['name']),class_="repo_name")}

		            <td><a href="${h.url('repo_settings_home',repo_name=repo['name'])}" title="${_('edit')}"><img class="icon" alt="${_('private')}" src="${h.url("/images/icons/application_form_edit.png")}"/></a></td>

	                  ${h.form(url('repo_settings_delete', repo_name=repo['name']),method='delete')}

	                    ${h.submit('remove_%s' % repo['name'],'',class_="delete_icon action_button",onclick="return confirm('Confirm to delete this repository');")}

						${h.pygmentize_annotation(c.repo_name,c.file,linenos=True,anchorlinenos=True,lineanchors='S',cssclass="code-highlight")}

             ${h.link_to(repo['name'],h.url('summary_home',repo_name=repo['name']),class_="%s" % repo['dbrepo']['repo_type'])}

    ${h.link_to(c.dbrepo.just_name,h.url('summary_home',repo_name=c.repo_name))}

                  %if c.rhodecode_user.username != 'default':

                      %if c.following:

                      <span id="follow_toggle" class="following" title="${_('Stop following this repository')}"

                            onclick="javascript:toggleFollowingRepo(this,${c.dbrepo.repo_id},'${str(h.get_token())}')">

                      </span>                 

                      %else:

                      <span id="follow_toggle" class="follow" title="${_('Start following this repository')}"

                            onclick="javascript:toggleFollowingRepo(this,${c.dbrepo.repo_id},'${str(h.get_token())}')">

                      </span>

                      %endif

                  %endif:			  

			      <span style="font-size: 1.6em;font-weight: bold;vertical-align: baseline;">${h.repo_link(c.dbrepo.groups_and_repo)}</span>

                  <b>${'r%s:%s' % (h.get_changeset_safe(c.rhodecode_repo,'tip').revision,

                            h.get_changeset_safe(c.rhodecode_repo,'tip').short_id)}</b> - 

			      <span class="tooltip" title="${c.rhodecode_repo.last_change}">

			      ${h.age(c.rhodecode_repo.last_change)}</span><br/>

			      ${_('by')} ${h.get_changeset_safe(c.rhodecode_repo,'tip').author} 

		        %if len(c.rhodecode_repo.revisions) == 0:

			        ${h.select('download_options',c.rhodecode_repo.get_changeset().raw_id,c.download_options)}

			        %for cnt,archive in enumerate(c.rhodecode_repo._get_archives()):

			                h.url('files_archive_home',repo_name=c.dbrepo.repo_name,

	            ${h.link_to(_('RSS'),h.url('rss_feed_home',repo_name=c.dbrepo.repo_name,api_key=c.rhodecode_user.api_key),class_='rss_icon')}

	            ${h.link_to(_('Atom'),h.url('atom_feed_home',repo_name=c.dbrepo.repo_name,api_key=c.rhodecode_user.api_key),class_='atom_icon')}

                ${h.link_to(_('RSS'),h.url('rss_feed_home',repo_name=c.dbrepo.repo_name),class_='rss_icon')}

                ${h.link_to(_('Atom'),h.url('atom_feed_home',repo_name=c.dbrepo.repo_name),class_='atom_icon')}	           

                 %for cnt,archive in enumerate(c.rhodecode_repo._get_archives()):

                        h.url('files_archive_home',repo_name=c.dbrepo.repo_name,

from rhodecode.tests import *

class TestReposGroupsController(TestController):

    def test_index(self):

        response = self.app.get(url('repos_groups'))

        # Test response...

    def test_index_as_xml(self):

        response = self.app.get(url('formatted_repos_groups', format='xml'))

    def test_create(self):

        response = self.app.post(url('repos_groups'))

    def test_new(self):

        response = self.app.get(url('new_repos_group'))

    def test_new_as_xml(self):

        response = self.app.get(url('formatted_new_repos_group', format='xml'))

    def test_update(self):

        response = self.app.put(url('repos_group', id=1))

    def test_update_browser_fakeout(self):

        response = self.app.post(url('repos_group', id=1), params=dict(_method='put'))

    def test_delete(self):

        response = self.app.delete(url('repos_group', id=1))

    def test_delete_browser_fakeout(self):

        response = self.app.post(url('repos_group', id=1), params=dict(_method='delete'))

    def test_show(self):

        response = self.app.get(url('repos_group', id=1))

    def test_show_as_xml(self):

        response = self.app.get(url('formatted_repos_group', id=1, format='xml'))

    def test_edit(self):

        response = self.app.get(url('edit_repos_group', id=1))

    def test_edit_as_xml(self):

        response = self.app.get(url('formatted_edit_repos_group', id=1, format='xml'))