def reset_password(
data: ResetPassword = Body(...),
db: Session = Depends(deps.get_db),
) -> Any:
"""
Reset password
"""
email = verify_password_reset_token(data.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=status.HTTP_404_NOT_FOUND,
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")
if data.new_password != data.repeat_password:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Password not matches.",
)
hashed_password = get_password_hash(data.new_password)
user.hashed_password = hashed_password
db.add(user)
db.commit()
return {"msg": "Password updated successfully"}
async def create_user(item: UserCreate):
hashed_password = get_password_hash(item.hashed_password)
item.hashed_password = hashed_password
user_create = item.dict()
user_pk = await database.execute(query=users.insert(), values=user_create)
return {**item.dict(), 'id': user_pk}
async def create(self, db: AsyncIOMotorClient, obj_in: UserCreate):
user_info = await db[self.mdb
][self.collection
].find_one({'username': obj_in.username})
if user_info:
return None
else:
set_params = {
'username':
obj_in.username,
'password':
get_password_hash(
DeAesCrypt(obj_in.password, obj_in.verify_key,
'pkcs7').decrypt_aes),
'full_name':
obj_in.full_name,
'create_time':
datetime.today(),
'update_time':
datetime.today(),
'roles': ['admin'],
'is_activate':
False,
'is_superuser':
False
}
insert_res = await db[self.mdb][self.collection
].insert_one(set_params)
return insert_res
def update(self, db_obj: User, obj_in: Dict[str, Any]) -> Dict[str, Any]:
if "password" in obj_in:
hashed_password = get_password_hash(obj_in["password"])
del obj_in["password"]
obj_in["hashed_password"] = hashed_password
return super().update(db_obj=db_obj, obj_in=obj_in)
def create(self, db: Session, *, obj_in: UserCreate) -> User:
obj_in_data = jsonable_encoder(obj_in)
obj_in_data['password'] = get_password_hash(obj_in_data['password'])
db_obj = self.model(**obj_in_data)
db.add(db_obj)
db.commit()
db.refresh(db_obj)
return db_obj
def add_new_user_to_db(values: dict):
values["id"] = str(values["id"])
values["password"] = get_password_hash(values["password"])
query = User.insert()
db.session.execute(query, values)
db.session.commit()
new_user = find_user_by_id(values["id"])
return new_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 create(self, obj_user: CreateUser) -> Optional[ResponseUser]:
db_user = User(username=obj_user.username,
password=get_password_hash(obj_user.plain_password))
query: Insert = self.table.insert()
try:
user_id = await db.execute(query, db_user.dict())
except UniqueViolationError:
return
return ResponseUser(id=user_id, username=db_user.username)
def create(self, db: Session, *, obj_in: UserCreate) -> User:
db_obj = User(
email=obj_in.email,
hashed_password=get_password_hash(obj_in.password),
)
db.add(db_obj)
db.commit()
db.refresh(db_obj)
return db_obj
def reset_password(*, user_id: int, password: str, db: Session):
try:
logger.info('reset password')
db.query(User).filter(User.id == user_id).update(
{User.password: get_password_hash(password)})
db.commit()
db.flush()
except Exception as e:
logger.error(f'error {e}')
async def create_new_user(obj_in) -> UUID:
hashed_pass = get_password_hash(obj_in["password"])
user_id = uuid4()
created_user_id = ps.create_user(
user_id=user_id,
user_name=obj_in["user_name"],
password=hashed_pass,
user_group=obj_in["group"]
)
return created_user_id
def create_user(db: Session, user: user_schema.UserCreate):
hashed_pass = get_password_hash(user.hashed_password)
db_user = user_model.User(email=user.email,
hashed_password=hashed_pass,
name=user.name,
lastname=user.lastname)
db.add(db_user)
db.commit()
db.refresh(db_user)
return db_user
async def init_db():
await Tortoise.init(db_url=settings.DB_URI, modules={'models': ['models']})
# Generate the schema
await Tortoise.generate_schemas()
sys_user = await SysUser.filter(username=settings.FIRST_SUPERUSER).first()
if not sys_user:
await SysUser.create(
username=settings.FIRST_SUPERUSER,
password=get_password_hash(settings.FIRST_SUPERUSER_PASSWORD),
)
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(db_session, *, user_in: UserInCreate) -> User:
user = User(
email=user_in.email,
hashed_password=get_password_hash(user_in.password),
full_name=user_in.full_name,
is_superuser=user_in.is_superuser,
)
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),
full_name=obj_in.full_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(self, db: Session, *, 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
return super().update(db, db_obj=db_obj, obj_in=update_data)
def create(session: Session, request: CreateUser) -> Optional[User]:
user = User(
name=request.name,
email=request.email,
hashed_password=get_password_hash(request.password),
is_active=True,
is_superuser=False
)
session.add(user)
session.commit()
return user
def create(self, db: Session, *, obj_in: UserCreate) -> AdminUser:
db_obj = AdminUser(nickname=obj_in.nickname,
email=obj_in.email,
hashed_password=get_password_hash(obj_in.password),
avatar=obj_in.avatar,
role_id=obj_in.role_id,
is_active=obj_in.is_active)
db.add(db_obj)
db.commit()
db.refresh(db_obj)
return db_obj
def retrieve_password_by_account(
self, db: Session, response: Response, *, account: str,
obj_in: schema_user.UserRetrievePasswordIn):
"""
通过账号(手机号/邮箱)找回密码
:param account: 手机号/邮箱
:param verify_code: 验证码
:param password: 密码
:return: 用户信息, 提示信息
"""
# ----------- 判断输入账号是 手机号/邮箱 ---------- #
if re.match(RE_PHONE, account): # 手机
db_user = crud_user.get_user_by_phone(db, phone=account)
elif re.match(RE_EMAIL, account): # 邮箱
db_user = crud_user.get_user_by_email(db, email=account)
else:
message = "账号输入有误"
response.status_code = status.HTTP_422_UNPROCESSABLE_ENTITY
return None, message
if not db_user:
message = f"账号 {account} 未注册"
response.status_code = status.HTTP_404_NOT_FOUND
logger.error(message)
return None, message
if db_user.status == 1:
message = f"账号 {account} 已被禁用"
response.status_code = status.HTTP_403_FORBIDDEN
else:
# ----------- 校验验证码 ---------- #
redis_verify_code = redis_client.get(account)
if obj_in.verify_code != redis_verify_code:
message = "验证码不正确或已过期"
response.status_code = status.HTTP_401_UNAUTHORIZED
return None, message
# ---------- 重新设置密码 ---------- #
hashed_new_password = security.get_password_hash(obj_in.password)
db_user_obj = crud_user.update_password_by_id(
db, id=db_user.id, hashed_password=hashed_new_password)
if not db_user_obj:
message = "找回密码失败"
response.status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
else:
redis_client.set(db_user.id, "", ex=1)
redis_client.set(account, "", ex=1)
message = "找回密码成功"
response.status_code = status.HTTP_200_OK
return db_user_obj, message
logger.error(message)
return None, message
def create(self, db: Session, *, obj_in: sys_user_schema.UserCreate) -> SysUser:
db_obj = SysUser(
nickname=obj_in.nickname,
email=obj_in.email,
hashed_password=get_password_hash(obj_in.password),
avatar=obj_in.avatar,
authority_id=obj_in.authority_id,
is_active=obj_in.is_active
)
db.add(db_obj)
db.commit()
db.refresh(db_obj)
return db_obj
def update(db_session: Session, *, user: Users, user_in: UserUpdate) -> Users:
user_data = jsonable_encoder(user)
update_data = user_in.dict(skip_defaults=True)
for field in user_data:
if field in update_data:
setattr(user, field, update_data[field])
if user_in.password:
passwordhash = get_password_hash(user_in.password)
user.hashed_password = passwordhash
db_session.add(user)
db_session.commit()
db_session.refresh(user)
return user
async def update_info(site: AdminUpdate, db: Session = Depends(deps.get_db)):
"""博客资料修改"""
site_obj = db.query(models.Admin).filter_by(id=1)
site_obj.update({
"about": site.about,
"blog_sub_title": site.blog_sub_title,
"password_hash": get_password_hash(site.password),
"username": site.username,
"name": site.name,
"blog_title": site.blog_title,
})
db.commit()
return Response200(data=site)
def update(db_session, *, user: User, user_in: UserInUpdate) -> User:
user_data = jsonable_encoder(user)
for field in user_data:
if field in user_in.fields:
value_in = getattr(user_in, field)
if value_in is not None:
setattr(user, field, value_in)
if user_in.password:
passwordhash = get_password_hash(user_in.password)
user.hashed_password = passwordhash
db_session.add(user)
db_session.commit()
db_session.refresh(user)
return user
def init_db(db_session: Session):
# Tables should be created with Alembic migrations
# But if you don't want to use migrations, create
# the tables un-commenting the next line
# Base.metadata.create_all(bind=engine)
# user
user = user_service.get_by_email(db_session, email='*****@*****.**')
if not user:
user = User(
email='*****@*****.**',
hashed_password=get_password_hash('admin'),
name='admin',
is_superuser=True,
)
db_session.add(user)
db_session.commit()
with open('data.csv') as csv_file:
csv_reader = csv.reader(csv_file, delimiter=',')
line = 0
for row in csv_reader:
print(f'--- {line} {row[0]} {row[1]} {row[5]} {row[6]}')
try:
product = Product()
product.upc = row[0]
product.name = row[1]
if row[5]:
category = db_session.query(Category).filter(Category.name == row[5]).first()
if not category:
category = Category(name=row[5])
db_session.add(category)
db_session.commit()
product.category_id = category.id
if row[6]:
department = db_session.query(Department).filter(Department.name == row[6]).first()
if not department:
department = Department(name=row[6])
db_session.add(department)
db_session.commit()
product.department_id = department.id
db_session.add(product)
db_session.commit()
except Exception as e:
print(e)
db_session.rollback()
line += 1
def create_user(db: Session, obj_in: UserCreate):
arsene = Response_SM(status=False, result='...')
try:
db_obj = User(email=obj_in.email,
name=obj_in.name,
password=get_password_hash(obj_in.password),
rol_id=obj_in.rol_id)
db.add(db_obj)
db.commit()
db.refresh(db_obj)
arsene.status = True if db_obj.id else False
arsene.result = 'success'
except Exception as e:
arsene.result = f'error {e}'
logger.error(f'error {e}')
return arsene
def fake_admin(self):
"""构造初始管理员数据"""
username = self.fake.user_name()
password = self.fake.password()
admin_obj = Admin(
username=username,
password_hash=get_password_hash(password),
blog_title=self.fake.pystr(max_chars=6),
blog_sub_title=self.fake.pystr(max_chars=30),
name=self.fake.name(),
about=self.fake.sentence()
)
session.add(admin_obj)
session.commit()
session.refresh(admin_obj)
print("管理员账号: " + username, "管理员密码: " + password)
async def o_insert(license: str, project: str, data: PersonaCreate):
hashed_password = get_password_hash(data.password)
model = PersonaInDB(**data.dict(),
license=license,
projectId=project,
hashed_password=hashed_password)
props = fields_in_create(model)
try:
collection = get_collection(DOCTYPE_PERSONA)
rs = await collection.insert_one(props)
if rs.inserted_id:
member = await collection.find_one({"_id": rs.inserted_id})
return member
except Exception as e:
logging.info(e)
raise_server_error(str(e))
async def insert(project: str, data: MemberCreate):
fpwd = create_fpwd(data.username)
hashed_password = get_password_hash(fpwd)
model = MemberInDB(**data.dict(),
projectId=project,
hashed_password=hashed_password)
props = fields_in_create(model)
props["xfpwd"] = fpwd[::-1]
try:
collection = get_collection(DOCTYPE_PROJECT_MEMBER)
rs = await collection.insert_one(props)
if rs.inserted_id:
member = await collection.find_one({"_id": rs.inserted_id})
return member
except Exception as e:
logging.info(e)
raise_server_error(str(e))
