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)