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
