first commit

models/Trade.js

@@ -0,0 +1,487 @@
+import mongoose from "mongoose";
+
+/**
+ * Trade Model
+ * Tracks Steam trade offers and their states
+ */
+
+const tradeSchema = new mongoose.Schema(
+  {
+    // Trade offer ID from Steam
+    offerId: {
+      type: String,
+      required: true,
+      unique: true,
+      index: true,
+    },
+
+    // User who initiated the trade
+    userId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
+      required: true,
+      index: true,
+    },
+
+    steamId: {
+      type: String,
+      required: true,
+      index: true,
+    },
+
+    // Trade state
+    state: {
+      type: String,
+      enum: [
+        "pending", // Trade offer sent, awaiting user acceptance
+        "accepted", // User accepted, items transferred
+        "declined", // User declined the offer
+        "expired", // Trade offer expired
+        "canceled", // Trade was canceled (by us or user)
+        "failed", // Trade failed (invalid items, error, etc.)
+        "escrow", // Trade in escrow
+      ],
+      default: "pending",
+      index: true,
+    },
+
+    // Items involved in the trade
+    items: [
+      {
+        assetId: { type: String, required: true },
+        name: { type: String, required: true },
+        image: { type: String },
+        game: { type: String, enum: ["cs2", "rust"], required: true },
+        price: { type: Number, required: true },
+        marketPrice: { type: Number },
+        category: { type: String },
+        rarity: { type: String },
+        wear: { type: String },
+        statTrak: { type: Boolean, default: false },
+        souvenir: { type: Boolean, default: false },
+        phase: { type: String },
+      },
+    ],
+
+    // Financial information
+    totalValue: {
+      type: Number,
+      required: true,
+      min: 0,
+    },
+
+    fee: {
+      type: Number,
+      default: 0,
+    },
+
+    feePercentage: {
+      type: Number,
+      default: 0,
+    },
+
+    userReceives: {
+      type: Number,
+      required: true,
+    },
+
+    // User's trade URL used
+    tradeUrl: {
+      type: String,
+      required: true,
+    },
+
+    // Steam trade offer URL
+    tradeOfferUrl: {
+      type: String,
+    },
+
+    // Verification code (shown on site and in trade message)
+    verificationCode: {
+      type: String,
+      required: true,
+      index: true,
+    },
+
+    // Timestamps
+    sentAt: {
+      type: Date,
+      default: Date.now,
+      index: true,
+    },
+
+    acceptedAt: {
+      type: Date,
+    },
+
+    completedAt: {
+      type: Date,
+    },
+
+    failedAt: {
+      type: Date,
+    },
+
+    expiresAt: {
+      type: Date,
+    },
+
+    // Error information
+    errorMessage: {
+      type: String,
+    },
+
+    errorCode: {
+      type: String,
+    },
+
+    // Transaction reference (created after trade completes)
+    transactionId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Transaction",
+    },
+
+    // Session tracking
+    sessionId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Session",
+    },
+
+    // Bot information
+    botId: {
+      type: String,
+      index: true,
+    },
+
+    botUsername: {
+      type: String,
+    },
+
+    // Retry tracking
+    retryCount: {
+      type: Number,
+      default: 0,
+    },
+
+    lastRetryAt: {
+      type: Date,
+    },
+
+    // Metadata
+    metadata: {
+      type: mongoose.Schema.Types.Mixed,
+    },
+
+    // Notes (internal use)
+    notes: {
+      type: String,
+    },
+  },
+  {
+    timestamps: true,
+    collection: "trades",
+  }
+);
+
+// Indexes for common queries
+tradeSchema.index({ userId: 1, state: 1 });
+tradeSchema.index({ state: 1, sentAt: -1 });
+tradeSchema.index({ steamId: 1, state: 1 });
+tradeSchema.index({ sessionId: 1 });
+tradeSchema.index({ createdAt: -1 });
+
+// Virtual for formatted total value
+tradeSchema.virtual("formattedTotal").get(function () {
+  return `$${this.totalValue.toFixed(2)}`;
+});
+
+// Virtual for formatted user receives
+tradeSchema.virtual("formattedUserReceives").get(function () {
+  return `$${this.userReceives.toFixed(2)}`;
+});
+
+// Virtual for item count
+tradeSchema.virtual("itemCount").get(function () {
+  return this.items.length;
+});
+
+// Virtual for time elapsed
+tradeSchema.virtual("timeElapsed").get(function () {
+  const now = new Date();
+  const start = this.sentAt || this.createdAt;
+  const diff = now - start;
+  const minutes = Math.floor(diff / 60000);
+
+  if (minutes < 1) return "Just now";
+  if (minutes < 60) return `${minutes}m ago`;
+
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+});
+
+// Virtual for is expired
+tradeSchema.virtual("isExpired").get(function () {
+  if (!this.expiresAt) return false;
+  return new Date() > this.expiresAt;
+});
+
+// Virtual for is pending
+tradeSchema.virtual("isPending").get(function () {
+  return this.state === "pending";
+});
+
+// Instance methods
+
+/**
+ * Mark trade as accepted
+ */
+tradeSchema.methods.markAsAccepted = async function () {
+  this.state = "accepted";
+  this.acceptedAt = new Date();
+  return await this.save();
+};
+
+/**
+ * Mark trade as completed (after transaction created)
+ */
+tradeSchema.methods.markAsCompleted = async function (transactionId) {
+  this.state = "accepted";
+  this.completedAt = new Date();
+  if (transactionId) {
+    this.transactionId = transactionId;
+  }
+  return await this.save();
+};
+
+/**
+ * Mark trade as failed
+ */
+tradeSchema.methods.markAsFailed = async function (errorMessage, errorCode) {
+  this.state = "failed";
+  this.failedAt = new Date();
+  this.errorMessage = errorMessage;
+  if (errorCode) {
+    this.errorCode = errorCode;
+  }
+  return await this.save();
+};
+
+/**
+ * Mark trade as declined
+ */
+tradeSchema.methods.markAsDeclined = async function () {
+  this.state = "declined";
+  return await this.save();
+};
+
+/**
+ * Mark trade as expired
+ */
+tradeSchema.methods.markAsExpired = async function () {
+  this.state = "expired";
+  return await this.save();
+};
+
+/**
+ * Mark trade as canceled
+ */
+tradeSchema.methods.markAsCanceled = async function () {
+  this.state = "canceled";
+  return await this.save();
+};
+
+/**
+ * Increment retry count
+ */
+tradeSchema.methods.incrementRetry = async function () {
+  this.retryCount += 1;
+  this.lastRetryAt = new Date();
+  return await this.save();
+};
+
+/**
+ * Add note
+ */
+tradeSchema.methods.addNote = async function (note) {
+  this.notes = this.notes ? `${this.notes}\n${note}` : note;
+  return await this.save();
+};
+
+// Static methods
+
+/**
+ * Create a new trade record
+ */
+tradeSchema.statics.createTrade = async function (data) {
+  const trade = new this({
+    offerId: data.offerId,
+    userId: data.userId,
+    steamId: data.steamId,
+    state: data.state || "pending",
+    items: data.items,
+    totalValue: data.totalValue,
+    fee: data.fee || 0,
+    feePercentage: data.feePercentage || 0,
+    userReceives: data.userReceives,
+    tradeUrl: data.tradeUrl,
+    tradeOfferUrl: data.tradeOfferUrl,
+    verificationCode: data.verificationCode,
+    sentAt: data.sentAt || new Date(),
+    expiresAt: data.expiresAt,
+    sessionId: data.sessionId,
+    botId: data.botId,
+    botUsername: data.botUsername,
+    metadata: data.metadata,
+  });
+
+  return await trade.save();
+};
+
+/**
+ * Get user's trades
+ */
+tradeSchema.statics.getUserTrades = async function (userId, options = {}) {
+  const {
+    limit = 50,
+    skip = 0,
+    state = null,
+    startDate = null,
+    endDate = null,
+  } = options;
+
+  const query = { userId };
+
+  if (state) query.state = state;
+  if (startDate || endDate) {
+    query.sentAt = {};
+    if (startDate) query.sentAt.$gte = new Date(startDate);
+    if (endDate) query.sentAt.$lte = new Date(endDate);
+  }
+
+  return await this.find(query)
+    .sort({ sentAt: -1 })
+    .limit(limit)
+    .skip(skip)
+    .populate("userId", "username steamId avatar")
+    .populate("transactionId")
+    .exec();
+};
+
+/**
+ * Get trade by offer ID
+ */
+tradeSchema.statics.getByOfferId = async function (offerId) {
+  return await this.findOne({ offerId })
+    .populate("userId", "username steamId avatar")
+    .populate("transactionId")
+    .exec();
+};
+
+/**
+ * Get pending trades
+ */
+tradeSchema.statics.getPendingTrades = async function (limit = 100) {
+  return await this.find({ state: "pending" })
+    .sort({ sentAt: -1 })
+    .limit(limit)
+    .populate("userId", "username steamId avatar")
+    .exec();
+};
+
+/**
+ * Get expired trades that need cleanup
+ */
+tradeSchema.statics.getExpiredTrades = async function () {
+  const now = new Date();
+  return await this.find({
+    state: "pending",
+    expiresAt: { $lt: now },
+  }).exec();
+};
+
+/**
+ * Get trade statistics
+ */
+tradeSchema.statics.getStats = async function (userId = null) {
+  const match = userId ? { userId: new mongoose.Types.ObjectId(userId) } : {};
+
+  const stats = await this.aggregate([
+    { $match: match },
+    {
+      $group: {
+        _id: "$state",
+        count: { $sum: 1 },
+        totalValue: { $sum: "$totalValue" },
+      },
+    },
+  ]);
+
+  const result = {
+    total: 0,
+    pending: 0,
+    accepted: 0,
+    declined: 0,
+    expired: 0,
+    canceled: 0,
+    failed: 0,
+    totalValue: 0,
+    acceptedValue: 0,
+  };
+
+  stats.forEach((stat) => {
+    result.total += stat.count;
+    result.totalValue += stat.totalValue;
+
+    if (stat._id === "accepted") {
+      result.accepted = stat.count;
+      result.acceptedValue = stat.totalValue;
+    } else if (stat._id === "pending") {
+      result.pending = stat.count;
+    } else if (stat._id === "declined") {
+      result.declined = stat.count;
+    } else if (stat._id === "expired") {
+      result.expired = stat.count;
+    } else if (stat._id === "canceled") {
+      result.canceled = stat.count;
+    } else if (stat._id === "failed") {
+      result.failed = stat.count;
+    }
+  });
+
+  return result;
+};
+
+/**
+ * Cleanup old completed trades
+ */
+tradeSchema.statics.cleanupOldTrades = async function (daysOld = 30) {
+  const cutoffDate = new Date();
+  cutoffDate.setDate(cutoffDate.getDate() - daysOld);
+
+  const result = await this.deleteMany({
+    state: { $in: ["accepted", "declined", "expired", "canceled", "failed"] },
+    completedAt: { $lt: cutoffDate },
+  });
+
+  return result.deletedCount;
+};
+
+// Pre-save hook
+tradeSchema.pre("save", function (next) {
+  // Set expires at if not set (default 10 minutes)
+  if (!this.expiresAt && this.state === "pending") {
+    this.expiresAt = new Date(Date.now() + 10 * 60 * 1000);
+  }
+  next();
+});
+
+// Ensure virtuals are included in JSON
+tradeSchema.set("toJSON", { virtuals: true });
+tradeSchema.set("toObject", { virtuals: true });
+
+const Trade = mongoose.model("Trade", tradeSchema);
+
+export default Trade;