white space cleanup

rhodecode/lib/cleanup.py

@@ -1,143 +1,142 b''
 # -*- coding: utf-8 -*-
 """
     package.rhodecode.lib.cleanup
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     :created_on: Jul 14, 2012
     :author: marcink
     :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
 # 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/>.
 from __future__ import with_statement
 
 import os
 import sys
 import re
 import shutil
 import logging
 import datetime
 
 from os.path import dirname as dn, join as jn
 from rhodecode.model import init_model
 from rhodecode.lib.utils2 import engine_from_config
 from rhodecode.model.db import RhodeCodeUi
 
 
 #to get the rhodecode import
 sys.path.append(dn(dn(dn(os.path.realpath(__file__)))))
 
 from rhodecode.lib.utils import BasePasterCommand, Command, ask_ok,\
     REMOVED_REPO_PAT, add_cache
 
 log = logging.getLogger(__name__)
 
 
 class CleanupCommand(BasePasterCommand):
 
     max_args = 1
     min_args = 1
 
     usage = "CONFIG_FILE"
     summary = "Cleanup deleted repos"
     group_name = "RhodeCode"
     takes_config_file = -1
     parser = Command.standard_parser(verbose=True)
 
     def _parse_older_than(self, val):
         regex = re.compile(r'((?P<days>\d+?)d)?((?P<hours>\d+?)h)?((?P<minutes>\d+?)m)?((?P<seconds>\d+?)s)?')
         parts = regex.match(val)
         if not parts:
             return
         parts = parts.groupdict()
         time_params = {}
         for (name, param) in parts.iteritems():
             if param:
                 time_params[name] = int(param)
         return datetime.timedelta(**time_params)
 
     def _extract_date(self, name):
         """
         Extract the date part from rm__<date> pattern of removed repos,
         and convert it to datetime object
 
         :param name:
         """
         date_part = name[4:19]  # 4:19 since we don't parse milisecods
         return datetime.datetime.strptime(date_part, '%Y%m%d_%H%M%S')
 
     def command(self):
         logging.config.fileConfig(self.path_to_ini_file)
         from pylons import config
 
         #get to remove repos !!
         add_cache(config)
         engine = engine_from_config(config, 'sqlalchemy.db1.')
         init_model(engine)
 
         repos_location = RhodeCodeUi.get_repos_location()
         to_remove = []
         for loc in os.listdir(repos_location):
             if REMOVED_REPO_PAT.match(loc):
                 to_remove.append([loc, self._extract_date(loc)])
 
         #filter older than (if present)!
         now = datetime.datetime.now()
         older_than = self.options.older_than
         if older_than:
             to_remove_filtered = []
             older_than_date = self._parse_older_than(older_than)
             for name, date_ in to_remove:
                 repo_age = now - date_
                 if repo_age > older_than_date:
                     to_remove_filtered.append([name, date_])
 
             to_remove = to_remove_filtered
             print >> sys.stdout, 'removing [%s] deleted repos older than %s[%s]' \
                 % (len(to_remove), older_than, older_than_date)
         else:
             print >> sys.stdout, 'removing all [%s] deleted repos' \
                 % len(to_remove)
         if self.options.dont_ask or not to_remove:
             # don't ask just remove !
             remove = True
         else:
             remove = ask_ok('are you sure to remove listed repos \n%s [y/n]?'
                             % ', \n'.join(['%s removed on %s' % (x[0], x[1])
                                            for x in to_remove]))
 
         if remove:
             for name, date_ in to_remove:
                 print >> sys.stdout, 'removing repository %s' % name
                 shutil.rmtree(os.path.join(repos_location, name))
         else:
             print 'nothing done exiting...'
             sys.exit(0)
 
     def update_parser(self):
         self.parser.add_option('--older-than',
                           action='store',
                           dest='older_than',
                           help=(
                             "only remove repos that have been removed "
                             "at least given time ago "
                             "ex. --older-than=30d deletes repositores "
                             "removed more than 30days ago. Possible options "
                             "d[ays]/h[ours]/m[inutes]/s[seconds]. OPTIONAL"),
                           )
         self.parser.add_option('--dont-ask',
                                action='store_true',
                                dest='dont_ask',
                                help=("Don't ask to remove repos"))
-        
  No newline at end of file

rhodecode/lib/indexers/__init__.py

@@ -1,264 +1,264 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.lib.indexers.__init__
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     Whoosh indexing module for RhodeCode
 
     :created_on: Aug 17, 2010
     :author: marcink
     :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
 # 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 os
 import sys
 import traceback
 import logging
 from os.path import dirname as dn, join as jn
 
 #to get the rhodecode import
 sys.path.append(dn(dn(dn(os.path.realpath(__file__)))))
 
 from string import strip
 from shutil import rmtree
 
 from whoosh.analysis import RegexTokenizer, LowercaseFilter, StopFilter
 from whoosh.fields import TEXT, ID, STORED, NUMERIC, BOOLEAN, Schema, FieldType
 from whoosh.index import create_in, open_dir
 from whoosh.formats import Characters
 from whoosh.highlight import highlight, HtmlFormatter, ContextFragmenter
 
 from webhelpers.html.builder import escape, literal
 from sqlalchemy import engine_from_config
 
 from rhodecode.model import init_model
 from rhodecode.model.scm import ScmModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.config.environment import load_environment
 from rhodecode.lib.utils2 import LazyProperty
 from rhodecode.lib.utils import BasePasterCommand, Command, add_cache,\
     load_rcextensions
 
 log = logging.getLogger(__name__)
 
 # CUSTOM ANALYZER wordsplit + lowercase filter
 ANALYZER = RegexTokenizer(expression=r"\w+") | LowercaseFilter()
 
 #INDEX SCHEMA DEFINITION
 SCHEMA = Schema(
     fileid=ID(unique=True),
     owner=TEXT(),
     repository=TEXT(stored=True),
     path=TEXT(stored=True),
     content=FieldType(format=Characters(), analyzer=ANALYZER,
                       scorable=True, stored=True),
     modtime=STORED(),
     extension=TEXT(stored=True)
 )
 
 IDX_NAME = 'HG_INDEX'
 FORMATTER = HtmlFormatter('span', between='\n<span class="break">...</span>\n')
 FRAGMENTER = ContextFragmenter(200)
 
 CHGSETS_SCHEMA = Schema(
     raw_id=ID(unique=True, stored=True),
     last=BOOLEAN(),
     owner=TEXT(),
     repository=ID(unique=True, stored=True),
     author=TEXT(stored=True),
     message=FieldType(format=Characters(), analyzer=ANALYZER,
                       scorable=True, stored=True),
     parents=TEXT(),
     added=TEXT(),
     removed=TEXT(),
     changed=TEXT(),
 )
 
 CHGSET_IDX_NAME = 'CHGSET_INDEX'
 
 class MakeIndex(BasePasterCommand):
 
     max_args = 1
     min_args = 1
 
     usage = "CONFIG_FILE"
     summary = "Creates index for full text search given configuration file"
     group_name = "RhodeCode"
     takes_config_file = -1
     parser = Command.standard_parser(verbose=True)
 
     def command(self):
         logging.config.fileConfig(self.path_to_ini_file)
         from pylons import config
         add_cache(config)
         engine = engine_from_config(config, 'sqlalchemy.db1.')
         init_model(engine)
         index_location = config['index_dir']
         repo_location = self.options.repo_location \
             if self.options.repo_location else RepoModel().repos_path
         repo_list = map(strip, self.options.repo_list.split(',')) \
             if self.options.repo_list else None
         repo_update_list = map(strip, self.options.repo_update_list.split(',')) \
             if self.options.repo_update_list else None
         load_rcextensions(config['here'])
         #======================================================================
         # WHOOSH DAEMON
         #======================================================================
         from rhodecode.lib.pidlock import LockHeld, DaemonLock
         from rhodecode.lib.indexers.daemon import WhooshIndexingDaemon
         try:
             l = DaemonLock(file_=jn(dn(dn(index_location)), 'make_index.lock'))
             WhooshIndexingDaemon(index_location=index_location,
                                  repo_location=repo_location,
                                  repo_list=repo_list,
                                  repo_update_list=repo_update_list)\
                 .run(full_index=self.options.full_index)
             l.release()
         except LockHeld:
             sys.exit(1)
 
     def update_parser(self):
         self.parser.add_option('--repo-location',
                           action='store',
                           dest='repo_location',
                           help="Specifies repositories location to index OPTIONAL",
                           )
         self.parser.add_option('--index-only',
                           action='store',
                           dest='repo_list',
                           help="Specifies a comma separated list of repositores "
                                 "to build index on. If not given all repositories "
                                 "are scanned for indexing. OPTIONAL",
                           )
         self.parser.add_option('--update-only',
                           action='store',
                           dest='repo_update_list',
                           help="Specifies a comma separated list of repositores "
                                 "to re-build index on. OPTIONAL",
                           )
         self.parser.add_option('-f',
                           action='store_true',
                           dest='full_index',
                           help="Specifies that index should be made full i.e"
                                 " destroy old and build from scratch",
                           default=False)
 
 
 class WhooshResultWrapper(object):
     def __init__(self, search_type, searcher, matcher, highlight_items,
                  repo_location):
         self.search_type = search_type
         self.searcher = searcher
         self.matcher = matcher
         self.highlight_items = highlight_items
         self.fragment_size = 200
         self.repo_location = repo_location
 
     @LazyProperty
     def doc_ids(self):
         docs_id = []
         while self.matcher.is_active():
             docnum = self.matcher.id()
             chunks = [offsets for offsets in self.get_chunks()]
             docs_id.append([docnum, chunks])
             self.matcher.next()
         return docs_id
 
     def __str__(self):
         return '<%s at %s>' % (self.__class__.__name__, len(self.doc_ids))
 
     def __repr__(self):
         return self.__str__()
 
     def __len__(self):
         return len(self.doc_ids)
 
     def __iter__(self):
         """
         Allows Iteration over results,and lazy generate content
 
         *Requires* implementation of ``__getitem__`` method.
         """
         for docid in self.doc_ids:
             yield self.get_full_content(docid)
 
     def __getitem__(self, key):
         """
         Slicing of resultWrapper
         """
         i, j = key.start, key.stop
 
         slices = []
         for docid in self.doc_ids[i:j]:
             slices.append(self.get_full_content(docid))
         return slices
 
     def get_full_content(self, docid):
         res = self.searcher.stored_fields(docid[0])
         log.debug('result: %s' % res)
         if self.search_type == 'content':
             full_repo_path = jn(self.repo_location, res['repository'])
             f_path = res['path'].split(full_repo_path)[-1]
             f_path = f_path.lstrip(os.sep)
             content_short = self.get_short_content(res, docid[1])
             res.update({'content_short': content_short,
                         'content_short_hl': self.highlight(content_short),
                         'f_path': f_path
                       })
         elif self.search_type == 'message':
             res.update({'message_hl': self.highlight(res['message'])})
 
         log.debug('result: %s' % res)
 
         return res
 
     def get_short_content(self, res, chunks):
 
         return ''.join([res['content'][chunk[0]:chunk[1]] for chunk in chunks])
 
     def get_chunks(self):
         """
         Smart function that implements chunking the content
         but not overlap chunks so it doesn't highlight the same
         close occurrences twice.
 
         :param matcher:
         :param size:
         """
         memory = [(0, 0)]
-        if self.matcher.supports('positions'): 
+        if self.matcher.supports('positions'):
             for span in self.matcher.spans():
                 start = span.startchar or 0
                 end = span.endchar or 0
                 start_offseted = max(0, start - self.fragment_size)
                 end_offseted = end + self.fragment_size
 
                 if start_offseted < memory[-1][1]:
                     start_offseted = memory[-1][1]
                 memory.append((start_offseted, end_offseted,))
                 yield (start_offseted, end_offseted,)
 
     def highlight(self, content, top=5):
         if self.search_type not in ['content', 'message']:
             return ''
         hl = highlight(
             text=content,
             terms=self.highlight_items,
             analyzer=ANALYZER,
             fragmenter=FRAGMENTER,
             formatter=FORMATTER,
             top=top
         )
         return hl

rhodecode/lib/middleware/simplehg.py

@@ -1,261 +1,261 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.lib.middleware.simplehg
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     SimpleHG middleware for handling mercurial protocol request
     (push/clone etc.). It's implemented with basic auth function
 
     :created_on: Apr 28, 2010
     :author: marcink
     :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
 # 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 os
 import logging
 import traceback
 import urllib
 
 from mercurial.error import RepoError
 from mercurial.hgweb import hgweb_mod
 
 from paste.httpheaders import REMOTE_USER, AUTH_TYPE
 from webob.exc import HTTPNotFound, HTTPForbidden, HTTPInternalServerError, \
     HTTPBadRequest, HTTPNotAcceptable
 
 from rhodecode.lib.utils2 import safe_str
 from rhodecode.lib.base import BaseVCSController
 from rhodecode.lib.auth import get_container_username
 from rhodecode.lib.utils import make_ui, is_valid_repo, ui_sections
 from rhodecode.model.db import User
 
 
 log = logging.getLogger(__name__)
 
 
 def is_mercurial(environ):
     """
     Returns True if request's target is mercurial server - header
     ``HTTP_ACCEPT`` of such request would start with ``application/mercurial``.
     """
     http_accept = environ.get('HTTP_ACCEPT')
     path_info = environ['PATH_INFO']
     if http_accept and http_accept.startswith('application/mercurial'):
         ishg_path = True
     else:
         ishg_path = False
 
     log.debug('pathinfo: %s detected as HG %s' % (
         path_info, ishg_path)
     )
     return ishg_path
 
 
 class SimpleHg(BaseVCSController):
 
     def _handle_request(self, environ, start_response):
         if not is_mercurial(environ):
             return self.application(environ, start_response)
         if not self._check_ssl(environ, start_response):
             return HTTPNotAcceptable('SSL REQUIRED !')(environ, start_response)
 
         ipaddr = self._get_ip_addr(environ)
-        username = None 
+        username = None
         # skip passing error to error controller
         environ['pylons.status_code_redirect'] = True
 
         #======================================================================
         # EXTRACT REPOSITORY NAME FROM ENV
         #======================================================================
         try:
             repo_name = environ['REPO_NAME'] = self.__get_repository(environ)
             log.debug('Extracted repo name is %s' % repo_name)
         except:
             return HTTPInternalServerError()(environ, start_response)
 
         # quick check if that dir exists...
         if is_valid_repo(repo_name, self.basepath) is False:
             return HTTPNotFound()(environ, start_response)
 
         #======================================================================
         # GET ACTION PULL or PUSH
         #======================================================================
         action = self.__get_action(environ)
 
         #======================================================================
         # CHECK ANONYMOUS PERMISSION
         #======================================================================
         if action in ['pull', 'push']:
             anonymous_user = self.__get_user('default')
             username = anonymous_user.username
             anonymous_perm = self._check_permission(action, anonymous_user,
                                                     repo_name)
 
             if anonymous_perm is not True or anonymous_user.active is False:
                 if anonymous_perm is not True:
                     log.debug('Not enough credentials to access this '
                               'repository as anonymous user')
                 if anonymous_user.active is False:
                     log.debug('Anonymous access is disabled, running '
                               'authentication')
                 #==============================================================
                 # DEFAULT PERM FAILED OR ANONYMOUS ACCESS IS DISABLED SO WE
                 # NEED TO AUTHENTICATE AND ASK FOR AUTH USER PERMISSIONS
                 #==============================================================
 
                 # Attempting to retrieve username from the container
                 username = get_container_username(environ, self.config)
 
                 # If not authenticated by the container, running basic auth
                 if not username:
                     self.authenticate.realm = \
                         safe_str(self.config['rhodecode_realm'])
                     result = self.authenticate(environ)
                     if isinstance(result, str):
                         AUTH_TYPE.update(environ, 'basic')
                         REMOTE_USER.update(environ, result)
                         username = result
                     else:
                         return result.wsgi_application(environ, start_response)
 
                 #==============================================================
                 # CHECK PERMISSIONS FOR THIS REQUEST USING GIVEN USERNAME
                 #==============================================================
                 try:
                     user = self.__get_user(username)
                     if user is None or not user.active:
                         return HTTPForbidden()(environ, start_response)
                     username = user.username
                 except:
                     log.error(traceback.format_exc())
                     return HTTPInternalServerError()(environ, start_response)
 
                 #check permissions for this repository
                 perm = self._check_permission(action, user, repo_name)
                 if perm is not True:
                     return HTTPForbidden()(environ, start_response)
 
         # extras are injected into mercurial UI object and later available
         # in hg hooks executed by rhodecode
         extras = {
             'ip': ipaddr,
             'username': username,
             'action': action,
             'repository': repo_name,
             'scm': 'hg',
         }
 
         #======================================================================
         # MERCURIAL REQUEST HANDLING
         #======================================================================
         repo_path = os.path.join(safe_str(self.basepath), safe_str(repo_name))
         log.debug('Repository path is %s' % repo_path)
 
         baseui = make_ui('db')
         self.__inject_extras(repo_path, baseui, extras)
 
         try:
             # invalidate cache on push
             if action == 'push':
                 self._invalidate_cache(repo_name)
             log.info('%s action on HG repo "%s"' % (action, repo_name))
             app = self.__make_app(repo_path, baseui, extras)
             return app(environ, start_response)
         except RepoError, e:
             if str(e).find('not found') != -1:
                 return HTTPNotFound()(environ, start_response)
         except Exception:
             log.error(traceback.format_exc())
             return HTTPInternalServerError()(environ, start_response)
 
     def __make_app(self, repo_name, baseui, extras):
         """
         Make an wsgi application using hgweb, and inject generated baseui
         instance, additionally inject some extras into ui object
         """
         return hgweb_mod.hgweb(repo_name, name=repo_name, baseui=baseui)
 
     def __get_repository(self, environ):
         """
         Get's repository name out of PATH_INFO header
 
         :param environ: environ where PATH_INFO is stored
         """
         try:
             environ['PATH_INFO'] = self._get_by_id(environ['PATH_INFO'])
             repo_name = '/'.join(environ['PATH_INFO'].split('/')[1:])
             if repo_name.endswith('/'):
                 repo_name = repo_name.rstrip('/')
         except:
             log.error(traceback.format_exc())
             raise
 
         return repo_name
 
     def __get_user(self, username):
         return User.get_by_username(username)
 
     def __get_action(self, environ):
         """
         Maps mercurial request commands into a clone,pull or push command.
         This should always return a valid command string
 
         :param environ:
         """
         mapping = {'changegroup': 'pull',
                    'changegroupsubset': 'pull',
                    'stream_out': 'pull',
                    'listkeys': 'pull',
                    'unbundle': 'push',
                    'pushkey': 'push', }
         for qry in environ['QUERY_STRING'].split('&'):
             if qry.startswith('cmd'):
                 cmd = qry.split('=')[-1]
                 if cmd in mapping:
                     return mapping[cmd]
 
                 return 'pull'
 
         raise Exception('Unable to detect pull/push action !!'
                         'Are you using non standard command or client ?')
 
     def __inject_extras(self, repo_path, baseui, extras={}):
         """
         Injects some extra params into baseui instance
 
         also overwrites global settings with those takes from local hgrc file
 
         :param baseui: baseui instance
         :param extras: dict with extra params to put into baseui
         """
 
         hgrc = os.path.join(repo_path, '.hg', 'hgrc')
 
         # make our hgweb quiet so it doesn't print output
         baseui.setconfig('ui', 'quiet', 'true')
 
         #inject some additional parameters that will be available in ui
         #for hooks
         for k, v in extras.items():
             baseui.setconfig('rhodecode_extras', k, v)
 
         repoui = make_ui('file', hgrc, False)
 
         if repoui:
             #overwrite our ui instance with the section from hgrc file
             for section in ui_sections:
                 for k, v in repoui.configitems(section):
                     baseui.setconfig(section, k, v)

rhodecode/lib/rcmail/utils.py

@@ -1,19 +1,19 b''
 """
 Email message and email sending related helper functions.
 """
 
 import socket
 
 
 # Cache the hostname, but do it lazily: socket.getfqdn() can take a couple of
 # seconds, which slows down the restart of the server.
 class CachedDnsName(object):
     def __str__(self):
         return self.get_fqdn()
 
     def get_fqdn(self):
         if not hasattr(self, '_fqdn'):
             self._fqdn = socket.getfqdn()
         return self._fqdn
 
-DNS_NAME = CachedDnsName()
  No newline at end of file
+DNS_NAME = CachedDnsName()

rhodecode/templates/admin/notifications/notifications.html

@@ -1,65 +1,65 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${_('My Notifications')} ${c.rhodecode_user.username} - ${c.rhodecode_name}
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${_('My Notifications')}
 </%def>
 
 <%def name="page_nav()">
 	${self.menu('admin')}
 </%def>
 
 <%def name="main()">
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
         ##<ul class="links">
         ##    <li>
         ##      <span style="text-transform: uppercase;"><a href="#">${_('Compose message')}</a></span>
         ##    </li>
         ##</ul>
     </div>
-    
+
       <div style="padding:14px 18px;text-align: right;float:left">
       <span id='all' class="ui-btn"><a href="${h.url.current()}">${_('All')}</a></span>
       <span id='comment' class="ui-btn"><a href="${h.url.current(type=c.comment_type)}">${_('Comments')}</a></span>
       <span id='pull_request' class="ui-btn"><a href="${h.url.current(type=c.pull_request_type)}">${_('Pull requests')}</a></span>
       </div>
       %if c.notifications:
       <div style="padding:14px 18px;text-align: right;float:right">
       <span id='mark_all_read' class="ui-btn">${_('Mark all read')}</span>
       </div>
       %endif
   <div id='notification_data'>
     <%include file='notifications_data.html'/>
   </div>
 </div>
 <script type="text/javascript">
 var url_action = "${url('notification', notification_id='__NOTIFICATION_ID__')}";
 var run = function(){
   YUE.on(YUQ('.delete-notification'),'click',function(e){
    var notification_id = e.currentTarget.id;
    deleteNotification(url_action,notification_id)
   })
   YUE.on(YUQ('.read-notification'),'click',function(e){
      var notification_id = e.currentTarget.id;
      readNotification(url_action,notification_id)
   })
 }
 run()
 YUE.on('mark_all_read','click',function(e){
     var url = "${h.url('notifications_mark_all_read', **request.GET.mixed())}";
     ypjax(url,'notification_data',function(){run()});
 })
 
 var current_filter = "${c.current_filter}";
 if (YUD.get(current_filter)){
 	YUD.addClass(current_filter, 'active');
 }
 </script>
 </%def>

rhodecode/templates/admin/notifications/notifications_data.html

@@ -1,40 +1,40 b''
 
 %if c.notifications:
 <%
 unread = lambda n:{False:'unread'}.get(n)
 %>
 
 
 <div class="notification-list  notification-table">
 %for notification in c.notifications:
   <div id="notification_${notification.notification.notification_id}" class="container ${unread(notification.read)}">
     <div class="notification-header">
       <div class="gravatar">
           <img alt="gravatar" src="${h.gravatar_url(h.email(notification.notification.created_by_user.email),24)}"/>
       </div>
       <div class="desc ${unread(notification.read)}">
       <a href="${url('notification', notification_id=notification.notification.notification_id)}">${notification.notification.description}</a>
       </div>
       <div class="delete-notifications">
         <span id="${notification.notification.notification_id}" class="delete-notification delete_icon action"></span>
       </div>
       %if not notification.read:
       <div class="read-notifications">
         <span id="${notification.notification.notification_id}" class="read-notification accept_icon action"></span>
-      </div>      
+      </div>
       %endif
     </div>
     <div class="notification-subject">${h.literal(notification.notification.subject)}</div>
   </div>
 %endfor
 </div>
 
 <div class="notification-paginator">
   <div class="pagination-wh pagination-left">
   ${c.notifications.pager('$link_previous ~2~ $link_next',**request.GET.mixed())}
   </div>
 </div>
 
 %else:
     <div class="table">${_('No notifications here yet')}</div>
 %endif

rhodecode/templates/admin/repos/repos.html

@@ -1,135 +1,135 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${_('Repositories administration')} - ${c.rhodecode_name}
 </%def>
 
 <%def name="breadcrumbs_links()">
     <input class="q_filter_box" id="q_filter" size="15" type="text" name="filter" value="${_('quick filter...')}"/> ${h.link_to(_('Admin'),h.url('admin_home'))} &raquo; <span id="repo_count">0</span> ${_('repositories')}
 </%def>
 <%def name="page_nav()">
 	${self.menu('admin')}
 </%def>
 <%def name="main()">
 <div class="box">
 
     <div class="title">
         ${self.breadcrumbs()}
         <ul class="links">
           <li>
             <span>${h.link_to(_(u'ADD REPOSITORY'),h.url('new_repo'))}</span>
           </li>
         </ul>
     </div>
     <div class="table yui-skin-sam" id="repos_list_wrap"></div>
     <div id="user-paginator" style="padding: 0px 0px 0px 20px"></div>
-    
+
 
 </div>
 <script>
   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();
           for (i = 0; i<data.length; i++) {
               var pos = data[i].raw_name.toLowerCase().indexOf(req)
               if (pos != -1) {
                   filtered.push(data[i]);
               }
           }
           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({
         rowsPerPage: 15,
         alwaysVisible: false,
         template : "{PreviousPageLink} {FirstPageLink} {PageLinks} {LastPageLink} {NextPageLink}",
         pageLinks: 5,
         containerClass: 'pagination-wh',
         currentPageClass: 'pager_curpage',
         pageLinkClass: 'pager_link',
         nextPageLinkLabel: '&gt;',
         previousPageLinkLabel: '&lt;',
         firstPageLinkLabel: '&lt;&lt;',
         lastPageLinkLabel: '&gt;&gt;',
         containers:['user-paginator']
     }),
 
     MSG_SORTASC:"${_('Click to sort ascending')}",
     MSG_SORTDESC:"${_('Click to sort descending')}",
     MSG_EMPTY:"${_('No records found.')}",
     MSG_ERROR:"${_('Data error.')}",
     MSG_LOADING:"${_('Loading...')}",
   }
   );
   myDataTable.subscribe('postRenderEvent',function(oArgs) {
       tooltip_activate();
       quick_repo_menu();
   });
-  
+
   var filterTimeout = null;
 
   updateFilter  = function () {
       // Reset timeout
       filterTimeout = null;
 
       // Reset sort
       var state = myDataTable.getState();
           state.sortedBy = {key:'name', dir:YAHOO.widget.DataTable.CLASS_ASC};
 
       // 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(){
       YUD.get('q_filter').value = '';
    });
 
   YUE.on('q_filter','keyup',function (e) {
       clearTimeout(filterTimeout);
       filterTimeout = setTimeout(updateFilter,600);
-  });  
+  });
 </script>
 
 </%def>

rhodecode/templates/admin/users/user_edit.html

@@ -1,264 +1,264 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${_('Edit user')} ${c.user.username} - ${c.rhodecode_name}
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${h.link_to(_('Admin'),h.url('admin_home'))}
     &raquo;
     ${h.link_to(_('Users'),h.url('users'))}
     &raquo;
     ${_('edit')} "${c.user.username}"
 </%def>
 
 <%def name="page_nav()">
 	${self.menu('admin')}
 </%def>
 
 <%def name="main()">
 <div class="box box-left">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
     <!-- end box / title -->
     ${h.form(url('update_user', id=c.user.user_id),method='put')}
     <div class="form">
         <div class="field">
            <div class="gravatar_box">
                <div class="gravatar"><img alt="gravatar" src="${h.gravatar_url(c.user.email)}"/></div>
                 <p>
                 %if c.use_gravatar:
                 <strong>${_('Change your avatar at')} <a href="http://gravatar.com">gravatar.com</a></strong>
                 <br/>${_('Using')} ${c.user.email}
                 %else:
                 <br/>${c.user.email}
                 %endif
            </div>
         </div>
         <div class="field">
             <div class="label">
                 <label>${_('API key')}</label> ${c.user.api_key}
             </div>
         </div>
 
         <div class="fields">
              <div class="field">
                 <div class="label">
                     <label for="username">${_('Username')}:</label>
                 </div>
                 <div class="input">
                     ${h.text('username',class_='medium')}
                 </div>
              </div>
 
              <div class="field">
                 <div class="label">
                     <label for="ldap_dn">${_('LDAP DN')}:</label>
                 </div>
                 <div class="input">
                     ${h.text('ldap_dn',class_='medium disabled',readonly="readonly")}
                 </div>
              </div>
 
              <div class="field">
                 <div class="label">
                     <label for="new_password">${_('New password')}:</label>
                 </div>
                 <div class="input">
                     ${h.password('new_password',class_='medium',autocomplete="off")}
                 </div>
              </div>
 
              <div class="field">
                 <div class="label">
                     <label for="password_confirmation">${_('New password confirmation')}:</label>
                 </div>
                 <div class="input">
                     ${h.password('password_confirmation',class_="medium",autocomplete="off")}
                 </div>
              </div>
 
              <div class="field">
                 <div class="label">
                     <label for="firstname">${_('First Name')}:</label>
                 </div>
                 <div class="input">
                     ${h.text('firstname',class_='medium')}
                 </div>
              </div>
 
              <div class="field">
                 <div class="label">
                     <label for="lastname">${_('Last Name')}:</label>
                 </div>
                 <div class="input">
                     ${h.text('lastname',class_='medium')}
                 </div>
              </div>
 
              <div class="field">
                 <div class="label">
                     <label for="email">${_('Email')}:</label>
                 </div>
                 <div class="input">
                     ${h.text('email',class_='medium')}
                 </div>
              </div>
 
              <div class="field">
                 <div class="label label-checkbox">
                     <label for="active">${_('Active')}:</label>
                 </div>
                 <div class="checkboxes">
                     ${h.checkbox('active',value=True)}
                 </div>
              </div>
 
              <div class="field">
                 <div class="label label-checkbox">
                     <label for="admin">${_('Admin')}:</label>
                 </div>
                 <div class="checkboxes">
                     ${h.checkbox('admin',value=True)}
                 </div>
              </div>
             <div class="buttons">
               ${h.submit('save',_('Save'),class_="ui-btn large")}
               ${h.reset('reset',_('Reset'),class_="ui-btn large")}
             </div>
     	</div>
     </div>
     ${h.end_form()}
 </div>
 <div style="min-height:780px" class="box box-right">
     <!-- box / title -->
     <div class="title">
         <h5>${_('Permissions')}</h5>
     </div>
     ${h.form(url('user_perm', id=c.user.user_id),method='put')}
     <div class="form">
         <!-- fields -->
         <div class="fields">
              <div class="field">
                 <div class="label label-checkbox">
                     <label for="create_repo_perm">${_('Create repositories')}:</label>
                 </div>
                 <div class="checkboxes">
                     ${h.checkbox('create_repo_perm',value=True)}
                 </div>
              </div>
             <div class="buttons">
               ${h.submit('save',_('Save'),class_="ui-btn large")}
               ${h.reset('reset',_('Reset'),class_="ui-btn large")}
             </div>
         </div>
     </div>
     ${h.end_form()}
 
     ## permissions overview
     <div id="perms" class="table">
            %for section in sorted(c.perm_user.permissions.keys()):
               <div class="perms_section_head">${section.replace("_"," ").capitalize()}</div>
               %if not c.perm_user.permissions[section]:
                   <span style="color:#B9B9B9">${_('Nothing here yet')}</span>
               %else:
               <div id='tbl_list_wrap_${section}' class="yui-skin-sam">
                <table id="tbl_list_${section}">
                 <thead>
                     <tr>
                     <th class="left">${_('Name')}</th>
                     <th class="left">${_('Permission')}</th>
                     <th class="left">${_('Edit Permission')}</th>
                 </thead>
                 <tbody>
                 %for k in c.perm_user.permissions[section]:
                      <%
                      if section != 'global':
                          section_perm = c.perm_user.permissions[section].get(k)
                          _perm = section_perm.split('.')[-1]
                      else:
                          _perm = section_perm = None
                      %>
                     <tr>
                         <td>
                             %if section == 'repositories':
                                 <a href="${h.url('summary_home',repo_name=k)}">${k}</a>
                             %elif section == 'repositories_groups':
                                 <a href="${h.url('repos_group_home',group_name=k)}">${k}</a>
                             %else:
                                 ${h.get_permission_name(k)}
                             %endif
                         </td>
                         <td>
                             %if section == 'global':
                              ${h.bool2icon(k.split('.')[-1] != 'none')}
                             %else:
                              <span class="perm_tag ${_perm}">${section_perm}</span>
                             %endif
                         </td>
                         <td>
                             %if section == 'repositories':
                                 <a href="${h.url('edit_repo',repo_name=k,anchor='permissions_manage')}">${_('edit')}</a>
                             %elif section == 'repositories_groups':
                                 <a href="${h.url('edit_repos_group',id=k,anchor='permissions_manage')}">${_('edit')}</a>
                             %else:
                                 --
-                            %endif                        
+                            %endif
                         </td>
                     </tr>
                 %endfor
                 </tbody>
                </table>
               </div>
               %endif
            %endfor
     </div>
 </div>
 <div class="box box-left">
     <!-- box / title -->
     <div class="title">
         <h5>${_('Email addresses')}</h5>
     </div>
 
     <div class="emails_wrap">
       <table class="noborder">
       %for em in c.user_email_map:
         <tr>
             <td><div class="gravatar"><img alt="gravatar" src="${h.gravatar_url(em.user.email,16)}"/> </div></td>
             <td><div class="email">${em.email}</div></td>
             <td>
               ${h.form(url('user_emails_delete', id=c.user.user_id),method='delete')}
                   ${h.hidden('del_email',em.email_id)}
                   ${h.submit('remove_',_('delete'),id="remove_email_%s" % em.email_id,
                   class_="delete_icon action_button", onclick="return  confirm('"+_('Confirm to delete this email: %s') % em.email+"');")}
               ${h.end_form()}
             </td>
         </tr>
       %endfor
       </table>
     </div>
 
     ${h.form(url('user_emails', id=c.user.user_id),method='put')}
     <div class="form">
         <!-- fields -->
         <div class="fields">
              <div class="field">
                 <div class="label">
                     <label for="email">${_('New email address')}:</label>
                 </div>
                 <div class="input">
                     ${h.text('new_email', class_='medium')}
                 </div>
              </div>
             <div class="buttons">
               ${h.submit('save',_('Add'),class_="ui-btn large")}
               ${h.reset('reset',_('Reset'),class_="ui-btn large")}
             </div>
         </div>
     </div>
     ${h.end_form()}
 </div>
 </%def>

rhodecode/templates/admin/users/user_edit_my_account.html

@@ -1,219 +1,219 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${_('My account')} ${c.rhodecode_user.username} - ${c.rhodecode_name}
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${_('My Account')}
 </%def>
 
 <%def name="page_nav()">
 	${self.menu('admin')}
 </%def>
 
 <%def name="main()">
 
 <div class="box box-left">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
     <!-- end box / title -->
     ${c.form|n}
 </div>
 
 <div class="box box-right">
     <!-- box / title -->
     <div class="title">
         <h5>
         <input class="q_filter_box" id="q_filter" size="15" type="text" name="filter" value="${_('quick filter...')}" style="display: none"/>
         </h5>
          <ul class="links" style="color:#DADADA">
            <li>
              <span><a id="show_perms" class="link-white current" href="#perms">${_('My permissions')}</a> </span>
            </li>
            <li>
              <span><a id="show_my" class="link-white" href="#my">${_('My repos')}</a> </span>
            </li>
            <li>
              <span><a id="show_pullrequests" class="link-white" href="#perms">${_('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 -->
     <div id="perms" class="table">
            %for section in sorted(c.rhodecode_user.permissions.keys()):
             <div class="perms_section_head">${section.replace("_"," ").capitalize()}</div>
 
             <div id='tbl_list_wrap_${section}' class="yui-skin-sam">
             <table id="tbl_list_${section}">
               <thead>
                   <tr>
                   <th class="left">${_('Name')}</th>
                   <th class="left">${_('Permission')}</th>
               </thead>
               <tbody>
             %for k in c.rhodecode_user.permissions[section]:
            <%
            if section != 'global':
                section_perm = c.rhodecode_user.permissions[section].get(k)
                _perm = section_perm.split('.')[-1]
            else:
                _perm = section_perm = None
            %>
             %if _perm not in ['none']:
                 <tr>
                     <td>
                         %if section == 'repositories':
                             <a href="${h.url('summary_home',repo_name=k)}">${k}</a>
                         %elif section == 'repositories_groups':
                             <a href="${h.url('repos_group_home',group_name=k)}">${k}</a>
                         %else:
                             ${k}
                         %endif
                     </td>
                     <td>
                         %if section == 'global':
                          ${h.bool2icon(True)}
                         %else:
                         <span class="perm_tag ${_perm}">${section_perm}</span>
                         %endif
                      </td>
                 </tr>
              %endif
             %endfor
             </tbody>
             </table>
             </div>
            %endfor
     </div>
     <div id="my" class="table" style="display:none">
-    </div>    
+    </div>
     <div id="pullrequests" class="table" style="display:none">
 </div>
 <script type="text/javascript">
 var filter_activate = function(){
     var nodes = YUQ('#my tr td a.repo_name');
     var func = function(node){
         return node.parentNode.parentNode.parentNode.parentNode;
     }
     q_filter('q_filter',YUQ('#my tr td a.repo_name'),func);
 }
 YUE.on('show_perms','click',function(e){
 	YUD.addClass('show_perms', 'current');
 	YUD.removeClass('show_my','current');
 	YUD.removeClass('show_pullrequests','current');
-	
+
     YUD.setStyle('my','display','none');
     YUD.setStyle('pullrequests','display','none');
     YUD.setStyle('perms','display','');
     YUD.setStyle('q_filter','display','none');
     YUE.preventDefault(e);
 })
 YUE.on('show_my','click',function(e){
     YUD.addClass('show_my', 'current');
     YUD.removeClass('show_perms','current');
     YUD.removeClass('show_pullrequests','current');
-    
+
     YUD.setStyle('perms','display','none');
     YUD.setStyle('pullrequests','display','none');
     YUD.setStyle('my','display','');
     YUD.setStyle('q_filter','display','');
-    
+
     YUE.preventDefault(e);
     var url = "${h.url('admin_settings_my_repos')}";
     ypjax(url, 'my', function(){
     	table_sort();
     	filter_activate();
     });
 })
 YUE.on('show_pullrequests','click',function(e){
     YUD.addClass('show_pullrequests', 'current');
     YUD.removeClass('show_my','current');
     YUD.removeClass('show_perms','current');
 
     YUD.setStyle('my','display','none');
     YUD.setStyle('perms','display','none');
     YUD.setStyle('pullrequests','display','');
     YUD.setStyle('q_filter','display','none');
     YUE.preventDefault(e);
     var url = "${h.url('admin_settings_my_pullrequests')}";
     ypjax(url, 'pullrequests');
 })
 
 // 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:"tip",label:"${_('Tip')}",sortable:true,
         sortOptions: { sortFunction: revisionSort }},
     {key:"action1",label:"",sortable:false},
     {key:"action2",label:"",sortable:false},
 ];
 
 function table_sort(){
 var myDataSource = new YAHOO.util.DataSource(YUD.get("repos_list"));
 myDataSource.responseType = YAHOO.util.DataSource.TYPE_HTMLTABLE;
 myDataSource.responseSchema = {
     fields: [
         {key:"menu"},
         {key:"name"},
         {key:"tip"},
         {key:"action1"},
         {key:"action2"},
     ]
 };
 var trans_defs =  {
     sortedBy:{key:"name",dir:"asc"},
     MSG_SORTASC:"${_('Click to sort ascending')}",
     MSG_SORTDESC:"${_('Click to sort descending')}",
     MSG_EMPTY:"${_('No records found.')}",
     MSG_ERROR:"${_('Data error.')}",
     MSG_LOADING:"${_('Loading...')}",
 }
 var myDataTable = new YAHOO.widget.DataTable("repos_list_wrap", myColumnDefs, myDataSource,trans_defs);
 myDataTable.subscribe('postRenderEvent',function(oArgs) {
     tooltip_activate();
     quick_repo_menu();
     filter_activate();
 });
 
 var permsColumnDefs = [
     {key:"name",label:"${_('Name')}",sortable:true, sortOptions: { sortFunction: permNameSort }},
     {key:"perm",label:"${_('Permission')}",sortable:false,},
 ];
 
 // perms repos table
 var myDataSource2 = new YAHOO.util.DataSource(YUD.get("tbl_list_repositories"));
 myDataSource2.responseType = YAHOO.util.DataSource.TYPE_HTMLTABLE;
 myDataSource2.responseSchema = {
     fields: [
         {key:"name"},
         {key:"perm"},
     ]
 };
 
 new YAHOO.widget.DataTable("tbl_list_wrap_repositories", permsColumnDefs, myDataSource2, trans_defs);
 
 //perms groups table
 var myDataSource3 = new YAHOO.util.DataSource(YUD.get("tbl_list_repositories_groups"));
 myDataSource3.responseType = YAHOO.util.DataSource.TYPE_HTMLTABLE;
 myDataSource3.responseSchema = {
     fields: [
         {key:"name"},
         {key:"perm"},
     ]
 };
 
 new YAHOO.widget.DataTable("tbl_list_wrap_repositories_groups", permsColumnDefs, myDataSource3, trans_defs);
 }
 </script>
 </%def>

rhodecode/templates/admin/users/user_edit_my_account_repos.html

@@ -1,46 +1,46 b''
 <div id='repos_list_wrap' class="yui-skin-sam">
   <table id="repos_list">
   <thead>
       <tr>
       <th></th>
       <th class="left">${_('Name')}</th>
       <th class="left">${_('Revision')}</th>
       <th class="left">${_('Action')}</th>
       <th class="left">${_('Action')}</th>
   </thead>
    <tbody>
    <%namespace name="dt" file="/data_table/_dt_elements.html"/>
    %if c.user_repos:
        %for repo in c.user_repos:
           <tr>
               ##QUICK MENU
               <td class="quick_repo_menu">
                 ${dt.quick_menu(repo['name'])}
               </td>
               ##REPO NAME AND ICONS
               <td class="reponame">
                 ${dt.repo_name(repo['name'],repo['dbrepo']['repo_type'],repo['dbrepo']['private'],repo['dbrepo_fork'].get('repo_name'))}
               </td>
               ##LAST REVISION
               <td>
                   ${dt.revision(repo['name'],repo['rev'],repo['tip'],repo['author'],repo['last_msg'])}
               </td>
               <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>
               <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: %s') % repo['name']+"');")}
                 ${h.end_form()}
               </td>
           </tr>
        %endfor
    %else:
       <div style="padding:5px 0px 10px 0px;">
       ${_('No repositories yet')}
       %if h.HasPermissionAny('hg.admin','hg.create.repository')():
           ${h.link_to(_('create one now'),h.url('admin_settings_create_repository'),class_="ui-btn")}
       %endif
       </div>
    %endif
    </tbody>
    </table>
-</div>
  No newline at end of file
+</div>

rhodecode/templates/admin/users/users.html

@@ -1,145 +1,145 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${_('Users administration')} - ${c.rhodecode_name}
 </%def>
 
 <%def name="breadcrumbs_links()">
     <input class="q_filter_box" id="q_filter" size="15" type="text" name="filter" value="${_('quick filter...')}"/> ${h.link_to(_('Admin'),h.url('admin_home'))} &raquo; <span id="user_count">0</span> ${_('users')}
 </%def>
 
 <%def name="page_nav()">
 	${self.menu('admin')}
 </%def>
 
 <%def name="main()">
 <div class="box">
     <!-- box / title -->
     <div class="title">
-        ${self.breadcrumbs()} 
+        ${self.breadcrumbs()}
         <ul class="links">
           <li>
             <span>${h.link_to(_(u'ADD NEW USER'),h.url('new_user'))}</span>
           </li>
         </ul>
     </div>
     <!-- end box / title -->
     <div class="table yui-skin-sam" id="users_list_wrap"></div>
     <div id="user-paginator" style="padding: 0px 0px 0px 20px"></div>
 </div>
 
 <script>
   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: "gravatar"},
           {key: "raw_username"},
           {key: "username"},
           {key: "firstname"},
           {key: "lastname"},
           {key: "last_login"},
           {key: "active"},
           {key: "admin"},
           {key: "ldap"},
           {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();
           for (i = 0; i<data.length; i++) {
         	  var pos = data[i].raw_username.toLowerCase().indexOf(req)
               if (pos != -1) {
                   filtered.push(data[i]);
               }
           }
           res.results = filtered;
       }
       YUD.get('user_count').innerHTML = res.results.length;
       return res;
   }
 
   // main table sorting
   var myColumnDefs = [
-      {key:"gravatar",label:"",sortable:false,},                      
+      {key:"gravatar",label:"",sortable:false,},
       {key:"username",label:"${_('username')}",sortable:true,
     	  sortOptions: { sortFunction: linkSort }
       },
       {key:"firstname",label:"${_('firstname')}",sortable:true,},
       {key:"lastname",label:"${_('lastname')}",sortable:true,},
       {key:"last_login",label:"${_('last login')}",sortable:true,},
       {key:"active",label:"${_('active')}",sortable:true,},
       {key:"admin",label:"${_('admin')}",sortable:true,},
       {key:"ldap",label:"${_('ldap')}",sortable:true,},
       {key:"action",label:"${_('action')}",sortable:false},
   ];
 
   var myDataTable = new YAHOO.widget.DataTable("users_list_wrap", myColumnDefs, myDataSource,{
     sortedBy:{key:"username",dir:"asc"},
     paginator: new YAHOO.widget.Paginator({
         rowsPerPage: 15,
         alwaysVisible: false,
         template : "{PreviousPageLink} {FirstPageLink} {PageLinks} {LastPageLink} {NextPageLink}",
         pageLinks: 5,
         containerClass: 'pagination-wh',
         currentPageClass: 'pager_curpage',
         pageLinkClass: 'pager_link',
         nextPageLinkLabel: '&gt;',
         previousPageLinkLabel: '&lt;',
         firstPageLinkLabel: '&lt;&lt;',
         lastPageLinkLabel: '&gt;&gt;',
         containers:['user-paginator']
     }),
 
     MSG_SORTASC:"${_('Click to sort ascending')}",
     MSG_SORTDESC:"${_('Click to sort descending')}",
     MSG_EMPTY:"${_('No records found.')}",
     MSG_ERROR:"${_('Data error.')}",
     MSG_LOADING:"${_('Loading...')}",
   }
   );
   myDataTable.subscribe('postRenderEvent',function(oArgs) {
 
   });
-  
+
   var filterTimeout = null;
 
   updateFilter  = function () {
       // Reset timeout
       filterTimeout = null;
 
       // Reset sort
       var state = myDataTable.getState();
           state.sortedBy = {key:'username', dir:YAHOO.widget.DataTable.CLASS_ASC};
 
       // 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(){
       YUD.get('q_filter').value = '';
    });
 
   YUE.on('q_filter','keyup',function (e) {
       clearTimeout(filterTimeout);
       filterTimeout = setTimeout(updateFilter,600);
-  });  
+  });
 </script>
 
 </%def>

rhodecode/templates/changeset/changeset.html

@@ -1,179 +1,179 b''
 ## -*- coding: utf-8 -*-
 
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${_('%s Changeset') % c.repo_name} - r${c.changeset.revision}:${h.short_id(c.changeset.raw_id)} - ${c.rhodecode_name}
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${h.link_to(_(u'Home'),h.url('/'))}
     &raquo;
     ${h.link_to(c.repo_name,h.url('summary_home',repo_name=c.repo_name))}
     &raquo;
     ${_('Changeset')} - <span class='hash'>r${c.changeset.revision}:${h.short_id(c.changeset.raw_id)}</span>
 </%def>
 
 <%def name="page_nav()">
     ${self.menu('changelog')}
 </%def>
 
 <%def name="main()">
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
     <div class="table">
 		<div class="diffblock">
 			<div class="code-header">
                 <div class="hash">
                  r${c.changeset.revision}:${h.short_id(c.changeset.raw_id)}
                 </div>
                 <div class="date">
                   ${h.fmt_date(c.changeset.date)}
                 </div>
                 <div class="changeset-status-container">
                     %if c.statuses:
                       <div title="${_('Changeset status')}" class="changeset-status-lbl">[${h.changeset_status_lbl(c.statuses[0])}]</div>
                       <div class="changeset-status-ico"><img src="${h.url('/images/icons/flag_status_%s.png' % c.statuses[0])}" /></div>
                     %endif
                 </div>
                 <div class="diff-actions">
                   <a href="${h.url('raw_changeset_home',repo_name=c.repo_name,revision=c.changeset.raw_id,diff='show')}"  class="tooltip" title="${h.tooltip(_('raw diff'))}"><img class="icon" src="${h.url('/images/icons/page_white.png')}"/></a>
                   <a href="${h.url('raw_changeset_home',repo_name=c.repo_name,revision=c.changeset.raw_id,diff='download')}"  class="tooltip" title="${h.tooltip(_('download diff'))}"><img class="icon" src="${h.url('/images/icons/page_white_get.png')}"/></a>
                   ${c.ignorews_url(request.GET)}
                   ${c.context_url(request.GET)}
                 </div>
                 <div class="comments-number" style="float:right;padding-right:5px">${ungettext("%d comment", "%d comments", len(c.comments)) % len(c.comments)} ${ungettext("(%d inline)", "(%d inline)", c.inline_cnt) % c.inline_cnt}</div>
 			</div>
 		</div>
 	    <div id="changeset_content">
 			<div class="container">
 	             <div class="left">
 	                 <div class="author">
 	                     <div class="gravatar">
 	                         <img alt="gravatar" src="${h.gravatar_url(h.email(c.changeset.author),20)}"/>
 	                     </div>
 	                     <span>${h.person(c.changeset.author)}</span><br/>
 	                     <span><a href="mailto:${h.email_or_none(c.changeset.author)}">${h.email_or_none(c.changeset.author)}</a></span><br/>
 	                 </div>
 	                 <div class="message">${h.urlify_commit(c.changeset.message, c.repo_name)}</div>
 	             </div>
 	             <div class="right">
 		             <div class="changes">
                         % if len(c.changeset.affected_files) <= c.affected_files_cut_off:
 		                 <span class="removed" title="${_('removed')}">${len(c.changeset.removed)}</span>
 		                 <span class="changed" title="${_('changed')}">${len(c.changeset.changed)}</span>
 		                 <span class="added" title="${_('added')}">${len(c.changeset.added)}</span>
 	                    % else:
                          <span class="removed" title="${_('affected %s files') % len(c.changeset.affected_files)}">!</span>
                          <span class="changed" title="${_('affected %s files') % len(c.changeset.affected_files)}">!</span>
                          <span class="added"   title="${_('affected %s files') % len(c.changeset.affected_files)}">!</span>
 	                    % endif
 		             </div>
 
 		            %if c.changeset.parents:
 		             %for p_cs in reversed(c.changeset.parents):
 		                 <div class="parent">${_('Parent')}
                      <span class="changeset_id">${p_cs.revision}:<span class="changeset_hash">${h.link_to(h.short_id(p_cs.raw_id),
 		                     h.url('changeset_home',repo_name=c.repo_name,revision=p_cs.raw_id),title=p_cs.message)}</span></span>
 		                 </div>
 		             %endfor
                     %else:
                         <div class="parent">${_('No parents')}</div>
                     %endif
 		         <span class="logtags">
                  %if len(c.changeset.parents)>1:
                  <span class="merge">${_('merge')}</span>
                  %endif
 		             %if c.changeset.branch:
                      <span class="branchtag" title="${'%s %s' % (_('branch'),c.changeset.branch)}">
 		             ${h.link_to(c.changeset.branch,h.url('files_home',repo_name=c.repo_name,revision=c.changeset.raw_id))}
                      </span>
                      %endif
 		             %for tag in c.changeset.tags:
 		                 <span class="tagtag"  title="${'%s %s' % (_('tag'),tag)}">
 		                 ${h.link_to(tag,h.url('files_home',repo_name=c.repo_name,revision=c.changeset.raw_id))}</span>
 		             %endfor
 		         </span>
 	                </div>
 	        </div>
 	        <span>
 	        ${_('%s files affected with %s insertions and %s deletions:') % (len(c.changeset.affected_files),c.lines_added,c.lines_deleted)}
 	        </span>
 	        <div class="cs_files">
 	                %for change,filenode,diff,cs1,cs2,stat in c.changes:
 	                    <div class="cs_${change}">
                             <div class="node">
                             %if change != 'removed':
                                 ${h.link_to(h.safe_unicode(filenode.path),c.anchor_url(filenode.changeset.raw_id,filenode.path,request.GET)+"_target")}
                             %else:
                                 ${h.link_to(h.safe_unicode(filenode.path),h.url.current(anchor=h.FID('',filenode.path)))}
                             %endif
                             </div>
 		                    <div class="changes">${h.fancy_file_stats(stat)}</div>
 	                    </div>
 	                %endfor
 	                % if c.cut_off:
 	                  ${_('Changeset was too big and was cut off...')}
 	                % endif
 	        </div>
 	    </div>
 
     </div>
     <script>
     var _USERS_AC_DATA = ${c.users_array|n};
     var _GROUPS_AC_DATA = ${c.users_groups_array|n};
     AJAX_COMMENT_URL = "${url('changeset_comment',repo_name=c.repo_name,revision=c.changeset.raw_id)}";
-    AJAX_COMMENT_DELETE_URL = "${url('changeset_comment_delete',repo_name=c.repo_name,comment_id='__COMMENT_ID__')}";    
+    AJAX_COMMENT_DELETE_URL = "${url('changeset_comment_delete',repo_name=c.repo_name,comment_id='__COMMENT_ID__')}";
     </script>
     ## diff block
     <%namespace name="diff_block" file="/changeset/diff_block.html"/>
     ${diff_block.diff_block(c.changes)}
 
     ## template for inline comment form
     <%namespace name="comment" file="/changeset/changeset_file_comment.html"/>
     ${comment.comment_inline_form()}
 
     ## render comments and inlines
     ${comment.generate_comments()}
 
     ## main comment form and it status
     ${comment.comments(h.url('changeset_comment', repo_name=c.repo_name, revision=c.changeset.raw_id),
                        h.changeset_status(c.rhodecode_db_repo, c.changeset.raw_id))}
 
     ## FORM FOR MAKING JS ACTION AS CHANGESET COMMENTS
     <script type="text/javascript">
       YUE.onDOMReady(function(){
           YUE.on(YUQ('.show-inline-comments'),'change',function(e){
               var show = 'none';
               var target = e.currentTarget;
               if(target.checked){
                   var show = ''
               }
               var boxid = YUD.getAttribute(target,'id_for');
               var comments = YUQ('#{0} .inline-comments'.format(boxid));
               for(c in comments){
                  YUD.setStyle(comments[c],'display',show);
               }
               var btns = YUQ('#{0} .inline-comments-button'.format(boxid));
               for(c in btns){
                   YUD.setStyle(btns[c],'display',show);
                }
           })
 
           YUE.on(YUQ('.line'),'click',function(e){
               var tr = e.currentTarget;
               injectInlineForm(tr);
           });
 
           // inject comments into they proper positions
           var file_comments = YUQ('.inline-comment-placeholder');
           renderInlineComments(file_comments);
       })
 
     </script>
 
     </div>
 </%def>

rhodecode/templates/changeset/changeset_file_comment.html

@@ -1,163 +1,163 b''
 ## -*- coding: utf-8 -*-
 ## usage:
 ## <%namespace name="comment" file="/changeset/changeset_file_comment.html"/>
 ## ${comment.comment_block(co)}
 ##
 <%def name="comment_block(co)">
   <div class="comment" id="comment-${co.comment_id}" line="${co.line_no}">
     <div class="comment-wrapp">
   	<div class="meta">
         <div style="float:left"> <img src="${h.gravatar_url(co.author.email, 20)}" /> </div>
   		<div class="user">
   			${co.author.username}
   		</div>
   		<div class="date">
   			${h.age(co.modified_at)}
   		</div>
         %if co.status_change:
            <div  style="float:left" class="changeset-status-container">
              <div style="float:left;padding:0px 2px 0px 2px"><span style="font-size: 18px;">&rsaquo;</span></div>
              <div title="${_('Changeset status')}" class="changeset-status-lbl"> ${co.status_change.status_lbl}</div>
              <div class="changeset-status-ico"><img src="${h.url(str('/images/icons/flag_status_%s.png' % co.status_change.status))}" /></div>
            </div>
         %endif
       %if h.HasPermissionAny('hg.admin', 'repository.admin')() or co.author.user_id == c.rhodecode_user.user_id:
         <div class="buttons">
           <span onClick="deleteComment(${co.comment_id})" class="delete-comment ui-btn">${_('Delete')}</span>
         </div>
       %endif
   	</div>
   	<div class="text">
   		${h.rst_w_mentions(co.text)|n}
   	</div>
     </div>
   </div>
 </%def>
 
 
 <%def name="comment_inline_form()">
 <div id='comment-inline-form-template' style="display:none">
   <div class="comment-inline-form ac">
   %if c.rhodecode_user.username != 'default':
     <div class="overlay"><div class="overlay-text">${_('Submitting...')}</div></div>
       ${h.form('#', class_='inline-form')}
       <div class="clearfix">
           <div class="comment-help">${_('Commenting on line {1}.')}
           ${(_('Comments parsed using %s syntax with %s support.') % (
                  ('<a href="%s">RST</a>' % h.url('rst_help')),
           	     ('<span style="color:#003367" class="tooltip" title="%s">@mention</span>' % _('Use @username inside this text to send notification to this RhodeCode user'))
                )
             )|n
            }
           </div>
             <div class="mentions-container" id="mentions_container_{1}"></div>
             <textarea id="text_{1}" name="text" class="yui-ac-input"></textarea>
       </div>
       <div class="comment-button">
       <input type="hidden" name="f_path" value="{0}">
       <input type="hidden" name="line" value="{1}">
       ${h.submit('save', _('Comment'), class_='ui-btn save-inline-form')}
       ${h.reset('hide-inline-form', _('Hide'), class_='ui-btn hide-inline-form')}
       </div>
       ${h.end_form()}
   %else:
       ${h.form('')}
       <div class="clearfix">
           <div class="comment-help">
             ${_('You need to be logged in to comment.')} <a href="${h.url('login_home',came_from=h.url.current())}">${_('Login now')}</a>
           </div>
       </div>
       <div class="comment-button">
       ${h.reset('hide-inline-form', _('Hide'), class_='ui-btn hide-inline-form')}
       </div>
       ${h.end_form()}
   %endif
   </div>
 </div>
 </%def>
 
 
 ## generates inlines taken from c.comments var
 <%def name="inlines()">
     <div class="comments-number">${ungettext("%d comment", "%d comments", len(c.comments)) % len(c.comments)} ${ungettext("(%d inline)", "(%d inline)", c.inline_cnt) % c.inline_cnt}</div>
     %for path, lines in c.inline_comments:
         % for line,comments in lines.iteritems():
             <div style="display:none" class="inline-comment-placeholder" path="${path}" target_id="${h.safeid(h.safe_unicode(path))}">
             %for co in comments:
                 ${comment_block(co)}
             %endfor
             </div>
         %endfor
     %endfor
 
 </%def>
 
 ## generate inline comments and the main ones
 <%def name="generate_comments()">
 <div class="comments">
     <div id="inline-comments-container">
     ## generate inlines for this changeset
      ${inlines()}
     </div>
 
     %for co in c.comments:
         <div id="comment-tr-${co.comment_id}">
           ${comment_block(co)}
         </div>
     %endfor
-</div>    
+</div>
 </%def>
 
 ## MAIN COMMENT FORM
 <%def name="comments(post_url, cur_status, close_btn=False)">
 
 <div class="comments">
     %if c.rhodecode_user.username != 'default':
     <div class="comment-form ac">
         ${h.form(post_url)}
         <strong>${_('Leave a comment')}</strong>
         <div class="clearfix">
             <div class="comment-help">
                 ${(_('Comments parsed using %s syntax with %s support.') % (('<a href="%s">RST</a>' % h.url('rst_help')),
           		'<span style="color:#003367" class="tooltip" title="%s">@mention</span>' %
           		_('Use @username inside this text to send notification to this RhodeCode user')))|n}
                 | <label for="show_changeset_status_box" class="tooltip" title="${_('Check this to change current status of code-review for this changeset')}"> ${_('change status')}</label>
                   <input style="vertical-align: bottom;margin-bottom:-2px" id="show_changeset_status_box" type="checkbox" name="change_changeset_status" />
             </div>
             <div id="status_block_container" class="status-block" style="display:none">
                 %for status,lbl in c.changeset_statuses:
                     <div class="">
                         <img src="${h.url('/images/icons/flag_status_%s.png' % status)}" /> <input ${'checked="checked"' if status == cur_status else ''}" type="radio" name="changeset_status" value="${status}"> <label>${lbl}</label>
                     </div>
                 %endfor
             </div>
             <div class="mentions-container" id="mentions_container"></div>
              ${h.textarea('text')}
         </div>
         <div class="comment-button">
         ${h.submit('save', _('Comment'), class_="ui-btn large")}
         %if close_btn:
            ${h.submit('save_close', _('Comment and close'), class_='ui-btn blue large')}
         %endif
         </div>
         ${h.end_form()}
     </div>
     %endif
 </div>
 <script>
 YUE.onDOMReady(function () {
    MentionsAutoComplete('text', 'mentions_container', _USERS_AC_DATA, _GROUPS_AC_DATA);
 
    // changeset status box listener
    YUE.on(YUD.get('show_changeset_status_box'),'change',function(e){
        if(e.currentTarget.checked){
            YUD.setStyle('status_block_container','display','');
        }
        else{
            YUD.setStyle('status_block_container','display','none');
        }
    })
 
 });
 </script>
 </%def>

rhodecode/templates/changeset/changeset_range.html

@@ -1,99 +1,99 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${_('%s Changesets') % c.repo_name} - r${c.cs_ranges[0].revision}:${h.short_id(c.cs_ranges[0].raw_id)} -> r${c.cs_ranges[-1].revision}:${h.short_id(c.cs_ranges[-1].raw_id)} - ${c.rhodecode_name}
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${h.link_to(_(u'Home'),h.url('/'))}
     &raquo;
     ${h.link_to(c.repo_name,h.url('summary_home',repo_name=c.repo_name))}
     &raquo;
     ${_('Changesets')} - r${c.cs_ranges[0].revision}:${h.short_id(c.cs_ranges[0].raw_id)} -> r${c.cs_ranges[-1].revision}:${h.short_id(c.cs_ranges[-1].raw_id)}
 </%def>
 
 <%def name="page_nav()">
     ${self.menu('changelog')}
 </%def>
 
 <%def name="main()">
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
     <div class="table">
 		<div id="body" class="diffblock">
 			<div class="code-header cv">
 		        <h3 class="code-header-title">${_('Compare View')}</h3>
                 <div>
 				${_('Changesets')} - r${c.cs_ranges[0].revision}:${h.short_id(c.cs_ranges[0].raw_id)} -> r${c.cs_ranges[-1].revision}:${h.short_id(c.cs_ranges[-1].raw_id)}
 				</div>
 			</div>
 		</div>
 	    <div id="changeset_compare_view_content">
 			<div class="container">
 			<table class="compare_view_commits noborder">
             %for cnt,cs in enumerate(c.cs_ranges):
                 <tr>
                 <td><div class="gravatar"><img alt="gravatar" src="${h.gravatar_url(h.email(cs.author),14)}"/></div></td>
                 <td>${h.link_to('r%s:%s' % (cs.revision,h.short_id(cs.raw_id)),h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id))}</td>
                 <td><div class="author">${h.person(cs.author)}</div></td>
                 <td><span class="tooltip" title="${h.age(cs.date)}">${cs.date}</span></td>
                 <td>
                   %if c.statuses:
                     <div title="${h.tooltip(_('Changeset status'))}" class="changeset-status-ico"><img src="${h.url('/images/icons/flag_status_%s.png' % c.statuses[cnt])}" /></div>
                   %endif
                 </td>
                 <td><div class="message">${h.urlify_commit(h.wrap_paragraphs(cs.message),c.repo_name)}</div></td>
                 </tr>
             %endfor
             </table>
 	        </div>
 	        <div style="font-size:1.1em;font-weight: bold;clear:both;padding-top:10px">${_('Files affected')}</div>
 	        <div class="cs_files">
 	               %for cs in c.cs_ranges:
 	                   <div class="cur_cs">${h.link_to('r%s:%s' % (cs.revision,h.short_id(cs.raw_id)),h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id))}</div>
 	                %for change,filenode,diff,cs1,cs2,st in c.changes[cs.raw_id]:
 	                    <div class="cs_${change}">${h.link_to(h.safe_unicode(filenode.path),h.url.current(anchor=h.FID(cs.raw_id,filenode.path)))}</div>
 	                %endfor
 	               %endfor
 	        </div>
 	    </div>
 
     </div>
     <%namespace name="comment" file="/changeset/changeset_file_comment.html"/>
     <%namespace name="diff_block" file="/changeset/diff_block.html"/>
      %for cs in c.cs_ranges:
           ##${comment.comment_inline_form(cs)}
           ## diff block
           <h3 style="padding-top:8px;">
           <a class="tooltip" title="${h.tooltip(cs.message)}" href="${h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id)}">${'r%s:%s' % (cs.revision,h.short_id(cs.raw_id))}</a>
            <div class="gravatar">
                <img alt="gravatar" src="${h.gravatar_url(h.email(cs.author),20)}"/>
-           </div>            
+           </div>
            </h3>
           ${diff_block.diff_block(c.changes[cs.raw_id])}
           ##${comment.comments(cs)}
 
      %endfor
      <script type="text/javascript">
 
       YUE.onDOMReady(function(){
 
           YUE.on(YUQ('.diff-menu-activate'),'click',function(e){
               var act = e.currentTarget.nextElementSibling;
 
               if(YUD.hasClass(act,'active')){
                   YUD.removeClass(act,'active');
                   YUD.setStyle(act,'display','none');
               }else{
                   YUD.addClass(act,'active');
                   YUD.setStyle(act,'display','');
               }
           });
       })
     </script>
     </div>
 </%def>

rhodecode/templates/errors/error_document.html

@@ -1,55 +1,55 b''
 ## -*- coding: utf-8 -*-
 <!DOCTYPE html>
 <html xmlns="http://www.w3.org/1999/xhtml">
     <head>
         <title>Error - ${c.error_message}</title>
         <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
         <meta name="robots" content="index, nofollow"/>
         <link rel="icon" href="${h.url('/images/icons/database_gear.png')}" type="image/png" />
-                
+
         <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
 	    %if c.redirect_time:
 	        <meta http-equiv="refresh" content="${c.redirect_time}; url=${c.url_redirect}"/>
 	    %endif
 
         <!-- stylesheets -->
         <link rel="stylesheet" type="text/css" href="${h.url('/css/style.css')}" media="screen" />
 	    <style type="text/css">
 	     #main_div{
 	       border: 0px solid #000;
 	       width: 500px;
 	       margin: auto;
 	       text-align: center;
 	       margin-top: 200px;
 	       font-size: 1.6em;
 	     }
 	     .error_message{
 	        text-align: center;
 	        color:#003367;
 	        font-size: 1.6em;
 	        margin:10px;
 	     }
 	    </style>
 
     </head>
     <body>
 
         <div id="login">
             <div class="table">
 				<div id="main_div">
 				    <div style="font-size:2.0em;margin: 10px">${c.rhodecode_name}</div>
 					<h1 class="error_message">${c.error_message}</h1>
 
 					<p>${c.error_explanation}</p>
 
 			        %if c.redirect_time:
 			            <p>${_('You will be redirected to %s in %s seconds') % (c.redirect_module,c.redirect_time)}</p>
 				    %endif
 
 				</div>
             </div>
             <!-- end login -->
         </div>
     </body>
 
 </html>

rhodecode/templates/forks/fork.html

@@ -1,100 +1,100 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${_('%s Fork') % c.repo_name} - ${c.rhodecode_name}
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${h.link_to(_(u'Home'),h.url('/'))}
     &raquo;
     ${h.link_to(c.repo_info.repo_name,h.url('summary_home',repo_name=c.repo_info.repo_name))}
     &raquo;
     ${_('fork')}
 </%def>
 
 <%def name="page_nav()">
 	${self.menu('')}
 </%def>
 <%def name="main()">
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
     ${h.form(url('repo_fork_create_home',repo_name=c.repo_info.repo_name))}
     <div class="form">
         <!-- fields -->
         <div class="fields">
             <div class="field">
               <div class="label">
                   <label for="repo_name">${_('Fork name')}:</label>
               </div>
               <div class="input">
                   ${h.text('repo_name',class_="small")}
                   ${h.hidden('repo_type',c.repo_info.repo_type)}
                   ${h.hidden('fork_parent_id',c.repo_info.repo_id)}
               </div>
             </div>
              <div class="field">
                 <div class="label">
                     <label for="landing_rev">${_('Landing revision')}:</label>
                 </div>
                 <div class="input">
                     ${h.select('landing_rev','',c.landing_revs,class_="medium")}
                     <span class="help-block">${_('Default revision for files page, downloads, whoosh and readme')}</span>
                 </div>
-            </div>            
+            </div>
             <div class="field">
                  <div class="label">
                      <label for="repo_group">${_('Repository group')}:</label>
                  </div>
                  <div class="input">
                      ${h.select('repo_group','',c.repo_groups,class_="medium")}
                      <span class="help-block">${_('Optionaly select a group to put this repository into.')}</span>
                  </div>
             </div>
             <div class="field">
                 <div class="label label-textarea">
                     <label for="description">${_('Description')}:</label>
                 </div>
                 <div class="textarea text-area editor">
                     ${h.textarea('description',cols=23,rows=5)}
                     <span class="help-block">${_('Keep it short and to the point. Use a README file for longer descriptions.')}</span>
                 </div>
              </div>
             <div class="field">
                 <div class="label label-checkbox">
                     <label for="private">${_('Private')}:</label>
                 </div>
                 <div class="checkboxes">
                     ${h.checkbox('private',value="True")}
                     <span class="help-block">${_('Private repositories are only visible to people explicitly added as collaborators.')}</span>
                 </div>
             </div>
             <div class="field">
                 <div class="label label-checkbox">
                     <label for="private">${_('Copy permissions')}:</label>
                 </div>
                 <div class="checkboxes">
                     ${h.checkbox('copy_permissions',value="True", checked="checked")}
                     <span class="help-block">${_('Copy permissions from forked repository')}</span>
                 </div>
              </div>
             <div class="field">
                 <div class="label label-checkbox">
                     <label for="private">${_('Update after clone')}:</label>
                 </div>
                 <div class="checkboxes">
                     ${h.checkbox('update_after_clone',value="True")}
                     <span class="help-block">${_('Checkout source after making a clone')}</span>
                 </div>
              </div>
 	        <div class="buttons">
 	          ${h.submit('',_('fork this repository'),class_="ui-btn large")}
 	        </div>
         </div>
     </div>
     ${h.end_form()}
 </div>
 </%def>

rhodecode/templates/forks/forks_data.html

@@ -1,39 +1,39 b''
 ## -*- coding: utf-8 -*-
 
 % if c.forks_pager:
 	% for f in c.forks_pager:
 	    <div>
 	        <div class="fork_user">
 	            <div class="gravatar">
 	                <img alt="gravatar" src="${h.gravatar_url(f.user.email,24)}"/>
 	            </div>
 	            <span style="font-size: 20px">
 	             <b>${f.user.username}</b> (${f.user.name} ${f.user.lastname}) /
 	              ${h.link_to(f.repo_name,h.url('summary_home',repo_name=f.repo_name))}
 	             </span>
 	             <div style="padding:5px 3px 3px 42px;">${f.description}</div>
 	        </div>
 	        <div style="clear:both;padding-top: 10px"></div>
 	        <div class="follower_date">${_('forked')} -
 	        <span class="tooltip" title="${h.tooltip(h.fmt_date(f.created_on))}"> ${h.age(f.created_on)}</span>
-            <a title="${_('compare fork with %s' % c.repo_name)}" 
-               href="${h.url('compare_url',repo_name=f.repo_name,org_ref_type='branch',org_ref='default',other_ref_type='branch',other_ref='default', repo=c.repo_name)}" 
+            <a title="${_('compare fork with %s' % c.repo_name)}"
+               href="${h.url('compare_url',repo_name=f.repo_name,org_ref_type='branch',org_ref='default',other_ref_type='branch',other_ref='default', repo=c.repo_name)}"
                class="ui-btn small">${_('Compare fork')}</a>
              </div>
 	        <div style="border-bottom: 1px solid #DDD;margin:10px 0px 10px 0px"></div>
 	    </div>
 	% endfor
   <div class="pagination-wh pagination-left">
   <script type="text/javascript">
   YUE.onDOMReady(function(){
       YUE.delegate("forks","click",function(e, matchedEl, container){
           ypjax(e.target.href,"forks",function(){show_more_event();tooltip_activate();});
           YUE.preventDefault(e);
       },'.pager_link');
   });
   </script>
   ${c.forks_pager.pager('$link_previous ~2~ $link_next')}
   </div>
 % else:
 	${_('There are no forks yet')}
 % endif

rhodecode/templates/pullrequests/pullrequest.html

@@ -1,188 +1,188 b''
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${c.repo_name} ${_('New pull request')}
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${h.link_to(_(u'Home'),h.url('/'))}
     &raquo;
     ${h.link_to(c.repo_name,h.url('changelog_home',repo_name=c.repo_name))}
     &raquo;
     ${_('New pull request')}
 </%def>
 
 <%def name="main()">
 
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
     ${h.form(url('pullrequest', repo_name=c.repo_name), method='post', id='pull_request_form')}
     <div style="float:left;padding:0px 30px 30px 30px">
        <div style="padding:0px 5px 5px 5px">
          <span>
            <a id="refresh" href="#">
              <img class="icon" title="${_('Refresh')}" alt="${_('Refresh')}" src="${h.url('/images/icons/arrow_refresh.png')}"/>
              ${_('refresh overview')}
            </a>
          </span>
        </div>
         ##ORG
         <div style="float:left">
             <div class="fork_user">
                 <div class="gravatar">
                     <img alt="gravatar" src="${h.gravatar_url(c.rhodecode_db_repo.user.email,24)}"/>
                 </div>
                 <span style="font-size: 20px">
                 ${h.select('org_repo','',c.org_repos,class_='refs')}:${h.select('org_ref','',c.org_refs,class_='refs')}
                 </span>
                  <div style="padding:5px 3px 3px 42px;">${c.rhodecode_db_repo.description}</div>
             </div>
             <div style="clear:both;padding-top: 10px"></div>
         </div>
           <div style="float:left;font-size:24px;padding:0px 20px">
           <img height=32 width=32 src="${h.url('/images/arrow_right_64.png')}"/>
           </div>
 
         ##OTHER, most Probably the PARENT OF THIS FORK
         <div style="float:left">
             <div class="fork_user">
                 <div class="gravatar">
                     <img id="other_repo_gravatar" alt="gravatar" src=""/>
                 </div>
                 <span style="font-size: 20px">
                 ${h.select('other_repo',c.default_pull_request ,c.other_repos,class_='refs')}:${h.select('other_ref','',c.other_refs,class_='refs')}
                 </span>
                  <div id="other_repo_desc" style="padding:5px 3px 3px 42px;"></div>
             </div>
             <div style="clear:both;padding-top: 10px"></div>
         </div>
        <div style="clear:both;padding-top: 10px"></div>
        ## overview pulled by ajax
        <div style="float:left" id="pull_request_overview"></div>
        <div style="float:left;clear:both;padding:10px 10px 10px 0px;display:none">
             <a id="pull_request_overview_url" href="#">${_('Detailed compare view')}</a>
        </div>
      </div>
     <div style="float:left; border-left:1px dashed #eee">
         <h4>${_('Pull request reviewers')}</h4>
         <div id="reviewers" style="padding:0px 0px 0px 15px">
           ## members goes here !
           <div class="group_members_wrap">
             <ul id="review_members" class="group_members">
             %for member in c.review_members:
               <li id="reviewer_${member.user_id}">
                 <div class="reviewers_member">
                   <div class="gravatar"><img alt="gravatar" src="${h.gravatar_url(member.email,14)}"/> </div>
                   <div style="float:left">${member.full_name} (${_('owner')})</div>
                   <input type="hidden" value="${member.user_id}" name="review_members" />
                   <span class="delete_icon action_button" onclick="removeReviewer(${member.user_id})"></span>
                 </div>
               </li>
             %endfor
             </ul>
-          </div>                
-          
+          </div>
+
           <div class='ac'>
             <div class="reviewer_ac">
                ${h.text('user', class_='yui-ac-input')}
                <span class="help-block">${_('Add reviewer to this pull request.')}</span>
-               <div id="reviewers_container"></div>           
+               <div id="reviewers_container"></div>
             </div>
           </div>
         </div>
     </div>
     <h3>${_('Create new pull request')}</h3>
 
     <div class="form">
         <!-- fields -->
 
         <div class="fields">
 
              <div class="field">
                 <div class="label">
                     <label for="pullrequest_title">${_('Title')}:</label>
                 </div>
                 <div class="input">
                     ${h.text('pullrequest_title',size=30)}
                 </div>
              </div>
 
             <div class="field">
                 <div class="label label-textarea">
                     <label for="pullrequest_desc">${_('description')}:</label>
                 </div>
                 <div class="textarea text-area editor">
                     ${h.textarea('pullrequest_desc',size=30)}
                 </div>
             </div>
 
             <div class="buttons">
                 ${h.submit('save',_('Send pull request'),class_="ui-btn large")}
                 ${h.reset('reset',_('Reset'),class_="ui-btn large")}
            </div>
         </div>
     </div>
     ${h.end_form()}
 
 </div>
 
 <script type="text/javascript">
   var _USERS_AC_DATA = ${c.users_array|n};
   var _GROUPS_AC_DATA = ${c.users_groups_array|n};
   PullRequestAutoComplete('user', 'reviewers_container', _USERS_AC_DATA, _GROUPS_AC_DATA);
 
   var other_repos_info = ${c.other_repos_info|n};
   var loadPreview = function(){
 	  YUD.setStyle(YUD.get('pull_request_overview_url').parentElement,'display','none');
       var url = "${h.url('compare_url',
           repo_name='org_repo',
           org_ref_type='branch', org_ref='org_ref',
           other_ref_type='branch', other_ref='other_ref',
           repo='other_repo',
           as_form=True)}";
 
       var select_refs = YUQ('#pull_request_form select.refs')
 
       for(var i=0;i<select_refs.length;i++){
         var select_ref = select_refs[i];
         var select_ref_data = select_ref.value.split(':');
         var key = null;
         var val = null;
         if(select_ref_data.length>1){
           key = select_ref.name+"_type";
           val = select_ref_data[0];
           url = url.replace(key,val);
 
           key = select_ref.name;
           val = select_ref_data[1];
           url = url.replace(key,val);
 
         }else{
           key = select_ref.name;
           val = select_ref.value;
           url = url.replace(key,val);
         }
       }
 
       ypjax(url,'pull_request_overview', function(data){
     	  var sel_box = YUQ('#pull_request_form #other_repo')[0];
     	  var repo_name = sel_box.options[sel_box.selectedIndex].value;
     	  YUD.get('pull_request_overview_url').href = url;
     	  YUD.setStyle(YUD.get('pull_request_overview_url').parentElement,'display','');
     	  YUD.get('other_repo_gravatar').src = other_repos_info[repo_name]['gravatar'];
     	  YUD.get('other_repo_desc').innerHTML = other_repos_info[repo_name]['description'];
       })
   }
   YUE.on('refresh','click',function(e){
      loadPreview()
   })
 
   //lazy load overview after 0.5s
   setTimeout(loadPreview, 500)
 
 </script>
 
 </%def>

rhodecode/templates/pullrequests/pullrequest_show.html

@@ -1,174 +1,174 b''
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${c.repo_name} ${_('Pull request #%s') % c.pull_request.pull_request_id}
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${h.link_to(_(u'Home'),h.url('/'))}
     &raquo;
     ${h.link_to(c.repo_name,h.url('changelog_home',repo_name=c.repo_name))}
     &raquo;
     ${_('Pull request #%s') % c.pull_request.pull_request_id}
 </%def>
 
 <%def name="main()">
 
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
         %if c.pull_request.is_closed():
         <div style="padding:10px; font-size:22px;width:100%;text-align: center; color:#88D882">${_('Closed %s') % (h.age(c.pull_request.updated_on))}</div>
-        %endif        
-    <h3>${_('Title')}: ${c.pull_request.title} 
+        %endif
+    <h3>${_('Title')}: ${c.pull_request.title}
         <div class="changeset-status-container" style="float:none">
         %if c.current_changeset_status:
           <div title="${_('Pull request status')}" class="changeset-status-lbl">[${h.changeset_status_lbl(c.current_changeset_status)}]</div>
-          <div class="changeset-status-ico" style="padding:4px"><img src="${h.url('/images/icons/flag_status_%s.png' % c.current_changeset_status)}" /></div>          
+          <div class="changeset-status-ico" style="padding:4px"><img src="${h.url('/images/icons/flag_status_%s.png' % c.current_changeset_status)}" /></div>
         %endif
         </div>
     </h3>
     <div style="white-space:pre-wrap;padding:3px 3px 5px 20px">${h.literal(c.pull_request.description)}</div>
     <div style="padding:4px 4px 10px 20px">
       <div>${_('Created on')}: ${h.fmt_date(c.pull_request.created_on)}</div>
     </div>
 
     <div style="min-height:160px">
       ##DIFF
       <div class="table" style="float:left;clear:none">
           <div id="body" class="diffblock">
               <div style="white-space:pre-wrap;padding:5px">${_('Compare view')}</div>
           </div>
           <div id="changeset_compare_view_content">
               ##CS
               <div style="font-size:1.1em;font-weight: bold;clear:both;padding-top:10px">${_('Incoming changesets')}</div>
               <%include file="/compare/compare_cs.html" />
-  
+
               ## FILES
               <div style="font-size:1.1em;font-weight: bold;clear:both;padding-top:10px">${_('Files affected')}</div>
               <div class="cs_files">
                 %for fid, change, f, stat in c.files:
                     <div class="cs_${change}">
                       <div class="node">${h.link_to(h.safe_unicode(f),h.url.current(anchor=fid))}</div>
                       <div class="changes">${h.fancy_file_stats(stat)}</div>
                     </div>
                 %endfor
               </div>
           </div>
       </div>
       ## REVIEWERS
        <div style="float:left; border-left:1px dashed #eee">
        <h4>${_('Pull request reviewers')}</h4>
         <div id="reviewers" style="padding:0px 0px 0px 15px">
           ## members goes here !
           <div class="group_members_wrap">
             <ul id="review_members" class="group_members">
             %for member,status in c.pull_request_reviewers:
               <li id="reviewer_${member.user_id}">
                 <div class="reviewers_member">
                     <div style="float:left;padding:0px 3px 0px 0px" class="tooltip" title="${h.tooltip(h.changeset_status_lbl(status[0][1].status if status else 'not_reviewed'))}">
                       <img src="${h.url(str('/images/icons/flag_status_%s.png' % (status[0][1].status if status else 'not_reviewed')))}"/>
-                    </div>                
+                    </div>
                   <div class="gravatar"><img alt="gravatar" src="${h.gravatar_url(member.email,14)}"/> </div>
                   <div style="float:left">${member.full_name} (${_('owner')})</div>
                   <input type="hidden" value="${member.user_id}" name="review_members" />
                   %if not c.pull_request.is_closed():
                   <span class="delete_icon action_button" onclick="removeReviewer(${member.user_id})"></span>
                   %endif
                 </div>
               </li>
             %endfor
             </ul>
-          </div>                
+          </div>
           %if not c.pull_request.is_closed():
           <div class='ac'>
             <div class="reviewer_ac">
                ${h.text('user', class_='yui-ac-input')}
                <span class="help-block">${_('Add reviewer to this pull request.')}</span>
-               <div id="reviewers_container"></div>       
+               <div id="reviewers_container"></div>
             </div>
             <div style="padding:0px 10px">
              <span id="update_pull_request" class="ui-btn xsmall">${_('save')}</span>
             </div>
           </div>
           %endif
-        </div>      
-       </div>      
+        </div>
+       </div>
     </div>
     <script>
     var _USERS_AC_DATA = ${c.users_array|n};
     var _GROUPS_AC_DATA = ${c.users_groups_array|n};
     AJAX_COMMENT_URL = "${url('pullrequest_comment',repo_name=c.repo_name,pull_request_id=c.pull_request.pull_request_id)}";
     AJAX_COMMENT_DELETE_URL = "${url('pullrequest_comment_delete',repo_name=c.repo_name,comment_id='__COMMENT_ID__')}";
     AJAX_UPDATE_PULLREQUEST = "${url('pullrequest_update',repo_name=c.repo_name,pull_request_id=c.pull_request.pull_request_id)}"
     </script>
 
     ## diff block
     <%namespace name="diff_block" file="/changeset/diff_block.html"/>
     %for fid, change, f, stat in c.files:
       ${diff_block.diff_block_simple([c.changes[fid]])}
     %endfor
 
     ## template for inline comment form
     <%namespace name="comment" file="/changeset/changeset_file_comment.html"/>
     ${comment.comment_inline_form()}
-    
+
     ## render comments and inlines
     ${comment.generate_comments()}
-    
+
     % if not c.pull_request.is_closed():
       ## main comment form and it status
       ${comment.comments(h.url('pullrequest_comment', repo_name=c.repo_name,
                                 pull_request_id=c.pull_request.pull_request_id),
                                 c.current_changeset_status,
                                 close_btn=True)}
     %endif
 
     <script type="text/javascript">
       YUE.onDOMReady(function(){
     	  PullRequestAutoComplete('user', 'reviewers_container', _USERS_AC_DATA, _GROUPS_AC_DATA);
 
           YUE.on(YUQ('.show-inline-comments'),'change',function(e){
               var show = 'none';
               var target = e.currentTarget;
               if(target.checked){
                   var show = ''
               }
               var boxid = YUD.getAttribute(target,'id_for');
               var comments = YUQ('#{0} .inline-comments'.format(boxid));
               for(c in comments){
                  YUD.setStyle(comments[c],'display',show);
               }
               var btns = YUQ('#{0} .inline-comments-button'.format(boxid));
               for(c in btns){
                   YUD.setStyle(btns[c],'display',show);
                }
           })
 
           YUE.on(YUQ('.line'),'click',function(e){
               var tr = e.currentTarget;
               injectInlineForm(tr);
           });
 
           // inject comments into they proper positions
           var file_comments = YUQ('.inline-comment-placeholder');
           renderInlineComments(file_comments);
-          
+
           YUE.on(YUD.get('update_pull_request'),'click',function(e){
-        	  
+
         	  var reviewers_ids = [];
         	  var ids = YUQ('#review_members input');
         	  for(var i=0; i<ids.length;i++){
         		  var id = ids[i].value
         		  reviewers_ids.push(id);
         	  }
         	  updateReviewers(reviewers_ids);
           })
       })
     </script>
 
 </div>
 
 </%def>

rhodecode/templates/pullrequests/pullrequest_show_all.html

@@ -1,42 +1,42 b''
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${c.repo_name} ${_('all pull requests')}
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${h.link_to(_(u'Home'),h.url('/'))}
     &raquo;
     ${h.link_to(c.repo_name,h.url('changelog_home',repo_name=c.repo_name))}
     &raquo;
     ${_('All pull requests')}
 </%def>
 
 <%def name="main()">
 
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
 
     %for pr in c.pull_requests:
         <div>
           <h4>
           %if pr.is_closed():
           <img src="${h.url('/images/icons/tick.png')}" alt="${_('Closed')}" />
-          %endif          
+          %endif
           <a href="${h.url('pullrequest_show',repo_name=c.repo_name,pull_request_id=pr.pull_request_id)}">
           ${_('Pull request #%s opened by %s on %s') % (pr.pull_request_id, pr.author.full_name, h.fmt_date(pr.created_on))}
           </a>
           </h4>
           <h5 style="border:0px;padding-bottom:0px">${_('Title')}: ${pr.title}</h5>
           <div style="padding:0px 24px">${pr.description}</div>
         </div>
     %endfor
 
 </div>
 
 <script type="text/javascript"></script>
 
 </%def>

rhodecode/templates/settings/repo_settings.html

@@ -1,101 +1,101 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${_('%s Settings') % c.repo_name} - ${c.rhodecode_name}
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${h.link_to(_(u'Home'),h.url('/'))}
     &raquo;
     ${h.link_to(c.repo_info.repo_name,h.url('summary_home',repo_name=c.repo_info.repo_name))}
     &raquo;
     ${_('Settings')}
 </%def>
 
 <%def name="page_nav()">
     ${self.menu('settings')}
 </%def>
 <%def name="main()">
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
     ${h.form(url('repo_settings_update', repo_name=c.repo_info.repo_name),method='put')}
     <div class="form">
         <!-- fields -->
         <div class="fields">
             <div class="field">
                 <div class="label">
                     <label for="repo_name">${_('Name')}:</label>
                 </div>
                 <div class="input input-medium">
                     ${h.text('repo_name',class_="small")}
                 </div>
              </div>
 	       <div class="field">
 	           <div class="label">
 	               <label for="clone_uri">${_('Clone uri')}:</label>
 	           </div>
 	           <div class="input">
 	               ${h.text('clone_uri',class_="medium")}
                  <span class="help-block">${_('Optional http[s] url from which repository should be cloned.')}</span>
 	           </div>
 	        </div>
             <div class="field">
                 <div class="label">
                     <label for="repo_group">${_('Repository group')}:</label>
                 </div>
                 <div class="input">
                     ${h.select('repo_group','',c.repo_groups,class_="medium")}
                     <span class="help-block">${_('Optional select a group to put this repository into.')}</span>
                 </div>
             </div>
             <div class="field">
                 <div class="label">
                     <label for="landing_rev">${_('Landing revision')}:</label>
                 </div>
                 <div class="input">
                     ${h.select('landing_rev','',c.landing_revs,class_="medium")}
                     <span class="help-block">${_('Default revision for files page, downloads, whoosh and readme')}</span>
                 </div>
-            </div>            
+            </div>
             <div class="field">
                 <div class="label label-textarea">
                     <label for="description">${_('Description')}:</label>
                 </div>
                 <div class="textarea text-area editor">
                     ${h.textarea('description')}
                     <span class="help-block">${_('Keep it short and to the point. Use a README file for longer descriptions.')}</span>
                 </div>
             </div>
 
             <div class="field">
                 <div class="label label-checkbox">
                     <label for="private">${_('Private repository')}:</label>
                 </div>
                 <div class="checkboxes">
                     ${h.checkbox('private',value="True")}
                     <span class="help-block">${_('Private repositories are only visible to people explicitly added as collaborators.')}</span>
                 </div>
             </div>
 
              <div class="field">
                 <div class="label">
                     <label for="">${_('Permissions')}:</label>
                 </div>
                 <div class="input">
                     <%include file="../admin/repos/repo_edit_perms.html"/>
                 </div>
 
             <div class="buttons">
               ${h.submit('save',_('Save'),class_="ui-btn large")}
               ${h.reset('reset',_('Reset'),class_="ui-btn large")}
             </div>
         </div>
     </div>
     ${h.end_form()}
 </div>
 </div>
 </%def>

rhodecode/templates/shortlog/shortlog_data.html

@@ -1,88 +1,88 b''
 ## -*- coding: utf-8 -*-
 %if c.repo_changesets:
 <table class="table_disp">
 	<tr>
 	    <th class="left">${_('revision')}</th>
         <th class="left">${_('commit message')}</th>
 		<th class="left">${_('age')}</th>
 		<th class="left">${_('author')}</th>
 		<th class="left">${_('branch')}</th>
 		<th class="left">${_('tags')}</th>
 	</tr>
 %for cnt,cs in enumerate(c.repo_changesets):
 	<tr class="parity${cnt%2}">
         <td>
             <div><pre><a href="${h.url('files_home',repo_name=c.repo_name,revision=cs.raw_id)}">r${cs.revision}:${h.short_id(cs.raw_id)}</a></pre></div>
         </td>
         <td>
             ${h.link_to(h.truncate(cs.message,50) or _('No commit message'),
             h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id),
             title=cs.message)}
         </td>
         <td><span class="tooltip" title="${h.tooltip(h.fmt_date(cs.date))}">
                       ${h.age(cs.date)}</span>
         </td>
 		<td title="${cs.author}">${h.person(cs.author)}</td>
 		<td>
 			<span class="logtags">
                 %if cs.branch:
 				<span class="branchtag">
                     ${cs.branch}
                 </span>
                 %endif
 			</span>
 		</td>
 		<td>
 			<span class="logtags">
 				%for tag in cs.tags:
 					<span class="tagtag">${tag}</span>
 				%endfor
 			</span>
 		</td>
 	</tr>
 %endfor
 
 </table>
 
 <script type="text/javascript">
   YUE.onDOMReady(function(){
     YUE.delegate("shortlog_data","click",function(e, matchedEl, container){
         ypjax(e.target.href,"shortlog_data",function(){tooltip_activate();});
         YUE.preventDefault(e);
     },'.pager_link');
   });
 </script>
 
 <div class="pagination-wh pagination-left">
 ${c.repo_changesets.pager('$link_previous ~2~ $link_next')}
 </div>
 %else:
 
 %if h.HasRepoPermissionAny('repository.write','repository.admin')(c.repo_name):
 <h4>${_('Add or upload files directly via RhodeCode')}</h4>
 <div style="margin: 20px 30px;">
   <div id="add_node_id" class="add_node">
       <a class="ui-btn" href="${h.url('files_add_home',repo_name=c.repo_name,revision=0,f_path='')}">${_('add new file')}</a>
   </div>
 </div>
 %endif
 
 
 <h4>${_('Push new repo')}</h4>
 <pre>
     ${c.rhodecode_repo.alias} clone ${c.clone_repo_url}
     ${c.rhodecode_repo.alias} add README # add first file
     ${c.rhodecode_repo.alias} commit -m "Initial" # commit with message
     ${c.rhodecode_repo.alias} push ${'origin master' if h.is_git(c.rhodecode_repo) else ''} # push changes back
 </pre>
 
 <h4>${_('Existing repository?')}</h4>
 <pre>
 %if h.is_git(c.rhodecode_repo):
     git remote add origin ${c.clone_repo_url}
     git push -u origin master
 %else:
     hg push ${c.clone_repo_url}
-%endif    
+%endif
 </pre>
 %endif

rhodecode/tests/api/api_base.py

@@ -1,991 +1,990 b''
 from __future__ import with_statement
 import random
 import mock
 
 from rhodecode.tests import *
 from rhodecode.lib.compat import json
 from rhodecode.lib.auth import AuthUser
 from rhodecode.model.user import UserModel
 from rhodecode.model.users_group import UsersGroupModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.meta import Session
 
 API_URL = '/_admin/api'
 
 
 def _build_data(apikey, method, **kw):
     """
     Builds API data with given random ID
 
     :param random_id:
     :type random_id:
     """
     random_id = random.randrange(1, 9999)
     return random_id, json.dumps({
         "id": random_id,
         "api_key": apikey,
         "method": method,
         "args": kw
     })
 
 jsonify = lambda obj: json.loads(json.dumps(obj))
 
 
 def crash(*args, **kwargs):
     raise Exception('Total Crash !')
 
 
 TEST_USERS_GROUP = 'test_users_group'
 
 
 def make_users_group(name=TEST_USERS_GROUP):
     gr = UsersGroupModel().create(name=name)
     UsersGroupModel().add_user_to_group(users_group=gr,
                                         user=TEST_USER_ADMIN_LOGIN)
     Session().commit()
     return gr
 
 
 def destroy_users_group(name=TEST_USERS_GROUP):
     UsersGroupModel().delete(users_group=name, force=True)
     Session().commit()
 
 
 def create_repo(repo_name, repo_type):
     # create new repo
     form_data = dict(repo_name=repo_name,
                      repo_name_full=repo_name,
                      fork_name=None,
                      description='description %s' % repo_name,
                      repo_group=None,
                      private=False,
                      repo_type=repo_type,
                      clone_uri=None,
                      landing_rev='tip')
     cur_user = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
     r = RepoModel().create(form_data, cur_user)
     Session().commit()
     return r
 
 
 def create_fork(fork_name, fork_type, fork_of):
     fork = RepoModel(Session())._get_repo(fork_of)
     r = create_repo(fork_name, fork_type)
     r.fork = fork
     Session().add(r)
     Session().commit()
     return r
 
 
 def destroy_repo(repo_name):
     RepoModel().delete(repo_name)
     Session().commit()
 
 
 class BaseTestApi(object):
     REPO = None
     REPO_TYPE = None
 
     @classmethod
     def setUpClass(self):
         self.usr = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
         self.apikey = self.usr.api_key
         self.TEST_USER = UserModel().create_or_update(
             username='test-api',
             password='test',
             email='[e-mail]',
             firstname='first',
             lastname='last'
         )
         Session().commit()
         self.TEST_USER_LOGIN = self.TEST_USER.username
 
     @classmethod
     def teardownClass(self):
         pass
 
     def setUp(self):
         self.maxDiff = None
         make_users_group()
 
     def tearDown(self):
         destroy_users_group()
 
     def _compare_ok(self, id_, expected, given):
         expected = jsonify({
             'id': id_,
             'error': None,
             'result': expected
         })
         given = json.loads(given)
         self.assertEqual(expected, given)
 
     def _compare_error(self, id_, expected, given):
         expected = jsonify({
             'id': id_,
             'error': expected,
             'result': None
         })
         given = json.loads(given)
         self.assertEqual(expected, given)
 
 #    def test_Optional(self):
 #        from rhodecode.controllers.api.api import Optional
 #        option1 = Optional(None)
 #        self.assertEqual('<Optional:%s>' % None, repr(option1))
 #
 #        self.assertEqual(1, Optional.extract(Optional(1)))
 #        self.assertEqual('trololo', Optional.extract('trololo'))
 
     def test_api_wrong_key(self):
         id_, params = _build_data('trololo', 'get_user')
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = 'Invalid API KEY'
         self._compare_error(id_, expected, given=response.body)
 
     def test_api_missing_non_optional_param(self):
         id_, params = _build_data(self.apikey, 'get_user')
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = 'Missing non optional `userid` arg in JSON DATA'
         self._compare_error(id_, expected, given=response.body)
 
     def test_api_get_users(self):
         id_, params = _build_data(self.apikey, 'get_users',)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
         ret_all = []
         for usr in UserModel().get_all():
             ret = usr.get_api_data()
             ret_all.append(jsonify(ret))
         expected = ret_all
         self._compare_ok(id_, expected, given=response.body)
 
     def test_api_get_user(self):
         id_, params = _build_data(self.apikey, 'get_user',
                                   userid=TEST_USER_ADMIN_LOGIN)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         usr = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
         ret = usr.get_api_data()
         ret['permissions'] = AuthUser(usr.user_id).permissions
 
         expected = ret
         self._compare_ok(id_, expected, given=response.body)
 
     def test_api_get_user_that_does_not_exist(self):
         id_, params = _build_data(self.apikey, 'get_user',
                                   userid='trololo')
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = "user `%s` does not exist" % 'trololo'
         self._compare_error(id_, expected, given=response.body)
 
     def test_api_pull(self):
         #TODO: issues with rhodecode_extras here.. not sure why !
         pass
 
 #        repo_name = 'test_pull'
 #        r = create_repo(repo_name, self.REPO_TYPE)
 #        r.clone_uri = TEST_self.REPO
 #        Session.add(r)
 #        Session.commit()
 #
 #        id_, params = _build_data(self.apikey, 'pull',
 #                                  repoid=repo_name,)
 #        response = self.app.post(API_URL, content_type='application/json',
 #                                 params=params)
 #
 #        expected = 'Pulled from `%s`' % repo_name
 #        self._compare_ok(id_, expected, given=response.body)
 #
 #        destroy_repo(repo_name)
 
     def test_api_pull_error(self):
         id_, params = _build_data(self.apikey, 'pull',
                                   repoid=self.REPO,)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = 'Unable to pull changes from `%s`' % self.REPO
         self._compare_error(id_, expected, given=response.body)
 
     def test_api_create_existing_user(self):
         id_, params = _build_data(self.apikey, 'create_user',
                                   username=TEST_USER_ADMIN_LOGIN,
                                   email='[e-mail]',
                                   password='trololo')
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = "user `%s` already exist" % TEST_USER_ADMIN_LOGIN
         self._compare_error(id_, expected, given=response.body)
 
     def test_api_create_user_with_existing_email(self):
         id_, params = _build_data(self.apikey, 'create_user',
                                   username=TEST_USER_ADMIN_LOGIN + 'new',
                                   email=TEST_USER_REGULAR_EMAIL,
                                   password='trololo')
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = "email `%s` already exist" % TEST_USER_REGULAR_EMAIL
         self._compare_error(id_, expected, given=response.body)
 
     def test_api_create_user(self):
         username = 'test_new_api_user'
         email = username + "@foo.com"
 
         id_, params = _build_data(self.apikey, 'create_user',
                                   username=username,
                                   email=email,
                                   password='trololo')
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         usr = UserModel().get_by_username(username)
         ret = dict(
             msg='created new user `%s`' % username,
             user=jsonify(usr.get_api_data())
         )
 
         expected = ret
         self._compare_ok(id_, expected, given=response.body)
 
         UserModel().delete(usr.user_id)
         self.Session().commit()
 
     @mock.patch.object(UserModel, 'create_or_update', crash)
     def test_api_create_user_when_exception_happened(self):
 
         username = 'test_new_api_user'
         email = username + "@foo.com"
 
         id_, params = _build_data(self.apikey, 'create_user',
                                   username=username,
                                   email=email,
                                   password='trololo')
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
         expected = 'failed to create user `%s`' % username
         self._compare_error(id_, expected, given=response.body)
 
     def test_api_delete_user(self):
         usr = UserModel().create_or_update(username=u'test_user',
                                            password=u'qweqwe',
                                            email=u'[e-mail]',
                                            firstname=u'u1', lastname=u'u1')
         self.Session().commit()
         username = usr.username
         email = usr.email
         usr_id = usr.user_id
         ## DELETE THIS USER NOW
 
         id_, params = _build_data(self.apikey, 'delete_user',
                                   userid=username,)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         ret = {'msg': 'deleted user ID:%s %s' % (usr_id, username),
                'user': None}
         expected = ret
         self._compare_ok(id_, expected, given=response.body)
 
     @mock.patch.object(UserModel, 'delete', crash)
     def test_api_delete_user_when_exception_happened(self):
         usr = UserModel().create_or_update(username=u'test_user',
                                            password=u'qweqwe',
                                            email=u'[e-mail]',
                                            firstname=u'u1', lastname=u'u1')
         self.Session().commit()
         username = usr.username
 
         id_, params = _build_data(self.apikey, 'delete_user',
                                   userid=username,)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
         ret = 'failed to delete ID:%s %s' % (usr.user_id,
                                              usr.username)
         expected = ret
         self._compare_error(id_, expected, given=response.body)
 
     @parameterized.expand([('firstname', 'new_username'),
                            ('lastname', 'new_username'),
                            ('email', 'new_username'),
                            ('admin', True),
                            ('admin', False),
                            ('ldap_dn', 'test'),
                            ('ldap_dn', None),
                            ('active', False),
                            ('active', True),
                            ('password', 'newpass')
                            ])
     def test_api_update_user(self, name, expected):
         usr = UserModel().get_by_username(self.TEST_USER_LOGIN)
         kw = {name: expected,
               'userid': usr.user_id}
         id_, params = _build_data(self.apikey, 'update_user', **kw)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         ret = {
         'msg': 'updated user ID:%s %s' % (usr.user_id, self.TEST_USER_LOGIN),
         'user': jsonify(UserModel()\
                             .get_by_username(self.TEST_USER_LOGIN)\
                             .get_api_data())
         }
 
         expected = ret
         self._compare_ok(id_, expected, given=response.body)
 
     def test_api_update_user_no_changed_params(self):
         usr = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
         ret = jsonify(usr.get_api_data())
         id_, params = _build_data(self.apikey, 'update_user',
                                   userid=TEST_USER_ADMIN_LOGIN)
 
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
         ret = {
         'msg': 'updated user ID:%s %s' % (usr.user_id, TEST_USER_ADMIN_LOGIN),
         'user': ret
         }
         expected = ret
         self._compare_ok(id_, expected, given=response.body)
 
     def test_api_update_user_by_user_id(self):
         usr = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
         ret = jsonify(usr.get_api_data())
         id_, params = _build_data(self.apikey, 'update_user',
                                   userid=usr.user_id)
 
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
         ret = {
         'msg': 'updated user ID:%s %s' % (usr.user_id, TEST_USER_ADMIN_LOGIN),
         'user': ret
         }
         expected = ret
         self._compare_ok(id_, expected, given=response.body)
 
     @mock.patch.object(UserModel, 'update_user', crash)
     def test_api_update_user_when_exception_happens(self):
         usr = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
         ret = jsonify(usr.get_api_data())
         id_, params = _build_data(self.apikey, 'update_user',
                                   userid=usr.user_id)
 
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
         ret = 'failed to update user `%s`' % usr.user_id
 
         expected = ret
         self._compare_error(id_, expected, given=response.body)
 
     def test_api_get_repo(self):
         new_group = 'some_new_group'
         make_users_group(new_group)
         RepoModel().grant_users_group_permission(repo=self.REPO,
                                                  group_name=new_group,
                                                  perm='repository.read')
         self.Session().commit()
         id_, params = _build_data(self.apikey, 'get_repo',
                                   repoid=self.REPO)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         repo = RepoModel().get_by_repo_name(self.REPO)
         ret = repo.get_api_data()
 
         members = []
         for user in repo.repo_to_perm:
             perm = user.permission.permission_name
             user = user.user
             user_data = user.get_api_data()
             user_data['type'] = "user"
             user_data['permission'] = perm
             members.append(user_data)
 
         for users_group in repo.users_group_to_perm:
             perm = users_group.permission.permission_name
             users_group = users_group.users_group
             users_group_data = users_group.get_api_data()
             users_group_data['type'] = "users_group"
             users_group_data['permission'] = perm
             members.append(users_group_data)
 
         ret['members'] = members
 
         expected = ret
         self._compare_ok(id_, expected, given=response.body)
         destroy_users_group(new_group)
 
     def test_api_get_repo_that_doesn_not_exist(self):
         id_, params = _build_data(self.apikey, 'get_repo',
                                   repoid='no-such-repo')
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         ret = 'repository `%s` does not exist' % 'no-such-repo'
         expected = ret
         self._compare_error(id_, expected, given=response.body)
 
     def test_api_get_repos(self):
         id_, params = _build_data(self.apikey, 'get_repos')
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         result = []
         for repo in RepoModel().get_all():
             result.append(repo.get_api_data())
         ret = jsonify(result)
 
         expected = ret
         self._compare_ok(id_, expected, given=response.body)
 
     @parameterized.expand([('all', 'all'),
                            ('dirs', 'dirs'),
                            ('files', 'files'), ])
     def test_api_get_repo_nodes(self, name, ret_type):
         rev = 'tip'
         path = '/'
         id_, params = _build_data(self.apikey, 'get_repo_nodes',
                                   repoid=self.REPO, revision=rev,
                                   root_path=path,
                                   ret_type=ret_type)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         # we don't the actual return types here since it's tested somewhere
         # else
         expected = json.loads(response.body)['result']
         self._compare_ok(id_, expected, given=response.body)
 
     def test_api_get_repo_nodes_bad_revisions(self):
         rev = 'i-dont-exist'
         path = '/'
         id_, params = _build_data(self.apikey, 'get_repo_nodes',
                                   repoid=self.REPO, revision=rev,
                                   root_path=path,)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = 'failed to get repo: `%s` nodes' % self.REPO
         self._compare_error(id_, expected, given=response.body)
 
     def test_api_get_repo_nodes_bad_path(self):
         rev = 'tip'
         path = '/idontexits'
         id_, params = _build_data(self.apikey, 'get_repo_nodes',
                                   repoid=self.REPO, revision=rev,
                                   root_path=path,)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = 'failed to get repo: `%s` nodes' % self.REPO
         self._compare_error(id_, expected, given=response.body)
 
     def test_api_get_repo_nodes_bad_ret_type(self):
         rev = 'tip'
         path = '/'
         ret_type = 'error'
         id_, params = _build_data(self.apikey, 'get_repo_nodes',
                                   repoid=self.REPO, revision=rev,
                                   root_path=path,
                                   ret_type=ret_type)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = 'ret_type must be one of %s' % (['files', 'dirs', 'all'])
         self._compare_error(id_, expected, given=response.body)
 
     def test_api_create_repo(self):
         repo_name = 'api-repo'
         id_, params = _build_data(self.apikey, 'create_repo',
                                     repo_name=repo_name,
                                     owner=TEST_USER_ADMIN_LOGIN,
                                     repo_type='hg',
                                   )
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         repo = RepoModel().get_by_repo_name(repo_name)
         ret = {
             'msg': 'Created new repository `%s`' % repo_name,
             'repo': jsonify(repo.get_api_data())
         }
         expected = ret
         self._compare_ok(id_, expected, given=response.body)
         destroy_repo(repo_name)
 
     def test_api_create_repo_unknown_owner(self):
         repo_name = 'api-repo'
         owner = 'i-dont-exist'
         id_, params = _build_data(self.apikey, 'create_repo',
                                     repo_name=repo_name,
                                     owner=owner,
                                     repo_type='hg',
                                   )
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
         expected = 'user `%s` does not exist' % owner
         self._compare_error(id_, expected, given=response.body)
 
     def test_api_create_repo_exists(self):
         repo_name = self.REPO
         id_, params = _build_data(self.apikey, 'create_repo',
                                     repo_name=repo_name,
                                     owner=TEST_USER_ADMIN_LOGIN,
                                     repo_type='hg',
                                   )
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
         expected = "repo `%s` already exist" % repo_name
         self._compare_error(id_, expected, given=response.body)
 
     @mock.patch.object(RepoModel, 'create_repo', crash)
     def test_api_create_repo_exception_occurred(self):
         repo_name = 'api-repo'
         id_, params = _build_data(self.apikey, 'create_repo',
                                     repo_name=repo_name,
                                     owner=TEST_USER_ADMIN_LOGIN,
                                     repo_type='hg',
                                   )
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
         expected = 'failed to create repository `%s`' % repo_name
         self._compare_error(id_, expected, given=response.body)
 
     def test_api_delete_repo(self):
         repo_name = 'api_delete_me'
         create_repo(repo_name, self.REPO_TYPE)
 
         id_, params = _build_data(self.apikey, 'delete_repo',
                                   repoid=repo_name,)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         ret = {
             'msg': 'Deleted repository `%s`' % repo_name,
             'success': True
         }
         expected = ret
         self._compare_ok(id_, expected, given=response.body)
 
     def test_api_delete_repo_exception_occurred(self):
         repo_name = 'api_delete_me'
         create_repo(repo_name, self.REPO_TYPE)
         try:
             with mock.patch.object(RepoModel, 'delete', crash):
                 id_, params = _build_data(self.apikey, 'delete_repo',
                                           repoid=repo_name,)
                 response = self.app.post(API_URL, content_type='application/json',
                                          params=params)
 
                 expected = 'failed to delete repository `%s`' % repo_name
                 self._compare_error(id_, expected, given=response.body)
         finally:
             destroy_repo(repo_name)
 
     def test_api_fork_repo(self):
         fork_name = 'api-repo-fork'
         id_, params = _build_data(self.apikey, 'fork_repo',
                                     repoid=self.REPO,
                                     fork_name=fork_name,
                                     owner=TEST_USER_ADMIN_LOGIN,
                                   )
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         ret = {
             'msg': 'Created fork of `%s` as `%s`' % (self.REPO,
                                                      fork_name),
             'success': True
         }
         expected = ret
         self._compare_ok(id_, expected, given=response.body)
         destroy_repo(fork_name)
 
     def test_api_fork_repo_unknown_owner(self):
         fork_name = 'api-repo-fork'
         owner = 'i-dont-exist'
         id_, params = _build_data(self.apikey, 'fork_repo',
                                     repoid=self.REPO,
                                     fork_name=fork_name,
                                     owner=owner,
                                   )
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
         expected = 'user `%s` does not exist' % owner
         self._compare_error(id_, expected, given=response.body)
 
     def test_api_fork_repo_fork_exists(self):
         fork_name = 'api-repo-fork'
         create_fork(fork_name, self.REPO_TYPE, self.REPO)
 
         try:
             fork_name = 'api-repo-fork'
 
             id_, params = _build_data(self.apikey, 'fork_repo',
                                         repoid=self.REPO,
                                         fork_name=fork_name,
                                         owner=TEST_USER_ADMIN_LOGIN,
                                       )
             response = self.app.post(API_URL, content_type='application/json',
                                      params=params)
 
             expected = "fork `%s` already exist" % fork_name
             self._compare_error(id_, expected, given=response.body)
         finally:
             destroy_repo(fork_name)
 
     def test_api_fork_repo_repo_exists(self):
         fork_name = self.REPO
 
         id_, params = _build_data(self.apikey, 'fork_repo',
                                     repoid=self.REPO,
                                     fork_name=fork_name,
                                     owner=TEST_USER_ADMIN_LOGIN,
                                   )
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = "repo `%s` already exist" % fork_name
         self._compare_error(id_, expected, given=response.body)
 
     @mock.patch.object(RepoModel, 'create_fork', crash)
     def test_api_fork_repo_exception_occurred(self):
         fork_name = 'api-repo-fork'
         id_, params = _build_data(self.apikey, 'fork_repo',
                                     repoid=self.REPO,
                                     fork_name=fork_name,
                                     owner=TEST_USER_ADMIN_LOGIN,
                                   )
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = 'failed to fork repository `%s` as `%s`' % (self.REPO,
                                                                fork_name)
         self._compare_error(id_, expected, given=response.body)
 
     def test_api_get_users_group(self):
         id_, params = _build_data(self.apikey, 'get_users_group',
                                   usersgroupid=TEST_USERS_GROUP)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         users_group = UsersGroupModel().get_group(TEST_USERS_GROUP)
         members = []
         for user in users_group.members:
             user = user.user
             members.append(user.get_api_data())
 
         ret = users_group.get_api_data()
         ret['members'] = members
         expected = ret
         self._compare_ok(id_, expected, given=response.body)
 
     def test_api_get_users_groups(self):
 
         make_users_group('test_users_group2')
 
         id_, params = _build_data(self.apikey, 'get_users_groups',)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = []
         for gr_name in [TEST_USERS_GROUP, 'test_users_group2']:
             users_group = UsersGroupModel().get_group(gr_name)
             ret = users_group.get_api_data()
             expected.append(ret)
         self._compare_ok(id_, expected, given=response.body)
 
         UsersGroupModel().delete(users_group='test_users_group2')
         self.Session().commit()
 
     def test_api_create_users_group(self):
         group_name = 'some_new_group'
         id_, params = _build_data(self.apikey, 'create_users_group',
                                   group_name=group_name)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         ret = {
             'msg': 'created new users group `%s`' % group_name,
             'users_group': jsonify(UsersGroupModel()\
                                    .get_by_name(group_name)\
                                    .get_api_data())
         }
         expected = ret
         self._compare_ok(id_, expected, given=response.body)
 
         destroy_users_group(group_name)
 
     def test_api_get_users_group_that_exist(self):
         id_, params = _build_data(self.apikey, 'create_users_group',
                                   group_name=TEST_USERS_GROUP)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = "users group `%s` already exist" % TEST_USERS_GROUP
         self._compare_error(id_, expected, given=response.body)
 
     @mock.patch.object(UsersGroupModel, 'create', crash)
     def test_api_get_users_group_exception_occurred(self):
         group_name = 'exception_happens'
         id_, params = _build_data(self.apikey, 'create_users_group',
                                   group_name=group_name)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = 'failed to create group `%s`' % group_name
         self._compare_error(id_, expected, given=response.body)
 
     def test_api_add_user_to_users_group(self):
         gr_name = 'test_group'
         UsersGroupModel().create(gr_name)
         self.Session().commit()
         id_, params = _build_data(self.apikey, 'add_user_to_users_group',
                                   usersgroupid=gr_name,
                                   userid=TEST_USER_ADMIN_LOGIN)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = {
                     'msg': 'added member `%s` to users group `%s`' % (
                                 TEST_USER_ADMIN_LOGIN, gr_name
                             ),
                     'success': True}
         self._compare_ok(id_, expected, given=response.body)
 
         UsersGroupModel().delete(users_group=gr_name)
         self.Session().commit()
 
     def test_api_add_user_to_users_group_that_doesnt_exist(self):
         id_, params = _build_data(self.apikey, 'add_user_to_users_group',
                                   usersgroupid='false-group',
                                   userid=TEST_USER_ADMIN_LOGIN)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = 'users group `%s` does not exist' % 'false-group'
         self._compare_error(id_, expected, given=response.body)
 
     @mock.patch.object(UsersGroupModel, 'add_user_to_group', crash)
     def test_api_add_user_to_users_group_exception_occurred(self):
         gr_name = 'test_group'
         UsersGroupModel().create(gr_name)
         self.Session().commit()
         id_, params = _build_data(self.apikey, 'add_user_to_users_group',
                                   usersgroupid=gr_name,
                                   userid=TEST_USER_ADMIN_LOGIN)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = 'failed to add member to users group `%s`' % gr_name
         self._compare_error(id_, expected, given=response.body)
 
         UsersGroupModel().delete(users_group=gr_name)
         self.Session().commit()
 
     def test_api_remove_user_from_users_group(self):
         gr_name = 'test_group_3'
         gr = UsersGroupModel().create(gr_name)
         UsersGroupModel().add_user_to_group(gr, user=TEST_USER_ADMIN_LOGIN)
         self.Session().commit()
         id_, params = _build_data(self.apikey, 'remove_user_from_users_group',
                                   usersgroupid=gr_name,
                                   userid=TEST_USER_ADMIN_LOGIN)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = {
                     'msg': 'removed member `%s` from users group `%s`' % (
                                 TEST_USER_ADMIN_LOGIN, gr_name
                             ),
                     'success': True}
         self._compare_ok(id_, expected, given=response.body)
 
         UsersGroupModel().delete(users_group=gr_name)
         self.Session().commit()
 
     @mock.patch.object(UsersGroupModel, 'remove_user_from_group', crash)
     def test_api_remove_user_from_users_group_exception_occurred(self):
         gr_name = 'test_group_3'
         gr = UsersGroupModel().create(gr_name)
         UsersGroupModel().add_user_to_group(gr, user=TEST_USER_ADMIN_LOGIN)
         self.Session().commit()
         id_, params = _build_data(self.apikey, 'remove_user_from_users_group',
                                   usersgroupid=gr_name,
                                   userid=TEST_USER_ADMIN_LOGIN)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = 'failed to remove member from users group `%s`' % gr_name
         self._compare_error(id_, expected, given=response.body)
 
         UsersGroupModel().delete(users_group=gr_name)
         self.Session().commit()
 
     @parameterized.expand([('none', 'repository.none'),
                            ('read', 'repository.read'),
                            ('write', 'repository.write'),
                            ('admin', 'repository.admin')])
     def test_api_grant_user_permission(self, name, perm):
         id_, params = _build_data(self.apikey, 'grant_user_permission',
                                   repoid=self.REPO,
                                   userid=TEST_USER_ADMIN_LOGIN,
                                   perm=perm)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         ret = {
                 'msg': 'Granted perm: `%s` for user: `%s` in repo: `%s`' % (
                     perm, TEST_USER_ADMIN_LOGIN, self.REPO
                 ),
                 'success': True
             }
         expected = ret
         self._compare_ok(id_, expected, given=response.body)
 
     def test_api_grant_user_permission_wrong_permission(self):
         perm = 'haha.no.permission'
         id_, params = _build_data(self.apikey, 'grant_user_permission',
                                   repoid=self.REPO,
                                   userid=TEST_USER_ADMIN_LOGIN,
                                   perm=perm)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = 'permission `%s` does not exist' % perm
         self._compare_error(id_, expected, given=response.body)
 
     @mock.patch.object(RepoModel, 'grant_user_permission', crash)
     def test_api_grant_user_permission_exception_when_adding(self):
         perm = 'repository.read'
         id_, params = _build_data(self.apikey, 'grant_user_permission',
                                   repoid=self.REPO,
                                   userid=TEST_USER_ADMIN_LOGIN,
                                   perm=perm)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = 'failed to edit permission for user: `%s` in repo: `%s`' % (
                     TEST_USER_ADMIN_LOGIN, self.REPO
                 )
         self._compare_error(id_, expected, given=response.body)
 
     def test_api_revoke_user_permission(self):
         id_, params = _build_data(self.apikey, 'revoke_user_permission',
                                   repoid=self.REPO,
                                   userid=TEST_USER_ADMIN_LOGIN,)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = {
             'msg': 'Revoked perm for user: `%s` in repo: `%s`' % (
                 TEST_USER_ADMIN_LOGIN, self.REPO
             ),
             'success': True
         }
         self._compare_ok(id_, expected, given=response.body)
 
     @mock.patch.object(RepoModel, 'revoke_user_permission', crash)
     def test_api_revoke_user_permission_exception_when_adding(self):
         id_, params = _build_data(self.apikey, 'revoke_user_permission',
                                   repoid=self.REPO,
                                   userid=TEST_USER_ADMIN_LOGIN,)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = 'failed to edit permission for user: `%s` in repo: `%s`' % (
                     TEST_USER_ADMIN_LOGIN, self.REPO
                 )
         self._compare_error(id_, expected, given=response.body)
 
     @parameterized.expand([('none', 'repository.none'),
                            ('read', 'repository.read'),
                            ('write', 'repository.write'),
                            ('admin', 'repository.admin')])
     def test_api_grant_users_group_permission(self, name, perm):
         id_, params = _build_data(self.apikey, 'grant_users_group_permission',
                                   repoid=self.REPO,
                                   usersgroupid=TEST_USERS_GROUP,
                                   perm=perm)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         ret = {
             'msg': 'Granted perm: `%s` for users group: `%s` in repo: `%s`' % (
                 perm, TEST_USERS_GROUP, self.REPO
             ),
             'success': True
         }
         expected = ret
         self._compare_ok(id_, expected, given=response.body)
 
     def test_api_grant_users_group_permission_wrong_permission(self):
         perm = 'haha.no.permission'
         id_, params = _build_data(self.apikey, 'grant_users_group_permission',
                                   repoid=self.REPO,
                                   usersgroupid=TEST_USERS_GROUP,
                                   perm=perm)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = 'permission `%s` does not exist' % perm
         self._compare_error(id_, expected, given=response.body)
 
     @mock.patch.object(RepoModel, 'grant_users_group_permission', crash)
     def test_api_grant_users_group_permission_exception_when_adding(self):
         perm = 'repository.read'
         id_, params = _build_data(self.apikey, 'grant_users_group_permission',
                                   repoid=self.REPO,
                                   usersgroupid=TEST_USERS_GROUP,
                                   perm=perm)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = 'failed to edit permission for users group: `%s` in repo: `%s`' % (
                     TEST_USERS_GROUP, self.REPO
                 )
         self._compare_error(id_, expected, given=response.body)
 
     def test_api_revoke_users_group_permission(self):
         RepoModel().grant_users_group_permission(repo=self.REPO,
                                                  group_name=TEST_USERS_GROUP,
                                                  perm='repository.read')
         self.Session().commit()
         id_, params = _build_data(self.apikey, 'revoke_users_group_permission',
                                   repoid=self.REPO,
                                   usersgroupid=TEST_USERS_GROUP,)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = {
             'msg': 'Revoked perm for users group: `%s` in repo: `%s`' % (
                 TEST_USERS_GROUP, self.REPO
             ),
             'success': True
         }
         self._compare_ok(id_, expected, given=response.body)
 
     @mock.patch.object(RepoModel, 'revoke_users_group_permission', crash)
     def test_api_revoke_users_group_permission_exception_when_adding(self):
 
         id_, params = _build_data(self.apikey, 'revoke_users_group_permission',
                                   repoid=self.REPO,
                                   usersgroupid=TEST_USERS_GROUP,)
         response = self.app.post(API_URL, content_type='application/json',
                                  params=params)
 
         expected = 'failed to edit permission for users group: `%s` in repo: `%s`' % (
                     TEST_USERS_GROUP, self.REPO
                 )
         self._compare_error(id_, expected, given=response.body)
-

rhodecode/tests/api/test_api_hg.py

@@ -1,7 +1,7 b''
 from rhodecode.tests import *
 from rhodecode.tests.api.api_base import BaseTestApi
 
 
 class TestHgApi(BaseTestApi, TestController):
     REPO = HG_REPO
-    REPO_TYPE = 'hg'
  No newline at end of file
+    REPO_TYPE = 'hg'

rhodecode/tests/functional/test_admin_settings.py

@@ -1,266 +1,266 b''
 # -*- coding: utf-8 -*-
 
 from rhodecode.lib.auth import get_crypt_password, check_password
 from rhodecode.model.db import User, RhodeCodeSetting, Repository
 from rhodecode.tests import *
 from rhodecode.lib import helpers as h
 from rhodecode.model.user import UserModel
 from rhodecode.model.scm import ScmModel
 
 
 class TestAdminSettingsController(TestController):
 
     def test_index(self):
         response = self.app.get(url('admin_settings'))
         # Test response...
 
     def test_index_as_xml(self):
         response = self.app.get(url('formatted_admin_settings', format='xml'))
 
     def test_create(self):
         response = self.app.post(url('admin_settings'))
 
     def test_new(self):
         response = self.app.get(url('admin_new_setting'))
 
     def test_new_as_xml(self):
         response = self.app.get(url('formatted_admin_new_setting', format='xml'))
 
     def test_update(self):
         response = self.app.put(url('admin_setting', setting_id=1))
 
     def test_update_browser_fakeout(self):
         response = self.app.post(url('admin_setting', setting_id=1), params=dict(_method='put'))
 
     def test_delete(self):
         response = self.app.delete(url('admin_setting', setting_id=1))
 
     def test_delete_browser_fakeout(self):
         response = self.app.post(url('admin_setting', setting_id=1), params=dict(_method='delete'))
 
     def test_show(self):
         response = self.app.get(url('admin_setting', setting_id=1))
 
     def test_show_as_xml(self):
         response = self.app.get(url('formatted_admin_setting', setting_id=1, format='xml'))
 
     def test_edit(self):
         response = self.app.get(url('admin_edit_setting', setting_id=1))
 
     def test_edit_as_xml(self):
         response = self.app.get(url('formatted_admin_edit_setting',
                                     setting_id=1, format='xml'))
 
     def test_ga_code_active(self):
         self.log_user()
         old_title = 'RhodeCode'
         old_realm = 'RhodeCode authentication'
         new_ga_code = 'ga-test-123456789'
         response = self.app.post(url('admin_setting', setting_id='global'),
                                      params=dict(
                                                  _method='put',
                                                  rhodecode_title=old_title,
                                                  rhodecode_realm=old_realm,
                                                  rhodecode_ga_code=new_ga_code
                                                  ))
 
         self.checkSessionFlash(response, 'Updated application settings')
 
         self.assertEqual(RhodeCodeSetting
                          .get_app_settings()['rhodecode_ga_code'], new_ga_code)
 
         response = response.follow()
         response.mustcontain("""_gaq.push(['_setAccount', '%s']);""" % new_ga_code)
 
     def test_ga_code_inactive(self):
         self.log_user()
         old_title = 'RhodeCode'
         old_realm = 'RhodeCode authentication'
         new_ga_code = ''
         response = self.app.post(url('admin_setting', setting_id='global'),
                                      params=dict(
                                                  _method='put',
                                                  rhodecode_title=old_title,
                                                  rhodecode_realm=old_realm,
                                                  rhodecode_ga_code=new_ga_code
                                                  ))
 
         self.assertTrue('Updated application settings' in
                         response.session['flash'][0][1])
         self.assertEqual(RhodeCodeSetting
                         .get_app_settings()['rhodecode_ga_code'], new_ga_code)
 
         response = response.follow()
         self.assertFalse("""_gaq.push(['_setAccount', '%s']);""" % new_ga_code
                          in response.body)
 
     def test_title_change(self):
         self.log_user()
         old_title = 'RhodeCode'
         new_title = old_title + '_changed'
         old_realm = 'RhodeCode authentication'
 
         for new_title in ['Changed', 'Żółwik', old_title]:
             response = self.app.post(url('admin_setting', setting_id='global'),
                                          params=dict(
                                                      _method='put',
                                                      rhodecode_title=new_title,
                                                      rhodecode_realm=old_realm,
                                                      rhodecode_ga_code=''
                                                      ))
 
             self.checkSessionFlash(response, 'Updated application settings')
             self.assertEqual(RhodeCodeSetting
                              .get_app_settings()['rhodecode_title'],
                              new_title.decode('utf-8'))
 
             response = response.follow()
             response.mustcontain("""<h1><a href="/">%s</a></h1>""" % new_title)
 
     def test_my_account(self):
         self.log_user()
         response = self.app.get(url('admin_settings_my_account'))
 
         self.assertTrue('value="test_admin' in response.body)
 
     @parameterized.expand([('firstname', 'new_username'),
                            ('lastname', 'new_username'),
                            ('admin', True),
                            ('admin', False),
                            ('ldap_dn', 'test'),
                            ('ldap_dn', None),
                            ('active', False),
                            ('active', True),
                            ('email', '[e-mail]'),
                            ])
     def test_my_account_update(self, name, expected):
         uname = 'testme'
         usr = UserModel().create_or_update(username=uname, password='qweqwe',
                                            email='[e-mail]')
         self.Session().commit()
         params = usr.get_api_data()
         user_id = usr.user_id
         self.log_user(username=uname, password='qweqwe')
         params.update({name: expected})
         params.update({'password_confirmation': ''})
         params.update({'new_password': ''})
 
         try:
             response = self.app.put(url('admin_settings_my_account_update',
                                         id=user_id), params)
 
             self.checkSessionFlash(response,
                                    'Your account was updated successfully')
 
             updated_user = User.get_by_username(uname)
             updated_params = updated_user.get_api_data()
             updated_params.update({'password_confirmation': ''})
             updated_params.update({'new_password': ''})
 
             params['last_login'] = updated_params['last_login']
             if name == 'email':
                 params['emails'] = [expected]
             if name == 'ldap_dn':
                 #cannot update this via form
                 params['ldap_dn'] = None
             if name == 'active':
                 #my account cannot deactivate account
                 params['active'] = True
             if name == 'admin':
                 #my account cannot make you an admin !
                 params['admin'] = False
 
             self.assertEqual(params, updated_params)
 
         finally:
             UserModel().delete('testme')
 
     def test_my_account_update_err_email_exists(self):
         self.log_user()
 
         new_email = '[e-mail]'  # already exisitn email
         response = self.app.put(url('admin_settings_my_account_update'),
                                 params=dict(
                                     username='test_admin',
                                     new_password='test12',
                                     password_confirmation='test122',
                                     firstname='NewName',
                                     lastname='NewLastname',
                                     email=new_email,)
                                 )
 
         response.mustcontain('This e-mail address is already taken')
 
     def test_my_account_update_err(self):
         self.log_user('test_regular2', 'test12')
 
         new_email = 'newmail.pl'
         response = self.app.post(url('admin_settings_my_account_update'),
                                  params=dict(
                                             _method='put',
                                             username='test_admin',
                                             new_password='test12',
                                             password_confirmation='test122',
                                             firstname='NewName',
                                             lastname='NewLastname',
                                             email=new_email,)
                                  )
 
         response.mustcontain('An email address must contain a single @')
         from rhodecode.model import validators
         msg = validators.ValidUsername(edit=False,
                                     old_data={})._messages['username_exists']
         msg = h.html_escape(msg % {'username': 'test_admin'})
         response.mustcontain(u"%s" % msg)
 
     def test_set_repo_fork_has_no_self_id(self):
         self.log_user()
         repo = Repository.get_by_repo_name(HG_REPO)
         response = self.app.get(url('edit_repo', repo_name=HG_REPO))
         opt = """<option value="%s">vcs_test_git</option>""" % repo.repo_id
         assert opt not in response.body
 
     def test_set_fork_of_repo(self):
         self.log_user()
         repo = Repository.get_by_repo_name(HG_REPO)
         repo2 = Repository.get_by_repo_name(GIT_REPO)
         response = self.app.put(url('repo_as_fork', repo_name=HG_REPO),
                                  params=dict(
                                     id_fork_of=repo2.repo_id
                                  ))
         repo = Repository.get_by_repo_name(HG_REPO)
         repo2 = Repository.get_by_repo_name(GIT_REPO)
         self.checkSessionFlash(response,
         'Marked repo %s as fork of %s' % (repo.repo_name, repo2.repo_name))
 
         assert repo.fork == repo2
         response = response.follow()
         # check if given repo is selected
 
         opt = """<option value="%s" selected="selected">%s</option>""" % (
                                                 repo2.repo_id, repo2.repo_name)
         response.mustcontain(opt)
 
         # clean session flash
         #response = self.app.get(url('edit_repo', repo_name=HG_REPO))
 
         ## mark it as None
         response = self.app.put(url('repo_as_fork', repo_name=HG_REPO),
                                  params=dict(
                                     id_fork_of=None
                                  ))
         repo = Repository.get_by_repo_name(HG_REPO)
         repo2 = Repository.get_by_repo_name(GIT_REPO)
         self.checkSessionFlash(response,
         'Marked repo %s as fork of %s' % (repo.repo_name, "Nothing"))
         assert repo.fork == None
 
     def test_set_fork_of_same_repo(self):
         self.log_user()
         repo = Repository.get_by_repo_name(HG_REPO)
         response = self.app.put(url('repo_as_fork', repo_name=HG_REPO),
                                  params=dict(
                                     id_fork_of=repo.repo_id
                                  ))
         self.checkSessionFlash(response,
-                               'An error occurred during this operation')
  No newline at end of file
+                               'An error occurred during this operation')

rhodecode/tests/models/test_notifications.py

@@ -1,191 +1,187 b''
 import os
 import unittest
 from rhodecode.tests import *
 
 from rhodecode.model.db import User, Notification, UserNotification
 from rhodecode.model.user import UserModel
 
 from rhodecode.model.meta import Session
 from rhodecode.model.notification import NotificationModel
 
 
 class TestNotifications(unittest.TestCase):
 
     def __init__(self, methodName='runTest'):
         Session.remove()
         self.u1 = UserModel().create_or_update(username=u'u1',
                                         password=u'qweqwe',
                                         email=u'[e-mail]',
                                         firstname=u'u1', lastname=u'u1')
         Session().commit()
         self.u1 = self.u1.user_id
 
         self.u2 = UserModel().create_or_update(username=u'u2',
                                         password=u'qweqwe',
                                         email=u'[e-mail]',
                                         firstname=u'u2', lastname=u'u3')
         Session().commit()
         self.u2 = self.u2.user_id
 
         self.u3 = UserModel().create_or_update(username=u'u3',
                                         password=u'qweqwe',
                                         email=u'[e-mail]',
                                         firstname=u'u3', lastname=u'u3')
         Session().commit()
         self.u3 = self.u3.user_id
 
         super(TestNotifications, self).__init__(methodName=methodName)
 
     def _clean_notifications(self):
         for n in Notification.query().all():
             Session().delete(n)
 
         Session().commit()
         self.assertEqual(Notification.query().all(), [])
 
     def tearDown(self):
         self._clean_notifications()
 
     def test_create_notification(self):
         self.assertEqual([], Notification.query().all())
         self.assertEqual([], UserNotification.query().all())
 
         usrs = [self.u1, self.u2]
         notification = NotificationModel().create(created_by=self.u1,
                                            subject=u'subj', body=u'hi there',
                                            recipients=usrs)
         Session().commit()
         u1 = User.get(self.u1)
         u2 = User.get(self.u2)
         u3 = User.get(self.u3)
         notifications = Notification.query().all()
         self.assertEqual(len(notifications), 1)
 
         self.assertEqual(notifications[0].recipients, [u1, u2])
         self.assertEqual(notification.notification_id,
                          notifications[0].notification_id)
 
         unotification = UserNotification.query()\
             .filter(UserNotification.notification == notification).all()
 
         self.assertEqual(len(unotification), len(usrs))
         self.assertEqual(set([x.user.user_id for x in unotification]),
                          set(usrs))
 
     def test_user_notifications(self):
         self.assertEqual([], Notification.query().all())
         self.assertEqual([], UserNotification.query().all())
 
         notification1 = NotificationModel().create(created_by=self.u1,
                                             subject=u'subj', body=u'hi there1',
                                             recipients=[self.u3])
         Session().commit()
         notification2 = NotificationModel().create(created_by=self.u1,
                                             subject=u'subj', body=u'hi there2',
                                             recipients=[self.u3])
         Session().commit()
         u3 = Session().query(User).get(self.u3)
 
         self.assertEqual(sorted([x.notification for x in u3.notifications]),
                          sorted([notification2, notification1]))
 
     def test_delete_notifications(self):
         self.assertEqual([], Notification.query().all())
         self.assertEqual([], UserNotification.query().all())
 
         notification = NotificationModel().create(created_by=self.u1,
                                            subject=u'title', body=u'hi there3',
                                     recipients=[self.u3, self.u1, self.u2])
         Session().commit()
         notifications = Notification.query().all()
         self.assertTrue(notification in notifications)
 
         Notification.delete(notification.notification_id)
         Session().commit()
 
         notifications = Notification.query().all()
         self.assertFalse(notification in notifications)
 
         un = UserNotification.query().filter(UserNotification.notification
                                              == notification).all()
         self.assertEqual(un, [])
 
     def test_delete_association(self):
 
         self.assertEqual([], Notification.query().all())
         self.assertEqual([], UserNotification.query().all())
 
         notification = NotificationModel().create(created_by=self.u1,
                                            subject=u'title', body=u'hi there3',
                                     recipients=[self.u3, self.u1, self.u2])
         Session().commit()
 
         unotification = UserNotification.query()\
                             .filter(UserNotification.notification ==
                                     notification)\
                             .filter(UserNotification.user_id == self.u3)\
                             .scalar()
 
         self.assertEqual(unotification.user_id, self.u3)
 
         NotificationModel().delete(self.u3,
                                    notification.notification_id)
         Session().commit()
 
         u3notification = UserNotification.query()\
                             .filter(UserNotification.notification ==
                                     notification)\
                             .filter(UserNotification.user_id == self.u3)\
                             .scalar()
 
         self.assertEqual(u3notification, None)
 
         # notification object is still there
         self.assertEqual(Notification.query().all(), [notification])
 
         #u1 and u2 still have assignments
         u1notification = UserNotification.query()\
                             .filter(UserNotification.notification ==
                                     notification)\
                             .filter(UserNotification.user_id == self.u1)\
                             .scalar()
         self.assertNotEqual(u1notification, None)
         u2notification = UserNotification.query()\
                             .filter(UserNotification.notification ==
                                     notification)\
                             .filter(UserNotification.user_id == self.u2)\
                             .scalar()
         self.assertNotEqual(u2notification, None)
 
     def test_notification_counter(self):
         self._clean_notifications()
         self.assertEqual([], Notification.query().all())
         self.assertEqual([], UserNotification.query().all())
 
         NotificationModel().create(created_by=self.u1,
                             subject=u'title', body=u'hi there_delete',
                             recipients=[self.u3, self.u1])
         Session().commit()
 
         self.assertEqual(NotificationModel()
                          .get_unread_cnt_for_user(self.u1), 1)
         self.assertEqual(NotificationModel()
                          .get_unread_cnt_for_user(self.u2), 0)
         self.assertEqual(NotificationModel()
                          .get_unread_cnt_for_user(self.u3), 1)
 
         notification = NotificationModel().create(created_by=self.u1,
                                            subject=u'title', body=u'hi there3',
                                     recipients=[self.u3, self.u1, self.u2])
         Session().commit()
 
         self.assertEqual(NotificationModel()
                          .get_unread_cnt_for_user(self.u1), 2)
         self.assertEqual(NotificationModel()
                          .get_unread_cnt_for_user(self.u2), 1)
         self.assertEqual(NotificationModel()
                          .get_unread_cnt_for_user(self.u3), 2)
-
-
-
-

rhodecode/tests/models/test_repos_groups.py

@@ -1,170 +1,170 b''
 import os
 import unittest
 from rhodecode.tests import *
 
 from rhodecode.model.repos_group import ReposGroupModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.db import RepoGroup, User
 from rhodecode.model.meta import Session
 from sqlalchemy.exc import IntegrityError
 
 
 def _make_group(path, desc='desc', parent_id=None,
                  skip_if_exists=False):
 
     gr = RepoGroup.get_by_group_name(path)
     if gr and skip_if_exists:
         return gr
 
     gr = ReposGroupModel().create(path, desc, parent_id)
     return gr
 
 
 class TestReposGroups(unittest.TestCase):
 
     def setUp(self):
         self.g1 = _make_group('test1', skip_if_exists=True)
         Session().commit()
         self.g2 = _make_group('test2', skip_if_exists=True)
         Session().commit()
         self.g3 = _make_group('test3', skip_if_exists=True)
         Session().commit()
 
     def tearDown(self):
         print 'out'
 
     def __check_path(self, *path):
         """
         Checks the path for existance !
         """
         path = [TESTS_TMP_PATH] + list(path)
         path = os.path.join(*path)
         return os.path.isdir(path)
 
     def _check_folders(self):
         print os.listdir(TESTS_TMP_PATH)
 
     def __delete_group(self, id_):
         ReposGroupModel().delete(id_)
 
     def __update_group(self, id_, path, desc='desc', parent_id=None):
         form_data = dict(
             group_name=path,
             group_description=desc,
             group_parent_id=parent_id,
             perms_updates=[],
             perms_new=[]
         )
         gr = ReposGroupModel().update(id_, form_data)
         return gr
 
     def test_create_group(self):
         g = _make_group('newGroup')
         self.assertEqual(g.full_path, 'newGroup')
 
         self.assertTrue(self.__check_path('newGroup'))
 
     def test_create_same_name_group(self):
         self.assertRaises(IntegrityError, lambda: _make_group('newGroup'))
         Session().rollback()
 
     def test_same_subgroup(self):
         sg1 = _make_group('sub1', parent_id=self.g1.group_id)
         self.assertEqual(sg1.parent_group, self.g1)
         self.assertEqual(sg1.full_path, 'test1/sub1')
         self.assertTrue(self.__check_path('test1', 'sub1'))
 
         ssg1 = _make_group('subsub1', parent_id=sg1.group_id)
         self.assertEqual(ssg1.parent_group, sg1)
         self.assertEqual(ssg1.full_path, 'test1/sub1/subsub1')
         self.assertTrue(self.__check_path('test1', 'sub1', 'subsub1'))
 
     def test_remove_group(self):
         sg1 = _make_group('deleteme')
         self.__delete_group(sg1.group_id)
 
         self.assertEqual(RepoGroup.get(sg1.group_id), None)
         self.assertFalse(self.__check_path('deteteme'))
 
         sg1 = _make_group('deleteme', parent_id=self.g1.group_id)
         self.__delete_group(sg1.group_id)
 
         self.assertEqual(RepoGroup.get(sg1.group_id), None)
         self.assertFalse(self.__check_path('test1', 'deteteme'))
 
     def test_rename_single_group(self):
         sg1 = _make_group('initial')
 
         new_sg1 = self.__update_group(sg1.group_id, 'after')
         self.assertTrue(self.__check_path('after'))
         self.assertEqual(RepoGroup.get_by_group_name('initial'), None)
 
     def test_update_group_parent(self):
 
         sg1 = _make_group('initial', parent_id=self.g1.group_id)
 
         new_sg1 = self.__update_group(sg1.group_id, 'after', parent_id=self.g1.group_id)
         self.assertTrue(self.__check_path('test1', 'after'))
         self.assertEqual(RepoGroup.get_by_group_name('test1/initial'), None)
 
         new_sg1 = self.__update_group(sg1.group_id, 'after', parent_id=self.g3.group_id)
         self.assertTrue(self.__check_path('test3', 'after'))
         self.assertEqual(RepoGroup.get_by_group_name('test3/initial'), None)
 
         new_sg1 = self.__update_group(sg1.group_id, 'hello')
         self.assertTrue(self.__check_path('hello'))
 
         self.assertEqual(RepoGroup.get_by_group_name('hello'), new_sg1)
 
     def test_subgrouping_with_repo(self):
 
         g1 = _make_group('g1')
         g2 = _make_group('g2')
 
         # create new repo
         form_data = dict(repo_name='john',
                          repo_name_full='john',
                          fork_name=None,
                          description=None,
                          repo_group=None,
                          private=False,
                          repo_type='hg',
                          clone_uri=None,
                          landing_rev='tip')
         cur_user = User.get_by_username(TEST_USER_ADMIN_LOGIN)
         r = RepoModel().create(form_data, cur_user)
 
         self.assertEqual(r.repo_name, 'john')
 
         # put repo into group
         form_data = form_data
         form_data['repo_group'] = g1.group_id
         form_data['perms_new'] = []
         form_data['perms_updates'] = []
         RepoModel().update(r.repo_name, form_data)
         self.assertEqual(r.repo_name, 'g1/john')
 
         self.__update_group(g1.group_id, 'g1', parent_id=g2.group_id)
         self.assertTrue(self.__check_path('g2', 'g1'))
 
         # test repo
         self.assertEqual(r.repo_name, RepoGroup.url_sep().join(['g2', 'g1',
                                                                 r.just_name]))
 
     def test_move_to_root(self):
         g1 = _make_group('t11')
         Session().commit()
         g2 = _make_group('t22', parent_id=g1.group_id)
         Session().commit()
 
         self.assertEqual(g2.full_path, 't11/t22')
         self.assertTrue(self.__check_path('t11', 't22'))
 
         g2 = self.__update_group(g2.group_id, 'g22', parent_id=None)
         Session().commit()
 
         self.assertEqual(g2.group_name, 'g22')
         # we moved out group from t1 to '' so it's full path should be 'g2'
         self.assertEqual(g2.full_path, 'g22')
         self.assertFalse(self.__check_path('t11', 't22'))
-        self.assertTrue(self.__check_path('g22'))
  No newline at end of file
+        self.assertTrue(self.__check_path('g22'))