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))