async def authenticate_user(email: str, password: str):
user = await get_user(email)
if not user:
return None
if not verify_password(password, user.password):
return None
return user
async def authenticate(self, *, account: str,
password: str) -> Optional[AdminUser]:
user = await self.get_user(account=account)
if not user:
return None
if not verify_password(password, user.hashed_password):
return None
return user
async def authenticate(self, *, account: str,
password: str) -> Optional[User]:
user = await self.get_user(account=account)
if not user:
raise CustomizeBase(err_desc="帐户或密码错误")
if not verify_password(password, user.hashed_password):
raise CustomizeBase(err_desc="帐户或密码错误")
return user
def authenticate(email: str, password: str):
user = get_by_email(email=email)
if not user:
return None
if not verify_password(password, user.password):
return None
print("authenticated user: {} ".format(user.to_dict()))
return user
def authenticate(self, db: Session, *, email: str,
password: str) -> Optional[User]:
user = self.get_by_email(db, email=email)
if not user:
return None
if not verify_password(password, user.hashed_password):
return None
return user
async def authenticate(self, db: Session, cache: aioredis.Redis, *,
username: str, password: str) -> Optional[UserInDB]:
user = await self.get_by_username(db, cache, username=username)
if user is None:
return None
if not verify_password(password, user.hashed_password):
return None
return user
def authenticate(self, db: Session, *, login: str,
password: str) -> Optional[User]:
user = self.get_by_login(db, login=login)
if not user:
return None
if not verify_password(password, user.password):
return None
return user
async def authenticate(db: DBClient, username: str, password: str):
collection = utils.get_collection(db, config.USER_DOCTYPE)
user = await collection.find_one({"username": username})
if not user:
return None
if not verify_password(password, user['hashed_password']):
return None
return user
def authenticate(self, db: Session, *, email: str,
password: str) -> Optional[Client]:
client = self.get_by_email(db, email=email)
if not client:
return None
if not verify_password(password, client.hashed_password):
return None
return client
def authenticate(self, db: Session, *, site_id: int, username: str,
password: str) -> Optional[UserModel]:
db_user = self.get_by_username(db, site_id=site_id, username=username)
if not db_user:
return None
if not verify_password(password, db_user.hashed_password):
return None
return db_user
async def authenticate_by_username(self, db: Database, *, username: str,
password: str) -> Optional[User]:
user = self.get_by_username(db, username=username)
if not user:
return None
if not verify_password(password, user.hashed_password):
return None
return await user
def authenticate(username: str, password: str) -> Optional[DBUser]:
user = get_db_user(username)
if not user:
return None
if not verify_password(plain_password=password,
hashed_password=user.Password):
return None
return user
async def authenticate(db: AsyncSession, *, phone_number: str,
raw_password: str) -> Optional[User]:
user = await get_user_by_phone(db, phone_number=phone_number)
if user is None:
return user
if not verify_password(raw_password, user.password):
return None
return user
def authenticate(db_session: Session, *, email: str,
password_hash: str) -> Optional[User]:
user = get_by_email(db_session, email=email)
if not user:
return None
if not verify_password(password_hash, user.hashed_password):
return None
return user
def authenticate(self, db: Session, *, username: str,
password: str) -> Optional[User]:
user = self.get_user_by_username(db=db, username=username)
if not user:
return None
if not verify_password(password, user.hashed_password):
return None
return user
def authenticate(self, session: Session, username: str,
password: str) -> Optional[models.User]:
user = self.get_by_map(session, models.User, {"username": username})
if not user:
return None
if not verify_password(password, user.hashed_password):
return None
return user
def authenticate_user(session: Session, *, email: str,
password: str) -> Optional[User]:
user = session.query(User).filter(User.email == email).first()
if not user:
return None
if not security.verify_password(password, user.password_hash):
return None
return user
def authenticate(db_session: Session, *, email_or_username: str, password: str) -> Optional[User]:
user = get_by_email(db_session, email=email_or_username)
if not user:
user = get_by_username(db_session, username=email_or_username)
if not user:
return None
if not verify_password(password, user.password):
return None
return user
def test_update_user(db: Session, new_user: User) -> None:
new_password = random_lower_string()
user_in_update = UserUpdate(password=new_password, is_superuser=True)
crud.user.update(db, db_obj=new_user, obj_in=user_in_update)
user = crud.user.get(db, id=new_user.id)
assert user
assert user.username == new_user.username
assert user.email == new_user.email
assert verify_password(new_password, user.hashed_password)
def user_authenticate(
db_session: Session, *, email: EmailStr, password: str
) -> Optional[User]:
user = get_user_by_email(db_session, email=email)
if not user:
return None
if not verify_password(password, user.password_hash):
return None
return user
def authenticate(
self, sess: Session, *, email: str, password: str
) -> Optional[models.Customer]:
customer = self.get_by_email(sess, email)
if not customer:
return None
if not verify_password(password, customer.password):
return None
return customer
async def user(email: str = Body(..., min_length=6), password: str = Body(..., min_length=6)):
try:
user = await Users.objects.get(email=email)
except Exception as e:
return HTTPException(status.HTTP_204_NO_CONTENT, detail="用户不存在")
if not verify_password(password, user.password):
return HTTPException(status.HTTP_401_UNAUTHORIZED, detail="密码错误请重试")
token = create_access_token(data={"username": user.username, "email": user.email, "scopes": [user.permission]})
return {"username": user.username, "email": user.email, "id": user.id, "token": token}
def test_update_user_student(db: Session) -> None:
user = create_random_user(db, type="student")
new_password = random_password()
user_in_update = UserUpdate(password=new_password)
crud.user.update(db, db_obj=user, obj_in=user_in_update)
user_2 = crud.user.get(db, id=user.id)
assert user_2
assert user.email == user_2.email
assert verify_password(new_password, user_2.hashed_password)
async def authenticate(async_db: Database, *, email: str,
password: str) -> Optional[User]:
user = await get_by_email(async_db, email=email)
if not user:
return None
if not verify_password(password, user.hashed_password):
return None
# Convert to User instance from UserInDb that does not includes hash.
return User(**user.dict())
def user_authenticate(db_session: Session, *, email: EmailStr,
password: str) -> Optional[User]:
user = get_user_by_email(db_session, email=email)
if not user:
return None
if not verify_password(password, user.password_hash):
return None
if not user.email_verified:
raise HTTPException(status_code=401, detail="Email not verified.")
return user
def authenticate(self, db: Session, *, email: str, password: str) -> Optional[User]:
"""
Returns user if user exists and password is correct, returns None otherwise
"""
_user = self.get_by_email(db, email=email)
if not _user:
return None
if not verify_password(password, _user.hashed_password):
return None
return _user
def test_update_user_with_dict_superuser(db: Session) -> None:
user = create_random_user(db, type="superuser")
db.refresh(user)
new_password = random_password()
user_in_update = {"password": new_password}
crud.user.update(db, db_obj=user, obj_in=user_in_update)
user_2 = crud.user.get(db, id=user.id)
assert user_2
assert user.email == user_2.email
assert verify_password(new_password, user_2.hashed_password)
async def authenticate(db: DBClient, username: str, password: str, prj_id: str):
collection = utils.get_collection(db, DOCTYPE_PERSONA)
user = await collection.find_one(
{"username": username, "prj_id": ObjectId(prj_id)}
)
if not user:
return None
if not verify_password(password, user['hashed_password']):
return None
return user
def test_update_user():
password = random_lower_string()
username = random_lower_string()
user_in = UserCreate(email=username, password=password, is_superuser=True)
user = crud.user.create(db_session, obj_in=user_in)
new_password = random_lower_string()
user_in = UserUpdate(password=new_password, is_superuser=True)
crud.user.update(db_session, db_obj=user, obj_in=user_in)
user_2 = crud.user.get(db_session, id=user.id)
assert user.email == user_2.email
assert verify_password(new_password, user_2.hashed_password)
async def authenticate_persona(db: DBClient, username: str, password: str, prj_id: str):
logging.info(f">>> {__name__}:{authenticate_persona.__name__}")
collection = utils.get_collection(db, DOCTYPE_PERSONA)
user = await collection.find_one(
{"username": username, "prj_id": ObjectId(prj_id)}
)
if not user:
return None
if not verify_password(password, user['hashed_password']):
return None
return user
