aiolabs/lnbits
1
0
Fork 0
Code Issues 1 Pull requests Projects Releases Packages Wiki Activity Actions 1

Merge pull request #501 from talvasconcelos/diagon-alley

Browse source 
UI is working
This commit is contained in:
Arc 2022-02-03 13:55:46 +00:00 • committed by GitHub
commit e26e342dd7
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
6 changed files with 261 additions and 242 deletions
Download patch file Download diff file Expand all files Collapse all files

35
lnbits/extensions/diagonalley/__init__.py
View file

@ -1,16 +1,37 @@
from quart import Blueprint import asyncio
from fastapi import APIRouter
from fastapi.staticfiles import StaticFiles
from lnbits.db import Database from lnbits.db import Database
from lnbits.helpers import template_renderer
from lnbits.tasks import catch_everything_and_restart
db = Database("ext_diagonalley") db = Database("ext_diagonalley")
diagonalley_ext: Blueprint = Blueprint( diagonalley_static_files = [
"diagonalley", __name__, static_folder="static", template_folder="templates" {
"path": "/diagonalley/static",
"app": StaticFiles(directory="lnbits/extensions/diagonalley/static"),
"name": "diagonalley_static",
}
]
diagonalley_ext: APIRouter = APIRouter(
prefix="/diagonalley", tags=["diagonalley"]
# "diagonalley", __name__, static_folder="static", template_folder="templates"
) )
from .views_api import * # noqa def diagonalley_renderer():
return template_renderer(["lnbits/extensions/diagonalley/templates"])
from .tasks import wait_for_paid_invoices
from .views import * # noqa from .views import * # noqa
from .views_api import * # noqa
from .tasks import register_listeners
from lnbits.tasks import record_async
diagonalley_ext.record(record_async(register_listeners)) def diagonalley_start():
loop = asyncio.get_event_loop()
loop.create_task(catch_everything_and_restart(wait_for_paid_invoices))

157
lnbits/extensions/diagonalley/crud.py
View file

@ -1,17 +1,26 @@
import re
from base64 import urlsafe_b64encode from base64 import urlsafe_b64encode
from uuid import uuid4
from typing import List, Optional, Union from typing import List, Optional, Union
from uuid import uuid4
from lnbits.settings import WALLET import httpx
# from lnbits.db import open_ext_db # from lnbits.db import open_ext_db
from lnbits.db import SQLITE from lnbits.db import SQLITE
from . import db
from .models import Products, Orders, Stalls, Zones
import httpx
from lnbits.helpers import urlsafe_short_hash from lnbits.helpers import urlsafe_short_hash
import re from lnbits.settings import WALLET
from . import db
from .models import (
Orders,
Products,
Stalls,
Zones,
createOrder,
createProduct,
createStalls,
createZones,
)
regex = re.compile( regex = re.compile(
r"^(?:http|ftp)s?://" # http:// or https:// r"^(?:http|ftp)s?://" # http:// or https://
@ -28,35 +37,27 @@ regex = re.compile(
async def create_diagonalley_product( async def create_diagonalley_product(
*, data: createProduct
stall_id: str,
product: str,
categories: str,
description: str,
image: Optional[str] = None,
price: int,
quantity: int,
shippingzones: str,
) -> Products: ) -> Products:
returning = "" if db.type == SQLITE else "RETURNING ID" # returning = "" if db.type == SQLITE else "RETURNING ID"
method = db.execute if db.type == SQLITE else db.fetchone # method = db.execute if db.type == SQLITE else db.fetchone
product_id = urlsafe_short_hash() product_id = urlsafe_short_hash()
# with open_ext_db("diagonalley") as db: # with open_ext_db("diagonalley") as db:
result = await (method)( # result = await (method)(
await db.execute(
f""" f"""
INSERT INTO diagonalley.products (id, stall, product, categories, description, image, price, quantity, shippingzones) INSERT INTO diagonalley.products (id, stall, product, categories, description, image, price, quantity)
VALUES (?, ?, ?, ?, ?, ?, ?, ?) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
{returning}
""", """,
( (
product_id, product_id,
stall_id, data.stall,
product, data.product,
categories, data.categories,
description, data.description,
image, data.image,
price, data.price,
quantity, data.quantity,
), ),
) )
product = await get_diagonalley_product(product_id) product = await get_diagonalley_product(product_id)
@ -83,7 +84,7 @@ async def get_diagonalley_product(product_id: str) -> Optional[Products]:
row = await db.fetchone( row = await db.fetchone(
"SELECT * FROM diagonalley.products WHERE id = ?", (product_id,) "SELECT * FROM diagonalley.products WHERE id = ?", (product_id,)
) )
return Products.from_row(row) if row else None return Products(**row) if row else None
async def get_diagonalley_products(wallet_ids: Union[str, List[str]]) -> List[Products]: async def get_diagonalley_products(wallet_ids: Union[str, List[str]]) -> List[Products]:
@ -98,7 +99,7 @@ async def get_diagonalley_products(wallet_ids: Union[str, List[str]]) -> List[Pr
""", """,
(*wallet_ids,), (*wallet_ids,),
) )
return [Products.from_row(row) for row in rows] return [Products(**row) for row in rows]
async def delete_diagonalley_product(product_id: str) -> None: async def delete_diagonalley_product(product_id: str) -> None:
@ -109,17 +110,11 @@ async def delete_diagonalley_product(product_id: str) -> None:
async def create_diagonalley_zone( async def create_diagonalley_zone(
*, wallet,
wallet: Optional[str] = None, data: createZones
cost: Optional[int] = 0,
countries: Optional[str] = None,
) -> Zones: ) -> Zones:
returning = "" if db.type == SQLITE else "RETURNING ID"
method = db.execute if db.type == SQLITE else db.fetchone
zone_id = urlsafe_short_hash() zone_id = urlsafe_short_hash()
result = await (method)( await db.execute(
f""" f"""
INSERT INTO diagonalley.zones ( INSERT INTO diagonalley.zones (
id, id,
@ -129,9 +124,8 @@ async def create_diagonalley_zone(
) )
VALUES (?, ?, ?, ?) VALUES (?, ?, ?, ?)
{returning}
""", """,
(zone_id, wallet, cost, countries), (zone_id, wallet, data.cost, data.countries),
) )
zone = await get_diagonalley_zone(zone_id) zone = await get_diagonalley_zone(zone_id)
@ -146,12 +140,12 @@ async def update_diagonalley_zone(zone_id: str, **kwargs) -> Optional[Zones]:
(*kwargs.values(), zone_id), (*kwargs.values(), zone_id),
) )
row = await db.fetchone("SELECT * FROM diagonalley.zones WHERE id = ?", (zone_id,)) row = await db.fetchone("SELECT * FROM diagonalley.zones WHERE id = ?", (zone_id,))
return Zones.from_row(row) if row else None return Zones(**row) if row else None
async def get_diagonalley_zone(zone_id: str) -> Optional[Zones]: async def get_diagonalley_zone(zone_id: str) -> Optional[Zones]:
row = await db.fetchone("SELECT * FROM diagonalley.zones WHERE id = ?", (zone_id,)) row = await db.fetchone("SELECT * FROM diagonalley.zones WHERE id = ?", (zone_id,))
return Zones.from_row(row) if row else None return Zones(**row) if row else None
async def get_diagonalley_zones(wallet_ids: Union[str, List[str]]) -> List[Zones]: async def get_diagonalley_zones(wallet_ids: Union[str, List[str]]) -> List[Zones]:
@ -189,7 +183,7 @@ async def get_diagonalley_zones(wallet_ids: Union[str, List[str]]) -> List[Zones
rows = await db.fetchall( rows = await db.fetchall(
f"SELECT * FROM diagonalley.zones WHERE wallet IN ({q})", (*wallet_ids,) f"SELECT * FROM diagonalley.zones WHERE wallet IN ({q})", (*wallet_ids,)
) )
return [Zones.from_row(row) for row in rows] return [Zones(**row) for row in rows]
async def delete_diagonalley_zone(zone_id: str) -> None: async def delete_diagonalley_zone(zone_id: str) -> None:
@ -200,20 +194,10 @@ async def delete_diagonalley_zone(zone_id: str) -> None:
async def create_diagonalley_stall( async def create_diagonalley_stall(
*, data: createStalls
wallet: str,
name: str,
publickey: str,
privatekey: str,
relays: str,
shippingzones: str,
) -> Stalls: ) -> Stalls:
returning = "" if db.type == SQLITE else "RETURNING ID"
method = db.execute if db.type == SQLITE else db.fetchone
stall_id = urlsafe_short_hash() stall_id = urlsafe_short_hash()
result = await (method)( await db.execute(
f""" f"""
INSERT INTO diagonalley.stalls ( INSERT INTO diagonalley.stalls (
id, id,
@ -225,9 +209,15 @@ async def create_diagonalley_stall(
shippingzones shippingzones
) )
VALUES (?, ?, ?, ?, ?, ?, ?) VALUES (?, ?, ?, ?, ?, ?, ?)
{returning}
""", """,
(stall_id, wallet, name, publickey, privatekey, relays, shippingzones), (
stall_id,
data.wallet,
data.name,
data.publickey,
data.privatekey,
data.relays,
data.shippingzones),
) )
stall = await get_diagonalley_stall(stall_id) stall = await get_diagonalley_stall(stall_id)
@ -244,7 +234,7 @@ async def update_diagonalley_stall(stall_id: str, **kwargs) -> Optional[Stalls]:
row = await db.fetchone( row = await db.fetchone(
"SELECT * FROM diagonalley.stalls WHERE id = ?", (stall_id,) "SELECT * FROM diagonalley.stalls WHERE id = ?", (stall_id,)
) )
return Stalls.from_row(row) if row else None return Stalls(**row) if row else None
async def get_diagonalley_stall(stall_id: str) -> Optional[Stalls]: async def get_diagonalley_stall(stall_id: str) -> Optional[Stalls]:
@ -277,7 +267,7 @@ async def get_diagonalley_stall(stall_id: str) -> Optional[Stalls]:
row = await db.fetchone( row = await db.fetchone(
"SELECT * FROM diagonalley.stalls WHERE id = ?", (stall_id,) "SELECT * FROM diagonalley.stalls WHERE id = ?", (stall_id,)
) )
return Stalls.from_row(row) if row else None return Stalls(**row) if row else None
async def get_diagonalley_stalls(wallet_ids: Union[str, List[str]]) -> List[Stalls]: async def get_diagonalley_stalls(wallet_ids: Union[str, List[str]]) -> List[Stalls]:
@ -314,7 +304,7 @@ async def get_diagonalley_stalls(wallet_ids: Union[str, List[str]]) -> List[Stal
rows = await db.fetchall( rows = await db.fetchall(
f"SELECT * FROM diagonalley.stalls WHERE wallet IN ({q})", (*wallet_ids,) f"SELECT * FROM diagonalley.stalls WHERE wallet IN ({q})", (*wallet_ids,)
) )
return [Stalls.from_row(row) for row in rows] return [Stalls(**row) for row in rows]
async def delete_diagonalley_stall(stall_id: str) -> None: async def delete_diagonalley_stall(stall_id: str) -> None:
@ -325,47 +315,34 @@ async def delete_diagonalley_stall(stall_id: str) -> None:
async def create_diagonalley_order( async def create_diagonalley_order(
*, data: createOrder
productid: str,
wallet: str,
product: str,
quantity: int,
shippingzone: str,
address: str,
email: str,
invoiceid: str,
paid: bool,
shipped: bool,
) -> Orders: ) -> Orders:
returning = "" if db.type == SQLITE else "RETURNING ID"
method = db.execute if db.type == SQLITE else db.fetchone
order_id = urlsafe_short_hash() order_id = urlsafe_short_hash()
result = await (method)( await db.execute(
f""" f"""
INSERT INTO diagonalley.orders (id, productid, wallet, product, INSERT INTO diagonalley.orders (id, productid, wallet, product,
quantity, shippingzone, address, email, invoiceid, paid, shipped) quantity, shippingzone, address, email, invoiceid, paid, shipped)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
{returning}
""", """,
( (
order_id, order_id,
productid, data.productid,
wallet, data.wallet,
product, data.product,
quantity, data.quantity,
shippingzone, data.shippingzone,
address, data.address,
email, data.email,
invoiceid, data.invoiceid,
False, False,
False, False,
), ),
) )
if db.type == SQLITE: # if db.type == SQLITE:
order_id = result._result_proxy.lastrowid # order_id = result._result_proxy.lastrowid
else: # else:
order_id = result[0] # order_id = result[0]
link = await get_diagonalley_order(order_id) link = await get_diagonalley_order(order_id)
assert link, "Newly created link couldn't be retrieved" assert link, "Newly created link couldn't be retrieved"
@ -376,7 +353,7 @@ async def get_diagonalley_order(order_id: str) -> Optional[Orders]:
row = await db.fetchone( row = await db.fetchone(
"SELECT * FROM diagonalley.orders WHERE id = ?", (order_id,) "SELECT * FROM diagonalley.orders WHERE id = ?", (order_id,)
) )
return Orders.from_row(row) if row else None return Orders(**row) if row else None
async def get_diagonalley_orders(wallet_ids: Union[str, List[str]]) -> List[Orders]: async def get_diagonalley_orders(wallet_ids: Union[str, List[str]]) -> List[Orders]:
@ -388,7 +365,7 @@ async def get_diagonalley_orders(wallet_ids: Union[str, List[str]]) -> List[Orde
f"SELECT * FROM diagonalley.orders WHERE wallet IN ({q})", (*wallet_ids,) f"SELECT * FROM diagonalley.orders WHERE wallet IN ({q})", (*wallet_ids,)
) )
# #
return [Orders.from_row(row) for row in rows] return [Orders(**row) for row in rows]
async def delete_diagonalley_order(order_id: str) -> None: async def delete_diagonalley_order(order_id: str) -> None:

94
lnbits/extensions/diagonalley/models.py
View file

@ -1,57 +1,83 @@
from urllib.parse import urlparse, urlunparse, parse_qs, urlencode, ParseResult import json
from starlette.requests import Request from lib2to3.pytree import Base
from sqlite3 import Row
from typing import Dict, Optional
from urllib.parse import ParseResult, parse_qs, urlencode, urlparse, urlunparse
from fastapi.param_functions import Query from fastapi.param_functions import Query
from typing import Optional, Dict
from lnbits.lnurl import encode as lnurl_encode # type: ignore
from lnurl.types import LnurlPayMetadata # type: ignore from lnurl.types import LnurlPayMetadata # type: ignore
from pydantic import BaseModel from pydantic import BaseModel
import json from starlette.requests import Request
from sqlite3 import Row
from lnbits.lnurl import encode as lnurl_encode # type: ignore
class Stalls(BaseModel): class Stalls(BaseModel):
id: str = Query(None) id: str
wallet: str = Query(None) wallet: str
name: str = Query(None) name: str
publickey: str = Query(None) publickey: str
privatekey: str = Query(None) privatekey: str
relays: str = Query(None) relays: str
shippingzones: str
class createStalls(BaseModel): class createStalls(BaseModel):
wallet: str = Query(None) wallet: str = Query(...)
name: str = Query(None) name: str = Query(...)
publickey: str = Query(None) publickey: str = Query(...)
privatekey: str = Query(None) privatekey: str = Query(...)
relays: str = Query(None) relays: str = Query(...)
shippingzones: str = Query(None) shippingzones: str = Query(...)
class Products(BaseModel): class createProduct(BaseModel):
id: str = Query(None)
stall: str = Query(None) stall: str = Query(None)
product: str = Query(None) product: str = Query(None)
categories: str = Query(None) categories: str = Query(None)
description: str = Query(None) description: str = Query(None)
image: str = Query(None) image: str = Query(None)
price: int = Query(0) price: int = Query(0, ge=0)
quantity: int = Query(0) quantity: int = Query(0, ge=0)
class Products(BaseModel):
id: str
stall: str
product: str
categories: str
description: str
image: str
price: int
quantity: int
class Zones(BaseModel): class createZones(BaseModel):
id: str = Query(None)
wallet: str = Query(None)
cost: str = Query(None) cost: str = Query(None)
countries: str = Query(None) countries: str = Query(None)
class Zones(BaseModel):
id: str
wallet: str
cost: str
countries: str
class createOrder(BaseModel):
productid: str = Query(...)
stall: str = Query(...)
product: str = Query(...)
quantity: int = Query(..., ge=1)
shippingzone: int = Query(...)
address: str = Query(...)
email: str = Query(...)
invoiceid: str = Query(...)
class Orders(BaseModel): class Orders(BaseModel):
id: str = Query(None) id: str
productid: str = Query(None) productid: str
stall: str = Query(None) stall: str
product: str = Query(None) product: str
quantity: int = Query(0) quantity: int
shippingzone: int = Query(0) shippingzone: int
address: str = Query(None) address: str
email: str = Query(None) email: str
invoiceid: str = Query(None) invoiceid: str
paid: bool paid: bool
shipped: bool shipped: bool

4
lnbits/extensions/diagonalley/tasks.py
View file

@ -3,8 +3,6 @@ import asyncio
from lnbits.core.models import Payment from lnbits.core.models import Payment
from lnbits.tasks import register_invoice_listener from lnbits.tasks import register_invoice_listener
from .crud import get_ticket, set_ticket_paid
async def wait_for_paid_invoices(): async def wait_for_paid_invoices():
invoice_queue = asyncio.Queue() invoice_queue = asyncio.Queue()
@ -16,6 +14,7 @@ async def wait_for_paid_invoices():
async def on_invoice_paid(payment: Payment) -> None: async def on_invoice_paid(payment: Payment) -> None:
"""
if "lnticket" != payment.extra.get("tag"): if "lnticket" != payment.extra.get("tag"):
# not a lnticket invoice # not a lnticket invoice
return return
@ -27,3 +26,4 @@ async def on_invoice_paid(payment: Payment) -> None:
await payment.set_pending(False) await payment.set_pending(False)
await set_ticket_paid(payment.payment_hash) await set_ticket_paid(payment.payment_hash)
"""

57
lnbits/extensions/diagonalley/views.py
View file

@ -1,44 +1,35 @@
from typing import List
from fastapi import Request, WebSocket, WebSocketDisconnect
from fastapi.params import Depends
from fastapi.templating import Jinja2Templates
from starlette.responses import HTMLResponse # type: ignore
from http import HTTPStatus from http import HTTPStatus
import json
from lnbits.decorators import check_user_exists, validate_uuids
from lnbits.extensions.diagonalley import diagonalley_ext
from .crud import ( from fastapi import Request
create_diagonalley_product, from fastapi.params import Depends
get_diagonalley_product, from fastapi.templating import Jinja2Templates
get_diagonalley_products, from starlette.exceptions import HTTPException
delete_diagonalley_product, from starlette.responses import HTMLResponse
create_diagonalley_order,
get_diagonalley_order,
get_diagonalley_orders,
update_diagonalley_product,
)
from lnbits.core.models import User
from lnbits.decorators import check_user_exists # type: ignore
from lnbits.extensions.diagonalley import diagonalley_ext, diagonalley_renderer
from .crud import get_diagonalley_products
templates = Jinja2Templates(directory="templates")
@diagonalley_ext.get("/", response_class=HTMLResponse) @diagonalley_ext.get("/", response_class=HTMLResponse)
@validate_uuids(["usr"], required=True) async def index(request: Request, user: User = Depends(check_user_exists)):
@check_user_exists(request: Request) return diagonalley_renderer().TemplateResponse(
async def index(): "diagonalley/index.html", {"request": request, "user": user.dict()}
return await render_template("diagonalley/index.html", user=g.user) )
@diagonalley_ext.get("/{stall_id}", response_class=HTMLResponse)
@diagonalley_ext.get("/<stall_id>", response_class=HTMLResponse)
async def display(request: Request, stall_id): async def display(request: Request, stall_id):
product = await get_diagonalley_products(stall_id) product = await get_diagonalley_products(stall_id)
if not product:
abort(HTTPStatus.NOT_FOUND, "Stall does not exist.")
return await render_template( if not product:
"diagonalley/stall.html", raise HTTPException(
stall=json.dumps( status_code=HTTPStatus.NOT_FOUND, detail="Stall does not exist."
[product._asdict() for product in await get_diagonalley_products(stall_id)] )
), return diagonalley_renderer().TemplateResponse(
"diagonalley/stall.html",
{"stall": [product.dict() for product in await get_diagonalley_products(stall_id)]}
) )

156
lnbits/extensions/diagonalley/views_api.py
View file

@ -1,4 +1,6 @@
from base64 import urlsafe_b64encode
from http import HTTPStatus from http import HTTPStatus
from uuid import uuid4
from fastapi import Request from fastapi import Request
from fastapi.param_functions import Query from fastapi.param_functions import Query
@ -6,41 +8,47 @@ from fastapi.params import Depends
from starlette.exceptions import HTTPException from starlette.exceptions import HTTPException
from lnbits.core.crud import get_user from lnbits.core.crud import get_user
from lnbits.decorators import api_check_wallet_key, api_validate_post_request from lnbits.core.services import create_invoice
from lnbits.decorators import WalletTypeInfo, get_key_type, require_admin_key
from . import diagonalley_ext from . import db, diagonalley_ext
from .crud import ( from .crud import (
create_diagonalley_product,
get_diagonalley_product,
get_diagonalley_products,
delete_diagonalley_product,
create_diagonalley_zone,
update_diagonalley_zone,
get_diagonalley_zone,
get_diagonalley_zones,
delete_diagonalley_zone,
create_diagonalley_stall,
update_diagonalley_stall,
get_diagonalley_stall,
get_diagonalley_stalls,
delete_diagonalley_stall,
create_diagonalley_order, create_diagonalley_order,
create_diagonalley_product,
create_diagonalley_stall,
create_diagonalley_zone,
delete_diagonalley_order,
delete_diagonalley_product,
delete_diagonalley_stall,
delete_diagonalley_zone,
get_diagonalley_order, get_diagonalley_order,
get_diagonalley_orders, get_diagonalley_orders,
get_diagonalley_product,
get_diagonalley_products,
get_diagonalley_stall,
get_diagonalley_stalls,
get_diagonalley_zone,
get_diagonalley_zones,
update_diagonalley_product, update_diagonalley_product,
delete_diagonalley_order, update_diagonalley_stall,
update_diagonalley_zone,
)
from .models import (
Orders,
Products,
Stalls,
Zones,
createOrder,
createProduct,
createStalls,
createZones,
) )
from lnbits.core.services import create_invoice
from base64 import urlsafe_b64encode
from uuid import uuid4
# from lnbits.db import open_ext_db # from lnbits.db import open_ext_db
from . import db
from .models import Products, Orders, Stalls
### Products ### Products
"""
@copilot_ext.get("/api/v1/copilot/{copilot_id}") @copilot_ext.get("/api/v1/copilot/{copilot_id}")
async def api_copilot_retrieve( async def api_copilot_retrieve(
req: Request, req: Request,
@ -55,26 +63,27 @@ async def api_copilot_retrieve(
if not copilot.lnurl_toggle: if not copilot.lnurl_toggle:
return copilot.dict() return copilot.dict()
return {**copilot.dict(), **{"lnurl": copilot.lnurl(req)}} return {**copilot.dict(), **{"lnurl": copilot.lnurl(req)}}
"""
@diagonalley_ext.get("/api/v1/products") @diagonalley_ext.get("/api/v1/products")
async def api_diagonalley_products( async def api_diagonalley_products(
req: Request, req: Request,
wallet: WalletTypeInfo = Depends(get_key_type), wallet: WalletTypeInfo = Depends(get_key_type),
all_stalls: bool = Query(False)
): ):
wallet_ids = [wallet.wallet.id] wallet_ids = [wallet.wallet.id]
if "all_stalls" in request.args: if all_stalls:
wallet_ids = (await get_user(wallet.wallet.user)).wallet_ids wallet_ids = (await get_user(wallet.wallet.user)).wallet_ids
return ([product._asdict() 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.post("/api/v1/products")
@diagonalley_ext.put("/api/v1/products/{product_id}") @diagonalley_ext.put("/api/v1/products/{product_id}")
async def api_diagonalley_product_create( async def api_diagonalley_product_create(
data: Products, product_id,
product_id=: str = Query(None), data: createProduct,
wallet: WalletTypeInfo = Depends(get_key_type) wallet: WalletTypeInfo = Depends(get_key_type)
): ):
@ -82,19 +91,19 @@ async def api_diagonalley_product_create(
product = await get_diagonalley_product(product_id) product = await get_diagonalley_product(product_id)
if not product: if not product:
return ({"message": "Withdraw product does not exist."})) return ({"message": "Withdraw product does not exist."})
if product.wallet != wallet.wallet.id: 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) product = await update_diagonalley_product(product_id, **data.dict())
else: else:
product = await create_diagonalley_product(wallet_id=wallet.wallet.id, data) product = await create_diagonalley_product(data=data)
return ({**product._asdict()})) return product.dict()
@diagonalley_ext.route("/api/v1/products/{product_id}") @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) product = await get_diagonalley_product(product_id)
@ -105,7 +114,6 @@ async def api_diagonalley_products_delete(product_id, wallet: WalletTypeInfo = D
return ({"message": "Not your Diagon Alley."}) return ({"message": "Not your Diagon Alley."})
await delete_diagonalley_product(product_id) await delete_diagonalley_product(product_id)
raise HTTPException(status_code=HTTPStatus.NO_CONTENT) raise HTTPException(status_code=HTTPStatus.NO_CONTENT)
@ -113,19 +121,18 @@ async def api_diagonalley_products_delete(product_id, wallet: WalletTypeInfo = D
@diagonalley_ext.get("/api/v1/zones") @diagonalley_ext.get("/api/v1/zones")
async def api_diagonalley_zones(wallet: WalletTypeInfo = Depends(get_key_type)): async def api_diagonalley_zones(wallet: WalletTypeInfo = Depends(get_key_type), all_wallets: bool = Query(False)):
wallet_ids = [wallet.wallet.id] wallet_ids = [wallet.wallet.id]
if "all_wallets" in request.args: if all_wallets:
wallet_ids = (await get_user(wallet.wallet.user)).wallet_ids wallet_ids = (await get_user(wallet.wallet.user)).wallet_ids
return ([zone._asdict() for zone in await get_diagonalley_zones(wallet_ids)])) return ([zone.dict() for zone in await get_diagonalley_zones(wallet_ids)])
@diagonalley_ext.post("/api/v1/zones") @diagonalley_ext.post("/api/v1/zones")
@diagonalley_ext.put("/api/v1/zones/{zone_id}") @diagonalley_ext.put("/api/v1/zones/{zone_id}")
async def api_diagonalley_zone_create( async def api_diagonalley_zone_create(
data: Zones, data: createZones,
zone_id: str = Query(None), zone_id: str = Query(None),
wallet: WalletTypeInfo = Depends(get_key_type) wallet: WalletTypeInfo = Depends(get_key_type)
): ):
@ -133,20 +140,20 @@ async def api_diagonalley_zone_create(
zone = await get_diagonalley_zone(zone_id) zone = await get_diagonalley_zone(zone_id)
if not zone: if not zone:
return ({"message": "Zone does not exist."})) return ({"message": "Zone does not exist."})
if zone.wallet != walley.wallet.id: if zone.wallet != wallet.wallet.id:
return ({"message": "Not your record."})) return ({"message": "Not your record."})
zone = await update_diagonalley_zone(zone_id, data) zone = await update_diagonalley_zone(zone_id, **data.dict())
else: else:
zone = await create_diagonalley_zone(wallet=wallet.wallet.id, data) zone = await create_diagonalley_zone(wallet=wallet.wallet.id, data=data)
return ({**zone._asdict()})) return zone.dict()
@diagonalley_ext.delete("/api/v1/zones/{zone_id}") @diagonalley_ext.delete("/api/v1/zones/{zone_id}")
async def api_diagonalley_zone_delete(zone_id: str = Query(None), 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) zone = await get_diagonalley_zone(zone_id)
if not zone: if not zone:
@ -156,7 +163,6 @@ async def api_diagonalley_zone_delete(zone_id: str = Query(None), wallet: Walle
return ({"message": "Not your zone."}) return ({"message": "Not your zone."})
await delete_diagonalley_zone(zone_id) await delete_diagonalley_zone(zone_id)
raise HTTPException(status_code=HTTPStatus.NO_CONTENT) raise HTTPException(status_code=HTTPStatus.NO_CONTENT)
@ -164,13 +170,13 @@ async def api_diagonalley_zone_delete(zone_id: str = Query(None), wallet: Walle
@diagonalley_ext.get("/api/v1/stalls") @diagonalley_ext.get("/api/v1/stalls")
async def api_diagonalley_stalls(wallet: WalletTypeInfo = Depends(get_key_type)): async def api_diagonalley_stalls(wallet: WalletTypeInfo = Depends(get_key_type), all_wallets: bool = Query(False)):
wallet_ids = [wallet.wallet.id] wallet_ids = [wallet.wallet.id]
if "all_wallets" in request.args: if all_wallets:
wallet_ids = (await get_user(wallet.wallet.user)).wallet_ids wallet_ids = (await get_user(wallet.wallet.user)).wallet_ids
return ([stall._asdict() 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.post("/api/v1/stalls")
@ -181,16 +187,16 @@ async def api_diagonalley_stall_create(data: createStalls, stall_id: str = Query
stall = await get_diagonalley_stall(stall_id) stall = await get_diagonalley_stall(stall_id)
if not stall: if not stall:
return ({"message": "Withdraw stall does not exist."})) return ({"message": "Withdraw stall does not exist."})
if stall.wallet != wallet.wallet.id: 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) stall = await update_diagonalley_stall(stall_id, **data.dict())
else: else:
stall = await create_diagonalley_stall(wallet_id=wallet.wallet.id, data) stall = await create_diagonalley_stall(data=data)
return ({**stall._asdict()})) return stall.dict()
@diagonalley_ext.delete("/api/v1/stalls/{stall_id}") @diagonalley_ext.delete("/api/v1/stalls/{stall_id}")
@ -204,7 +210,6 @@ async def api_diagonalley_stall_delete(stall_id: str = Query(None), wallet: Wall
return ({"message": "Not your Stall."}) return ({"message": "Not your Stall."})
await delete_diagonalley_stall(stall_id) await delete_diagonalley_stall(stall_id)
raise HTTPException(status_code=HTTPStatus.NO_CONTENT) raise HTTPException(status_code=HTTPStatus.NO_CONTENT)
@ -212,23 +217,22 @@ async def api_diagonalley_stall_delete(stall_id: str = Query(None), wallet: Wall
@diagonalley_ext.get("/api/v1/orders") @diagonalley_ext.get("/api/v1/orders")
async def api_diagonalley_orders(wallet: WalletTypeInfo = Depends(get_key_type)): async def api_diagonalley_orders(wallet: WalletTypeInfo = Depends(get_key_type), all_wallets: bool = Query(False)):
wallet_ids = [wallet.wallet.id] wallet_ids = [wallet.wallet.id]
if "all_wallets" in request.args: if all_wallets:
wallet_ids = (await get_user(wallet.wallet.user)).wallet_ids wallet_ids = (await get_user(wallet.wallet.user)).wallet_ids
try: try:
return ([order._asdict() for order in await get_diagonalley_orders(wallet_ids)]) return ([order.dict() for order in await get_diagonalley_orders(wallet_ids)])
except: except:
return ({"message": "We could not retrieve the orders."})) return ({"message": "We could not retrieve the orders."})
@diagonalley_ext.post("/api/v1/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: createOrders, wallet: WalletTypeInfo = Depends(get_key_type)): order = await create_diagonalley_order(wallet_id=wallet.wallet.id, data=data)
order = await create_diagonalley_order(wallet_id=wallet.wallet.id, data) return order.dict()
return ({**order._asdict()})
@diagonalley_ext.delete("/api/v1/orders/{order_id}") @diagonalley_ext.delete("/api/v1/orders/{order_id}")
@ -271,7 +275,7 @@ async def api_diagonalley_order_shipped(order_id: str = Query(None), wallet: Wal
"SELECT * FROM diagonalley.orders WHERE id = ?", (order_id,) "SELECT * FROM diagonalley.orders WHERE id = ?", (order_id,)
) )
return ([order._asdict() 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 ###List products based on stall id
@ -293,14 +297,14 @@ async def api_diagonalley_stall_products(stall_id: str = Query(None), wallet: Wa
if not products: if not products:
return ({"message": "No products"}) return ({"message": "No products"})
return ([products._asdict() 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 ###Check a product has been shipped
@diagonalley_ext.get("/api/v1/stall/checkshipped/{checking_id}") @diagonalley_ext.get("/api/v1/stall/checkshipped/{checking_id}")
async def api_diagonalley_stall_checkshipped(checking_id: str = Query(None), wallet: WalletTypeInfo = Depends(get_key_type)): async def api_diagonalley_stall_checkshipped(checking_id, wallet: WalletTypeInfo = Depends(get_key_type)):
rows = await db.fetchone( rows = await db.fetchone(
"SELECT * FROM diagonalley.orders WHERE invoiceid = ?", (checking_id,) "SELECT * FROM diagonalley.orders WHERE invoiceid = ?", (checking_id,)
) )
@ -311,19 +315,19 @@ async def api_diagonalley_stall_checkshipped(checking_id: str = Query(None), wal
@diagonalley_ext.post("/api/v1/stall/order/{stall_id}") @diagonalley_ext.post("/api/v1/stall/order/{stall_id}")
async def api_diagonalley_stall_order(data:createOrders, 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.id) product = await get_diagonalley_product(data.productid)
shipping = await get_diagonalley_stall(stall_id) shipping = await get_diagonalley_stall(stall_id)
if data.shippingzone == 1: if data.shippingzone == 1:
shippingcost = shipping.zone1cost shippingcost = shipping.zone1cost #missing in model
else: else:
shippingcost = shipping.zone2cost shippingcost = shipping.zone2cost #missing in model
checking_id, payment_request = await create_invoice( checking_id, payment_request = await create_invoice(
wallet_id=product.wallet, wallet_id=product.wallet,
amount=shippingcost + (data.quantity * product.price), amount=shippingcost + (data.quantity * product.price),
memo=data.id, memo=shipping.wallet,
) )
selling_id = urlsafe_b64encode(uuid4().bytes_le).decode("utf-8") selling_id = urlsafe_b64encode(uuid4().bytes_le).decode("utf-8")
await db.execute( await db.execute(
@ -333,8 +337,8 @@ async def api_diagonalley_stall_order(data:createOrders, wallet: WalletTypeInfo
""", """,
( (
selling_id, selling_id,
data.id, data.productid,
product.wallet, product.wallet, #doesn't exist in model
product.product, product.product,
data.quantity, data.quantity,
data.shippingzone, data.shippingzone,
@ -345,4 +349,4 @@ async def api_diagonalley_stall_order(data:createOrders, wallet: WalletTypeInfo
False, False,
), ),
) )
return ({"checking_id": checking_id, "payment_request": payment_request})) return ({"checking_id": checking_id, "payment_request": payment_request})