Python User.ldap_dn方法代码示例

# 需要导入模块: from rhodecode.model.db import User [as 别名]
# 或者: from rhodecode.model.db.User import ldap_dn [as 别名]
    def create_ldap(self, username, password, user_dn, attrs):
        """
        Checks if user is in database, if not creates this user marked
        as ldap user
        
        :param username:
        :param password:
        :param user_dn:
        :param attrs:
        """
        from rhodecode.lib.auth import get_crypt_password
        log.debug('Checking for such ldap account in RhodeCode database')
        if self.get_by_username(username, case_insensitive=True) is None:
            try:
                new_user = User()
                # add ldap account always lowercase
                new_user.username = username.lower()
                new_user.password = get_crypt_password(password)
                new_user.api_key = generate_api_key(username)
                new_user.email = attrs['email']
                new_user.active = True
                new_user.ldap_dn = safe_unicode(user_dn)
                new_user.name = attrs['name']
                new_user.lastname = attrs['lastname']

                self.sa.add(new_user)
                self.sa.commit()
                return True
            except (DatabaseError,):
                log.error(traceback.format_exc())
                self.sa.rollback()
                raise
        log.debug('this %s user exists skipping creation of ldap account',
                  username)
        return False

# 需要导入模块: from rhodecode.model.db import User [as 别名]
# 或者: from rhodecode.model.db.User import ldap_dn [as 别名]
    def create_or_update(
        self, username, password, email, firstname="", 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 firstname:
        :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()
            edit = False
        else:
            log.debug("updating user %s" % username)
            new_user = user
            edit = True

        try:
            new_user.username = username
            new_user.admin = admin
            # set password only if creating an user or password is changed
            if not edit or user.password != password:
                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 = firstname
            new_user.lastname = lastname
            self.sa.add(new_user)
            return new_user
        except (DatabaseError,):
            log.error(traceback.format_exc())
            raise

# 需要导入模块: from rhodecode.model.db import User [as 别名]
# 或者: from rhodecode.model.db.User import ldap_dn [as 别名]
    def create_ldap(self, username, password, user_dn, attrs):
        """
        Checks if user is in database, if not creates this user marked
        as ldap user

        :param username:
        :param password:
        :param user_dn:
        :param attrs:
        """
        from rhodecode.lib.auth import get_crypt_password

        log.debug("Checking for such ldap account in RhodeCode database")
        if self.get_by_username(username, case_insensitive=True) is None:

            # autogenerate email for ldap account without one
            generate_email = lambda usr: "%[email protected]" % usr

            try:
                new_user = User()
                username = username.lower()
                # add ldap account always lowercase
                new_user.username = username
                new_user.password = get_crypt_password(password)
                new_user.api_key = generate_api_key(username)
                new_user.email = attrs["email"] or generate_email(username)
                new_user.active = attrs.get("active", True)
                new_user.ldap_dn = safe_unicode(user_dn)
                new_user.name = attrs["name"]
                new_user.lastname = attrs["lastname"]

                self.sa.add(new_user)
                return new_user
            except (DatabaseError,):
                log.error(traceback.format_exc())
                self.sa.rollback()
                raise
        log.debug("this %s user exists skipping creation of ldap account", username)
        return None

# 需要导入模块: from rhodecode.model.db import User [as 别名]
# 或者: from rhodecode.model.db.User import ldap_dn [as 别名]
    def create_ldap(self, username, password, user_dn, attrs, cur_user=None):
        """
        Checks if user is in database, if not creates this user marked
        as ldap user

        :param username:
        :param password:
        :param user_dn:
        :param attrs:
        :param cur_user:
        """
        if not cur_user:
            cur_user = getattr(get_current_rhodecode_user(), "username", None)
        from rhodecode.lib.auth import get_crypt_password

        log.debug("Checking for such ldap account in RhodeCode database")
        if self.get_by_username(username, case_insensitive=True) is None:
            # autogenerate email for container account without one
            generate_email = lambda usr: "%[email protected]" % usr
            password = get_crypt_password(password)
            firstname = attrs["name"]
            lastname = attrs["lastname"]
            active = attrs.get("active", True)
            email = attrs["email"] or generate_email(username)

            from rhodecode.lib.hooks import log_create_user, check_allowed_create_user

            user_data = {
                "username": username,
                "password": password,
                "email": email,
                "firstname": firstname,
                "lastname": lastname,
                "active": attrs.get("active", True),
                "admin": False,
            }
            # raises UserCreationError if it's not allowed
            check_allowed_create_user(user_data, cur_user)

            try:
                new_user = User()
                username = username.lower()
                # add ldap account always lowercase
                new_user.username = username
                new_user.password = password
                new_user.api_key = generate_api_key(username)
                new_user.email = email
                new_user.active = active
                new_user.ldap_dn = safe_unicode(user_dn)
                new_user.name = firstname
                new_user.lastname = lastname
                self.sa.add(new_user)

                log_create_user(new_user.get_dict(), cur_user)
                return new_user
            except (DatabaseError,):
                log.error(traceback.format_exc())
                self.sa.rollback()
                raise
        log.debug("this %s user exists skipping creation of ldap account", username)
        return None

# 需要导入模块: from rhodecode.model.db import User [as 别名]
# 或者: from rhodecode.model.db.User import ldap_dn [as 别名]
    def create_or_update(
        self,
        username,
        password,
        email,
        firstname="",
        lastname="",
        active=True,
        admin=False,
        ldap_dn=None,
        cur_user=None,
    ):
        """
        Creates a new instance if not found, or updates current one

        :param username:
        :param password:
        :param email:
        :param active:
        :param firstname:
        :param lastname:
        :param active:
        :param admin:
        :param ldap_dn:
        :param cur_user:
        """
        if not cur_user:
            cur_user = getattr(get_current_rhodecode_user(), "username", None)

        from rhodecode.lib.auth import get_crypt_password
        from rhodecode.lib.hooks import log_create_user, check_allowed_create_user

        user_data = {
            "username": username,
            "password": password,
            "email": email,
            "firstname": firstname,
            "lastname": lastname,
            "active": active,
            "admin": admin,
        }
        # raises UserCreationError if it's not allowed
        check_allowed_create_user(user_data, cur_user)

        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()
            edit = False
        else:
            log.debug("updating user %s" % username)
            new_user = user
            edit = True

        try:
            new_user.username = username
            new_user.admin = admin
            # set password only if creating an user or password is changed
            if not edit or user.password != password:
                new_user.password = get_crypt_password(password) if password else None
                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 = firstname
            new_user.lastname = lastname
            self.sa.add(new_user)

            if not edit:
                log_create_user(new_user.get_dict(), cur_user)
            return new_user
        except (DatabaseError,):
            log.error(traceback.format_exc())
            raise