m.connect('admin_home', '', action='index')

        m.connect('admin_add_repo', '/add_repo/{new_repo:[a-z0-9\. _-]*}',

                  action='add_repo')

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

    # API V2

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

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='api/api') as m:

        m.connect('api', '/api')

    #USER JOURNAL

    rmap.connect('journal', '%s/journal' % ADMIN_PREFIX,

                 controller='journal', action='index')

    rmap.connect('journal_rss', '%s/journal/rss' % ADMIN_PREFIX,

                 controller='journal', action='journal_rss')

    rmap.connect('journal_atom', '%s/journal/atom' % ADMIN_PREFIX,

                 controller='journal', action='journal_atom')

    rmap.connect('public_journal', '%s/public_journal' % ADMIN_PREFIX,

                 controller='journal', action="public_journal")

    rmap.connect('public_journal_rss', '%s/public_journal/rss' % ADMIN_PREFIX,

                 controller='journal', action="public_journal_rss")

        defaults['id_fork_of'] = db_repo.fork.repo_id if db_repo.fork else ''

        return defaults

    @HasPermissionAllDecorator('hg.admin')

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

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

        # url('repos')

        c.repos_list = Repository.query()\

                        .order_by(func.lower(Repository.repo_name))\

                        .all()

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

    @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')

    def create(self):

        """

        POST /repos: Create a new item"""

        # url('repos')

        self.__load_defaults()

        form_result = {}

        try:

        c.group = RepoGroup.get_or_404(id)

        c.group_repos = c.group.repositories.all()

        #overwrite our cached list with current filter

        gr_filter = c.group_repos

        c.repo_cnt = 0

        groups = RepoGroup.query().order_by(RepoGroup.group_name)\

            .filter(RepoGroup.group_parent_id == id).all()

        c.groups = self.scm_model.get_repos_groups(groups)

        if c.visual.lightweight_dashboard is False:

        ## lightweight version of dashboard

        else:

            c.repos_list = Repository.query()\

                            .filter(Repository.group_id == id)\

                            .order_by(func.lower(Repository.repo_name))\

                            .all()

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

    @HasPermissionAnyDecorator('hg.admin')

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

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

        # url('edit_repos_group', id=ID)

        c.repos_group = ReposGroupModel()._get_repos_group(id)

        defaults = self.__load_data(c.repos_group.group_id)

        # we need to exclude this group from the group list for editing

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, \

    HasPermissionAnyDecorator, NotAnonymous

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.celerylib import tasks, run_task

from rhodecode.lib.utils import repo2db_mapper, invalidate_cache, \

    set_rhodecode_config, repo_name_slug, check_git_version

from rhodecode.model.db import RhodeCodeUi, Repository, RepoGroup, \

    RhodeCodeSetting, PullRequest, PullRequestReviewers

from rhodecode.model.forms import UserForm, ApplicationSettingsForm, \

    ApplicationUiSettingsForm, ApplicationVisualisationForm

from rhodecode.model.scm import ScmModel

from rhodecode.model.user import UserModel

from rhodecode.model.db import User

from rhodecode.model.notification import EmailNotificationModel

from rhodecode.model.meta import Session

from rhodecode.lib.utils2 import str2bool, safe_unicode

log = logging.getLogger(__name__)

class SettingsController(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('setting', 'settings', controller='admin/settings',

    #         path_prefix='/admin', name_prefix='admin_')

    @LoginRequired()

    def __before__(self):

            encoding="UTF-8",

            force_defaults=False

        )

    @NotAnonymous()

    def my_account(self):

        """

        GET /_admin/my_account Displays info about my account

        """

        # url('admin_settings_my_account')

        c.user = User.get(self.rhodecode_user.user_id)

        if c.user.username == 'default':

            h.flash(_("You can't edit this user since it's"

              " crucial for entire application"), category='warning')

            return redirect(url('users'))

        defaults = c.user.get_dict()

        c.form = htmlfill.render(

            render('admin/users/user_edit_my_account_form.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

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

    @NotAnonymous()

    def my_account_update(self):

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

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

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occurred during update of user %s') \

                    % form_result.get('username'), category='error')

        return redirect(url('my_account'))

    @NotAnonymous()

    def my_account_my_pullrequests(self):

        c.my_pull_requests = PullRequest.query()\

                                        self.rhodecode_user.user_id)\

                                .all()

        c.participate_in_pull_requests = \

            [x.pull_request for x in PullRequestReviewers.query()\

                                            self.rhodecode_user.user_id)\

                                    .all()]

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

    @NotAnonymous()

    @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')

    def create_repository(self):

        """GET /_admin/create_repository: Form to create a new item"""

        c.repo_groups = RepoGroup.groups_choices(check_perms=True)

        c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)

        choices, c.landing_revs = ScmModel().get_repo_landing_revs()

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import logging

from pylons import tmpl_context as c, request

from pylons.i18n.translation import _

from webob.exc import HTTPBadRequest

import rhodecode

from rhodecode.lib import helpers as h

from rhodecode.lib.ext_json import json

from rhodecode.lib.auth import LoginRequired

from rhodecode.lib.base import BaseController, render

from rhodecode.model.db import Repository

log = logging.getLogger(__name__)

class HomeController(BaseController):

    @LoginRequired()

    def __before__(self):

        super(HomeController, self).__before__()

    def index(self):

        c.groups = self.scm_model.get_repos_groups()

        c.group = None

        if c.visual.lightweight_dashboard is False:

            c.repos_list = self.scm_model.get_repos()

        ## lightweight version of dashboard

        else:

            c.repos_list = Repository.query()\

                            .filter(Repository.group_id == None)\

                            .order_by(func.lower(Repository.repo_name))\

                            .all()

        return render('/index.html')

    def repo_switcher(self):

        if request.is_xhr:

            all_repos = Repository.query().order_by(Repository.repo_name).all()

            c.repos_list = self.scm_model.get_repos(all_repos,

                                                    sort_key='name_sort',

                                                    simple=True)

            return render('/repo_switcher_list.html')

        else:

            raise HTTPBadRequest()

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import logging

from itertools import groupby

from sqlalchemy import or_

from sqlalchemy.orm import joinedload

from webhelpers.paginate import Page

from webhelpers.feedgenerator import Atom1Feed, Rss201rev2Feed

from webob.exc import HTTPBadRequest

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

from pylons.i18n.translation import _

import rhodecode.lib.helpers as h

from rhodecode.lib.auth import LoginRequired, NotAnonymous

from rhodecode.lib.base import BaseController, render

from rhodecode.model.db import UserLog, UserFollowing, Repository, User

from rhodecode.model.meta import Session

from rhodecode.lib.utils2 import safe_int, AttributeDict

from rhodecode.controllers.admin.admin import _journal_filter

log = logging.getLogger(__name__)

class JournalController(BaseController):

    def __before__(self):

        super(JournalController, self).__before__()

        self.language = 'en-us'

        self.ttl = "5"

        self.feed_nr = 20

        c.search_term = request.GET.get('filter')

        journal = self._get_journal_data(c.following)

        def url_generator(**kw):

            return url.current(filter=c.search_term, **kw)

        c.journal_pager = Page(journal, page=p, items_per_page=20, url=url_generator)

        c.journal_day_aggreagate = self._get_daily_aggregate(c.journal_pager)

        c.journal_data = render('journal/journal_data.html')

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

            return c.journal_data

    @LoginRequired(api_access=True)

    @NotAnonymous()

    def journal_atom(self):

        """

        Produce an atom-1.0 feed via feedgenerator module

        """

        following = self.sa.query(UserFollowing)\

            .filter(UserFollowing.user_id == self.rhodecode_user.user_id)\

            .options(joinedload(UserFollowing.follows_repository))\

            .all()

        return self._atom_feed(following, public=False)

from rhodecode.lib.vcs.backends import get_backend

from rhodecode.lib.compat import json

from rhodecode.lib.utils2 import LazyProperty, safe_str, safe_unicode,\

    remove_prefix

from rhodecode.lib.caching_query import FromCache

from rhodecode.lib.hooks import log_create_repository, log_delete_repository

from rhodecode.model import BaseModel

from rhodecode.model.db import Repository, UserRepoToPerm, User, Permission, \

    Statistics, UsersGroup, UsersGroupRepoToPerm, RhodeCodeUi, RepoGroup,\

    RhodeCodeSetting

from rhodecode.lib import helpers as h

log = logging.getLogger(__name__)

class RepoModel(BaseModel):

    cls = Repository

    URL_SEPARATOR = Repository.url_sep()

    def __get_users_group(self, users_group):

        return self._get_instance(UsersGroup, users_group,

    def get_users_groups_js(self):

        users_groups = self.sa.query(UsersGroup)\

            .filter(UsersGroup.users_group_active == True).all()

        return json.dumps([

            {

             'id': gr.users_group_id,

             'grname': gr.users_group_name,

             'grmembers': len(gr.members),

            } for gr in users_groups]

        )

    def _get_defaults(self, repo_name):

        """

        Get's information about repository, and returns a dict for

        usage in forms

        :param repo_name:

        """

        repo_info = Repository.get_by_repo_name(repo_name)

        if repo_info is None:

            return None

	padding-top: 0px;

	text-align: left;

}

.accept_icon {

    background: url("../images/icons/accept.png") no-repeat scroll 3px;

    padding-left: 20px;

    padding-top: 0px;

    text-align: left;

}

.edit_icon {

	padding-left: 20px;

	padding-top: 0px;

	text-align: left;

}

.delete_icon {

	background: url("../images/icons/delete.png") no-repeat scroll 3px;

	padding-left: 20px;

	padding-top: 0px;

	text-align: left;

}

  var url = "${h.url('formatted_users', format='json')}";

  var data = ${c.data|n};

  var myDataSource = new YAHOO.util.DataSource(data);

  myDataSource.responseType = YAHOO.util.DataSource.TYPE_JSON;

  myDataSource.responseSchema = {

      resultsList: "records",

      fields: [

         {key:"menu"},

         {key:"raw_name"},

         {key:"name"},

         {key:"desc"},

         {key:"owner"},

         {key:"action"},

      ]

   };

  myDataSource.doBeforeCallback = function(req,raw,res,cb) {

      // This is the filter function

      var data     = res.results || [],

          filtered = [],

          i,l;

      if (req) {

          req = req.toLowerCase();

          res.results = filtered;

      }

      YUD.get('repo_count').innerHTML = res.results.length;

      return res;

  }

  // main table sorting

  var myColumnDefs = [

      {key:"menu",label:"",sortable:false,className:"quick_repo_menu hidden"},

      {key:"name",label:"${_('Name')}",sortable:true,

    	  sortOptions: { sortFunction: nameSort }},

      {key:"desc",label:"${_('Description')}",sortable:true},

      {key:"owner",label:"${_('Owner')}",sortable:true},

      {key:"action",label:"${_('Action')}",sortable:false},

  ];

  var myDataTable = new YAHOO.widget.DataTable("repos_list_wrap", myColumnDefs, myDataSource,{

    sortedBy:{key:"name",dir:"asc"},

    paginator: new YAHOO.widget.Paginator({

        alwaysVisible: false,

        template : "{PreviousPageLink} {FirstPageLink} {PageLinks} {LastPageLink} {NextPageLink}",

        pageLinks: 5,

        containerClass: 'pagination-wh',

        currentPageClass: 'pager_curpage',

        pageLinkClass: 'pager_link',

        nextPageLinkLabel: '>',

        previousPageLinkLabel: '<',

        firstPageLinkLabel: '<<',

        lastPageLinkLabel: '>>',

        containers:['user-paginator']

    }),

      tooltip_activate();

      quick_repo_menu();

  });

  var filterTimeout = null;

  updateFilter  = function () {

      // Reset timeout

      filterTimeout = null;

      // Reset sort

      var state = myDataTable.getState();

      // Get filtered data

      myDataSource.sendRequest(YUD.get('q_filter').value,{

          success : myDataTable.onDataReturnInitializeTable,

          failure : myDataTable.onDataReturnInitializeTable,

          scope   : myDataTable,

          argument: state

      });

  };

  YUE.on('q_filter','click',function(){

   });

  YUE.on('q_filter','keyup',function (e) {

      clearTimeout(filterTimeout);

      filterTimeout = setTimeout(updateFilter,600);

  });

</script>

</%def>

           </li>

           <li>

             <span><a id="show_pullrequests" class="link-white" href="#pullrequests">${_('My pull requests')}</a> </span>

           </li>

           %if h.HasPermissionAny('hg.admin','hg.create.repository')():

             <li>

               <span>${h.link_to(_('Add repo'),h.url('admin_settings_create_repository'))}</span>

             </li>

           %endif

         </ul>

    </div>

    <!-- end box / title -->