warlock/cbd420
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

payment on hold

Browse Source
This commit is contained in:
root
2025-12-21 08:43:43 +01:00
parent 872e5a1a6a
commit 6741f5ed72
9 changed files with 977 additions and 217 deletions
Download Patch File Download Diff File Expand all files Collapse all files

87
app/api/drops/active/route.ts
View File

@@ -6,6 +6,11 @@ export async function GET() {
try {
const now = new Date()
// Clean up expired pending orders first to ensure accurate calculations
await pool.execute(
'DELETE FROM pending_orders WHERE expires_at < NOW()',
)
// Get all drops ordered by start_time (or created_at if start_time is null)
const [rows] = await pool.execute(
'SELECT * FROM drops ORDER BY COALESCE(start_time, created_at) ASC'
@@ -14,33 +19,50 @@ export async function GET() {
const drops = rows as any[]
// Find the first drop that's not fully sold out and has started
console.log(`Checking ${drops.length} drops for active drop`)
for (const drop of drops) {
// Check if drop has started (start_time is in the past or null)
const startTime = drop.start_time ? new Date(drop.start_time) : new Date(drop.created_at)
console.log(`Checking drop ${drop.id} (${drop.item}): startTime=${startTime.toISOString()}, now=${now.toISOString()}, started=${startTime <= now}`)
if (startTime > now) {
// Drop hasn't started yet - return it with a flag indicating it's upcoming
// Calculate fill (will be 0 for upcoming drops)
// Calculate fill (will be 0 for upcoming drops, but include pending for consistency)
const [salesRows] = await pool.execute(
'SELECT COALESCE(SUM(size), 0) as total_fill FROM sales WHERE drop_id = ?',
[drop.id]
)
const salesData = salesRows as any[]
const totalFillInGrams = salesData[0]?.total_fill || 0
// Include non-expired pending orders in fill calculation
const [pendingRows] = await pool.execute(
'SELECT COALESCE(SUM(size), 0) as total_pending FROM pending_orders WHERE drop_id = ? AND expires_at > NOW()',
[drop.id]
)
const pendingData = pendingRows as any[]
const pendingFillInGrams = pendingData[0]?.total_pending || 0
let fill = totalFillInGrams
const totalReservedInGrams = totalFillInGrams + pendingFillInGrams
let salesFill = totalFillInGrams
let pendingFill = pendingFillInGrams
if (drop.unit === 'kg') {
fill = totalFillInGrams / 1000
salesFill = totalFillInGrams / 1000
pendingFill = pendingFillInGrams / 1000
}
const totalFill = salesFill + pendingFill
console.log(`Returning upcoming drop ${drop.id} (${drop.item}): fill=${totalFill}, size=${drop.size}, starts at ${startTime.toISOString()}`)
return NextResponse.json({
...drop,
fill: fill,
fill: totalFill,
sales_fill: salesFill,
pending_fill: pendingFill,
is_upcoming: true,
start_time: drop.start_time || drop.created_at,
})
}
// Calculate fill from sales records
// Calculate fill from sales records and pending orders
// Sales are stored in grams, so we need to convert based on drop unit
const [salesRows] = await pool.execute(
'SELECT COALESCE(SUM(size), 0) as total_fill FROM sales WHERE drop_id = ?',
@@ -48,22 +70,65 @@ export async function GET() {
)
const salesData = salesRows as any[]
const totalFillInGrams = salesData[0]?.total_fill || 0
// Include non-expired pending orders in fill calculation (shows "on hold" inventory)
const [pendingRows] = await pool.execute(
'SELECT COALESCE(SUM(size), 0) as total_pending FROM pending_orders WHERE drop_id = ? AND expires_at > NOW()',
[drop.id]
)
const pendingData = pendingRows as any[]
// Ensure we get a number, handle null/undefined cases
// When table is empty, SUM returns NULL, COALESCE converts it to 0
let pendingFillInGrams = 0
if (pendingData && pendingData.length > 0 && pendingData[0]) {
const rawValue = pendingData[0].total_pending
// Handle both null (from empty result) and actual 0 values
if (rawValue !== null && rawValue !== undefined) {
pendingFillInGrams = Number(rawValue) || 0
}
}
// Explicitly ensure it's 0 if we got here with no valid data
pendingFillInGrams = Number(pendingFillInGrams) || 0
// Ensure totalFillInGrams and pendingFillInGrams are numbers, not strings
const totalFillNum = Number(totalFillInGrams) || 0
const pendingFillNum = Number(pendingFillInGrams) || 0
const totalReservedInGrams = totalFillNum + pendingFillNum
// Convert fill to drop's unit for comparison
let fill = totalFillInGrams
// Convert to drop's unit for display
let salesFill = totalFillNum
let pendingFill = pendingFillNum
if (drop.unit === 'kg') {
fill = totalFillInGrams / 1000
salesFill = totalFillNum / 1000
pendingFill = pendingFillNum / 1000
}
const totalFill = salesFill + pendingFill
// Ensure drop.size is a number for comparison
const dropSize = typeof drop.size === 'string' ? parseFloat(drop.size) : Number(drop.size)
const fillNum = Number(totalFill)
// Check if drop is not fully sold out
if (fill < drop.size) {
// Return drop with calculated fill
// Use a small epsilon for floating point comparison to handle precision issues
// Consider sold out if fill is within epsilon of size (to handle rounding)
const epsilon = drop.unit === 'kg' ? 0.00001 : 0.01
const remaining = dropSize - fillNum
if (remaining > epsilon) {
// Ensure pending_fill is explicitly 0 if no pending orders
const finalPendingFill = Number(pendingFill) || 0
console.log(`Returning active drop ${drop.id} with fill ${fillNum} < size ${dropSize}, pending_fill=${finalPendingFill} (raw: ${pendingFill})`)
return NextResponse.json({
...drop,
fill: fill,
fill: fillNum,
sales_fill: Number(salesFill) || 0, // Only confirmed sales
pending_fill: finalPendingFill, // Items on hold (explicitly 0 if no pending orders)
is_upcoming: false,
start_time: drop.start_time || drop.created_at,
})
} else {
console.log(`Drop ${drop.id} is sold out: fill=${fillNum} >= size=${dropSize} (remaining=${remaining})`)
}
}