kallithea Changeset - aa3e860a1fe0

Changeset - aa3e860a1fe0

Parent rev.

Child rev.

[Not reviewed]

Merge default

0 10 0

Mads Kiilerich (mads) - 5 years ago 2020-12-21 01:19:49
mads@kiilerich.com

Merge stable

3 files changed:

kallithea/controllers/api/api.py

kallithea/i18n/de/LC_MESSAGES/kallithea.po

kallithea/i18n/el/LC_MESSAGES/kallithea.po

Changeset was too big and was cut off... Show full diff anyway

0 comments (0 inline, 0 general)

kallithea/controllers/api/api.py

➞

Show inline comments

 # -*- coding: utf-8 -*-
 # 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/>.
 """
 kallithea.controllers.api.api
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 API controller for Kallithea
 This file was forked by the Kallithea project in July 2014.
 Original author and date, and relevant copyright and licensing information is below:
 :created_on: Aug 20, 2011
 :author: marcink
 :copyright: (c) 2013 RhodeCode GmbH, and others.
 :license: GPLv3, see LICENSE.md for more details.
 """
 import logging
 import traceback
 from datetime import datetime
 from tg import request
 from kallithea.controllers.api import JSONRPCController, JSONRPCError
 from kallithea.lib.auth import (AuthUser, HasPermissionAny, HasPermissionAnyDecorator, HasRepoGroupPermissionLevel, HasRepoPermissionLevel,
                                 HasUserGroupPermissionLevel)
 from kallithea.lib.exceptions import DefaultUserException, UserGroupsAssignedException
 from kallithea.lib.utils import repo2db_mapper
 from kallithea.lib.vcs.backends.base import EmptyChangeset
 from kallithea.lib.vcs.exceptions import EmptyRepositoryError
 from kallithea.model import db, meta, userlog
 from kallithea.model.changeset_status import ChangesetStatusModel
 from kallithea.model.comment import ChangesetCommentsModel
 from kallithea.model.gist import GistModel
 from kallithea.model.pull_request import PullRequestModel
 from kallithea.model.repo import RepoModel
 from kallithea.model.repo_group import RepoGroupModel
 from kallithea.model.scm import ScmModel, UserGroupList
 from kallithea.model.user import UserModel
 from kallithea.model.user_group import UserGroupModel
 log = logging.getLogger(__name__)
 def store_update(updates, attr, name):
     """
     Stores param in updates dict if it's not None (i.e. if user explicitly set
     a parameter). This allows easy updates of passed in params.
     """
     if attr is not None:
         updates[name] = attr
 def get_user_or_error(userid):
     """
     Get user by id or name or return JsonRPCError if not found
     :param userid:
     """
     user = UserModel().get_user(userid)
     if user is None:
         raise JSONRPCError("user `%s` does not exist" % (userid,))
     return user
 def get_repo_or_error(repoid):
     """
     Get repo by id or name or return JsonRPCError if not found
     :param repoid:
     """
     repo = RepoModel().get_repo(repoid)
     if repo is None:
         raise JSONRPCError('repository `%s` does not exist' % (repoid,))
     return repo
 def get_repo_group_or_error(repogroupid):
     """
     Get repo group by id or name or return JsonRPCError if not found
     :param repogroupid:
     """
     repo_group = db.RepoGroup.guess_instance(repogroupid)
     if repo_group is None:
         raise JSONRPCError(
             'repository group `%s` does not exist' % (repogroupid,))
     return repo_group
 def get_user_group_or_error(usergroupid):
     """
     Get user group by id or name or return JsonRPCError if not found
     :param usergroupid:
     """
     user_group = UserGroupModel().get_group(usergroupid)
     if user_group is None:
         raise JSONRPCError('user group `%s` does not exist' % (usergroupid,))
     return user_group
 def get_perm_or_error(permid, prefix=None):
     """
     Get permission by id or name or return JsonRPCError if not found
     :param permid:
     """
     perm = db.Permission.get_by_key(permid)
     if perm is None:
         raise JSONRPCError('permission `%s` does not exist' % (permid,))
     if prefix:
         if not perm.permission_name.startswith(prefix):
             raise JSONRPCError('permission `%s` is invalid, '
                                'should start with %s' % (permid, prefix))
     return perm
 def get_gist_or_error(gistid):
     """
     Get gist by id or gist_access_id or return JsonRPCError if not found
     :param gistid:
     """
     gist = GistModel().get_gist(gistid)
     if gist is None:
         raise JSONRPCError('gist `%s` does not exist' % (gistid,))
     return gist
 class ApiController(JSONRPCController):
     """
     API Controller
     The authenticated user can be found as request.authuser.
     Example function::
         def func(arg1, arg2,...):
             pass
     Each function should also **raise** JSONRPCError for any
     errors that happens.
     """
     @HasPermissionAnyDecorator('hg.admin')
     def test(self, args):
         return args
     @HasPermissionAnyDecorator('hg.admin')
     def pull(self, repoid, clone_uri=None):
         """
         Triggers a pull from remote location on given repo. Can be used to
         automatically keep remote repos up to date. This command can be executed
         only using api_key belonging to user with admin rights
         :param repoid: repository name or repository id
         :type repoid: str or int
         :param clone_uri: repository URI to pull from (optional)
         :type clone_uri: str
         OUTPUT::
           id : <id_given_in_input>
           result : {
             "msg": "Pulled from `<repository name>`"
             "repository": "<repository name>"
+          }
           error :  null
         ERROR OUTPUT::
           id : <id_given_in_input>
           result : null
           error :  {
             "Unable to pull changes from `<reponame>`"
+          }
         """
         repo = get_repo_or_error(repoid)
         try:
             ScmModel().pull_changes(repo.repo_name,
                                     request.authuser.username,
                                     request.ip_addr,
                                     clone_uri=clone_uri)
             return dict(
                 msg='Pulled from `%s`' % repo.repo_name,
                 repository=repo.repo_name
+            )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError(
                 'Unable to pull changes from `%s`' % repo.repo_name
+            )
     @HasPermissionAnyDecorator('hg.admin')
     def rescan_repos(self, remove_obsolete=False):
         """
         Triggers rescan repositories action. If remove_obsolete is set
         than also delete repos that are in database but not in the filesystem.
         aka "clean zombies". This command can be executed only using api_key
         belonging to user with admin rights.
         :param remove_obsolete: deletes repositories from
             database that are not found on the filesystem
         :type remove_obsolete: Optional(bool)
         OUTPUT::
           id : <id_given_in_input>
           result : {
             'added': [<added repository name>,...]
             'removed': [<removed repository name>,...]
+          }
           error :  null
         ERROR OUTPUT::
           id : <id_given_in_input>
           result : null
           error :  {
             'Error occurred during rescan repositories action'
+          }
         """
         try:
             rm_obsolete = remove_obsolete
             added, removed = repo2db_mapper(ScmModel().repo_scan(),
                                             remove_obsolete=rm_obsolete)
             return {'added': added, 'removed': removed}
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError(
                 'Error occurred during rescan repositories action'
+            )
     def invalidate_cache(self, repoid):
         """
         Invalidate cache for repository.
         This command can be executed only using api_key belonging to user with admin
         rights or regular user that have write or admin or write access to repository.
         :param repoid: repository name or repository id
         :type repoid: str or int
         OUTPUT::
           id : <id_given_in_input>
           result : {
             'msg': Cache for repository `<repository name>` was invalidated,
             'repository': <repository name>
+          }
           error :  null
         ERROR OUTPUT::
           id : <id_given_in_input>
           result : null
           error :  {
             'Error occurred during cache invalidation action'
+          }
         """
         repo = get_repo_or_error(repoid)
         if not HasPermissionAny('hg.admin')():
             if not HasRepoPermissionLevel('write')(repo.repo_name):
                 raise JSONRPCError('repository `%s` does not exist' % (repoid,))
         try:
             ScmModel().mark_for_invalidation(repo.repo_name)
             return dict(
                 msg='Cache for repository `%s` was invalidated' % (repoid,),
                 repository=repo.repo_name
+            )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError(
                 'Error occurred during cache invalidation action'
+            )
     @HasPermissionAnyDecorator('hg.admin')
     def get_ip(self, userid=None):
         """
         Shows IP address as seen from Kallithea server, together with all
         defined IP addresses for given user. If userid is not passed data is
         returned for user who's calling this function.
         This command can be executed only using api_key belonging to user with
         admin rights.
         :param userid: username to show ips for
         :type userid: Optional(str or int)
         OUTPUT::
             id : <id_given_in_input>
             result : {
                          "server_ip_addr": "<ip_from_clien>",
                          "user_ips": [
+                                        {
                                            "ip_addr": "<ip_with_mask>",
                                            "ip_range": ["<start_ip>", "<end_ip>"],
                                         },
                                         ...
+                                     ]
+            }
         """
         if userid is None:
             userid = request.authuser.user_id
         user = get_user_or_error(userid)
         ips = db.UserIpMap.query().filter(db.UserIpMap.user == user).all()
         return dict(
             server_ip_addr=request.ip_addr,
             user_ips=ips
+        )
     # alias for old
     show_ip = get_ip
     @HasPermissionAnyDecorator('hg.admin')
     def get_server_info(self):
         """
         return server info, including Kallithea version and installed packages
         OUTPUT::
           id : <id_given_in_input>
           result : {
             'modules': [<module name>,...]
             'py_version': <python version>,
             'platform': <platform type>,
             'kallithea_version': <kallithea version>
+          }
           error :  null
         """
         return db.Setting.get_server_info()
     def get_user(self, userid=None):
         """
         Gets a user by username or user_id, Returns empty result if user is
         not found. If userid param is skipped it is set to id of user who is
         calling this method. This command can be executed only using api_key
         belonging to user with admin rights, or regular users that cannot
         specify different userid than theirs
         :param userid: user to get data for
         :type userid: Optional(str or int)
         OUTPUT::
             id : <id_given_in_input>
             result: None if user does not exist or
+                    {
                         "user_id" :     "<user_id>",
                         "api_key" :     "<api_key>",
                         "api_keys":     "[<list of all API keys including additional ones>]"
                         "username" :    "<username>",
                         "firstname":    "<firstname>",
                         "lastname" :    "<lastname>",
                         "email" :       "<email>",
                         "emails":       "[<list of all emails including additional ones>]",
                         "ip_addresses": "[<ip_address_for_user>,...]",
                         "active" :      "<bool: user active>",
                         "admin" :       "<bool: user is admin>",
                         "extern_name" : "<extern_name>",
                         "extern_type" : "<extern type>
                         "last_login":   "<last_login>",
                         "permissions": {
                             "global": ["hg.create.repository",
                                        "repository.read",
                                        "hg.register.manual_activate"],
                             "repositories": {"repo1": "repository.none"},
                             "repositories_groups": {"Group1": "group.read"}
                          },
+                    }
             error:  null
         """
         if not HasPermissionAny('hg.admin')():
             # make sure normal user does not pass someone else userid,
             # he is not allowed to do that
             if userid is not None and userid != request.authuser.user_id:
                 raise JSONRPCError(
                     'userid is not the same as your user'
+                )
         if userid is None:
             userid = request.authuser.user_id
         user = get_user_or_error(userid)
         data = user.get_api_data()
         data['permissions'] = AuthUser(user_id=user.user_id).permissions
         return data
     @HasPermissionAnyDecorator('hg.admin')
     def get_users(self):
         """
         Lists all existing users. This command can be executed only using api_key
         belonging to user with admin rights.
         OUTPUT::
             id : <id_given_in_input>
             result: [<user_object>, ...]
             error:  null
         """
         return [
             user.get_api_data()
             for user in db.User.query()
                 .order_by(db.User.username)
                 .filter_by(is_default_user=False)
+        ]
     @HasPermissionAnyDecorator('hg.admin')
     def create_user(self, username, email, password='',
                     firstname='', lastname='',
                     active=True, admin=False,
                     extern_type=db.User.DEFAULT_AUTH_TYPE,
                     extern_name=''):
         """
         Creates new user. Returns new user object. This command can
         be executed only using api_key belonging to user with admin rights.
         :param username: new username
         :type username: str or int
         :param email: email
         :type email: str
         :param password: password
         :type password: Optional(str)
         :param firstname: firstname
         :type firstname: Optional(str)
         :param lastname: lastname
         :type lastname: Optional(str)
         :param active: active
         :type active: Optional(bool)
         :param admin: admin
         :type admin: Optional(bool)
         :param extern_name: name of extern
         :type extern_name: Optional(str)
         :param extern_type: extern_type
         :type extern_type: Optional(str)
         OUTPUT::
             id : <id_given_in_input>
             result: {
                       "msg" : "created new user `<username>`",
                       "user": <user_obj>
+                    }
             error:  null
         ERROR OUTPUT::
           id : <id_given_in_input>
           result : null
           error :  {
             "user `<username>` already exist"
             or
             "email `<email>` already exist"
             or
             "failed to create user `<username>`"
+          }
         """
         if db.User.get_by_username(username):
             raise JSONRPCError("user `%s` already exist" % (username,))
         if db.User.get_by_email(email):
             raise JSONRPCError("email `%s` already exist" % (email,))
         try:
             user = UserModel().create_or_update(
                 username=username,
                 password=password,
                 email=email,
                 firstname=firstname,
                 lastname=lastname,
                 active=active,
                 admin=admin,
                 extern_type=extern_type,
                 extern_name=extern_name
+            )
             meta.Session().commit()
             return dict(
                 msg='created new user `%s`' % username,
                 user=user.get_api_data()
+            )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError('failed to create user `%s`' % (username,))
     @HasPermissionAnyDecorator('hg.admin')
     def update_user(self, userid, username=None,
                     email=None, password=None,
                     firstname=None, lastname=None,
                     active=None, admin=None,
                     extern_type=None, extern_name=None):
         """
         updates given user if such user exists. This command can
         be executed only using api_key belonging to user with admin rights.
         :param userid: userid to update
         :type userid: str or int
         :param username: new username
         :type username: str or int
         :param email: email
         :type email: str
         :param password: password
         :type password: Optional(str)
         :param firstname: firstname
         :type firstname: Optional(str)
         :param lastname: lastname
         :type lastname: Optional(str)
         :param active: active
         :type active: Optional(bool)
         :param admin: admin
         :type admin: Optional(bool)
         :param extern_name:
         :type extern_name: Optional(str)
         :param extern_type:
         :type extern_type: Optional(str)
         OUTPUT::
             id : <id_given_in_input>
             result: {
                       "msg" : "updated user ID:<userid> <username>",
                       "user": <user_object>,
+                    }
             error:  null
         ERROR OUTPUT::
           id : <id_given_in_input>
           result : null
           error :  {
             "failed to update user `<username>`"
+          }
         """
         user = get_user_or_error(userid)
         # only non optional arguments will be stored in updates
         updates = {}
         try:
             store_update(updates, username, 'username')
             store_update(updates, password, 'password')
             store_update(updates, email, 'email')
             store_update(updates, firstname, 'name')
             store_update(updates, lastname, 'lastname')
             store_update(updates, active, 'active')
             store_update(updates, admin, 'admin')
             store_update(updates, extern_name, 'extern_name')
             store_update(updates, extern_type, 'extern_type')
             user = UserModel().update_user(user, **updates)
             meta.Session().commit()
             return dict(
                 msg='updated user ID:%s %s' % (user.user_id, user.username),
                 user=user.get_api_data()
+            )
         except DefaultUserException:
             log.error(traceback.format_exc())
             raise JSONRPCError('editing default user is forbidden')
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError('failed to update user `%s`' % (userid,))
     @HasPermissionAnyDecorator('hg.admin')
     def delete_user(self, userid):
         """
         deletes given user if such user exists. This command can
         be executed only using api_key belonging to user with admin rights.
         :param userid: user to delete
         :type userid: str or int
         OUTPUT::
             id : <id_given_in_input>
             result: {
                       "msg" : "deleted user ID:<userid> <username>",
                       "user": null
+                    }
             error:  null
         ERROR OUTPUT::
           id : <id_given_in_input>
           result : null
           error :  {
             "failed to delete user ID:<userid> <username>"
+          }
         """
         user = get_user_or_error(userid)
         try:
             UserModel().delete(userid)
             meta.Session().commit()
             return dict(
                 msg='deleted user ID:%s %s' % (user.user_id, user.username),
                 user=None
+            )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError('failed to delete user ID:%s %s'
                                % (user.user_id, user.username))
     # permission check inside
     def get_user_group(self, usergroupid):
         """
         Gets an existing user group. This command can be executed only using api_key
         belonging to user with admin rights or user who has at least
         read access to user group.
         :param usergroupid: id of user_group to edit
         :type usergroupid: str or int
         OUTPUT::
             id : <id_given_in_input>
             result : None if group not exist
+                     {
                        "users_group_id" : "<id>",
                        "group_name" :     "<groupname>",
                        "active":          "<bool>",
                        "members" :  [<user_obj>,...]
+                     }
             error : null
         """
         user_group = get_user_group_or_error(usergroupid)
         if not HasPermissionAny('hg.admin')():
             if not HasUserGroupPermissionLevel('read')(user_group.users_group_name):
                 raise JSONRPCError('user group `%s` does not exist' % (usergroupid,))
         data = user_group.get_api_data()
         return data
     # permission check inside
     def get_user_groups(self):
         """
         Lists all existing user groups. This command can be executed only using
         api_key belonging to user with admin rights or user who has at least
         read access to user group.
         OUTPUT::
             id : <id_given_in_input>
             result : [<user_group_obj>,...]
             error : null
         """
         return [
             user_group.get_api_data()
             for user_group in UserGroupList(db.UserGroup.query().all(), perm_level='read')
+        ]
     @HasPermissionAnyDecorator('hg.admin', 'hg.usergroup.create.true')
     def create_user_group(self, group_name, description='',
                           owner=None, active=True):
         """
         Creates new user group. This command can be executed only using api_key
         belonging to user with admin rights or an user who has create user group
         permission
         :param group_name: name of new user group
         :type group_name: str
         :param description: group description
         :type description: str
         :param owner: owner of group. If not passed apiuser is the owner
         :type owner: Optional(str or int)
         :param active: group is active
         :type active: Optional(bool)
         OUTPUT::
             id : <id_given_in_input>
             result: {
                       "msg": "created new user group `<groupname>`",
                       "user_group": <user_group_object>
+                    }
             error:  null
         ERROR OUTPUT::
           id : <id_given_in_input>
           result : null
           error :  {
             "user group `<group name>` already exist"
             or
             "failed to create group `<group name>`"
+          }
         """
         if UserGroupModel().get_by_name(group_name):
             raise JSONRPCError("user group `%s` already exist" % (group_name,))
         try:
             if owner is None:
                 owner = request.authuser.user_id
             owner = get_user_or_error(owner)
             ug = UserGroupModel().create(name=group_name, description=description,
                                          owner=owner, active=active)
             meta.Session().commit()
             return dict(
                 msg='created new user group `%s`' % group_name,
                 user_group=ug.get_api_data()
+            )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError('failed to create group `%s`' % (group_name,))
     # permission check inside
     def update_user_group(self, usergroupid, group_name=None,
                           description=None, owner=None,
                           active=None):
         """
         Updates given usergroup.  This command can be executed only using api_key
         belonging to user with admin rights or an admin of given user group
         :param usergroupid: id of user group to update
         :type usergroupid: str or int
         :param group_name: name of new user group
         :type group_name: str
         :param description: group description
         :type description: str
         :param owner: owner of group.
         :type owner: Optional(str or int)
         :param active: group is active
         :type active: Optional(bool)
         OUTPUT::
           id : <id_given_in_input>
           result : {
             "msg": 'updated user group ID:<user group id> <user group name>',
             "user_group": <user_group_object>
+          }
           error :  null
         ERROR OUTPUT::
           id : <id_given_in_input>
           result : null
           error :  {
             "failed to update user group `<user group name>`"
+          }
         """
         user_group = get_user_group_or_error(usergroupid)
         if not HasPermissionAny('hg.admin')():
             if not HasUserGroupPermissionLevel('admin')(user_group.users_group_name):
                 raise JSONRPCError('user group `%s` does not exist' % (usergroupid,))
         if owner is not None:
             owner = get_user_or_error(owner)
         updates = {}
         store_update(updates, group_name, 'users_group_name')
         store_update(updates, description, 'user_group_description')
         store_update(updates, owner, 'owner')
         store_update(updates, active, 'users_group_active')
         try:
             UserGroupModel().update(user_group, updates)
             meta.Session().commit()
             return dict(
                 msg='updated user group ID:%s %s' % (user_group.users_group_id,
                                                      user_group.users_group_name),
                 user_group=user_group.get_api_data()
+            )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError('failed to update user group `%s`' % (usergroupid,))
     # permission check inside
     def delete_user_group(self, usergroupid):
         """
         Delete given user group by user group id or name.
         This command can be executed only using api_key
         belonging to user with admin rights or an admin of given user group
         :param usergroupid:
         :type usergroupid: int
         OUTPUT::
           id : <id_given_in_input>
           result : {
             "msg": "deleted user group ID:<user_group_id> <user_group_name>"
+          }
           error :  null
         ERROR OUTPUT::
           id : <id_given_in_input>
           result : null
           error :  {
             "failed to delete user group ID:<user_group_id> <user_group_name>"
             or
             "RepoGroup assigned to <repo_groups_list>"
+          }
         """
         user_group = get_user_group_or_error(usergroupid)
         if not HasPermissionAny('hg.admin')():
             if not HasUserGroupPermissionLevel('admin')(user_group.users_group_name):
                 raise JSONRPCError('user group `%s` does not exist' % (usergroupid,))
         try:
             UserGroupModel().delete(user_group)
             meta.Session().commit()
             return dict(
                 msg='deleted user group ID:%s %s' %
                     (user_group.users_group_id, user_group.users_group_name),
                 user_group=None
+            )
         except UserGroupsAssignedException as e:
             log.error(traceback.format_exc())
             raise JSONRPCError(str(e))
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError('failed to delete user group ID:%s %s' %
                                (user_group.users_group_id,
                                 user_group.users_group_name)
+                               )
     # permission check inside
     def add_user_to_user_group(self, usergroupid, userid):
         """
         Adds a user to a user group. If user exists in that group success will be
         `false`. This command can be executed only using api_key
         belonging to user with admin rights  or an admin of given user group
         :param usergroupid:
         :type usergroupid: int
         :param userid:
         :type userid: int
         OUTPUT::
           id : <id_given_in_input>
           result : {
               "success": True|False # depends on if member is in group
               "msg": "added member `<username>` to user group `<groupname>` |
                       User is already in that group"
+          }
           error :  null
         ERROR OUTPUT::
           id : <id_given_in_input>
           result : null
           error :  {
             "failed to add member to user group `<user_group_name>`"
+          }
         """
         user = get_user_or_error(userid)
         user_group = get_user_group_or_error(usergroupid)
         if not HasPermissionAny('hg.admin')():
             if not HasUserGroupPermissionLevel('admin')(user_group.users_group_name):
                 raise JSONRPCError('user group `%s` does not exist' % (usergroupid,))
         try:
             ugm = UserGroupModel().add_user_to_group(user_group, user)
             success = True if ugm is not True else False
             msg = 'added member `%s` to user group `%s`' % (
                 user.username, user_group.users_group_name
+            )
             msg = msg if success else 'User is already in that group'
             meta.Session().commit()
             return dict(
                 success=success,
                 msg=msg
+            )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError(
                 'failed to add member to user group `%s`' % (
                     user_group.users_group_name,
+                )
+            )
     # permission check inside
     def remove_user_from_user_group(self, usergroupid, userid):
         """
         Removes a user from a user group. If user is not in given group success will
         be `false`. This command can be executed only
         using api_key belonging to user with admin rights or an admin of given user group
         :param usergroupid:
         :param userid:
         OUTPUT::
             id : <id_given_in_input>
             result: {
                       "success":  True|False,  # depends on if member is in group
                       "msg": "removed member <username> from user group <groupname> |
                               User wasn't in group"
+                    }
             error:  null
         """
         user = get_user_or_error(userid)
         user_group = get_user_group_or_error(usergroupid)
         if not HasPermissionAny('hg.admin')():
             if not HasUserGroupPermissionLevel('admin')(user_group.users_group_name):
                 raise JSONRPCError('user group `%s` does not exist' % (usergroupid,))
         try:
             success = UserGroupModel().remove_user_from_group(user_group, user)
             msg = 'removed member `%s` from user group `%s`' % (
                 user.username, user_group.users_group_name
+            )
             msg = msg if success else "User wasn't in group"
             meta.Session().commit()
             return dict(success=success, msg=msg)
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError(
                 'failed to remove member from user group `%s`' % (
                     user_group.users_group_name,
+                )
+            )
     # permission check inside
     def get_repo(self, repoid,
                  with_revision_names=False,
                  with_pullrequests=False):
         """
         Gets an existing repository by it's name or repository_id. Members will return
         either users_group or user associated to that repository. This command can be
         executed only using api_key belonging to user with admin
         rights or regular user that have at least read access to repository.
         :param repoid: repository name or repository id
         :type repoid: str or int
         OUTPUT::
           id : <id_given_in_input>
           result : {
+            {
                 "repo_id" :          "<repo_id>",
                 "repo_name" :        "<reponame>"
                 "repo_type" :        "<repo_type>",
                 "clone_uri" :        "<clone_uri>",
                 "enable_downloads":  "<bool>",
                 "enable_statistics": "<bool>",
                 "private":           "<bool>",
                 "created_on" :       "<date_time_created>",
                 "description" :      "<description>",
                 "landing_rev":       "<landing_rev>",
                 "last_changeset":    {
                                        "author":   "<full_author>",
                                        "date":     "<date_time_of_commit>",
                                        "message":  "<commit_message>",
                                        "raw_id":   "<raw_id>",
                                        "revision": "<numeric_revision>",
                                        "short_id": "<short_id>"
+                                     }
                 "owner":             "<repo_owner>",
                 "fork_of":           "<name_of_fork_parent>",
                 "members" :     [
+                                  {
                                     "name":     "<username>",
                                     "type" :    "user",
                                     "permission" : "repository.(read|write|admin)"
                                   },
                                   …
+                                  {
                                     "name":     "<usergroup name>",
                                     "type" :    "user_group",
                                     "permission" : "usergroup.(read|write|admin)"
                                   },
                                   …
+                                ]
                  "followers":   [<user_obj>, ...],
                  <if with_revision_names == True>
                  "tags": {
                             "<tagname>": "<raw_id>",
                             ...
                          },
                  "branches": {
                             "<branchname>": "<raw_id>",
                             ...
                          },
                  "bookmarks": {
                             "<bookmarkname>": "<raw_id>",
                             ...
                          },
+            }
+          }
           error :  null
         """
         repo = get_repo_or_error(repoid)
         if not HasPermissionAny('hg.admin')():
             if not HasRepoPermissionLevel('read')(repo.repo_name):
                 raise JSONRPCError('repository `%s` does not exist' % (repoid,))
         members = []
         for user in repo.repo_to_perm:
             perm = user.permission.permission_name
             user = user.user
             user_data = {
                 'name': user.username,
                 'type': "user",
                 'permission': perm
+            }
             members.append(user_data)
         for user_group in repo.users_group_to_perm:
             perm = user_group.permission.permission_name
             user_group = user_group.users_group
             user_group_data = {
                 'name': user_group.users_group_name,
                 'type': "user_group",
                 'permission': perm
+            }
             members.append(user_group_data)
         followers = [
             uf.user.get_api_data()
             for uf in repo.followers
+        ]
         data = repo.get_api_data(with_revision_names=with_revision_names,
                                  with_pullrequests=with_pullrequests)
         data['members'] = members
         data['followers'] = followers
         return data
     # permission check inside
     def get_repos(self):
         """
         Lists all existing repositories. This command can be executed only using
         api_key belonging to user with admin rights or regular user that have
         admin, write or read access to repository.
         OUTPUT::
             id : <id_given_in_input>
             result: [
+                      {
                         "repo_id" :          "<repo_id>",
                         "repo_name" :        "<reponame>"
                         "repo_type" :        "<repo_type>",
                         "clone_uri" :        "<clone_uri>",
                         "private": :         "<bool>",
                         "created_on" :       "<datetimecreated>",
                         "description" :      "<description>",
                         "landing_rev":       "<landing_rev>",
                         "owner":             "<repo_owner>",
                         "fork_of":           "<name_of_fork_parent>",
                         "enable_downloads":  "<bool>",
                         "enable_statistics": "<bool>",
                       },
                       …
+                    ]
             error:  null
         """
         if not HasPermissionAny('hg.admin')():
             repos = request.authuser.get_all_user_repos()
         else:
             repos = db.Repository.query()
         return [
             repo.get_api_data()
             for repo in repos
+        ]
     # permission check inside
     def get_repo_nodes(self, repoid, revision, root_path,
                        ret_type='all'):
         """
         returns a list of nodes and it's children in a flat list for a given path
         at given revision. It's possible to specify ret_type to show only `files` or
         `dirs`.  This command can be executed only using api_key belonging to
         user with admin rights or regular user that have at least read access to repository.
         :param repoid: repository name or repository id
         :type repoid: str or int
         :param revision: revision for which listing should be done
         :type revision: str
         :param root_path: path from which start displaying
         :type root_path: str
         :param ret_type: return type 'all|files|dirs' nodes
         :type ret_type: Optional(str)
         OUTPUT::
             id : <id_given_in_input>
             result: [
+                      {
                         "name" :        "<name>"
                         "type" :        "<type>",
                       },
                       …
+                    ]
             error:  null
         """
         repo = get_repo_or_error(repoid)
         if not HasPermissionAny('hg.admin')():
             if not HasRepoPermissionLevel('read')(repo.repo_name):
                 raise JSONRPCError('repository `%s` does not exist' % (repoid,))
         _map = {}
         try:
             _d, _f = ScmModel().get_nodes(repo, revision, root_path,
                                           flat=False)
             _map = {
                 'all': _d + _f,
                 'files': _f,
                 'dirs': _d,
+            }
             return _map[ret_type]
         except KeyError:
             raise JSONRPCError('ret_type must be one of %s'
                                % (','.join(sorted(_map))))
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError(
                 'failed to get repo: `%s` nodes' % repo.repo_name
+            )
     @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')
     def create_repo(self, repo_name, owner=None,
                     repo_type=None, description='',
                     private=False, clone_uri=None,
                     landing_rev='rev:tip',
                     enable_statistics=None,
                     enable_downloads=None,
                     copy_permissions=False):
         """
         Creates a repository. The repository name contains the full path, but the
         parent repository group must exist. For example "foo/bar/baz" require the groups
         "foo" and "bar" (with "foo" as parent), and create "baz" repository with
         "bar" as group. This command can be executed only using api_key
         belonging to user with admin rights or regular user that have create
         repository permission. Regular users cannot specify owner parameter
         :param repo_name: repository name
         :type repo_name: str
         :param owner: user_id or username
         :type owner: Optional(str)
         :param repo_type: 'hg' or 'git'
         :type repo_type: Optional(str)
         :param description: repository description
         :type description: Optional(str)
         :param private:
         :type private: bool
         :param clone_uri:
         :type clone_uri: str
         :param landing_rev: <rev_type>:<rev>
         :type landing_rev: str
         :param enable_downloads:
         :type enable_downloads: bool
         :param enable_statistics:
         :type enable_statistics: bool
         :param copy_permissions: Copy permission from group that repository is
             being created.
         :type copy_permissions: bool
         OUTPUT::
             id : <id_given_in_input>
             result: {
                       "msg": "Created new repository `<reponame>`",
                       "success": true,
                       "task": "<celery task id or None if done sync>"
+                    }
             error:  null
         ERROR OUTPUT::
           id : <id_given_in_input>
           result : null
           error :  {
              'failed to create repository `<repo_name>`
+          }
         """
         if not HasPermissionAny('hg.admin')():
             if owner is not None:
                 # forbid setting owner for non-admins
                 raise JSONRPCError(
                     'Only Kallithea admin can specify `owner` param'
+                )
         if owner is None:
             owner = request.authuser.user_id
         owner = get_user_or_error(owner)
         if RepoModel().get_by_repo_name(repo_name):
             raise JSONRPCError("repo `%s` already exist" % repo_name)
         defs = db.Setting.get_default_repo_settings(strip_prefix=True)
         if private is None:
             private = defs.get('repo_private') or False
         if repo_type is None:
             repo_type = defs.get('repo_type')
         if enable_statistics is None:
             enable_statistics = defs.get('repo_enable_statistics')
         if enable_downloads is None:
             enable_downloads = defs.get('repo_enable_downloads')
         try:
             repo_name_parts = repo_name.split('/')
             repo_group = None
             if len(repo_name_parts) > 1:
                 group_name = '/'.join(repo_name_parts[:-1])
                 repo_group = db.RepoGroup.get_by_group_name(group_name)
                 if repo_group is None:
                     raise JSONRPCError("repo group `%s` not found" % group_name)
             data = dict(
                 repo_name=repo_name_parts[-1],
                 repo_name_full=repo_name,
                 repo_type=repo_type,
                 repo_description=description,
                 owner=owner,
                 repo_private=private,
                 clone_uri=clone_uri,
                 repo_group=repo_group,
                 repo_landing_rev=landing_rev,
                 enable_statistics=enable_statistics,
                 enable_downloads=enable_downloads,
                 repo_copy_permissions=copy_permissions,
+            )
             task = RepoModel().create(form_data=data, cur_user=owner)
+            task = RepoModel().create(form_data=data, cur_user=owner.username)
             task_id = task.task_id
             # no commit, it's done in RepoModel, or async via celery
             return dict(
                 msg="Created new repository `%s`" % (repo_name,),
                 success=True,  # cannot return the repo data here since fork
                                # can be done async
                 task=task_id
+            )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError(
                 'failed to create repository `%s`' % (repo_name,))
     # permission check inside
     def update_repo(self, repoid, name=None,
                     owner=None,
                     group=None,
                     description=None, private=None,
                     clone_uri=None, landing_rev=None,
                     enable_statistics=None,
                     enable_downloads=None):
         """
         Updates repo
         :param repoid: repository name or repository id
         :type repoid: str or int
         :param name:
         :param owner:
         :param group:
         :param description:
         :param private:
         :param clone_uri:
         :param landing_rev:
         :param enable_statistics:
         :param enable_downloads:
         """
         repo = get_repo_or_error(repoid)
         if not HasPermissionAny('hg.admin')():
             if not HasRepoPermissionLevel('admin')(repo.repo_name):
                 raise JSONRPCError('repository `%s` does not exist' % (repoid,))
             if (name != repo.repo_name and
                 not HasPermissionAny('hg.create.repository')()
             ):
                 raise JSONRPCError('no permission to create (or move) repositories')
             if owner is not None:
                 # forbid setting owner for non-admins
                 raise JSONRPCError(
                     'Only Kallithea admin can specify `owner` param'
+                )
         updates = {}
         repo_group = group
         if repo_group is not None:
             repo_group = get_repo_group_or_error(repo_group)
             repo_group = repo_group.group_id
         try:
             store_update(updates, name, 'repo_name')
             store_update(updates, repo_group, 'repo_group')
             store_update(updates, owner, 'owner')
             store_update(updates, description, 'repo_description')
             store_update(updates, private, 'repo_private')
             store_update(updates, clone_uri, 'clone_uri')
             store_update(updates, landing_rev, 'repo_landing_rev')
             store_update(updates, enable_statistics, 'repo_enable_statistics')
             store_update(updates, enable_downloads, 'repo_enable_downloads')
             RepoModel().update(repo, **updates)
             meta.Session().commit()
             return dict(
                 msg='updated repo ID:%s %s' % (repo.repo_id, repo.repo_name),
                 repository=repo.get_api_data()
+            )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError('failed to update repo `%s`' % repoid)
     @HasPermissionAnyDecorator('hg.admin', 'hg.fork.repository')
     def fork_repo(self, repoid, fork_name,
                   owner=None,
                   description='', copy_permissions=False,
                   private=False, landing_rev='rev:tip'):
         """
         Creates a fork of given repo. In case of using celery this will
         immediately return success message, while fork is going to be created
         asynchronous. This command can be executed only using api_key belonging to
         user with admin rights or regular user that have fork permission, and at least
         read access to forking repository. Regular users cannot specify owner parameter.
         :param repoid: repository name or repository id
         :type repoid: str or int
         :param fork_name:
         :param owner:
         :param description:
         :param copy_permissions:
         :param private:
         :param landing_rev:
         INPUT::
             id : <id_for_response>
             api_key : "<api_key>"
             args:     {
                         "repoid" :          "<reponame or repo_id>",
                         "fork_name":        "<forkname>",
                         "owner":            "<username or user_id = Optional(=apiuser)>",
                         "description":      "<description>",
                         "copy_permissions": "<bool>",
                         "private":          "<bool>",
                         "landing_rev":      "<landing_rev>"
+                      }
         OUTPUT::
             id : <id_given_in_input>
             result: {
                       "msg": "Created fork of `<reponame>` as `<forkname>`",
                       "success": true,
                       "task": "<celery task id or None if done sync>"
+                    }
             error:  null
         """
         repo = get_repo_or_error(repoid)
         repo_name = repo.repo_name
         _repo = RepoModel().get_by_repo_name(fork_name)
         if _repo:
             type_ = 'fork' if _repo.fork else 'repo'
             raise JSONRPCError("%s `%s` already exist" % (type_, fork_name))
         if HasPermissionAny('hg.admin')():
             pass
         elif HasRepoPermissionLevel('read')(repo.repo_name):
             if owner is not None:
                 # forbid setting owner for non-admins
                 raise JSONRPCError(
                     'Only Kallithea admin can specify `owner` param'
+                )
             if not HasPermissionAny('hg.create.repository')():
                 raise JSONRPCError('no permission to create repositories')
         else:
             raise JSONRPCError('repository `%s` does not exist' % (repoid,))
         if owner is None:
             owner = request.authuser.user_id
         owner = get_user_or_error(owner)
         try:
             fork_name_parts = fork_name.split('/')
             repo_group = None
             if len(fork_name_parts) > 1:
                 group_name = '/'.join(fork_name_parts[:-1])
                 repo_group = db.RepoGroup.get_by_group_name(group_name)
                 if repo_group is None:
                     raise JSONRPCError("repo group `%s` not found" % group_name)
             form_data = dict(
                 repo_name=fork_name_parts[-1],
                 repo_name_full=fork_name,
                 repo_group=repo_group,
                 repo_type=repo.repo_type,
                 description=description,
                 private=private,
                 copy_permissions=copy_permissions,
                 landing_rev=landing_rev,
                 update_after_clone=False,
                 fork_parent_id=repo.repo_id,
+            )
             task = RepoModel().create_fork(form_data, cur_user=owner)
+            task = RepoModel().create_fork(form_data, cur_user=owner.username)
             # no commit, it's done in RepoModel, or async via celery
             task_id = task.task_id
             return dict(
                 msg='Created fork of `%s` as `%s`' % (repo.repo_name,
                                                       fork_name),
                 success=True,  # cannot return the repo data here since fork
                                # can be done async
                 task=task_id
+            )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError(
                 'failed to fork repository `%s` as `%s`' % (repo_name,
                                                             fork_name)
+            )
     # permission check inside
     def delete_repo(self, repoid, forks=''):
         """
         Deletes a repository. This command can be executed only using api_key belonging
         to user with admin rights or regular user that have admin access to repository.
         When `forks` param is set it's possible to detach or delete forks of deleting
         repository
         :param repoid: repository name or repository id
         :type repoid: str or int
         :param forks: `detach` or `delete`, what do do with attached forks for repo
         :type forks: Optional(str)
         OUTPUT::
             id : <id_given_in_input>
             result: {
                       "msg": "Deleted repository `<reponame>`",
                       "success": true
+                    }
             error:  null
         """
         repo = get_repo_or_error(repoid)
         if not HasPermissionAny('hg.admin')():
             if not HasRepoPermissionLevel('admin')(repo.repo_name):
                 raise JSONRPCError('repository `%s` does not exist' % (repoid,))
         try:
             handle_forks = forks
             _forks_msg = ''
             _forks = [f for f in repo.forks]
             if handle_forks == 'detach':
                 _forks_msg = ' ' + 'Detached %s forks' % len(_forks)
             elif handle_forks == 'delete':
                 _forks_msg = ' ' + 'Deleted %s forks' % len(_forks)
             elif _forks:
                 raise JSONRPCError(
                     'Cannot delete `%s` it still contains attached forks' %
                     (repo.repo_name,)
+                )
             RepoModel().delete(repo, forks=forks)
             meta.Session().commit()
             return dict(
                 msg='Deleted repository `%s`%s' % (repo.repo_name, _forks_msg),
                 success=True
+            )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError(
                 'failed to delete repository `%s`' % (repo.repo_name,)
+            )
     @HasPermissionAnyDecorator('hg.admin')
     def grant_user_permission(self, repoid, userid, perm):
         """
         Grant permission for user on given repository, or update existing one
         if found. This command can be executed only using api_key belonging to user
         with admin rights.
         :param repoid: repository name or repository id
         :type repoid: str or int
         :param userid:
         :param perm: (repository.(none|read|write|admin))
         :type perm: str
         OUTPUT::
             id : <id_given_in_input>
             result: {
                       "msg" : "Granted perm: `<perm>` for user: `<username>` in repo: `<reponame>`",
                       "success": true
+                    }
             error:  null
         """
         repo = get_repo_or_error(repoid)
         user = get_user_or_error(userid)
         perm = get_perm_or_error(perm)
         try:
             RepoModel().grant_user_permission(repo=repo, user=user, perm=perm)
             meta.Session().commit()
             return dict(
                 msg='Granted perm: `%s` for user: `%s` in repo: `%s`' % (
                     perm.permission_name, user.username, repo.repo_name
                 ),
                 success=True
+            )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError(
                 'failed to edit permission for user: `%s` in repo: `%s`' % (
                     userid, repoid
+                )
+            )
     @HasPermissionAnyDecorator('hg.admin')
     def revoke_user_permission(self, repoid, userid):
         """
         Revoke permission for user on given repository. This command can be executed
         only using api_key belonging to user with admin rights.
         :param repoid: repository name or repository id
         :type repoid: str or int
         :param userid:
         OUTPUT::
             id : <id_given_in_input>
             result: {
                       "msg" : "Revoked perm for user: `<username>` in repo: `<reponame>`",
                       "success": true
+                    }
             error:  null
         """
         repo = get_repo_or_error(repoid)
         user = get_user_or_error(userid)
         try:
             RepoModel().revoke_user_permission(repo=repo, user=user)
             meta.Session().commit()
             return dict(
                 msg='Revoked perm for user: `%s` in repo: `%s`' % (
                     user.username, repo.repo_name
                 ),
                 success=True
+            )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError(
                 'failed to edit permission for user: `%s` in repo: `%s`' % (
                     userid, repoid
+                )
+            )
     # permission check inside
     def grant_user_group_permission(self, repoid, usergroupid, perm):
         """
         Grant permission for user group on given repository, or update
         existing one if found. This command can be executed only using
         api_key belonging to user with admin rights.
         :param repoid: repository name or repository id
         :type repoid: str or int
         :param usergroupid: id of usergroup
         :type usergroupid: str or int
         :param perm: (repository.(none|read|write|admin))
         :type perm: str
         OUTPUT::
           id : <id_given_in_input>
           result : {
             "msg" : "Granted perm: `<perm>` for group: `<usersgroupname>` in repo: `<reponame>`",
             "success": true
+          }
           error :  null
         ERROR OUTPUT::
           id : <id_given_in_input>
           result : null
           error :  {
             "failed to edit permission for user group: `<usergroup>` in repo `<repo>`'
+          }
         """
         repo = get_repo_or_error(repoid)
         perm = get_perm_or_error(perm)
         user_group = get_user_group_or_error(usergroupid)
         if not HasPermissionAny('hg.admin')():
             if not HasRepoPermissionLevel('admin')(repo.repo_name):
                 raise JSONRPCError('repository `%s` does not exist' % (repoid,))
             if not HasUserGroupPermissionLevel('read')(user_group.users_group_name):
                 raise JSONRPCError('user group `%s` does not exist' % (usergroupid,))
         try:
             RepoModel().grant_user_group_permission(
                 repo=repo, group_name=user_group, perm=perm)
             meta.Session().commit()
             return dict(
                 msg='Granted perm: `%s` for user group: `%s` in '
                     'repo: `%s`' % (
                         perm.permission_name, user_group.users_group_name,
                         repo.repo_name
                     ),
                 success=True
+            )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError(
                 'failed to edit permission for user group: `%s` in '
                 'repo: `%s`' % (
                     usergroupid, repo.repo_name
+                )
+            )
     # permission check inside
     def revoke_user_group_permission(self, repoid, usergroupid):
         """
         Revoke permission for user group on given repository. This command can be
         executed only using api_key belonging to user with admin rights.
         :param repoid: repository name or repository id
         :type repoid: str or int
         :param usergroupid:
         OUTPUT::
             id : <id_given_in_input>
             result: {
                       "msg" : "Revoked perm for group: `<usersgroupname>` in repo: `<reponame>`",
                       "success": true
+                    }
             error:  null
         """
         repo = get_repo_or_error(repoid)
         user_group = get_user_group_or_error(usergroupid)
         if not HasPermissionAny('hg.admin')():
             if not HasRepoPermissionLevel('admin')(repo.repo_name):
                 raise JSONRPCError('repository `%s` does not exist' % (repoid,))
             if not HasUserGroupPermissionLevel('read')(user_group.users_group_name):
                 raise JSONRPCError('user group `%s` does not exist' % (usergroupid,))
         try:
             RepoModel().revoke_user_group_permission(
                 repo=repo, group_name=user_group)
             meta.Session().commit()
             return dict(
                 msg='Revoked perm for user group: `%s` in repo: `%s`' % (
                     user_group.users_group_name, repo.repo_name
                 ),
                 success=True
+            )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError(
                 'failed to edit permission for user group: `%s` in '
                 'repo: `%s`' % (
                     user_group.users_group_name, repo.repo_name
+                )
+            )
     @HasPermissionAnyDecorator('hg.admin')
     def get_repo_group(self, repogroupid):
         """
         Returns given repo group together with permissions, and repositories
         inside the group
         :param repogroupid: id/name of repository group
         :type repogroupid: str or int
         """
         repo_group = get_repo_group_or_error(repogroupid)
         members = []
         for user in repo_group.repo_group_to_perm:
             perm = user.permission.permission_name
             user = user.user
             user_data = {
                 'name': user.username,
                 'type': "user",
                 'permission': perm
+            }
             members.append(user_data)
         for user_group in repo_group.users_group_to_perm:
             perm = user_group.permission.permission_name
             user_group = user_group.users_group
             user_group_data = {
                 'name': user_group.users_group_name,
                 'type': "user_group",
                 'permission': perm
+            }
             members.append(user_group_data)
         data = repo_group.get_api_data()
         data["members"] = members
         return data
     @HasPermissionAnyDecorator('hg.admin')
     def get_repo_groups(self):
         """
         Returns all repository groups
         """
         return [
             repo_group.get_api_data()
             for repo_group in db.RepoGroup.query()
+        ]
     @HasPermissionAnyDecorator('hg.admin')
     def create_repo_group(self, group_name, description='',
                           owner=None,
                           parent=None,
                           copy_permissions=False):
         """
         Creates a repository group. This command can be executed only using
         api_key belonging to user with admin rights.
         :param group_name:
         :type group_name:
         :param description:
         :type description:
         :param owner:
         :type owner:
         :param parent:
         :type parent:
         :param copy_permissions:
         :type copy_permissions:
         OUTPUT::
           id : <id_given_in_input>
           result : {
               "msg": "created new repo group `<repo_group_name>`"
               "repo_group": <repogroup_object>
+          }
           error :  null
         ERROR OUTPUT::
           id : <id_given_in_input>
           result : null
           error :  {
             failed to create repo group `<repogroupid>`
+          }
         """
         if db.RepoGroup.get_by_group_name(group_name):
             raise JSONRPCError("repo group `%s` already exist" % (group_name,))
         if owner is None:
             owner = request.authuser.user_id
         group_description = description
         parent_group = None
         if parent is not None:
             parent_group = get_repo_group_or_error(parent)
         try:
             repo_group = RepoGroupModel().create(
                 group_name=group_name,
                 group_description=group_description,
                 owner=owner,
                 parent=parent_group,
                 copy_permissions=copy_permissions
+            )
             meta.Session().commit()
             return dict(
                 msg='created new repo group `%s`' % group_name,
                 repo_group=repo_group.get_api_data()
+            )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError('failed to create repo group `%s`' % (group_name,))
     @HasPermissionAnyDecorator('hg.admin')
     def update_repo_group(self, repogroupid, group_name=None,
                           description=None,
                           owner=None,
                           parent=None):
         repo_group = get_repo_group_or_error(repogroupid)
         updates = {}
         try:
             store_update(updates, group_name, 'group_name')
             store_update(updates, description, 'group_description')
             store_update(updates, owner, 'owner')
             store_update(updates, parent, 'parent_group')
             repo_group = RepoGroupModel().update(repo_group, updates)
             meta.Session().commit()
             return dict(
                 msg='updated repository group ID:%s %s' % (repo_group.group_id,
                                                            repo_group.group_name),
                 repo_group=repo_group.get_api_data()
+            )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError('failed to update repository group `%s`'
                                % (repogroupid,))
     @HasPermissionAnyDecorator('hg.admin')
     def delete_repo_group(self, repogroupid):
         """
         :param repogroupid: name or id of repository group
         :type repogroupid: str or int
         OUTPUT::
           id : <id_given_in_input>
           result : {
             'msg': 'deleted repo group ID:<repogroupid> <repogroupname>
             'repo_group': null
+          }
           error :  null
         ERROR OUTPUT::
           id : <id_given_in_input>
           result : null
           error :  {
             "failed to delete repo group ID:<repogroupid> <repogroupname>"
+          }
         """
         repo_group = get_repo_group_or_error(repogroupid)
         try:
             RepoGroupModel().delete(repo_group)
             meta.Session().commit()
             return dict(
                 msg='deleted repo group ID:%s %s' %
                     (repo_group.group_id, repo_group.group_name),
                 repo_group=None
+            )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError('failed to delete repo group ID:%s %s' %
                                (repo_group.group_id, repo_group.group_name)
+                               )
     # permission check inside
     def grant_user_permission_to_repo_group(self, repogroupid, userid,
                                             perm, apply_to_children='none'):
         """
         Grant permission for user on given repository group, or update existing
         one if found. This command can be executed only using api_key belonging
         to user with admin rights, or user who has admin right to given repository
         group.
         :param repogroupid: name or id of repository group
         :type repogroupid: str or int
         :param userid:
         :param perm: (group.(none|read|write|admin))
         :type perm: str
         :param apply_to_children: 'none', 'repos', 'groups', 'all'
         :type apply_to_children: str
         OUTPUT::
             id : <id_given_in_input>
             result: {
                       "msg" : "Granted perm: `<perm>` (recursive:<apply_to_children>) for user: `<username>` in repo group: `<repo_group_name>`",
                       "success": true
+                    }
             error:  null
         ERROR OUTPUT::
           id : <id_given_in_input>
           result : null
           error :  {
             "failed to edit permission for user: `<userid>` in repo group: `<repo_group_name>`"
+          }
         """
         repo_group = get_repo_group_or_error(repogroupid)
         if not HasPermissionAny('hg.admin')():
             if not HasRepoGroupPermissionLevel('admin')(repo_group.group_name):
                 raise JSONRPCError('repository group `%s` does not exist' % (repogroupid,))
         user = get_user_or_error(userid)
         perm = get_perm_or_error(perm, prefix='group.')
         try:
             RepoGroupModel().add_permission(repo_group=repo_group,
                                             obj=user,
                                             obj_type="user",
                                             perm=perm,
                                             recursive=apply_to_children)
             meta.Session().commit()
             return dict(
                 msg='Granted perm: `%s` (recursive:%s) for user: `%s` in repo group: `%s`' % (
                     perm.permission_name, apply_to_children, user.username, repo_group.name
                 ),
                 success=True
+            )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError(
                 'failed to edit permission for user: `%s` in repo group: `%s`' % (
                     userid, repo_group.name))
     # permission check inside
     def revoke_user_permission_from_repo_group(self, repogroupid, userid,
                                                apply_to_children='none'):
         """
         Revoke permission for user on given repository group. This command can
         be executed only using api_key belonging to user with admin rights, or
         user who has admin right to given repository group.
         :param repogroupid: name or id of repository group
         :type repogroupid: str or int
         :param userid:
         :type userid:
         :param apply_to_children: 'none', 'repos', 'groups', 'all'
         :type apply_to_children: str
         OUTPUT::
             id : <id_given_in_input>
             result: {
                       "msg" : "Revoked perm (recursive:<apply_to_children>) for user: `<username>` in repo group: `<repo_group_name>`",
                       "success": true
+                    }
             error:  null
         ERROR OUTPUT::
           id : <id_given_in_input>
           result : null
           error :  {
             "failed to edit permission for user: `<userid>` in repo group: `<repo_group_name>`"
+          }
         """
         repo_group = get_repo_group_or_error(repogroupid)
         if not HasPermissionAny('hg.admin')():
             if not HasRepoGroupPermissionLevel('admin')(repo_group.group_name):
                 raise JSONRPCError('repository group `%s` does not exist' % (repogroupid,))
         user = get_user_or_error(userid)
         try:
             RepoGroupModel().delete_permission(repo_group=repo_group,
                                                obj=user,
                                                obj_type="user",
                                                recursive=apply_to_children)
             meta.Session().commit()
             return dict(
                 msg='Revoked perm (recursive:%s) for user: `%s` in repo group: `%s`' % (
                     apply_to_children, user.username, repo_group.name
                 ),
                 success=True
+            )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError(
                 'failed to edit permission for user: `%s` in repo group: `%s`' % (
                     userid, repo_group.name))
     # permission check inside
     def grant_user_group_permission_to_repo_group(
             self, repogroupid, usergroupid, perm,
             apply_to_children='none'):
         """
         Grant permission for user group on given repository group, or update
         existing one if found. This command can be executed only using
         api_key belonging to user with admin rights, or user who has admin
         right to given repository group.
         :param repogroupid: name or id of repository group
         :type repogroupid: str or int
         :param usergroupid: id of usergroup
         :type usergroupid: str or int
         :param perm: (group.(none|read|write|admin))
         :type perm: str
         :param apply_to_children: 'none', 'repos', 'groups', 'all'
         :type apply_to_children: str
         OUTPUT::
           id : <id_given_in_input>
           result : {
             "msg" : "Granted perm: `<perm>` (recursive:<apply_to_children>) for user group: `<usersgroupname>` in repo group: `<repo_group_name>`",
             "success": true
+          }
           error :  null
         ERROR OUTPUT::
           id : <id_given_in_input>
           result : null
           error :  {
             "failed to edit permission for user group: `<usergroup>` in repo group: `<repo_group_name>`"
+          }
         """
         repo_group = get_repo_group_or_error(repogroupid)
         perm = get_perm_or_error(perm, prefix='group.')
         user_group = get_user_group_or_error(usergroupid)
         if not HasPermissionAny('hg.admin')():
             if not HasRepoGroupPermissionLevel('admin')(repo_group.group_name):
                 raise JSONRPCError(
                     'repository group `%s` does not exist' % (repogroupid,))
             if not HasUserGroupPermissionLevel('read')(user_group.users_group_name):
                 raise JSONRPCError(
                     'user group `%s` does not exist' % (usergroupid,))
         try:
             RepoGroupModel().add_permission(repo_group=repo_group,
                                             obj=user_group,
                                             obj_type="user_group",
                                             perm=perm,
                                             recursive=apply_to_children)
             meta.Session().commit()
             return dict(
                 msg='Granted perm: `%s` (recursive:%s) for user group: `%s` in repo group: `%s`' % (
                     perm.permission_name, apply_to_children,
                     user_group.users_group_name, repo_group.name
                 ),
                 success=True
+            )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError(
                 'failed to edit permission for user group: `%s` in '
                 'repo group: `%s`' % (
                     usergroupid, repo_group.name
+                )
+            )
     # permission check inside
     def revoke_user_group_permission_from_repo_group(
             self, repogroupid, usergroupid,
             apply_to_children='none'):
         """
         Revoke permission for user group on given repository. This command can be
         executed only using api_key belonging to user with admin rights, or
         user who has admin right to given repository group.
         :param repogroupid: name or id of repository group
         :type repogroupid: str or int
         :param usergroupid:
         :param apply_to_children: 'none', 'repos', 'groups', 'all'
         :type apply_to_children: str
         OUTPUT::
             id : <id_given_in_input>
             result: {
                       "msg" : "Revoked perm (recursive:<apply_to_children>) for user group: `<usersgroupname>` in repo group: `<repo_group_name>`",
                       "success": true
+                    }
             error:  null
         ERROR OUTPUT::
           id : <id_given_in_input>
           result : null
           error :  {
             "failed to edit permission for user group: `<usergroup>` in repo group: `<repo_group_name>`"
+          }
         """
         repo_group = get_repo_group_or_error(repogroupid)
         user_group = get_user_group_or_error(usergroupid)
         if not HasPermissionAny('hg.admin')():
             if not HasRepoGroupPermissionLevel('admin')(repo_group.group_name):
                 raise JSONRPCError(
                     'repository group `%s` does not exist' % (repogroupid,))
             if not HasUserGroupPermissionLevel('read')(user_group.users_group_name):
                 raise JSONRPCError(
                     'user group `%s` does not exist' % (usergroupid,))
         try:
             RepoGroupModel().delete_permission(repo_group=repo_group,
                                                obj=user_group,
                                                obj_type="user_group",
                                                recursive=apply_to_children)
             meta.Session().commit()
             return dict(
                 msg='Revoked perm (recursive:%s) for user group: `%s` in repo group: `%s`' % (
                     apply_to_children, user_group.users_group_name, repo_group.name
                 ),
                 success=True
+            )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError(
                 'failed to edit permission for user group: `%s` in repo group: `%s`' % (
                     user_group.users_group_name, repo_group.name
+                )
+            )
     def get_gist(self, gistid):
         """
         Get given gist by id
         :param gistid: id of private or public gist
         :type gistid: str
         """
         gist = get_gist_or_error(gistid)
         if not HasPermissionAny('hg.admin')():
             if gist.owner_id != request.authuser.user_id:
                 raise JSONRPCError('gist `%s` does not exist' % (gistid,))
         return gist.get_api_data()
     def get_gists(self, userid=None):
         """
         Get all gists for given user. If userid is empty returned gists
         are for user who called the api
         :param userid: user to get gists for
         :type userid: Optional(str or int)
         """
         if not HasPermissionAny('hg.admin')():
             # make sure normal user does not pass someone else userid,
             # he is not allowed to do that
             if userid is not None and userid != request.authuser.user_id:
                 raise JSONRPCError(
                     'userid is not the same as your user'
+                )
         if userid is None:
             user_id = request.authuser.user_id
         else:
             user_id = get_user_or_error(userid).user_id
         return [
             gist.get_api_data()
             for gist in db.Gist().query()
                 .filter_by(is_expired=False)
                 .filter(db.Gist.owner_id == user_id)
                 .order_by(db.Gist.created_on.desc())
+        ]
     def create_gist(self, files, owner=None,
                     gist_type=db.Gist.GIST_PUBLIC, lifetime=-1,
                     description=''):
         """
         Creates new Gist
         :param files: files to be added to gist
             {'filename': {'content':'...', 'lexer': null},
              'filename2': {'content':'...', 'lexer': null}}
         :type files: dict
         :param owner: gist owner, defaults to api method caller
         :type owner: Optional(str or int)
         :param gist_type: type of gist 'public' or 'private'
         :type gist_type: Optional(str)
         :param lifetime: time in minutes of gist lifetime
         :type lifetime: Optional(int)
         :param description: gist description
         :type description: Optional(str)
         OUTPUT::
           id : <id_given_in_input>
           result : {
             "msg": "created new gist",
             "gist": {}
+          }
           error :  null
         ERROR OUTPUT::
           id : <id_given_in_input>
           result : null
           error :  {
             "failed to create gist"
+          }
         """
         try:
             if owner is None:
                 owner = request.authuser.user_id
             owner = get_user_or_error(owner)
             gist = GistModel().create(description=description,
                                       owner=owner,
                                       ip_addr=request.ip_addr,
                                       gist_mapping=files,
                                       gist_type=gist_type,
                                       lifetime=lifetime)
             meta.Session().commit()
             return dict(
                 msg='created new gist',
                 gist=gist.get_api_data()
+            )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError('failed to create gist')
     # permission check inside
     def delete_gist(self, gistid):
         """
         Deletes existing gist
         :param gistid: id of gist to delete
         :type gistid: str
         OUTPUT::
           id : <id_given_in_input>
           result : {
             "deleted gist ID: <gist_id>",
             "gist": null
+          }
           error :  null
         ERROR OUTPUT::
           id : <id_given_in_input>
           result : null
           error :  {
             "failed to delete gist ID:<gist_id>"
+          }
         """
         gist = get_gist_or_error(gistid)
         if not HasPermissionAny('hg.admin')():
             if gist.owner_id != request.authuser.user_id:
                 raise JSONRPCError('gist `%s` does not exist' % (gistid,))
         try:
             GistModel().delete(gist)
             meta.Session().commit()
             return dict(
                 msg='deleted gist ID:%s' % (gist.gist_access_id,),
                 gist=None
+            )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError('failed to delete gist ID:%s'
                                % (gist.gist_access_id,))
     # permission check inside
     def get_changesets(self, repoid, start=None, end=None, start_date=None,
                        end_date=None, branch_name=None, reverse=False, with_file_list=False, max_revisions=None):
         repo = get_repo_or_error(repoid)
         if not HasRepoPermissionLevel('read')(repo.repo_name):
             raise JSONRPCError('Access denied to repo %s' % repo.repo_name)
         format = "%Y-%m-%dT%H:%M:%S"
         try:
             return [e.__json__(with_file_list) for e in
                 repo.scm_instance.get_changesets(start,
                                                  end,
                                                  datetime.strptime(start_date, format) if start_date else None,
                                                  datetime.strptime(end_date, format) if end_date else None,
                                                  branch_name,
                                                  reverse, max_revisions)]
         except EmptyRepositoryError as e:
             raise JSONRPCError('Repository is empty')
     # permission check inside
     def get_changeset(self, repoid, raw_id, with_reviews=False):
         repo = get_repo_or_error(repoid)
         if not HasRepoPermissionLevel('read')(repo.repo_name):
             raise JSONRPCError('Access denied to repo %s' % repo.repo_name)
         changeset = repo.get_changeset(raw_id)
         if isinstance(changeset, EmptyChangeset):
             raise JSONRPCError('Changeset %s does not exist' % raw_id)
         info = dict(changeset.as_dict())
         if with_reviews:
             reviews = ChangesetStatusModel().get_statuses(
                                 repo.repo_name, raw_id)
             info["reviews"] = reviews
         return info
     # permission check inside
     def get_pullrequest(self, pullrequest_id):
         """
         Get given pull request by id
         """
         pull_request = db.PullRequest.get(pullrequest_id)
         if pull_request is None:
             raise JSONRPCError('pull request `%s` does not exist' % (pullrequest_id,))
         if not HasRepoPermissionLevel('read')(pull_request.org_repo.repo_name):
             raise JSONRPCError('not allowed')
         return pull_request.get_api_data()
     # permission check inside
     def comment_pullrequest(self, pull_request_id, comment_msg='', status=None, close_pr=False):
         """
         Add comment, close and change status of pull request.
         """
         apiuser = get_user_or_error(request.authuser.user_id)
         pull_request = db.PullRequest.get(pull_request_id)
         if pull_request is None:
             raise JSONRPCError('pull request `%s` does not exist' % (pull_request_id,))
         if (not HasRepoPermissionLevel('read')(pull_request.org_repo.repo_name)):
             raise JSONRPCError('No permission to add comment. User needs at least reading permissions'
                                ' to the source repository.')
         owner = apiuser.user_id == pull_request.owner_id
         reviewer = apiuser.user_id in [reviewer.user_id for reviewer in pull_request.reviewers]
         if close_pr and not (apiuser.admin or owner):
             raise JSONRPCError('No permission to close pull request. User needs to be admin or owner.')
         if status and not (apiuser.admin or owner or reviewer):
             raise JSONRPCError('No permission to change pull request status. User needs to be admin, owner or reviewer.')
         if pull_request.is_closed():
             raise JSONRPCError('pull request is already closed')
         comment = ChangesetCommentsModel().create(
             text=comment_msg,
             repo=pull_request.org_repo.repo_id,
             author=apiuser.user_id,
             pull_request=pull_request.pull_request_id,
             f_path=None,
             line_no=None,
             status_change=db.ChangesetStatus.get_status_lbl(status),
             closing_pr=close_pr
+        )
         userlog.action_logger(apiuser,
                       'user_commented_pull_request:%s' % pull_request_id,
                       pull_request.org_repo, request.ip_addr)
         if status:
             ChangesetStatusModel().set_status(
                 pull_request.org_repo_id,
                 status,
                 apiuser.user_id,
                 comment,
                 pull_request=pull_request_id
+            )
         if close_pr:
             PullRequestModel().close_pull_request(pull_request_id)
             userlog.action_logger(apiuser,
                           'user_closed_pull_request:%s' % pull_request_id,
                           pull_request.org_repo, request.ip_addr)
         meta.Session().commit()
         return True
     # permission check inside
     def edit_reviewers(self, pull_request_id, add=None, remove=None):
         """
         Add and/or remove one or more reviewers to a pull request, by username
         or user ID. Reviewers are specified either as a single-user string or
         as a JSON list of one or more strings.
         """
         if add is None and remove is None:
             raise JSONRPCError('''Invalid request. Neither 'add' nor 'remove' is specified.''')
         pull_request = db.PullRequest.get(pull_request_id)
         if pull_request is None:
             raise JSONRPCError('pull request `%s` does not exist' % (pull_request_id,))
         apiuser = get_user_or_error(request.authuser.user_id)
         is_owner = apiuser.user_id == pull_request.owner_id
         is_repo_admin = HasRepoPermissionLevel('admin')(pull_request.other_repo.repo_name)
         if not (apiuser.admin or is_repo_admin or is_owner):
             raise JSONRPCError('No permission to edit reviewers of this pull request. User needs to be admin or pull request owner.')
         if pull_request.is_closed():
             raise JSONRPCError('Cannot edit reviewers of a closed pull request.')
         if not isinstance(add, list):
             add = [add]
         if not isinstance(remove, list):
             remove = [remove]
         # look up actual user objects from given name or id. Bail out if unknown.
         add_objs = set(get_user_or_error(user) for user in add if user is not None)
         remove_objs = set(get_user_or_error(user) for user in remove if user is not None)
         new_reviewers = redundant_reviewers = set()
         if add_objs:
             new_reviewers, redundant_reviewers = PullRequestModel().add_reviewers(apiuser, pull_request, add_objs)
         if remove_objs:
             PullRequestModel().remove_reviewers(apiuser, pull_request, remove_objs)
         meta.Session().commit()
         return {
             'added': [x.username for x in new_reviewers],
             'already_present': [x.username for x in redundant_reviewers],
             # NOTE: no explicit check that removed reviewers were actually present.
             'removed': [x.username for x in remove_objs],
+        }

kallithea/i18n/de/LC_MESSAGES/kallithea.po

➞

Show inline comments

@@ @@ -511,2080 +511,2080 @@ msgid "Please enter email address" @@
 msgstr "Bitte geben Sie eine E-Mail-Adresse an"
 msgid "Send email task created"
 msgstr "Task zum Versenden von E-Mails erstellt"
 msgid "Builtin hooks are read-only. Please use another hook name."
 msgstr ""
 "Die eingebauten Hooks sind schreibgeschützt. Bitte verwenden Sie einen "
 "anderen Hook-Namen."
 msgid "Added new hook"
 msgstr "Neuer Hook hinzugefügt"
 msgid "Updated hooks"
 msgstr "Die Hooks wurden aktutalisiert"
 msgid "Error occurred during hook creation"
 msgstr "Während der Erzeugung des Hooks ist ein Fehler aufgetreten"
 msgid "Whoosh reindex task scheduled"
 msgstr "Whoosh Reindizierungs Aufgabe wurde zur Ausführung geplant"
 msgid "Created user group %s"
 msgstr "Nutzergruppe %s erstellt"
 msgid "Error occurred during creation of user group %s"
 msgstr ""
 "Es ist ein Fehler während der Erstellung der Nutzergruppe %s aufgetreten"
 msgid "Updated user group %s"
 msgstr "Aktualisierte Nutzergruppe %s"
 msgid "Error occurred during update of user group %s"
 msgstr ""
 "Während des Updates der Benutzergruppe %s ist ein Fehler aufgetreten"
 msgid "Successfully deleted user group"
 msgstr "Die Nutzergruppe wurde erfolgreich entfernt"
 msgid "An error occurred during deletion of user group"
 msgstr "Während des Löschens der Benutzergruppe ist ein Fehler aufgetreten"
 msgid "Target group cannot be the same"
 msgstr "Zielgruppe kann nicht die gleiche Gruppe sein"
 msgid "User group permissions updated"
 msgstr "Berechtigungen der Benutzergruppe wurden aktualisiert"
 msgid "Updated permissions"
 msgstr "Berechtigungen wurden aktualisiert"
 msgid "An error occurred during permissions saving"
 msgstr ""
 "Es ist ein Fehler während des Speicherns der Berechtigungen aufgetreten"
 msgid "Created user %s"
 msgstr "Nutzer %s erstellt"
 msgid "Error occurred during creation of user %s"
 msgstr "Während des Erstellens des Benutzers %s ist ein Fehler aufgetreten"
 msgid "User updated successfully"
 msgstr "Der Benutzer wurde erfolgreich aktualisiert"
 msgid "Successfully deleted user"
 msgstr "Der Nutzer wurde erfolgreich gelöscht"
 msgid "An error occurred during deletion of user"
 msgstr "Während der Löschen des Benutzers trat ein Fehler auf"
 msgid "The default user cannot be edited"
 msgstr "Der Standard-Benutzer kann nicht bearbeitet werden"
 msgid "Added IP address %s to user whitelist"
 msgstr "Die IP-Adresse %s wurde zur Nutzerwhitelist hinzugefügt"
 msgid "An error occurred while adding IP address"
 msgstr "Während des Speicherns der IP-Adresse ist ein Fehler aufgetreten"
 msgid "Removed IP address from user whitelist"
 msgstr "IP-Adresse wurde von der Nutzerwhitelist entfernt"
 msgid "You need to be a registered user to perform this action"
 msgstr ""
 "Sie müssen ein Registrierter Nutzer sein um diese Aktion durchzuführen"
 msgid "You need to be signed in to view this page"
 msgstr "Sie müssen sich anmelden um diese Seite aufzurufen"
 msgid ""
 "CSRF token leak has been detected - all form tokens have been expired"
 msgstr ""
 "Es wurde ein CSRF Leck entdeckt. Alle Formular Token sind abgelaufen"
 msgid "Repository not found in the filesystem"
 msgstr "Das Repository konnte nicht im Filesystem gefunden werden"
 msgid "Binary file"
 msgstr "Binäre Datei"
 msgid ""
 "Changeset was too big and was cut off, use diff menu to display this diff"
 msgstr ""
 "Der Änderungssatz war zu groß und wurde abgeschnitten, benutzen sie das "
 "Diff Menü um die Unterschiede anzuzeigen"
 msgid "No changes detected"
 msgstr "Keine Änderungen erkannt"
 msgid "Deleted branch: %s"
 msgstr "Branch %s gelöscht"
 msgid "Created tag: %s"
 msgstr "Tag %s erstellt"
 msgid "Show all combined changesets %s->%s"
 msgstr "Zeige alle Kombinierten Änderungensätze %s->%s"
 msgid "Compare view"
 msgstr "Vergleichsansicht"
 msgid "and"
 msgstr "und"
 msgid "%s more"
 msgstr "%s mehr"
 msgid "revisions"
 msgstr "revisionen"
 msgid "Fork name %s"
 msgstr "Fork Name %s"
 msgid "Pull request %s"
 msgstr "Pull Request %s"
 msgid "[deleted] repository"
 msgstr "[gelöscht] Repository"
 msgid "[created] repository"
 msgstr "[erstellt] Repository"
 msgid "[created] repository as fork"
 msgstr "[erstellt] Repository als Fork"
 msgid "[forked] repository"
 msgstr "[forked] Repository"
 msgid "[updated] repository"
 msgstr "[aktualisiert] Repository"
 msgid "[downloaded] archive from repository"
 msgstr "Archiv von Repository [heruntergeladen]"
 msgid "[delete] repository"
 msgstr "Repository [gelöscht]"
 msgid "[created] user"
 msgstr "Benutzer [erstellt]"
 msgid "[updated] user"
 msgstr "Benutzer [akutalisiert]"
 msgid "[created] user group"
 msgstr "Benutzergruppe [erstellt]"
 msgid "[updated] user group"
 msgstr "Benutzergruppe [aktualisiert]"
 msgid "[commented] on revision in repository"
 msgstr "Revision [kommentiert] in Repository"
 msgid "[commented] on pull request for"
 msgstr "Pull Request [kommentiert] für"
 msgid "[closed] pull request for"
 msgstr "Pull Request [geschlossen] für"
 msgid "[pushed] into"
 msgstr "[Pushed] in"
 msgid "[committed via Kallithea] into repository"
 msgstr "[via Kallithea] in Repository [committed]"
 msgid "[pulled from remote] into repository"
 msgstr "[Pulled von Remote] in Repository"
 msgid "[pulled] from"
 msgstr "[Pulled] von"
 msgid "[started following] repository"
 msgstr "[Following gestartet] für Repository"
 msgid "[stopped following] repository"
 msgstr "[Following gestoppt] für Repository"
 msgid " and %s more"
 msgstr " und %s weitere"
 msgid "No files"
 msgstr "Keine Dateien"
 msgid "new file"
 msgstr "neue Datei"
 msgid "mod"
 msgstr "mod"
 msgid "del"
 msgstr "entf"
 msgid "rename"
 msgstr "umbenennen"
 msgid "chmod"
 msgstr "chmod"
 msgid ""
 "%s repository is not mapped to db perhaps it was created or renamed from "
 "the filesystem please run the application again in order to rescan "
 "repositories"
 msgstr ""
 "Das %s Repository ist nicht in der Datenbank vorhanden, eventuell wurde "
 "es im Dateisystem erstellt oder umbenannt. Bitte starten sie die "
 "Applikation erneut um die Repositories neu zu Indizieren"
 msgid "%d year"
 msgid_plural "%d years"
 msgstr[0] "%d Jahr"
 msgstr[1] "%d Jahre"
 msgid "%d month"
 msgid_plural "%d months"
 msgstr[0] "%d Monat"
 msgstr[1] "%d Monate"
 msgid "%d day"
 msgid_plural "%d days"
 msgstr[0] "%d Tag"
 msgstr[1] "%d Tage"
 msgid "%d hour"
 msgid_plural "%d hours"
 msgstr[0] "%d Stunde"
 msgstr[1] "%d Stunden"
 msgid "%d minute"
 msgid_plural "%d minutes"
 msgstr[0] "%d Minute"
 msgstr[1] "%d Minuten"
 msgid "%d second"
 msgid_plural "%d seconds"
 msgstr[0] "%d Sekunde"
 msgstr[1] "%d Sekunden"
 msgid "in %s"
 msgstr "in %s"
 msgid "%s ago"
 msgstr "vor %s"
 msgid "in %s and %s"
 msgstr "in %s und %s"
 msgid "%s and %s ago"
 msgstr "%s und %s her"
 msgid "just now"
 msgstr "jetzt gerade"
 msgid "on line %s"
 msgstr "in Zeile %s"
 msgid "[Mention]"
 msgstr "[Mention]"
 msgid "top level"
 msgstr "höchste Ebene"
 msgid "Kallithea Administrator"
 msgstr "Kallithea Administrator"
 msgid "Default user has no access to new repositories"
 msgstr "Der Standard-Benutzer hat keinen Zugriff auf neue Repositories"
 msgid "Default user has read access to new repositories"
 msgstr "Der Standard-Benutzer hat Leserechte auf neuen Repositories"
 msgid "Default user has write access to new repositories"
 msgstr "Der Standard-Benutzer hat Schreibrechte auf neuen Repositories"
 msgid "Default user has admin access to new repositories"
 msgstr "Der Standard-Benutzer hat Admin-Rechte auf neuen Repositories"
 msgid "Default user has no access to new repository groups"
 msgstr ""
 "Der Standard-Benutzer hat keinen Zugriff auf neue Repository-Gruppen"
 msgid "Default user has read access to new repository groups"
 msgstr "Der Standard-Benutzer hat Leserechte auf neuen Repository-Gruppen"
 msgid "Default user has write access to new repository groups"
 msgstr "Der Standard-Benutzer Schreibrechte auf neuen Repository-Gruppen"
 msgid "Default user has admin access to new repository groups"
 msgstr "Der Standard-Benutzer Admin-Rechte auf neuen Repository-Gruppen"
 msgid "Default user has no access to new user groups"
 msgstr "Der Standard-Benutzer hat keinen Zugriff auf neue Benutzer-Gruppen"
 msgid "Default user has read access to new user groups"
 msgstr "Der Standard-Benutzer hat Leserechte auf neuen Benutzer-Gruppen"
 msgid "Default user has write access to new user groups"
 msgstr "Der Standard-Benutzer hat Schreibrechte auf neuen Benutzer-Gruppen"
 msgid "Default user has admin access to new user groups"
 msgstr "Der Standard-Benutzer hat Admin-Rechte auf neuen Benutzer-Gruppen"
 msgid "Only admins can create repository groups"
 msgstr "Nur Admins können Repository-Gruppen erstellen"
 msgid "Non-admins can create repository groups"
 msgstr "Nicht-Admins können Repository-Gruppen erstellen"
 msgid "Only admins can create user groups"
 msgstr "Nur Admins können Benutzer-Gruppen erstellen"
 msgid "Non-admins can create user groups"
 msgstr "Nicht-Admins können Benutzer-Gruppen erstellen"
 msgid "Only admins can create top level repositories"
 msgstr "Nur Admins können Repositories auf oberster Ebene erstellen"
 msgid "Non-admins can create top level repositories"
 msgstr "Nicht-Admins können Repositories oberster Ebene erstellen"
 msgid ""
 "Repository creation enabled with write permission to a repository group"
 msgstr ""
 "Erstellung von Repositories mit Schreibzugriff für Repositorygruppe "
 "aktiviert"
 msgid ""
 "Repository creation disabled with write permission to a repository group"
 msgstr ""
 "Erstellung von Repositories mit Schreibzugriff für Repositorygruppe "
 "deaktiviert"
 msgid "Only admins can fork repositories"
 msgstr "Nur Admins können Repositories forken"
 msgid "Non-admins can fork repositories"
 msgstr "Nicht-Admins können Repositorys forken"
 msgid "Registration disabled"
 msgstr "Registrierung deaktiviert"
 msgid "User registration with manual account activation"
 msgstr "Benutzerregistrierung mit manueller Kontoaktivierung"
 msgid "User registration with automatic account activation"
 msgstr "Benutzerregistrierung mit automatischer Kontoaktivierung"
 msgid "Not reviewed"
 msgstr "Nicht Begutachtet"
 msgid "Under review"
 msgstr "In Begutachtung"
 msgid "Approved"
 msgstr "Akzeptiert"
 msgid "Please enter a login"
 msgstr "Bitte einen Benutzernamen eingeben"
 msgid "Enter a value %(min)i characters long or more"
 msgstr "Bitte einen Wert mit mindestens %(min)i Zeichen eingeben"
 msgid "Please enter a password"
 msgstr "Bitte ein Passwort eingeben"
 msgid "Enter %(min)i characters or more"
 msgstr "Bitte mindestens %(min)i Zeichen eingeben"
 msgid "Name must not contain only digits"
 msgstr "Name darf nicht nur Ziffern enthalten"
 msgid "New user %(new_username)s registered"
 msgstr "Neuer Benutzer %(new_username)s registriert"
 msgid "Closing"
 msgstr "Schließen"
 msgid ""
 "Cannot create pull request - criss cross merge detected, please merge a "
 "later %s revision to %s"
 msgstr ""
 "Pull-Request kann nicht erstellt werden - Criss Cross Merge erkannt, "
 "bitte eine spätere %s-Revision in %s zusammenführen."
 msgid "You are not authorized to create the pull request"
 msgstr "Sie sind nicht berechtigt, den Pull-Request anzulegen."
 msgid "Closed, next iteration: %s ."
 msgstr "Geschlossen, nächste Iteration: %s ."
 msgid "latest tip"
 msgstr "Letzter Tip"
 msgid "New user registration"
 msgstr "Neue Benutzerregistrierung"
 msgid ""
 "User \"%s\" still owns %s repositories and cannot be removed. Switch "
 "owners or remove those repositories: %s"
 msgstr ""
 "Der Benutzer \"%s\" besitzt noch immer %s Repositories und kann daher "
 "nicht entfernt werden. Entweder muss der Besitzer geändert oder das "
 "Repository entfernt werden: %s"
 msgid ""
 "User \"%s\" still owns %s repository groups and cannot be removed. Switch "
 "owners or remove those repository groups: %s"
 msgstr ""
 "Der Benutzer \"%s\" ist noch der Besitzer von %s Repositorygruppen und "
 "kann daher nicht entfernt werden. Entweder muss der Besitzer geändert "
 "oder die Repositorygruppen müssen entfernt werden: %s"
 msgid ""
 "User \"%s\" still owns %s user groups and cannot be removed. Switch "
 "owners or remove those user groups: %s"
 msgstr ""
 "Der Benutzer \"%s\" besitzt noch immer %s Benutzergruppen und kann daher "
 "nicht entfernt werden. Entweder muss der Besitzer geändert oder die "
 "Benutzergruppen müssen gelöscht werden: %s"
 msgid "Password reset link"
 msgstr "Link zum Zurücksetzen des Passworts"
 msgid ""
 "The password to your account %s has been changed using password reset "
 "form."
 msgstr ""
 "Das Passwort für dein Konto %s wurde mit dem Formular zum Zurücksetzen "
 "des Passworts geändert."
 msgid "Value cannot be an empty list"
 msgstr "Eine leere Liste ist kein gültiger Wert"
 msgid "Username \"%(username)s\" already exists"
 msgstr "Benutezrname \"%(username)s\" existiert bereits"
 msgid "The input is not valid"
 msgstr "Die Eingabe ist nicht gültig"
 msgid "Username %(username)s is not valid"
 msgstr "Benutzername \"%(username)s\" ist ungültig"
 msgid "Invalid user group name"
 msgstr "Ungültiger Benutzergruppenname"
 msgid "User group \"%(usergroup)s\" already exists"
 msgstr "Benutzergruppe \"%(usergroup)s\" existiert bereits"
 msgid ""
 "user group name may only contain alphanumeric characters underscores, "
 "periods or dashes and must begin with alphanumeric character"
 msgstr ""
 "Der Name einer Benutzergruppe darf nur alphanumerische Zeichen, "
 "Unterstriche, Punkte oder Bindestriche enthalten und muss mit einem "
 "alphanumerischen Zeichen beginnen"
 msgid "Cannot assign this group as parent"
 msgstr "Kann diese Gruppe nicht als vorgesetzt setzen"
 msgid "Group \"%(group_name)s\" already exists"
 msgstr "Gruppe \"%(group_name)s\" existiert bereits"
 msgid "Repository with name \"%(group_name)s\" already exists"
 msgstr "Es gibt bereits ein Repository mit \"%(group_name)s\""
 msgid "Invalid characters (non-ascii) in password"
 msgstr "Üngültige(nicht ASCII) Zeichen im Passwort"
 msgid "Invalid old password"
 msgstr "Ungültiges altes Passwort"
 msgid "Passwords do not match"
 msgstr "Die Passwörter stimmen nicht überein"
 msgid "Repository named %(repo)s already exists"
 msgstr "Es gibt bereits ein Repository mit \"%(repo)s\""
 msgid "Repository \"%(repo)s\" already exists in group \"%(group)s\""
 msgstr ""
 "Es gibt bereits ein Repository mit \"%(repo)s\" in der Gruppe \"%(group)s"
 "\""
 msgid "Repository group with name \"%(repo)s\" already exists"
 msgstr "Eine Repositorygruppe mit dem Namen \"%(repo)s\" existiert bereits"
 msgid "Invalid repository URL"
 msgstr "Ungültige Repository-URL"
 msgid "Fork has to be the same type as parent"
 msgstr "Forke um den selben typ wie der Vorgesetze zu haben"
 msgid "You don't have permissions to create repository in this group"
 msgstr ""
 "Du hast nicht die erforderlichen Berechtigungen, um in dieser Gruppe ein "
 "Repository zu erzeugen"
 msgid "no permission to create repository in root location"
 msgstr "keine Berechtigung, um ein Repository auf höchster Ebene anzulegen"
 msgid "You don't have permissions to create a group in this location"
 msgstr ""
 "Sie haben keine Berechtigung, um an diesem Ort ein Repository anzulegen"
 msgid "This username or user group name is not valid"
 msgstr "Dieser Benutzername oder Benutzergruppenname ist nicht gültig"
 msgid "This is not a valid path"
 msgstr "Dies ist ein Ungültiger Pfad"
 msgid "This email address is already in use"
 msgstr "Diese E-Mail-Addresse ist bereits in Benutzung"
 msgid "Email address \"%(email)s\" not found"
 msgstr "E-Mail-Addresse „%(email)s“ existiert nicht."
 msgid ""
 "The LDAP Login attribute of the CN must be specified - this is the name "
 "of the attribute that is equivalent to \"username\""
 msgstr ""
 "Das LDAP-Login-Attribut des CN muss angeben werden - Es ist der Name des "
 "Attributes äquivalent zu \"Benutzername\""
 msgid "Please enter a valid IPv4 or IPv6 address"
 msgstr "Bitte eine gültige IPv4- oder IPv6-Adresse angeben"
 msgid ""
 "The network size (bits) must be within the range of 0-32 (not %(bits)r)"
 msgstr ""
 "Die Größe (in Bits) des Netzwerks muss im Bereich 0-32 liegen (nicht "
 "%(bits)r)"
 msgid "Key name can only consist of letters, underscore, dash or numbers"
 msgstr ""
 "Der Name eines Schlüssels darf nur aus Buchstaben, Ziffern, Unterstrich "
 "und Bindestrich bestehen"
 msgid "Filename cannot be inside a directory"
 msgstr "Dateiname darf kein Unterverzeichnis enthalten"
 msgid "Plugins %(loaded)s and %(next_to_load)s both export the same name"
 msgstr ""
 "Die Plug-Ins %(loaded)s und %(next_to_load)s exportieren beide den selben "
 "Namen"
 msgid "About"
 msgstr "Über"
 msgid "Add Repository"
 msgstr "Repository hinzufügen"
 msgid "Add Repository Group"
 msgstr "Repositorygruppe hinzufügen"
 msgid "You have admin right to this group, and can edit it"
 msgstr "Du hast Adminrechte für diese Gruppe und kannst sie editieren"
 msgid "Edit Repository Group"
 msgstr "Repositorygruppe bearbeiten"
 msgid "Repository"
 msgstr "Repository"
 msgid "Description"
 msgstr "Beschreibung"
 msgid "Last Change"
 msgstr "Letzte Änderung"
 msgid "Tip"
 msgstr "Tipp"
 msgid "Owner"
 msgstr "Besitzer"
 msgid "Log In"
 msgstr "Log In"
 msgid "Log In to %s"
 msgstr "Log In in %s"
 msgid "Username"
 msgstr "Benutzername"
 msgid "Password"
 msgstr "Passwort"
 msgid "Stay logged in after browser restart"
 msgstr "Nach dem Neustart des Browsers eingeloggt bleiben"
 msgid "Forgot your password ?"
 msgstr "Passowrt Vergessen?"
 msgid "Don't have an account ?"
 msgstr "Kein Account?"
 msgid "Sign In"
 msgstr "Einloggen"
 msgid "Password Reset"
 msgstr "Passwort zurücksetzen"
 msgid "Reset Your Password to %s"
 msgstr "Setze dein Passwort auf %s zurück"
 msgid "Reset Your Password"
 msgstr "Setze dein Passwort zurück"
 msgid "Email Address"
 msgstr "E-Mail-Adresse"
 msgid "Captcha"
 msgstr "CAPTCHA"
 msgid "Send Password Reset Email"
 msgstr "E-Mail zum Zurücksetzen des Passworts anfordern"
 msgid ""
 "A password reset link will be sent to the specified email address if it "
 "is registered in the system."
 msgstr ""
 "Ein Link zum Zurücksetzen des Passworts wird an die angegebene E-Mail-"
 "Adresse gesendet, wenn diese im System registriert ist."
 msgid "You are about to set a new password for the email address %s."
 msgstr ""
 "Du bist dabei, ein neues Passwort für die E-Mail-Adresse %s festzulegen."
 msgid ""
 "Note that you must use the same browser session for this as the one used "
 "to request the password reset."
 msgstr ""
 "Beachten Sie, dass Sie dafür die gleiche Browsersitzung verwenden müssen, "
 "mit der Sie das Zurücksetzen des Passworts beantragt haben."
 msgid "Code you received in the email"
 msgstr "Code, den du in der E-Mail erhalten hast"
 msgid "Confirm"
 msgstr "Bestätigen"
 msgid "Sign Up"
 msgstr "Registrieren"
 msgid "Sign Up to %s"
 msgstr "Registrieren für %s"
 msgid "Re-enter password"
 msgstr "Passwort erneut eingeben"
 msgid "First Name"
 msgstr "Vorname"
 msgid "Last Name"
 msgstr "Nachname"
 msgid "Email"
 msgstr "E-Mail"
 msgid "Registered accounts are ready to use and need no further action."
 msgstr "Registrierte Konten können ohne weitere Aktion genutzt werden."
 msgid "Please wait for an administrator to activate your account."
 msgstr ""
 "Bitte warten Sie auf die Aktivierung Ihres Benutzerkontos durch einen "
 "Administrator."
 msgid "Admin Journal"
 msgstr "Admin-Logbuch"
 msgid "journal filter..."
 msgstr "Logbuch filter..."
 msgid "Filter"
 msgstr "Filter"
 msgid "%s Entry"
 msgid_plural "%s Entries"
 msgstr[0] "%s Eintrag"
 msgstr[1] "%s Einträge"
 msgid "Action"
 msgstr "Aktion"
 msgid "Date"
 msgstr "Datum"
 msgid "From IP"
 msgstr "Von IP"
 msgid "No actions yet"
 msgstr "Es sind bisher keine Aktionen passiert"
 msgid "Authentication Settings"
 msgstr "Authentifizierungseinstellungen"
 msgid "Authentication"
 msgstr "Authentifizierung"
 msgid "Authentication Plugins"
 msgstr "Plug-Ins zur Authentifizierung"
 msgid "Enabled Plugins"
 msgstr "Aktivierte Plugins"
 msgid "Available built-in plugins"
 msgstr "Verfügbare mitgelieferte Plug-Ins"
 msgid "Plugin"
 msgstr "Plugin"
 msgid "Save"
 msgstr "Speichern"
 msgid "Repository Defaults"
 msgstr "Repositorystandards"
 msgid "Type"
 msgstr "Typ"
 msgid "Private repository"
 msgstr "Privates Repository"
 msgid ""
 "Private repositories are only visible to people explicitly added as "
 "collaborators."
 msgstr ""
 "Private Repositories sind nur für explizit hinzugefügte Mitarbeiter "
 "sichtbar."
 msgid "Enable statistics"
 msgstr "Aktiviere Statistiken"
 msgid "Enable statistics window on summary page."
 msgstr "Statistik-Fenster in der Zusammenfassungsseite aktivieren."
 msgid "Enable downloads"
 msgstr "Aktiviere Downloads"
 msgid "Enable download menu on summary page."
 msgstr "Download-Menü auf der Zusammenfassungsseite aktivieren."
 msgid "Edit Gist"
 msgstr "Gist editieren"
 msgid ""
 "Gist was updated since you started editing. Copy your changes and click "
 "%(here)s to reload new version."
 msgstr ""
 "Gist wurde während der Änderung aktualisiert. Änderungen kopieren und "
 "%(here)s klicken um die neue Version nachzuladen."
 msgid "here"
 msgstr "hier"
 msgid "Gist description ..."
 msgstr "Gist Beschreibung ..."
 msgid "Gist lifetime"
 msgstr "Gist Lebenszeit"
 msgid "Expires"
 msgstr "Verfällt"
 msgid "Update Gist"
 msgstr "Gist aktualisieren"
 msgid "Cancel"
 msgstr "Abbrechen"
 msgid "Private Gists for User %s"
 msgstr "Privater Gist für Benutzer %s"
 msgid "Public Gists for User %s"
 msgstr "Öffentlicher Gist für Benutzer %s"
 msgid "Public Gists"
 msgstr "Öffentliche Gists"
 msgid "Create New Gist"
 msgstr "Neuen Gist erstellen"
 msgid "Created"
 msgstr "Erstellt"
 msgid "There are no gists yet"
 msgstr "Bisher sind keine Gists vorhanden"
 msgid "New Gist"
 msgstr "Neuer Gist"
 msgid "Create Private Gist"
 msgstr "Privaten Gist erstellen"
 msgid "Create Public Gist"
 msgstr "Öffentlichen Gist erstellen"
 msgid "Reset"
 msgstr "Zurücksetzen"
 msgid "Gist"
 msgstr "Gist"
 msgid "URL"
 msgstr "URL"
 msgid "Public Gist"
 msgstr "Öffentlicher Gist"
 msgid "Private Gist"
 msgstr "Privater Gist"
 msgid "Delete"
 msgstr "Löschen"
 msgid "Confirm to delete this Gist"
 msgstr "Löschen des Gists bestätigen"
 msgid "Edit"
 msgstr "Bearbeiten"
 msgid "Show as Raw"
 msgstr "Als Raw anzeigen"
 msgid "created"
 msgstr "erstellt"
 msgid "Show as raw"
 msgstr "Als Raw anzeigen"
 msgid "My Account"
 msgstr "Mein Account"
 msgid "Profile"
 msgstr "Profil"
 msgid "Email Addresses"
 msgstr "E-Mail-Adressen"
 msgid "API Keys"
 msgstr "API Keys"
 msgid "Owned Repositories"
 msgstr "Eigene Repositories"
 msgid "Watched Repositories"
 msgstr "Beobachtete Repositories"
 msgid "Show Permissions"
 msgstr "Berechtigungen anzeigen"
 msgid "Built-in"
 msgstr "Mitgeliefert"
 msgid "Confirm to reset this API key: %s"
 msgstr "Zurücksetzen des API-Schlüssels \"%s\" bestätigen"
 msgid "Expired"
 msgstr "Verfallen"
 msgid "Confirm to remove this API key: %s"
 msgstr "Entfernen des API-Schlüssels \"%s\" bestätigen"
 msgid "Remove"
 msgstr "Entfernen"
 msgid "No additional API keys specified"
 msgstr "Keine weiteren API-Schlüssel angegeben"
 msgid "New API key"
 msgstr "Neuer API-Schlüssel"
 msgid "Add"
 msgstr "Hinzufügen"
 msgid ""
 "\n"
 "API keys are used to let scripts or services access %s using your\n"
 "account, as if you had provided the script or service with your actual\n"
 "password.\n"
 msgstr ""
 "\n"
 "API-Schlüssel werden verwendet, um Skripten oder Diensten denselben\n"
 "Zugang zu %s zu gewähren, den Sie mit Eingabe Ihres Passworts\n"
 "erlangen würden.\n"
 msgid ""
 "\n"
 "Like passwords, API keys should therefore never be shared with others,\n"
 "nor passed to untrusted scripts or services. If such sharing should\n"
 "happen anyway, reset the API key on this page to prevent further use.\n"
 msgstr ""
 "\n"
 "Ebenso wie Passworte, sollten API-Schlüssel somit niemals mit anderen\n"
 "geteilt oder von nicht-vertrauenswürdigen Skripten oder Diensten\n"
 "verwendet werden. Falls ein solcher Zugriff zwischenzeitlich passiert "
 "sein\n"
 "sollte, dann können Sie hier den API-Schlüssel zurücksetzen, um weiteren\n"
 "Missbrauchen zu verhindern.\n"
 msgid "Primary"
 msgstr "Primär"
 msgid "Confirm to delete this email: %s"
 msgstr "Löschen der E-Mail „%s“ bestätigen"
 msgid "No additional emails specified."
 msgstr "Keine weiteren E-Mails spezifiziert."
 msgid "New email address"
 msgstr "Neue E-Mailadresse"
 msgid "Change Your Account Password"
 msgstr "Passwort des Benutzerkontos ändern"
 msgid "Current password"
 msgstr "Aktuelles Passwort"
 msgid "New password"
 msgstr "Neues Passwort"
 msgid "Confirm new password"
 msgstr "Bestätige neues Passwort"
 msgid ""
 "This account is managed with %s and the password cannot be changed here"
 msgstr ""
 "Dieser Account wird mit %s verwaltet - daher kann das Passwort nicht "
 "geändert werden"
 msgid "Gravatar"
 msgstr "Gravatar"
 msgid "Change %s avatar at"
 msgstr "Benutzerbild %s ändern unter"
 msgid "Avatars are disabled"
 msgstr "Avatare sind deaktiviert"
 msgid "Repositories You Own"
 msgstr "Repositories in Ihrem Besitz"
 msgid "Name"
 msgstr "Name"
 msgid "Repositories You are Watching"
 msgstr "Repositories, denen Sie folgen"
 msgid "Default Permissions"
 msgstr "Standardrechte"
 msgid "Global"
 msgstr "Global"
 msgid "IP Whitelist"
 msgstr "IP Whitelist"
 msgid "Anonymous access"
 msgstr "Anonymer Zugang"
 msgid ""
 "Allow access to Kallithea without needing to log in. Anonymous users use "
 "%s user permissions."
 msgstr ""
 "Unauthentifizierten Zugriff auf Kallithea erlauben. Anonyme Benutzer "
 "verwenden %s Benutzerrechte."
 msgid ""
 "All default permissions on each repository will be reset to chosen "
 "permission, note that all custom default permission on repositories will "
 "be lost"
 msgstr ""
 "Alle Standardrechte jedes Repositorys werden auf die gewählten Rechte "
 "gesetzt. Beachten Sie, dass alle spezifischen Standardrechte der "
 "Repositories verloren gehen"
 msgid "Apply to all existing repositories"
 msgstr "Auf alle bestehenden Repositories anwenden"
 msgid "Permissions for the Default user on new repositories."
 msgstr "Berechtigungen für neue Repositories des Vorgabe-Benutzers."
 msgid "Repository group"
 msgstr "Repository Gruppe"
 msgid ""
 "All default permissions on each repository group will be reset to chosen "
 "permission, note that all custom default permission on repository groups "
 "will be lost"
 msgstr ""
 "Alle Standardrechte jeder Repositorygruppe werden auf die gewählten "
 "Rechte gesetzt. Beachten Sie, dass all spezifischen Standardrechte der "
 "Repositorygruppen verloren gehen"
 msgid "Apply to all existing repository groups"
 msgstr "Auf alle bestehenden Repository-Gruppen anwenden"
 msgid "Permissions for the Default user on new repository groups."
 msgstr "Berechtigungen des Vorgabe-Benutzers für neue Repository-Gruppen."
 msgid "User group"
 msgstr "Benutzergruppe"
 msgid ""
 "All default permissions on each user group will be reset to chosen "
 "permission, note that all custom default permission on user groups will "
 "be lost"
 msgstr ""
 "Alle Vorgabe-Berechtigungen jeder Benutzergruppe werden auf die gewählten "
 "Berechtigungen zurückgesetzt. Beachten Sie, dass dabei alle Anpassungen "
 "von Vorgabe-Berechtigungen für Benutzergruppen verloren gehen"
 msgid "Apply to all existing user groups"
 msgstr "Auf alle bestehenden Benutzergruppen anwenden"
 msgid "Permissions for the Default user on new user groups."
 msgstr "Berechtigungen für neue Benutzergruppen des den Vorgabe-Benutzer."
 msgid "Top level repository creation"
 msgstr "Erstellung eines übergeordneten Repositories"
 msgid ""
 "Enable this to allow non-admins to create repositories at the top level."
 msgstr ""
 "Aktiviere dies, damit Nicht-Administratoren Repositories auf der obersten "
 "Ebene erstellen können."
 msgid ""
 "Note: This will also give all users API access to create repositories "
 "everywhere. That might change in future versions."
 msgstr ""
 "Hinweis: dadurch erhalten auch alle Benutzer API-Zugriff, um überall "
 "Repositories zu erstellen. Das kann sich in zukünftigen Versionen ändern."
 msgid "Repository creation with group write access"
 msgstr "Repository-Erstellung mit Gruppen-Schreibzugriff"
 msgid ""
 "With this, write permission to a repository group allows creating "
 "repositories inside that group. Without this, group write permissions "
 "mean nothing."
 msgstr ""
 "Falls aktiv, gewährt dies das Recht zum Erzeugen von Repositories in "
 "einer Repository-Gruppe. Falls inaktiv, sind Gruppen-"
 "Schreibberechtigungen wirkungslos."
 msgid "User group creation"
 msgstr "Benutzergruppen Erstellung"
 msgid "Enable this to allow non-admins to create user groups."
 msgstr ""
 "Aktivieren Sie dies, damit Nicht-Administratoren Benutzergruppen "
 "erstellen können."
 msgid "Repository forking"
 msgstr "Repository-forking"
 msgid "Enable this to allow non-admins to fork repositories."
 msgstr ""
 "Aktivieren Sie dies, um Nichtadministratoren zu erlauben, Repositories zu "
 "forken."
 msgid "Registration"
 msgstr "Registrierung"
 msgid "All IP addresses are allowed."
 msgstr "Alle IP-Adressen sind zulässig."
 msgid "New IP address"
 msgstr "Neue IP-Adresse"
 msgid "Repository Groups"
 msgstr "Repositorygruppen"
 msgid "Group name"
 msgstr "Gruppen name"
 msgid "Group parent"
 msgstr "Übergeordnete Gruppe"
 msgid "Copy parent group permissions"
 msgstr "Rechte der übergeordneten Gruppe kopieren"
 msgid "Copy permission set from parent repository group."
 msgstr "Rechte der übergeordneten Repositorygruppe kopieren."
 msgid "%s Repository Group Settings"
 msgstr "%s Einstellungen für Repositorygruppen"
 msgid "Add Child Group"
 msgstr "Untergruppe hinzufügen"
 msgid "Settings"
 msgstr "Einstellungen"
 msgid "Advanced"
 msgstr "Erweitert"
 msgid "Permissions"
 msgstr "Rechte"
 msgid "Repository Group: %s"
 msgstr "Repositorygruppe: %s"
 msgid "Top level repositories"
 msgstr "Repositories oberster Ebene"
 msgid "Total repositories"
 msgstr "Alle Repositories"
 msgid "Children groups"
 msgstr "Untergruppen"
 msgid "Created on"
 msgstr "Erstellt am"
 msgid "Confirm to delete this group: %s with %s repository"
 msgid_plural "Confirm to delete this group: %s with %s repositories"
 msgstr[0] "Löschen der Gruppe bestätigen: %s mit %s Repository"
 msgstr[1] "Löschen der Gruppe bestätigen: %s mit %s Repositories"
 msgid "Delete this repository group"
 msgstr "Diese Repositorygruppe löschen"
 msgid "Not visible"
 msgstr "Nicht sichtbar"
 msgid "Visible"
 msgstr "Sichtbar"
 msgid "Add/Edit groups"
 msgstr "Benutzergruppen hinzufügen oder ändern"
 msgid "Default"
 msgstr "Vorgabe"
 msgid "Revoke"
 msgstr "Zurückziehen"
 msgid "Add new"
 msgstr "Neues hinzufügen"
 msgid "Apply to children"
 msgstr "Auf untergeordnete Elemente anwenden"
 msgid "Both"
 msgstr "Beide"
 msgid ""
 "Set or revoke permission to all children of that group, including non-"
 "private repositories and other groups if selected."
 msgstr ""
 "Setzen oder zurückziehen von Berechtigungen bezüglich aller "
 "untergeordneten Elemente, einschließlich nicht-privater Repositories und "
 "anderer Gruppen, falls ausgewählt."
 msgid "Remove this group"
 msgstr "Diese Gruppe löschen"
 msgid "Confirm to delete this group"
 msgstr "Löschen der Gruppe bestätigen"
 msgid "Repository group %s"
 msgstr "Repository-Gruppe %s"
 msgid "Repository Groups Administration"
 msgstr "Repositorygruppenverwaltung"
 msgid "Number of Top-level Repositories"
 msgstr "Anzahl der Repositories oberster Ebene"
 msgid "Clone remote repository"
 msgstr "Entferntes Repository clonen"
 msgid ""
 "Optional: URL of a remote repository. If set, the repository will be "
 "created as a clone from this URL."
 msgstr ""
 "Optional: URL eines entfernten Repositories. Falls gesetzt, dann wird das "
 "Repository als Clon von dieser URL erstellt."
 msgid ""
 "Keep it short and to the point. Use a README file for longer descriptions."
 msgstr ""
 "Halten Sie es kurz und prägnant. Benutzen Sie eine README-Datei für "
 "längere Beschreibungen."
 msgid "Optionally select a group to put this repository into."
 msgstr ""
 "Wähle bei Bedarf eine Gruppe, der dieses Repository zugeordnet werden "
 "soll."
 msgid "Type of repository to create."
 msgstr "Repository Typ der erstellt werden soll."
 msgid "Landing revision"
 msgstr "Start Revision"
 msgid ""
 "Default revision for files page, downloads, full text search index and "
 "readme generation"
 msgstr ""
 "Vorgabe-Revision für Datei-Seiten, Downloads, Volltext-Indizierung und "
 "Doku-Erzeugung"
 msgid "%s Creating Repository"
 msgstr "%s Erstelle Repository"
 msgid "Creating repository"
 msgstr "Repository erzeugen"
 msgid ""
 "Repository \"%(repo_name)s\" is being created, you will be redirected "
 "when this process is finished.repo_name"
 msgstr ""
 "Repository \"%(repo_name)s\" wird erzeugt. Sie werden dorthin umgeleitet, "
 "sobald der Prozess abgeschlossen ist."
 msgid ""
 "We're sorry but error occurred during this operation. Please check your "
 "Kallithea server logs, or contact administrator."
 msgstr ""
 "Bedauerlicherweise ist bei dieser Operation ein Fehler aufgetreten. Bitte "
 "prüfen Sie die Kallithea-Server-Logs or kontaktieren Sie die "
 "Administrierenden."
 msgid "%s Repository Settings"
 msgstr "%s Repositoryeinstellungen"
 msgid "Extra Fields"
 msgstr "Extra-Feld"
 msgid "Remote"
 msgstr "Entfernt"
 msgid "Statistics"
 msgstr "Statistiken"
 msgid "Parent"
 msgstr "Übergeordnet"
 msgid "Set"
 msgstr "Setzen"
 msgid "Manually set this repository as a fork of another from the list."
 msgstr ""
 "Manuell dieses Repository als Fork einem anderen aus der List zuordnen."
 msgid "Public Journal Visibility"
 msgstr "Sichtbarkeit des öffentlichen Logbuches"
 msgid "Remove from public journal"
 msgstr "Entferne aus dem Öffentlichen Logbuch"
 msgid "Add to Public Journal"
 msgstr "Zum öffentlichen Logbuch hinzufügen"
 msgid ""
 "All actions done in this repository will be visible to everyone in the "
 "public journal."
 msgstr ""
 "Alle Aktionen, die in diesem Repository ausgeführt wurden, sind im "
 "öffentlichen Logbuch für jeden einsehbar."
 msgid "Confirm to delete this repository: %s"
 msgstr "Löschen des Repositorys bestätigen: %s"
 msgid "Delete this Repository"
 msgstr "Dieses Repository löschen"
 msgid "This repository has %s fork"
 msgid_plural "This repository has %s forks"
 msgstr[0] "Dieses Repository hat %s Fork"
 msgstr[1] "Dieses Repository hat %s Forks"
 msgid "Detach forks"
 msgstr "Fork abtrennen"
 msgid "Delete forks"
 msgstr "Forks löschen"
 msgid ""
 "The deleted repository will be moved away and hidden until the "
 "administrator expires it. The administrator can both permanently delete "
 "it or restore it."
 msgstr ""
 "Das gelöschte Repository wird beiseitegelegt und versteckt, bis ein "
 "Administrierender es verfallen lässt. Der Administrierende kann es sowohl "
 "permanent löschen oder wiederherstellen."
 msgid "Label"
 msgstr "Bezeichnung"
 msgid "Key"
 msgstr "Schlüssel"
 msgid "Confirm to delete this field: %s"
 msgstr "Löschen des Felds bestätigen: %s"
 msgid "New field key"
 msgstr "Eindeutiges Kennzeichen des neuen Felds"
 msgid "New field label"
 msgstr "Neue Bezeichnung des Felds"
 msgid "Enter short label"
 msgstr "Eingabe einer kurzen Bezeichnung"
 msgid "New field description"
 msgstr "Beschreibung des neuen Felds"
 msgid "Enter description of a field"
 msgstr "Beschreibung eines Felds eingeben"
 msgid "Extra fields are disabled."
 msgstr "Zusatzfelder sind deaktiviert."
 msgid "Private Repository"
 msgstr "Privates Repository"
 msgid "Fork of repository"
 msgstr "Fork des Repository"
 msgid "Remote repository URL"
 msgstr "URL des entfernten Repository"
 msgid "Pull Changes from Remote Repository"
 msgstr "Hole Änderungen vom entfernten Repository"
 msgid "Confirm to pull changes from remote repository."
 msgstr "Bestätige die Abholung von Änderungen vom entfernten Repository."
 msgid "This repository does not have a remote repository URL."
 msgstr "Für dieses Repository ist keine nicht-lokale URL angegeben."
 msgid ""
 "In case this repository is renamed or moved into another group the "
 "repository URL changes.\n"
 "                               Using the above permanent URL guarantees "
 "that this repository always will be accessible on that URL.\n"
 "                               This is useful for CI systems, or any "
 "other cases that you need to hardcode the URL into a 3rd party service."
 msgstr ""
 "Falls dieses Repository umbenannt oder in eine andere Gruppe verschoben "
 "wird, ändert sich seine URL.\n"
 "Die Verwendung der permanenten URL garantiert, dass dieses Repository "
 "immer über diese URL erreichbar sein wird.\n"
 "Dies ist insbesondere für CI-Systeme oder in Fällen nützlich, in denen "
 "die URL des Repositories bei Dritten dauerhaft eingetragen wird."
 msgid "Remote repository"
 msgstr "Entferntes Repository"
 msgid "Repository URL"
 msgstr "Repository URL"
 msgid ""
 "Optional: URL of a remote repository. If set, the repository can be "
 "pulled from this URL."
 msgstr ""
 "Optional: URL eines entfernten Repositories. Falls gesetzt, dann kann das "
 "Repository von dieser URL bezogen werden."
 msgid "Default revision for files page, downloads, whoosh and readme"
 msgstr "Standardrevision für Dateiseite, Downloads, Whoosh und Readme"
 msgid "Type name of user"
 msgstr "Typname des Benutzers"
 msgid "Change owner of this repository."
 msgstr "Besitzer des Repositorys ändern."
 msgid "Processed commits"
 msgstr "Verarbeitete Commits"
 msgid "Processed progress"
 msgstr "Verarbeiteter Fortschritt"
 msgid "Reset Statistics"
 msgstr "Statistiken zurücksetzen"
 msgid "Confirm to remove current statistics."
 msgstr "Bestätigen Sie, um die aktuellen Statistiken zu entfernen."
 msgid "Repositories Administration"
 msgstr "Repositoryverwaltung"
 msgid "State"
 msgstr "Zustand"
 msgid "Settings Administration"
 msgstr "Einstellungsverwaltung"
 msgid "VCS"
 msgstr "VCS"
 msgid "Remap and Rescan"
 msgstr "Neu zuordnen und neu scannen"
 msgid "Visual"
 msgstr "Visuell"
 msgid "Hooks"
 msgstr "Hooks"
 msgid "Full Text Search"
 msgstr "Volltextsuche"
 msgid "System Info"
 msgstr "Systeminfo"
 msgid "Send test email to"
 msgstr "Test-E-Mail senden an"
 msgid "Send"
 msgstr "Senden"
 msgid "Site branding"
 msgstr "Website-Branding"
 msgid "Set a custom title for your Kallithea Service."
 msgstr ""
 "Legen Sie einen benutzerdefinierten Titel für Ihren Kallithea-Dienst fest."
 msgid "HTTP authentication realm"
 msgstr "HTTP-Authentifizierungsrealm"
 msgid "HTML/JavaScript/CSS customization block"
 msgstr "HTML/JavaScript/CSS Anpassungsblock"
 msgid "ReCaptcha public key"
 msgstr "ReCaptcha öffentlicher Schlüssel"
 msgid "Public key for reCaptcha system."
 msgstr "Öffentlicher Schlüssel für das reCaptcha-System."
 msgid "ReCaptcha private key"
 msgstr "ReCaptcha privater Schlüssel"
 msgid ""
 "Private key for reCaptcha system. Setting this value will enable captcha "
 "on registration."
 msgstr ""
 "Privater Schlüssel für das reCaptcha-System. Wenn Sie diesen Wert "
 "einstellen, wird das Captcha bei der Registrierung aktiviert."
 msgid "Save Settings"
 msgstr "Einstellungen speichern"
 msgid "Built-in Mercurial Hooks (Read-Only)"
 msgstr "Eingebaute Mercurial Hooks (Read -Only)"
 msgid "Custom Hooks"
 msgstr "Benutzerdefinierte Hooks"
 msgid ""
 "Hooks can be used to trigger actions on certain events such as push / "
 "pull. They can trigger Python functions or external applications."
 msgstr ""
 "Mit Hilfe von Hooks können bei bestimmten Ereignissen, wie z.B. Push / "
 "Pull, Aktionen ausgelöst werden. Sie können Python-Funktionen oder "
 "externe Anwendungen auslösen."
 msgid "Failed to remove hook"
 msgstr "Hook konnte nicht entfernt werden"
 msgid "Delete records of missing repositories"
 msgstr "Datensätze fehlender Repositories löschen"
 msgid ""
 "Check this option to remove all comments, pull requests and other records "
 "related to repositories that no longer exist in the filesystem."
 msgstr ""
 "Aktivieren Sie diese Option, um alle Kommentare, Pull-Requests und andere "
 "Datensätze zu entfernen, die sich auf Repositories beziehen, die nicht "
 "mehr im Dateisystem vorhanden sind."
 msgid "Invalidate cache for all repositories"
 msgstr "Cache für alle Repositories entwerten"
 msgid "Check this to reload data and clear cache keys for all repositories."
 msgstr ""
 "Aktivieren Sie dies, um Daten neu zu laden und Cache-Schlüssel für alle "
 "Repositories zu löschen."
 msgid "Install Git hooks"
 msgstr "Git-Hooks installieren"
 msgid ""
 "Verify if Kallithea's Git hooks are installed for each repository. "
 "Current hooks will be updated to the latest version."
 msgstr ""
 "Überprüfen Sie, ob die Git-Hooks von Kallithea für jedes Repository "
 "installiert sind. Aktuelle Hooks werden auf die neueste Version "
 "aktualisiert."
 msgid "Overwrite existing Git hooks"
 msgstr "Bestehende Git-Hooks überschreiben"
 msgid ""
 "If installing Git hooks, overwrite any existing hooks, even if they do "
 "not seem to come from Kallithea. WARNING: This operation will destroy any "
 "custom git hooks you may have deployed by hand!"
 msgstr ""
 "Wenn Sie Git-Hooks installieren, überschreiben Sie alle vorhandenen "
 "Hooks, auch wenn sie nicht von Kallithea zu kommen scheinen. WARNUNG: "
 "Diese Operation zerstört alle benutzerdefinierten Git-Hooks, die Sie "
 "möglicherweise von Hand bereitgestellt haben!"
 msgid "Rescan Repositories"
 msgstr "Repositories erneut scannen"
 msgid "Index build option"
 msgstr "Option zum Aufbau eines Index"
 msgid "Build from scratch"
 msgstr "Von Grund auf neu bauen"
 msgid ""
-"This option completely reindexeses all of the repositories for proper "
+"This option completely reindexes all of the repositories for proper "
 "fulltext search capabilities."
 msgstr ""
 "Diese Option führt zu einer vollständigen Neuindizierung aller "
 "Repositories für eine korrekte Volltextsuche."
 msgid "Reindex"
 msgstr "Erneut Indizieren"
 msgid "Checking for updates..."
 msgstr "Prüfe auf Updates..."
 msgid "Kallithea version"
 msgstr "Kallithea-Version"
 msgid "Kallithea configuration file"
 msgstr "Kallithea Konfigurationsdatei"
 msgid "Python version"
 msgstr "Python-Version"
 msgid "Platform"
 msgstr "Plattform"
 msgid "Git version"
 msgstr "Git-Version"
 msgid "Git path"
 msgstr "Git-Pfad"
 msgid "Python Packages"
 msgstr "Python-Pakete"
 msgid "Show repository size after push"
 msgstr "Zeigt die Größe des Repositories nach dem Push an"
 msgid "Update repository after push (hg update)"
 msgstr "Repository nach dem Push aktualisieren (hg update)"
 msgid "Mercurial extensions"
 msgstr "Mercurial-Erweiterungen"
 msgid "Enable largefiles extension"
 msgstr "Erweiterung largefiles aktivieren"
 msgid "Location of repositories"
 msgstr "Ort der Repositories"
 msgid ""
 "Click to unlock. You must restart Kallithea in order to make this setting "
 "take effect."
 msgstr ""
 "Zum Entsperren klicken. Sie müssen Kallithea neu starten, damit diese "
 "Einstellung wirksam wird."
 msgid ""
 "Filesystem location where repositories are stored. After changing this "
 "value, a restart and rescan of the repository folder are both required."
 msgstr ""
 "Dateisystem-Speicherort, an dem die Repositories gespeichert sind. Nach "
 "dem Ändern dieses Wertes sind sowohl ein Neustart als auch ein erneuter "
 "Scan des Repository-Ordners erforderlich."
 msgid "General"
 msgstr "Allgemein"
 msgid "Use repository extra fields"
 msgstr "Zusätzliche Repository-Felder verwenden"
 msgid "Allows storing additional customized fields per repository."
 msgstr ""
 "Ermöglicht die Speicherung zusätzlicher benutzerdefinierter Felder pro "
 "Repository."
 msgid "Show Kallithea version"
 msgstr "Zeige Kallithea-Version"
 msgid ""
 "Shows or hides a version number of Kallithea displayed in the footer."
 msgstr ""
 "Zeigt oder verbirgt eine Versionsnummer von Kallithea, die in der "
 "Fußzeile angezeigt wird."
 msgid "Show user Gravatars"
 msgstr "Benutzer Gravatare anzeigen"
 msgid ""
 "Gravatar URL allows you to use another avatar server application.\n"
 "                                                        The following "
 "variables of the URL will be replaced accordingly.\n"
 "                                                        {scheme}    "
 "'http' or 'https' sent from running Kallithea server,\n"
 "                                                        {email}     user "
 "email,\n"
 "                                                        {md5email}  md5 "
 "hash of the user email (like at gravatar.com),\n"
 "                                                        {size}      size "
 "of the image that is expected from the server application,\n"
 "                                                        {netloc}    "
 "network location/server host of running Kallithea server"
 msgstr ""
 "Gravatar URL ermöglicht es Ihnen, eine andere Avatar-Serveranwendung zu "
 "verwenden.\n"
 "                                                        Die folgenden "
 "Variablen der URL werden entsprechend ersetzt.\n"
 "                                                        {scheme}    "
 "'http' oder'https', die vom laufenden Kallithea-Server gesendet werden,\n"
 "                                                        {email}    "
 "Benutzer-E-Mail,\n"
 "                                                        {md5email}  md5 "
 "Hash der Benutzer-E-Mail (wie bei gravatar.com),\n"
 "                                                        {size}       "
 "Größe des Bildes, das von der Serveranwendung erwartet wird,\n"
 "                                                        {netloc}    "
 "Netzwerkstandort/Server-Host des laufenden Kallithea-Servers"
 msgid ""
 "Number of items displayed in the repository pages before pagination is "
 "shown."
 msgstr ""
 "Anzahl der Elemente, die auf den Repository-Seiten angezeigt werden, "
 "bevor der Seitenumbruch angezeigt wird."
 msgid "Admin page size"
 msgstr "Größe der Admin-Seite"
 msgid ""
 "Number of items displayed in the admin pages grids before pagination is "
 "shown."
 msgstr ""
 "Anzahl der Elemente, die in den Gittern der Admin-Seiten angezeigt "
 "werden, bevor der Seitenumbruch angezeigt wird."
 msgid "Icons"
 msgstr "Icons"
 msgid "Show public repository icon on repositories"
 msgstr "Öffentliches Repository-Symbol in Repositories anzeigen"
 msgid "Show private repository icon on repositories"
 msgstr "Privates Repository-Symbol in Repositories anzeigen"
 msgid "Show public/private icons next to repository names."
 msgstr ""
 "Zeigt öffentliche/private Symbole neben den Namen der Repositories an."
 msgid ""
 "Parses meta tags from the repository description field and turns them "
 "into colored tags."
 msgstr ""
 "Analysiert Meta-Tags aus dem Beschreibungsfeld des Repositorys und "
 "verwandelt sie in farbige Tags."
 msgid "Stylify recognised meta tags:"
 msgstr "Erkannte Meta-Tags stilisieren:"
 msgid "Add user group"
 msgstr "Benutzergruppe hinzufügen"
 msgid "User Groups"
 msgstr "Benutzergruppen"
 msgid "Add User Group"
 msgstr "Benutzergruppe hinzufügen"
 msgid "Short, optional description for this user group."
 msgstr "Kurze, optionale Beschreibung für diese Benutzergruppe."
 msgid "Active"
 msgstr "Aktiv"
 msgid "User Group: %s"
 msgstr "Benutzergruppe: %s"
 msgid "Members"
 msgstr "Mitglieder"
 msgid "Confirm to delete this user group: %s"
 msgstr "Bestätigen, um diese Benutzergruppe zu löschen: %s"
 msgid "Delete this user group"
 msgstr "Diese Benutzergruppe löschen"
 msgid "No members yet"
 msgstr "Noch keine Mitglieder"
 msgid "Chosen group members"
 msgstr "Ausgewählte Grppenmitglieder"
 msgid "Available members"
 msgstr "Verfügbare Mitglieder"
 msgid "User Groups Administration"
 msgstr "Benutzergruppenverwaltung"
 msgid "Add user"
 msgstr "Benutzer hinzufügen"
 msgid "Users"
 msgstr "Benutzer"
 msgid "Add User"
 msgstr "Benutzer hinzufügen"
 msgid "Password confirmation"
 msgstr "Passwortbestätigung"
 msgid "Emails"
 msgstr "E-Mails"
 msgid "User: %s"
 msgstr "Benutzer: %s"
 msgid "Last Login"
 msgstr "Letzter Login"
 msgid "Member of User Groups"
 msgstr "Mitglieder der Benutzergruppe"
 msgid "Delete this user"
 msgstr "Diesen Benutzer löschen"
 msgid "Users Administration"
 msgstr "Benutzerverwaltung"
 msgid "Auth Type"
 msgstr "Authentifizierungsart"
 msgid "Support"
 msgstr "Support"
 msgid "Mercurial repository"
 msgstr "Mercurial Repository"
 msgid "Git repository"
 msgstr "Git Repository"
 msgid "Create Fork"
 msgstr "Fork erstellen"
 msgid "Summary"
 msgstr "Zusammenfassung"
 msgid "Files"
 msgstr "Dateien"
 msgid "Pull Requests"
 msgstr "Pull Requests"
 msgid "Options"
 msgstr "Optionen"
 msgid "Compare Fork"
 msgstr "Fork vergleichen"
 msgid "No matches found"
 msgstr "Keine Übereinstimmungen gefunden"
 msgid "Public journal"
 msgstr "Öffentliches Logbuch"
 msgid "My Pull Requests"
 msgstr "Meine Pull Requests"
 msgid "Not Logged In"
 msgstr "Nicht eingeloggt"
 msgid "Permission"
 msgstr "Rechte"
 msgid "Edit Permission"
 msgstr "Berechtigungen editieren"
 msgid "Add Another Comment"
 msgstr "Einen weiteren Kommentar hinzufügen"
 msgid "Group"
 msgstr "Gruppe"
 msgid "Confirm to revoke permission for {0}: {1} ?"
 msgstr "Widerruf der Rechte für {0}: {1} bestätigen?"
 msgid "Select changeset"
 msgstr "Änderungssätze auswählen"
 msgid "Specify changeset"
 msgstr "Changeset angeben"
 msgid "Click to sort ascending"
 msgstr "Klicken um Aufsteigend zu Sortieren"
 msgid "Click to sort descending"
 msgstr "Klicken um Absteigend zu Sortieren"
 msgid "No records found."
 msgstr "Keine Datensätze gefunden."
 msgid "Data error."
 msgstr "Datenfehler."
 msgid "Loading..."
 msgstr "Lade..."
 msgid "Go to tip of repository"
 msgstr "Gehe zum Tip des Repositorys"
 msgid "There are no changes yet"
 msgstr "Bisher gibt es keine Änderungen"
 msgid "Branch %s"
 msgstr "Branch %s"
 msgid "No title"
 msgstr "Kein Titel"
 msgid "Delete comment?"
 msgstr "Kommentar löschen?"
 msgid "Set changeset status"
 msgstr "Setze Changesetstatus"
 msgid "No change"
 msgstr "Keine Änderungen"
 msgid "Close"
 msgstr "Schließen"
 msgid "Comment"
 msgstr "Kommentar"
 msgid "%d comment"
 msgid_plural "%d comments"
 msgstr[0] "%d Kommentar"
 msgstr[1] "%d Kommentare"
 msgid "%d inline"
 msgid_plural "%d inline"
 msgstr[0] "%d inline"
 msgstr[1] "%d inline"
 msgid "%d general"
 msgid_plural "%d general"
 msgstr[0] "%d generell"
 msgstr[1] "%d generell"
 msgid "Deleted"
 msgstr "Gelöscht"
 msgid "Renamed"
 msgstr "Umbenannt"
 msgid "%s changesets"
 msgstr "%s Changesets"
 msgid "behind"
 msgstr "zurück"
 msgid "Public repository"
 msgstr "Öffenentliches Repository"
 msgid "Subscribe to %s rss feed"
 msgstr "Abonniere den %s RSS Feed"
 msgid "Subscribe to %s atom feed"
 msgstr "Abonniere den %s ATOM Feed"
 msgid "Hello %s"
 msgstr "Hallo %s"
 msgid "or"
 msgstr "oder"
 msgid "Upload File"
 msgstr "Datei hochladen"
 msgid "Commit Changes"
 msgstr "Änderungen einchecken"
 msgid "Size"
 msgstr "Größe"
 msgid "Last Modified"
 msgstr "Zuletzt geändert"
 msgid "Delete file"
 msgstr "Datei löschen"
 msgid "%s author"
 msgid_plural "%s authors"
 msgstr[0] "%s Autor"
 msgstr[1] "%s Autoren"
 msgid "Go Back"
 msgstr "Zurück"
 msgid "Private"
 msgstr "Privat"
 msgid "Copy permissions"
 msgstr "Berechtigungen kopieren"
 msgid "ATOM journal feed"
 msgstr "ATOM Logbuch Feed"
 msgid "RSS journal feed"
 msgstr "RSS Logbuch Feed"
 msgid "My Repositories"
 msgstr "Meine Repositories"
 msgid "ATOM public journal feed"
 msgstr "ATOM Feed für das Öffentliche Logbuch"
 msgid "RSS public journal feed"
 msgstr "RSS Feed für das Öffentliche Logbuch"
 msgid "New Pull Request"
 msgstr "Neuer Pull Request"
 msgid "Title"
 msgstr "Titel"
 msgid "Revision"
 msgstr "Revision"
 msgid "Age"
 msgstr "Alter"
 msgid "Delete Pull Request"
 msgstr "Pull Request löschen"
 msgid "Summarize the changes"
 msgstr "Zusammenfassung der Änderungen"
 msgid "on"
 msgstr "in"
 msgid "Cancel Changes"
 msgstr "Änderungen verwerfen"
 msgid "Remove reviewer"
 msgstr "Reviewer entfernen"
 msgid "Potential Reviewers"
 msgstr "Potentielle Reviewer"
 msgid "Pull Request Content"
 msgstr "Inhalt des Pull Requests"
 msgid "Pull Requests to '%s'"
 msgstr "Pull Requests für '%s'"
 msgid "Open New Pull Request"
 msgstr "Einen neuen Pull Request eröffnen"
 msgid "Show Pull Requests to %s"
 msgstr "Zeige Pull Requests für '%s'"
 msgid "Show Pull Requests from '%s'"
 msgstr "Zeige Pull Requests von '%s'"
 msgid "Pull Requests Created by Me"
 msgstr "Von mir erstellte Pull Requests"
 msgid "Search in All Repositories"
 msgstr "Suche in allen Repositories"
 msgid "Search term"
 msgstr "Suchbegriff"
 msgid "Search in"
 msgstr "Suchen in"
 msgid "File contents"
 msgstr "Dateiinhalt"
 msgid "Commit messages"
 msgstr "Commit Nachrichten"
 msgid "File names"
 msgstr "Dateinamen"
 msgid "Permission denied"
 msgstr "Zugriff verweigert"
 msgid "Enable"
 msgstr "Aktiviere"
 msgid "files"
 msgstr "Dateien"
 msgid "Show more"
 msgstr "Mehr anzeigen"
 msgid "commits"
 msgstr "Commits"
 msgid "files added"
 msgstr "Dateien hinzugefügt"
 msgid "files changed"
 msgstr "Dateien geändert"
 msgid "files removed"
 msgstr "Dateien entfernt"
 msgid "commit"
 msgstr "Commit"
 msgid "file added"
 msgstr "Datei hinzugefügt"
 msgid "file changed"
 msgstr "Datei geändert"
 msgid "file removed"
 msgstr "Datei entfernt"
 msgid "Clone from"
 msgstr "Clone von"
 msgid "Clone URL"
 msgstr "Clone-URL"
 msgid "Download as zip"
 msgstr "Herunterladen als zip"
 msgid "Feed"
 msgstr "Feed"
 msgid "Latest Changes"
 msgstr "Letzte Änderungen"
 msgid "Quick Start"
 msgstr "Schnelleinstieg"
 msgid "Add or upload files directly via Kallithea"
 msgstr "Dateien direkt über Kallithea hinzufügen oder hochladen"
 msgid "Readme file from revision %s:%s"
 msgstr "Liesmich-Datei von Revision %s:%s"
 msgid "Download %s as %s"
 msgstr "%s als %s herunterladen"

kallithea/i18n/el/LC_MESSAGES/kallithea.po

➞

Show inline comments

@@ @@ -668,2907 +668,2907 @@ msgid "Binary file" @@
 msgstr "Δυαδικό αρχείο"
 msgid ""
 "Changeset was too big and was cut off, use diff menu to display this diff"
 msgstr ""
 "Το σετ αλλαγών ήταν πολύ μεγάλο και αποκόπηκε, χρησιμοποιήστε το μενού "
 "διαφορών για να εμφανίσετε τις διαφορές"
 msgid "No changes detected"
 msgstr "Δεν εντοπίστηκαν αλλαγές"
 msgid "Deleted branch: %s"
 msgstr "Διαγραφή κλάδου: %s"
 msgid "Created tag: %s"
 msgstr "Δημιουργηθείσα ετικέτα: %s"
 msgid "Changeset %s not found"
 msgstr "Δεν βρέθηκε το σετ αλλαγών %s"
 msgid "Show all combined changesets %s->%s"
 msgstr "Εμφάνιση όλων των συνδυασμένων σετ αλλαγών %s->%s"
 msgid "Compare view"
 msgstr "Σύγκριση εμφάνισης"
 msgid "and"
 msgstr "και"
 msgid "%s more"
 msgstr "%s επιπλέον"
 msgid "revisions"
 msgstr "αναθεωρήσεις"
 msgid "Fork name %s"
 msgstr "Όνομα κλώνου %s"
 msgid "Pull request %s"
 msgstr "Αίτημα έλξης %s"
 msgid "[deleted] repository"
 msgstr "[διαγραμμένο] αποθετήριο"
 msgid "[created] repository"
 msgstr "[δημιουργημένο] αποθετήριο"
 msgid "[updated] repository"
 msgstr "[ενημερωμένο] αποθετήριο"
 msgid "[downloaded] archive from repository"
 msgstr "[λήψη] αρχείο από το αποθετήριο"
 msgid "[delete] repository"
 msgstr "[διαγραμμένο] αποθετήριο"
 msgid " and %s more"
 msgstr " και %s περισσότερα"
 msgid "No files"
 msgstr "Δεν υπάρχουν αρχεία"
 msgid "new file"
 msgstr "νέο αρχείο"
 msgid "mod"
 msgstr "τροποποιημένο"
 msgid "del"
 msgstr "διαγραμμένο"
 msgid "rename"
 msgstr "μετονομασμένο"
 msgid "chmod"
 msgstr "αλλ δικαιωμ"
 msgid ""
 "%s repository is not mapped to db perhaps it was created or renamed from "
 "the filesystem please run the application again in order to rescan "
 "repositories"
 msgstr ""
 "Το αποθετήριο δεδομένων %s δεν έχει αντιστοιχιστεί στη βάση δεδομένων. "
 "Ίσως δημιουργήθηκε ή μετονομάστηκε από το σύστημα αρχείων. Εκτελέστε ξανά "
 "την εφαρμογή για να σαρώσετε ξανά τα αποθετήρια δεδομένων"
 msgid "SSH key is missing"
 msgstr "Το κλειδί SSH λείπει"
 msgid ""
 "Incorrect SSH key - it must have both a key type and a base64 part, like "
 "'ssh-rsa ASRNeaZu4FA...xlJp='"
 msgstr ""
 "Λανθασμένο κλειδί SSH - πρέπει να έχει έναν τύπο κλειδιού καθώς και ένα "
 "τμήμα base64, όπως \"ssh-rsa ASRNeaZu4FA ... xlJp =\""
 msgid "Incorrect SSH key - it must start with 'ssh-(rsa|dss|ed25519)'"
 msgstr "Εσφαλμένο κλειδί SSH - πρέπει να ξεκινά με 'ssh-(rsa|dss|ed25519)'"
 msgid "Incorrect SSH key - unexpected characters in base64 part %r"
 msgstr ""
 "Εσφαλμένο κλειδί SSH - μη αναμενόμενοι χαρακτήρες στο τμήμα base64 %r"
 msgid "Incorrect SSH key - failed to decode base64 part %r"
 msgstr ""
 "Εσφαλμένο κλειδί SSH - απέτυχε η αποκωδικοποίηση του τμήματος base64 %r"
 msgid "Incorrect SSH key - base64 part is not %r as claimed but %r"
 msgstr ""
 "Εσφαλμένο κλειδί SSH - το base64 μέρος δεν είναι %r όπως ζητήθηκε, αλλά %r"
 msgid "%d year"
 msgid_plural "%d years"
 msgstr[0] "%d έτος"
 msgstr[1] "%d έτη"
 msgid "%d month"
 msgid_plural "%d months"
 msgstr[0] "%d μήνας"
 msgstr[1] "%d μήνες"
 msgid "%d day"
 msgid_plural "%d days"
 msgstr[0] "%d ημέρα"
 msgstr[1] "%d ημέρες"
 msgid "%d hour"
 msgid_plural "%d hours"
 msgstr[0] "%d ώρα"
 msgstr[1] "%d ώρες"
 msgid "%d minute"
 msgid_plural "%d minutes"
 msgstr[0] "%d λεπτό"
 msgstr[1] "%d λεπτά"
 msgid "%d second"
 msgid_plural "%d seconds"
 msgstr[0] "%d δευτερόλεπτο"
 msgstr[1] "%d δευτερόλεπτα"
 msgid "in %s"
 msgstr "σε %s"
 msgid "%s ago"
 msgstr "%s πριν"
 msgid "in %s and %s"
 msgstr "σε %s και %s"
 msgid "%s and %s ago"
 msgstr "%s και %s πριν"
 msgid "just now"
 msgstr "μόλις τώρα"
 msgid "on line %s"
 msgstr "στη γραμμή %s"
 msgid "[Mention]"
 msgstr "[Αναφορά]"
 msgid "top level"
 msgstr "ανώτερο επίπεδο"
 msgid "Kallithea Administrator"
 msgstr "Διαχειριστής Καλλιθέας"
 msgid "Default user has no access to new repositories"
 msgstr "Ο προεπιλεγμένος χρήστης δεν έχει πρόσβαση σε νέα αποθετήρια"
 msgid "Default user has read access to new repositories"
 msgstr "Ο προεπιλεγμένος χρήστης έχει πρόσβαση ανάγνωσης σε νέα αποθετήρια"
 msgid "Default user has write access to new repositories"
 msgstr "Ο προεπιλεγμένος χρήστης έχει πρόσβαση εγγραφής σε νέα αποθετήρια"
 msgid "Default user has admin access to new repositories"
 msgstr ""
 "Ο προεπιλεγμένος χρήστης έχει πρόσβαση διαχειριστή σε νέα αποθετήρια"
 msgid "Default user has no access to new repository groups"
 msgstr ""
 "Ο προεπιλεγμένος χρήστης δεν έχει πρόσβαση σε νέες ομάδες αποθετηρίων"
 msgid "Default user has read access to new repository groups"
 msgstr ""
 "Ο προεπιλεγμένος χρήστης έχει πρόσβαση ανάγνωσης σε νέες ομάδες "
 "αποθετηρίων"
 msgid "Default user has write access to new repository groups"
 msgstr ""
 "Ο προεπιλεγμένος χρήστης έχει πρόσβαση εγγραφής σε νέες ομάδες αποθετηρίων"
 msgid "Default user has admin access to new repository groups"
 msgstr ""
 "Ο προεπιλεγμένος χρήστης έχει πρόσβαση διαχειριστή σε νέες ομάδες "
 "αποθετηρίων"
 msgid "Default user has no access to new user groups"
 msgstr "Ο προεπιλεγμένος χρήστης δεν έχει πρόσβαση σε νέες ομάδες χρηστών"
 msgid "Default user has read access to new user groups"
 msgstr ""
 "Ο προεπιλεγμένος χρήστης έχει πρόσβαση ανάγνωσης σε νέες ομάδες χρηστών"
 msgid "Default user has write access to new user groups"
 msgstr ""
 "Ο προεπιλεγμένος χρήστης έχει πρόσβαση εγγραφής σε νέες ομάδες χρηστών"
 msgid "Default user has admin access to new user groups"
 msgstr ""
 "Ο προεπιλεγμένος χρήστης έχει πρόσβαση διαχειριστή σε νέες ομάδες χρηστών"
 msgid "Only admins can create repository groups"
 msgstr "Μόνο οι διαχειριστές μπορούν να δημιουργήσουν ομάδες αποθετηρίων"
 msgid "Non-admins can create repository groups"
 msgstr "Οι μη διαχειριστές μπορούν να δημιουργήσουν ομάδες αποθετηρίων"
 msgid "Only admins can create user groups"
 msgstr "Μόνο οι διαχειριστές μπορούν να δημιουργήσουν ομάδες χρηστών"
 msgid "Non-admins can create user groups"
 msgstr "Οι μη διαχειριστές μπορούν να δημιουργήσουν ομάδες χρηστών"
 msgid "Only admins can create top level repositories"
 msgstr ""
 "Μόνο οι διαχειριστές μπορούν να δημιουργήσουν αποθετήρια ανώτατου επιπέδου"
 msgid "Non-admins can create top level repositories"
 msgstr ""
 "Οι μη διαχειριστές μπορούν να δημιουργήσουν αποθετήρια ανώτατου επιπέδου"
 msgid ""
 "Repository creation enabled with write permission to a repository group"
 msgstr ""
 "Η δημιουργία αποθετηρίου είναι ενεργοποιημένη με δικαιώματα εγγραφής σε "
 "μια ομάδα αποθετηρίων"
 msgid ""
 "Repository creation disabled with write permission to a repository group"
 msgstr ""
 "Η δημιουργία αποθετηρίου απενεργοποιήθηκε με δικαιώματα εγγραφής σε μια "
 "ομάδα αποθετηρίων"
 msgid "Registration disabled"
 msgstr "Η εγγραφή απενεργοποιήθηκε"
 msgid "User registration with manual account activation"
 msgstr "Εγγραφή χρήστη με χειροκίνητη ενεργοποίηση λογαριασμού"
 msgid "User registration with automatic account activation"
 msgstr "Εγγραφή χρήστη με αυτόματη ενεργοποίηση λογαριασμού"
 msgid "Not reviewed"
 msgstr "Δεν έχει ελεγχθεί"
 msgid "Under review"
 msgstr "Υπό εξέταση"
 msgid "Not approved"
 msgstr "Δεν έχει εγκριθεί"
 msgid "Approved"
 msgstr "Εγκρίθηκε"
 msgid "Please enter a login"
 msgstr "Παρακαλώ εισάγετε ένα όνομα χρήστη"
 msgid "Enter a value %(min)i characters long or more"
 msgstr "Εισαγάγετε μια τιμή με μήκος %(min)i χαρακτήρες ή περισσότερους"
 msgid "Please enter a password"
 msgstr "Παρακαλώ εισάγετε έναν κωδικό πρόσβασης"
 msgid "Enter %(min)i characters or more"
 msgstr "Εισαγάγετε %(min)i χαρακτήρες ή περισσότερους"
 msgid "Name must not contain only digits"
 msgstr "Το όνομα δεν πρέπει να περιέχει μόνο ψηφία"
 msgid "New user %(new_username)s registered"
 msgstr "Καταχωρήθηκε νέος χρήστης %(new_username)s"
 msgid "Closing"
 msgstr "Κλείσιμο"
 msgid ""
 "%(user)s wants you to review pull request %(pr_nice_id)s: %(pr_title)s"
 msgstr ""
 "Ο χρήστης %(user)s θέλει να αναθεωρήσετε την αίτηση έλξης %(pr_nice_id)s: "
 "%(pr_title)s"
 msgid "Cannot create empty pull request"
 msgstr "Δεν είναι δυνατή η δημιουργία κενής αίτησης έλξης"
 msgid ""
 "Cannot create pull request - criss cross merge detected, please merge a "
 "later %s revision to %s"
 msgstr ""
 "Δεν είναι δυνατή η δημιουργία αίτησης έλξης - εντοπίστηκε διασταυρούμενη "
 "συγχώνευση, παρακαλώ συγχωνεύστε μια μεταγενέστερη αναθεώρηση %s στο %s"
 msgid "You are not authorized to create the pull request"
 msgstr "Δεν έχετε εξουσιοδότηση για τη δημιουργία του αιτήματος έλξης"
 msgid "Missing changesets since the previous iteration:"
 msgstr "Λείπουν σετ αλλαγών από την προηγούμενη επανάληψη:"
 msgid "New changesets on %s %s since the previous iteration:"
 msgstr "Νέα σετ αλλαγών στο %s %s από την προηγούμενη επανάληψη:"
 msgid "Ancestor didn't change - diff since previous iteration:"
 msgstr "Ο πρόγονος δεν άλλαξε - διαφορά από την προηγούμενη επανάληψη:"
 msgid ""
 "This iteration is based on another %s revision and there is no simple "
 "diff."
 msgstr ""
 "Αυτή η επανάληψη βασίζεται σε μια άλλη αναθεώρηση %s και δεν υπάρχει απλή "
 "διαφορά."
 msgid "No changes found on %s %s since previous iteration."
 msgstr "Δεν βρέθηκαν αλλαγές στο %s %s από την προηγούμενη έκδοση."
 msgid "Closed, next iteration: %s ."
 msgstr "Κλειστή, επόμενη επανάληψη: %s ."
 msgid "latest tip"
 msgstr "τελευταία κεφαλή"
 msgid "SSH key %r is invalid: %s"
 msgstr "Το κλειδί SSH %r δεν είναι έγκυρο: %s"
 msgid "SSH key %s is already used by %s"
 msgstr "Το κλειδί SSH %s χρησιμοποιείται ήδη από το χρήστη %s"
 msgid "SSH key with fingerprint %r found"
 msgstr "Βρέθηκε κλειδί SSH με δακτυλικό αποτύπωμα %r"
 msgid "New user registration"
 msgstr "Εγγραφή νέου χρήστη"
 msgid ""
 "You can't remove this user since it is crucial for the entire application"
 msgstr ""
 "Δεν μπορείτε να καταργήσετε αυτόν το χρήστη, καθώς είναι ζωτικής σημασίας "
 "για ολόκληρη την εφαρμογή"
 msgid ""
 "User \"%s\" still owns %s repositories and cannot be removed. Switch "
 "owners or remove those repositories: %s"
 msgstr ""
 "Ο χρήστης \"%s\" εξακολουθεί να κατέχει %s αποθετήρια και δεν είναι "
 "δυνατόν να αφαιρεθεί. Αλλάξτε κάτοχο ή καταργείστε αυτά τα αποθετήρια: %s"
 msgid ""
 "User \"%s\" still owns %s repository groups and cannot be removed. Switch "
 "owners or remove those repository groups: %s"
 msgstr ""
 "Ο χρήστης \"%s\" εξακολουθεί να κατέχει %s ομάδες αποθετηρίων και δεν "
 "είναι δυνατόν να αφαιρεθεί. Αλλάξτε κάτοχο ή καταργείστε αυτές τις "
 "ομάδες: %s"
 msgid ""
 "User \"%s\" still owns %s user groups and cannot be removed. Switch "
 "owners or remove those user groups: %s"
 msgstr ""
 "Ο χρήστης \"%s\" εξακολουθεί να κατέχει %s ομάδες χρηστών και δεν είναι "
 "δυνατόν να αφαιρεθεί. Αλλάξτε κάτοχο ή αφαιρέστε αυτές τις ομάδες "
 "χρηστών: %s"
 msgid "Password reset link"
 msgstr "Σύνδεσμος επαναφοράς κωδικού πρόσβασης"
 msgid "Password reset notification"
 msgstr "Ειδοποίηση επαναφοράς κωδικού πρόσβασης"
 msgid ""
 "The password to your account %s has been changed using password reset "
 "form."
 msgstr ""
 "Ο κωδικός πρόσβασης στο λογαριασμό σας %s έχει αλλάξει χρησιμοποιώντας τη "
 "φόρμα επαναφοράς κωδικού πρόσβασης."
 msgid "Value cannot be an empty list"
 msgstr "Η τιμή δεν μπορεί να είναι μια κενή λίστα"
 msgid "Username \"%(username)s\" already exists"
 msgstr "Το όνομα χρήστη \"%(username)s\" υπάρχει ήδη"
 msgid "Username \"%(username)s\" cannot be used"
 msgstr "Δεν είναι δυνατή η χρήση του ονόματος χρήστη \"%(username)s\""
 msgid ""
 "Username may only contain alphanumeric characters underscores, periods or "
 "dashes and must begin with an alphanumeric character or underscore"
 msgstr ""
 "Το όνομα χρήστη μπορεί να περιέχει μόνο αλφαριθμητικούς χαρακτήρες, κάτω "
 "παύλες, τελείες ή παύλες και πρέπει να ξεκινά με αλφαριθμητικό χαρακτήρα "
 "ή κάτω παύλα"
 msgid "The input is not valid"
 msgstr "Η είσοδος δεν είναι έγκυρη"
 msgid "Username %(username)s is not valid"
 msgstr "Το όνομα χρήστη %(username)s δεν είναι έγκυρο"
 msgid "Invalid user group name"
 msgstr "Μη έγκυρο όνομα ομάδας χρηστών"
 msgid "User group \"%(usergroup)s\" already exists"
 msgstr "Η ομάδα χρηστών \"%(usergroup)s\" υπάρχει ήδη"
 msgid ""
 "user group name may only contain alphanumeric characters underscores, "
 "periods or dashes and must begin with alphanumeric character"
 msgstr ""
 "Το όνομα της ομάδας χρηστών μπορεί να περιέχει μόνο αλφαριθμητικούς "
 "χαρακτήρες, κάτω παύλες, τελείες ή παύλες και πρέπει να ξεκινά με "
 "αλφαριθμητικό χαρακτήρα"
 msgid "Cannot assign this group as parent"
 msgstr "Δεν είναι δυνατή η εκχώρηση αυτής της ομάδας ως γονικής"
 msgid "Group \"%(group_name)s\" already exists"
 msgstr "Η ομάδα \"%(group_name)s\" υπάρχει ήδη"
 msgid "Repository with name \"%(group_name)s\" already exists"
 msgstr "Το αποθετήριο με όνομα \"%(group_name)s\" υπάρχει ήδη"
 msgid "Invalid characters (non-ascii) in password"
 msgstr "Μη έγκυροι χαρακτήρες (μη ascii) στον κωδικό πρόσβασης"
 msgid "Invalid old password"
 msgstr "Ο παλιός κωδικός πρόσβασης δεν είναι έγκυρος"
 msgid "Passwords do not match"
 msgstr "Οι κωδικοί πρόσβασης δεν ταιριάζουν"
 msgid "Invalid username or password"
 msgstr "Το όνομα χρήστη ή ο κωδικός πρόσβασης δεν είναι έγκυρος"
 msgid "Repository name %(repo)s is not allowed"
 msgstr "Δεν επιτρέπεται το %(repo)s ως όνομα του αποθετηρίου"
 msgid "Repository named %(repo)s already exists"
 msgstr "Το αποθετήριο με το όνομα %(repo)s υπάρχει ήδη"
 msgid "Repository \"%(repo)s\" already exists in group \"%(group)s\""
 msgstr "Το αποθετήριο \"%(repo)s\" υπάρχει ήδη στην ομάδα \"%(group)s\""
 msgid "Repository group with name \"%(repo)s\" already exists"
 msgstr "Η ομάδα αποθετηρίου με το όνομα \"%(repo)s\" υπάρχει ήδη"
 msgid "Invalid repository URL"
 msgstr "Μη έγκυρη διεύθυνση URL αποθετηρίου"
 msgid "You don't have permissions to create repository in this group"
 msgstr "Δεν έχετε δικαιώματα δημιουργίας αποθετηρίου σε αυτήν την ομάδα"
 msgid "no permission to create repository in root location"
 msgstr "Δεν υπάρχει δικαίωμα δημιουργίας αποθετηρίου στη ριζική τοποθεσία"
 msgid "You don't have permissions to create a group in this location"
 msgstr "Δεν έχετε δικαιώματα δημιουργίας ομάδας σε αυτήν την τοποθεσία"
 msgid "This username or user group name is not valid"
 msgstr "Αυτό το όνομα χρήστη ή το όνομα ομάδας χρηστών δεν είναι έγκυρο"
 msgid "This is not a valid path"
 msgstr "Αυτή η διαδρομή δεν είναι έγκυρη"
 msgid "This email address is already in use"
 msgstr "Αυτή η διεύθυνση ηλεκτρονικού ταχυδρομείου χρησιμοποιείται ήδη"
 msgid "Email address \"%(email)s\" not found"
 msgstr "Η διεύθυνση ηλεκτρονικού ταχυδρομείου \"%(email)s\" δεν βρέθηκε"
 msgid ""
 "The LDAP Login attribute of the CN must be specified - this is the name "
 "of the attribute that is equivalent to \"username\""
 msgstr ""
 "Πρέπει να προσδιοριστεί το χαρακτηριστικό LDAP Login του CN - αυτό είναι "
 "το όνομα του χαρακτηριστικού που είναι ισοδύναμο με το \"όνομα χρήστη\""
 msgid "Please enter a valid IPv4 or IPv6 address"
 msgstr "Παρακαλώ εισαγάγετε μια έγκυρη διεύθυνση IPv4 ή IPv6"
 msgid ""
 "The network size (bits) must be within the range of 0-32 (not %(bits)r)"
 msgstr ""
 "Το μέγεθος δικτύου (bits) πρέπει να βρίσκεται εντός της περιοχής 0-32 "
 "(όχι %(bits)r)"
 msgid "Key name can only consist of letters, underscore, dash or numbers"
 msgstr ""
 "Το όνομα κλειδιού μπορεί να αποτελείται μόνο από γράμματα, κάτω παύλα, "
 "παύλα ή αριθμούς"
 msgid "Filename cannot be inside a directory"
 msgstr "Το όνομα αρχείου δεν μπορεί να βρίσκεται μέσα σε έναν κατάλογο"
 msgid "Plugins %(loaded)s and %(next_to_load)s both export the same name"
 msgstr ""
 "Τα πρόσθετα %(loaded)s και %(next_to_load)s εξάγουν και τα δύο το ίδιο "
 "όνομα"
 msgid "About"
 msgstr "Σχετικά"
 msgid "Add Repository"
 msgstr "Προσθήκη Αποθετηρίου"
 msgid "Add Repository Group"
 msgstr "Προσθήκη Ομάδας Αποθετηρίων"
 msgid "You have admin right to this group, and can edit it"
 msgstr ""
 "Έχετε δικαίωμα διαχειριστή σε αυτήν την ομάδα και μπορείτε να την "
 "επεξεργαστείτε"
 msgid "Edit Repository Group"
 msgstr "Επεξεργασία Ομάδας Αποθετηρίων"
 msgid "Repository"
 msgstr "Αποθετήριο"
 msgid "Description"
 msgstr "Περιγραφή"
 msgid "Last Change"
 msgstr "Τελευταία Αλλαγή"
 msgid "Tip"
 msgstr "Κεφαλή"
 msgid "Owner"
 msgstr "Κάτοχος"
 msgid "Log In"
 msgstr "Σύνδεση"
 msgid "Log In to %s"
 msgstr "Συνδεθείτε στο %s"
 msgid "Username"
 msgstr "Όνομα χρήστη"
 msgid "Password"
 msgstr "Κωδικό πρόσβασης"
 msgid "Stay logged in after browser restart"
 msgstr ""
 "Μείνετε συνδεδεμένοι μετά την επανεκκίνηση του προγράμματος περιήγησης"
 msgid "Forgot your password ?"
 msgstr "Ξεχάσατε τον κωδικό σας;"
 msgid "Don't have an account ?"
 msgstr "Δεν έχετε λογαριασμό;"
 msgid "Sign In"
 msgstr "Είσοδος"
 msgid "Password Reset"
 msgstr "Επαναφορά κωδικού"
 msgid "Reset Your Password to %s"
 msgstr "Επαναφορά του κωδικού πρόσβασής σας στο %s"
 msgid "Reset Your Password"
 msgstr "Επαναφορά του κωδικού πρόσβασής σας"
 msgid "Email Address"
 msgstr "Διεύθυνση ηλεκτρονικού ταχυδρομείου"
 msgid "Captcha"
 msgstr "Captcha"
 msgid "Send Password Reset Email"
 msgstr ""
 "Αποστολή μηνύματος ηλεκτρονικού ταχυδρομείου για την επαναφορά του "
 "κωδικού πρόσβασης"
 msgid ""
 "A password reset link will be sent to the specified email address if it "
 "is registered in the system."
 msgstr ""
 "Ένας σύνδεσμος για την επαναφορά του κωδικού πρόσβασης θα σταλεί στην "
 "καθορισμένη διεύθυνση ηλεκτρονικού ταχυδρομείου, εάν έχει καταχωρηθεί στο "
 "σύστημα."
 msgid "You are about to set a new password for the email address %s."
 msgstr ""
 "Πρόκειται να ορίσετε έναν νέο κωδικό πρόσβασης για τη διεύθυνση "
 "ηλεκτρονικού ταχυδρομείου %s."
 msgid ""
 "Note that you must use the same browser session for this as the one used "
 "to request the password reset."
 msgstr ""
 "Λάβετε υπόψη ότι πρέπει να χρησιμοποιήσετε την ίδια περίοδο λειτουργίας "
 "του προγράμματος περιήγησης με αυτήν που χρησιμοποιήθηκε για να ζητήσετε "
 "την επαναφορά του κωδικού πρόσβασης."
 msgid "Code you received in the email"
 msgstr "Κωδικός που λάβατε στο μήνυμα ηλεκτρονικού ταχυδρομείου"
 msgid "New Password"
 msgstr "Νέος Κωδικός"
 msgid "Confirm New Password"
 msgstr "Επιβεβαίωση Νέου Κωδικού Πρόσβασης"
 msgid "Confirm"
 msgstr "Επιβεβαίωση"
 msgid "Sign Up"
 msgstr "Εγγραφή"
 msgid "Sign Up to %s"
 msgstr "Εγγραφείτε στο %s"
 msgid "Re-enter password"
 msgstr "Εισαγάγετε ξανά τον κωδικό πρόσβασης"
 msgid "First Name"
 msgstr "Όνομα"
 msgid "Last Name"
 msgstr "Επώνυμο"
 msgid "Email"
 msgstr "Διεύθυνση Ηλεκτρονικού Ταχυδρομείου"
 msgid "Registered accounts are ready to use and need no further action."
 msgstr ""
 "Οι εγγεγραμμένοι λογαριασμοί είναι έτοιμοι για χρήση και δεν χρειάζονται "
 "περαιτέρω ενέργειες."
 msgid "Please wait for an administrator to activate your account."
 msgstr ""
 "Περιμένετε έως ότου ένας διαχειριστής ενεργοποιήσει τον λογαριασμό σας."
 msgid "Admin Journal"
 msgstr "Ημερολόγιο Διαχειριστή"
 msgid "journal filter..."
 msgstr "φίλτρο εγγραφών..."
 msgid "Filter"
 msgstr "Φίλτρο"
 msgid "%s Entry"
 msgid_plural "%s Entries"
 msgstr[0] "%s Καταχώρηση"
 msgstr[1] "%s Καταχωρήσεις"
 msgid "Action"
 msgstr "Ενέργεια"
 msgid "Date"
 msgstr "Ημερομηνία"
 msgid "From IP"
 msgstr "Από IP"
 msgid "No actions yet"
 msgstr "Καμία ενέργεια ακόμα"
 msgid "Authentication Settings"
 msgstr "Ρυθμίσεις ελέγχου ταυτότητας"
 msgid "Authentication"
 msgstr "Έλεγχος ταυτότητας"
 msgid "Authentication Plugins"
 msgstr "Πρόσθετα ελέγχου ταυτότητας"
 msgid "Enabled Plugins"
 msgstr "Ενεργοποιημένα Πρόσθετα"
 msgid ""
 "Comma-separated list of plugins; Kallithea will try user authentication "
 "in plugin order"
 msgstr ""
 "Λίστα πρόσθετων διαχωρισμένη με κόμματα. Η Καλλιθέα θα προσπαθήσει να "
 "ελέγξει την ταυτότητα του χρήστη με τη σειρά του πρόσθετου"
 msgid "Available built-in plugins"
 msgstr "Διαθέσιμα ενσωματωμένα πρόσθετα"
 msgid "Plugin"
 msgstr "Πρόσθετο"
 msgid "Save"
 msgstr "Αποθήκευση"
 msgid "Repository Defaults"
 msgstr "Προεπιλογές Αποθετηρίου"
 msgid "Type"
 msgstr "Τύπος"
 msgid "Private repository"
 msgstr "Ιδιωτικό αποθετήριο"
 msgid ""
 "Private repositories are only visible to people explicitly added as "
 "collaborators."
 msgstr ""
 "Τα ιδιωτικά αποθετήρια είναι ορατά μόνο σε άτομα που προστίθενται ρητά ως "
 "συνεργάτες."
 msgid "Enable statistics"
 msgstr "Ενεργοποίηση στατιστικών"
 msgid "Enable statistics window on summary page."
 msgstr "Ενεργοποίηση παραθύρου στατιστικών στοιχείων στη σελίδα περίληψης."
 msgid "Enable downloads"
 msgstr "Ενεργοποίηση λήψεων"
 msgid "Enable download menu on summary page."
 msgstr "Ενεργοποίηση μενού λήψης στη σελίδα περίληψης."
 msgid "Edit Gist"
 msgstr "Επεξεργασία Gist"
 msgid ""
 "Gist was updated since you started editing. Copy your changes and click "
 "%(here)s to reload new version."
 msgstr ""
 "Το gist ενημερώθηκε από τότε που αρχίσατε την επεξεργασία. Αντιγράψτε τις "
 "αλλαγές σας και κάντε κλικ στο κουμπί %(here)s για να φορτώσετε τη νέα "
 "έκδοση."
 msgid "here"
 msgstr "εδώ"
 msgid "Gist description ..."
 msgstr "Περιγραφή gist..."
 msgid "Gist lifetime"
 msgstr "Διάρκεια ζωής του gist"
 msgid "Expires"
 msgstr "Λήγει"
 msgid "Never"
 msgstr "Ποτέ"
 msgid "Update Gist"
 msgstr "Ενημέρωση του gist"
 msgid "Cancel"
 msgstr "Ακύρωση"
 msgid "Private Gists for User %s"
 msgstr "Ιδιωτικά gists για το χρήστη %s"
 msgid "Public Gists for User %s"
 msgstr "Δημόσια gists για το χρήστη %s"
 msgid "Public Gists"
 msgstr "Δημόσια Gists"
 msgid "Create New Gist"
 msgstr "Δημιουργία Νέου Gist"
 msgid "Created"
 msgstr "Δημιουργήθηκε"
 msgid "There are no gists yet"
 msgstr "Δεν υπάρχουν ακόμη gists"
 msgid "New Gist"
 msgstr "Νέο Gist"
 msgid "Name this gist ..."
 msgstr "Ονομάστε αυτό το gist..."
 msgid "Create Private Gist"
 msgstr "Δημιουργία Ιδιωτικού Gist"
 msgid "Create Public Gist"
 msgstr "Δημιουργία Δημόσιου Gist"
 msgid "Reset"
 msgstr "Επαναφορά"
 msgid "Gist"
 msgstr "Gist"
 msgid "URL"
 msgstr "URL"
 msgid "Public Gist"
 msgstr "Δημόσιο Gist"
 msgid "Private Gist"
 msgstr "Ιδιωτικό Gist"
 msgid "Delete"
 msgstr "Διαγραφή"
 msgid "Confirm to delete this Gist"
 msgstr "Επιβεβαίωση για διαγραφή αυτού του Gist"
 msgid "Edit"
 msgstr "Επεξεργασία"
 msgid "Show as Raw"
 msgstr "Ακατέργαστη Εμφάνιση"
 msgid "created"
 msgstr "δημιουργήθηκε"
 msgid "Show as raw"
 msgstr "Ακατέργαστη εμφάνιση"
 msgid "My Account"
 msgstr "Ο Λογαριασμός Μου"
 msgid "Profile"
 msgstr "Προφίλ"
 msgid "Email Addresses"
 msgstr "Διευθύνσεις ηλεκτρονικού ταχυδρομείου"
 msgid "SSH Keys"
 msgstr "Κλειδιά SSH"
 msgid "API Keys"
 msgstr "Κλειδιά API"
 msgid "Owned Repositories"
 msgstr "Αποθετήρια που μου Ανήκουν"
 msgid "Watched Repositories"
 msgstr "Αποθετήρια που Παρακολουθώ"
 msgid "Show Permissions"
 msgstr "Εμφάνιση Δικαιωμάτων"
 msgid "Built-in"
 msgstr "Ενσωματωμένο"
 msgid "Confirm to reset this API key: %s"
 msgstr "Επιβεβαίωση για επαναφορά αυτού του κλειδιού API: %s"
 msgid "Expired"
 msgstr "Έληξε"
 msgid "Confirm to remove this API key: %s"
 msgstr "Επιβεβαίωση κατάργησης αυτού του κλειδιού API: %s"
 msgid "Remove"
 msgstr "Κατάργηση"
 msgid "No additional API keys specified"
 msgstr "Δεν έχουν καθοριστεί πρόσθετα κλειδιά API"
 msgid "New API key"
 msgstr "Νέο κλειδί API"
 msgid "Add"
 msgstr "Προσθήκη"
 msgid ""
 "\n"
 "API keys are used to let scripts or services access %s using your\n"
 "account, as if you had provided the script or service with your actual\n"
 "password.\n"
 msgstr ""
 "\n"
 "Τα κλειδιά API χρησιμοποιούνται για να επιτρέπουν προγράμματα ή υπηρεσίες "
 "να έχουν πρόσβαση στο %s χρησιμοποιώντας το λογαριασμό σας, σαν να "
 "παρείχατε στο πρόγραμμα ή την υπηρεσία, τον πραγματικό σας κωδικό "
 "πρόσβασης.\n"
 msgid ""
 "\n"
 "Like passwords, API keys should therefore never be shared with others,\n"
 "nor passed to untrusted scripts or services. If such sharing should\n"
 "happen anyway, reset the API key on this page to prevent further use.\n"
 msgstr ""
 "\n"
 "Όπως οι κωδικοί πρόσβασης, τα κλειδιά API δεν πρέπει επομένως να "
 "κοινοποιούνται ποτέ σε άλλους,\n"
 "ούτε να μεταβιβάζονται σε μη αξιόπιστα προγράμματα ή υπηρεσίες. Εάν μια "
 "τέτοια κοινοποίηση πρέπει\n"
 "γίνει, επαναφέρετε το κλειδί API σε αυτήν τη σελίδα για να αποφύγετε "
 "περαιτέρω χρήση.\n"
 msgid "Primary"
 msgstr "Πρωτεύων"
 msgid "Confirm to delete this email: %s"
 msgstr ""
 "Επιβεβαίωση διαγραφής αυτού του μηνύματος ηλεκτρονικού ταχυδρομείου: %s"
 msgid "No additional emails specified."
 msgstr "Δεν έχουν καθοριστεί πρόσθετα μηνύματα ηλεκτρονικού ταχυδρομείου."
 msgid "New email address"
 msgstr "Νέα διεύθυνση ηλεκτρονικού ταχυδρομείου"
 msgid "Change Your Account Password"
 msgstr "Αλλαγή του Κωδικού Πρόσβασης του Λογαριασμού σας"
 msgid "Current password"
 msgstr "Τρέχων κωδικός πρόσβασης"
 msgid "New password"
 msgstr "Νέος κωδικός πρόσβασης"
 msgid "Confirm new password"
 msgstr "Επιβεβαίωση νέου κωδικού πρόσβασης"
 msgid ""
 "This account is managed with %s and the password cannot be changed here"
 msgstr ""
 "Η διαχείριση αυτού του λογαριασμού γίνεται με %s και ο κωδικός πρόσβασης "
 "δεν μπορεί να αλλάξει εδώ"
 msgid "Current IP"
 msgstr "Τρέχουσα IP"
 msgid "Gravatar"
 msgstr "Gravatar"
 msgid "Change %s avatar at"
 msgstr "Αλλαγή avatar %s στο"
 msgid "Avatars are disabled"
 msgstr "Τα Avatars είναι απενεργοποιημένα"
 msgid "Repositories You Own"
 msgstr "Αποθετήρια που σας ανήκουν"
 msgid "Name"
 msgstr "Όνομα"
 msgid "Fingerprint"
 msgstr "Αποτύπωμα"
 msgid "Last Used"
 msgstr "Τελευταία χρησιμοποιήθηκε"
 msgid "Confirm to remove this SSH key: %s"
 msgstr "Επιβεβαίωση κατάργησης αυτού του κλειδιού SSH: %s"
 msgid "No SSH keys have been added"
 msgstr "Δεν έχουν προστεθεί κλειδιά SSH"
 msgid "New SSH key"
 msgstr "Νέο κλειδί SSH"
 msgid "Public key"
 msgstr "Δημόσιο κλειδί"
 msgid "Public key (contents of e.g. ~/.ssh/id_rsa.pub)"
 msgstr "Δημόσιο κλειδί (περιεχόμενο π.χ. ~/.ssh/id_rsa.pub)"
 msgid "Repositories You are Watching"
 msgstr "Αποθετήρια που παρακολουθείτε"
 msgid "Default Permissions"
 msgstr "Προεπιλεγμένα Δικαιώματα"
 msgid "Global"
 msgstr "Γενικά"
 msgid "IP Whitelist"
 msgstr "Λίστα επιτρεπόμενων IP"
 msgid "Anonymous access"
 msgstr "Ανώνυμη πρόσβαση"
 msgid "Allow anonymous access"
 msgstr "Να επιτρέπεται η ανώνυμη πρόσβαση"
 msgid ""
 "Allow access to Kallithea without needing to log in. Anonymous users use "
 "%s user permissions."
 msgstr ""
 "Να επιτρέπεται η πρόσβαση στην Καλλιθέα χωρίς να χρειάζεται να "
 "συνδεθείτε. Οι ανώνυμοι χρήστες χρησιμοποιούν δικαιώματα χρήστη %s."
 msgid ""
 "All default permissions on each repository will be reset to chosen "
 "permission, note that all custom default permission on repositories will "
 "be lost"
 msgstr ""
 "Όλα τα προεπιλεγμένα δικαιώματα σε κάθε αποθετήριο θα επαναφερθούν στα "
 "επιλεγμένα δικαιώματα. Σημειώστε ότι όλα τα προσαρμοσμένα προεπιλεγμένα "
 "δικαιώματα στα αποθετήρια θα χαθούν"
 msgid "Apply to all existing repositories"
 msgstr "Εφαρμογή σε όλα τα υπάρχοντα αποθετήρια"
 msgid "Permissions for the Default user on new repositories."
 msgstr "Δικαιώματα για τον προεπιλεγμένο χρήστη σε νέα αποθετήρια."
 msgid "Repository group"
 msgstr "Ομάδα αποθετηρίου"
 msgid ""
 "All default permissions on each repository group will be reset to chosen "
 "permission, note that all custom default permission on repository groups "
 "will be lost"
 msgstr ""
 "Όλα τα προεπιλεγμένα δικαιώματα σε κάθε ομάδα αποθετηρίων θα επαναφερθούν "
 "στα επιλεγμένα δικαιώματα. Σημειώστε ότι όλα τα προσαρμοσμένα "
 "προεπιλεγμένα δικαιώματα στις ομάδες αποθετηρίων θα χαθούν"
 msgid "Apply to all existing repository groups"
 msgstr "Εφαρμογή σε όλες τις υπάρχουσες ομάδες αποθετηρίων"
 msgid "Permissions for the Default user on new repository groups."
 msgstr "Δικαιώματα για τον προεπιλεγμένο χρήστη σε νέες ομάδες αποθετηρίων."
 msgid "User group"
 msgstr "Ομάδα χρηστών"
 msgid ""
 "All default permissions on each user group will be reset to chosen "
 "permission, note that all custom default permission on user groups will "
 "be lost"
 msgstr ""
 "Όλα τα προεπιλεγμένα δικαιώματα σε κάθε ομάδα χρηστών θα επαναφερθούν στα "
 "επιλεγμένα δικαιώματα. Σημειώστε ότι όλα τα προσαρμοσμένα προεπιλεγμένα "
 "δικαιώματα στις ομάδες χρηστών θα χαθούν"
 msgid "Apply to all existing user groups"
 msgstr "Εφαρμογή σε όλες τις υπάρχουσες ομάδες χρηστών"
 msgid "Permissions for the Default user on new user groups."
 msgstr "Δικαιώματα για τον προεπιλεγμένο χρήστη σε νέες ομάδες χρηστών."
 msgid "Top level repository creation"
 msgstr "Δημιουργία αποθετηρίου ανώτατου επιπέδου"
 msgid ""
 "Enable this to allow non-admins to create repositories at the top level."
 msgstr ""
 "Ενεργοποιήστε αυτήν την επιλογή ώστε να επιτρέπεται σε μη διαχειριστές να "
 "δημιουργούν αποθετήρια στο ανώτερο επίπεδο."
 msgid ""
 "Note: This will also give all users API access to create repositories "
 "everywhere. That might change in future versions."
 msgstr ""
 "Σημείωση: Αυτό θα δώσει επίσης σε όλους τους χρήστες πρόσβαση API για τη "
 "δημιουργία αποθετηρίων παντού. Αυτό μπορεί να αλλάξει σε μελλοντικές "
 "εκδόσεις."
 msgid "Repository creation with group write access"
 msgstr "Δημιουργία αποθετηρίου με πρόσβαση εγγραφής ομάδας"
 msgid ""
 "With this, write permission to a repository group allows creating "
 "repositories inside that group. Without this, group write permissions "
 "mean nothing."
 msgstr ""
 "Με αυτό, η άδεια εγγραφής σε μια ομάδα αποθετηρίων επιτρέπει τη "
 "δημιουργία αποθετηρίων εντός αυτής της ομάδας. Χωρίς αυτό, τα δικαιώματα "
 "ομαδικής εγγραφής δεν σημαίνουν τίποτα."
 msgid "User group creation"
 msgstr "Δημιουργία ομάδας χρηστών"
 msgid "Enable this to allow non-admins to create user groups."
 msgstr ""
 "Ενεργοποιήστε αυτήν την επιλογή για να επιτρέψετε σε μη διαχειριστές να "
 "δημιουργούν ομάδες χρηστών."
 msgid "Registration"
 msgstr "Εγγραφή"
 msgid "External auth account activation"
 msgstr "Ενεργοποίηση λογαριασμού εξωτερικού ελέγχου"
 msgid "Confirm to delete this IP address: %s"
 msgstr "Επιβεβαίωση για διαγραφή αυτής της διεύθυνσης IP: %s"
 msgid "All IP addresses are allowed."
 msgstr "Επιτρέπονται όλες οι διευθύνσεις IP."
 msgid "New IP address"
 msgstr "Νέα διεύθυνση IP"
 msgid "Repository Groups"
 msgstr "Ομάδες Αποθετηρίου"
 msgid "Group name"
 msgstr "Όνομα ομάδας"
 msgid "Group parent"
 msgstr "Γονική ομάδα"
 msgid "Copy parent group permissions"
 msgstr "Αντιγραφή δικαιωμάτων γονικής ομάδας"
 msgid "Copy permission set from parent repository group."
 msgstr "Αντιγραφή συνόλου δικαιωμάτων από γονική ομάδα αποθετηρίου."
 msgid "%s Repository Group Settings"
 msgstr "Ρυθμίσεις ομάδας αποθετηρίου %s"
 msgid "Add Child Group"
 msgstr "Προσθήκη Θυγατρικής Ομάδας"
 msgid "Settings"
 msgstr "Ρυθμίσεις"
 msgid "Advanced"
 msgstr "Προχωρημένες Ρυθμίσεις"
 msgid "Permissions"
 msgstr "Δικαιώματα"
 msgid "Repository Group: %s"
 msgstr "Ομάδα αποθετηρίου: %s"
 msgid "Top level repositories"
 msgstr "Αποθετήρια ανώτατου επιπέδου"
 msgid "Total repositories"
 msgstr "Σύνολο αποθετηρίων"
 msgid "Children groups"
 msgstr "Θυγατρικές ομάδες"
 msgid "Created on"
 msgstr "Δημιουργήθηκε στις"
 msgid "Confirm to delete this group: %s with %s repository"
 msgid_plural "Confirm to delete this group: %s with %s repositories"
 msgstr[0] ""
 "Επιβεβαίωση διαγραφής αυτής της ομάδας: %s με αποθετήριο δεδομένων %s"
 msgstr[1] ""
 "Επιβεβαίωση διαγραφής αυτής της ομάδας: %s με αποθετήρια δεδομένων %s"
 msgid "Delete this repository group"
 msgstr "Διαγραφή αυτής της ομάδας αποθετηρίων"
 msgid "Not visible"
 msgstr "Μη ορατό"
 msgid "Visible"
 msgstr "Ορατό"
 msgid "Add repos"
 msgstr "Προσθήκη αποθετηρίων"
 msgid "Add/Edit groups"
 msgstr "Προσθήκη/Επεξεργασία ομάδων"
 msgid "User/User Group"
 msgstr "Χρήστης / Ομάδα χρηστών"
 msgid "Default"
 msgstr "Προεπιλογή"
 msgid "Revoke"
 msgstr "Ανακάλεσε"
 msgid "Add new"
 msgstr "Προσθήκη νέου"
 msgid "Apply to children"
 msgstr "Εφαρμογή στα θυγατρικά"
 msgid "Both"
 msgstr "Και τα δυο"
 msgid ""
 "Set or revoke permission to all children of that group, including non-"
 "private repositories and other groups if selected."
 msgstr ""
 "Ορίστε ή ανακαλέστε τα θυγατρικά δικαιώματα αυτής της ομάδας, "
 "συμπεριλαμβανομένων των μη ιδιωτικών αποθετηρίων και άλλων ομάδων, εάν "
 "επιλεγεί."
 msgid "Remove this group"
 msgstr "Κατάργηση αυτής της ομάδας"
 msgid "Confirm to delete this group"
 msgstr "Επιβεβαιώστε για να διαγράψετε αυτή την ομάδα"
 msgid "Repository group %s"
 msgstr "Ομάδα αποθετηρίων %s"
 msgid "Repository Groups Administration"
 msgstr "Διαχείριση Ομάδων Αποθετηρίου"
 msgid "Number of Top-level Repositories"
 msgstr "Αριθμός αποθετηρίων ανώτατου επιπέδου"
 msgid "Clone remote repository"
 msgstr "Κλωνοποίηση απομακρυσμένου αποθετηρίου"
 msgid ""
 "Optional: URL of a remote repository. If set, the repository will be "
 "created as a clone from this URL."
 msgstr ""
 "Προαιρετικό: Διεύθυνση URL ενός απομακρυσμένου αποθετηρίου. Εάν οριστεί, "
 "το αποθετήριο θα δημιουργηθεί ως κλώνος από αυτήν τη διεύθυνση URL."
 msgid ""
 "Keep it short and to the point. Use a README file for longer descriptions."
 msgstr ""
 "Κρατήστε τη σύντομη και περιεκτική. Χρησιμοποιήστε ένα αρχείο README για "
 "μεγαλύτερες περιγραφές."
 msgid "Optionally select a group to put this repository into."
 msgstr ""
 "Προαιρετικά, επιλέξτε μια ομάδα για να τοποθετήσετε αυτό το αποθετήριο."
 msgid "Type of repository to create."
 msgstr "Τύπος αποθετηρίου προς δημιουργία."
 msgid ""
 "Default revision for files page, downloads, full text search index and "
 "readme generation"
 msgstr ""
 "Προεπιλεγμένη αναθεώρηση για τη σελίδα αρχείων, λήψεων, ευρετήριο "
 "αναζήτησης πλήρους κειμένου και δημιουργία readme"
 msgid "%s Creating Repository"
 msgstr "%s Δημιουργία Αποθετηρίου"
 msgid "Creating repository"
 msgstr "Δημιουργία αποθετηρίου"
 msgid ""
 "Repository \"%(repo_name)s\" is being created, you will be redirected "
 "when this process is finished.repo_name"
 msgstr ""
 "Δημιουργείται το αποθετήριο \"%(repo_name)s\", θα ανακατευθυνθείτε όταν "
 "ολοκληρωθεί αυτή η διαδικασία."
 msgid ""
 "We're sorry but error occurred during this operation. Please check your "
 "Kallithea server logs, or contact administrator."
 msgstr ""
 "Λυπούμαστε, αλλά παρουσιάστηκε σφάλμα κατά τη διάρκεια αυτής της "
 "λειτουργίας. Ελέγξτε τα αρχεία καταγραφής του διακομιστή Καλλιθέας ή "
 "επικοινωνήστε με το διαχειριστή."
 msgid "%s Repository Settings"
 msgstr "Ρυθμίσεις Αποθετηρίου %s"
 msgid "Extra Fields"
 msgstr "Επιπλέον Πεδία"
 msgid "Remote"
 msgstr "Απομακρυσμένο"
 msgid "Statistics"
 msgstr "Στατιστικά"
 msgid "Parent"
 msgstr "Γονικό"
 msgid "Set"
 msgstr "Ορισμός"
 msgid "Public Journal Visibility"
 msgstr "Ορατότητα δημόσιων εγγραφών"
 msgid "Remove from public journal"
 msgstr "Κατάργηση από τις δημόσιες εγγραφές"
 msgid "Add to Public Journal"
 msgstr "Προσθήκη στις Δημόσια Εγγραφές"
 msgid ""
 "All actions done in this repository will be visible to everyone in the "
 "public journal."
 msgstr ""
 "Όλες οι ενέργειες που γίνονται σε αυτό το αποθετήριο θα είναι ορατές σε "
 "όλους στις δημόσιες εγγραφές."
 msgid "Confirm to delete this repository: %s"
 msgstr "Επιβεβαίωση διαγραφής αυτού του αποθετηρίου: %s"
 msgid "Delete this Repository"
 msgstr "Διαγραφή αυτού του Αποθετηρίου"
 msgid "This repository has %s fork"
 msgid_plural "This repository has %s forks"
 msgstr[0] "Αυτό το αποθετήριο έχει %s παράγωγο"
 msgstr[1] "Αυτό το αποθετήριο έχει %s παράγωγα"
 msgid ""
 "The deleted repository will be moved away and hidden until the "
 "administrator expires it. The administrator can both permanently delete "
 "it or restore it."
 msgstr ""
 "Το διαγραμμένο αποθετήριο θα απομακρυνθεί και θα κρυφτεί έως ότου το "
 "λήξει ο διαχειριστής. Ο διαχειριστής μπορεί να το διαγράψει οριστικά ή να "
 "το επαναφέρει."
 msgid "Label"
 msgstr "Ετικέτα"
 msgid "Key"
 msgstr "Κλειδί"
 msgid "Confirm to delete this field: %s"
 msgstr "Επιβεβαίωση διαγραφής αυτού του πεδίου: %s"
 msgid "New field key"
 msgstr "Νέο κλειδί πεδίου"
 msgid "New field label"
 msgstr "Νέα ετικέτα πεδίου"
 msgid "Enter short label"
 msgstr "Εισαγωγή σύντομης ετικέτας"
 msgid "New field description"
 msgstr "Νέα περιγραφή πεδίου"
 msgid "Enter description of a field"
 msgstr "Εισαγωγή περιγραφής ενός πεδίου"
 msgid "Extra fields are disabled."
 msgstr "Τα επιπλέον πεδία είναι απενεργοποιημένα."
 msgid "Private Repository"
 msgstr "Ιδιωτικό Αποθετήριο"
 msgid "Remote repository URL"
 msgstr "Διεύθυνση URL απομακρυσμένου αποθετηρίου"
 msgid "Pull Changes from Remote Repository"
 msgstr "Τραβήξτε τις αλλαγές από το απομακρυσμένο αποθετήριο"
 msgid "Confirm to pull changes from remote repository."
 msgstr ""
 "Επιβεβαιώστε ότι θα τραβήξετε αλλαγές από το απομακρυσμένο αποθετήριο "
 "δεδομένων."
 msgid "This repository does not have a remote repository URL."
 msgstr ""
 "Αυτό το αποθετήριο δεν έχει διεύθυνση URL απομακρυσμένου αποθετηρίου."
 msgid "Permanent URL"
 msgstr "Μόνιμη διεύθυνση URL"
 msgid ""
 "In case this repository is renamed or moved into another group the "
 "repository URL changes.\n"
 "                               Using the above permanent URL guarantees "
 "that this repository always will be accessible on that URL.\n"
 "                               This is useful for CI systems, or any "
 "other cases that you need to hardcode the URL into a 3rd party service."
 msgstr ""
 "Η διεύθυνση URL του αποθετηρίου αλλάζει όταν αυτό μετονομαστεί ή "
 "μετακινηθεί σε άλλη ομάδα.\n"
 "                               Η χρήση της παραπάνω μόνιμης διεύθυνσης "
 "URL εγγυάται ότι αυτό το αποθετήριο θα είναι πάντα προσβάσιμο σε αυτήν τη "
 "διεύθυνση URL.\n"
 "                               Αυτό είναι χρήσιμο για συστήματα CI ή για "
 "άλλες περιπτώσεις που χρειάζεστε να κωδικοποιήσετε τη διεύθυνση URL σε "
 "κάποια υπηρεσία τρίτου μέρους."
 msgid "Remote repository"
 msgstr "Απομακρυσμένο αποθετήριο"
 msgid "Repository URL"
 msgstr "URL Αποθετηρίου"
 msgid ""
 "Optional: URL of a remote repository. If set, the repository can be "
 "pulled from this URL."
 msgstr ""
 "Προαιρετικό: Διεύθυνση URL ενός απομακρυσμένου αποθετηρίου. Εάν οριστεί, "
 "το αποθετήριο μπορεί να τραβηχτεί από αυτήν τη διεύθυνση URL."
 msgid "Default revision for files page, downloads, whoosh and readme"
 msgstr ""
 "Προεπιλεγμένη αναθεώρηση για τη σελίδα αρχείων, λήψεων, Whoosh και readme"
 msgid "Type name of user"
 msgstr "Πληκτρολογήστε το όνομα του χρήστη"
 msgid "Change owner of this repository."
 msgstr "Αλλάξτε τον κάτοχο αυτού του αποθετηρίου."
 msgid "Processed commits"
 msgstr "Επεξεργασμένα commits"
 msgid "Processed progress"
 msgstr "Επεξεργασμένη πρόοδος"
 msgid "Reset Statistics"
 msgstr "Επαναφορά Στατιστικών"
 msgid "Confirm to remove current statistics."
 msgstr "Επιβεβαιώστε την κατάργηση των τρεχόντων στατιστικών στοιχείων."
 msgid "Repositories Administration"
 msgstr "Διαχείριση Αποθετηρίων"
 msgid "State"
 msgstr "Κατάσταση"
 msgid "Settings Administration"
 msgstr "Διαχείριση Ρυθμίσεων"
 msgid "VCS"
 msgstr "VCS"
 msgid "Remap and Rescan"
 msgstr "Επανάληψη αντιστοίχισης και επανασάρωση"
 msgid "Visual"
 msgstr "Εμφάνιση"
 msgid "Full Text Search"
 msgstr "Αναζήτηση Πλήρους Κειμένου"
 msgid "System Info"
 msgstr "Πληροφορίες Συστήματος"
 msgid "Send test email to"
 msgstr "Αποστολή δοκιμαστικού μηνύματος ηλεκτρονικού ταχυδρομείου σε"
 msgid "Send"
 msgstr "Αποστολή"
 msgid "Site branding"
 msgstr "Επωνυμία ιστότοπου"
 msgid "Set a custom title for your Kallithea Service."
 msgstr "Ορίστε έναν προσαρμοσμένο τίτλο για την υπηρεσία της Καλλιθέα σας."
 msgid "HTML/JavaScript/CSS customization block"
 msgstr "Μπλοκ προσαρμογής HTML / JavaScript / CSS"
 msgid ""
 "HTML (possibly with                         JavaScript and/or CSS) that "
 "will be added to the bottom                         of every page. This "
 "can be used for web analytics                         systems, but also "
 "to                         perform instance-specific customizations like "
 "adding a                         project banner at the top of every page."
 msgstr ""
 "HTML (ενδεχομένως με JavaScript ή / και CSS) που θα προστεθούν στο κάτω "
 "μέρος της κάθε σελίδας. Αυτό μπορεί να χρησιμοποιηθεί για web analytics, "
 "αλλά και για την προσαρμογή της εμφάνισης, όπως η προσθήκη ενός banner "
 "στο επάνω μέρος κάθε σελίδας."
 msgid "ReCaptcha public key"
 msgstr "Δημόσιο κλειδί ReCaptcha"
 msgid "Public key for reCaptcha system."
 msgstr "Δημόσιο κλειδί για το σύστημα reCaptcha."
 msgid "ReCaptcha private key"
 msgstr "Ιδιωτικό κλειδί ReCaptcha"
 msgid ""
 "Private key for reCaptcha system. Setting this value will enable captcha "
 "on registration."
 msgstr ""
 "Ιδιωτικό κλειδί για το σύστημα reCaptcha. Ο καθορισμός αυτής της τιμής θα "
 "ενεργοποιήσει το captcha κατά την εγγραφή."
 msgid "Save Settings"
 msgstr "Αποθήκευση Ρυθμίσεων"
 msgid "Built-in Mercurial Hooks (Read-Only)"
 msgstr "Ενσωματωμένοι Mercurial Hooks (μόνο για ανάγνωση)"
 msgid "Rescan options"
 msgstr "Επιλογές Επανασάρωσης"
 msgid "Delete records of missing repositories"
 msgstr "Διαγραφή εγγραφών αποθετηρίων που λείπουν"
 msgid ""
 "Check this option to remove all comments, pull requests and other records "
 "related to repositories that no longer exist in the filesystem."
 msgstr ""
 "Επιλέξτε αυτήν την επιλογή για να καταργήσετε όλα τα σχόλια, να αιτήματα "
 "έλξης και άλλες εγγραφές που σχετίζονται με αποθετήρια που δεν υπάρχουν "
 "πλέον στο σύστημα αρχείων."
 msgid "Invalidate cache for all repositories"
 msgstr "Ακυρώνει την προσωρινή αποθήκευση για όλα τα αποθετήρια"
 msgid "Check this to reload data and clear cache keys for all repositories."
 msgstr ""
 "Επιλέξτε αυτό για να φορτώσετε ξανά τα δεδομένα και να καταργήστε την "
 "cache για όλα τα αποθετήρια."
 msgid "Install Git hooks"
 msgstr "Εγκατάσταση Git hooks"
 msgid ""
 "Verify if Kallithea's Git hooks are installed for each repository. "
 "Current hooks will be updated to the latest version."
 msgstr ""
 "Επαληθεύστε εάν τα Git hooks της Καλλιθέας είναι εγκατεστημένα για κάθε "
 "αποθετήριο. Τα τρέχοντα hooks θα ενημερωθούν στην τελευταία έκδοση."
 msgid "Overwrite existing Git hooks"
 msgstr "Αντικατάσταση υπαρχόντων Git hooks"
 msgid ""
 "If installing Git hooks, overwrite any existing hooks, even if they do "
 "not seem to come from Kallithea. WARNING: This operation will destroy any "
 "custom git hooks you may have deployed by hand!"
 msgstr ""
 "Εάν εγκαθιστάτε Git hooks, αντικαταστήστε τυχόν υπάρχοντα hooks, ακόμα κι "
 "αν δεν φαίνεται να προέρχονται από την Καλλιθέα. ΠΡΟΕΙΔΟΠΟΙΗΣΗ: Αυτή η "
 "λειτουργία θα καταστρέψει τυχόν προσαρμοσμένα git hooks που μπορεί να "
 "έχετε αναπτύξει με το χέρι!"
 msgid "Rescan Repositories"
 msgstr "Επανασάρωση αποθετηρίων"
 msgid "Index build option"
 msgstr "Επιλογή δημιουργίας ευρετηρίου"
 msgid "Build from scratch"
 msgstr "Κατασκευή από το μηδέν"
 msgid ""
-"This option completely reindexeses all of the repositories for proper "
+"This option completely reindexes all of the repositories for proper "
 "fulltext search capabilities."
 msgstr ""
 "Αυτή η επιλογή ξαναδημιουργεί πλήρως τα ευρετήρια σε όλα τα αποθετήρια "
 "για δυνατότητα αναζήτησης πλήρους κειμένου."
 msgid "Reindex"
 msgstr "Αναδημιουργία ευρετηρίου"
 msgid "Checking for updates..."
 msgstr "Έλεγχος για ενημερώσεις..."
 msgid "Kallithea version"
 msgstr "Έκδοση Καλλιθέας"
 msgid "Kallithea configuration file"
 msgstr "Αρχείο διαμόρφωσης Καλλιθέας"
 msgid "Python version"
 msgstr "Έκδοση Python"
 msgid "Platform"
 msgstr "Πλατφόρμα"
 msgid "Git version"
 msgstr "Έκδοση Git"
 msgid "Git path"
 msgstr "Διαδρομή Git"
 msgid "Python Packages"
 msgstr "Πακέτα Python"
 msgid "Show repository size after push"
 msgstr "Εμφάνιση μεγέθους αποθετηρίου μετά την ώθηση"
 msgid "Update repository after push (hg update)"
 msgstr "Ενημέρωση αποθετηρίου μετά την ώθηση (hg update)"
 msgid "Mercurial extensions"
 msgstr "Επεκτάσεις Mercurial"
 msgid "Enable largefiles extension"
 msgstr "Ενεργοποίηση επέκτασης μεγάλων αρχείων"
 msgid "Location of repositories"
 msgstr "Τοποθεσία αποθετηρίων"
 msgid ""
 "Click to unlock. You must restart Kallithea in order to make this setting "
 "take effect."
 msgstr ""
 "Κάντε κλικ για να ξεκλειδώσετε. Πρέπει να επανεκκινήσετε την Καλλιθέα για "
 "να εφαρμοστεί αυτή η ρύθμιση."
 msgid ""
 "Filesystem location where repositories are stored. After changing this "
 "value, a restart and rescan of the repository folder are both required."
 msgstr ""
 "Θέση συστήματος αρχείων όπου αποθηκεύονται τα αποθετήρια. Μετά την αλλαγή "
 "αυτής της τιμής, απαιτείται επανεκκίνηση και σάρωση του φακέλου "
 "αποθετηρίου."
 msgid "General"
 msgstr "Γενικά"
 msgid "Use repository extra fields"
 msgstr "Χρήση πρόσθετων πεδίων αποθετηρίου"
 msgid "Allows storing additional customized fields per repository."
 msgstr ""
 "Επιτρέπει την αποθήκευση πρόσθετων προσαρμοσμένων πεδίων ανά αποθετήριο."
 msgid "Show Kallithea version"
 msgstr "Εμφάνιση της έκδοσης Καλλιθέας"
 msgid ""
 "Shows or hides a version number of Kallithea displayed in the footer."
 msgstr ""
 "Εμφανίζει ή αποκρύπτει τον αριθμό έκδοσης της Καλλιθέας που εμφανίζεται "
 "στο υποσέλιδο."
 msgid "Show user Gravatars"
 msgstr "Εμφάνιση Gravatars του χρήστη"
 msgid ""
 "Gravatar URL allows you to use another avatar server application.\n"
 "                                                        The following "
 "variables of the URL will be replaced accordingly.\n"
 "                                                        {scheme}    "
 "'http' or 'https' sent from running Kallithea server,\n"
 "                                                        {email}     user "
 "email,\n"
 "                                                        {md5email}  md5 "
 "hash of the user email (like at gravatar.com),\n"
 "                                                        {size}      size "
 "of the image that is expected from the server application,\n"
 "                                                        {netloc}    "
 "network location/server host of running Kallithea server"
 msgstr ""
 "Το Gravatar URL σας επιτρέπει να χρησιμοποιήσετε avatar από έναν άλλο "
 "διακομιστή.\n"
 "                                                        Οι ακόλουθες "
 "μεταβλητές της διεύθυνσης URL θα αντικατασταθούν ανάλογα.\n"
 "                                                        {scheme} 'http' ή "
 "'https' που αποστέλλεται από την εκτέλεση του διακομιστή της Καλλιθέας,\n"
 "                                                        {email} "
 "ηλεκτρονικό ταχυδρομείο,\n"
 "                                                        {md5email} md5 "
 "hash του email χρήστη (όπως στο gravatar.com),\n"
 "                                                        {size} μέγεθος "
 "της εικόνας που αναμένεται από το διακομιστή,\n"
 "                                                        {netloc} θέση "
 "δικτύου/διακομιστή που τρέχει την Καλλιθέα"
 msgid "HTTP Clone URL"
 msgstr "HTTP Clone URL"
 msgid ""
 "Schema of clone URL construction eg. '{scheme}://{user}@{netloc}/"
 "{repo}'.\n"
 "                                                    The following "
 "variables are available:\n"
 "                                                    {scheme} 'http' or "
 "'https' sent from running Kallithea server,\n"
 "                                                    {user}   current user "
 "username,\n"
 "                                                    {netloc} network "
 "location/server host of running Kallithea server,\n"
 "                                                    {repo}   full "
 "repository name,\n"
 "                                                    {repoid} ID of "
 "repository, can be used to construct clone-by-id,\n"
 "                                                    {system_user}  name "
 "of the Kallithea system user,\n"
 "                                                    {hostname}  server "
 "hostname\n"
 "                                                    "
 msgstr ""
 "Κατασκευή σχήματος του URL clone π.χ. '{scheme}}}{user}@{netloc}/"
 "{repo}'.\n"
 "                                                    Οι ακόλουθες "
 "μεταβλητές είναι διαθέσιμες:\n"
 "                                                    {scheme} 'http' ή "
 "'https' αποστέλλεται από την εκτέλεση του διακομιστή της Καλλιθέας,\n"
 "                                                    {user} τρέχον όνομα "
 "χρήστη,\n"
 "                                                    {netloc} θέση δικτύου/"
 "κεντρικός υπολογιστής διακομιστή που τρέχει το διακομιστή της Καλλιθέας,\n"
 "                                                    {repo} πλήρες όνομα "
 "αποθετηρίου,\n"
 "                                                    {repoid} ID του "
 "αποθετηρίου, μπορεί να χρησιμοποιηθεί για την κατασκευή clone-by-id,\n"
 "                                                    {system_user} όνομα "
 "του χρήστη του συστήματος Καλλιθέας,\n"
 "                                                    {hostname} όνομα του "
 "διακομιστή\n"
 "                                                    "
 msgid "SSH Clone URL"
 msgstr "SSH Clone URL"
 msgid ""
 "Schema for constructing SSH clone URL, eg. 'ssh://{system_user}"
 "@{hostname}/{repo}'."
 msgstr ""
 "Κατασκευή σχήματος SSH clone URL, πχ. 'ssh://{system_user}@{hostname}/"
 "{repo}'."
 msgid "Repository page size"
 msgstr "Μέγεθος σελίδας αποθετηρίου"
 msgid ""
 "Number of items displayed in the repository pages before pagination is "
 "shown."
 msgstr ""
 "Ο αριθμός των αντικειμένων που εμφανίζονται στις σελίδες αποθετηρίου πριν "
 "εφαρμοστεί η σελιδοποίηση."
 msgid "Admin page size"
 msgstr "Μέγεθος σελίδας διαχειριστή"
 msgid ""
 "Number of items displayed in the admin pages grids before pagination is "
 "shown."
 msgstr ""
 "Ο αριθμός των στοιχείων που εμφανίζονται στα πλέγματα των σελίδων "
 "διαχειριστή πριν εφαρμοστεί η σελιδοποίηση."
 msgid "Icons"
 msgstr "Εικονίδια"
 msgid "Show public repository icon on repositories"
 msgstr "Εμφάνιση δημόσιου εικονιδίου αποθετηρίου στα αποθετήρια"
 msgid "Show private repository icon on repositories"
 msgstr "Εμφάνιση εικονιδίου ιδιωτικού αποθετηρίου στα αποθετήρια"
 msgid "Show public/private icons next to repository names."
 msgstr ""
 "Εμφάνιση δημόσιων/ιδιωτικών εικονιδίων δίπλα στα ονόματα αποθετηρίων."
 msgid "Meta Tagging"
 msgstr "Μεταετικέτες"
 msgid ""
 "Parses meta tags from the repository description field and turns them "
 "into colored tags."
 msgstr ""
 "Αναλύει τις μετα-ετικέτες από το πεδίο περιγραφής του αποθετηρίου και τις "
 "μετατρέπει σε έγχρωμες ετικέτες."
 msgid "Add user group"
 msgstr "Προσθήκη ομάδας χρηστών"
 msgid "User Groups"
 msgstr "Ομάδες Χρηστών"
 msgid "Add User Group"
 msgstr "Προσθήκη Ομάδας Χρηστών"
 msgid "Short, optional description for this user group."
 msgstr "Σύντομη, προαιρετική περιγραφή για αυτήν την ομάδα χρηστών."
 msgid "Active"
 msgstr "Ενεργό"
 msgid "%s user group settings"
 msgstr "Ρυθμίσεις ομάδας χρηστών %s"
 msgid "Show Members"
 msgstr "Εμφάνιση Μελών"
 msgid "User Group: %s"
 msgstr "Ομάδα Χρηστών: %s"
 msgid "Members"
 msgstr "Μέλη"
 msgid "Confirm to delete this user group: %s"
 msgstr "Επιβεβαίωση για διαγραφή αυτής της ομάδας χρηστών: %s"
 msgid "Delete this user group"
 msgstr "Διαγραφή αυτής της ομάδας χρηστών"
 msgid "No members yet"
 msgstr "Δεν υπάρχουν μέλη ακόμα"
 msgid "Chosen group members"
 msgstr "Επιλεγμένα μέλη της ομάδας"
 msgid "Available members"
 msgstr "Διαθέσιμα μέλη"
 msgid "User Groups Administration"
 msgstr "Διαχείριση Ομάδων Χρηστών"
 msgid "Add user"
 msgstr "Προσθήκη χρήστη"
 msgid "Users"
 msgstr "Χρήστες"
 msgid "Add User"
 msgstr "Προσθήκη χρήστη"
 msgid "Password confirmation"
 msgstr "Επιβεβαίωση κωδικού πρόσβασης"
 msgid "%s user settings"
 msgstr "Ρυθμίσεις χρήστη %s"
 msgid "Emails"
 msgstr "Μηνύματα ηλεκτρονικού ταχυδρομείου"
 msgid "User: %s"
 msgstr "Χρήστης: %s"
 msgid "Source of Record"
 msgstr "Προέλευση εγγραφής"
 msgid "Last Login"
 msgstr "Τελευταία Σύνδεση"
 msgid "Member of User Groups"
 msgstr "Μέλος των Ομάδων Χρηστών"
 msgid "Confirm to delete this user: %s"
 msgstr "Επιβεβαίωση διαγραφής αυτού του χρήστη: %s"
 msgid "Delete this user"
 msgstr "Διαγραφή αυτού του χρήστη"
 msgid "Inherited from %s"
 msgstr "Κληρονομήθηκε από %s"
 msgid "New password confirmation"
 msgstr "Επιβεβαίωση νέου κωδικού πρόσβασης"
 msgid "Users Administration"
 msgstr "Διαχείριση Χρηστών"
 msgid "Auth Type"
 msgstr "Τύπος Πιστοποίησης"
 msgid "Server instance: %s"
 msgstr "Παρουσία διακομιστή: %s"
 msgid "Support"
 msgstr "Υποστήριξη"
 msgid "Mercurial repository"
 msgstr "Αποθετήριο Mercurial"
 msgid "Git repository"
 msgstr "Αποθετήριο Git"
 msgid "Summary"
 msgstr "Περίληψη"
 msgid "Changelog"
 msgstr "Ιστορικό αλλαγών"
 msgid "Files"
 msgstr "Αρχεία"
 msgid "Show Pull Requests for %s"
 msgstr "Εμφάνιση Αιτήσεων Έλξης για %s"
 msgid "Pull Requests"
 msgstr "Αιτήματα Έλξης"
 msgid "Options"
 msgstr "Επιλογές"
 msgid "Compare"
 msgstr "Σύγκριση"
 msgid "Search"
 msgstr "Αναζήτηση"
 msgid "Follow"
 msgstr "Παρακολούθηση"
 msgid "Unfollow"
 msgstr "Κατάργηση παρακολούθησης"
 msgid "Create Pull Request"
 msgstr "Δημιουργία Αιτήματος Έλξης"
 msgid "Switch To"
 msgstr "Αλλαγή Σε"
 msgid "No matches found"
 msgstr "Δεν βρέθηκαν αντιστοιχίσεις"
 msgid "Show recent activity"
 msgstr "Εμφάνιση πρόσφατης δραστηριότητας"
 msgid "Public journal"
 msgstr "Δημόσιο Ημερολόγιο"
 msgid "Show public gists"
 msgstr "Εμφάνιση δημόσιων gists"
 msgid "Gists"
 msgstr "Gists"
 msgid "All Public Gists"
 msgstr "Όλα τα Δημόσια Gists"
 msgid "My Public Gists"
 msgstr "Τα Δημόσιά μου Gists"
 msgid "My Private Gists"
 msgstr "Τα Ιδιωτικά μου Gists"
 msgid "Search in repositories"
 msgstr "Αναζήτηση σε αποθετήρια"
 msgid "My Pull Requests"
 msgstr "Τα αιτήματά μου για έλξη"
 msgid "Not Logged In"
 msgstr "Δεν έχετε συνδεθεί"
 msgid "Login to Your Account"
 msgstr "Συνδεθείτε στο λογαριασμό σας"
 msgid "Forgot password?"
 msgstr "Ξεχάσατε τον κωδικό πρόσβασης;"
 msgid "Don't have an account?"
 msgstr "Δεν έχετε λογαριασμό;"
 msgid "Log Out"
 msgstr "Αποσύνδεση"
 msgid "Parent rev."
 msgstr "Γονική αναθ."
 msgid "Child rev."
 msgstr "Θυγατρική αναθ."
 msgid "Create repositories"
 msgstr "Δημιουργία αποθετηρίων"
 msgid "Select this option to allow repository creation for this user"
 msgstr ""
 "Ενεργοποιήστε αυτήν την επιλογή για να επιτρέψετε τη δημιουργία "
 "αποθετηρίου για αυτόν το χρήστη"
 msgid "Create user groups"
 msgstr "Δημιουργία ομάδων χρηστών"
 msgid "Select this option to allow user group creation for this user"
 msgstr ""
 "Ενεργοποιήστε αυτήν την επιλογή για να επιτρέψετε τη δημιουργία ομάδας "
 "χρηστών για αυτόν το χρήστη"
 msgid "Show"
 msgstr "Εμφάνιση"
 msgid "No permissions defined yet"
 msgstr "Δεν έχουν οριστεί ακόμα δικαιώματα"
 msgid "Permission"
 msgstr "Δικαίωμα"
 msgid "Edit Permission"
 msgstr "Επεξεργασία Δικαιώματος"
 msgid "No permission defined"
 msgstr "Δεν έχει οριστεί κανένα δικαίωμα"
 msgid "Retry"
 msgstr "Επανάληψη"
 msgid "Submitting ..."
 msgstr "Υποβολή..."
 msgid "Unable to post"
 msgstr "Δεν είναι δυνατή η δημοσίευση"
 msgid "Add Another Comment"
 msgstr "Προσθήκη και άλλου Σχολίου"
 msgid "Stop following this repository"
 msgstr "Διακοπή παρακολούθησης αυτού του αποθετηρίου"
 msgid "Start following this repository"
 msgstr "Έναρξη παρακολούθησης αυτού του αποθετηρίου"
 msgid "Group"
 msgstr "Ομάδα"
 msgid "Loading ..."
 msgstr "Φόρτωση..."
 msgid "loading ..."
 msgstr "φόρτωση ..."
 msgid "Search truncated"
 msgstr "Περικομμένη αναζήτηση"
 msgid "No matching files"
 msgstr "Δεν υπάρχουν αρχεία που να ταιριάζουν"
 msgid "Open New Pull Request from {0}"
 msgstr "Άνοιγμα νέας αίτησης έλξης από {0}"
 msgid "Open New Pull Request for {0} &rarr; {1}"
 msgstr "Άνοιγμα νέου αιτήματος έλξης για {0} &rarr; {1}"
 msgid "Show Selected Changesets {0} &rarr; {1}"
 msgstr "Εμφάνιση Επιλεγμένων Σετ Αλλαγών {0} &rarr; {1}"
 msgid "Selection Link"
 msgstr "Σύνδεσμος Επιλογής"
 msgid "Collapse Diff"
 msgstr "Σύμπτυξη Διαφοράς"
 msgid "Expand Diff"
 msgstr "Ανάπτυξη Διαφοράς"
 msgid "No revisions"
 msgstr "Χωρίς αναθεωρήσεις"
 msgid "Type name of user or member to grant permission"
 msgstr ""
 "Πληκτρολογήστε το όνομα του χρήστη ή του μέλους για την εκχώρηση "
 "δικαιωμάτων"
 msgid "Failed to revoke permission"
 msgstr "Απέτυχε η ανάκληση του δικαιωμάτος"
 msgid "Confirm to revoke permission for {0}: {1} ?"
 msgstr "Επιβεβαιώστε την ανάκληση του δικαιώματος για {0}: {1};"
 msgid "Select changeset"
 msgstr "Επιλογή σετ αλλαγών"
 msgid "Specify changeset"
 msgstr "Καθορισμός σετ αλλαγών"
 msgid "Click to sort ascending"
 msgstr "Κάντε κλικ για αύξουσα ταξινόμηση"
 msgid "Click to sort descending"
 msgstr "Κάντε κλικ για φθίνουσα ταξινόμηση"
 msgid "No records found."
 msgstr "Δεν βρέθηκαν εγγραφές."
 msgid "Data error."
 msgstr "Σφάλμα δεδομένων."
 msgid "Loading..."
 msgstr "Φόρτωση..."
 msgid "%s Changelog"
 msgstr "%s Αρχείο καταγραφής αλλαγών"
 msgid "showing %d out of %d revision"
 msgid_plural "showing %d out of %d revisions"
 msgstr[0] "εμφάνιση %d από %d αναθεώρηση"
 msgstr[1] "εμφάνιση %d από %d αναθεώρησεις"
 msgid "Clear selection"
 msgstr "Καθαρισμός επιλογής"
 msgid "Go to tip of repository"
 msgstr "Μετάβαση στην κεφαλή του αποθετηρίου"
 msgid "Branch filter:"
 msgstr "Φίλτρο κλάδου:"
 msgid "There are no changes yet"
 msgstr "Δεν υπάρχουν αλλαγές ακόμα"
 msgid "Removed"
 msgstr "Αφαιρέθηκε"
 msgid "Changed"
 msgstr "Αλλάχτηκε"
 msgid "Added"
 msgstr "Προστέθηκε"
 msgid "Affected %s files"
 msgstr "Επηρεάστηκαν %s αρχεία"
 msgid "First (oldest) changeset in this list"
 msgstr "Πρώτο (παλαιότερο) σετ αλλαγών σε αυτήν τη λίστα"
 msgid "Last (most recent) changeset in this list"
 msgstr "Τελευταίο (πιο πρόσφατο) σετ αλλαγών σε αυτήν τη λίστα"
 msgid "Position in this list of changesets"
 msgstr "Θέση σε αυτήν τη λίστα των αλλαγών"
 msgid ""
 "Changeset status: %s by %s\n"
 "Click to open associated pull request %s"
 msgstr ""
 "Κατάσταση συνόλου αλλαγών: %s από %s\n"
 "Κάντε κλικ για να ανοίξετε το συσχετισμένο αίτημα έλξης %s"
 msgid "Changeset status: %s by %s"
 msgstr "Κατάσταση σετ αλλαγών: %s από %s"
 msgid "Expand commit message"
 msgstr "Ανάπτυξη μηνύματος commit"
 msgid "%s comments"
 msgstr "%s σχόλια"
 msgid "Bookmark %s"
 msgstr "Σελιδοδείκτης %s"
 msgid "Tag %s"
 msgstr "Ετικέτα %s"
 msgid "Branch %s"
 msgstr "Κλάδος %s"
 msgid "%s Changeset"
 msgstr "Σετ αλλαγών %s"
 msgid "Changeset status"
 msgstr "Κατάσταση σετ αλλαγών"
 msgid "Raw diff"
 msgstr "Ακατέργαστη διαφορά"
 msgid "Patch diff"
 msgstr "Διαφορά κώδικα"
 msgid "Download diff"
 msgstr "Λήψη διαφοράς"
 msgid "Merge"
 msgstr "Συγχώνευση"
 msgid "Replaced by:"
 msgstr "Αντικαταστάθηκε από:"
 msgid "Preceded by:"
 msgstr "Προηγείται από:"
 msgid "%s file changed"
 msgid_plural "%s files changed"
 msgstr[0] "Άλλαξε %s αρχείο"
 msgstr[1] "Άλλαξαν %s αρχεία"
 msgid "%s file changed with %s insertions and %s deletions"
 msgid_plural "%s files changed with %s insertions and %s deletions"
 msgstr[0] "Άλλαξε %s αρχείο με %s εισαγωγές και %s διαγραφές"
 msgstr[1] "Άλλαξαν %s αρχεία με %s εισαγωγές και %s διαγραφές"
 msgid "Show full diff anyway"
 msgstr "Εμφάνιση πλήρους διαφοράς ούτως ή άλλως"
 msgid "comment"
 msgstr "σχόλιο"
 msgid "on pull request"
 msgstr "κατόπιν αιτήματος έλξης"
 msgid "No title"
 msgstr "Χωρίς τίτλο"
 msgid "on this changeset"
 msgstr "σε αυτό το σετ αλλαγών"
 msgid "Delete comment?"
 msgstr "Διαγραφή σχολίου;"
 msgid "Status change"
 msgstr "Αλλαγή κατάστασης"
 msgid "Comments are in plain text. Use @username to notify another user."
 msgstr ""
 "Τα σχόλια είναι σε απλό κείμενο. Χρησιμοποιήστε @username για να "
 "ειδοποιήσετε έναν άλλο χρήστη."
 msgid "Set changeset status"
 msgstr "Ορισμός κατάστασης σετ αλλαγών"
 msgid "Vote for pull request status"
 msgstr "Ψηφοφορία για την κατάσταση του αιτήματος έλξης"
 msgid "No change"
 msgstr "Καμία αλλαγή"
 msgid "Finish pull request"
 msgstr "Τερματισμός αιτήματος έλξης"
 msgid "Close"
 msgstr "Κλείσιμο"
 msgid "Comment"
 msgstr "Σχολιασμός"
 msgid "You need to be logged in to comment."
 msgstr "Πρέπει να είστε συνδεδεμένος για να σχολιάσετε."
 msgid "Login now"
 msgstr "Συνδεθείτε τώρα"
 msgid "Hide"
 msgstr "Απόκρυψη"
 msgid "%d comment"
 msgid_plural "%d comments"
 msgstr[0] "%d σχόλιο"
 msgstr[1] "%d σχόλια"
 msgid "%d inline"
 msgid_plural "%d inline"
 msgstr[0] "%d ενσωματωμένο"
 msgstr[1] "%d ενσωματωμένα"
 msgid "%d general"
 msgid_plural "%d general"
 msgstr[0] "%d γενικά"
 msgstr[1] "%d γενικά"
 msgid "%s Changesets"
 msgstr "Σετ αλλαγών του %s"
 msgid "Changeset status: %s"
 msgstr "Κατάσταση σετ αλλαγών: %s"
 msgid "Files affected"
 msgstr "Αρχεία που επηρεάστηκαν"
 msgid "No file before"
 msgstr "Δεν υπάρχει αρχείο πριν"
 msgid "File before"
 msgstr "Αρχείο πριν"
 msgid "Modified"
 msgstr "Τροποποιημένο"
 msgid "Deleted"
 msgstr "Διαγράφηκε"
 msgid "Renamed"
 msgstr "Μετονομάστηκε"
 msgid "Unknown operation: %r"
 msgstr "Άγνωστη λειτουργία: %r"
 msgid "No file after"
 msgstr "Δεν υπάρχει αρχείο μετά"
 msgid "File after"
 msgstr "Αρχείο μετά"
 msgid "Show full diff for this file"
 msgstr "Εμφάνιση πλήρους διαφοράς για αυτό το αρχείο"
 msgid "Show full side-by-side diff for this file"
 msgstr "Εμφάνιση πλήρους διαφοράς δίπλα-δίπλα για αυτό το αρχείο"
 msgid "Show inline comments"
 msgstr "Εμφάνιση ενσωματωμένων σχολίων"
 msgid "No changesets"
 msgstr "Χωρίς σετ αλλαγών"
 msgid "Criss cross merge situation with multiple merge ancestors detected!"
 msgstr ""
 "Εντοπίστηκε κατάσταση διασταυρούμενης συγχώνευσης με πολλούς προγόνους "
 "συγχώνευσης!"
 msgid ""
 "Please merge the target branch to your branch before creating a pull "
 "request."
 msgstr ""
 "Παρακαλώ συγχωνεύστε τον κλάδο-στόχο στον κλάδο σας πριν δημιουργήσετε "
 "ένα αίτημα έλξης."
 msgid "Merge Ancestor"
 msgstr "Πρόγονος Συγχώνευσης"
 msgid "Show merge diff"
 msgstr "Εμφάνιση διαφοράς συγχώνευσης"
 msgid "is"
 msgstr "είναι"
 msgid "%s changesets"
 msgstr "%s σετ αλλαγών"
 msgid "behind"
 msgstr "πίσω"
 msgid "%s Compare"
 msgstr "Σύγκριση %s"
 msgid "Compare Revisions"
 msgstr "Σύγκριση Αναθεωρήσεων"
 msgid "Swap"
 msgstr "Ανταλαγή"
 msgid "Compare revisions, branches, bookmarks, or tags."
 msgstr "Συγκρίνετε αναθεωρήσεις, κλάδους, σελιδοδείκτες ή ετικέτες."
 msgid "Showing %s commit"
 msgid_plural "Showing %s commits"
 msgstr[0] "Εμφάνιση %s commit"
 msgstr[1] "Εμφάνιση %s commits"
 msgid "Show full diff"
 msgstr "Εμφάνιση πλήρους διαφοράς"
 msgid "Public repository"
 msgstr "Δημόσιο αποθετήριο"
 msgid "Repository creation in progress..."
 msgstr "Η δημιουργία αποθετηρίου βρίσκεται σε εξέλιξη..."
 msgid "No changesets yet"
 msgstr "Δεν υπάρχουν ακόμα σετ αλλαγών"
 msgid "Subscribe to %s rss feed"
 msgstr "Εγγραφή στην τροφοδοσία rss του %s"
 msgid "Subscribe to %s atom feed"
 msgstr "Εγγραφή στην τροφοδοσία του %s atom"
 msgid "Creating"
 msgstr "Δημιουργία σε εξέλιξη"
 msgid "Mention in Comment on Changeset \"%s\""
 msgstr "Αναφορά στο Σχόλιο για το σετ αλλαγών \"%s\""
 msgid "Comment on Changeset \"%s\""
 msgstr "Σχόλιο για το σετ αλλαγών \"%s\""
 msgid "Changeset on"
 msgstr "Σετ αλλαγών σε"
 msgid "branch"
 msgstr "κλάδος"
 msgid "by"
 msgstr "από"
 msgid "Status change:"
 msgstr "Αλλαγή κατάστασης:"
 msgid "The pull request has been closed."
 msgstr "Το αίτημα έλξης έχει κλείσει."
 msgid "Hello %s"
 msgstr "Γεια σας %s"
 msgid "We have received a request to reset the password for your account."
 msgstr ""
 "Λάβαμε ένα αίτημα για επαναφορά του κωδικού πρόσβασης για το λογαριασμό "
 "σας."
 msgid ""
 "This account is however managed outside this system and the password "
 "cannot be changed here."
 msgstr ""
 "Ωστόσο, η διαχείριση αυτού του λογαριασμού γίνεται εκτός αυτού του "
 "συστήματος και ο κωδικός πρόσβασης δεν μπορεί να αλλάξει εδώ."
 msgid "To set a new password, click the following link"
 msgstr ""
 "Για να ορίσετε έναν νέο κωδικό πρόσβασης, κάντε κλικ στον ακόλουθο "
 "σύνδεσμο"
 msgid ""
 "Should you not be able to use the link above, please type the following "
 "code into the password reset form"
 msgstr ""
 "Εάν δεν μπορείτε να χρησιμοποιήσετε τον παραπάνω σύνδεσμο, πληκτρολογήστε "
 "τον ακόλουθο κώδικα στη φόρμα επαναφοράς κωδικού πρόσβασης"
 msgid ""
 "If it weren't you who requested the password reset, just disregard this "
 "message."
 msgstr ""
 "Αν δεν ήσασταν εσείς που ζητήσατε την επαναφορά κωδικού πρόσβασης, απλώς "
 "αγνοήστε αυτό το μήνυμα."
 msgid "Mention on Pull Request %s \"%s\" by %s"
 msgstr "Αναφορά στην αίτημα έλξης %s \"%s\" από %s"
 msgid "Added as Reviewer of Pull Request %s \"%s\" by %s"
 msgstr "Προστεθήκατε ως αναθεωρητής του αιτήματος έλξης %s \"%s\" από %s"
 msgid "Pull request"
 msgstr "Αίτημα έλξης"
 msgid "from"
 msgstr "από"
 msgid "to"
 msgstr "προς"
 msgid "Mention in Comment on Pull Request %s \"%s\""
 msgstr "Αναφορά στο σχόλιο για το αίτημα έλξης %s \"%s\""
 msgid "Pull Request %s \"%s\" Closed"
 msgstr "Το αίτημα έλξης %s \"%s\" είναι Κλειστό"
 msgid "Comment on Pull Request %s \"%s\""
 msgstr "Σχόλιο στην αίτηση έλξης %s \"%s\""
 msgid "Full Name"
 msgstr "Ονοματεπώνυμο"
 msgid "%s File side-by-side diff"
 msgstr "%s Αρχείο διαφοράς δίπλα-δίπλα"
 msgid "File diff"
 msgstr "Αρχείο διαφοράς"
 msgid "%s File Diff"
 msgstr "%s Αρχείο διαφοράς"
 msgid "%s Files"
 msgstr "%s Αρχεία"
 msgid "%s Files Add"
 msgstr "%s Προσθήκη Αρχείων"
 msgid "Add New File"
 msgstr "Προσθήκη Νέου Αρχείου"
 msgid "Location"
 msgstr "Τοποθεσία"
 msgid "Enter filename..."
 msgstr "Εισαγωγή ονόματος αρχείου..."
 msgid "or"
 msgstr "ή"
 msgid "Upload File"
 msgstr "Ανέβασμα Αρχείου"
 msgid "Create New File"
 msgstr "Δημιουργία Νέου Αρχείου"
 msgid "New file type"
 msgstr "Νέος τύπος αρχείου"
 msgid "Commit Message"
 msgstr "Μήνυμα Υποβολής"
 msgid "Commit Changes"
 msgstr "Υποβολή Των Αλλαγών"
 msgid "Search File List"
 msgstr "Αναζήτηση στη Λίστα Αρχείων"
 msgid "Loading file list..."
 msgstr "Φόρτωση λίστας αρχείων..."
 msgid "Size"
 msgstr "Μέγεθος"
 msgid "Last Revision"
 msgstr "Τελευταία Αναθεώρηση"
 msgid "Last Modified"
 msgstr "Τελευταία Τροποποίηση"
 msgid "Last Committer"
 msgstr "Τελευταίος Υποβάλλων"
 msgid "%s Files Delete"
 msgstr "%s Διαγραφή Αρχείων"
 msgid "Delete file"
 msgstr "Διαγραφή αρχείου"
 msgid "%s File Edit"
 msgstr "%s Επεξεργασία Αρχείου"
 msgid "Edit file"
 msgstr "Επεξεργασία αρχείου"
 msgid "Show Annotation"
 msgstr "Εμφάνιση Σχολιασμού"
 msgid "Download as Raw"
 msgstr "Λήψη ως ακατέργαστο"
 msgid "Source"
 msgstr "Πηγή"
 msgid "%s author"
 msgid_plural "%s authors"
 msgstr[0] "%s συντάκτης"
 msgstr[1] "%s συντάκτες"
 msgid "Diff to Revision"
 msgstr "Διαφορά σε Αναθεώρηση"
 msgid "Show at Revision"
 msgstr "Εμφάνιση στην Αναθεώρηση"
 msgid "Show Full History"
 msgstr "Εμφάνιση Πλήρους Ιστορικού"
 msgid "Show Authors"
 msgstr "Εμφάνιση Συντακτών"
 msgid "Show Source"
 msgstr "Εμφάνιση Πηγής"
 msgid "Edit on Branch: %s"
 msgstr "Επεξεργασία στον κλάδο: %s"
 msgid "Editing binary files not allowed"
 msgstr "Η επεξεργασία δυαδικών αρχείων δεν επιτρέπεται"
 msgid "Editing files allowed only when on branch head revision"
 msgstr ""
 "Η επεξεργασία αρχείων επιτρέπεται μόνο σε αναθεώρηση επί της κεφαλής του "
 "κλάδου"
 msgid "Deleting files allowed only when on branch head revision"
 msgstr ""
 "Η διαγραφή αρχείων επιτρέπεται μόνο σε αναθεώρηση επί της κεφαλής του "
 "κλάδου"
 msgid "Binary file (%s)"
 msgstr "Δυαδικό αρχείο (%s)"
 msgid "File is too big to display."
 msgstr "Το αρχείο είναι πολύ μεγάλο για προβολή."
 msgid "Show full annotation anyway."
 msgstr "Εμφάνιση πλήρους σχολιασμού ούτως ή άλλως."
 msgid "Show as raw."
 msgstr "Ακατέργαστη εμφάνιση."
 msgid "annotation"
 msgstr "σχολιασμός"
 msgid "Go Back"
 msgstr "Πήγαινε Πίσω"
 msgid "No files at given path"
 msgstr "Δεν υπάρχουν αρχεία στη δοσμένη διαδρομή"
 msgid "%s Followers"
 msgstr "%s Ακόλουθοι"
 msgid "Followers"
 msgstr "Ακόλουθοι"
 msgid "Started following -"
 msgstr "Ξεκίνησαν να ακολουθούν -"
 msgid "Default revision for files page, downloads, whoosh, and readme."
 msgstr ""
 "Προεπιλεγμένη αναθεώρηση για τη σελίδα αρχείων, λήψεων, whoosh, και "
 "readme."
 msgid "Private"
 msgstr "Ιδιωτικό"
 msgid "Copy permissions"
 msgstr "Αντιγραφή δικαιωμάτων"
 msgid "Update after clone"
 msgstr "Ενημέρωση μετά την κλωνοποίηση"
 msgid "Checkout source after making a clone"
 msgstr "Πηγαίνετε στον κώδικα μετά την κλωνοποίηση"
 msgid "ATOM journal feed"
 msgstr "Ημερολόγιο τροφοδοσίας ATOM"
 msgid "RSS journal feed"
 msgstr "Ημερολόγιο τροφοδοσίας RSS"
 msgid "My Repositories"
 msgstr "Τα αποθετήριά μου"
 msgid "No entries yet"
 msgstr "Δεν υπάρχουν ακόμη καταχωρήσεις"
 msgid "ATOM public journal feed"
 msgstr "Δημόσιο ημερολόγιο τροφοδοσίας ATOM"
 msgid "RSS public journal feed"
 msgstr "Δημόσιο ημερολόγιο τροφοδοσίας RSS"
 msgid "New Pull Request"
 msgstr "Νέο Αίτημα Έλξης"
 msgid "Title"
 msgstr "Τίτλος"
 msgid "Summarize the changes - or leave empty"
 msgstr "Συνοψίστε τις αλλαγές - ή αφήστε το κενό"
 msgid "Write a short description on this pull request"
 msgstr "Γράψτε μια σύντομη περιγραφή σχετικά με αυτό το αίτημα έλξης"
 msgid "Changeset flow"
 msgstr "Ροή σετ αλλαγών"
 msgid "Origin repository"
 msgstr "Αποθετήριο προέλευσης"
 msgid "Revision"
 msgstr "Αναθεώρηση"
 msgid "Destination repository"
 msgstr "Αποθετήριο προορισμού"
 msgid "No entries"
 msgstr "Χωρίς καταχωρήσεις"
 msgid "Vote"
 msgstr "Ψήφος"
 msgid "Age"
 msgstr "Ηλικία"
 msgid "From"
 msgstr "Από"
 msgid "To"
 msgstr "Προς"
 msgid "You voted: %s"
 msgstr "Ψηφίσατε: %s"
 msgid "You didn't vote"
 msgstr "Δεν ψηφίσατε"
 msgid "(no title)"
 msgstr "(χωρίς τίτλο)"
 msgid "Closed"
 msgstr "Κλειστό"
 msgid "Delete Pull Request"
 msgstr "Διαγραφή Αιτήματος Έλξης"
 msgid "Confirm to delete this pull request"
 msgstr "Επιβεβαίωση διαγραφής αυτού του αιτήματος έλξης"
 msgid "Confirm again to delete this pull request with %s comments"
 msgstr ""
 "Επιβεβαίωση ξανά για τη διαγραφή αυτού του αιτήματος έλξης με %s σχόλια"
 msgid "%s Pull Request %s"
 msgstr "%s Αίτημα Έλξης %s"
 msgid "Pull request %s from %s#%s"
 msgstr "Αίτημα έλξης %s από %s#%s"
 msgid "Summarize the changes"
 msgstr "Σύνοψη των αλλαγών"
 msgid "Voting Result"
 msgstr "Αποτέλεσμα Ψηφοφορίας"
 msgid "Pull request status calculated from votes"
 msgstr "Η κατάσταση του αιτήματος έλξης υπολογισμένο από τις ψήφους"
 msgid "Origin"
 msgstr "Προέλευση"
 msgid "on"
 msgstr "επί"
 msgid "Target"
 msgstr "Στόχος"
 msgid ""
 "This is just a range of changesets and doesn't have a target or a real "
 "merge ancestor."
 msgstr ""
 "Αυτό είναι μόνο μια σειρά από σετ αλλαγών και δεν έχει προορισμό ή "
 "πραγματικό πρόγονο συγχώνευσης."
 msgid "Pull changes"
 msgstr "Τράβηγμα αλλαγών"
 msgid "Next iteration"
 msgstr "Επόμενη επανάληψη"
 msgid "Current revision - no change"
 msgstr "Τρέχουσα αναθεώρηση - καμία αλλαγή"
 msgid ""
 "Pull request iterations do not change content once created. Select a "
 "revision to create a new iteration."
 msgstr ""
 "Οι επαναλήψεις αιτήσεων έλξης δεν αλλάζουν περιεχόμενο μετά τη δημιουργία "
 "τους. Επιλέξτε μια αναθεώρηση για να δημιουργήσετε μια νέα επανάληψη."
 msgid "Save Changes"
 msgstr "Αποθήκευση Αλλαγών"
 msgid "Create New Iteration with Changes"
 msgstr "Δημιουργία Νέας Επανάληψης με τις Αλλαγές"
 msgid "Cancel Changes"
 msgstr "Ακύρωση Αλλαγών"
 msgid "Reviewers"
 msgstr "Επιθεωρητές"
 msgid "Remove reviewer"
 msgstr "Κατάργηση επιθεωρητή"
 msgid "Type name of reviewer to add"
 msgstr "Πληκτρολογήστε το όνομα του επιθεωρητή για προσθήκη"
 msgid "Potential Reviewers"
 msgstr "Πιθανοί Επιθεωρητές"
 msgid "Click to add the repository owner as reviewer:"
 msgstr ""
 "Κάντε κλικ για να προσθέσετε τον κάτοχο του αποθετηρίου ως επιθεωρητή:"
 msgid "Pull Request Content"
 msgstr "Περιεχόμενο Αιτήματος Έλξης"
 msgid "Common ancestor"
 msgstr "Κοινός πρόγονος"
 msgid "%s Pull Requests"
 msgstr "%s Αιτήματα Έλξης"
 msgid "Pull Requests from '%s'"
 msgstr "Αιτήματα Έλξης από '%s'"
 msgid "Pull Requests to '%s'"
 msgstr "Αιτήματα Έλξης προς '%s'"
 msgid "Open New Pull Request"
 msgstr "Άνοιγμα Νέου Αιτήματος Έλξης"
 msgid "Show Pull Requests to %s"
 msgstr "Εμφάνιση Αιτημάτων Έλξης προς %s"
 msgid "Show Pull Requests from '%s'"
 msgstr "Εμφάνιση Αιτημάτων Έλξης από '%s'"
 msgid "Hide closed pull requests (only show open pull requests)"
 msgstr ""
 "Απόκρυψη κλειστών αιτημάτων έλξης (εμφάνιση μόνο ανοικτών αιτημάτων έλξης)"
 msgid "Show closed pull requests (in addition to open pull requests)"
 msgstr ""
 "Εμφάνιση κλειστών αιτημάτων έλξης (εκτός από τα ανοιχτά αιτήματα έλξης)"
 msgid "Pull Requests Created by Me"
 msgstr "Αιτήματα Έλξης που Δημιουργήθηκαν από Εμένα"
 msgid "Pull Requests Needing My Review"
 msgstr "Αιτήματα Έλξης που Χρειάζονται την Επιθεώρησή μου"
 msgid "Pull Requests I Participate In"
 msgstr "Αιτήματα Έλξης που Συμμετέχω"
 msgid "%s Search"
 msgstr "%s Αναζήτηση"
 msgid "Search in All Repositories"
 msgstr "Αναζήτηση σε Όλα τα Αποθετήρια"
 msgid "Search term"
 msgstr "Όρος αναζήτησης"
 msgid "Search in"
 msgstr "Αναζήτηση σε"
 msgid "File contents"
 msgstr "Περιεχόμενα αρχείου"
 msgid "Commit messages"
 msgstr "Μηνύματα commit"
 msgid "File names"
 msgstr "Ονόματα αρχείων"
 msgid "Permission denied"
 msgstr "Άρνηση δικαιώματος"
 msgid "%s Statistics"
 msgstr "%s Στατιστικά"
 msgid "%s ATOM feed"
 msgstr "%s Τροφοδοσία ATOM"
 msgid "%s RSS feed"
 msgstr "%s Τροφοδοσία RSS"
 msgid "Enable"
 msgstr "Ενεργοποίηση"
 msgid "Stats gathered: "
 msgstr "Στατιστικά που συγκεντρώθηκαν: "
 msgid "files"
 msgstr "αρχεία"
 msgid "Show more"
 msgstr "Εμφάνιση περισσότερων"
 msgid "commits"
 msgstr "commits"
 msgid "files added"
 msgstr "αρχεία που προστέθηκαν"
 msgid "files changed"
 msgstr "αρχεία που άλλαξαν"
 msgid "files removed"
 msgstr "αρχεία που αφαιρέθηκαν"
 msgid "commit"
 msgstr "commit"
 msgid "file added"
 msgstr "αρχείο προστέθηκε"
 msgid "file changed"
 msgstr "αρχείο άλλαξε"
 msgid "file removed"
 msgstr "αρχείο αφαιρέθηκε"
 msgid "%s Summary"
 msgstr "%s Σύνοψη"
 msgid "Clone from"
 msgstr "Κλώνος από"
 msgid "Clone URL"
 msgstr "Clone URL"
 msgid "Use ID"
 msgstr "Χρήση ID"
 msgid "Use SSH"
 msgstr "Χρήση SSH"
 msgid "Use Name"
 msgstr "Χρήση Ονόματος"
 msgid "Use HTTP"
 msgstr "Χρήση HTTP"
 msgid "Trending files"
 msgstr "Δημοφιλή αρχεία"
 msgid "Download"
 msgstr "Λήψη"
 msgid "There are no downloads yet"
 msgstr "Δεν υπάρχουν λήψεις ακόμα"
 msgid "Downloads are disabled for this repository"
 msgstr "Οι λήψεις είναι απενεργοποιημένες για αυτό το αποθετήριο"
 msgid "Download as zip"
 msgstr "Λήψη ως zip"
 msgid "Check this to download archive with subrepos"
 msgstr "Επιλέξτε αυτό για τη λήψη του αρχείου με τα υπο-αποθετήρια"
 msgid "With subrepos"
 msgstr "Με υπο-αποθετήρια"
 msgid "Feed"
 msgstr "Ροή"
 msgid "Latest Changes"
 msgstr "Τελευταίες Αλλαγές"
 msgid "Quick Start"
 msgstr "Γρήγορη Εκκίνηση"
 msgid "Add or upload files directly via Kallithea"
 msgstr "Προσθέστε ή ανεβάστε αρχεία απευθείας μέσω Καλλιθέας"
 msgid "Push new repository"
 msgstr "Ώθηση νέου αποθετηρίου"
 msgid "Existing repository?"
 msgstr "Υπάρχον αποθετήριο;"
 msgid "Readme file from revision %s:%s"
 msgstr "Αρχείο Readme από την αναθεώρηση %s:%s"
 msgid "Download %s as %s"
 msgstr "Λήψη %s ως %s"

Changeset was too big and was cut off... Show full diff anyway

0 comments (0 inline, 0 general)