From 00e6aced53db00c3789c048672f98340609413cd Mon Sep 17 00:00:00 2001 From: Tiago vasconcelos Date: Tue, 12 Jul 2022 15:25:25 +0100 Subject: [PATCH] black'ed --- lnbits/extensions/diagonalley/__init__.py | 5 +- lnbits/extensions/diagonalley/crud.py | 25 ++-- lnbits/extensions/diagonalley/models.py | 6 + lnbits/extensions/diagonalley/views.py | 11 +- lnbits/extensions/diagonalley/views_api.py | 132 +++++++++++++-------- 5 files changed, 106 insertions(+), 73 deletions(-) diff --git a/lnbits/extensions/diagonalley/__init__.py b/lnbits/extensions/diagonalley/__init__.py index 6b082a5dc..db88bdbda 100644 --- a/lnbits/extensions/diagonalley/__init__.py +++ b/lnbits/extensions/diagonalley/__init__.py @@ -11,9 +11,7 @@ from lnbits.helpers import template_renderer from lnbits.settings import LNBITS_ADMIN_EXTENSIONS from lnbits.tasks import catch_everything_and_restart -diagonalley_ext: APIRouter = APIRouter( - prefix="/diagonalley", tags=["diagonalley"] -) +diagonalley_ext: APIRouter = APIRouter(prefix="/diagonalley", tags=["diagonalley"]) db = Database("ext_diagonalley") # if 'nostradmin' not in LNBITS_ADMIN_EXTENSIONS: # @diagonalley_ext.get("/", response_class=HTMLResponse) @@ -25,6 +23,7 @@ db = Database("ext_diagonalley") def diagonalley_renderer(): return template_renderer(["lnbits/extensions/diagonalley/templates"]) + from .tasks import wait_for_paid_invoices from .views import * # noqa from .views_api import * # noqa diff --git a/lnbits/extensions/diagonalley/crud.py b/lnbits/extensions/diagonalley/crud.py index 12cc611f9..fec2778cb 100644 --- a/lnbits/extensions/diagonalley/crud.py +++ b/lnbits/extensions/diagonalley/crud.py @@ -24,9 +24,8 @@ from .models import ( ###Products -async def create_diagonalley_product( - data: createProduct -) -> Products: + +async def create_diagonalley_product(data: createProduct) -> Products: product_id = urlsafe_short_hash() await db.execute( f""" @@ -93,10 +92,7 @@ async def delete_diagonalley_product(product_id: str) -> None: ###zones -async def create_diagonalley_zone( - user, - data: createZones -) -> Zones: +async def create_diagonalley_zone(user, data: createZones) -> Zones: zone_id = urlsafe_short_hash() await db.execute( f""" @@ -133,7 +129,9 @@ async def get_diagonalley_zone(zone_id: str) -> Optional[Zones]: async def get_diagonalley_zones(user: str) -> List[Zones]: - rows = await db.fetchall('SELECT * FROM diagonalley.zones WHERE "user" = ?', (user,)) + rows = await db.fetchall( + 'SELECT * FROM diagonalley.zones WHERE "user" = ?', (user,) + ) return [Zones(**row) for row in rows] @@ -144,9 +142,7 @@ async def delete_diagonalley_zone(zone_id: str) -> None: ###Stalls -async def create_diagonalley_stall( - data: createStalls -) -> Stalls: +async def create_diagonalley_stall(data: createStalls) -> Stalls: stall_id = urlsafe_short_hash() await db.execute( f""" @@ -168,7 +164,8 @@ async def create_diagonalley_stall( data.publickey, data.privatekey, data.relays, - data.shippingzones), + data.shippingzones, + ), ) stall = await get_diagonalley_stall(stall_id) @@ -210,9 +207,7 @@ async def delete_diagonalley_stall(stall_id: str) -> None: ###Orders -async def create_diagonalley_order( - data: createOrder -) -> Orders: +async def create_diagonalley_order(data: createOrder) -> Orders: order_id = urlsafe_short_hash() await db.execute( diff --git a/lnbits/extensions/diagonalley/models.py b/lnbits/extensions/diagonalley/models.py index 0d42c2794..5b0f3d5ca 100644 --- a/lnbits/extensions/diagonalley/models.py +++ b/lnbits/extensions/diagonalley/models.py @@ -13,6 +13,7 @@ class Stalls(BaseModel): relays: Optional[str] shippingzones: str + class createStalls(BaseModel): wallet: str = Query(...) name: str = Query(...) @@ -21,6 +22,7 @@ class createStalls(BaseModel): relays: str = Query(None) shippingzones: str = Query(...) + class createProduct(BaseModel): stall: str = Query(None) product: str = Query(None) @@ -30,6 +32,7 @@ class createProduct(BaseModel): price: int = Query(0, ge=0) quantity: int = Query(0, ge=0) + class Products(BaseModel): id: str stall: str @@ -40,10 +43,12 @@ class Products(BaseModel): price: int quantity: int + class createZones(BaseModel): cost: int = Query(0, ge=0) countries: str = Query(...) + class Zones(BaseModel): id: str user: str @@ -61,6 +66,7 @@ class createOrder(BaseModel): email: str = Query(...) invoiceid: str = Query(...) + class Orders(BaseModel): id: str productid: str diff --git a/lnbits/extensions/diagonalley/views.py b/lnbits/extensions/diagonalley/views.py index ae0899ca6..c38f8d51c 100644 --- a/lnbits/extensions/diagonalley/views.py +++ b/lnbits/extensions/diagonalley/views.py @@ -1,4 +1,3 @@ - from http import HTTPStatus from fastapi import Request @@ -15,21 +14,27 @@ from .crud import get_diagonalley_products templates = Jinja2Templates(directory="templates") + @diagonalley_ext.get("/", response_class=HTMLResponse) async def index(request: Request, user: User = Depends(check_user_exists)): return diagonalley_renderer().TemplateResponse( "diagonalley/index.html", {"request": request, "user": user.dict()} ) + @diagonalley_ext.get("/{stall_id}", response_class=HTMLResponse) async def display(request: Request, stall_id): product = await get_diagonalley_products(stall_id) - + if not product: raise HTTPException( status_code=HTTPStatus.NOT_FOUND, detail="Stall does not exist." ) return diagonalley_renderer().TemplateResponse( "diagonalley/stall.html", - {"stall": [product.dict() for product in await get_diagonalley_products(stall_id)]} + { + "stall": [ + product.dict() for product in await get_diagonalley_products(stall_id) + ] + }, ) diff --git a/lnbits/extensions/diagonalley/views_api.py b/lnbits/extensions/diagonalley/views_api.py index 6363dc97e..c91eecf54 100644 --- a/lnbits/extensions/diagonalley/views_api.py +++ b/lnbits/extensions/diagonalley/views_api.py @@ -65,36 +65,35 @@ async def api_copilot_retrieve( return {**copilot.dict(), **{"lnurl": copilot.lnurl(req)}} """ + @diagonalley_ext.get("/api/v1/products") async def api_diagonalley_products( req: Request, wallet: WalletTypeInfo = Depends(get_key_type), - all_stalls: bool = Query(False) + all_stalls: bool = Query(False), ): wallet_ids = [wallet.wallet.id] if all_stalls: wallet_ids = (await get_user(wallet.wallet.user)).wallet_ids - return ([product.dict() for product in await get_diagonalley_products(wallet_ids)]) + return [product.dict() for product in await get_diagonalley_products(wallet_ids)] @diagonalley_ext.post("/api/v1/products") @diagonalley_ext.put("/api/v1/products/{product_id}") async def api_diagonalley_product_create( - product_id, - data: createProduct, - wallet: WalletTypeInfo = Depends(get_key_type) - ): + product_id, data: createProduct, wallet: WalletTypeInfo = Depends(get_key_type) +): if product_id: product = await get_diagonalley_product(product_id) if not product: - return ({"message": "Withdraw product does not exist."}) + return {"message": "Withdraw product does not exist."} if product.wallet != wallet.wallet.id: - return ({"message": "Not your withdraw product."}) + return {"message": "Not your withdraw product."} product = await update_diagonalley_product(product_id, **data.dict()) else: @@ -104,14 +103,16 @@ async def api_diagonalley_product_create( @diagonalley_ext.delete("/api/v1/products/{product_id}") -async def api_diagonalley_products_delete(product_id, wallet: WalletTypeInfo = Depends(require_admin_key)): +async def api_diagonalley_products_delete( + product_id, wallet: WalletTypeInfo = Depends(require_admin_key) +): product = await get_diagonalley_product(product_id) if not product: - return ({"message": "Product does not exist."}) + return {"message": "Product does not exist."} if product.wallet != wallet.wallet.id: - return ({"message": "Not your Diagon Alley."}) + return {"message": "Not your Diagon Alley."} await delete_diagonalley_product(product_id) raise HTTPException(status_code=HTTPStatus.NO_CONTENT) @@ -125,38 +126,41 @@ async def api_diagonalley_zones(wallet: WalletTypeInfo = Depends(get_key_type)): return await get_diagonalley_zones(wallet.wallet.user) + @diagonalley_ext.post("/api/v1/zones") async def api_diagonalley_zone_create( - data: createZones, - wallet: WalletTypeInfo = Depends(get_key_type) - ): + data: createZones, wallet: WalletTypeInfo = Depends(get_key_type) +): zone = await create_diagonalley_zone(user=wallet.wallet.user, data=data) return zone.dict() + @diagonalley_ext.post("/api/v1/zones/{zone_id}") async def api_diagonalley_zone_update( - data: createZones, - zone_id: str = Query(None), - wallet: WalletTypeInfo = Depends(require_admin_key) - ): + data: createZones, + zone_id: str = Query(None), + wallet: WalletTypeInfo = Depends(require_admin_key), +): zone = await get_diagonalley_zone(zone_id) if not zone: - return ({"message": "Zone does not exist."}) + return {"message": "Zone does not exist."} if zone.user != wallet.wallet.user: - return ({"message": "Not your record."}) + return {"message": "Not your record."} zone = await update_diagonalley_zone(zone_id, **data.dict()) return zone @diagonalley_ext.delete("/api/v1/zones/{zone_id}") -async def api_diagonalley_zone_delete(zone_id, wallet: WalletTypeInfo = Depends(require_admin_key)): +async def api_diagonalley_zone_delete( + zone_id, wallet: WalletTypeInfo = Depends(require_admin_key) +): zone = await get_diagonalley_zone(zone_id) if not zone: - return ({"message": "zone does not exist."}) + return {"message": "zone does not exist."} if zone.user != wallet.wallet.user: - return ({"message": "Not your zone."}) + return {"message": "Not your zone."} await delete_diagonalley_zone(zone_id) raise HTTPException(status_code=HTTPStatus.NO_CONTENT) @@ -166,27 +170,33 @@ async def api_diagonalley_zone_delete(zone_id, wallet: WalletTypeInfo = Depends( @diagonalley_ext.get("/api/v1/stalls") -async def api_diagonalley_stalls(wallet: WalletTypeInfo = Depends(get_key_type), all_wallets: bool = Query(False)): +async def api_diagonalley_stalls( + wallet: WalletTypeInfo = Depends(get_key_type), all_wallets: bool = Query(False) +): wallet_ids = [wallet.wallet.id] if all_wallets: wallet_ids = (await get_user(wallet.wallet.user)).wallet_ids - return ([stall.dict() for stall in await get_diagonalley_stalls(wallet_ids)]) + return [stall.dict() for stall in await get_diagonalley_stalls(wallet_ids)] @diagonalley_ext.post("/api/v1/stalls") @diagonalley_ext.put("/api/v1/stalls/{stall_id}") -async def api_diagonalley_stall_create(data: createStalls, stall_id: str = Query(None), wallet: WalletTypeInfo = Depends(get_key_type)): +async def api_diagonalley_stall_create( + data: createStalls, + stall_id: str = Query(None), + wallet: WalletTypeInfo = Depends(get_key_type), +): if stall_id: stall = await get_diagonalley_stall(stall_id) if not stall: - return ({"message": "Withdraw stall does not exist."}) + return {"message": "Withdraw stall does not exist."} if stall.wallet != wallet.wallet.id: - return ({"message": "Not your withdraw stall."}) + return {"message": "Not your withdraw stall."} stall = await update_diagonalley_stall(stall_id, **data.dict()) else: @@ -196,14 +206,16 @@ async def api_diagonalley_stall_create(data: createStalls, stall_id: str = Query @diagonalley_ext.delete("/api/v1/stalls/{stall_id}") -async def api_diagonalley_stall_delete(stall_id: str = Query(None), wallet: WalletTypeInfo = Depends(require_admin_key)): +async def api_diagonalley_stall_delete( + stall_id: str = Query(None), wallet: WalletTypeInfo = Depends(require_admin_key) +): stall = await get_diagonalley_stall(stall_id) if not stall: - return ({"message": "Stall does not exist."}) + return {"message": "Stall does not exist."} if stall.wallet != wallet.wallet.id: - return ({"message": "Not your Stall."}) + return {"message": "Not your Stall."} await delete_diagonalley_stall(stall_id) raise HTTPException(status_code=HTTPStatus.NO_CONTENT) @@ -213,33 +225,39 @@ async def api_diagonalley_stall_delete(stall_id: str = Query(None), wallet: Wall @diagonalley_ext.get("/api/v1/orders") -async def api_diagonalley_orders(wallet: WalletTypeInfo = Depends(get_key_type), all_wallets: bool = Query(False)): +async def api_diagonalley_orders( + wallet: WalletTypeInfo = Depends(get_key_type), all_wallets: bool = Query(False) +): wallet_ids = [wallet.wallet.id] if all_wallets: wallet_ids = (await get_user(wallet.wallet.user)).wallet_ids try: - return ([order.dict() for order in await get_diagonalley_orders(wallet_ids)]) + return [order.dict() for order in await get_diagonalley_orders(wallet_ids)] except: - return ({"message": "We could not retrieve the orders."}) + return {"message": "We could not retrieve the orders."} @diagonalley_ext.post("/api/v1/orders") -async def api_diagonalley_order_create(data: createOrder, wallet: WalletTypeInfo = Depends(get_key_type)): +async def api_diagonalley_order_create( + data: createOrder, wallet: WalletTypeInfo = Depends(get_key_type) +): order = await create_diagonalley_order(wallet_id=wallet.wallet.id, data=data) return order.dict() @diagonalley_ext.delete("/api/v1/orders/{order_id}") -async def api_diagonalley_order_delete(order_id: str = Query(None), wallet: WalletTypeInfo = Depends(get_key_type)): +async def api_diagonalley_order_delete( + order_id: str = Query(None), wallet: WalletTypeInfo = Depends(get_key_type) +): order = await get_diagonalley_order(order_id) if not order: - return ({"message": "Order does not exist."}) + return {"message": "Order does not exist."} if order.wallet != wallet.wallet.id: - return ({"message": "Not your Order."}) + return {"message": "Not your Order."} await delete_diagonalley_order(order_id) @@ -247,7 +265,9 @@ async def api_diagonalley_order_delete(order_id: str = Query(None), wallet: Wall @diagonalley_ext.get("/api/v1/orders/paid/{order_id}") -async def api_diagonalley_order_paid(order_id: str = Query(None), wallet: WalletTypeInfo = Depends(require_admin_key)): +async def api_diagonalley_order_paid( + order_id: str = Query(None), wallet: WalletTypeInfo = Depends(require_admin_key) +): await db.execute( "UPDATE diagonalley.orders SET paid = ? WHERE id = ?", ( @@ -259,7 +279,9 @@ async def api_diagonalley_order_paid(order_id: str = Query(None), wallet: Wallet @diagonalley_ext.get("/api/v1/orders/shipped/{order_id}") -async def api_diagonalley_order_shipped(order_id: str = Query(None), wallet: WalletTypeInfo = Depends(get_key_type)): +async def api_diagonalley_order_shipped( + order_id: str = Query(None), wallet: WalletTypeInfo = Depends(get_key_type) +): await db.execute( "UPDATE diagonalley.orders SET shipped = ? WHERE id = ?", ( @@ -271,54 +293,60 @@ async def api_diagonalley_order_shipped(order_id: str = Query(None), wallet: Wal "SELECT * FROM diagonalley.orders WHERE id = ?", (order_id,) ) - return ([order.dict() for order in get_diagonalley_orders(order["wallet"])]) + return [order.dict() for order in get_diagonalley_orders(order["wallet"])] ###List products based on stall id @diagonalley_ext.get("/api/v1/stall/products/{stall_id}") -async def api_diagonalley_stall_products(stall_id: str = Query(None), wallet: WalletTypeInfo = Depends(get_key_type)): +async def api_diagonalley_stall_products( + stall_id: str = Query(None), wallet: WalletTypeInfo = Depends(get_key_type) +): rows = await db.fetchone( "SELECT * FROM diagonalley.stalls WHERE id = ?", (stall_id,) ) print(rows[1]) if not rows: - return ({"message": "Stall does not exist."}) + return {"message": "Stall does not exist."} products = db.fetchone( "SELECT * FROM diagonalley.products WHERE wallet = ?", (rows[1],) ) if not products: - return ({"message": "No products"}) + return {"message": "No products"} - return ([products.dict() for products in await get_diagonalley_products(rows[1])]) + return [products.dict() for products in await get_diagonalley_products(rows[1])] ###Check a product has been shipped @diagonalley_ext.get("/api/v1/stall/checkshipped/{checking_id}") -async def api_diagonalley_stall_checkshipped(checking_id, wallet: WalletTypeInfo = Depends(get_key_type)): +async def api_diagonalley_stall_checkshipped( + checking_id, wallet: WalletTypeInfo = Depends(get_key_type) +): rows = await db.fetchone( "SELECT * FROM diagonalley.orders WHERE invoiceid = ?", (checking_id,) ) - return ({"shipped": rows["shipped"]}) + return {"shipped": rows["shipped"]} ###Place order @diagonalley_ext.post("/api/v1/stall/order/{stall_id}") -async def api_diagonalley_stall_order(stall_id, data: createOrder, wallet: WalletTypeInfo = Depends(get_key_type)): +async def api_diagonalley_stall_order( + stall_id, data: createOrder, wallet: WalletTypeInfo = Depends(get_key_type) +): product = await get_diagonalley_product(data.productid) shipping = await get_diagonalley_stall(stall_id) if data.shippingzone == 1: - shippingcost = shipping.zone1cost #missing in model + shippingcost = shipping.zone1cost # missing in model else: - shippingcost = shipping.zone2cost #missing in model + shippingcost = shipping.zone2cost # missing in model checking_id, payment_request = await create_invoice( wallet_id=product.wallet, @@ -334,7 +362,7 @@ async def api_diagonalley_stall_order(stall_id, data: createOrder, wallet: Walle ( selling_id, data.productid, - product.wallet, #doesn't exist in model + product.wallet, # doesn't exist in model product.product, data.quantity, data.shippingzone, @@ -345,4 +373,4 @@ async def api_diagonalley_stall_order(stall_id, data: createOrder, wallet: Walle False, ), ) - return ({"checking_id": checking_id, "payment_request": payment_request}) + return {"checking_id": checking_id, "payment_request": payment_request}