iDefineHD
7a32454b83
All checks were successful
Build Frontend / Build Frontend (push) Successful in 24s
923 lines
28 KiB
JavaScript
923 lines
28 KiB
JavaScript
import axios from "axios";
|
|
import { authenticate } from "../middleware/auth.js";
|
|
import Item from "../models/Item.js";
|
|
import Trade from "../models/Trade.js";
|
|
import Transaction from "../models/Transaction.js";
|
|
import SiteConfig from "../models/SiteConfig.js";
|
|
import { config } from "../config/index.js";
|
|
import pricingService from "../services/pricing.js";
|
|
import marketPriceService from "../services/marketPrice.js";
|
|
import { getSteamBotManager } from "../services/steamBot.js";
|
|
|
|
/**
|
|
* Inventory routes for fetching and listing Steam items
|
|
* @param {FastifyInstance} fastify
|
|
* @param {Object} options
|
|
*/
|
|
export default async function inventoryRoutes(fastify, options) {
|
|
// GET /inventory/steam - Fetch user's Steam inventory
|
|
fastify.get(
|
|
"/steam",
|
|
{
|
|
preHandler: authenticate,
|
|
schema: {
|
|
querystring: {
|
|
type: "object",
|
|
properties: {
|
|
game: { type: "string", enum: ["cs2", "rust"], default: "cs2" },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
async (request, reply) => {
|
|
try {
|
|
const { game = "cs2" } = request.query;
|
|
const steamId = request.user.steamId;
|
|
|
|
if (!steamId) {
|
|
return reply.status(400).send({
|
|
success: false,
|
|
message: "Steam ID not found",
|
|
});
|
|
}
|
|
|
|
// Map game to Steam app ID
|
|
const appIds = {
|
|
cs2: 730, // Counter-Strike 2
|
|
rust: 252490, // Rust
|
|
};
|
|
|
|
const appId = appIds[game];
|
|
const contextId = 2; // Standard Steam inventory context
|
|
|
|
console.log(
|
|
`🎮 Fetching ${game.toUpperCase()} inventory for Steam ID: ${steamId}`
|
|
);
|
|
|
|
// Get Steam API key from environment (check both possible env var names)
|
|
const steamApiKey =
|
|
process.env.STEAM_APIS_KEY ||
|
|
process.env.STEAM_API_KEY ||
|
|
config.steam?.apiKey;
|
|
|
|
if (!steamApiKey) {
|
|
console.error("❌ STEAM_API_KEY or STEAM_APIS_KEY not configured");
|
|
return reply.status(500).send({
|
|
success: false,
|
|
message: "Steam API is not configured. Please contact support.",
|
|
});
|
|
}
|
|
|
|
// Fetch from SteamAPIs.com
|
|
const steamApiUrl = `https://api.steamapis.com/steam/inventory/${steamId}/${appId}/${contextId}`;
|
|
|
|
console.log(`📡 Calling: ${steamApiUrl}`);
|
|
|
|
const response = await axios.get(steamApiUrl, {
|
|
params: {
|
|
api_key: steamApiKey,
|
|
},
|
|
timeout: 15000,
|
|
headers: {
|
|
"User-Agent": "TurboTrades/1.0",
|
|
},
|
|
});
|
|
|
|
if (!response.data || !response.data.assets) {
|
|
console.log("⚠️ Empty inventory or private profile");
|
|
return reply.send({
|
|
success: true,
|
|
items: [],
|
|
message: "Inventory is empty or private",
|
|
});
|
|
}
|
|
|
|
const { assets, descriptions } = response.data;
|
|
|
|
// Create a map of descriptions for quick lookup
|
|
const descMap = new Map();
|
|
descriptions.forEach((desc) => {
|
|
const key = `${desc.classid}_${desc.instanceid}`;
|
|
descMap.set(key, desc);
|
|
});
|
|
|
|
// Process items
|
|
const items = assets
|
|
.map((asset) => {
|
|
const key = `${asset.classid}_${asset.instanceid}`;
|
|
const desc = descMap.get(key);
|
|
|
|
if (!desc) return null;
|
|
|
|
// Parse item details
|
|
const item = {
|
|
assetid: asset.assetid,
|
|
appid: appId,
|
|
contextid: contextId,
|
|
classid: asset.classid,
|
|
instanceid: asset.instanceid,
|
|
name: desc.market_hash_name || desc.name || "Unknown Item",
|
|
type: desc.type || "",
|
|
image: desc.icon_url
|
|
? `https://community.cloudflare.steamstatic.com/economy/image/${desc.icon_url}`
|
|
: null,
|
|
nameColor: desc.name_color || null,
|
|
backgroundColor: desc.background_color || null,
|
|
marketable: desc.marketable === 1,
|
|
tradable: desc.tradable === 1,
|
|
commodity: desc.commodity === 1,
|
|
tags: desc.tags || [],
|
|
descriptions: desc.descriptions || [],
|
|
};
|
|
|
|
// Extract rarity from tags
|
|
const rarityTag = item.tags.find(
|
|
(tag) => tag.category === "Rarity"
|
|
);
|
|
if (rarityTag) {
|
|
item.rarity =
|
|
rarityTag.internal_name || rarityTag.localized_tag_name;
|
|
}
|
|
|
|
// Extract exterior (wear) from tags for CS2
|
|
if (game === "cs2") {
|
|
const exteriorTag = item.tags.find(
|
|
(tag) => tag.category === "Exterior"
|
|
);
|
|
if (exteriorTag) {
|
|
const wearMap = {
|
|
"Factory New": "fn",
|
|
"Minimal Wear": "mw",
|
|
"Field-Tested": "ft",
|
|
"Well-Worn": "ww",
|
|
"Battle-Scarred": "bs",
|
|
};
|
|
item.wear = wearMap[exteriorTag.localized_tag_name] || null;
|
|
item.wearName = exteriorTag.localized_tag_name;
|
|
}
|
|
}
|
|
|
|
// Extract category
|
|
const categoryTag = item.tags.find(
|
|
(tag) => tag.category === "Type" || tag.category === "Weapon"
|
|
);
|
|
if (categoryTag) {
|
|
item.category =
|
|
categoryTag.internal_name || categoryTag.localized_tag_name;
|
|
}
|
|
|
|
// Check if StatTrak or Souvenir
|
|
item.statTrak = item.name.includes("StatTrak™");
|
|
item.souvenir = item.name.includes("Souvenir");
|
|
|
|
// Detect phase for Doppler items
|
|
const descriptionText = item.descriptions
|
|
.map((d) => d.value || "")
|
|
.join(" ");
|
|
item.phase = pricingService.detectPhase(item.name, descriptionText);
|
|
|
|
return item;
|
|
})
|
|
.filter((item) => item !== null && item.marketable && item.tradable);
|
|
|
|
console.log(`✅ Found ${items.length} marketable items in inventory`);
|
|
|
|
// Enrich items with market prices (fast database lookup)
|
|
console.log(`💰 Adding market prices...`);
|
|
|
|
// Get site config for payout rate
|
|
const siteConfig = await SiteConfig.getConfig();
|
|
let payoutRate = siteConfig.instantSell.payoutRate || 0.6;
|
|
|
|
// Check for game-specific payout rate
|
|
if (game === "cs2" && siteConfig.instantSell.cs2?.payoutRate) {
|
|
payoutRate = siteConfig.instantSell.cs2.payoutRate;
|
|
} else if (game === "rust" && siteConfig.instantSell.rust?.payoutRate) {
|
|
payoutRate = siteConfig.instantSell.rust.payoutRate;
|
|
}
|
|
|
|
console.log(
|
|
`💵 Instant sell payout rate: ${(payoutRate * 100).toFixed(
|
|
0
|
|
)}% of market price`
|
|
);
|
|
|
|
// Get all item names for batch lookup
|
|
const itemNames = items.map((item) => item.name);
|
|
console.log(`📋 Looking up prices for ${itemNames.length} items`);
|
|
console.log(`🎮 Game: ${game}`);
|
|
console.log(`📝 First 3 item names:`, itemNames.slice(0, 3));
|
|
|
|
const priceMap = await marketPriceService.getPrices(itemNames, game);
|
|
const foundPrices = Object.keys(priceMap).length;
|
|
console.log(
|
|
`💰 Found prices for ${foundPrices}/${itemNames.length} items`
|
|
);
|
|
|
|
// Add prices to items (applying payout rate for instant sell)
|
|
const enrichedItems = items.map((item) => {
|
|
const marketPrice = priceMap[item.name] || null;
|
|
return {
|
|
...item,
|
|
marketPrice: marketPrice
|
|
? parseFloat((marketPrice * payoutRate).toFixed(2))
|
|
: null,
|
|
fullMarketPrice: marketPrice, // Keep original for reference
|
|
payoutRate: payoutRate,
|
|
hasPriceData: !!marketPrice,
|
|
};
|
|
});
|
|
|
|
// Log items without prices
|
|
const itemsWithoutPrices = enrichedItems.filter(
|
|
(item) => !item.marketPrice
|
|
);
|
|
if (itemsWithoutPrices.length > 0) {
|
|
console.log(`⚠️ ${itemsWithoutPrices.length} items without prices:`);
|
|
itemsWithoutPrices.slice(0, 5).forEach((item) => {
|
|
console.log(` - ${item.name}`);
|
|
});
|
|
}
|
|
|
|
console.log(`✅ Prices added to ${enrichedItems.length} items`);
|
|
|
|
return reply.send({
|
|
success: true,
|
|
items: enrichedItems,
|
|
total: enrichedItems.length,
|
|
});
|
|
} catch (error) {
|
|
console.error("❌ Error fetching Steam inventory:", error.message);
|
|
console.error("Error details:", error.response?.data || error.message);
|
|
|
|
if (error.response?.status === 401) {
|
|
return reply.status(500).send({
|
|
success: false,
|
|
message: "Steam API authentication failed. Please contact support.",
|
|
});
|
|
}
|
|
|
|
if (error.response?.status === 403) {
|
|
return reply.status(403).send({
|
|
success: false,
|
|
message:
|
|
"Steam inventory is private. Please make your inventory public in Steam settings.",
|
|
});
|
|
}
|
|
|
|
if (error.response?.status === 404) {
|
|
return reply.status(404).send({
|
|
success: false,
|
|
message: "Steam profile not found or inventory is empty.",
|
|
});
|
|
}
|
|
|
|
if (error.response?.status === 429) {
|
|
return reply.status(429).send({
|
|
success: false,
|
|
message:
|
|
"Steam API rate limit exceeded. Please try again in a few moments.",
|
|
});
|
|
}
|
|
|
|
if (error.code === "ECONNABORTED" || error.code === "ETIMEDOUT") {
|
|
return reply.status(504).send({
|
|
success: false,
|
|
message: "Steam API request timed out. Please try again.",
|
|
});
|
|
}
|
|
|
|
return reply.status(500).send({
|
|
success: false,
|
|
message: "Failed to fetch Steam inventory. Please try again later.",
|
|
});
|
|
}
|
|
}
|
|
);
|
|
|
|
// POST /inventory/price - Get pricing for items
|
|
fastify.post(
|
|
"/price",
|
|
{
|
|
preHandler: authenticate,
|
|
schema: {
|
|
body: {
|
|
type: "object",
|
|
required: ["items"],
|
|
properties: {
|
|
items: {
|
|
type: "array",
|
|
items: {
|
|
type: "object",
|
|
required: ["name"],
|
|
properties: {
|
|
name: { type: "string" },
|
|
assetid: { type: "string" },
|
|
wear: { type: "string" },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
async (request, reply) => {
|
|
try {
|
|
const { items } = request.body;
|
|
|
|
// Use fast market price database for instant lookups
|
|
const pricedItems = await Promise.all(
|
|
items.map(async (item) => {
|
|
try {
|
|
// Use market price service for instant lookup (<1ms)
|
|
const marketPrice = await marketPriceService.getPrice(
|
|
item.name,
|
|
"cs2" // TODO: Get from request or item
|
|
);
|
|
|
|
return {
|
|
...item,
|
|
estimatedPrice: marketPrice,
|
|
currency: "USD",
|
|
hasPriceData: marketPrice !== null,
|
|
};
|
|
} catch (err) {
|
|
console.error(`Error pricing item ${item.name}:`, err.message);
|
|
return {
|
|
...item,
|
|
estimatedPrice: null,
|
|
currency: "USD",
|
|
hasPriceData: false,
|
|
error: "Price data not available",
|
|
};
|
|
}
|
|
})
|
|
);
|
|
|
|
// Filter out items without price data
|
|
const itemsWithPrices = pricedItems.filter(
|
|
(item) => item.estimatedPrice !== null
|
|
);
|
|
|
|
return reply.send({
|
|
success: true,
|
|
items: itemsWithPrices,
|
|
total: items.length,
|
|
priced: itemsWithPrices.length,
|
|
noPriceData: items.length - itemsWithPrices.length,
|
|
});
|
|
} catch (error) {
|
|
console.error("Error pricing items:", error);
|
|
return reply.status(500).send({
|
|
success: false,
|
|
message: "Failed to calculate item prices",
|
|
});
|
|
}
|
|
}
|
|
);
|
|
|
|
// POST /inventory/sell - Create Steam trade offer to sell items
|
|
fastify.post(
|
|
"/sell",
|
|
{
|
|
preHandler: authenticate,
|
|
schema: {
|
|
body: {
|
|
type: "object",
|
|
required: ["items", "tradeUrl"],
|
|
properties: {
|
|
items: {
|
|
type: "array",
|
|
items: {
|
|
type: "object",
|
|
required: [
|
|
"assetid",
|
|
"appid",
|
|
"contextid",
|
|
"name",
|
|
"price",
|
|
"image",
|
|
],
|
|
properties: {
|
|
assetid: { type: "string" },
|
|
appid: { type: "number" },
|
|
contextid: { type: "string" },
|
|
name: { type: "string" },
|
|
price: { type: "number" },
|
|
image: { type: "string" },
|
|
wear: { type: "string" },
|
|
rarity: { type: "string" },
|
|
category: { type: "string" },
|
|
statTrak: { type: "boolean" },
|
|
souvenir: { type: "boolean" },
|
|
},
|
|
},
|
|
},
|
|
tradeUrl: { type: "string" },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
async (request, reply) => {
|
|
// Declare variables outside try block for catch block access
|
|
let userId, steamId, items, tradeUrl, botManager, bypassBots;
|
|
|
|
try {
|
|
items = request.body.items;
|
|
tradeUrl = request.body.tradeUrl;
|
|
userId = request.user._id;
|
|
steamId = request.user.steamId;
|
|
|
|
console.log("🔍 Sell endpoint called:", {
|
|
userId,
|
|
steamId,
|
|
itemCount: items?.length,
|
|
hasTradeUrl: !!tradeUrl,
|
|
nodeEnv: process.env.NODE_ENV,
|
|
bypassBot: process.env.BYPASS_BOT_REQUIREMENT,
|
|
});
|
|
|
|
if (!items || items.length === 0) {
|
|
return reply.status(400).send({
|
|
success: false,
|
|
message: "No items selected",
|
|
});
|
|
}
|
|
|
|
if (!tradeUrl) {
|
|
return reply.status(400).send({
|
|
success: false,
|
|
message:
|
|
"Trade URL is required. Please set your trade URL in your profile.",
|
|
});
|
|
}
|
|
|
|
// Calculate total value
|
|
const totalValue = items.reduce((sum, item) => sum + item.price, 0);
|
|
|
|
// Get bot manager
|
|
botManager = getSteamBotManager();
|
|
|
|
// In development mode, allow bypassing bot requirement
|
|
const isDevelopmentMode = process.env.NODE_ENV === "development";
|
|
bypassBots = process.env.BYPASS_BOT_REQUIREMENT === "true";
|
|
|
|
if (!botManager.isInitialized && !bypassBots) {
|
|
return reply.status(503).send({
|
|
success: false,
|
|
message:
|
|
"Trade system is currently unavailable. Please try again later.",
|
|
});
|
|
}
|
|
|
|
// Development mode: Mock trade creation
|
|
if (bypassBots || !botManager.isInitialized) {
|
|
console.log(
|
|
"⚠️ DEVELOPMENT MODE: Creating mock trade (no real Steam bot)"
|
|
);
|
|
|
|
// Generate mock verification code
|
|
const mockCode = Math.random()
|
|
.toString(36)
|
|
.substring(2, 8)
|
|
.toUpperCase();
|
|
const mockOfferId = `DEV_${Date.now()}`;
|
|
const mockTradeOfferUrl = `https://steamcommunity.com/tradeoffer/${mockOfferId}`;
|
|
|
|
// Create trade record in database
|
|
const trade = new Trade({
|
|
offerId: mockOfferId,
|
|
botId: "dev-bot",
|
|
userId: userId,
|
|
steamId: steamId,
|
|
tradeUrl: tradeUrl,
|
|
tradeOfferUrl: mockTradeOfferUrl,
|
|
items: items.map((item) => ({
|
|
assetId: item.assetid,
|
|
name: item.name,
|
|
price: item.price,
|
|
image: item.image,
|
|
game: item.appid === 730 ? "cs2" : "rust",
|
|
wear: item.wear,
|
|
rarity: item.rarity,
|
|
category: item.category,
|
|
statTrak: item.statTrak,
|
|
souvenir: item.souvenir,
|
|
})),
|
|
totalValue,
|
|
userReceives: totalValue,
|
|
verificationCode: mockCode,
|
|
state: "pending",
|
|
});
|
|
|
|
await trade.save();
|
|
|
|
console.log(
|
|
`✅ Mock trade created: ${mockOfferId} with code: ${mockCode}`
|
|
);
|
|
|
|
// Send WebSocket notification
|
|
if (fastify.websocketManager) {
|
|
fastify.websocketManager.sendToUser(steamId, {
|
|
type: "trade_created",
|
|
data: {
|
|
tradeId: trade._id,
|
|
offerId: mockOfferId,
|
|
verificationCode: mockCode,
|
|
tradeOfferUrl: mockTradeOfferUrl,
|
|
itemCount: items.length,
|
|
totalValue,
|
|
botId: "dev-bot",
|
|
status: "pending",
|
|
timestamp: Date.now(),
|
|
isDevelopment: true,
|
|
},
|
|
});
|
|
}
|
|
|
|
return reply.send({
|
|
success: true,
|
|
message: "Mock trade created (Development Mode)",
|
|
trade: {
|
|
tradeId: trade._id,
|
|
offerId: mockOfferId,
|
|
verificationCode: mockCode,
|
|
tradeOfferUrl: mockTradeOfferUrl,
|
|
itemCount: items.length,
|
|
totalValue,
|
|
status: "pending",
|
|
botId: "dev-bot",
|
|
isDevelopment: true,
|
|
},
|
|
});
|
|
}
|
|
|
|
// Prepare items for Steam trade (format required by steam-tradeoffer-manager)
|
|
const itemsToReceive = items.map((item) => ({
|
|
assetid: item.assetid,
|
|
appid: item.appid,
|
|
contextid: item.contextid,
|
|
}));
|
|
|
|
console.log(
|
|
`📤 Creating trade offer for user ${request.user.username} (${
|
|
items.length
|
|
} items, $${totalValue.toFixed(2)})`
|
|
);
|
|
|
|
// Create trade offer via bot
|
|
let tradeResult;
|
|
try {
|
|
tradeResult = await botManager.createTradeOffer({
|
|
tradeUrl,
|
|
itemsToReceive,
|
|
userId: steamId,
|
|
metadata: {
|
|
username: request.user.username,
|
|
itemCount: items.length,
|
|
totalValue,
|
|
},
|
|
});
|
|
} catch (botError) {
|
|
console.error("Bot trade creation error:", botError);
|
|
return reply.status(503).send({
|
|
success: false,
|
|
message:
|
|
botError.message ||
|
|
"Failed to create trade offer. Please try again.",
|
|
});
|
|
}
|
|
|
|
// Create trade record in database
|
|
const trade = new Trade({
|
|
offerId: tradeResult.offerId,
|
|
botId: tradeResult.botId,
|
|
userId: userId,
|
|
steamId: steamId,
|
|
tradeUrl: tradeUrl,
|
|
tradeOfferUrl: tradeResult.tradeOfferUrl,
|
|
items: items.map((item) => ({
|
|
assetId: item.assetid,
|
|
name: item.name,
|
|
price: item.price,
|
|
image: item.image,
|
|
game: item.appid === 730 ? "cs2" : "rust",
|
|
wear: item.wear,
|
|
rarity: item.rarity,
|
|
category: item.category,
|
|
statTrak: item.statTrak,
|
|
souvenir: item.souvenir,
|
|
})),
|
|
totalValue,
|
|
userReceives: totalValue,
|
|
verificationCode: tradeResult.code,
|
|
state: "pending",
|
|
});
|
|
|
|
await trade.save();
|
|
|
|
console.log(
|
|
`✅ Trade offer created: ${tradeResult.offerId} with verification code: ${tradeResult.code}`
|
|
);
|
|
|
|
// Send immediate WebSocket notification with verification code
|
|
if (fastify.websocketManager) {
|
|
fastify.websocketManager.sendToUser(steamId, {
|
|
type: "trade_created",
|
|
data: {
|
|
tradeId: trade._id,
|
|
offerId: tradeResult.offerId,
|
|
verificationCode: tradeResult.code,
|
|
tradeOfferUrl: tradeResult.tradeOfferUrl,
|
|
itemCount: items.length,
|
|
totalValue,
|
|
botId: tradeResult.botId,
|
|
status: "pending",
|
|
timestamp: Date.now(),
|
|
},
|
|
});
|
|
}
|
|
|
|
return reply.send({
|
|
success: true,
|
|
message: "Trade offer created successfully",
|
|
trade: {
|
|
tradeId: trade._id,
|
|
offerId: tradeResult.offerId,
|
|
verificationCode: tradeResult.code,
|
|
tradeOfferUrl: tradeResult.tradeOfferUrl,
|
|
itemCount: items.length,
|
|
totalValue,
|
|
status: "pending",
|
|
botId: tradeResult.botId,
|
|
},
|
|
});
|
|
} catch (error) {
|
|
console.error("❌ Error creating sell trade:", error);
|
|
console.error("Error stack:", error.stack);
|
|
console.error("Error details:", {
|
|
message: error.message,
|
|
name: error.name,
|
|
userId,
|
|
steamId,
|
|
itemCount: items?.length,
|
|
tradeUrl: tradeUrl ? "present" : "missing",
|
|
bypassBots,
|
|
isInitialized: botManager?.isInitialized,
|
|
});
|
|
return reply.status(500).send({
|
|
success: false,
|
|
message:
|
|
error.message || "Failed to create trade offer. Please try again.",
|
|
});
|
|
}
|
|
}
|
|
);
|
|
|
|
// GET /inventory/trades - Get user's trades
|
|
fastify.get(
|
|
"/trades",
|
|
{
|
|
preHandler: authenticate,
|
|
},
|
|
async (request, reply) => {
|
|
try {
|
|
const userId = request.user._id;
|
|
|
|
const trades = await Trade.find({ user: userId })
|
|
.sort({ createdAt: -1 })
|
|
.limit(50);
|
|
|
|
return reply.send({
|
|
success: true,
|
|
trades,
|
|
});
|
|
} catch (error) {
|
|
console.error("Error fetching trades:", error);
|
|
return reply.status(500).send({
|
|
success: false,
|
|
message: "Failed to fetch trades",
|
|
});
|
|
}
|
|
}
|
|
);
|
|
|
|
// GET /inventory/trade/:tradeId - Get specific trade details
|
|
fastify.get(
|
|
"/trade/:tradeId",
|
|
{
|
|
preHandler: authenticate,
|
|
},
|
|
async (request, reply) => {
|
|
try {
|
|
const { tradeId } = request.params;
|
|
const userId = request.user._id;
|
|
|
|
const trade = await Trade.findOne({ _id: tradeId, userId: userId });
|
|
|
|
if (!trade) {
|
|
return reply.status(404).send({
|
|
success: false,
|
|
message: "Trade not found",
|
|
});
|
|
}
|
|
|
|
return reply.send({
|
|
success: true,
|
|
trade,
|
|
});
|
|
} catch (error) {
|
|
console.error("Error fetching trade:", error);
|
|
return reply.status(500).send({
|
|
success: false,
|
|
message: "Failed to fetch trade details",
|
|
});
|
|
}
|
|
}
|
|
);
|
|
|
|
// POST /inventory/trade/:tradeId/cancel - Cancel a pending trade
|
|
fastify.post(
|
|
"/trade/:tradeId/cancel",
|
|
{
|
|
preHandler: authenticate,
|
|
},
|
|
async (request, reply) => {
|
|
try {
|
|
const { tradeId } = request.params;
|
|
const userId = request.user._id;
|
|
const steamId = request.user.steamId;
|
|
|
|
const trade = await Trade.findOne({ _id: tradeId, userId: userId });
|
|
|
|
if (!trade) {
|
|
return reply.status(404).send({
|
|
success: false,
|
|
message: "Trade not found",
|
|
});
|
|
}
|
|
|
|
if (trade.state !== "pending") {
|
|
return reply.status(400).send({
|
|
success: false,
|
|
message: "Only pending trades can be cancelled",
|
|
});
|
|
}
|
|
|
|
// Cancel via bot manager
|
|
const botManager = getSteamBotManager();
|
|
await botManager.cancelTradeOffer(trade.offerId, trade.botId);
|
|
|
|
// Update trade status
|
|
trade.state = "canceled";
|
|
await trade.save();
|
|
|
|
// Notify via WebSocket
|
|
if (fastify.websocketManager) {
|
|
fastify.websocketManager.sendToUser(steamId, {
|
|
type: "trade_cancelled",
|
|
data: {
|
|
tradeId: trade._id,
|
|
offerId: trade.offerId,
|
|
timestamp: Date.now(),
|
|
},
|
|
});
|
|
}
|
|
|
|
return reply.send({
|
|
success: true,
|
|
message: "Trade cancelled successfully",
|
|
});
|
|
} catch (error) {
|
|
console.error("Error cancelling trade:", error);
|
|
return reply.status(500).send({
|
|
success: false,
|
|
message: "Failed to cancel trade",
|
|
});
|
|
}
|
|
}
|
|
);
|
|
|
|
// POST /inventory/trade/:tradeId/complete - Complete trade (development mode only)
|
|
fastify.post(
|
|
"/trade/:tradeId/complete",
|
|
{
|
|
preHandler: authenticate,
|
|
},
|
|
async (request, reply) => {
|
|
try {
|
|
const { tradeId } = request.params;
|
|
const userId = request.user._id;
|
|
const steamId = request.user.steamId;
|
|
|
|
// Only allow in development mode
|
|
if (
|
|
process.env.NODE_ENV !== "development" &&
|
|
process.env.BYPASS_BOT_REQUIREMENT !== "true"
|
|
) {
|
|
return reply.status(403).send({
|
|
success: false,
|
|
message: "This endpoint is only available in development mode",
|
|
});
|
|
}
|
|
|
|
const trade = await Trade.findOne({ _id: tradeId, user: userId });
|
|
|
|
if (!trade) {
|
|
return reply.status(404).send({
|
|
success: false,
|
|
message: "Trade not found",
|
|
});
|
|
}
|
|
|
|
if (trade.state !== "pending") {
|
|
return reply.status(400).send({
|
|
success: false,
|
|
message: "Only pending trades can be completed",
|
|
});
|
|
}
|
|
|
|
// Simulate trade acceptance
|
|
console.log(
|
|
`🧪 DEV MODE: Manually completing trade ${tradeId} for user ${request.user.username}`
|
|
);
|
|
|
|
// Credit user balance
|
|
request.user.balance += trade.totalValue;
|
|
await request.user.save();
|
|
|
|
// Update trade status
|
|
trade.state = "accepted";
|
|
trade.completedAt = new Date();
|
|
await trade.save();
|
|
|
|
// Create transaction record
|
|
const transaction = new Transaction({
|
|
user: userId,
|
|
type: "sale",
|
|
amount: trade.totalValue,
|
|
description: `Sold ${trade.items.length} item(s) (DEV MODE)`,
|
|
status: "completed",
|
|
metadata: {
|
|
tradeId: trade._id,
|
|
offerId: trade.offerId,
|
|
botId: trade.botId,
|
|
itemCount: trade.items.length,
|
|
verificationCode: trade.verificationCode,
|
|
isDevelopment: true,
|
|
},
|
|
});
|
|
await transaction.save();
|
|
|
|
console.log(
|
|
`✅ DEV MODE: Credited $${trade.totalValue.toFixed(2)} to user ${
|
|
request.user.username
|
|
} (Balance: $${request.user.balance.toFixed(2)})`
|
|
);
|
|
|
|
// Notify via WebSocket
|
|
if (fastify.websocketManager) {
|
|
fastify.websocketManager.sendToUser(steamId, {
|
|
type: "trade_completed",
|
|
data: {
|
|
tradeId: trade._id,
|
|
offerId: trade.offerId,
|
|
amount: trade.totalValue,
|
|
newBalance: request.user.balance,
|
|
itemCount: trade.items.length,
|
|
timestamp: Date.now(),
|
|
isDevelopment: true,
|
|
},
|
|
});
|
|
|
|
fastify.websocketManager.sendToUser(steamId, {
|
|
type: "balance_update",
|
|
data: {
|
|
balance: request.user.balance,
|
|
change: trade.totalValue,
|
|
reason: "trade_completed",
|
|
},
|
|
});
|
|
}
|
|
|
|
return reply.send({
|
|
success: true,
|
|
message: "Trade completed successfully (Development Mode)",
|
|
trade: {
|
|
tradeId: trade._id,
|
|
status: "completed",
|
|
amount: trade.totalValue,
|
|
newBalance: request.user.balance,
|
|
},
|
|
});
|
|
} catch (error) {
|
|
console.error("Error completing trade:", error);
|
|
return reply.status(500).send({
|
|
success: false,
|
|
message: "Failed to complete trade",
|
|
});
|
|
}
|
|
}
|
|
);
|
|
}
|