Python UserModel.get_by_username方法代码示例

# 需要导入模块: from rhodecode.model.user import UserModel [as 别名]
# 或者: from rhodecode.model.user.UserModel import get_by_username [as 别名]
    def register(self):
        user_model = UserModel()
        c.auto_active = False
        for perm in user_model.get_by_username('default',
                                               cache=False).user_perms:
            if perm.permission.permission_name == 'hg.register.auto_activate':
                c.auto_active = True
                break

        if request.POST:

            register_form = RegisterForm()()
            try:
                form_result = register_form.to_python(dict(request.POST))
                form_result['active'] = c.auto_active
                user_model.create_registration(form_result)
                h.flash(_('You have successfully registered into rhodecode'),
                            category='success')
                return redirect(url('login_home'))

            except formencode.Invalid, errors:
                return htmlfill.render(
                    render('/register.html'),
                    defaults=errors.value,
                    errors=errors.error_dict or {},
                    prefix_error=False,
                    encoding="UTF-8")

# 需要导入模块: from rhodecode.model.user import UserModel [as 别名]
# 或者: from rhodecode.model.user.UserModel import get_by_username [as 别名]
def action_logger(user, action, repo, ipaddr='', sa=None):
    """
    Action logger for various actions made by users

    :param user: user that made this action, can be a unique username string or
        object containing user_id attribute
    :param action: action to log, should be on of predefined unique actions for
        easy translations
    :param repo: string name of repository or object containing repo_id,
        that action was made on
    :param ipaddr: optional ip address from what the action was made
    :param sa: optional sqlalchemy session

    """

    if not sa:
        sa = meta.Session()

    try:
        um = UserModel()
        if hasattr(user, 'user_id'):
            user_obj = user
        elif isinstance(user, basestring):
            user_obj = um.get_by_username(user, cache=False)
        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_name = repo_obj.repo_name
        elif  isinstance(repo, basestring):
            repo_name = repo.lstrip('/')
            repo_obj = rm.get_by_repo_name(repo_name, cache=False)
        else:
            raise Exception('You have to provide repository to action logger')

        user_log = UserLog()
        user_log.user_id = user_obj.user_id
        user_log.action = action

        user_log.repository_id = repo_obj.repo_id
        user_log.repository_name = repo_name

        user_log.action_date = datetime.datetime.now()
        user_log.user_ip = ipaddr
        sa.add(user_log)
        sa.commit()

        log.info('Adding user %s, action %s on %s', user_obj, action, repo)
    except:
        log.error(traceback.format_exc())
        sa.rollback()

# 需要导入模块: from rhodecode.model.user import UserModel [as 别名]
# 或者: from rhodecode.model.user.UserModel import get_by_username [as 别名]
    def propagate_data(self):
        user_model = UserModel()
        self.anonymous_user = user_model.get_by_username("default", cache=True)
        if self._api_key and self._api_key != self.anonymous_user.api_key:
            # try go get user by api key
            log.debug("Auth User lookup by API KEY %s", self._api_key)
            user_model.fill_data(self, api_key=self._api_key)
        else:
            log.debug("Auth User lookup by USER ID %s", self.user_id)
            if self.user_id is not None and self.user_id != self.anonymous_user.user_id:
                user_model.fill_data(self, user_id=self.user_id)
            else:
                if self.anonymous_user.active is True:
                    user_model.fill_data(self, user_id=self.anonymous_user.user_id)
                    # then we set this user is logged in
                    self.is_authenticated = True
                else:
                    self.is_authenticated = False

        log.debug("Auth User is now %s", self)
        user_model.fill_perms(self)

# 需要导入模块: from rhodecode.model.user import UserModel [as 别名]
# 或者: from rhodecode.model.user.UserModel import get_by_username [as 别名]
def authenticate(username, password):
    """Authentication function used for access control,
    firstly checks for db authentication then if ldap is enabled for ldap
    authentication, also creates ldap user if not in database

    :param username: username
    :param password: password
    """

    user_model = UserModel()
    user = user_model.get_by_username(username, cache=False)

    log.debug("Authenticating user using RhodeCode account")
    if user is not None and not user.ldap_dn:
        if user.active:
            if user.username == "default" and user.active:
                log.info("user %s authenticated correctly as anonymous user", username)
                return True

            elif user.username == username and check_password(password, user.password):
                log.info("user %s authenticated correctly", username)
                return True
        else:
            log.warning("user %s is disabled", username)

    else:
        log.debug("Regular authentication failed")
        user_obj = user_model.get_by_username(username, cache=False, case_insensitive=True)

        if user_obj is not None and not user_obj.ldap_dn:
            log.debug("this user already exists as non ldap")
            return False

        ldap_settings = RhodeCodeSettings.get_ldap_settings()
        # ======================================================================
        # FALLBACK TO LDAP AUTH IF ENABLE
        # ======================================================================
        if str2bool(ldap_settings.get("ldap_active")):
            log.debug("Authenticating user using ldap")
            kwargs = {
                "server": ldap_settings.get("ldap_host", ""),
                "base_dn": ldap_settings.get("ldap_base_dn", ""),
                "port": ldap_settings.get("ldap_port"),
                "bind_dn": ldap_settings.get("ldap_dn_user"),
                "bind_pass": ldap_settings.get("ldap_dn_pass"),
                "tls_kind": ldap_settings.get("ldap_tls_kind"),
                "tls_reqcert": ldap_settings.get("ldap_tls_reqcert"),
                "ldap_filter": ldap_settings.get("ldap_filter"),
                "search_scope": ldap_settings.get("ldap_search_scope"),
                "attr_login": ldap_settings.get("ldap_attr_login"),
                "ldap_version": 3,
            }
            log.debug("Checking for ldap authentication")
            try:
                aldap = AuthLdap(**kwargs)
                (user_dn, ldap_attrs) = aldap.authenticate_ldap(username, password)
                log.debug("Got ldap DN response %s", user_dn)

                get_ldap_attr = lambda k: ldap_attrs.get(ldap_settings.get(k), [""])[0]

                user_attrs = {
                    "name": safe_unicode(get_ldap_attr("ldap_attr_firstname")),
                    "lastname": safe_unicode(get_ldap_attr("ldap_attr_lastname")),
                    "email": get_ldap_attr("ldap_attr_email"),
                }

                if user_model.create_ldap(username, password, user_dn, user_attrs):
                    log.info("created new ldap user %s", username)

                return True
            except (LdapUsernameError, LdapPasswordError):
                pass
            except (Exception,):
                log.error(traceback.format_exc())
                pass
    return False