kallithea Changeset - 8628c8706bf8

Changeset - 8628c8706bf8

Parent rev.

Child rev.

[Not reviewed]

Merge beta

0 14 0

Nicolas VINOT - 14 years ago 2011-10-22 23:18:03
aeris@imirhil.fr

[API] Update doc

14 files changed with 305 insertions and 39 deletions:

development.ini

docs/api/api.rst

266

production.ini

rhodecode/config/deployment.ini_tmpl

rhodecode/lib/__init__.py

rhodecode/lib/auth_ldap.py

rhodecode/lib/celerylib/tasks.py

rhodecode/lib/smtp_mailer.py

rhodecode/model/db.py

rhodecode/templates/admin/repos_groups/repos_groups_add.html

rhodecode/templates/admin/repos_groups/repos_groups_edit.html

rhodecode/templates/admin/settings/settings.html

rhodecode/templates/admin/users/user_edit.html

rhodecode/templates/admin/users_groups/users_group_edit.html

0 comments (0 inline, 0 general)

development.ini

➞

Show inline comments

 ################################################################################
 ################################################################################
 # RhodeCode - Pylons environment configuration                                 #
 #                                                                              #
 # The %(here)s variable will be replaced with the parent directory of this file#
 ################################################################################
 [DEFAULT]
 debug = true
 pdebug = false
 ################################################################################
 ## Uncomment and replace with the address which should receive                ##
 ## any error reports after application crash                                  ##
 ## Additionally those settings will be used by RhodeCode mailing system       ##
 ################################################################################
 #email_to = admin@localhost
 #error_email_from = paste_error@localhost
 #app_email_from = rhodecode-noreply@localhost
 #error_message =
 #smtp_server = mail.server.com
 #smtp_username =
 #smtp_password =
 #smtp_port =
 #smtp_use_tls = false
 #smtp_use_ssl = true
 # Specify available auth parameters here (e.g. LOGIN PLAIN CRAM-MD5, etc.)
 #smtp_auth =
 [server:main]
 ##nr of threads to spawn
 threadpool_workers = 5
 ##max request before thread respawn
 threadpool_max_requests = 6
 ##option to use threads of process
 use_threadpool = true
 use = egg:Paste#http
 host = 0.0.0.0
 port = 5000
 [app:main]
 use = egg:rhodecode
 full_stack = true
 static_files = true
 lang=en
 cache_dir = %(here)s/data
 index_dir = %(here)s/data/index
 app_instance_uuid = develop
 cut_off_limit = 256000
 force_https = false
 commit_parse_limit = 25
 use_gravatar = true
 ####################################
 ###        CELERY CONFIG        ####
 ####################################
 use_celery = false
 broker.host = localhost
 broker.vhost = rabbitmqhost
 broker.port = 5672
 broker.user = rabbitmq
 broker.password = qweqwe
 celery.imports = rhodecode.lib.celerylib.tasks
 celery.result.backend = amqp
 celery.result.dburi = amqp://
 celery.result.serialier = json
 #celery.send.task.error.emails = true
 #celery.amqp.task.result.expires = 18000
 celeryd.concurrency = 2
 #celeryd.log.file = celeryd.log
 celeryd.log.level = debug
 celeryd.max.tasks.per.child = 1
 #tasks will never be sent to the queue, but executed locally instead.
 celery.always.eager = false
 ####################################
 ###         BEAKER CACHE        ####
 ####################################
 beaker.cache.data_dir=%(here)s/data/cache/data
 beaker.cache.lock_dir=%(here)s/data/cache/lock
 beaker.cache.regions=super_short_term,short_term,long_term,sql_cache_short,sql_cache_med,sql_cache_long
 beaker.cache.super_short_term.type=memory
 beaker.cache.super_short_term.expire=10
 beaker.cache.short_term.type=memory
 beaker.cache.short_term.expire=60
 beaker.cache.long_term.type=memory
 beaker.cache.long_term.expire=36000
 beaker.cache.sql_cache_short.type=memory
 beaker.cache.sql_cache_short.expire=10
 beaker.cache.sql_cache_med.type=memory
 beaker.cache.sql_cache_med.expire=360
 beaker.cache.sql_cache_long.type=file
 beaker.cache.sql_cache_long.expire=3600
 ####################################
 ###       BEAKER SESSION        ####
 ####################################
 ## Type of storage used for the session, current types are
 ## dbm, file, memcached, database, and memory.
 ## The storage uses the Container API
 ##that is also used by the cache system.
 beaker.session.type = file
 beaker.session.key = rhodecode
 beaker.session.secret = g654dcno0-9873jhgfreyu
 beaker.session.timeout = 36000
 ##auto save the session to not to use .save()
 beaker.session.auto = False
 ##true exire at browser close
 #beaker.session.cookie_expires = 3600
 ################################################################################
 ## WARNING: *THE LINE BELOW MUST BE UNCOMMENTED ON A PRODUCTION ENVIRONMENT*  ##
 ## Debug mode will enable the interactive debugging tool, allowing ANYONE to  ##
 ## execute malicious code after an exception is raised.                       ##
 ################################################################################
 #set debug = false
 ##################################
 ###       LOGVIEW CONFIG       ###
 ##################################
 logview.sqlalchemy = #faa
 logview.pylons.templating = #bfb
 logview.pylons.util = #eee
 #########################################################
 ### DB CONFIGS - EACH DB WILL HAVE IT'S OWN CONFIG    ###
 #########################################################
 #sqlalchemy.db1.url = sqlite:///%(here)s/rhodecode.db
 sqlalchemy.db1.url = postgresql://postgres:qwe@localhost/rhodecode
 sqlalchemy.db1.echo = false
 sqlalchemy.db1.pool_recycle = 3600
 sqlalchemy.convert_unicode = true
 ################################
 ### LOGGING CONFIGURATION   ####
 ################################
 [loggers]
 keys = root, routes, rhodecode, sqlalchemy, beaker, templates
 [handlers]
 keys = console, console_sql
 [formatters]
 keys = generic, color_formatter, color_formatter_sql
 #############
 ## LOGGERS ##
 #############
 [logger_root]
 level = NOTSET
 handlers = console
 [logger_routes]
 level = DEBUG
 handlers =
 qualname = routes.middleware
 # "level = DEBUG" logs the route matched and routing variables.
 propagate = 1
 [logger_beaker]
 level = DEBUG
 handlers =
 qualname = beaker.container
 propagate = 1
 [logger_templates]
 level = INFO
 handlers =
 qualname = pylons.templating
 propagate = 1
 [logger_rhodecode]
 level = DEBUG
 handlers =
 qualname = rhodecode
 propagate = 1
 [logger_sqlalchemy]
 level = INFO
 handlers = console_sql
 qualname = sqlalchemy.engine
 propagate = 0
 ##############
 ## HANDLERS ##
 ##############
 [handler_console]
 class = StreamHandler
 args = (sys.stderr,)
 level = DEBUG
 formatter = color_formatter
 [handler_console_sql]
 class = StreamHandler
 args = (sys.stderr,)
 level = DEBUG
 formatter = color_formatter_sql
 ################
 ## FORMATTERS ##

docs/api/api.rst

➞

Show inline comments

 .. _api:
 API
 ===
 Starting from RhodeCode version 1.2 a simple API was implemented.
 There's a single schema for calling all api methods. API is implemented
 with JSON protocol both ways. An url to send API request in RhodeCode is
 <your_server>/_admin/api
 All clients need to send JSON data in such format::
+    {
         "api_key":"<api_key>",
         "method":"<method_name>",
         "args":{"<arg_key>":"<arg_val>"}
+    }
 Example call for autopulling remotes repos using curl::
     curl https://server.com/_admin/api -X POST -H 'content-type:text/plain' --data-binary '{"api_key":"xe7cdb2v278e4evbdf5vs04v832v0efvcbcve4a3","method":"pull","args":{"repo":"CPython"}}'
 Simply provide
  - *api_key* for access and permission validation.
  - *method* is name of method to call
  - *args* is an key:value list of arguments to pass to method
 .. note::
     api_key can be found in your user account page
 RhodeCode API will return always a JSON formatted answer::
+    {
         "result": "<result>",
         "error": null
+    }
 All responses from API will be `HTTP/1.0 200 OK`, if there's an error while
 calling api *error* key from response will contain failure description
 and result will be null.
 API METHODS
 +++++++++++
 pull
 ----
 Pulls given repo from remote location. 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
 INPUT::
     api_key:"<api_key>"
     method: "pull"
     args: {"repo":<repo_name>}
     args :    {
                 "repo" : "<repo_name>"
+              }
 OUTPUT::
     result:"Pulled from <repo_name>"
     error:null
 get_users
 ---------
 Lists all existing users. This command can be executed only using api_key
 belonging to user with admin rights.
 INPUT::
     api_key : "<api_key>"
     method :  "get_users"
     args :    { }
 OUTPUT::
     result: [
+              {
                 "id" :       "<id>",
                 "username" : "<username>",
                 "firstname": "<firstname>",
                 "lastname" : "<lastname>",
                 "email" :    "<email>",
                 "active" :   "<bool>",
                 "admin" :    "<bool>",
                 "ldap" :     "<ldap_dn>"
               },
     	      …
+            ]
     error:  null
 create_user
 -----------
 Creates new user in RhodeCode. This command can be executed only using api_key
 belonging to user with admin rights
+belonging to user with admin rights.
 INPUT::
     api_key:"<api_key>"
     method: "create_user"
     args: {"username": "<username>",
     args :    {
                 "username" :  "<username>",
            "password": "<password>",
            "active":   "<bool>",
            "admin":    "<bool>",
            "name":     "<firstname>",
                 "firstname" : "<firstname>",
            "lastname": "<lastname>",
            "email":    "<useremail>"}
                 "email" :     "<useremail>"
                 "active" :    "<bool> = True",
                 "admin" :     "<bool> = False",
                 "ldap_dn" :   "<ldap_dn> = None"
+              }
 OUTPUT::
     result: {
               "msg" : "created new user <username>"
+            }
     error:  null
 get_users_groups
 ----------------
 Lists all existing users groups. This command can be executed only using api_key
 belonging to user with admin rights.
 INPUT::
     api_key : "<api_key>"
     method :  "get_users_groups"
     args :    { }
 OUTPUT::
     result:{"id": <newuserid>,
             "msg":"created new user <username>"}
     result : [
+               {
                  "id" :       "<id>",
                  "name" :     "<name>",
                  "active":    "<bool>",
                  "members" :  [
+	    	                    {
 	    	                      "id" :       "<userid>",
 	                              "username" : "<username>",
 	                              "firstname": "<firstname>",
 	                              "lastname" : "<lastname>",
 	                              "email" :    "<email>",
 	                              "active" :   "<bool>",
 	                              "admin" :    "<bool>",
 	                              "ldap" :     "<ldap_dn>"
 	                            },
 	    	                    …
+	                          ]
+	            }
+              ]
     error:null
 get_users_group
 ---------------
 Gets an existing users group. This command can be executed only using api_key
 belonging to user with admin rights.
 INPUT::
     api_key : "<api_key>"
     method :  "get_users_group"
     args :    {
                 "group_name" : "<name>"
+              }
 OUTPUT::
     result : None if group not exist
+             {
                "id" :       "<id>",
                "name" :     "<name>",
                "active":    "<bool>",
                "members" :  [
 	    	                  { "id" :       "<userid>",
 	                            "username" : "<username>",
 	                            "firstname": "<firstname>",
 	                            "lastname" : "<lastname>",
 	                            "email" :    "<email>",
 	                            "active" :   "<bool>",
 	                            "admin" :    "<bool>",
 	                            "ldap" :     "<ldap_dn>"
 	                          },
 	    	                  …
+	                        ]
+             }
     error : null
 create_users_group
 ------------------
 creates new users group. This command can be executed only using api_key
 Creates new users group. This command can be executed only using api_key
 belonging to user with admin rights
 INPUT::
     api_key : "<api_key>"
     method :  "create_users_group"
     args:     {
                 "name":  "<name>",
                 "active":"<bool> = True"
+              }
 OUTPUT::
     result: {
               "id":  "<newusersgroupid>",
               "msg": "created new users group <name>"
+            }
     error:  null
 add_user_to_users_groups
 ------------------------
 Adds a user to a users group. This command can be executed only using api_key
 belonging to user with admin rights
 INPUT::
     api_key:"<api_key>"
     method: "create_user"
     args: {"name":  "<groupname>",
            "active":"<bool>"}
     method :  "add_user_users_group"
     args:     {
                 "group_name" :  "<groupname>",
                 "user_name" :   "<username>"
+              }
 OUTPUT::
     result: {
               "id":  "<newusersgroupmemberid>",
               "msg": "created new users group member"
+            }
     error:  null
 get_repos
 ---------
 Lists all existing repositories. This command can be executed only using api_key
 belonging to user with admin rights
 INPUT::
     api_key : "<api_key>"
     method :  "get_repos"
     args:     { }
 OUTPUT::
     result: [
+              {
                 "id" :          "<id>",
                 "name" :        "<name>"
                 "type" :        "<type>",
                 "description" : "<description>"
               },
               …
+            ]
     error:  null
 get_repo
 --------
 Gets an existing repository. This command can be executed only using api_key
 belonging to user with admin rights
 INPUT::
     api_key : "<api_key>"
     method :  "get_repo"
     args:     {
                 "name" : "<name>"
+              }
 OUTPUT::
     result:{"id": <newusersgroupid>,
             "msg":"created new users group <groupname>"}
     result: None if repository not exist
+            {
                 "id" :          "<id>",
                 "name" :        "<name>"
                 "type" :        "<type>",
                 "description" : "<description>",
                 "members" :     [
                                   { "id" :         "<userid>",
 	                                "username" :   "<username>",
 	                                "firstname":   "<firstname>",
 	                                "lastname" :   "<lastname>",
 	                                "email" :      "<email>",
 	                                "active" :     "<bool>",
 	                                "admin" :      "<bool>",
 	                                "ldap" :       "<ldap_dn>",
 	                                "permission" : "repository_(read|write|admin)"
 	                              },
                                   …
+                                  {
                                     "id" :       "<usersgroupid>",
                                     "name" :     "<usersgroupname>",
                                     "active":    "<bool>",
                                     "permission" : "repository_(read|write|admin)"
                                   },
                                   …
+                                ]
+            }
     error:null
 create_repo
 -----------
 Creates a repository. This command can be executed only using api_key
 belonging to user with admin rights.
 If repository name contains "/", all needed repository groups will be created.
 For example "foo/bar/baz" will create groups "foo", "bar" (with "foo" as parent),
 and create "baz" repository with "bar" as group.
 INPUT::
     api_key : "<api_key>"
     method :  "create_repo"
     args:     {
                 "name" :        "<name>",
                 "owner_name" :  "<ownername>",
                 "description" : "<description> = ''",
                 "repo_type" :   "<type> = 'hg'",
                 "private" :     "<bool> = False"
+              }
 OUTPUT::
     result: None
     error:  null
 add_user_to_repo
 ----------------
 Add a user to a repository. This command can be executed only using api_key
 belonging to user with admin rights.
 If "perm" is None, user will be removed from the repository.
 INPUT::
     api_key : "<api_key>"
     method :  "add_user_to_repo"
     args:     {
                 "repo_name" :  "<reponame>",
                 "user_name" :  "<username>",
                 "perm" :       "(None|repository_(read|write|admin))",
+              }
 OUTPUT::
     result: None
     error:  null

production.ini

➞

Show inline comments

 ################################################################################
 ################################################################################
 # RhodeCode - Pylons environment configuration                                 #
 #                                                                              #
 # The %(here)s variable will be replaced with the parent directory of this file#
 ################################################################################
 [DEFAULT]
 debug = true
 pdebug = false
 ################################################################################
 ## Uncomment and replace with the address which should receive                ##
 ## any error reports after application crash                                  ##
 ## Additionally those settings will be used by RhodeCode mailing system       ##
 ################################################################################
 #email_to = admin@localhost
 #error_email_from = paste_error@localhost
 #app_email_from = rhodecode-noreply@localhost
 #error_message =
 #smtp_server = mail.server.com
 #smtp_username =
 #smtp_password =
 #smtp_port =
 #smtp_use_tls = false
 #smtp_use_ssl = true
 # Specify available auth parameters here (e.g. LOGIN PLAIN CRAM-MD5, etc.)
 #smtp_auth =
 [server:main]
 ##nr of threads to spawn
 threadpool_workers = 5
 ##max request before thread respawn
 threadpool_max_requests = 10
 ##option to use threads of process
 use_threadpool = true
 use = egg:Paste#http
 host = 127.0.0.1
 port = 8001
 [app:main]
 use = egg:rhodecode
 full_stack = true
 static_files = true
 lang=en
 cache_dir = %(here)s/data
 index_dir = %(here)s/data/index
 app_instance_uuid = prod1234
 cut_off_limit = 256000
 force_https = false
 commit_parse_limit = 50
 use_gravatar = true
 ####################################
 ###        CELERY CONFIG        ####
 ####################################
 use_celery = false
 broker.host = localhost
 broker.vhost = rabbitmqhost
 broker.port = 5672
 broker.user = rabbitmq
 broker.password = qweqwe
 celery.imports = rhodecode.lib.celerylib.tasks
 celery.result.backend = amqp
 celery.result.dburi = amqp://
 celery.result.serialier = json
 #celery.send.task.error.emails = true
 #celery.amqp.task.result.expires = 18000
 celeryd.concurrency = 2
 #celeryd.log.file = celeryd.log
 celeryd.log.level = debug
 celeryd.max.tasks.per.child = 1
 #tasks will never be sent to the queue, but executed locally instead.
 celery.always.eager = false
 ####################################
 ###         BEAKER CACHE        ####
 ####################################
 beaker.cache.data_dir=%(here)s/data/cache/data
 beaker.cache.lock_dir=%(here)s/data/cache/lock
 beaker.cache.regions=super_short_term,short_term,long_term,sql_cache_short,sql_cache_med,sql_cache_long
 beaker.cache.super_short_term.type=memory
 beaker.cache.super_short_term.expire=10
 beaker.cache.short_term.type=memory
 beaker.cache.short_term.expire=60
 beaker.cache.long_term.type=memory
 beaker.cache.long_term.expire=36000
 beaker.cache.sql_cache_short.type=memory
 beaker.cache.sql_cache_short.expire=10
 beaker.cache.sql_cache_med.type=memory
 beaker.cache.sql_cache_med.expire=360
 beaker.cache.sql_cache_long.type=file
 beaker.cache.sql_cache_long.expire=3600
 ####################################
 ###       BEAKER SESSION        ####
 ####################################
 ## Type of storage used for the session, current types are
 ## dbm, file, memcached, database, and memory.
 ## The storage uses the Container API
 ##that is also used by the cache system.
 beaker.session.type = file
 beaker.session.key = rhodecode
 beaker.session.secret = g654dcno0-9873jhgfreyu
 beaker.session.timeout = 36000
 ##auto save the session to not to use .save()
 beaker.session.auto = False
 ##true exire at browser close
 #beaker.session.cookie_expires = 3600
 ################################################################################
 ## WARNING: *THE LINE BELOW MUST BE UNCOMMENTED ON A PRODUCTION ENVIRONMENT*  ##
 ## Debug mode will enable the interactive debugging tool, allowing ANYONE to  ##
 ## execute malicious code after an exception is raised.                       ##
 ################################################################################
 set debug = false
 ##################################
 ###       LOGVIEW CONFIG       ###
 ##################################
 logview.sqlalchemy = #faa
 logview.pylons.templating = #bfb
 logview.pylons.util = #eee
 #########################################################
 ### DB CONFIGS - EACH DB WILL HAVE IT'S OWN CONFIG    ###
 #########################################################
 #sqlalchemy.db1.url = sqlite:///%(here)s/rhodecode.db
 sqlalchemy.db1.url = postgresql://postgres:qwe@localhost/rhodecode
 sqlalchemy.db1.echo = false
 sqlalchemy.db1.pool_recycle = 3600
 sqlalchemy.convert_unicode = true
 ################################
 ### LOGGING CONFIGURATION   ####
 ################################
 [loggers]
 keys = root, routes, rhodecode, sqlalchemy, beaker, templates
 [handlers]
 keys = console, console_sql
 [formatters]
 keys = generic, color_formatter, color_formatter_sql
 #############
 ## LOGGERS ##
 #############
 [logger_root]
 level = NOTSET
 handlers = console
 [logger_routes]
 level = DEBUG
 handlers =
 qualname = routes.middleware
 # "level = DEBUG" logs the route matched and routing variables.
 propagate = 1
 [logger_beaker]
 level = DEBUG
 handlers =
 qualname = beaker.container
 propagate = 1
 [logger_templates]
 level = INFO
 handlers =
 qualname = pylons.templating
 propagate = 1
 [logger_rhodecode]
 level = DEBUG
 handlers =
 qualname = rhodecode
 propagate = 1
 [logger_sqlalchemy]
 level = INFO
 handlers = console_sql
 qualname = sqlalchemy.engine
 propagate = 0
 ##############
 ## HANDLERS ##
 ##############
 [handler_console]
 class = StreamHandler
 args = (sys.stderr,)
 level = INFO
 formatter = generic
 [handler_console_sql]
 class = StreamHandler
 args = (sys.stderr,)
 level = WARN
 formatter = generic
 ################
 ## FORMATTERS ##

rhodecode/config/deployment.ini_tmpl

➞

Show inline comments

 ################################################################################
 ################################################################################
 # RhodeCode - Pylons environment configuration                                 #
 #                                                                              #
 # The %(here)s variable will be replaced with the parent directory of this file#
 ################################################################################
 [DEFAULT]
 debug = true
 pdebug = false
 ################################################################################
 ## Uncomment and replace with the address which should receive                ##
 ## any error reports after application crash                                  ##
 ## Additionally those settings will be used by RhodeCode mailing system       ##
 ################################################################################
 #email_to = admin@localhost
 #error_email_from = paste_error@localhost
 #app_email_from = rhodecode-noreply@localhost
 #error_message =
 #smtp_server = mail.server.com
 #smtp_username =
 #smtp_password =
 #smtp_port =
 #smtp_use_tls = false
 #smtp_use_ssl = true
 # Specify available auth parameters here (e.g. LOGIN PLAIN CRAM-MD5, etc.)
 #smtp_auth =
 [server:main]
 ##nr of threads to spawn
 threadpool_workers = 5
 ##max request before thread respawn
 threadpool_max_requests = 10
 ##option to use threads of process
 use_threadpool = true
 use = egg:Paste#http
 host = 127.0.0.1
 port = 5000
 [app:main]
 use = egg:rhodecode
 full_stack = true
 static_files = true
 lang=en
 cache_dir = %(here)s/data
 index_dir = %(here)s/data/index
 app_instance_uuid = ${app_instance_uuid}
 cut_off_limit = 256000
 force_https = false
 commit_parse_limit = 50
 use_gravatar = true
 ####################################
 ###        CELERY CONFIG        ####
 ####################################
 use_celery = false
 broker.host = localhost
 broker.vhost = rabbitmqhost
 broker.port = 5672
 broker.user = rabbitmq
 broker.password = qweqwe
 celery.imports = rhodecode.lib.celerylib.tasks
 celery.result.backend = amqp
 celery.result.dburi = amqp://
 celery.result.serialier = json
 #celery.send.task.error.emails = true
 #celery.amqp.task.result.expires = 18000
 celeryd.concurrency = 2
 #celeryd.log.file = celeryd.log
 celeryd.log.level = debug
 celeryd.max.tasks.per.child = 1
 #tasks will never be sent to the queue, but executed locally instead.
 celery.always.eager = false
 ####################################
 ###         BEAKER CACHE        ####
 ####################################
 beaker.cache.data_dir=%(here)s/data/cache/data
 beaker.cache.lock_dir=%(here)s/data/cache/lock
 beaker.cache.regions=super_short_term,short_term,long_term,sql_cache_short,sql_cache_med,sql_cache_long
 beaker.cache.super_short_term.type=memory
 beaker.cache.super_short_term.expire=10
 beaker.cache.short_term.type=memory
 beaker.cache.short_term.expire=60
 beaker.cache.long_term.type=memory
 beaker.cache.long_term.expire=36000
 beaker.cache.sql_cache_short.type=memory
 beaker.cache.sql_cache_short.expire=10
 beaker.cache.sql_cache_med.type=memory
 beaker.cache.sql_cache_med.expire=360
 beaker.cache.sql_cache_long.type=file
 beaker.cache.sql_cache_long.expire=3600
 ####################################
 ###       BEAKER SESSION        ####
 ####################################
 ## Type of storage used for the session, current types are
 ## dbm, file, memcached, database, and memory.
 ## The storage uses the Container API
 ##that is also used by the cache system.
 beaker.session.type = file
 beaker.session.key = rhodecode
 beaker.session.secret = ${app_instance_secret}
 beaker.session.timeout = 36000
 ##auto save the session to not to use .save()
 beaker.session.auto = False
 ##true exire at browser close
 #beaker.session.cookie_expires = 3600
 ################################################################################
 ## WARNING: *THE LINE BELOW MUST BE UNCOMMENTED ON A PRODUCTION ENVIRONMENT*  ##
 ## Debug mode will enable the interactive debugging tool, allowing ANYONE to  ##
 ## execute malicious code after an exception is raised.                       ##
 ################################################################################
 set debug = false
 ##################################
 ###       LOGVIEW CONFIG       ###
 ##################################
 logview.sqlalchemy = #faa
 logview.pylons.templating = #bfb
 logview.pylons.util = #eee
 #########################################################
 ### DB CONFIGS - EACH DB WILL HAVE IT'S OWN CONFIG    ###
 #########################################################
 # SQLITE [default]
 sqlalchemy.db1.url = sqlite:///%(here)s/rhodecode.db
-# POSTGRES
+# POSTGRESQL
 # sqlalchemy.db1.url = postgresql://user:pass@localhost/rhodecode
 # MySQL
 # sqlalchemy.db1.url = mysql://user:pass@localhost/rhodecode
 sqlalchemy.db1.echo = false
 sqlalchemy.db1.pool_recycle = 3600
 sqlalchemy.convert_unicode = true
 ################################
 ### LOGGING CONFIGURATION   ####
 ################################
 [loggers]
 keys = root, routes, rhodecode, sqlalchemy, beaker, templates
 [handlers]
 keys = console, console_sql
 [formatters]
 keys = generic, color_formatter, color_formatter_sql
 #############
 ## LOGGERS ##
 #############
 [logger_root]
 level = NOTSET
 handlers = console
 [logger_routes]
 level = DEBUG
 handlers =
 qualname = routes.middleware
 # "level = DEBUG" logs the route matched and routing variables.
 propagate = 1
 [logger_beaker]
 level = DEBUG
 handlers =
 qualname = beaker.container
 propagate = 1
 [logger_templates]
 level = INFO
 handlers =
 qualname = pylons.templating
 propagate = 1
 [logger_rhodecode]
 level = DEBUG
 handlers =
 qualname = rhodecode
 propagate = 1
 [logger_sqlalchemy]
 level = INFO
 handlers = console_sql
 qualname = sqlalchemy.engine
 propagate = 0
 ##############
 ## HANDLERS ##
 ##############
 [handler_console]
 class = StreamHandler
 args = (sys.stderr,)
 level = INFO
 formatter = color_formatter
 [handler_console_sql]
 class = StreamHandler
 args = (sys.stderr,)
 level = WARN
 formatter = color_formatter_sql
 ################
 ## FORMATTERS ##
 ################
 [formatter_generic]
 format = %(asctime)s.%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
 datefmt = %Y-%m-%d %H:%M:%S
 [formatter_color_formatter]
 class=rhodecode.lib.colored_formatter.ColorFormatter
 format= %(asctime)s.%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
 datefmt = %Y-%m-%d %H:%M:%S
 [formatter_color_formatter_sql]
 class=rhodecode.lib.colored_formatter.ColorFormatterSql
 format= %(asctime)s.%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
 datefmt = %Y-%m-%d %H:%M:%S
@@ \ No newline at end of file @@

rhodecode/lib/__init__.py

➞

Show inline comments

@@ @@ -205,204 +205,203 @@ def safe_str(unicode_, to_encoding='utf8 @@
         pass
     try:
         import chardet
         encoding = chardet.detect(unicode_)['encoding']
         print encoding
         if encoding is None:
             raise UnicodeEncodeError()
         return unicode_.encode(encoding)
     except (ImportError, UnicodeEncodeError):
         return unicode_.encode(to_encoding, 'replace')
     return safe_str
 def engine_from_config(configuration, prefix='sqlalchemy.', **kwargs):
     """
     Custom engine_from_config functions that makes sure we use NullPool for
     file based sqlite databases. This prevents errors on sqlite. This only
     applies to sqlalchemy versions < 0.7.0
     """
     import sqlalchemy
     from sqlalchemy import engine_from_config as efc
     import logging
     if int(sqlalchemy.__version__.split('.')[1]) < 7:
         # This solution should work for sqlalchemy < 0.7.0, and should use
         # proxy=TimerProxy() for execution time profiling
         from sqlalchemy.pool import NullPool
         url = configuration[prefix + 'url']
         if url.startswith('sqlite'):
             kwargs.update({'poolclass': NullPool})
         return efc(configuration, prefix, **kwargs)
     else:
         import time
         from sqlalchemy import event
         from sqlalchemy.engine import Engine
         log = logging.getLogger('sqlalchemy.engine')
         BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = xrange(30, 38)
         engine = efc(configuration, prefix, **kwargs)
         def color_sql(sql):
             COLOR_SEQ = "\033[1;%dm"
             COLOR_SQL = YELLOW
             normal = '\x1b[0m'
             return ''.join([COLOR_SEQ % COLOR_SQL, sql, normal])
         if configuration['debug']:
             #attach events only for debug configuration
             def before_cursor_execute(conn, cursor, statement,
                                     parameters, context, executemany):
                 context._query_start_time = time.time()
                 log.info(color_sql(">>>>> STARTING QUERY >>>>>"))
             def after_cursor_execute(conn, cursor, statement,
                                     parameters, context, executemany):
                 total = time.time() - context._query_start_time
                 log.info(color_sql("<<<<< TOTAL TIME: %f <<<<<" % total))
             event.listen(engine, "before_cursor_execute",
                          before_cursor_execute)
             event.listen(engine, "after_cursor_execute",
                          after_cursor_execute)
     return engine
 def age(curdate):
     """
     turns a datetime into an age string.
     :param curdate: datetime object
     :rtype: unicode
     :returns: unicode words describing age
     """
     from datetime import datetime
     from webhelpers.date import time_ago_in_words
     _ = lambda s:s
     if not curdate:
         return ''
     agescales = [(_(u"year"), 3600 * 24 * 365),
                  (_(u"month"), 3600 * 24 * 30),
                  (_(u"day"), 3600 * 24),
                  (_(u"hour"), 3600),
                  (_(u"minute"), 60),
                  (_(u"second"), 1), ]
     age = datetime.now() - curdate
     age_seconds = (age.days * agescales[2][1]) + age.seconds
     pos = 1
     for scale in agescales:
         if scale[1] <= age_seconds:
             if pos == 6:pos = 5
             return '%s %s' % (time_ago_in_words(curdate,
                                                 agescales[pos][0]), _('ago'))
         pos += 1
     return _(u'just now')
 def uri_filter(uri):
     """
     Removes user:password from given url string
     :param uri:
     :rtype: unicode
     :returns: filtered list of strings
     """
     if not uri:
         return ''
     proto = ''
     for pat in ('https://', 'http://'):
         if uri.startswith(pat):
             uri = uri[len(pat):]
             proto = pat
             break
     # remove passwords and username
     uri = uri[uri.find('@') + 1:]
     # get the port
     cred_pos = uri.find(':')
     if cred_pos == -1:
         host, port = uri, None
     else:
         host, port = uri[:cred_pos], uri[cred_pos + 1:]
     return filter(None, [proto, host, port])
 def credentials_filter(uri):
     """
     Returns a url with removed credentials
     :param uri:
     """
     uri = uri_filter(uri)
     #check if we have port
     if len(uri) > 2 and uri[2]:
         uri[2] = ':' + uri[2]
     return ''.join(uri)
 def get_changeset_safe(repo, rev):
     """
     Safe version of get_changeset if this changeset doesn't exists for a
     repo it returns a Dummy one instead
     :param repo:
     :param rev:
     """
     from vcs.backends.base import BaseRepository
     from vcs.exceptions import RepositoryError
     if not isinstance(repo, BaseRepository):
         raise Exception('You must pass an Repository '
                         'object as first argument got %s', type(repo))
     try:
         cs = repo.get_changeset(rev)
     except RepositoryError:
         from rhodecode.lib.utils import EmptyChangeset
         cs = EmptyChangeset(requested_revision=rev)
     return cs
 def get_current_revision(quiet=False):
     """
     Returns tuple of (number, id) from repository containing this package
     or None if repository could not be found.
     :param quiet: prints error for fetching revision if True
     """
     try:
         from vcs import get_repo
         from vcs.utils.helpers import get_scm
         from vcs.exceptions import RepositoryError, VCSError
         repopath = os.path.join(os.path.dirname(__file__), '..', '..')
         scm = get_scm(repopath)[0]
         repo = get_repo(path=repopath, alias=scm)
         tip = repo.get_changeset()
         return (tip.revision, tip.short_id)
-    except (ImportError, RepositoryError, VCSError), err:
+    except Exception, err:
         if not quiet:
             print ("Cannot retrieve rhodecode's revision. Original error "
                    "was: %s" % err)
         return None

rhodecode/lib/auth_ldap.py

➞

Show inline comments

 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.changelog
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     RhodeCode authentication library for LDAP
     :created_on: Created on Nov 17, 2010
     :author: marcink
     :copyright: (C) 2009-2011 Marcin Kuzminski <marcin@python-works.com>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
+#
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
+#
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 import logging
 from rhodecode.lib.exceptions import LdapConnectionError, LdapUsernameError, \
     LdapPasswordError
 log = logging.getLogger(__name__)
 try:
     import ldap
 except ImportError:
     # means that python-ldap is not installed
     pass
 class AuthLdap(object):
     def __init__(self, server, base_dn, port=389, bind_dn='', bind_pass='',
                  tls_kind='PLAIN', tls_reqcert='DEMAND', ldap_version=3,
                  ldap_filter='(&(objectClass=user)(!(objectClass=computer)))',
                  search_scope='SUBTREE',
                  attr_login='uid'):
         self.ldap_version = ldap_version
         ldap_server_type = 'ldap'
         self.TLS_KIND = tls_kind
         if self.TLS_KIND == 'LDAPS':
             port = port or 689
             ldap_server_type = ldap_server_type + 's'
         self.TLS_REQCERT = ldap.__dict__['OPT_X_TLS_' + tls_reqcert]
         OPT_X_TLS_DEMAND = 2
         self.TLS_REQCERT = getattr(ldap, 'OPT_X_TLS_%s' % tls_reqcert,
                                    OPT_X_TLS_DEMAND)
         self.LDAP_SERVER_ADDRESS = server
         self.LDAP_SERVER_PORT = port
         #USE FOR READ ONLY BIND TO LDAP SERVER
         self.LDAP_BIND_DN = bind_dn
         self.LDAP_BIND_PASS = bind_pass
         self.LDAP_SERVER = "%s://%s:%s" % (ldap_server_type,
                                                self.LDAP_SERVER_ADDRESS,
                                                self.LDAP_SERVER_PORT)
         self.BASE_DN = base_dn
         self.LDAP_FILTER = ldap_filter
-        self.SEARCH_SCOPE = ldap.__dict__['SCOPE_' + search_scope]
+        self.SEARCH_SCOPE = getattr(ldap, 'SCOPE_%s' % search_scope)
         self.attr_login = attr_login
     def authenticate_ldap(self, username, password):
         """Authenticate a user via LDAP and return his/her LDAP properties.
         Raises AuthenticationError if the credentials are rejected, or
         EnvironmentError if the LDAP server can't be reached.
         :param username: username
         :param password: password
         """
         from rhodecode.lib.helpers import chop_at
         uid = chop_at(username, "@%s" % self.LDAP_SERVER_ADDRESS)
         if "," in username:
             raise LdapUsernameError("invalid character in username: ,")
         try:
             ldap.set_option(ldap.OPT_X_TLS_CACERTDIR, '/etc/openldap/cacerts')
             if hasattr(ldap,'OPT_X_TLS_CACERTDIR'):
                 ldap.set_option(ldap.OPT_X_TLS_CACERTDIR,
                                 '/etc/openldap/cacerts')
             ldap.set_option(ldap.OPT_REFERRALS, ldap.OPT_OFF)
             ldap.set_option(ldap.OPT_RESTART, ldap.OPT_ON)
             ldap.set_option(ldap.OPT_TIMEOUT, 20)
             ldap.set_option(ldap.OPT_NETWORK_TIMEOUT, 10)
             ldap.set_option(ldap.OPT_TIMELIMIT, 15)
             if self.TLS_KIND != 'PLAIN':
                 ldap.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, self.TLS_REQCERT)
             server = ldap.initialize(self.LDAP_SERVER)
             if self.ldap_version == 2:
                 server.protocol = ldap.VERSION2
             else:
                 server.protocol = ldap.VERSION3
             if self.TLS_KIND == 'START_TLS':
                 server.start_tls_s()
             if self.LDAP_BIND_DN and self.LDAP_BIND_PASS:
                 server.simple_bind_s(self.LDAP_BIND_DN, self.LDAP_BIND_PASS)
             filt = '(&%s(%s=%s))' % (self.LDAP_FILTER, self.attr_login,
                                      username)
             log.debug("Authenticating %r filt %s at %s", self.BASE_DN,
                       filt, self.LDAP_SERVER)
             lobjects = server.search_ext_s(self.BASE_DN, self.SEARCH_SCOPE,
                                            filt)
             if not lobjects:
                 raise ldap.NO_SUCH_OBJECT()
             for (dn, _attrs) in lobjects:
                 if dn is None:
                     continue
                 try:
                     server.simple_bind_s(dn, password)
                     attrs = server.search_ext_s(dn, ldap.SCOPE_BASE,
                                                 '(objectClass=*)')[0][1]
                     break
                 except ldap.INVALID_CREDENTIALS, e:
                     log.debug("LDAP rejected password for user '%s' (%s): %s",
                               uid, username, dn)
             else:
                 log.debug("No matching LDAP objects for authentication "
                           "of '%s' (%s)", uid, username)
                 raise LdapPasswordError()
         except ldap.NO_SUCH_OBJECT, e:
             log.debug("LDAP says no such user '%s' (%s)", uid, username)
             raise LdapUsernameError()
         except ldap.SERVER_DOWN, e:
             raise LdapConnectionError("LDAP can't access "
                                       "authentication server")
         return (dn, attrs)

rhodecode/lib/celerylib/tasks.py

➞

Show inline comments

@@ @@ -167,245 +167,246 @@ def get_commits_stats(repo_name, ts_min_ @@
                     datadict = \
                         co_day_auth_aggr[akc(cs.author)]['data'][time_pos]
                     datadict["commits"] += 1
                     datadict["added"] += len(cs.added)
                     datadict["changed"] += len(cs.changed)
                     datadict["removed"] += len(cs.removed)
                 else:
                     if k >= ts_min_y and k <= ts_max_y or skip_date_limit:
                         datadict = {"time": k,
                                     "commits": 1,
                                     "added": len(cs.added),
                                     "changed": len(cs.changed),
                                     "removed": len(cs.removed),
+                                   }
                         co_day_auth_aggr[akc(cs.author)]['data']\
                             .append(datadict)
             else:
                 if k >= ts_min_y and k <= ts_max_y or skip_date_limit:
                     co_day_auth_aggr[akc(cs.author)] = {
                                         "label": akc(cs.author),
                                         "data": [{"time":k,
                                                  "commits":1,
                                                  "added":len(cs.added),
                                                  "changed":len(cs.changed),
                                                  "removed":len(cs.removed),
                                                  }],
                                         "schema": ["commits"],
+                                        }
             #gather all data by day
             if k in commits_by_day_aggregate:
                 commits_by_day_aggregate[k] += 1
             else:
                 commits_by_day_aggregate[k] = 1
         overview_data = sorted(commits_by_day_aggregate.items(),
                                key=itemgetter(0))
         if not co_day_auth_aggr:
             co_day_auth_aggr[akc(repo.contact)] = {
                 "label": akc(repo.contact),
                 "data": [0, 1],
                 "schema": ["commits"],
+            }
         stats = cur_stats if cur_stats else Statistics()
         stats.commit_activity = json.dumps(co_day_auth_aggr)
         stats.commit_activity_combined = json.dumps(overview_data)
         log.debug('last revison %s', last_rev)
         leftovers = len(repo.revisions[last_rev:])
         log.debug('revisions to parse %s', leftovers)
         if last_rev == 0 or leftovers < parse_limit:
             log.debug('getting code trending stats')
             stats.languages = json.dumps(__get_codes_stats(repo_name))
         try:
             stats.repository = dbrepo
             stats.stat_on_revision = last_cs.revision if last_cs else 0
             sa.add(stats)
             sa.commit()
         except:
             log.error(traceback.format_exc())
             sa.rollback()
             lock.release()
             return False
         #final release
         lock.release()
         #execute another task if celery is enabled
         if len(repo.revisions) > 1 and CELERY_ON:
             run_task(get_commits_stats, repo_name, ts_min_y, ts_max_y)
         return True
     except LockHeld:
         log.info('LockHeld')
         return 'Task with key %s already running' % lockkey
 @task(ignore_result=True)
 def send_password_link(user_email):
     try:
         log = reset_user_password.get_logger()
     except:
         log = logging.getLogger(__name__)
     from rhodecode.lib import auth
     from rhodecode.model.db import User
     try:
         sa = get_session()
         user = sa.query(User).filter(User.email == user_email).scalar()
         if user:
             link = url('reset_password_confirmation', key=user.api_key,
                        qualified=True)
             tmpl = """
 Hello %s
 We received a request to create a new password for your account.
 You can generate it by clicking following URL:
 %s
 If you didn't request new password please ignore this email.
             """
             run_task(send_email, user_email,
                      "RhodeCode password reset link",
                      tmpl % (user.short_contact, link))
             log.info('send new password mail to %s', user_email)
     except:
         log.error('Failed to update user password')
         log.error(traceback.format_exc())
         return False
     return True
 @task(ignore_result=True)
 def reset_user_password(user_email):
     try:
         log = reset_user_password.get_logger()
     except:
         log = logging.getLogger(__name__)
     from rhodecode.lib import auth
     from rhodecode.model.db import User
     try:
         try:
             sa = get_session()
             user = sa.query(User).filter(User.email == user_email).scalar()
             new_passwd = auth.PasswordGenerator().gen_password(8,
                              auth.PasswordGenerator.ALPHABETS_BIG_SMALL)
             if user:
                 user.password = auth.get_crypt_password(new_passwd)
                 user.api_key = auth.generate_api_key(user.username)
                 sa.add(user)
                 sa.commit()
                 log.info('change password for %s', user_email)
             if new_passwd is None:
                 raise Exception('unable to generate new password')
         except:
             log.error(traceback.format_exc())
             sa.rollback()
         run_task(send_email, user_email,
                  "Your new RhodeCode password",
                  'Your new RhodeCode password:%s' % (new_passwd))
         log.info('send new password mail to %s', user_email)
     except:
         log.error('Failed to update user password')
         log.error(traceback.format_exc())
     return True
 @task(ignore_result=True)
 def send_email(recipients, subject, body):
     """
     Sends an email with defined parameters from the .ini files.
     :param recipients: list of recipients, it this is empty the defined email
         address from field 'email_to' is used instead
     :param subject: subject of the mail
     :param body: body of the mail
     """
     try:
         log = send_email.get_logger()
     except:
         log = logging.getLogger(__name__)
     email_config = config
     if not recipients:
         recipients = [email_config.get('email_to')]
     mail_from = email_config.get('app_email_from')
     user = email_config.get('smtp_username')
     passwd = email_config.get('smtp_password')
     mail_server = email_config.get('smtp_server')
     mail_port = email_config.get('smtp_port')
     tls = str2bool(email_config.get('smtp_use_tls'))
     ssl = str2bool(email_config.get('smtp_use_ssl'))
     debug = str2bool(config.get('debug'))
     smtp_auth = email_config.get('smtp_auth')
     try:
         m = SmtpMailer(mail_from, user, passwd, mail_server,
+        m = SmtpMailer(mail_from, user, passwd, mail_server,smtp_auth,
                        mail_port, ssl, tls, debug=debug)
         m.send(recipients, subject, body)
     except:
         log.error('Mail sending failed')
         log.error(traceback.format_exc())
         return False
     return True
 @task(ignore_result=True)
 def create_repo_fork(form_data, cur_user):
     from rhodecode.model.repo import RepoModel
     from vcs import get_backend
     try:
         log = create_repo_fork.get_logger()
     except:
         log = logging.getLogger(__name__)
     repo_model = RepoModel(get_session())
     repo_model.create(form_data, cur_user, just_db=True, fork=True)
     repo_name = form_data['repo_name']
     repos_path = get_repos_path()
     repo_path = os.path.join(repos_path, repo_name)
     repo_fork_path = os.path.join(repos_path, form_data['fork_name'])
     alias = form_data['repo_type']
     log.info('creating repo fork %s as %s', repo_name, repo_path)
     backend = get_backend(alias)
     backend(str(repo_fork_path), create=True, src_url=str(repo_path))
 def __get_codes_stats(repo_name):
     repos_path = get_repos_path()
     repo = get_repo(safe_str(os.path.join(repos_path, repo_name)))
     tip = repo.get_changeset()
     code_stats = {}
     def aggregate(cs):
         for f in cs[2]:
             ext = lower(f.extension)
             if ext in LANGUAGES_EXTENSIONS_MAP.keys() and not f.is_binary:
                 if ext in code_stats:
                     code_stats[ext] += 1
                 else:
                     code_stats[ext] = 1
     map(aggregate, tip.walk('/'))
     return code_stats or {}

rhodecode/lib/smtp_mailer.py

➞

Show inline comments

 # -*- coding: utf-8 -*-
 """
     rhodecode.lib.smtp_mailer
     ~~~~~~~~~~~~~~~~~~~~~~~~~
     Simple smtp mailer used in RhodeCode
     :created_on: Sep 13, 2010
     :copyright: (C) 2009-2011 Marcin Kuzminski <marcin@python-works.com>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
+#
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
+#
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 import logging
 import smtplib
 import mimetypes
 from socket import sslerror
 from email.mime.multipart import MIMEMultipart
 from email.mime.image import MIMEImage
 from email.mime.audio import MIMEAudio
 from email.mime.base import MIMEBase
 from email.mime.text import MIMEText
 from email.utils import formatdate
 from email import encoders
 class SmtpMailer(object):
     """SMTP mailer class
     mailer = SmtpMailer(mail_from, user, passwd, mail_server,
+    mailer = SmtpMailer(mail_from, user, passwd, mail_server, smtp_auth
                         mail_port, ssl, tls)
     mailer.send(recipients, subject, body, attachment_files)
     :param recipients might be a list of string or single string
     :param attachment_files is a dict of {filename:location}
         it tries to guess the mimetype and attach the file
     """
     def __init__(self, mail_from, user, passwd, mail_server,
+    def __init__(self, mail_from, user, passwd, mail_server, smtp_auth=None,
                     mail_port=None, ssl=False, tls=False, debug=False):
         self.mail_from = mail_from
         self.mail_server = mail_server
         self.mail_port = mail_port
         self.user = user
         self.passwd = passwd
         self.ssl = ssl
         self.tls = tls
         self.debug = debug
         self.auth = smtp_auth
     def send(self, recipients=[], subject='', body='', attachment_files=None):
         if isinstance(recipients, basestring):
             recipients = [recipients]
         if self.ssl:
             smtp_serv = smtplib.SMTP_SSL(self.mail_server, self.mail_port)
         else:
             smtp_serv = smtplib.SMTP(self.mail_server, self.mail_port)
         if self.tls:
             smtp_serv.ehlo()
             smtp_serv.starttls()
         if self.debug:
             smtp_serv.set_debuglevel(1)
         smtp_serv.ehlo()
         if self.auth:
             smtp_serv.esmtp_features["auth"] = self.auth
         #if server requires authorization you must provide login and password
         #but only if we have them
         if self.user and self.passwd:
             smtp_serv.login(self.user, self.passwd)
         date_ = formatdate(localtime=True)
         msg = MIMEMultipart()
         msg.set_type('multipart/alternative')
         msg.preamble = 'You will not see this in a MIME-aware mail reader.\n'
         text_msg = MIMEText(body)
         text_msg.set_type('text/plain')
         text_msg.set_param('charset', 'UTF-8')
         msg['From'] = self.mail_from
         msg['To'] = ','.join(recipients)
         msg['Date'] = date_
         msg['Subject'] = subject
         msg.attach(text_msg)
         if attachment_files:
             self.__atach_files(msg, attachment_files)
         smtp_serv.sendmail(self.mail_from, recipients, msg.as_string())
         logging.info('MAIL SEND TO: %s' % recipients)
         try:
             smtp_serv.quit()
         except sslerror:
             # sslerror is raised in tls connections on closing sometimes
             pass
     def __atach_files(self, msg, attachment_files):
         if isinstance(attachment_files, dict):
             for f_name, msg_file in attachment_files.items():
                 ctype, encoding = mimetypes.guess_type(f_name)
                 logging.info("guessing file %s type based on %s", ctype,
                              f_name)
                 if ctype is None or encoding is not None:
                     # No guess could be made, or the file is encoded
                     # (compressed), so use a generic bag-of-bits type.
                     ctype = 'application/octet-stream'
                 maintype, subtype = ctype.split('/', 1)
                 if maintype == 'text':
                     # Note: we should handle calculating the charset
                     file_part = MIMEText(self.get_content(msg_file),
                                          _subtype=subtype)
                 elif maintype == 'image':
                     file_part = MIMEImage(self.get_content(msg_file),
                                           _subtype=subtype)
                 elif maintype == 'audio':
                     file_part = MIMEAudio(self.get_content(msg_file),
                                           _subtype=subtype)
                 else:
                     file_part = MIMEBase(maintype, subtype)
                     file_part.set_payload(self.get_content(msg_file))
                     # Encode the payload using Base64
                     encoders.encode_base64(msg)
                 # Set the filename parameter
                 file_part.add_header('Content-Disposition', 'attachment',
                                      filename=f_name)
                 file_part.add_header('Content-Type', ctype, name=f_name)
                 msg.attach(file_part)
         else:
             raise Exception('Attachment files should be'
                             'a dict in format {"filename":"filepath"}')
     def get_content(self, msg_file):
         """Get content based on type, if content is a string do open first
         else just read because it's a probably open file object
         :param msg_file:
         """
         if isinstance(msg_file, str):
             return open(msg_file, "rb").read()
         else:
             #just for safe seek to 0
             msg_file.seek(0)
             return msg_file.read()

rhodecode/model/db.py

➞

Show inline comments

@@ @@ -236,385 +236,386 @@ class RhodeCodeUi( Base, BaseModel ): @@
     @classmethod
     def get_builtin_hooks( cls ):
         q = cls.query()
         q = q.filter( cls.ui_key.in_( [cls.HOOK_UPDATE,
                                     cls.HOOK_REPO_SIZE,
                                     cls.HOOK_PUSH, cls.HOOK_PULL] ) )
         return q.all()
     @classmethod
     def get_custom_hooks( cls ):
         q = cls.query()
         q = q.filter( ~cls.ui_key.in_( [cls.HOOK_UPDATE,
                                     cls.HOOK_REPO_SIZE,
                                     cls.HOOK_PUSH, cls.HOOK_PULL] ) )
         q = q.filter( cls.ui_section == 'hooks' )
         return q.all()
     @classmethod
     def create_or_update_hook( cls, key, val ):
         new_ui = cls.get_by_key( key ).scalar() or cls()
         new_ui.ui_section = 'hooks'
         new_ui.ui_active = True
         new_ui.ui_key = key
         new_ui.ui_value = val
         Session.add( new_ui )
         Session.commit()
 class User( Base, BaseModel ):
     __tablename__ = 'users'
     __table_args__ = ( UniqueConstraint( 'username' ), UniqueConstraint( 'email' ), {'extend_existing':True} )
     user_id = Column( "user_id", Integer(), nullable = False, unique = True, default = None, primary_key = True )
     username = Column( "username", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None )
     password = Column( "password", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None )
     active = Column( "active", Boolean(), nullable = True, unique = None, default = None )
     admin = Column( "admin", Boolean(), nullable = True, unique = None, default = False )
     name = Column( "name", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None )
     lastname = Column( "lastname", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None )
     email = Column( "email", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None )
     last_login = Column( "last_login", DateTime( timezone = False ), nullable = True, unique = None, default = None )
     ldap_dn = Column( "ldap_dn", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None )
     api_key = Column( "api_key", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None )
     user_log = relationship( 'UserLog', cascade = 'all' )
     user_perms = relationship( 'UserToPerm', primaryjoin = "User.user_id==UserToPerm.user_id", cascade = 'all' )
     repositories = relationship( 'Repository' )
     user_followers = relationship( 'UserFollowing', primaryjoin = 'UserFollowing.follows_user_id==User.user_id', cascade = 'all' )
     repo_to_perm = relationship( 'RepoToPerm', primaryjoin = 'RepoToPerm.user_id==User.user_id', cascade = 'all' )
     group_member = relationship( 'UsersGroupMember', cascade = 'all' )
     @property
     def full_contact( self ):
         return '%s %s <%s>' % ( self.name, self.lastname, self.email )
     @property
     def short_contact( self ):
         return '%s %s' % ( self.name, self.lastname )
     @property
     def is_admin( self ):
         return self.admin
     def __repr__( self ):
         try:
             return "<%s('id:%s:%s')>" % ( self.__class__.__name__,
                                              self.user_id, self.username )
         except:
             return self.__class__.__name__
     @classmethod
     def get_by_username( cls, username, case_insensitive = False ):
         if case_insensitive:
             return Session.query( cls ).filter( cls.username.ilike( username ) ).scalar()
         else:
             return Session.query( cls ).filter( cls.username == username ).scalar()
     @classmethod
     def get_by_api_key( cls, api_key ):
         return cls.query().filter( cls.api_key == api_key ).one()
     def update_lastlogin( self ):
         """Update user lastlogin"""
         self.last_login = datetime.datetime.now()
         Session.add( self )
         Session.commit()
         log.debug( 'updated user %s lastlogin', self.username )
     @classmethod
     def create( cls, form_data ):
         from rhodecode.lib.auth import get_crypt_password
         try:
             new_user = cls()
             for k, v in form_data.items():
                 if k == 'password':
                     v = get_crypt_password( v )
                 setattr( new_user, k, v )
             new_user.api_key = generate_api_key( form_data['username'] )
             Session.add( new_user )
             Session.commit()
             return new_user
         except:
             log.error( traceback.format_exc() )
             Session.rollback()
             raise
 class UserLog( Base, BaseModel ):
     __tablename__ = 'user_logs'
     __table_args__ = {'extend_existing':True}
     user_log_id = Column( "user_log_id", Integer(), nullable = False, unique = True, default = None, primary_key = True )
     user_id = Column( "user_id", Integer(), ForeignKey( 'users.user_id' ), nullable = False, unique = None, default = None )
     repository_id = Column( "repository_id", Integer(), ForeignKey( 'repositories.repo_id' ), nullable = False, unique = None, default = None )
     repository_name = Column( "repository_name", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None )
     user_ip = Column( "user_ip", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None )
     action = Column( "action", UnicodeText( length = 1200000, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None )
     action_date = Column( "action_date", DateTime( timezone = False ), nullable = True, unique = None, default = None )
     @property
     def action_as_day( self ):
         return date( *self.action_date.timetuple()[:3] )
     user = relationship( 'User' )
     repository = relationship( 'Repository' )
 class UsersGroup( Base, BaseModel ):
     __tablename__ = 'users_groups'
     __table_args__ = {'extend_existing':True}
     users_group_id = Column( "users_group_id", Integer(), nullable = False, unique = True, default = None, primary_key = True )
     users_group_name = Column( "users_group_name", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = False, unique = True, default = None )
     users_group_active = Column( "users_group_active", Boolean(), nullable = True, unique = None, default = None )
     members = relationship( 'UsersGroupMember', cascade = "all, delete, delete-orphan", lazy = "joined" )
     def __repr__( self ):
         return '<userGroup(%s)>' % ( self.users_group_name )
     @classmethod
     def get_by_group_name( cls, group_name, cache = False, case_insensitive = False ):
         if case_insensitive:
             gr = cls.query()\
                 .filter( cls.users_group_name.ilike( group_name ) )
         else:
             gr = cls.query()\
                 .filter( cls.users_group_name == group_name )
         if cache:
             gr = gr.options( FromCache( "sql_cache_short",
                                           "get_user_%s" % group_name ) )
         return gr.scalar()
     @classmethod
     def get( cls, users_group_id, cache = False ):
         users_group = cls.query()
         if cache:
             users_group = users_group.options( FromCache( "sql_cache_short",
                                     "get_users_group_%s" % users_group_id ) )
         return users_group.get( users_group_id )
     @classmethod
     def create( cls, form_data ):
         try:
             new_users_group = cls()
             for k, v in form_data.items():
                 setattr( new_users_group, k, v )
             Session.add( new_users_group )
             Session.commit()
             return new_users_group
         except:
             log.error( traceback.format_exc() )
             Session.rollback()
             raise
     @classmethod
     def update( cls, users_group_id, form_data ):
         try:
             users_group = cls.get( users_group_id, cache = False )
             for k, v in form_data.items():
                 if k == 'users_group_members':
                     users_group.members = []
                     Session.flush()
                     members_list = []
                     if v:
                         for u_id in set( list( v ) ):
                         v = [v] if isinstance(v, basestring) else v
                         for u_id in set(v):
                             member = UsersGroupMember( users_group_id, u_id )
                             members_list.append( member )
                     setattr( users_group, 'members', members_list )
                 setattr( users_group, k, v )
             Session.add( users_group )
             Session.commit()
         except:
             log.error( traceback.format_exc() )
             Session.rollback()
             raise
     @classmethod
     def delete( cls, users_group_id ):
         try:
             # check if this group is not assigned to repo
             assigned_groups = UsersGroupRepoToPerm.query()\
                 .filter( UsersGroupRepoToPerm.users_group_id ==
                         users_group_id ).all()
             if assigned_groups:
                 raise UsersGroupsAssignedException( 'Group assigned to %s' %
                                                    assigned_groups )
             users_group = cls.get( users_group_id, cache = False )
             Session.delete( users_group )
             Session.commit()
         except:
             log.error( traceback.format_exc() )
             Session.rollback()
             raise
 class UsersGroupMember( Base, BaseModel ):
     __tablename__ = 'users_groups_members'
     __table_args__ = {'extend_existing':True}
     users_group_member_id = Column( "users_group_member_id", Integer(), nullable = False, unique = True, default = None, primary_key = True )
     users_group_id = Column( "users_group_id", Integer(), ForeignKey( 'users_groups.users_group_id' ), nullable = False, unique = None, default = None )
     user_id = Column( "user_id", Integer(), ForeignKey( 'users.user_id' ), nullable = False, unique = None, default = None )
     user = relationship( 'User', lazy = 'joined' )
     users_group = relationship( 'UsersGroup' )
     def __init__( self, gr_id = '', u_id = '' ):
         self.users_group_id = gr_id
         self.user_id = u_id
     @staticmethod
     def add_user_to_group( group, user ):
         ugm = UsersGroupMember()
         ugm.users_group = group
         ugm.user = user
         Session.add( ugm )
         Session.commit()
         return ugm
 class Repository( Base, BaseModel ):
     __tablename__ = 'repositories'
     __table_args__ = ( UniqueConstraint( 'repo_name' ), {'extend_existing':True}, )
     repo_id = Column( "repo_id", Integer(), nullable = False, unique = True, default = None, primary_key = True )
     repo_name = Column( "repo_name", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = False, unique = True, default = None )
     clone_uri = Column( "clone_uri", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = True, unique = False, default = None )
     repo_type = Column( "repo_type", String( length = 255, convert_unicode = False, assert_unicode = None ), nullable = False, unique = False, default = 'hg' )
     user_id = Column( "user_id", Integer(), ForeignKey( 'users.user_id' ), nullable = False, unique = False, default = None )
     private = Column( "private", Boolean(), nullable = True, unique = None, default = None )
     enable_statistics = Column( "statistics", Boolean(), nullable = True, unique = None, default = True )
     enable_downloads = Column( "downloads", Boolean(), nullable = True, unique = None, default = True )
     description = Column( "description", String( length = 10000, convert_unicode = False, assert_unicode = None ), nullable = True, unique = None, default = None )
     created_on = Column( 'created_on', DateTime( timezone = False ), nullable = True, unique = None, default = datetime.datetime.now )
     fork_id = Column( "fork_id", Integer(), ForeignKey( 'repositories.repo_id' ), nullable = True, unique = False, default = None )
     group_id = Column( "group_id", Integer(), ForeignKey( 'groups.group_id' ), nullable = True, unique = False, default = None )
     user = relationship( 'User' )
     fork = relationship( 'Repository', remote_side = repo_id )
     group = relationship( 'Group' )
     repo_to_perm = relationship( 'RepoToPerm', cascade = 'all', order_by = 'RepoToPerm.repo_to_perm_id' )
     users_group_to_perm = relationship( 'UsersGroupRepoToPerm', cascade = 'all' )
     stats = relationship( 'Statistics', cascade = 'all', uselist = False )
     followers = relationship( 'UserFollowing', primaryjoin = 'UserFollowing.follows_repo_id==Repository.repo_id', cascade = 'all' )
     logs = relationship( 'UserLog', cascade = 'all' )
     def __repr__( self ):
         return "<%s('%s:%s')>" % ( self.__class__.__name__,
                                   self.repo_id, self.repo_name )
     @classmethod
     def url_sep( cls ):
         return '/'
     @classmethod
     def get_by_repo_name( cls, repo_name ):
         q = Session.query( cls ).filter( cls.repo_name == repo_name )
         q = q.options( joinedload( Repository.fork ) )\
                 .options( joinedload( Repository.user ) )\
                 .options( joinedload( Repository.group ) )
         return q.one()
     @classmethod
     def get_repo_forks( cls, repo_id ):
         return cls.query().filter( Repository.fork_id == repo_id )
     @classmethod
     def base_path( cls ):
         """
         Returns base path when all repos are stored
         :param cls:
         """
         q = Session.query( RhodeCodeUi ).filter( RhodeCodeUi.ui_key ==
                                               cls.url_sep() )
         q.options( FromCache( "sql_cache_short", "repository_repo_path" ) )
         return q.one().ui_value
     @property
     def just_name( self ):
         return self.repo_name.split( Repository.url_sep() )[-1]
     @property
     def groups_with_parents( self ):
         groups = []
         if self.group is None:
             return groups
         cur_gr = self.group
         groups.insert( 0, cur_gr )
         while 1:
             gr = getattr( cur_gr, 'parent_group', None )
             cur_gr = cur_gr.parent_group
             if gr is None:
                 break
             groups.insert( 0, gr )
         return groups
     @property
     def groups_and_repo( self ):
         return self.groups_with_parents, self.just_name
     @LazyProperty
     def repo_path( self ):
         """
         Returns base full path for that repository means where it actually
         exists on a filesystem
         """
         q = Session.query( RhodeCodeUi ).filter( RhodeCodeUi.ui_key ==
                                               Repository.url_sep() )
         q.options( FromCache( "sql_cache_short", "repository_repo_path" ) )
         return q.one().ui_value
     @property
     def repo_full_path( self ):
         p = [self.repo_path]
         # we need to split the name by / since this is how we store the
         # names in the database, but that eventually needs to be converted
         # into a valid system path
         p += self.repo_name.split( Repository.url_sep() )
         return os.path.join( *p )
     def get_new_name( self, repo_name ):
         """
         returns new full repository name based on assigned group and new new
         :param group_name:
         """
         path_prefix = self.group.full_path_splitted if self.group else []
         return Repository.url_sep().join( path_prefix + [repo_name] )
     @property
     def _ui( self ):
         """
         Creates an db based ui object for this repository
         """
         from mercurial import ui
         from mercurial import config
         baseui = ui.ui()
         #clean the baseui object
         baseui._ocfg = config.config()
         baseui._ucfg = config.config()
         baseui._tcfg = config.config()
         ret = RhodeCodeUi.query()\
             .options( FromCache( "sql_cache_short", "repository_repo_ui" ) ).all()
         hg_ui = ret

rhodecode/templates/admin/repos_groups/repos_groups_add.html

➞

Show inline comments

 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.html"/>
 <%def name="title()">
     ${_('Add repos group')} - ${c.rhodecode_name}
 </%def>
 <%def name="breadcrumbs_links()">
     ${h.link_to(_('Admin'),h.url('admin_home'))}
     &raquo;
     ${h.link_to(_('Repos groups'),h.url('repos_groups'))}
     &raquo;
     ${_('add new repos group')}
 </%def>
 <%def name="page_nav()">
     ${self.menu('admin')}
 </%def>
 <%def name="main()">
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
     <!-- end box / title -->
     ${h.form(url('repos_groups'))}
     <div class="form">
         <!-- fields -->
         <div class="fields">
              <div class="field">
                 <div class="label">
-                    <label for="users_group_name">${_('Group name')}:</label>
+                    <label for="group_name">${_('Group name')}:</label>
                 </div>
                 <div class="input">
                     ${h.text('group_name',class_='medium')}
                 </div>
              </div>
             <div class="field">
                 <div class="label label-textarea">
-                    <label for="description">${_('Description')}:</label>
+                    <label for="group_description">${_('Description')}:</label>
                 </div>
                 <div class="textarea text-area editor">
                     ${h.textarea('group_description',cols=23,rows=5,class_="medium")}
                 </div>
              </div>
              <div class="field">
                  <div class="label">
-                     <label for="repo_group">${_('Group parent')}:</label>
+                     <label for="group_parent_id">${_('Group parent')}:</label>
                  </div>
                  <div class="input">
                      ${h.select('group_parent_id','',c.repo_groups,class_="medium")}
                  </div>
              </div>
             <div class="buttons">
               ${h.submit('save',_('save'),class_="ui-button")}
             </div>
         </div>
     </div>
     ${h.end_form()}
 </div>
 </%def>

rhodecode/templates/admin/repos_groups/repos_groups_edit.html

➞

Show inline comments

 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.html"/>
 <%def name="title()">
     ${_('Edit repos group')} ${c.repos_group.name} - ${c.rhodecode_name}
 </%def>
 <%def name="breadcrumbs_links()">
     ${h.link_to(_('Admin'),h.url('admin_home'))}
     &raquo;
     ${h.link_to(_('Repos groups'),h.url('repos_groups'))}
     &raquo;
     ${_('edit repos group')} "${c.repos_group.name}"
 </%def>
 <%def name="page_nav()">
     ${self.menu('admin')}
 </%def>
 <%def name="main()">
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
     <!-- end box / title -->
     ${h.form(url('repos_group',id=c.repos_group.group_id),method='put')}
     <div class="form">
         <!-- fields -->
         <div class="fields">
              <div class="field">
                 <div class="label">
-                    <label for="users_group_name">${_('Group name')}:</label>
+                    <label for="group_name">${_('Group name')}:</label>
                 </div>
                 <div class="input">
                     ${h.text('group_name',class_='medium')}
                 </div>
              </div>
 	        <div class="field">
 	            <div class="label label-textarea">
-	                <label for="description">${_('Description')}:</label>
+	                <label for="group_description">${_('Description')}:</label>
 	            </div>
 	            <div class="textarea text-area editor">
 	                ${h.textarea('group_description',cols=23,rows=5,class_="medium")}
 	            </div>
 	         </div>
 	         <div class="field">
 	             <div class="label">
-	                 <label for="repo_group">${_('Group parent')}:</label>
+	                 <label for="group_parent_id">${_('Group parent')}:</label>
 	             </div>
 	             <div class="input">
 	                 ${h.select('group_parent_id','',c.repo_groups,class_="medium")}
 	             </div>
 	         </div>
             <div class="buttons">
               ${h.submit('save',_('save'),class_="ui-button")}
             </div>
         </div>
     </div>
     ${h.end_form()}
 </div>
 </%def>

rhodecode/templates/admin/settings/settings.html

➞

Show inline comments

 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.html"/>
 <%def name="title()">
     ${_('Settings administration')} - ${c.rhodecode_name}
 </%def>
 <%def name="breadcrumbs_links()">
     ${h.link_to(_('Admin'),h.url('admin_home'))} &raquo; ${_('Settings')}
 </%def>
 <%def name="page_nav()">
 	${self.menu('admin')}
 </%def>
 <%def name="main()">
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
     <!-- end box / title -->
     <h3>${_('Remap and rescan repositories')}</h3>
     ${h.form(url('admin_setting', setting_id='mapping'),method='put')}
     <div class="form">
         <!-- fields -->
         <div class="fields">
 			<div class="field">
 		        <div class="label label-checkbox">
 		            <label for="destroy">${_('rescan option')}:</label>
 		        </div>
 		        <div class="checkboxes">
 		            <div class="checkbox">
 		                ${h.checkbox('destroy',True)}
-		                <label for="checkbox-1">
+		                <label for="destroy">
 		                <span class="tooltip" title="${h.tooltip(_('In case a repository was deleted from filesystem and there are leftovers in the database check this option to scan obsolete data in database and remove it.'))}">
 		                ${_('destroy old data')}</span> </label>
 		            </div>
 		        </div>
 			</div>
             <div class="buttons">
             ${h.submit('rescan',_('Rescan repositories'),class_="ui-button")}
             </div>
         </div>
     </div>
     ${h.end_form()}
     <h3>${_('Whoosh indexing')}</h3>
     ${h.form(url('admin_setting', setting_id='whoosh'),method='put')}
     <div class="form">
         <!-- fields -->
         <div class="fields">
             <div class="field">
                 <div class="label label-checkbox">
-                    <label for="destroy">${_('index build option')}:</label>
                     <label>${_('index build option')}:</label>
                 </div>
                 <div class="checkboxes">
                     <div class="checkbox">
                         ${h.checkbox('full_index',True)}
-                        <label for="checkbox-1">${_('build from scratch')}</label>
+                        <label for="full_index">${_('build from scratch')}</label>
                     </div>
                 </div>
             </div>
             <div class="buttons">
             ${h.submit('reindex',_('Reindex'),class_="ui-button")}
             </div>
         </div>
     </div>
     ${h.end_form()}
     <h3>${_('Global application settings')}</h3>
     ${h.form(url('admin_setting', setting_id='global'),method='put')}
     <div class="form">
         <!-- fields -->
         <div class="fields">
              <div class="field">
                 <div class="label">
                     <label for="rhodecode_title">${_('Application name')}:</label>
                 </div>
                 <div class="input">
                     ${h.text('rhodecode_title',size=30)}
                 </div>
              </div>
             <div class="field">
                 <div class="label">
                     <label for="rhodecode_realm">${_('Realm text')}:</label>
                 </div>
                 <div class="input">
                     ${h.text('rhodecode_realm',size=30)}
                 </div>
             </div>
             <div class="field">
                 <div class="label">
-                    <label for="ga_code">${_('GA code')}:</label>
+                    <label for="rhodecode_ga_code">${_('GA code')}:</label>
                 </div>
                 <div class="input">
                     ${h.text('rhodecode_ga_code',size=30)}
                 </div>
             </div>
             <div class="buttons">
                 ${h.submit('save',_('Save settings'),class_="ui-button")}
                 ${h.reset('reset',_('Reset'),class_="ui-button")}
            </div>
         </div>
     </div>
     ${h.end_form()}
     <h3>${_('Mercurial settings')}</h3>
     ${h.form(url('admin_setting', setting_id='mercurial'),method='put')}
     <div class="form">
         <!-- fields -->
         <div class="fields">
              <div class="field">
                 <div class="label label-checkbox">
-                    <label for="web_push_ssl">${_('Web')}:</label>
                     <label>${_('Web')}:</label>
                 </div>
                 <div class="checkboxes">
 					<div class="checkbox">
 						${h.checkbox('web_push_ssl','true')}
 						<label for="web_push_ssl">${_('require ssl for pushing')}</label>
 					</div>
 				</div>
              </div>
              <div class="field">
                 <div class="label label-checkbox">
-                    <label for="web_push_ssl">${_('Hooks')}:</label>
                     <label>${_('Hooks')}:</label>
                 </div>
                 <div class="input">
                     ${h.link_to(_('advanced setup'),url('admin_edit_setting',setting_id='hooks'))}
                 </div>
                 <div class="checkboxes">
 					<div class="checkbox">
 						${h.checkbox('hooks_changegroup_update','True')}
 						<label for="hooks_changegroup_update">${_('Update repository after push (hg update)')}</label>
 					</div>
 					<div class="checkbox">
 						${h.checkbox('hooks_changegroup_repo_size','True')}
 						<label for="hooks_changegroup_repo_size">${_('Show repository size after push')}</label>
 					</div>
                     <div class="checkbox">
                         ${h.checkbox('hooks_pretxnchangegroup_push_logger','True')}
                         <label for="hooks_pretxnchangegroup_push_logger">${_('Log user push commands')}</label>
                     </div>
                     <div class="checkbox">
                         ${h.checkbox('hooks_preoutgoing_pull_logger','True')}
                         <label for="hooks_preoutgoing_pull_logger">${_('Log user pull commands')}</label>
                     </div>
 				</div>
              </div>
             <div class="field">
                 <div class="label">
                     <label for="paths_root_path">${_('Repositories location')}:</label>
                 </div>
                 <div class="input">
                     ${h.text('paths_root_path',size=30,readonly="readonly")}
 					<span id="path_unlock" class="tooltip"
 						title="${h.tooltip(_('This a crucial application setting. If you are really sure you need to change this, you must restart application in order to make this setting take effect. Click this label to unlock.'))}">
 		                ${_('unlock')}</span>
                 </div>
             </div>
             <div class="buttons">
                 ${h.submit('save',_('Save settings'),class_="ui-button")}
                 ${h.reset('reset',_('Reset'),class_="ui-button")}
            </div>
         </div>
     </div>
     ${h.end_form()}
     <script type="text/javascript">
         YAHOO.util.Event.onDOMReady(function(){
             YAHOO.util.Event.addListener('path_unlock','click',function(){
                 YAHOO.util.Dom.get('paths_root_path').removeAttribute('readonly');
             });
         });
     </script>
 </div>
 </%def>

rhodecode/templates/admin/users/user_edit.html

➞

Show inline comments

 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.html"/>
 <%def name="title()">
     ${_('Edit user')} ${c.user.username} - ${c.rhodecode_name}
 </%def>
 <%def name="breadcrumbs_links()">
     ${h.link_to(_('Admin'),h.url('admin_home'))}
     &raquo;
     ${h.link_to(_('Users'),h.url('users'))}
     &raquo;
     ${_('edit')} "${c.user.username}"
 </%def>
 <%def name="page_nav()">
 	${self.menu('admin')}
 </%def>
 <%def name="main()">
 <div class="box box-left">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
     <!-- end box / title -->
     ${h.form(url('update_user', id=c.user.user_id),method='put')}
     <div class="form">
         <div class="field">
            <div class="gravatar_box">
                <div class="gravatar"><img alt="gravatar" src="${h.gravatar_url(c.user.email)}"/></div>
                <p>
                <strong>${_('Change your avatar at')} <a href="http://gravatar.com">gravatar.com</a></strong><br/>
                ${_('Using')} ${c.user.email}
                </p>
            </div>
         </div>
         <div class="field">
             <div class="label">
                 <label>${_('API key')}</label> ${c.user.api_key}
             </div>
         </div>
         <div class="fields">
              <div class="field">
                 <div class="label">
                     <label for="username">${_('Username')}:</label>
                 </div>
                 <div class="input">
                     ${h.text('username',class_='medium')}
                 </div>
              </div>
              <div class="field">
                 <div class="label">
                     <label for="ldap_dn">${_('LDAP DN')}:</label>
                 </div>
                 <div class="input">
                     ${h.text('ldap_dn',class_='medium')}
                 </div>
              </div>
              <div class="field">
                 <div class="label">
                     <label for="new_password">${_('New password')}:</label>
                 </div>
                 <div class="input">
                     ${h.password('new_password',class_='medium',autocomplete="off")}
                 </div>
              </div>
              <div class="field">
                 <div class="label">
                     <label for="name">${_('First Name')}:</label>
                 </div>
                 <div class="input">
                     ${h.text('name',class_='medium')}
                 </div>
              </div>
              <div class="field">
                 <div class="label">
                     <label for="lastname">${_('Last Name')}:</label>
                 </div>
                 <div class="input">
                     ${h.text('lastname',class_='medium')}
                 </div>
              </div>
              <div class="field">
                 <div class="label">
                     <label for="email">${_('Email')}:</label>
                 </div>
                 <div class="input">
                     ${h.text('email',class_='medium')}
                 </div>
              </div>
              <div class="field">
                 <div class="label label-checkbox">
                     <label for="active">${_('Active')}:</label>
                 </div>
                 <div class="checkboxes">
                     ${h.checkbox('active',value=True)}
                 </div>
              </div>
              <div class="field">
                 <div class="label label-checkbox">
                     <label for="admin">${_('Admin')}:</label>
                 </div>
                 <div class="checkboxes">
                     ${h.checkbox('admin',value=True)}
                 </div>
              </div>
             <div class="buttons">
               ${h.submit('save',_('Save'),class_="ui-button")}
               ${h.reset('reset',_('Reset'),class_="ui-button")}
             </div>
     	</div>
     </div>
     ${h.end_form()}
 </div>
 <div class="box box-right">
     <!-- box / title -->
     <div class="title">
         <h5>${_('Permissions')}</h5>
     </div>
     ${h.form(url('user_perm', id=c.user.user_id),method='put')}
     <div class="form">
         <!-- fields -->
         <div class="fields">
              <div class="field">
                 <div class="label label-checkbox">
                     <label for="">${_('Create repositories')}:</label>
+                    <label for="create_repo_perm">${_('Create repositories')}:</label>
                 </div>
                 <div class="checkboxes">
                     ${h.checkbox('create_repo_perm',value=True)}
                 </div>
              </div>
             <div class="buttons">
               ${h.submit('save',_('Save'),class_="ui-button")}
               ${h.reset('reset',_('Reset'),class_="ui-button")}
             </div>
         </div>
     </div>
     ${h.end_form()}
 </div>
 </%def>

rhodecode/templates/admin/users_groups/users_group_edit.html

➞

Show inline comments

@@ @@ -64,207 +64,207 @@ @@
 	                                        </div>
 	                                        <div style="float:left;width:20px;padding-top:50px">
 	                                            <img alt="add" id="add_element"
 	                                                style="padding:2px;cursor:pointer"
 	                                                src="${h.url("/images/icons/arrow_left.png")}"/>
 	                                            <br />
 	                                            <img alt="remove" id="remove_element"
 	                                                style="padding:2px;cursor:pointer"
 	                                                src="${h.url("/images/icons/arrow_right.png")}"/>
 	                                        </div>
 	                                        <div style="float:left">
 	                                             <div class="text" style="padding: 0px 0px 6px;">${_('Available members')}</div>
 	                                             ${h.select('available_members',[],c.available_members,multiple=True,size=8,style="min-width:210px")}
 	                                             <div id="add_all_elements" style="cursor:pointer;text-align:center">
 	                                                   <img alt="add" style="vertical-align:text-bottom" src="${h.url("/images/icons/arrow_left.png")}"/>
 	                                                    ${_('Add all elements')}
 	                                             </div>
 	                                        </div>
 	                                    </div>
 	                                </td>
 	                            </tr>
 	                    </table>
                     </div>
                 </div>
                 <div class="buttons">
                   ${h.submit('save',_('save'),class_="ui-button")}
                 </div>
             </div>
     </div>
 ${h.end_form()}
 </div>
 <script type="text/javascript">
     YAHOO.util.Event.onDOMReady(function(){
             var D = YAHOO.util.Dom;
             var E = YAHOO.util.Event;
             //definition of containers ID's
             var available_container = 'available_members';
             var selected_container = 'users_group_members';
             //form containing containers id
             var form_id = 'edit_users_group';
             //temp container for selected storage.
             var cache = new Array();
             var av_cache = new Array();
             var c =  D.get(selected_container);
             var ac = D.get(available_container);
             //get only selected options for further fullfilment
             for(var i = 0;node =c.options[i];i++){
                 if(node.selected){
                     //push selected to my temp storage left overs :)
                     cache.push(node);
+                }
+            }
             //clear 'selected' select
             //c.options.length = 0;
             //fill it with remembered options
             //for(var i = 0;node = cache[i];i++){
             //   c.options[i]=new Option(node.text, node.value, false, false);
             //}
             //get all available options to cache
             for(var i = 0;node =ac.options[i];i++){
                     //push selected to my temp storage left overs :)
                     av_cache.push(node);
+            }
             //fill available only with those not in choosen
             ac.options.length=0;
             tmp_cache = new Array();
             for(var i = 0;node = av_cache[i];i++){
             	var add = true;
 	            for(var i2 = 0;node_2 = cache[i2];i2++){
 	                if(node.value == node_2.value){
 	                	add=false;
 	                	break;
+	                }
+	            }
 	            if(add){
 	            	tmp_cache.push(new Option(node.text, node.value, false, false));
+	            }
+            }
             for(var i = 0;node = tmp_cache[i];i++){
                 ac.options[i] = node;
+            }
             function prompts_action_callback(e){
                 var choosen = D.get(selected_container);
                 var available = D.get(available_container);
                 //get checked and unchecked options from field
                 function get_checked(from_field){
                     //temp container for storage.
                     var sel_cache = new Array();
                     var oth_cache = new Array();
                     for(var i = 0;node = from_field.options[i];i++){
                         if(node.selected){
                             //push selected fields :)
                             sel_cache.push(node);
+                        }
                         else{
                         	oth_cache.push(node)
+                        }
+                    }
                     return [sel_cache,oth_cache]
+                }
                 //fill the field with given options
                 function fill_with(field,options){
                 	//clear firtst
                 	field.options.length=0;
                     for(var i = 0;node = options[i];i++){
                             field.options[i]=new Option(node.text, node.value,
                                     false, false);
+                    }
+                }
                 //adds to current field
                 function add_to(field,options){
                     for(var i = 0;node = options[i];i++){
                             field.appendChild(new Option(node.text, node.value,
                                     false, false));
+                    }
+                }
                 // add action
                 if (this.id=='add_element'){
                     var c = get_checked(available);
                     add_to(choosen,c[0]);
                     fill_with(available,c[1]);
+                }
                 // remove action
                 if (this.id=='remove_element'){
                     var c = get_checked(choosen);
                     add_to(available,c[0]);
                     fill_with(choosen,c[1]);
+                }
                 // add all elements
                 if(this.id=='add_all_elements'){
                     for(var i=0; node = available.options[i];i++){
                             choosen.appendChild(new Option(node.text,
                                     node.value, false, false));
+                    }
                     available.options.length = 0;
+                }
                 //remove all elements
                 if(this.id=='remove_all_elements'){
                     for(var i=0; node = choosen.options[i];i++){
                         available.appendChild(new Option(node.text,
                                 node.value, false, false));
+                    }
                     choosen.options.length = 0;
+                }
+            }
             E.addListener(['add_element','remove_element',
                            'add_all_elements','remove_all_elements'],'click',
                            prompts_action_callback)
             E.addListener(form_id,'submit',function(){
                 var choosen = D.get(selected_container);
                 for (var i = 0; i < choosen.options.length; i++) {
                     choosen.options[i].selected = 'selected';
+                }
             })
         });
 </script>
 <div class="box box-right">
     <!-- box / title -->
     <div class="title">
         <h5>${_('Permissions')}</h5>
     </div>
     ${h.form(url('users_group_perm', id=c.users_group.users_group_id), method='put')}
     <div class="form">
         <!-- fields -->
         <div class="fields">
              <div class="field">
                 <div class="label label-checkbox">
                     <label for="">${_('Create repositories')}:</label>
+                    <label for="create_repo_perm">${_('Create repositories')}:</label>
                 </div>
                 <div class="checkboxes">
                     ${h.checkbox('create_repo_perm',value=True)}
                 </div>
              </div>
             <div class="buttons">
               ${h.submit('save',_('Save'),class_="ui-button")}
               ${h.reset('reset',_('Reset'),class_="ui-button")}
             </div>
         </div>
     </div>
     ${h.end_form()}
 </div>
 </%def>

0 comments (0 inline, 0 general)