async def get_user(conn: AsyncIOMotorClient, username: str) -> UserInDB:
row = await conn[database_name][users_collection_name].find_one(
{"username": username})
if row:
dbuser = UserInDB(**row)
dbuser.id = str(row["_id"])
return dbuser
async def get_user_by_email(conn: AsyncIOMotorClient,
email: EmailStr) -> UserInDB:
row = await conn[database_name][users_collection_name].find_one(
{"email": email})
if row:
dbuser = UserInDB(**row)
dbuser.id = str(row["_id"])
return dbuser
async def create_user(conn: AsyncIOMotorClient, user: UserInCreate) -> UserInDB:
dbuser = UserInDB(**user.dict())
dbuser.change_password(user.password)
row = await conn[database_name][user_collection_name].insert_one(dbuser.dict())
# dbuser.created_at = ObjectId(dbuser.id ).generation_time
# dbuser.updated_at = ObjectId(dbuser.id ).generation_time
# await conn[database_name][user_collection_name]\
# .update_one({"username": dbuser.username}, {'$set': dbuser.dict()})
return dbuser
def register_user(new_user: UserInDB):
new_user.hashed_password = get_password_hash(new_user.password)
userDb[new_user.username] = new_user.__dict__
with open('userDb.json', 'w') as f:
f.write(json.dumps(userDb, indent=4, sort_keys=True))
return "SUCCESS"
def get(self, username: str):
result = None
if username in self.db:
result = self.db[username]
if result is None:
return None
return UserInDB(**result)
async def test_user_with_wrong_creds_doesnt_receive_token(
self,
app: FastAPI,
client: AsyncClient,
test_user: UserInDB,
credential: str,
wrong_value: str,
status_code: int,
) -> None:
client.headers["content-type"] = "application/x-www-form-urlencoded"
user_data = test_user.dict()
# insert user's plaintext password
user_data["password"] = "******"
user_data[credential] = wrong_value
login_data = {
"username": user_data["email"],
# insert password from parameters
"password": user_data["password"],
}
res = await client.post(
app.url_path_for("users:login-email-and-password"),
data=login_data)
assert res.status_code == status_code
assert "access_token" not in res.json()
async def get_user_by_username(self, *, username: str) -> UserInDB:
user = await self.db.fetch_one(query=GET_USER_BY_USERNAME_QUERY,
values={'username': username})
if not user:
return None
return UserInDB(**user)
def update(self, username: str, userIn: UserUpdate):
self.db[username]["hashed_password"] = get_password_hash(userIn.hashed_password)
result = self.db[username]
if result.acknowledged:
result = self.database.players.find_one({"_id": username})
if result is None:
return None
return UserInDB(**result)
async def create_in_db(db: AsyncIOMotorDatabase, *,
user_in: UserCreate) -> InsertOneResult:
passwordhash = get_password_hash(user_in.password)
user = UserInDB(**user_in.dict(), hashed_password=passwordhash)
doc_data = jsonable_encoder(user)
res = await db[USER_COLLECTION_NAME].insert_one(doc_data)
return res
async def authenticate_user(username: str, password: str):
user_data = await mail_db['user'].find_one({ 'username': username })
if not user_data:
return False
user = UserInDB(**user_data)
if not verify_password(password, user.hashed_password):
return False
return user
async def get_user_by_email(self, *, email: EmailStr) -> UserInDB:
user = await self.db.fetch_one(query=GET_USER_BY_EMAIL_QUERY,
values={'email': email})
if not user:
return None
return UserInDB(**user)
async def create_user(api_user: UserIn, cli: AsyncIOMotorClient) -> BaseModel:
hashed_password = generate_hash(api_user.password)
api_user = UserInDB(**api_user.dict(),
created_at=epoch_time(),
last_login=0,
hashed_password=hashed_password)
row = await cli[mongo_db]['users'].insert_one(api_user.dict())
return UserOut(**api_user.dict(), id=str(row.inserted_id))
async def create_user(conn: AsyncIOMotorClient,
user: UserInRegister) -> UserInDB:
dbuser = UserInDB(**user.dict())
dbuser.change_password(user.password)
dbuser.created_at = datetime.now()
dbuser.updated_at = datetime.now()
inserted_row = await conn[database_name][users_collection_name].insert_one(
dbuser.dict())
dbuser.id = str(inserted_row.inserted_id)
return dbuser
def update(self, username: str, userIn: UserUpdate):
result = self.database.players.update_one({"_id": username}, {
"$set": {
"hashed_password": get_password_hash(userIn.hashed_password)
}
})
if result.acknowledged:
result = self.database.players.find_one({"_id": username})
if result is None:
return None
return UserInDB(**result)
def _create_user_db(user: User, hashed_password: str) -> UserInDB:
""" Create a user model to save in DB
:param user: User
:param hashed_password: hashed password
:return: UserInDB
"""
return UserInDB(username=user.username,
email=user.email,
full_name=user.full_name,
disabled=user.disabled,
hashed_password=hashed_password)
async def login(form_data: OAuth2PasswordRequestForm = Depends()):
user_dict = await users.get_login(form_data.username)
if not user_dict:
raise HTTPException(status_code=HTTP_400_BAD_REQUEST,
detail="Incorrect username or password")
user = UserInDB(**user_dict)
hashed_password = fake_hash_password(form_data.password)
if not user.hashed_password == hashed_password:
raise HTTPException(status_code=HTTP_400_BAD_REQUEST,
detail="Incorrect username or password")
return {"access_token": user.id, "token_type": "bearer"}
async def get_current_user(token: str = Depends(oauth2_scheme)):
credentials_exception = HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Could not validate credentials",
headers={"WWW-Authenticate": "Bearer"},
)
try:
payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
username: str = payload.get("sub")
if username is None:
raise credentials_exception
token_data = TokenData(username=username)
except JWTError:
raise credentials_exception
user_data = await mail_db['user'].find_one({ 'username': token_data.username })
user = UserInDB(**user_data)
if user is None:
raise credentials_exception
return user
async def insert_one(data: UserCreate):
logging.info(">>> " + __name__ + ":insert_one")
# Check license
valid = await is_license_valid(data.license)
if not valid:
raise_bad_request("License is not valid")
collection = get_collection(DOCUMENT_TYPE)
hashed_password = get_password_hash(data.password)
model = UserInDB(**data.dict(), hashed_password=hashed_password)
props = fields_in_create(model)
try:
rs = await collection.insert_one(props)
if rs.inserted_id:
user = await collection.find_one({"_id": rs.inserted_id})
return user
except Exception as e:
logging.info(e)
raise_server_error(str(e))
async def register_new_user(self, *, new_user: UserCreate) -> UserInDB:
# make sure email isn't already taken
if await self.get_user_by_email(email=new_user.email):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail=
"That email is already taken. Login with that email or register with another one."
)
# make sure username isn't already taken
if await self.get_user_by_username(username=new_user.username):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="That username is already taken. Please try another one."
)
user_password_update = self.auth_service.create_salt_and_hashed_password(
plaintext_password=new_user.password)
new_user_params = new_user.copy(update=user_password_update.dict())
created_user = await self.db.fetch_one(query=REGISTER_NEW_USER_QUERY,
values=new_user_params.dict())
return UserInDB(**created_user)
def get_user(db, username: str):
if username in db:
user_dict = db[username]
return UserInDB(**user_dict)
async def get_user_by_email(conn: AsyncIOMotorClient, email: EmailStr) -> UserInDB:
row = await conn[database_name][user_collection_name].find_one({"email": email})
if row:
return UserInDB(**row)
async def get_user(db: AsyncIOMotorDatabase, username: str) -> UserInDB:
row = await db[USER_COLLECTION_NAME].find_one({"username": username})
if row:
return UserInDB(**row)
async def get_user(conn: AsyncIOMotorClient, username: str) -> UserInDB:
row = await conn[database_name][user_collection_name].find_one({"username": username})
if row:
return UserInDB(**row)
def get_users():
with open(file_path, 'r') as users_file:
users = json.load(users_file)
return [UserInDB(**users[username]) for username in users]
def get_user(userDb, username: str):
if username in userDb:
user_dict = userDb[username]
return UserInDB(**user_dict)
def get(self, username: str):
result = self.database.players.find_one({"_id": username})
if result is None:
return None
return UserInDB(**result)
def get_user(username: str):
with open(file_path, 'r') as users_file:
users = json.load(users_file)
if username in users:
user_dict = users[username]
return UserInDB(**user_dict)
async def get_user(username: str):
logging.info(">>> " + __name__ + ":get_user")
user = await find_one(username)
logging.info(user)
if user:
return UserInDB(**user)
def create_model_from_dict(self, d: dict, obj_id: str) -> UserInDB:
d["id"] = obj_id
return UserInDB(**d)
