tanshu/barker
1
0
Fork 0
Code Issues 1 Pull Requests Releases 4 Activity

Allow editing of product version with the right permission.

Browse Source
This commit is contained in:
Amritanshu Agrawal
2021-09-04 12:52:05 +05:30
parent f929a731cb
commit 4a12ee0834
11 changed files with 370 additions and 196 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
barker/alembic/versions/c123dbf9c659_temporal_products_editing.py Normal file
View File

@ -0,0 +1,27 @@
"""temporal products editing
Revision ID: c123dbf9c659
Revises: e5e8acfc6495
Create Date: 2021-08-06 10:15:57.719313
"""
from alembic import op
# revision identifiers, used by Alembic.
from barker.models.permission import Permission
revision = "c123dbf9c659"
down_revision = "e5e8acfc6495"
branch_labels = None
depends_on = None
def upgrade():
op.execute(
Permission.__table__.insert().values(id="eb604d72-8cbc-4fcb-979c-4713eaf34e56", name="Temporal Products")
)
def downgrade():
pass

257
barker/barker/routers/product.py
View File

@ -6,7 +6,7 @@ from typing import List, Optional
import barker.schemas.product as schemas
from fastapi import APIRouter, Depends, HTTPException, Security, status
from sqlalchemy import and_, insert, or_, select, update
from sqlalchemy import and_, delete, insert, or_, select, update
from sqlalchemy.exc import SQLAlchemyError
from sqlalchemy.orm import Session, contains_eager, joinedload
from sqlalchemy.sql.functions import count
@ -71,7 +71,7 @@ def save(
data: schemas.ProductIn,
date_: date = Depends(effective_date),
user: UserToken = Security(get_user, scopes=["products"]),
):
) -> None:
try:
with SessionFuture() as db:
item = Product()
@ -93,7 +93,7 @@ def save(
db.add(product_version)
add_modifiers(item.id, product_version.menu_category_id, date_, db)
db.commit()
return product_info(product_version)
return
except SQLAlchemyError as e:
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
@ -143,16 +143,18 @@ def add_modifiers(product_id: uuid.UUID, menu_category_id: uuid.UUID, date_: dat
db.execute(insert(modifier_categories_products).values(product_id=product_id, modifier_category_id=mc))
@router.put("/{id_}", response_model=schemas.Product)
@router.put("/{version_id}", response_model=schemas.Product)
def update_route(
id_: uuid.UUID,
version_id: uuid.UUID,
data: schemas.ProductIn,
date_: date = Depends(effective_date),
user: UserToken = Security(get_user, scopes=["products"]),
) -> schemas.Product:
) -> None:
try:
with SessionFuture() as db:
item: ProductVersion = db.execute(
old: ProductVersion = db.execute(select(ProductVersion).where(ProductVersion.id == version_id)).scalar_one()
id_ = old.product_id
latest: ProductVersion = db.execute(
select(ProductVersion)
.join(ProductVersion.menu_category)
.where(
@ -169,42 +171,65 @@ def update_route(
)
)
).scalar_one()
if item.valid_till is not None:
if version_id != latest.id and "temporal-products" not in user.permissions:
# This should not happen as only someone with this permission should reach here
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail="Permission error, you cannot edit this product version.",
)
if version_id != latest.id:
# Update the old product update by temporal product editor
old.name = data.name
old.units = data.units
old.menu_category_id = data.menu_category.id_
old.sale_category_id = data.sale_category.id_
old.price = data.price
old.has_happy_hour = data.has_happy_hour
old.is_not_available = data.is_not_available
old.quantity = data.quantity
db.commit()
return
if latest.valid_till is not None:
# Allow adding a product here splitting the valid from and to, but not implemented right now
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail="Product has been invalidated",
)
if item.valid_from == date_: # Update the product as valid from the the same
item.name = data.name
item.units = data.units
item.menu_category_id = data.menu_category.id_
item.sale_category_id = data.sale_category.id_
item.price = data.price
item.has_happy_hour = data.has_happy_hour
item.is_not_available = data.is_not_available
item.quantity = data.quantity
if latest.valid_from == date_:
# Update the product as it is valid from the the same
latest.name = data.name
latest.units = data.units
latest.menu_category_id = data.menu_category.id_
latest.sale_category_id = data.sale_category.id_
latest.price = data.price
latest.has_happy_hour = data.has_happy_hour
latest.is_not_available = data.is_not_available
latest.quantity = data.quantity
db.commit()
return product_info(item)
else: # Create a new version of the product from the new details
item.valid_till = date_ - timedelta(days=1)
product_version = ProductVersion(
product_id=item.product_id,
name=data.name,
units=data.units,
menu_category_id=data.menu_category.id_,
sale_category_id=data.sale_category.id_,
price=data.price,
has_happy_hour=data.has_happy_hour,
is_not_available=data.is_not_available,
quantity=data.quantity,
valid_from=date_,
valid_till=None,
sort_order=item.sort_order,
)
db.add(product_version)
db.commit()
return product_info(product_version)
return
# Create a new product version
latest.valid_till = date_ - timedelta(days=1)
product_version = ProductVersion(
product_id=id_,
name=data.name,
units=data.units,
menu_category_id=data.menu_category.id_,
sale_category_id=data.sale_category.id_,
price=data.price,
has_happy_hour=data.has_happy_hour,
is_not_available=data.is_not_available,
quantity=data.quantity,
valid_from=date_,
valid_till=None,
sort_order=latest.sort_order,
)
db.add(product_version)
db.commit()
return
except SQLAlchemyError as e:
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
@ -212,15 +237,19 @@ def update_route(
)
@router.delete("/{id_}")
@router.delete("/{version_id}")
def delete_route(
id_: uuid.UUID,
version_id: uuid.UUID,
date_: date = Depends(effective_date),
user: UserToken = Security(get_user, scopes=["products"]),
):
) -> None:
with SessionFuture() as db:
item: ProductVersion = db.execute(
select(ProductVersion).where(
old: ProductVersion = db.execute(select(ProductVersion).where(ProductVersion.id == version_id)).scalar_one()
id_ = old.product_id
latest: ProductVersion = db.execute(
select(ProductVersion)
.join(ProductVersion.menu_category)
.where(
and_(
ProductVersion.product_id == id_,
or_(
@ -234,26 +263,82 @@ def delete_route(
)
)
).scalar_one()
if item.valid_from == date_:
db.delete(item)
if version_id != latest.id and "temporal-products" not in user.permissions:
# This should not happen as only someone with this permission should reach here
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail="Permission error, you cannot delete this product.",
)
if version_id != latest.id:
# Delete old product, but make sure that no gaps remain
if old.valid_from is not None:
# Set the previous version valid till to item's valid till
db.execute(
delete(ProductVersion)
.where(ProductVersion.id == version_id)
.execution_options(synchronize_session=False)
)
id_to_update = (
select(ProductVersion.id)
.where(
ProductVersion.product_id == id_,
ProductVersion.valid_till == old.valid_from - timedelta(days=1),
)
.scalar_subquery()
)
db.execute(
update(ProductVersion)
.where(ProductVersion.id == id_to_update)
.values(valid_till=old.valid_till)
.execution_options(synchronize_session=False)
)
else:
# Set the next version valid from to item's valid from which is None
db.execute(
delete(ProductVersion)
.where(ProductVersion.id == version_id)
.execution_options(synchronize_session=False)
)
id_to_update = (
select(ProductVersion.id)
.where(
ProductVersion.product_id == id_,
ProductVersion.valid_from == old.valid_till + timedelta(days=1),
)
.scalar_subquery()
)
db.execute(
update(ProductVersion)
.where(ProductVersion.id == id_to_update)
.values(valid_till=old.valid_from)
.execution_options(synchronize_session=False)
)
db.commit()
return
if latest.valid_from == date_:
db.delete(latest)
else:
item.valid_till = date_ - timedelta(days=1)
latest.valid_till = date_ - timedelta(days=1)
db.commit()
return
@router.get("", response_model=schemas.ProductBlank)
@router.get("", response_model=List[schemas.ProductBlank])
def show_blank(
user: UserToken = Security(get_user, scopes=["products"]),
) -> schemas.ProductBlank:
return schemas.ProductBlank(
name="",
units="",
price=0,
hasHappyHour=False,
isNotAvailable=False,
isActive=True,
sortOrder=0,
)
) -> List[schemas.ProductBlank]:
return [
schemas.ProductBlank(
name="",
units="",
price=0,
hasHappyHour=False,
isNotAvailable=False,
isActive=True,
sortOrder=0,
)
]
@router.get("/list", response_model=List[schemas.Product])
@ -401,39 +486,44 @@ def product_list_of_sale_category(date_: date, db: Session) -> List[schemas.Prod
]
@router.get("/{id_}", response_model=schemas.Product)
@router.get("/{id_}", response_model=List[schemas.Product])
def show_id(
id_: uuid.UUID,
date_: date = Depends(effective_date),
user: UserToken = Security(get_user, scopes=["products"]),
) -> schemas.Product:
) -> List[schemas.Product]:
query = (
select(ProductVersion)
.join(ProductVersion.sale_category)
.join(SaleCategory.tax)
.where(ProductVersion.product_id == id_)
)
if "temporal-products" not in user.permissions:
query = query.where(
or_(
ProductVersion.valid_from == None, # noqa: E711
ProductVersion.valid_from <= date_,
),
or_(
ProductVersion.valid_till == None, # noqa: E711
ProductVersion.valid_till >= date_,
),
)
with SessionFuture() as db:
item: ProductVersion = db.execute(
select(ProductVersion)
.join(ProductVersion.sale_category)
.join(SaleCategory.tax)
.where(
and_(
ProductVersion.product_id == id_,
or_(
ProductVersion.valid_from == None, # noqa: E711
ProductVersion.valid_from <= date_,
),
or_(
ProductVersion.valid_till == None, # noqa: E711
ProductVersion.valid_till >= date_,
),
items = [
product_info(item)
for item in db.execute(
query.order_by(ProductVersion.valid_till).options(
joinedload(ProductVersion.sale_category, innerjoin=True),
joinedload(ProductVersion.sale_category, SaleCategory.tax, innerjoin=True),
contains_eager(ProductVersion.sale_category),
contains_eager(ProductVersion.sale_category, SaleCategory.tax),
)
)
.order_by(ProductVersion.sort_order, ProductVersion.name)
.options(
joinedload(ProductVersion.sale_category, innerjoin=True),
joinedload(ProductVersion.sale_category, SaleCategory.tax, innerjoin=True),
contains_eager(ProductVersion.sale_category),
contains_eager(ProductVersion.sale_category, SaleCategory.tax),
)
).scalar_one()
return product_info(item)
.scalars()
.all()
]
return items
def query_product_info(item: ProductVersion, happy_hour: bool):
@ -459,6 +549,7 @@ def query_product_info(item: ProductVersion, happy_hour: bool):
def product_info(item: ProductVersion) -> schemas.Product:
return schemas.Product(
id=item.product_id,
versionId=item.id,
name=item.name,
units=item.units,
menuCategory=schemas.MenuCategoryLink(id=item.menu_category_id, name=item.menu_category.name, products=[]),
@ -472,4 +563,6 @@ def product_info(item: ProductVersion) -> schemas.Product:
quantity=item.quantity,
isActive=True,
sortOrder=item.sort_order,
validFrom=item.valid_from,
validTill=item.valid_till,
)

23
barker/barker/schemas/product.py
View File

@ -1,9 +1,10 @@
import uuid
from datetime import date, datetime
from decimal import Decimal
from typing import Optional
from pydantic import BaseModel, Field
from pydantic import BaseModel, Field, validator
from . import to_camel
from .menu_category import MenuCategoryLink
@ -29,10 +30,30 @@ class ProductIn(BaseModel):
class Product(ProductIn):
id_: uuid.UUID
version_id: uuid.UUID
valid_from: Optional[date]
valid_till: Optional[date]
class Config:
anystr_strip_whitespace = True
alias_generator = to_camel
json_encoders = {date: lambda v: v.strftime("%d-%b-%Y")}
@validator("valid_from", pre=True)
def parse_valid_from(cls, value):
if value is None:
return None
if isinstance(value, date):
return value
return datetime.strptime(value, "%d-%b-%Y").date()
@validator("valid_till", pre=True)
def parse_valid_till(cls, value):
if value is None:
return None
if isinstance(value, date):
return value
return datetime.strptime(value, "%d-%b-%Y").date()
class ProductBlank(ProductIn):