def create_tokens(db: Session, user_id: int): # """パスワード認証を行い、トークンを生成""" # ペイロード作成 access_payload = { "token_type": "access_token", "exp": datetime.utcnow() + timedelta(minutes=60), "user_id": user_id, } refresh_payload = { "token_type": "refresh_token", "exp": datetime.utcnow() + timedelta(days=90), "user_id": user_id, } # トークン作成(本来は'SECRET_KEY123'はもっと複雑にする) access_token = jwt.encode(access_payload, "SECRET_KEY123", algorithm="HS256") refresh_token = jwt.encode(refresh_payload, "SECRET_KEY123", algorithm="HS256") # DBにリフレッシュトークンを保存 db_user = db.query(User).filter(User.id == int(user_id)).first() db_user.refresh_token = refresh_token db.commit() db.refresh(db_user) # User.update(refresh_token=refresh_token).where(User.id == user_id).execute() return { "access_token": access_token, "refresh_token": refresh_token, "token_type": "bearer", }
def insert_month(mon: BaseMonth, db: Session) -> BaseModelMonth: validation(mon=mon, db=db) month = Month(**mon.dict(by_alias=False)) db.add(month) db.commit() db.refresh(month) return month
def update_budget_by_id( budget_id: int, bud: BaseBudget, db: Session ) -> BaseModelBudgetEmployee: budget = select_budget_by_budget_id(budget_id=budget_id, db=db) if not budget: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="O orçamento informado não existe.", ) if budget.name == bud.name: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="O orçamento informado já existe. Não há nada a ser alterado.", ) if not select_employee_by_id(id=bud.fk_id_employees, db=db): raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="O funcionário informado não existe.", ) db.query(Budget).filter(Budget.id == budget_id).update( bud.dict(by_alias=False), synchronize_session=False ) db.commit() db.refresh(budget) return budget
def create_user(session: Session, username: str, password: str) -> User: hashed_password = pbkdf2_sha256.hash(password) db_user = User(username=username, password=hashed_password) session.add(db_user) session.commit() session.refresh(db_user) return db_user
async def create_user(user: UserRequest, db: Session = Depends(database.get_db_session), current_user: LoginSchema = Depends( oauth.get_current_user)): created = datetime(datetime.today().year, datetime.today().month, datetime.today().day) password = Hash.bcrypt(user.password) new_user = UserModel(username=user.username, password=password, name=user.name, lastname=user.lastname, email=user.email, enabled=user.enabled, created=created) db.add(new_user) db.commit() db.refresh(new_user) if not new_user: raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail='Error trying to create blog!') return new_user
def create_taste(db: Session, taste: TasteCreate): db_taste = models.Taste(**taste.dict()) db.add(db_taste) db.commit() db.refresh(db_taste) return db_taste
def create_project(request: schema.Project, db: Session = Depends(database.get_db), current_user: schema.User = Depends(get_current_user)): new_project = models.Project(title=request.title, due_date=request.due_date) db.add(new_project) db.commit() db.refresh(new_project) return request
def update(self, db: Session, values: Dict[str, Any]) -> None: shop: Shop = db.query(Shop).filter_by(id=self.id).first() for key in values: setattr(shop, key, values[key]) db.add(shop) db.commit() db.refresh(shop) for key in values: setattr(self, key, getattr(shop, key))
def create_user(request: schema.User, db: Session = Depends(database.get_db)): hashed_pass = hashing.get_password_hash(request.password) new_user = models.User(name=request.name, username=request.username, password=hashed_pass) db.add(new_user) db.commit() db.refresh(new_user) return request
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, is_superuser=obj_in.is_superuser) db.add(db_obj) db.commit() db.refresh(db_obj) return db_obj
def create_user(request: schemas.User, db: Session = Depends(get_db)): new_user = models.User(name=request.name, email=request.email, password=hashing.Hash.bcrypt(request.password)) db.add(new_user) db.commit() db.refresh(new_user) return new_user
async def create_todo(todo_data: schemas.TODOCreate, db: Session, current_user: models.User = Depends(get_current_user)): todo = models.TODO(text=todo_data.text, completed=todo_data.completed, priority=todo_data.priority) todo.owner = current_user db.add(todo) db.commit() db.refresh(todo) return todo
def create(self, db: Session, *, obj_in: CreateSchemaType) -> ModelType: obj_in_data = obj_in.dict() if "id" in obj_in_data and self.get(db, id=obj_in_data["id"]): detail = f"{self.model.__name__} with id={obj_in_data['id']} already exists" raise NotFoundError(detail) db_obj = self.model(**obj_in_data) db.add(db_obj) db.commit() db.refresh(db_obj) return db_obj
def update(db: Session, *, db_obj: ModelType, obj_in: UpdateSchemaType) -> ModelType: obj_data = obj_in.dict(exclude_unset=True) for field in obj_data: setattr(db_obj, field, obj_data[field]) db.add(db_obj) db.commit() db.refresh(db_obj) return db_obj
def create_client(db: Session, client_data: client_dtos.ClientCreate) -> client_dtos.ClientResponse: client = client_create_to_client(client_data) db.add(client) db.commit() db.refresh(client) response = client_to_client_response(client) return response
def create(self, db: Session) -> None: shop = Shop( name=self.name, address=self.address, owner_id=self.owner_id, radius_metres=self.radius_metres, location=f'POINT({self.longitude} {self.latitude})', ) db.add(shop) db.commit() db.refresh(shop) self.id = shop.id
def create_user(db: Session, user: UserCreate): hashed_pass = pwd_context.hash(user.password) db_user = orm_user.User( email=user.email, user_name=user.user_name, first_name=user.first_name, last_name=user.last_name, password=hashed_pass, ) db.add(db_user) db.commit() db.refresh(db_user) return db_user
def insert_approver(appro: BaseApprover, db: Session) -> BaseModelApprover: validade_approver(appro=appro, db=db) if select_check_exists( approver_id=appro.fk_id_approver, budget_id=appro.fk_id_budget, db=db ): raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="O aprovador já existe" ) approver = Approver(**appro.dict(by_alias=False)) db.add(approver) db.commit() db.refresh(approver) return approver
def update_approver(id: int, appro: BaseApprover, db: Session) -> BaseModelApprover: validade_approver(appro=appro, db=db) approver = db.query(Approver).filter(Approver.id == id).first() if not approver: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="O aprovador não existe.", ) db.query(Approver).filter(Approver.id == id).update( appro.dict(by_alias=False), synchronize_session=False ) db.commit() db.refresh(approver) return approver
def insert_status_budget(status_bud: BaseStatusBudget, db: Session) -> BaseModelStatusBudget: if not select_budget_by_budget_id(budget_id=status_bud.fk_id_budget, db=db): raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="O orçamento informado não existe.", ) if status_bud.current: change_status_to_disable(budget_id=status_bud.fk_id_budget, db=db) status_budget = StatusBudget(**status_bud.dict(by_alias=False)) db.add(status_budget) db.commit() db.refresh(status_budget) return status_budget
def insert_budget(bud: BaseBudget, db: Session): if select_budget_by_name(budget_name=bud.name, db=db): raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="Já existe um orçamento com este nome.", ) if not select_employee_by_id(id=bud.fk_id_employees, db=db): raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="O funcionário informado não existe.", ) budget = Budget(**bud.dict(by_alias=False)) db.add(budget) db.commit() db.refresh(budget) return budget
def update_status_budget(id: int, status_bud: BasestatusBudgetToUpdate, db: Session) -> BaseModelStatusBudget: status = select_status_budget_by_id(id=id, db=db) if not status: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="O status do orçamento não existe.", ) row = status_bud.dict(exclude_none=True) if not row: raise HTTPException( status_code=status.HTTP_206_PARTIAL_CONTENT, detail="Não há dados para serem alterados.", ) db.query(StatusBudget).filter(StatusBudget.id == id).update( row, synchronize_session=False) db.commit() db.refresh(status) return status
def update_client(db: Session, id: int, request: Request, client_data: client_dtos.ClientUpdate) -> client_dtos.ClientResponse: token = request.headers.get("Authorization").split(" ")[1] username = b64decode(token).decode().split(":")[0] password_hash, password_salt = utils.generate_hash_and_salt(client_data.password) client = db.query(models.Client).filter(models.Client.id == id).first() if client.username != username: raise ForbiddenException(username) client.username = client_data.username client.password_hash = password_hash client.password_salt = password_salt db.commit() db.refresh(client) response = client_to_client_response(client) return response
def create( cls, session: Session, params: typing.Dict[str, typing.Any], commit: bool = True, autoflush: bool = False, ) -> DeclarativeMeta: obj = cls.model(**params) session.add(obj) if commit: session.commit() session.refresh(obj) if autoflush: session.flush() return obj
async def create_blog(request: Blog, db: Session = Depends(database.get_db_session), current_user: LoginSchema = Depends( oauth.get_current_user)): created = datetime(datetime.today().year, datetime.today().month, datetime.today().day) new_blog = BlogModel(title=request.title, body=request.body, created=created) db.add(new_blog) db.commit() db.refresh(new_blog) if not new_blog: raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail='Error trying to create blog!') return new_blog
async def add_addresses_to_business(db: Session = Depends(get_db), *, business_id: int, addresses: BusinessAddAddresses) -> Any: """ Add addresses to Business """ business_db = await crud.business.get(db, id=business_id) if not business_db: raise HTTPException(status_code=404, detail="Business not Found") if addresses.shipping_address_id: shipping_address = await crud.address.get( db, id=addresses.shipping_address_id) if not shipping_address: raise HTTPException(status_code=404, detail="Shipping address not Found") business_db.shipping_address_id = shipping_address.id print(business_db.__dict__) if addresses.billing_address_id: billing_address = await crud.address.get( db, id=addresses.billing_address_id) if not billing_address: raise HTTPException(status_code=404, detail="Billing address not Found") business_db.billing_address_id = billing_address.id db.add(business_db) db.commit() db.refresh(business_db) return business_db
async def create(self, db: Session, user_in: SignupUser) -> CreatedUser: user_by_username = await crud.user.get_by_username( db, username=user_in.username ) if user_by_username: raise HTTPException( status_code=400, detail="Email or Username already in use" ) user_by_email = await crud.user.get_by_email(db, email=user_in.email) if user_by_email: raise HTTPException( status_code=400, detail="Email or Username already in use" ) hashed_password = bcrypt.hashpw( user_in.password.encode("UTF-8"), bcrypt.gensalt() ) user_db = User( email=user_in.email, username=user_in.username, hashed_password=hashed_password.decode("UTF-8"), ) db.add(user_db) db.commit() db.refresh(user_db) created_user = CreatedUser( id=user_db.id, username=user_db.username, email=user_db.email, password=user_in.password, created_at=user_db.created_at, ) return created_user
async def envia_email_senha( background_tasks: BackgroundTasks, db: Session, email_para: str, ): filtro = db.query(models.Pessoa).filter(models.Pessoa.email == email_para) if not filtro: raise HTTPException(status.HTTP_404_NOT_FOUND, detail="Email Não Cadastrado!") pessoa = get_pessoa_by_email(db, email_para) if not pessoa.token_senha or datetime.date.today( ) > pessoa.expiracao_token + datetime.timedelta(days=1): pessoa.token_senha = str(uuid.uuid4().hex) pessoa.expiracao_token = datetime.date.today() + datetime.timedelta( days=1) db.add(pessoa) db.commit() db.refresh(pessoa) url = 'http://boraconectar.com/esqueci-senha/' + pessoa.token_senha message = MessageSchema( subject='Esqueci a senha', recipients=[email_para], template_body={ 'name': pessoa.nome, 'token': pessoa.token_senha, 'UrlToken': url }, ) fm = FastMail(conf) background_tasks.add_task(fm.send_message, message, template_name='email.html')
def add_track(session: Session, track_schema: schemas.TrackSchema): image_files = [] if track_schema.image_files: image_files = [image_file for image_file in track_schema.image_files] db_track = TrackModel( bitrate=track_schema.bitrate, bpm=track_schema.bpm, album=track_schema.album, artist=track_schema.artist, comment=track_schema.comment, duration=track_schema.duration, key=track_schema.key, file=str(track_schema.file), title=track_schema.title, import_error=track_schema.import_error, image_files=image_files, file_mtime=track_schema.file_mtime, ) session.add(db_track) session.commit() session.refresh(db_track) return db_track
def create( self, db: Session, schema: schema.UserCreate, ) -> Optional[model.User]: """ Persist a new user. Args: db: the database session. schema: the schema for create the new user. Returns: The created user. """ user = model.User(**schema.dict()) user.password = security.password.hash_password( user.password.get_secret_value()) db.add(user) db.commit() db.refresh(user) return user