User usermodel instead of db model to manage accounts

- initial refactoring of models to handle rhodecode+api

rhodecode/lib/db_manage.py

@@ -33,7 +33,7 b' from os.path import dirname as dn, join '
 from rhodecode import __dbversion__
 from rhodecode.model import meta
 
-from rhodecode.lib.auth import get_crypt_password, generate_api_key
+from rhodecode.model.user import UserModel
 from rhodecode.lib.utils import ask_ok
 from rhodecode.model import init_model
 from rhodecode.model.db import User, Permission, RhodeCodeUi, \
@@ -415,30 +415,18 b' class DbManage(object):'
         log.info('created ui config')
 
     def create_user(self, username, password, email='', admin=False):
-        log.info('creating administrator user %s', username)
-        
-        form_data = dict(username=username,
-                         password=password,
-                         active=True,
-                         admin=admin,
-                         name='RhodeCode',
-                         lastname='Admin',
-                         email=email)
-        User.create(form_data)
-
+        log.info('creating user %s', username)
+        UserModel().create_or_update(username, password, email, 
+                                     name='RhodeCode', lastname='Admin', 
+                                     active=True, admin=admin)
 
     def create_default_user(self):
         log.info('creating default user')
-        #create default user for handling default permissions.
-
-        form_data = dict(username='default',
-                         password=str(uuid.uuid1())[:8],
-                         active=False,
-                         admin=False,
-                         name='Anonymous',
-                         lastname='User',
-                         email='[e-mail]')
-        User.create(form_data)
+        # create default user for handling default permissions.
+        UserModel().create_or_update(username='default', 
+                              password=str(uuid.uuid1())[:8], 
+                              email='[e-mail]', 
+                              name='Anonymous', lastname='User')
         
     def create_permissions(self):
         #module.(access|create|change|delete)_[name]

rhodecode/lib/utils.py

@@ -47,15 +47,14 b' from rhodecode.model import meta'
 from rhodecode.model.caching_query import FromCache
 from rhodecode.model.db import Repository, User, RhodeCodeUi, UserLog, RepoGroup, \
     RhodeCodeSetting
-from rhodecode.model.repo import RepoModel
 
 log = logging.getLogger(__name__)
 
 
-def recursive_replace(str, replace=' '):
+def recursive_replace(str_, replace=' '):
     """Recursive replace of given sign to just one instance
 
-    :param str: given string
+    :param str_: given string
     :param replace: char to find and replace multiple instances
 
     Examples::
@@ -63,11 +62,11 b" def recursive_replace(str, replace=' '):"
     'Mighty-Mighty-Bo-sstones'
     """
 
-    if str.find(replace * 2) == -1:
-        return str
+    if str_.find(replace * 2) == -1:
+        return str_
     else:
-        str = str.replace(replace * 2, replace)
-        return recursive_replace(str, replace)
+        str_ = str_.replace(replace * 2, replace)
+        return recursive_replace(str_, replace)
 
 
 def repo_name_slug(value):
@@ -116,13 +115,12 b' def action_logger(user, action, repo, ip'
         else:
             raise Exception('You have to provide user object or username')
 
-        rm = RepoModel()
         if hasattr(repo, 'repo_id'):
-            repo_obj = rm.get(repo.repo_id, cache=False)
+            repo_obj = Repository.get(repo.repo_id)
             repo_name = repo_obj.repo_name
         elif  isinstance(repo, basestring):
             repo_name = repo.lstrip('/')
-            repo_obj = rm.get_by_repo_name(repo_name, cache=False)
+            repo_obj = Repository.get_by_repo_name(repo_name)
         else:
             raise Exception('You have to provide repository to action logger')
 
@@ -151,8 +149,6 b' def get_repos(path, recursive=False):'
     :param path: path to scann for repositories
     :param recursive: recursive search and return names with subdirs in front
     """
-    from vcs.utils.helpers import get_scm
-    from vcs.exceptions import VCSError
 
     if path.endswith(os.sep):
         #remove ending slash for better results
@@ -377,17 +373,20 b' def map_groups(groups):'
 
 
 def repo2db_mapper(initial_repo_list, remove_obsolete=False):
-    """maps all repos given in initial_repo_list, non existing repositories
+    """
+    maps all repos given in initial_repo_list, non existing repositories
     are created, if remove_obsolete is True it also check for db entries
     that are not in initial_repo_list and removes them.
 
     :param initial_repo_list: list of repositories found by scanning methods
     :param remove_obsolete: check for obsolete entries in database
     """
-
+    from rhodecode.model.repo import RepoModel
     sa = meta.Session()
     rm = RepoModel()
     user = sa.query(User).filter(User.admin == True).first()
+    if user is None:
+        raise Exception('Missing administrative account !')    
     added = []
     # fixup groups paths to new format on the fly
     # TODO: remove this in future

rhodecode/model/db.py

@@ -30,6 +30,7 b' import traceback'
 from datetime import date
 
 from sqlalchemy import *
+from sqlalchemy.exc import DatabaseError
 from sqlalchemy.ext.hybrid import hybrid_property
 from sqlalchemy.orm import relationship, joinedload, class_mapper, validates
 from beaker.cache import cache_region, region_invalidate
@@ -322,26 +323,6 b' class User(Base, BaseModel):'
         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}

rhodecode/model/user.py

@@ -92,6 +92,54 b' class UserModel(BaseModel):'
             self.sa.rollback()
             raise
 
+
+    def create_or_update(self, username, password, email, name, lastname, 
+                         active=True, admin=False, ldap_dn=None):
+        """
+        Creates a new instance if not found, or updates current one
+        
+        :param username:
+        :param password:
+        :param email:
+        :param active:
+        :param name:
+        :param lastname:
+        :param active:
+        :param admin:
+        :param ldap_dn:
+        """
+        
+        from rhodecode.lib.auth import get_crypt_password
+        
+        log.debug('Checking for %s account in RhodeCode database', username)
+        user = User.get_by_username(username, case_insensitive=True)
+        if user is None:
+            log.debug('creating new user %s', username)            
+            new_user = User()
+        else:
+            log.debug('updating user %s', username)            
+            new_user = user
+            
+        try:
+            new_user.username = username
+            new_user.admin = admin
+            new_user.password = get_crypt_password(password)
+            new_user.api_key = generate_api_key(username)
+            new_user.email = email
+            new_user.active = active
+            new_user.ldap_dn = safe_unicode(ldap_dn) if ldap_dn else None
+            new_user.name = name
+            new_user.lastname = lastname
+
+            self.sa.add(new_user)
+            self.sa.commit()
+            return new_user
+        except (DatabaseError,):
+            log.error(traceback.format_exc())
+            self.sa.rollback()
+            raise
+    
+    
     def create_for_container_auth(self, username, attrs):
         """
         Creates the given user if it's not already in the database