def populate_database(): group1 = db.Group(name='group1') group2 = db.Group(name='group2') role1 = db.Role(name='role1') role2 = db.Role(name='role2') db.Role(name='role3') user1 = db.User(username='******', password=get_password_hash('1234'), email='*****@*****.**', groups=[group1]) user2 = db.User(username='******', password=get_password_hash('1234'), email='*****@*****.**', groups=[group1]) user3 = db.User(username='******', password=get_password_hash('1234'), email='*****@*****.**', roles=[role2]) user4 = db.User(username='******', password=get_password_hash('1234'), email='*****@*****.**', roles=[role2]) lang1 = db.Lang(name='Spanish') lang2 = db.Lang(name='English') lang3 = db.Lang(name='French') state = db.NotifyState(name='Nuevo') db.NotifyState(name='Leido') db.NotifyState(name='Borrado') db.Group(name='group3') db.App(name='App1') db.App(name='App2') app = db.App(name='App3') db.App_lang(app=app, lang=lang1, filename='example.ts') users = [user1, user2] groups = [group1] roles = [role1]
def init() -> None: db = SessionLocal() # 初始化用户信息 user_info = [{ "username": "******", "password": "******", "nickname": "艾尔文", "avatar": "/img/alvin.jpeg" }, { "username": "******", "password": "******", "nickname": "卡卡洛特", "avatar": "/img/wukong.jpeg" }, { "username": "******", "password": "******", "nickname": "小猫🐱", "avatar": "/img/xiaomao.jpg" }] for item in user_info: hashed_password = get_password_hash(password=item["password"]) sql = f"""INSERT INTO chat_user (user_id, username, hashed_password, nickname, avatar)VALUES( "{str(uuid.uuid4()).replace("-",'')}", "{item["username"]}", "{hashed_password}", "{item["nickname"]}", "{item["avatar"]}");""" db.execute(sql) db.commit()
def edit_user(db: Session, user_id: int, user: schemas.UserEdit): """ edit_user [summary] Args: db (Session): データベース接続 user_id (int): 編集するユーザーのID user (schemas.UserEdit): 編集するユーザーのデータ Raises: HTTPException: ユーザーが見つからない旨のHTTP 404 エラー Returns: schemas.User: 編集されるユーザー情報 """ db_user = get_user(db, user_id) if not db_user: raise HTTPException(status.HTTP_404_NOT_FOUND, detail="User not found") update_data = user.dict(exclude_unset=True) if "password" in update_data: update_data["hashed_password"] = get_password_hash(user.password) del update_data["password"] for key, value in update_data.items(): setattr(db_user, key, value) db.add(db_user) db.commit() db.refresh(db_user) return db_user
async def add_member(db: DBClient, ref: str, mtype: str, data: GuestCreate): logging.info(f">>> {__name__}:{add_member.__name__}") collection = utils.get_collection(db, config.DOCTYPE_PROJECT) dic = { "_id": str(ObjectId()), **data.dict(), "type": mtype, "hashed_password": get_password_hash(data.password) } del dic["password"] rs = await collection.find_one_and_update( {"_id": ObjectId(ref)}, {"$push": { "members": dic }}, { "_id": 0, "members": { "$elemMatch": { "username": data.username } } }, return_document=ReturnDocument.AFTER) if rs['members']: return rs['members'][0] return None
async def reset_password(token: str = Body(...), new_password: str = Body(...)): """ Reset password [NOT IMPLEMENTED YET] """ logging.info(">>> " + __name__ + ":" + reset_password.__name__ ) username = verify_password_reset_token(token) if not username: raise HTTPException(status_code=400, detail="Invalid token") db = get_database() user = await crud.get(db, username) if not user: raise HTTPException( status_code=404, detail="The user with this username does not exist in the system.", ) # NOT IMPLEMENTED YET # elif not crud.user.is_active(user): # raise HTTPException(status_code=400, detail="Inactive user") # user_in = UserUpdate(name=username, password=new_password) # user = crud.user.update(bucket, username=username, user_in=user_in) logging.info("FULL NAME: " + user['full_name']) hashed_password = get_password_hash(password=new_password) collection = get_collection(db, DOCTYPE_USER) rs = await collection.update_one( {"username": username}, {'$set': { 'hashed_password': hashed_password, 'modified': datetime.utcnow() } } ) return {"msg": "Password updated successfully"}
def reset_password( token: str = Body(...), new_password: str = Body(...), db: Session = Depends(deps.get_db), ) -> Any: """ Reset password :return: """ email = verify_password_reset_token(token) if not email: raise HTTPException(status_code=400, detail="Invalid token") user = crud.user.get_by_email(db, email=email) if not user: raise HTTPException( status_code=404, detail="The user with this username does not exist in the system.", ) elif not crud.user.is_active(user): raise HTTPException(status_code=400, detail="Inactive user") hashed_password = get_password_hash(new_password) user.hashed_password = hashed_password db.add(user) db.commit() return {"msg": "Password updated successfully"}
def update(self, db: Session, *, db_obj: User, obj_in: Union[UserUpdate, Dict[str, Any]]) -> UserScheme: if isinstance(obj_in, dict): update_data = obj_in else: update_data = obj_in.dict(exclude_unset=True) if update_data["password"]: hashed_password = get_password_hash(update_data["password"]) del update_data["password"] update_data["hashed_password"] = hashed_password # fixme # can't use `jsonable_encoder` after `db_obj` is committed # update `userprofile` table db_profile = self.update_once(db_obj.profile, update_data.get("profile")) db.add(db_profile) del update_data["profile"] # update `userextend` table db_extend = self.update_once(db_obj.extend, update_data.get("extend")) db.add(db_extend) del update_data["extend"] # update `user` table db_obj = db_profile = self.update_once(db_obj, update_data) db.add(db_obj) db.commit() db.refresh(db_obj) return self.get_full_info(db, db_obj)
async def user(user: CreateUser): hash_password = get_password_hash(user.password) await Users.objects.create(email=user.email, phone=user.phone, password=hash_password, username=user.username) task = celery_app.send_task("app.api.api_v1.tasks.emails.decoratorEmail", args=[user.email, "".join([str(random.randint(1, 9)) for i in range(6)])]) print(task, "---------") return create_access_token(data={"username": user.username, "email": user.email})
def authentication_token_from_email(*, client: TestClient, email: str, db: Session) -> Dict[str, str]: """ Return a valid token for the user with given email. If the user doesn't exist it is created first. """ password = random_lower_string() password_hash = security.get_password_hash(password) user = db.query(User).where(User.email == email).first() if not user: # TODO(TOM): put Create op in some util function user = User(name=email.split("@")[0], email=email, password_hash=password_hash) else: user.password_hash = password_hash db.add(user) db.commit() db.refresh(user) return user_authentication_headers(client=client, email=email, password=password)
def update(*, db_obj: User, obj_in: Union[UserUpdate, Dict[str, Any]]) -> User: if isinstance(obj_in, dict): update_data = obj_in else: update_data = obj_in.dict(exclude_unset=True) if update_data["password"]: hashed_password = get_password_hash(update_data["password"]) del update_data["password"] update_data["hashed_password"] = hashed_password obj_data = jsonable_encoder(update_data) for field in obj_data: if field in update_data: setattr(db_obj, field, update_data[field]) query_str = {"email": f"{db_obj.email}"} newvalues = {"$set": obj_data} db = get_default_bucket() collection = db["users"] user_db = collection.find_one_and_update(query_str, newvalues) user = UserInDB(**user_db) return user
def create(self, db: Session, *, obj_in: UserCreate) -> User: db_obj = User( email=obj_in.email, hashed_password=get_password_hash(obj_in.password), full_name=obj_in.full_name, type=obj_in.type, is_admin=obj_in.is_admin or obj_in.type in ("admin", "superuser"), school_id=obj_in.school_id, ) db.add(db_obj) try: db.commit() except Exception as e: logging.error(f"{e.__class__} - {e.__str__}") db.rollback() db.refresh(db_obj) # Ensure user gets the appropriate permissions depending on type if obj_in.type == "superuser": admin.create(db, obj_in=AdminCreate(user_id=db_obj.id, permissions=-1)) elif obj_in.type == "admin" or obj_in.is_admin: admin.create(db, obj_in=AdminCreate(user_id=db_obj.id, permissions=0)) elif obj_in.type == "professor": professor.create(db, obj_in=ProfessorCreate(user_id=db_obj.id)) elif obj_in.type == "student": student.create(db, obj_in=StudentCreate(user_id=db_obj.id)) return db_obj
def update(self, db: Session, *, db_obj: User, obj_in: UserUpdate) -> User: update_data = obj_in.dict(exclude_unset=True) if update_data.get("password"): hashed_password = get_password_hash(update_data["password"]) del update_data["password"] update_data["hashed_password"] = hashed_password return super().update(db, db_obj=db_obj, obj_in=update_data)
def create(self, *, obj_in: UserCreate) -> User: db_obj = User( email=obj_in.email, hashed_password=get_password_hash(obj_in.password), is_superuser=obj_in.is_superuser, ).save() return db_obj
async def create(self, *, obj_in: [UserCreate, Dict[str, Any]]) -> User: if isinstance(obj_in, dict): obj_in_data = obj_in else: obj_in_data = obj_in.dict() obj_in_data["hashed_password"] = get_password_hash(obj_in.password) del obj_in_data["password"] return await super().create(obj_in=obj_in_data)
def create(db: Session, *, user_in: UserCreate) -> User: user = User(email=user_in.email, hashed_password=get_password_hash(user_in.password), full_name=user_in.full_name) db.add(user) db.commit() db.refresh(user) return user
def upsert_user_in_db(bucket: Bucket, user_in: UserInCreate): user_doc_id = get_user_doc_id(user_in.name) passwordhash = get_password_hash(user_in.password) user = UserStored(**user_in.json_dict(), hashed_password=passwordhash) doc_data = user.json_dict() bucket.upsert(user_doc_id, doc_data) return user
def update(self, db_session: Session, *, db_obj: User, obj_in: UserUpdate) -> User: if obj_in.password: update_data = obj_in.dict(exclude_unset=True) hashed_password = get_password_hash(obj_in.password) del update_data["password"] update_data["hashed_password"] = hashed_password use_obj_in = UserInDB.parse_obj(update_data) return super().update(db_session, db_obj=db_obj, obj_in=use_obj_in)
def create(self, db: Session, *, obj_in: UserCreate) -> User: db_obj = User(email=obj_in.email, hashed_password=get_password_hash(obj_in.password), username=obj_in.username) db.add(db_obj) db.commit() db.refresh(db_obj) return db_obj
def create_user(db_session: Session, *, user_in: UserCreate, otp: int) -> User: user = User(email=user_in.email, password_hash=get_password_hash(user_in.password), otp=otp) db_session.add(user) db_session.commit() db_session.refresh(user) return user
def create(self, db_session: Session, *, obj_in: UserCreate) -> User: db_obj = User(email=obj_in.email, hashed_password=get_password_hash(obj_in.password), name=obj_in.name, is_superuser=obj_in.is_superuser) db_session.add(db_obj) db_session.commit() db_session.refresh(db_obj) return db_obj
def update(user: User, data: UserUpdateRequest): user.full_name = user.full_name if data.full_name is None else data.full_name user.email = user.email if data.email is None else data.email user.hashed_password = user.hashed_password if data.password is None else get_password_hash( data.password) user.is_active = user.is_active if data.is_active is None else data.is_active user.role = user.role if data.role is None else data.role.value db.session.commit() return user
async def create_user(self, *, obj_in: AdminUserCreate) -> Any: db_obj = self.model(nickname=obj_in.nickname, email=obj_in.email, phone=obj_in.phone, hashed_password=get_password_hash(obj_in.password), role_id=obj_in.role_id, is_active=obj_in.is_active) await db_obj.create() return db_obj
async def create(db: AsyncIOMotorClient, *, broker_in: BrokerBase) -> BrokerInDB: print(broker_in) broker_in.password = get_password_hash(broker_in.password) now = datetime.utcnow() broker_in.created_at, broker_in.updated_at = now, now broker_json = broker_in.dict() await db['hack']['brokers'].insert_one(broker_json) broker_json['_id'] return broker_json
def user(data={}): """ Fake an user in db for testing :return: user model object """ user = User(full_name=data.get('name') or fake.name(), email=data.get('email') or fake.email(), hashed_password=get_password_hash(data.get('password')) or get_password_hash(fake.lexify(text='?????????')), is_active=data.get('is_active') if data.get('is_active') is not None else True, role=data.get('role') if data.get('role') is not None else UserRole.GUEST.value) with db(): db.session.add(user) db.session.commit() db.session.refresh(user) return user
def create_owner(db_session: Session, *, user_in: OwnerCreate, otp: int) -> Owner: owner = Owner(email=user_in.email, password_hash=get_password_hash(user_in.password), otp=otp) db_session.add(owner) db_session.commit() db_session.refresh(owner) return owner
def create(self, db: Session, *, obj_in: UserCreate) -> UserModel: db_user = UserModel( email=obj_in.email, hashed_password=get_password_hash(obj_in.password), ) db.add(db_user) db.commit() db.refresh(db_user) return db_user
def upsert_in_db(bucket: Bucket, *, user_in: UserCreate, persist_to=0): user_doc_id = get_doc_id(user_in.username) passwordhash = get_password_hash(user_in.password) user = UserInDB(**user_in.dict(), hashed_password=passwordhash) doc_data = jsonable_encoder(user) with bucket.durability(persist_to=persist_to, timeout=config.COUCHBASE_DURABILITY_TIMEOUT_SECS): bucket.upsert(user_doc_id, doc_data) return user
def mutate(self, info, id, **kwargs): user = default_model_resolver(self, info=info, id=id) pw = kwargs.get('password', None) if pw is not None: kwargs['password'] = get_password_hash(pw) user.update(**kwargs) user.save() return user
def add_user(self, user: UserCreate) -> Users: user_in = Users( username=user.username, name=user.name, email=user.email, hashed_password=get_password_hash(user.password), ) res = db.users.insert_one(user_in.dict(by_alias=True)) return res
async def update_me(self, db_obj: User, obj_in: UserUpdateMe) -> User: db_obj.name = obj_in.name db_obj.family_name = obj_in.family_name if obj_in.password: new_password = get_password_hash(obj_in.password) db_obj.password_hash = new_password await db_obj.save() await db_obj.refresh_from_db() return db_obj