505 lines
19 KiB
Python
505 lines
19 KiB
Python
"""
|
||
Pazar — oyuncu arası ticaret (gold ile) + NPC vendor.
|
||
|
||
Kurallar:
|
||
- İlan verme / satın alma / vendor'a satma SADECE 'pazar' lokasyonundayken.
|
||
- İlanları görüntüleme her yerden serbest (vitrin).
|
||
- Para birimi: gold (characters.gold). Vendor her şeyi items.base_value'dan alır.
|
||
- İlan iptali her yerden yapılabilir (item envantere döner).
|
||
|
||
Endpoint'ler:
|
||
- GET /market/listings → açık ilanlar (q= arama, mine= sadece benimkiler)
|
||
- POST /market/list → {item_code, qty, unit_price} ilan ver
|
||
- POST /market/buy → {listing_id, qty?} satın al (kısmi alım destekli)
|
||
- POST /market/cancel → {listing_id} ilanı iptal et
|
||
- GET /market/vendor → envanterim + vendor'un ödeyeceği birim fiyatlar
|
||
- POST /market/vendor/sell → {item_code, qty} vendor'a sat → gold
|
||
"""
|
||
from datetime import datetime, timezone
|
||
from typing import Optional
|
||
|
||
from fastapi import APIRouter, Depends, HTTPException
|
||
from pydantic import BaseModel, Field
|
||
from sqlalchemy import select, text
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
|
||
from deps import get_current_user
|
||
from models import Character, User, get_db
|
||
from routers.harvest import consume_items
|
||
from routers.travel import _add_items
|
||
|
||
router = APIRouter(prefix="/market", tags=["market"])
|
||
|
||
MARKET_LOCATION = "pazar"
|
||
MAX_OPEN_LISTINGS = 10
|
||
|
||
|
||
async def _char(db: AsyncSession, user: User) -> Character:
|
||
char = (await db.execute(select(Character).where(Character.user_id == user.id))).scalar_one_or_none()
|
||
if not char:
|
||
raise HTTPException(404, "Karakter yok")
|
||
return char
|
||
|
||
|
||
async def _require_at_market(db: AsyncSession, char: Character) -> None:
|
||
row = (await db.execute(text(
|
||
"SELECT code FROM locations WHERE id = :i"
|
||
), {"i": char.location_id})).first()
|
||
if not row or row[0] != MARKET_LOCATION:
|
||
raise HTTPException(400, "Bunun için Pazar'da olmalısın")
|
||
|
||
|
||
# ---------- İlanlar ----------
|
||
|
||
class ListingOut(BaseModel):
|
||
id: int
|
||
item_code: str
|
||
item_name: str
|
||
rarity: str
|
||
icon: Optional[str] = None
|
||
qty: int
|
||
unit_price: int
|
||
seller_name: str
|
||
mine: bool
|
||
|
||
|
||
@router.get("/listings", response_model=list[ListingOut])
|
||
async def listings(q: str = "", mine: bool = False,
|
||
user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
|
||
char = await _char(db, user)
|
||
sql = """
|
||
SELECT ml.id, i.code, i.name, i.rarity, i.icon, ml.qty, ml.unit_price, c.name, ml.seller_id
|
||
FROM market_listings ml
|
||
JOIN items i ON i.id = ml.item_id
|
||
JOIN characters c ON c.id = ml.seller_id
|
||
WHERE ml.status = 'open'
|
||
"""
|
||
params: dict = {}
|
||
if q:
|
||
sql += " AND i.name ILIKE :q"
|
||
params["q"] = f"%{q}%"
|
||
if mine:
|
||
sql += " AND ml.seller_id = :me"
|
||
params["me"] = char.id
|
||
sql += " ORDER BY i.name, ml.unit_price LIMIT 100"
|
||
rows = (await db.execute(text(sql), params)).all()
|
||
return [ListingOut(id=r[0], item_code=r[1], item_name=r[2], rarity=r[3], icon=r[4],
|
||
qty=r[5], unit_price=r[6], seller_name=r[7], mine=(r[8] == char.id))
|
||
for r in rows]
|
||
|
||
|
||
class ListIn(BaseModel):
|
||
item_code: str
|
||
qty: int = Field(ge=1, le=999)
|
||
unit_price: int = Field(ge=1, le=1_000_000)
|
||
|
||
|
||
class ListingActionOut(BaseModel):
|
||
listing_id: int
|
||
gold: int
|
||
|
||
|
||
@router.post("/list", response_model=ListingActionOut)
|
||
async def create_listing(l: ListIn, user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
|
||
char = await _char(db, user)
|
||
await _require_at_market(db, char)
|
||
|
||
open_count = (await db.execute(text(
|
||
"SELECT count(*) FROM market_listings WHERE seller_id=:s AND status='open'"
|
||
), {"s": char.id})).scalar_one()
|
||
if open_count >= MAX_OPEN_LISTINGS:
|
||
raise HTTPException(400, f"En fazla {MAX_OPEN_LISTINGS} açık ilanın olabilir")
|
||
|
||
item = (await db.execute(text(
|
||
"SELECT id, name FROM items WHERE code = :c"), {"c": l.item_code})).first()
|
||
if not item:
|
||
raise HTTPException(404, "Item yok")
|
||
|
||
await consume_items(db, char.id, item[0], l.qty, item[1])
|
||
lid = (await db.execute(text("""
|
||
INSERT INTO market_listings (seller_id, item_id, qty, unit_price)
|
||
VALUES (:s, :i, :q, :p) RETURNING id
|
||
"""), {"s": char.id, "i": item[0], "q": l.qty, "p": l.unit_price})).scalar_one()
|
||
await db.commit()
|
||
return ListingActionOut(listing_id=lid, gold=char.gold)
|
||
|
||
|
||
class BuyIn(BaseModel):
|
||
listing_id: int
|
||
qty: Optional[int] = Field(None, ge=1, le=999) # None = tamamı
|
||
|
||
|
||
class BuyOut(BaseModel):
|
||
item_code: str
|
||
item_name: str
|
||
qty: int
|
||
total_price: int
|
||
gold: int
|
||
|
||
|
||
@router.post("/buy", response_model=BuyOut)
|
||
async def buy(b: BuyIn, user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
|
||
char = await _char(db, user)
|
||
await _require_at_market(db, char)
|
||
|
||
row = (await db.execute(text("""
|
||
SELECT ml.id, ml.seller_id, ml.item_id, ml.qty, ml.unit_price, i.code, i.name
|
||
FROM market_listings ml JOIN items i ON i.id = ml.item_id
|
||
WHERE ml.id = :id AND ml.status = 'open' FOR UPDATE OF ml
|
||
"""), {"id": b.listing_id})).first()
|
||
if not row:
|
||
raise HTTPException(404, "İlan yok ya da kapanmış")
|
||
if row[1] == char.id:
|
||
raise HTTPException(400, "Kendi ilanını satın alamazsın")
|
||
|
||
qty = b.qty if b.qty is not None else int(row[3])
|
||
if qty > int(row[3]):
|
||
raise HTTPException(400, f"İlanda sadece {row[3]} adet var")
|
||
total = qty * int(row[4])
|
||
if char.gold < total:
|
||
raise HTTPException(400, f"Yetersiz gold: {total} gerekli, {char.gold} var")
|
||
|
||
char.gold -= total
|
||
await db.execute(text("UPDATE characters SET gold = gold + :g WHERE id = :s"),
|
||
{"g": total, "s": row[1]})
|
||
await _add_items(db, char.id, row[5], qty)
|
||
|
||
if qty == int(row[3]):
|
||
await db.execute(text(
|
||
"UPDATE market_listings SET status='sold', closed_at=:t WHERE id=:id"
|
||
), {"t": datetime.now(timezone.utc), "id": row[0]})
|
||
else:
|
||
await db.execute(text("UPDATE market_listings SET qty = qty - :q WHERE id=:id"),
|
||
{"q": qty, "id": row[0]})
|
||
|
||
await db.execute(text("""
|
||
INSERT INTO trade_logs (seller_id, buyer_id, item_id, qty, unit_price)
|
||
VALUES (:s, :b, :i, :q, :p)
|
||
"""), {"s": row[1], "b": char.id, "i": row[2], "q": qty, "p": row[4]})
|
||
await db.commit()
|
||
return BuyOut(item_code=row[5], item_name=row[6], qty=qty, total_price=total, gold=char.gold)
|
||
|
||
|
||
class CancelIn(BaseModel):
|
||
listing_id: int
|
||
|
||
|
||
@router.post("/cancel", response_model=ListingActionOut)
|
||
async def cancel(cn: CancelIn, user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
|
||
char = await _char(db, user)
|
||
row = (await db.execute(text("""
|
||
SELECT ml.id, ml.item_id, ml.qty, i.code
|
||
FROM market_listings ml JOIN items i ON i.id = ml.item_id
|
||
WHERE ml.id = :id AND ml.status = 'open' AND ml.seller_id = :s FOR UPDATE OF ml
|
||
"""), {"id": cn.listing_id, "s": char.id})).first()
|
||
if not row:
|
||
raise HTTPException(404, "Açık ilanın yok")
|
||
await db.execute(text(
|
||
"UPDATE market_listings SET status='cancelled', closed_at=:t WHERE id=:id"
|
||
), {"t": datetime.now(timezone.utc), "id": row[0]})
|
||
await _add_items(db, char.id, row[3], int(row[2]))
|
||
await db.commit()
|
||
return ListingActionOut(listing_id=row[0], gold=char.gold)
|
||
|
||
|
||
# ---------- NPC Vendor ----------
|
||
|
||
class VendorRow(BaseModel):
|
||
item_code: str
|
||
item_name: str
|
||
rarity: str
|
||
qty: int
|
||
unit_price: int # vendor'un ödeyeceği gold
|
||
|
||
|
||
@router.get("/vendor", response_model=list[VendorRow])
|
||
async def vendor_prices(user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
|
||
char = await _char(db, user)
|
||
rows = (await db.execute(text("""
|
||
SELECT i.code, i.name, i.rarity, SUM(inv.qty), i.base_value
|
||
FROM inventory inv JOIN items i ON i.id = inv.item_id
|
||
WHERE inv.character_id = :cid
|
||
GROUP BY i.code, i.name, i.rarity, i.base_value
|
||
ORDER BY i.name
|
||
"""), {"cid": char.id})).all()
|
||
return [VendorRow(item_code=r[0], item_name=r[1], rarity=r[2], qty=int(r[3]), unit_price=int(r[4]))
|
||
for r in rows]
|
||
|
||
|
||
class VendorSellIn(BaseModel):
|
||
item_code: str
|
||
qty: int = Field(ge=1, le=999)
|
||
|
||
|
||
class VendorSellOut(BaseModel):
|
||
item_code: str
|
||
item_name: str
|
||
qty: int
|
||
gold_gained: int
|
||
gold: int
|
||
|
||
|
||
@router.post("/vendor/sell", response_model=VendorSellOut)
|
||
async def vendor_sell(v: VendorSellIn, user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
|
||
char = await _char(db, user)
|
||
await _require_at_market(db, char)
|
||
|
||
item = (await db.execute(text(
|
||
"SELECT id, name, base_value FROM items WHERE code = :c"), {"c": v.item_code})).first()
|
||
if not item:
|
||
raise HTTPException(404, "Item yok")
|
||
|
||
await consume_items(db, char.id, item[0], v.qty, item[1])
|
||
gained = int(item[2]) * v.qty
|
||
char.gold += gained
|
||
await db.commit()
|
||
return VendorSellOut(item_code=v.item_code, item_name=item[1], qty=v.qty,
|
||
gold_gained=gained, gold=char.gold)
|
||
|
||
|
||
# ---------- Vendor stok (satın alma — gold sink) ----------
|
||
|
||
# Vendor'un sattığı temel mallar; fiyat = base_value × çarpan
|
||
VENDOR_STOCK_MARKUP = 4
|
||
VENDOR_STOCK_CODES = ["axe_stone", "pickaxe_stone", "fishing_rod", "tea_mint", "stone_small", "stick", "vine"]
|
||
|
||
|
||
class VendorStockRow(BaseModel):
|
||
item_code: str
|
||
item_name: str
|
||
rarity: str
|
||
unit_price: int # gold
|
||
|
||
|
||
@router.get("/vendor/stock", response_model=list[VendorStockRow])
|
||
async def vendor_stock(user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
|
||
await _char(db, user)
|
||
from sqlalchemy import bindparam
|
||
stmt = text(
|
||
"SELECT code, name, rarity, base_value FROM items WHERE code IN :codes ORDER BY base_value"
|
||
).bindparams(bindparam("codes", expanding=True))
|
||
rows = (await db.execute(stmt, {"codes": VENDOR_STOCK_CODES})).all()
|
||
return [VendorStockRow(item_code=r[0], item_name=r[1], rarity=r[2],
|
||
unit_price=int(r[3]) * VENDOR_STOCK_MARKUP) for r in rows]
|
||
|
||
|
||
class VendorBuyIn(BaseModel):
|
||
item_code: str
|
||
qty: int = Field(ge=1, le=10)
|
||
|
||
|
||
class VendorBuyOut(BaseModel):
|
||
item_code: str
|
||
item_name: str
|
||
qty: int
|
||
total_price: int
|
||
gold: int
|
||
|
||
|
||
@router.post("/vendor/buy", response_model=VendorBuyOut)
|
||
async def vendor_buy(v: VendorBuyIn, user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
|
||
char = await _char(db, user)
|
||
await _require_at_market(db, char)
|
||
if v.item_code not in VENDOR_STOCK_CODES:
|
||
raise HTTPException(400, "Vendor bunu satmıyor")
|
||
|
||
item = (await db.execute(text(
|
||
"SELECT id, name, base_value FROM items WHERE code = :c"), {"c": v.item_code})).first()
|
||
if not item:
|
||
raise HTTPException(404, "Item yok")
|
||
|
||
total = int(item[2]) * VENDOR_STOCK_MARKUP * v.qty
|
||
if char.gold < total:
|
||
raise HTTPException(400, f"Yetersiz gold: {total} gerekli, {char.gold} var")
|
||
|
||
char.gold -= total
|
||
await _add_items(db, char.id, v.item_code, v.qty)
|
||
await db.commit()
|
||
return VendorBuyOut(item_code=v.item_code, item_name=item[1], qty=v.qty,
|
||
total_price=total, gold=char.gold)
|
||
|
||
|
||
# ---------- Şehir haritası: konum bazlı NPC vendor'lar ----------
|
||
# Her şehir location'ının kendi vendor NPC'leri var (npcs.location_id).
|
||
# Vendor stoğu = sabit stok (npc_items, sonsuz, base_value×markup)
|
||
# + konsinye (vendor_stock: oyuncuların sattığı, 24s ömürlü, kendi fiyatı).
|
||
# Oyuncu vendor'a sattığında: gold alır + ürün vendor'ın normal satmadığı bir şeyse
|
||
# 24s ömürle konsinyeye eklenir (varsa süresi yenilenir). Normal sattığı üründe
|
||
# sadece gold ödenir (sabit stok zaten sonsuz).
|
||
|
||
VENDOR_CONSIGN_HOURS = 24
|
||
|
||
|
||
async def _clean_expired(db: AsyncSession) -> None:
|
||
await db.execute(text("DELETE FROM vendor_stock WHERE expires_at < now()"))
|
||
|
||
|
||
async def _vendor_at_here(db: AsyncSession, npc_id: int, char: Character) -> dict:
|
||
"""npc_id gerçekten char'ın bulunduğu şehrin vendor'ı mı? değilse 400."""
|
||
row = (await db.execute(text(
|
||
"SELECT id, name, role, location_id FROM npcs WHERE id = :i"
|
||
), {"i": npc_id})).first()
|
||
if not row:
|
||
raise HTTPException(404, "Satıcı yok")
|
||
if row[3] != char.location_id:
|
||
raise HTTPException(400, "Bu satıcı burada değil")
|
||
return {"id": row[0], "name": row[1], "role": row[2]}
|
||
|
||
|
||
class CityVendor(BaseModel):
|
||
npc_id: int
|
||
name: str
|
||
role: Optional[str] = None
|
||
|
||
|
||
class CityOut(BaseModel):
|
||
location_code: str
|
||
location_name: str
|
||
vendors: list[CityVendor]
|
||
|
||
|
||
@router.get("/city", response_model=CityOut)
|
||
async def city_vendors(user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
|
||
"""Bulunduğun şehrin vendor NPC'leri (şehir haritası pinleri)."""
|
||
char = await _char(db, user)
|
||
loc = (await db.execute(text(
|
||
"SELECT code, name FROM locations WHERE id = :i"
|
||
), {"i": char.location_id})).first()
|
||
if not loc:
|
||
raise HTTPException(404, "Konum yok")
|
||
rows = (await db.execute(text(
|
||
"SELECT id, name, role FROM npcs WHERE location_id = :l ORDER BY id"
|
||
), {"l": char.location_id})).all()
|
||
return CityOut(location_code=loc[0], location_name=loc[1],
|
||
vendors=[CityVendor(npc_id=r[0], name=r[1], role=r[2]) for r in rows])
|
||
|
||
|
||
class ShopRow(BaseModel):
|
||
item_code: str
|
||
item_name: str
|
||
rarity: str
|
||
icon: Optional[str] = None
|
||
unit_price: int
|
||
qty: Optional[int] = None # None = sabit stok (sonsuz); sayı = konsinye kalan
|
||
source: str # "base" | "player"
|
||
expires_in_h: Optional[int] = None
|
||
|
||
|
||
class ShopOut(BaseModel):
|
||
npc_id: int
|
||
npc_name: str
|
||
role: Optional[str] = None
|
||
items: list[ShopRow]
|
||
|
||
|
||
@router.get("/vendor/{npc_id}/shop", response_model=ShopOut)
|
||
async def vendor_shop(npc_id: int, user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
|
||
char = await _char(db, user)
|
||
v = await _vendor_at_here(db, npc_id, char)
|
||
await _clean_expired(db)
|
||
# sabit stok — npc_items
|
||
base = (await db.execute(text(
|
||
"SELECT i.code, i.name, i.rarity, i.icon, i.base_value "
|
||
"FROM npc_items ni JOIN items i ON i.id = ni.item_id "
|
||
"WHERE ni.npc_id = :n ORDER BY i.base_value"
|
||
), {"n": npc_id})).all()
|
||
items = [ShopRow(item_code=r[0], item_name=r[1], rarity=r[2], icon=r[3],
|
||
unit_price=int(r[4]) * VENDOR_STOCK_MARKUP, qty=None, source="base")
|
||
for r in base]
|
||
# konsinye — vendor_stock (aktif)
|
||
cons = (await db.execute(text(
|
||
"SELECT i.code, i.name, i.rarity, i.icon, vs.unit_price, vs.qty, "
|
||
"CEIL(EXTRACT(EPOCH FROM (vs.expires_at - now()))/3600.0) "
|
||
"FROM vendor_stock vs JOIN items i ON i.id = vs.item_id "
|
||
"WHERE vs.npc_id = :n AND vs.expires_at > now() ORDER BY vs.expires_at"
|
||
), {"n": npc_id})).all()
|
||
items += [ShopRow(item_code=r[0], item_name=r[1], rarity=r[2], icon=r[3],
|
||
unit_price=int(r[4]), qty=int(r[5]), source="player", expires_in_h=int(r[6]))
|
||
for r in cons]
|
||
await db.commit()
|
||
return ShopOut(npc_id=v["id"], npc_name=v["name"], role=v["role"], items=items)
|
||
|
||
|
||
class NpcBuyIn(BaseModel):
|
||
item_code: str
|
||
qty: int = Field(ge=1, le=99)
|
||
|
||
|
||
@router.post("/vendor/{npc_id}/buy", response_model=VendorBuyOut)
|
||
async def npc_buy(npc_id: int, b: NpcBuyIn, user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
|
||
char = await _char(db, user)
|
||
await _vendor_at_here(db, npc_id, char)
|
||
await _clean_expired(db)
|
||
item = (await db.execute(text(
|
||
"SELECT id, name, base_value FROM items WHERE code = :c"), {"c": b.item_code})).first()
|
||
if not item:
|
||
raise HTTPException(404, "Item yok")
|
||
# önce konsinye stoğu (sınırlı), yoksa sabit stok (npc_items, sonsuz)
|
||
cons = (await db.execute(text(
|
||
"SELECT qty, unit_price FROM vendor_stock "
|
||
"WHERE npc_id = :n AND item_id = :it AND expires_at > now()"
|
||
), {"n": npc_id, "it": item[0]})).first()
|
||
if cons is not None:
|
||
if int(cons[0]) < b.qty:
|
||
raise HTTPException(400, f"Stokta {int(cons[0])} adet var")
|
||
unit = int(cons[1])
|
||
total = unit * b.qty
|
||
if char.gold < total:
|
||
raise HTTPException(400, f"Yetersiz gold: {total} gerekli, {char.gold} var")
|
||
remaining = int(cons[0]) - b.qty
|
||
if remaining > 0:
|
||
await db.execute(text("UPDATE vendor_stock SET qty = :q WHERE npc_id = :n AND item_id = :it"),
|
||
{"q": remaining, "n": npc_id, "it": item[0]})
|
||
else:
|
||
await db.execute(text("DELETE FROM vendor_stock WHERE npc_id = :n AND item_id = :it"),
|
||
{"n": npc_id, "it": item[0]})
|
||
else:
|
||
# sabit stok mu?
|
||
is_base = (await db.execute(text(
|
||
"SELECT 1 FROM npc_items WHERE npc_id = :n AND item_id = :it"
|
||
), {"n": npc_id, "it": item[0]})).first()
|
||
if not is_base:
|
||
raise HTTPException(400, "Bu satıcı bunu satmıyor")
|
||
unit = int(item[2]) * VENDOR_STOCK_MARKUP
|
||
total = unit * b.qty
|
||
if char.gold < total:
|
||
raise HTTPException(400, f"Yetersiz gold: {total} gerekli, {char.gold} var")
|
||
char.gold -= total
|
||
await _add_items(db, char.id, b.item_code, b.qty)
|
||
await db.commit()
|
||
return VendorBuyOut(item_code=b.item_code, item_name=item[1], qty=b.qty,
|
||
total_price=total, gold=char.gold)
|
||
|
||
|
||
class NpcSellIn(BaseModel):
|
||
item_code: str
|
||
qty: int = Field(ge=1, le=999)
|
||
|
||
|
||
@router.post("/vendor/{npc_id}/sell", response_model=VendorSellOut)
|
||
async def npc_sell(npc_id: int, s: NpcSellIn, user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
|
||
char = await _char(db, user)
|
||
await _vendor_at_here(db, npc_id, char)
|
||
item = (await db.execute(text(
|
||
"SELECT id, name, base_value FROM items WHERE code = :c"), {"c": s.item_code})).first()
|
||
if not item:
|
||
raise HTTPException(404, "Item yok")
|
||
await consume_items(db, char.id, item[0], s.qty, item[1])
|
||
gained = int(item[2]) * s.qty
|
||
char.gold += gained
|
||
# Vendor'ın normal satmadığı ürünse konsinyeye ekle (24s, süresi yenilenir).
|
||
is_base = (await db.execute(text(
|
||
"SELECT 1 FROM npc_items WHERE npc_id = :n AND item_id = :it"
|
||
), {"n": npc_id, "it": item[0]})).first()
|
||
if not is_base:
|
||
unit = int(item[2]) * VENDOR_STOCK_MARKUP
|
||
await db.execute(text(
|
||
"INSERT INTO vendor_stock(npc_id, item_id, qty, unit_price, expires_at) "
|
||
"VALUES (:n, :it, :q, :u, now() + make_interval(hours => :h)) "
|
||
"ON CONFLICT (npc_id, item_id) DO UPDATE SET "
|
||
"qty = vendor_stock.qty + EXCLUDED.qty, unit_price = EXCLUDED.unit_price, "
|
||
"expires_at = now() + make_interval(hours => :h)"
|
||
), {"n": npc_id, "it": item[0], "q": s.qty, "u": unit, "h": VENDOR_CONSIGN_HOURS})
|
||
await db.commit()
|
||
return VendorSellOut(item_code=s.item_code, item_name=item[1], qty=s.qty,
|
||
gold_gained=gained, gold=char.gold)
|