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
