Merge branch 'AngeloTadeucci:main' into main

src/controllers/api/artifactsController.ts

@@ -0,0 +1,23 @@
+import { upgradeMod } from "@/src/services/inventoryService";
+import { RequestHandler } from "express";
+
+// eslint-disable-next-line @typescript-eslint/no-misused-promises
+const artifactsController: RequestHandler = async (req, res) => {
+    const [data] = String(req.body).split("\n");
+    const id = req.query.accountId as string;
+
+    // TODO - salt check
+
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const parsedData = JSON.parse(data);
+
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        const upgradeModId = await upgradeMod(parsedData, id);
+        res.send(upgradeModId);
+    } catch (err) {
+        console.error("Error parsing JSON data:", err);
+    }
+};
+
+export { artifactsController };

src/controllers/api/genericUpdateController.ts

@@ -1,7 +1,30 @@
+import { updateGeneric } from "@/src/services/inventoryService";
+import { IGenericUpdate } from "@/src/types/genericUpdate";
 import { RequestHandler } from "express";
 
-const genericUpdateController: RequestHandler = (_req, res) => {
+// TODO: Nightwave evidence submission support is the only thing missing.
-    res.json({});
+// TODO: Also, you might want to test this, because I definitely didn't.
+const genericUpdateController: RequestHandler = async (request, response) => {
+    const accountId = request.query.accountId as string;
+
+    const [body] = String(request.body).split("\n");
+
+    let reply = {};
+    try {
+        const update = JSON.parse(body) as IGenericUpdate;
+        if (typeof update !== "object") {
+            throw new Error("Invalid data format");
+        }
+
+        reply = await updateGeneric(update, accountId);
+    } catch (err) {
+        console.error("Error parsing JSON data:", err);
+    }
+
+    // Response support added for when Nightwave is supported below.
+    // response.json(reply);
+
+    response.json({});
 };
 
 export { genericUpdateController };

src/controllers/api/missionInventoryUpdateController.ts

@@ -1,7 +1,9 @@
 import { RequestHandler } from "express";
 import { missionInventoryUpdate } from "@/src/services/inventoryService";
-import { MissionInventoryUpdate } from "@/src/types/missionInventoryUpdateType";
+import { combineRewardAndLootInventory, getRewards } from "@/src/services/missionInventoryUpdateService ";
+import { IMissionInventoryUpdate } from "@/src/types/missionInventoryUpdateType";
 /*
+**** INPUT ****
 - [ ]  crossPlaySetting
 - [ ]  rewardsMultiplier
 - [ ]  ActiveBoosters
@@ -25,13 +27,13 @@ import { MissionInventoryUpdate } from "@/src/types/missionInventoryUpdateType";
 - [ ]  hosts
 - [x]  ChallengeProgress
 - [ ]  SeasonChallengeHistory
-- [ ]  PS
+- [ ]  PS (Passive anti-cheat data which includes your username, module list, process list, and system name.)
 - [ ]  ActiveDojoColorResearch
-- [ ]  RewardInfo
+- [x]  RewardInfo
 - [ ]  ReceivedCeremonyMsg
 - [ ]  LastCeremonyResetDate
-- [ ]  MissionPTS
+- [ ]  MissionPTS (Used to validate the mission/alive time above.)
-- [ ]  RepHash
+- [ ]  RepHash (A hash from the replication manager/RepMgr Unknown what it does.)
 - [ ]  EndOfMatchUpload
 - [ ]  ObjectiveReached
 - [ ]  FpsAvg
@@ -45,18 +47,42 @@ const missionInventoryUpdateController: RequestHandler = async (req, res) => {
     const [data] = String(req.body).split("\n");
     const id = req.query.accountId as string;
 
-    // TODO - salt check
-
     try {
-        const parsedData = JSON.parse(data) as MissionInventoryUpdate;
+        const lootInventory = JSON.parse(data) as IMissionInventoryUpdate;
-        if (typeof parsedData !== "object" || parsedData === null) throw new Error("Invalid data format");
+        if (typeof lootInventory !== "object" || lootInventory === null) {
-        await missionInventoryUpdate(parsedData, id);
+            throw new Error("Invalid data format");
+        }
+
+        const { InventoryChanges, MissionRewards } = getRewards(lootInventory.RewardInfo);
+
+        const { combinedInventoryChanges, TotalCredits, CreditsBonus, MissionCredits, FusionPoints } =
+            combineRewardAndLootInventory(InventoryChanges, lootInventory);
+
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const InventoryJson = JSON.stringify(await missionInventoryUpdate(combinedInventoryChanges, id));
+        res.json({
+            // InventoryJson, // this part will reset game data and missions will be locked
+            MissionRewards,
+            InventoryChanges,
+            TotalCredits,
+            CreditsBonus,
+            MissionCredits,
+            ...(FusionPoints !== undefined && { FusionPoints })
+        });
     } catch (err) {
         console.error("Error parsing JSON data:", err);
     }
-
-    // TODO - get original response
-    res.json({});
 };
 
+/*
+**** OUTPUT ****
+- [x]  InventoryJson
+- [x]  MissionRewards
+- [x]  TotalCredits
+- [x]  CreditsBonus
+- [x]  MissionCredits
+- [x]  InventoryChanges
+- [x]  FusionPoints
+*/
+
 export { missionInventoryUpdateController };

src/managers/sessionManager.ts

@@ -1,10 +1,10 @@
-import { Session, FindSessionRequest } from "@/src/types/session";
+import { ISession, IFindSessionRequest } from "@/src/types/session";
 
-const sessions: Session[] = [];
+const sessions: ISession[] = [];
 
-function createNewSession(sessionData: Session, Creator: string): Session {
+function createNewSession(sessionData: ISession, Creator: string): ISession {
     const sessionId = getNewSessionID();
-    const newSession: Session = {
+    const newSession: ISession = {
         sessionId,
         creatorId: Creator,
         maxPlayers: sessionData.maxPlayers || 4,
@@ -35,15 +35,15 @@ function createNewSession(sessionData: Session, Creator: string): Session {
     return newSession;
 }
 
-function getAllSessions(): Session[] {
+function getAllSessions(): ISession[] {
     return sessions;
 }
 
-function getSessionByID(sessionId: string): Session | undefined {
+function getSessionByID(sessionId: string): ISession | undefined {
     return sessions.find(session => session.sessionId === sessionId);
 }
 
-function getSession(sessionIdOrRequest: string | FindSessionRequest): any[] {
+function getSession(sessionIdOrRequest: string | IFindSessionRequest): any[] {
     if (typeof sessionIdOrRequest === "string") {
         const session = sessions.find(session => session.sessionId === sessionIdOrRequest);
         if (session) {
@@ -58,10 +58,10 @@ function getSession(sessionIdOrRequest: string | FindSessionRequest): any[] {
         return [];
     }
 
-    const request = sessionIdOrRequest as FindSessionRequest;
+    const request = sessionIdOrRequest as IFindSessionRequest;
     const matchingSessions = sessions.filter(session => {
         for (const key in request) {
-            if (key !== "eloRating" && key !== "queryId" && request[key] !== session[key as keyof Session]) {
+            if (key !== "eloRating" && key !== "queryId" && request[key] !== session[key as keyof ISession]) {
                 return false;
             }
         }
@@ -74,7 +74,7 @@ function getSession(sessionIdOrRequest: string | FindSessionRequest): any[] {
     }));
 }
 
-function getSessionByCreatorID(creatorId: string): Session | undefined {
+function getSessionByCreatorID(creatorId: string): ISession | undefined {
     return sessions.find(session => session.creatorId === creatorId);
 }
 

src/models/inventoryModel.ts

@@ -1,7 +1,13 @@
 import { Model, Schema, Types, model } from "mongoose";
-import { FlavourItem, RawUpgrade, MiscItem, IInventoryDatabase, Booster } from "../types/inventoryTypes/inventoryTypes";
+import {
-import { Oid } from "../types/commonTypes";
+    IFlavourItem,
-import { ISuitDatabase, ISuitDocument } from "@/src/types/inventoryTypes/SuitTypes";
+    IRawUpgrade,
+    IMiscItem,
+    IInventoryDatabase,
+    IBooster
+} from "../types/inventoryTypes/inventoryTypes";
+import { IOid } from "../types/commonTypes";
+import { ISuitDatabase } from "@/src/types/inventoryTypes/SuitTypes";
 import { IWeaponDatabase } from "@/src/types/inventoryTypes/weaponTypes";
 
 const abilityOverrideSchema = new Schema({
@@ -71,10 +77,38 @@ const BoosterSchema = new Schema({
     ItemType: String
 });
 
+const RawUpgrades = new Schema({
+    ItemType: String,
+    ItemCount: Number
+});
+
+RawUpgrades.set("toJSON", {
+    transform(_document, returnedObject) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
+        returnedObject.LastAdded = { $oid: returnedObject._id.toString() } satisfies IOid;
+        delete returnedObject._id;
+        delete returnedObject.__v;
+    }
+});
+
+const Upgrade = new Schema({
+    UpgradeFingerprint: String,
+    ItemType: String
+});
+
+Upgrade.set("toJSON", {
+    transform(_document, returnedObject) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
+        returnedObject.ItemId = { $oid: returnedObject._id.toString() } satisfies IOid;
+        delete returnedObject._id;
+        delete returnedObject.__v;
+    }
+});
+
 WeaponSchema.set("toJSON", {
     transform(_document, returnedObject) {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
-        returnedObject.ItemId = { $oid: returnedObject._id.toString() } satisfies Oid;
+        returnedObject.ItemId = { $oid: returnedObject._id.toString() } satisfies IOid;
         delete returnedObject._id;
         delete returnedObject.__v;
     }
@@ -130,7 +164,7 @@ const suitSchema = new Schema<ISuitDatabase>({
 suitSchema.set("toJSON", {
     transform(_document, returnedObject) {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
-        returnedObject.ItemId = { $oid: returnedObject._id.toString() } satisfies Oid;
+        returnedObject.ItemId = { $oid: returnedObject._id.toString() } satisfies IOid;
         delete returnedObject._id;
         delete returnedObject.__v;
     }
@@ -181,7 +215,7 @@ const inventorySchema = new Schema<IInventoryDatabase, InventoryDocumentProps>({
     MiscItems: [Schema.Types.Mixed],
     ChallengesFixVersion: Number,
     ChallengeProgress: [Schema.Types.Mixed],
-    RawUpgrades: [Schema.Types.Mixed],
+    RawUpgrades: [RawUpgrades],
     ReceivedStartingGear: Boolean,
     Suits: [suitSchema],
     LongGuns: [WeaponSchema],
@@ -203,7 +237,7 @@ const inventorySchema = new Schema<IInventoryDatabase, InventoryDocumentProps>({
     PendingRecipes: [Schema.Types.Mixed],
     TrainingDate: Schema.Types.Mixed,
     PlayerLevel: Number,
-    Upgrades: [Schema.Types.Mixed],
+    Upgrades: [Upgrade],
     EquippedGear: [String],
     DeathMarks: [String],
     FusionTreasures: [Schema.Types.Mixed],
@@ -338,13 +372,13 @@ type InventoryDocumentProps = {
     LongGuns: Types.DocumentArray<IWeaponDatabase>;
     Pistols: Types.DocumentArray<IWeaponDatabase>;
     Melee: Types.DocumentArray<IWeaponDatabase>;
-    FlavourItems: Types.DocumentArray<FlavourItem>;
+    FlavourItems: Types.DocumentArray<IFlavourItem>;
-    RawUpgrades: Types.DocumentArray<RawUpgrade>;
+    RawUpgrades: Types.DocumentArray<IRawUpgrade>;
-    MiscItems: Types.DocumentArray<MiscItem>;
+    MiscItems: Types.DocumentArray<IMiscItem>;
-    Boosters: Types.DocumentArray<Booster>;
+    Boosters: Types.DocumentArray<IBooster>;
 };
 
-type InventoryModelType = Model<IInventoryDatabase, {}, InventoryDocumentProps>;
+type InventoryModelType = Model<IInventoryDatabase, object, InventoryDocumentProps>;
 
 const Inventory = model<IInventoryDatabase, InventoryModelType>("Inventory", inventorySchema);
 

src/models/shipModel.ts

@@ -1,6 +1,6 @@
 import { Schema, model } from "mongoose";
 import { IShip } from "../types/shipTypes";
-import { Oid } from "../types/commonTypes";
+import { IOid } from "../types/commonTypes";
 
 const roomSchema = new Schema(
     {
@@ -19,7 +19,7 @@ const shipSchema = new Schema({
 shipSchema.set("toJSON", {
     transform(_document, returnedObject) {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
-        returnedObject.ShipId = { $oid: returnedObject._id.toString() } satisfies Oid;
+        returnedObject.ShipId = { $oid: returnedObject._id.toString() } satisfies IOid;
         delete returnedObject._id;
     }
 });

src/routes/api.ts

@@ -29,6 +29,7 @@ import { updateSessionGetController, updateSessionPostController } from "@/src/c
 import { viewController } from "@/src/controllers/api/viewController";
 import { joinSessionController } from "@/src/controllers/api/joinSessionController";
 import { saveLoadoutController } from "@/src/controllers/api/saveLoadout";
+import { artifactsController } from "../controllers/api/artifactsController";
 
 import express from "express";
 
@@ -58,6 +59,7 @@ apiRouter.get("/deleteSession.php", deleteSessionController);
 apiRouter.get("/logout.php", logoutController);
 
 // post
+apiRouter.post("/artifacts.php", artifactsController);
 apiRouter.post("/findSessions.php", findSessionsController);
 // eslint-disable-next-line @typescript-eslint/no-misused-promises
 apiRouter.post("/purchase.php", purchaseController);

src/services/inventoryService.ts

@@ -5,13 +5,17 @@ import { Types } from "mongoose";
 import { ISuitResponse } from "@/src/types/inventoryTypes/SuitTypes";
 import { SlotType } from "@/src/types/purchaseTypes";
 import { IWeaponResponse } from "@/src/types/inventoryTypes/weaponTypes";
-import { ChallengeProgress, FlavourItem, IInventoryDatabaseDocument } from "@/src/types/inventoryTypes/inventoryTypes";
 import {
-    MissionInventoryUpdate,
+    IChallengeProgress,
-    MissionInventoryUpdateCard,
+    IConsumable,
-    MissionInventoryUpdateGear,
+    ICrewShipSalvagedWeaponSkin,
-    MissionInventoryUpdateItem
+    IFlavourItem,
-} from "../types/missionInventoryUpdateType";
+    IInventoryDatabaseDocument,
+    IMiscItem,
+    IRawUpgrade
+} from "@/src/types/inventoryTypes/inventoryTypes";
+import { IMissionInventoryUpdate, IMissionInventoryUpdateGear } from "../types/missionInventoryUpdateType";
+import { IGenericUpdate } from "../types/genericUpdate";
 
 const createInventory = async (accountOwnerId: Types.ObjectId) => {
     try {
@@ -76,6 +80,27 @@ export const updateCurrency = async (price: number, usePremium: boolean, account
     return { [currencyName]: -price };
 };
 
+// TODO: AffiliationMods support (Nightwave).
+export const updateGeneric = async (data: IGenericUpdate, accountId: string) => {
+    const inventory = await getInventory(accountId);
+
+    // Make it an array for easier parsing.
+    if (typeof data.NodeIntrosCompleted === "string") {
+        data.NodeIntrosCompleted = [data.NodeIntrosCompleted];
+    }
+
+    // Combine the two arrays into one.
+    data.NodeIntrosCompleted = inventory.NodeIntrosCompleted.concat(data.NodeIntrosCompleted);
+
+    // Remove duplicate entries.
+    const nodes = [...new Set(data.NodeIntrosCompleted)];
+
+    inventory.NodeIntrosCompleted = nodes;
+    await inventory.save();
+
+    return data;
+};
+
 export type WeaponTypeInternal = "LongGuns" | "Pistols" | "Melee";
 
 export const addWeapon = async (
@@ -104,7 +129,7 @@ export const addWeapon = async (
     return changedInventory[weaponType][weaponIndex - 1].toJSON();
 };
 
-export const addCustomization = async (customizatonName: string, accountId: string): Promise<FlavourItem> => {
+export const addCustomization = async (customizatonName: string, accountId: string): Promise<IFlavourItem> => {
     const inventory = await getInventory(accountId);
 
     const flavourItemIndex = inventory.FlavourItems.push({ ItemType: customizatonName }) - 1;
@@ -114,13 +139,13 @@ export const addCustomization = async (customizatonName: string, accountId: stri
 
 const addGearExpByCategory = (
     inventory: IInventoryDatabaseDocument,
-    gearArray: MissionInventoryUpdateGear[] | undefined,
+    gearArray: IMissionInventoryUpdateGear[] | undefined,
     categoryName: "Pistols" | "LongGuns" | "Melee" | "Suits"
 ) => {
     const category = inventory[categoryName];
 
     gearArray?.forEach(({ ItemId, XP }) => {
-        const itemIndex = category.findIndex(i => i._id?.equals(ItemId.$oid));
+        const itemIndex = category.findIndex(item => item._id?.equals(ItemId.$oid));
         const item = category[itemIndex];
 
         if (itemIndex !== -1 && item.XP != undefined) {
@@ -130,26 +155,66 @@ const addGearExpByCategory = (
     });
 };
 
-const addItemsByCategory = (
+const addMiscItems = (inventory: IInventoryDatabaseDocument, itemsArray: IMiscItem[] | undefined) => {
-    inventory: IInventoryDatabaseDocument,
+    const { MiscItems } = inventory;
-    itemsArray: (MissionInventoryUpdateItem | MissionInventoryUpdateCard)[] | undefined,
-    categoryName: "RawUpgrades" | "MiscItems"
-) => {
-    const category = inventory[categoryName];
 
     itemsArray?.forEach(({ ItemCount, ItemType }) => {
-        const itemIndex = category.findIndex(i => i.ItemType === ItemType);
+        const itemIndex = MiscItems.findIndex(miscItem => miscItem.ItemType === ItemType);
 
         if (itemIndex !== -1) {
-            category[itemIndex].ItemCount += ItemCount;
+            MiscItems[itemIndex].ItemCount += ItemCount;
-            inventory.markModified(`${categoryName}.${itemIndex}.ItemCount`);
+            inventory.markModified(`MiscItems.${itemIndex}.ItemCount`);
         } else {
-            category.push({ ItemCount, ItemType });
+            MiscItems.push({ ItemCount, ItemType });
         }
     });
 };
 
-const addChallenges = (inventory: IInventoryDatabaseDocument, itemsArray: ChallengeProgress[] | undefined) => {
+const addConsumables = (inventory: IInventoryDatabaseDocument, itemsArray: IConsumable[] | undefined) => {
+    const { Consumables } = inventory;
+
+    itemsArray?.forEach(({ ItemCount, ItemType }) => {
+        const itemIndex = Consumables.findIndex(i => i.ItemType === ItemType);
+
+        if (itemIndex !== -1) {
+            Consumables[itemIndex].ItemCount += ItemCount;
+            inventory.markModified(`Consumables.${itemIndex}.ItemCount`);
+        } else {
+            Consumables.push({ ItemCount, ItemType });
+        }
+    });
+};
+
+const addRecipes = (inventory: IInventoryDatabaseDocument, itemsArray: IConsumable[] | undefined) => {
+    const { Recipes } = inventory;
+
+    itemsArray?.forEach(({ ItemCount, ItemType }) => {
+        const itemIndex = Recipes.findIndex(i => i.ItemType === ItemType);
+
+        if (itemIndex !== -1) {
+            Recipes[itemIndex].ItemCount += ItemCount;
+            inventory.markModified(`Recipes.${itemIndex}.ItemCount`);
+        } else {
+            Recipes.push({ ItemCount, ItemType });
+        }
+    });
+};
+
+const addMods = (inventory: IInventoryDatabaseDocument, itemsArray: IRawUpgrade[] | undefined) => {
+    const { RawUpgrades } = inventory;
+    itemsArray?.forEach(({ ItemType, ItemCount }) => {
+        const itemIndex = RawUpgrades.findIndex(i => i.ItemType === ItemType);
+
+        if (itemIndex !== -1) {
+            RawUpgrades[itemIndex].ItemCount += ItemCount;
+            inventory.markModified(`RawUpgrades.${itemIndex}.ItemCount`);
+        } else {
+            RawUpgrades.push({ ItemCount, ItemType });
+        }
+    });
+};
+
+const addChallenges = (inventory: IInventoryDatabaseDocument, itemsArray: IChallengeProgress[] | undefined) => {
     const category = inventory.ChallengeProgress;
 
     itemsArray?.forEach(({ Name, Progress }) => {
@@ -167,32 +232,37 @@ const addChallenges = (inventory: IInventoryDatabaseDocument, itemsArray: Challe
 const gearKeys = ["Suits", "Pistols", "LongGuns", "Melee"] as const;
 type GearKeysType = (typeof gearKeys)[number];
 
-export const missionInventoryUpdate = async (data: MissionInventoryUpdate, accountId: string): Promise<void> => {
+export const missionInventoryUpdate = async (data: IMissionInventoryUpdate, accountId: string) => {
-    const { RawUpgrades, MiscItems, RegularCredits, ChallengeProgress } = data;
+    const { RawUpgrades, MiscItems, RegularCredits, ChallengeProgress, FusionPoints, Consumables, Recipes } = data;
     const inventory = await getInventory(accountId);
 
-    // TODO - multipliers logic
     // credits
     inventory.RegularCredits += RegularCredits || 0;
 
-    // gear exp
+    // endo
+    inventory.FusionPoints += FusionPoints || 0;
+
+    // Gear XP
     gearKeys.forEach((key: GearKeysType) => addGearExpByCategory(inventory, data[key], key));
 
     // other
-    addItemsByCategory(inventory, RawUpgrades, "RawUpgrades"); // TODO - check mods fusion level
+    addMods(inventory, RawUpgrades);
-    addItemsByCategory(inventory, MiscItems, "MiscItems");
+    addMiscItems(inventory, MiscItems);
+    addConsumables(inventory, Consumables);
+    addRecipes(inventory, Recipes);
     addChallenges(inventory, ChallengeProgress);
 
-    await inventory.save();
+    const changedInventory = await inventory.save();
+    return changedInventory.toJSON();
 };
 
 export const addBooster = async (ItemType: string, time: number, accountId: string): Promise<void> => {
-    const currentTime = Math.floor(Date.now() / 1000) - 129600; // booster time getting more without 129600, probably defence logic, idk
+    const currentTime = Math.floor(Date.now() / 1000) - 129600; // Value is wrong without 129600. Figure out why, please. :)
 
     const inventory = await getInventory(accountId);
     const { Boosters } = inventory;
 
-    const itemIndex = Boosters.findIndex(i => i.ItemType === ItemType);
+    const itemIndex = Boosters.findIndex(booster => booster.ItemType === ItemType);
 
     if (itemIndex !== -1) {
         const existingBooster = Boosters[itemIndex];
@@ -205,4 +275,62 @@ export const addBooster = async (ItemType: string, time: number, accountId: stri
     await inventory.save();
 };
 
+export const upgradeMod = async (
+    {
+        Upgrade,
+        LevelDiff,
+        Cost,
+        FusionPointCost
+    }: { Upgrade: ICrewShipSalvagedWeaponSkin; LevelDiff: number; Cost: number; FusionPointCost: number },
+    accountId: string
+): Promise<string | undefined> => {
+    try {
+        const inventory = await getInventory(accountId);
+        const { Upgrades, RawUpgrades } = inventory;
+        const { ItemType, UpgradeFingerprint, ItemId } = Upgrade;
+
+        const safeUpgradeFingerprint = UpgradeFingerprint || '{"lvl":0}';
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const parsedUpgradeFingerprint = JSON.parse(safeUpgradeFingerprint);
+        parsedUpgradeFingerprint.lvl += LevelDiff;
+        const stringifiedUpgradeFingerprint = JSON.stringify(parsedUpgradeFingerprint);
+
+        let itemIndex = Upgrades.findIndex(upgrade => upgrade._id?.equals(ItemId!.$oid));
+
+        if (itemIndex !== -1) {
+            Upgrades[itemIndex].UpgradeFingerprint = stringifiedUpgradeFingerprint;
+            inventory.markModified(`Upgrades.${itemIndex}.UpgradeFingerprint`);
+        } else {
+            itemIndex =
+                Upgrades.push({
+                    UpgradeFingerprint: stringifiedUpgradeFingerprint,
+                    ItemType
+                }) - 1;
+
+            const rawItemIndex = RawUpgrades.findIndex(rawUpgrade => rawUpgrade.ItemType === ItemType);
+            RawUpgrades[rawItemIndex].ItemCount--;
+            if (RawUpgrades[rawItemIndex].ItemCount > 0) {
+                inventory.markModified(`RawUpgrades.${rawItemIndex}.UpgradeFingerprint`);
+            } else {
+                RawUpgrades.splice(rawItemIndex, 1);
+            }
+        }
+
+        inventory.RegularCredits -= Cost;
+        inventory.FusionPoints -= FusionPointCost;
+
+        const changedInventory = await inventory.save();
+        const itemId = changedInventory.toJSON().Upgrades[itemIndex]?.ItemId?.$oid;
+
+        if (!itemId) {
+            throw new Error("Item Id not found in upgradeMod");
+        }
+
+        return itemId;
+    } catch (error) {
+        console.error("Error in upgradeMod:", error);
+        throw error;
+    }
+};
+
 export { createInventory, addPowerSuit };

src/services/missionInventoryUpdateService .ts

@@ -0,0 +1,249 @@
+import {
+    IMissionInventoryUpdate,
+    IMissionInventoryUpdateRewardInfo,
+    IMissionRewardResponse,
+    IReward,
+    IInventoryFieldType,
+    inventoryFields
+} from "@/src/types/missionInventoryUpdateType";
+
+import missionsDropTable from "@/static/json/missions-drop-table.json";
+import { modNames, relicNames, miscNames, resourceNames, gearNames, blueprintNames } from "@/static/data/items";
+
+// need reverse engineer rewardSeed, otherwise ingame displayed rotation reward will be different than added to db or displayed on mission end
+const getRewards = (
+    rewardInfo: IMissionInventoryUpdateRewardInfo | undefined
+): { InventoryChanges: IMissionInventoryUpdate; MissionRewards: IMissionRewardResponse[] } => {
+    if (!rewardInfo) {
+        return { InventoryChanges: {}, MissionRewards: [] };
+    }
+
+    const rewards = (missionsDropTable as { [key: string]: IReward[] })[rewardInfo.node];
+    if (!rewards) {
+        return { InventoryChanges: {}, MissionRewards: [] };
+    }
+
+    const rotationCount = rewardInfo.rewardQualifications?.length || 0;
+    const rotations = getRotations(rotationCount);
+    const drops: IReward[] = [];
+    for (const rotation of rotations) {
+        const rotationRewards = rewards.filter(reward => reward.rotation === rotation);
+
+        // Separate guaranteed and chance drops
+        const guaranteedDrops: IReward[] = [];
+        const chanceDrops: IReward[] = [];
+        for (const reward of rotationRewards) {
+            if (reward.chance === 100) {
+                guaranteedDrops.push(reward);
+            } else {
+                chanceDrops.push(reward);
+            }
+        }
+
+        const randomDrop = getRandomRewardByChance(chanceDrops);
+        if (randomDrop) {
+            guaranteedDrops.push(randomDrop);
+        }
+
+        drops.push(...guaranteedDrops);
+    }
+
+    // const testDrops = [
+    //     { chance: 7.69, name: "Lith W3 Relic", rotation: "B" },
+    //     { chance: 7.69, name: "Lith W3 Relic", rotation: "B" },
+    //     { chance: 10.82, name: "2X Orokin Cell", rotation: "C" },
+    //     { chance: 10.82, name: "Arrow Mutation", rotation: "C" },
+    //     { chance: 10.82, name: "200 Endo", rotation: "C" },
+    //     { chance: 10.82, name: "2,000,000 Credits Cache", rotation: "C" },
+    //     { chance: 7.69, name: "Health Restore (Large)", rotation: "C" },
+    //     { chance: 7.69, name: "Vapor Specter Blueprint", rotation: "C" }
+    // ];
+    // console.log("Mission rewards:", testDrops);
+    // return formatRewardsToInventoryType(testDrops);
+
+    console.log("Mission rewards:", drops);
+    return formatRewardsToInventoryType(drops);
+};
+
+const combineRewardAndLootInventory = (
+    rewardInventory: IMissionInventoryUpdate,
+    lootInventory: IMissionInventoryUpdate
+) => {
+    const missionCredits = lootInventory.RegularCredits || 0;
+    const creditsBonus = rewardInventory.RegularCredits || 0;
+    const totalCredits = missionCredits + creditsBonus;
+    const FusionPoints = (lootInventory.FusionPoints || 0) + (rewardInventory.FusionPoints || 0) || undefined;
+
+    lootInventory.RegularCredits = totalCredits;
+    if (FusionPoints) {
+        lootInventory.FusionPoints = FusionPoints;
+    }
+    inventoryFields.forEach((field: IInventoryFieldType) => {
+        if (rewardInventory[field] && !lootInventory[field]) {
+            lootInventory[field] = [];
+        }
+        rewardInventory[field]?.forEach(item => lootInventory[field]!.push(item));
+    });
+
+    return {
+        combinedInventoryChanges: lootInventory,
+        TotalCredits: [totalCredits, totalCredits],
+        CreditsBonus: [creditsBonus, creditsBonus],
+        MissionCredits: [missionCredits, missionCredits],
+        ...(FusionPoints !== undefined && { FusionPoints })
+    };
+};
+
+const getRotations = (rotationCount: number): (string | undefined)[] => {
+    if (rotationCount === 0) return [undefined];
+
+    const rotationPattern = ["A", "A", "B", "C"];
+    let rotationIndex = 0;
+    const rotatedValues = [];
+
+    for (let i = 1; i <= rotationCount; i++) {
+        rotatedValues.push(rotationPattern[rotationIndex]);
+        rotationIndex = (rotationIndex + 1) % 3;
+    }
+
+    return rotatedValues;
+};
+
+const getRandomRewardByChance = (data: IReward[] | undefined): IReward | undefined => {
+    if (!data || data.length == 0) return;
+
+    const totalChance = data.reduce((sum, item) => sum + item.chance, 0);
+    const randomValue = Math.random() * totalChance;
+
+    let cumulativeChance = 0;
+    for (const item of data) {
+        cumulativeChance += item.chance;
+        if (randomValue <= cumulativeChance) {
+            return item;
+        }
+    }
+
+    return;
+};
+
+const formatRewardsToInventoryType = (
+    rewards: IReward[]
+): { InventoryChanges: IMissionInventoryUpdate; MissionRewards: IMissionRewardResponse[] } => {
+    const InventoryChanges: IMissionInventoryUpdate = {};
+    const MissionRewards: IMissionRewardResponse[] = [];
+    for (const reward of rewards) {
+        if (itemCheck(InventoryChanges, MissionRewards, reward.name)) {
+            continue;
+        }
+
+        if (reward.name.includes(" Endo")) {
+            if (!InventoryChanges.FusionPoints) {
+                InventoryChanges.FusionPoints = 0;
+            }
+            InventoryChanges.FusionPoints += getCountFromName(reward.name);
+        } else if (reward.name.includes(" Credits Cache") || reward.name.includes("Return: ")) {
+            if (!InventoryChanges.RegularCredits) {
+                InventoryChanges.RegularCredits = 0;
+            }
+            InventoryChanges.RegularCredits += getCountFromName(reward.name);
+        }
+    }
+    return { InventoryChanges, MissionRewards };
+};
+
+const itemCheck = (
+    InventoryChanges: IMissionInventoryUpdate,
+    MissionRewards: IMissionRewardResponse[],
+    name: string
+) => {
+    const rewardCheck = {
+        RawUpgrades: modNames[name],
+        Consumables: gearNames[name],
+        MiscItems:
+            miscNames[name] ||
+            miscNames[name.replace(/\d+X\s*/, "")] ||
+            resourceNames[name] ||
+            resourceNames[name.replace(/\d+X\s*/, "")] ||
+            relicNames[name.replace("Relic", "Intact")] ||
+            relicNames[name.replace("Relic (Radiant)", "Radiant")],
+        Recipes: blueprintNames[name]
+    };
+    for (const key of Object.keys(rewardCheck) as IInventoryFieldType[]) {
+        if (rewardCheck[key]) {
+            addRewardResponse(InventoryChanges, MissionRewards, name, rewardCheck[key]!, key);
+            return true;
+        }
+    }
+    return false;
+};
+
+const getCountFromName = (name: string) => {
+    const regex = /(^(?:\d{1,3}(?:,\d{3})*(?:\.\d+)?)(\s|X))|(\s(?:\d{1,3}(?:,\d{3})*(?:\.\d+)?)$)/;
+    const countMatches = name.match(regex);
+    return countMatches ? parseInt(countMatches[0].replace(/,/g, ""), 10) : 1;
+};
+
+const addRewardResponse = (
+    InventoryChanges: IMissionInventoryUpdate,
+    MissionRewards: IMissionRewardResponse[],
+    ItemName: string,
+    ItemType: string,
+    InventoryCategory: IInventoryFieldType
+) => {
+    if (!ItemType) return;
+
+    if (!InventoryChanges[InventoryCategory]) {
+        InventoryChanges[InventoryCategory] = [];
+    }
+
+    const ItemCount = getCountFromName(ItemName);
+    const TweetText = `${ItemName}`;
+
+    const existReward = InventoryChanges[InventoryCategory]!.find(item => item.ItemType === ItemType);
+    if (existReward) {
+        existReward.ItemCount += ItemCount;
+        const missionReward = MissionRewards.find(missionReward => missionReward.TypeName === ItemType);
+        if (missionReward) {
+            missionReward.ItemCount += ItemCount;
+        }
+    } else {
+        InventoryChanges[InventoryCategory]!.push({ ItemType, ItemCount });
+        MissionRewards.push({
+            ItemCount,
+            TweetText,
+            ProductCategory: InventoryCategory,
+            StoreItem: ItemType.replace("/Lotus/", "/Lotus/StoreItems/"),
+            TypeName: ItemType
+        });
+    }
+};
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const _missionRewardsCheckAllNamings = () => {
+    let tempRewards: IReward[] = [];
+    Object.values(missionsDropTable as { [key: string]: IReward[] }).forEach(rewards => {
+        rewards.forEach(reward => {
+            tempRewards.push(reward);
+        });
+    });
+    tempRewards = tempRewards
+        .filter(reward => !modNames[reward.name])
+        .filter(reward => !miscNames[reward.name])
+        .filter(reward => !miscNames[reward.name.replace(/\d+X\s*/, "")])
+        .filter(reward => !resourceNames[reward.name])
+        .filter(reward => !resourceNames[reward.name.replace(/\d+X\s*/, "")])
+        .filter(reward => !gearNames[reward.name])
+        .filter(reward => {
+            return (
+                !relicNames[reward.name.replace("Relic", "Intact")] &&
+                !relicNames[reward.name.replace("Relic (Radiant)", "Radiant")]
+            );
+        })
+        .filter(reward => !blueprintNames[reward.name])
+        .filter(reward => !reward.name.includes(" Endo"))
+        .filter(reward => !reward.name.includes(" Credits Cache") && !reward.name.includes("Return: "));
+    console.log(tempRewards);
+};
+// _missionRewardsCheckAllNamings();
+
+export { getRewards, combineRewardAndLootInventory };

src/types/commonTypes.ts

@@ -1,3 +1,3 @@
-export interface Oid {
+export interface IOid {
     $oid: string;
 }

src/types/genericUpdate.ts

@@ -0,0 +1,4 @@
+export interface IGenericUpdate {
+    NodeIntrosCompleted: string | string[];
+    // AffiliationMods: any[];
+}

src/types/inventoryTypes/SuitTypes.ts

@@ -1,5 +1,5 @@
-import { Oid } from "@/src/types/commonTypes";
+import { IOid } from "@/src/types/commonTypes";
-import { AbilityOverride, Color, Polarity } from "@/src/types/inventoryTypes/commonInventoryTypes";
+import { IAbilityOverride, IColor, IPolarity } from "@/src/types/inventoryTypes/commonInventoryTypes";
 import { Document, Types } from "mongoose";
 
 // export interface ISuitDocument extends ISuitResponse, Document {}
@@ -8,7 +8,7 @@ export interface ISuitDocument extends Document, ISuitResponse {
 }
 
 export interface ISuitResponse extends ISuitDatabase {
-    ItemId: Oid;
+    ItemId: IOid;
 }
 
 export interface ISuitDatabase {
@@ -18,7 +18,7 @@ export interface ISuitDatabase {
     XP?: number;
     InfestationDate?: Date;
     Features?: number;
-    Polarity?: Polarity[];
+    Polarity?: IPolarity[];
     Polarized?: number;
     ModSlotPurchases?: number;
     FocusLens?: string;
@@ -28,14 +28,14 @@ export interface ISuitDatabase {
 
 export interface SuitConfig {
     Skins?: string[];
-    pricol?: Color;
+    pricol?: IColor;
-    attcol?: Color;
+    attcol?: IColor;
-    eyecol?: Color;
+    eyecol?: IColor;
-    sigcol?: Color;
+    sigcol?: IColor;
     Upgrades?: string[];
     Songs?: Song[];
     Name?: string;
-    AbilityOverride?: AbilityOverride;
+    AbilityOverride?: IAbilityOverride;
     PvpUpgrades?: string[];
     ugly?: boolean;
 }

src/types/inventoryTypes/commonInventoryTypes.ts

@@ -1,4 +1,4 @@
-export interface Polarity {
+export interface IPolarity {
     Slot: number;
     Value: FocusSchool;
 }
@@ -15,7 +15,7 @@ export enum FocusSchool {
     ApWard = "AP_WARD"
 }
 
-export interface Color {
+export interface IColor {
     t0?: number;
     t1?: number;
     t2?: number;
@@ -26,16 +26,17 @@ export interface Color {
     m1?: number;
 }
 
-export interface AbilityOverride {
+export interface IAbilityOverride {
     Ability: string;
     Index: number;
 }
 
-export interface SlotsBin {
+export interface ISlotsBin {
     Slots: number;
 }
 
-export interface sigcol {
+// ISigCol? IsIgCoL? ISIGCOL!
+export interface Isigcol {
     t0: number;
     t1: number;
     en: number;

src/types/inventoryTypes/weaponTypes.ts

@@ -1,9 +1,9 @@
-import { Oid } from "@/src/types/commonTypes";
+import { IOid } from "@/src/types/commonTypes";
-import { Color, Polarity } from "@/src/types/inventoryTypes/commonInventoryTypes";
+import { IColor, IPolarity } from "@/src/types/inventoryTypes/commonInventoryTypes";
 import { Types } from "mongoose";
 
 export interface IWeaponResponse extends IWeaponDatabase {
-    ItemId: Oid;
+    ItemId: IOid;
 }
 
 export interface IWeaponDatabase {
@@ -13,7 +13,7 @@ export interface IWeaponDatabase {
     XP?: number;
     Features?: number;
     Polarized?: number;
-    Polarity?: Polarity[];
+    Polarity?: IPolarity[];
     FocusLens?: string;
     ModSlotPurchases?: number;
     UpgradeType?: string;
@@ -26,15 +26,15 @@ export interface IWeaponDatabase {
 
 export interface WeaponConfig {
     Skins?: string[];
-    pricol?: Color;
+    pricol?: IColor;
     Upgrades?: string[];
-    attcol?: Color;
+    attcol?: IColor;
-    eyecol?: OperatorLoadOutSigcol;
+    eyecol?: IOperatorLoadOutSigcol;
     Name?: string;
     PvpUpgrades?: string[];
 }
 
-export interface OperatorLoadOutSigcol {
+export interface IOperatorLoadOutSigcol {
     t0?: number;
     t1?: number;
     en?: number;

src/types/loginTypes.ts

@@ -10,7 +10,7 @@ export interface ILoginResponse extends Omit<IDatabaseAccountDocument, "email" |
     HUB: string;
 }
 
-//includes virtual id
+// Includes virtual ID
 export interface IDatabaseAccountDocument extends IDatabaseAccount {
     id: string;
 }

src/types/missionInventoryUpdateType.ts

@@ -1,17 +1,13 @@
-interface MongooseId{
+/* eslint-disable @typescript-eslint/no-explicit-any */
-    $oid: string;
+import { IOid } from "./commonTypes";
-}
+import { IDate } from "./inventoryTypes/inventoryTypes";
 
-interface ExpireDate{
+export const inventoryFields = ["RawUpgrades", "MiscItems", "Consumables", "Recipes"] as const;
-    $date: {
+export type IInventoryFieldType = (typeof inventoryFields)[number];
-        $numberLong: string;
+export interface IMissionInventoryUpdateGear {
-    }
-}
-
-export interface MissionInventoryUpdateGear{
     ItemType: string;
     ItemName: string;
-    ItemId: MongooseId;
+    ItemId: IOid;
     XP: number;
     UpgradeVer: number;
     Features: number;
@@ -19,7 +15,7 @@ export interface MissionInventoryUpdateGear{
     CustomizationSlotPurchases: number;
     ModSlotPurchases: number;
     FocusLens: string;
-    Expiry: ExpireDate;
+    Expiry: IDate;
     Polarity: any[];
     Configs: any[];
     ModularParts: any[];
@@ -28,37 +24,71 @@ export interface MissionInventoryUpdateGear{
     UpgradeFingerprint: string;
     OffensiveUpgrade: string;
     DefensiveUpgrade: string;
-    UpgradesExpiry: ExpireDate;
+    UpgradesExpiry: IDate;
     ArchonCrystalUpgrades: any[];
 }
 
-export interface MissionInventoryUpdateItem{
+export interface IMissionInventoryUpdateItem {
     ItemCount: number;
     ItemType: string;
 }
 
-export interface MissionInventoryUpdateCard extends MissionInventoryUpdateItem{
+export interface IMissionInventoryUpdateCard extends IMissionInventoryUpdateItem {
-    ItemId: MongooseId;
+    ItemId: IOid;
     UpgradeFingerprint: string;
     PendingRerollFingerprint: string;
-    LastAdded: MongooseId;
+    LastAdded: IOid;
 }
 
-interface MissionInventoryUpdateChallange{
+export interface IMissionInventoryUpdateChallange {
     Name: string;
     Progress: number;
     Completed: any[];
 }
 
-export interface MissionInventoryUpdate{
+export interface IMissionInventoryUpdateRewardInfo {
+    node: string;
+    rewardTier?: number;
+    nightmareMode?: boolean;
+    useVaultManifest?: boolean;
+    EnemyCachesFound?: number;
+    toxinOk?: boolean;
+    lostTargetWave?: number;
+    defenseTargetCount?: number;
+    EOM_AFK?: number;
+    rewardQualifications?: string;
+    PurgatoryRewardQualifications?: string;
+    rewardSeed?: number;
+}
+
+export interface IMissionInventoryUpdate {
     rewardsMultiplier?: number;
     ActiveBoosters?: any[];
-    LongGuns?: MissionInventoryUpdateGear[];
+    LongGuns?: IMissionInventoryUpdateGear[];
-    Pistols?: MissionInventoryUpdateGear[];
+    Pistols?: IMissionInventoryUpdateGear[];
-    Suits?: MissionInventoryUpdateGear[];
+    Suits?: IMissionInventoryUpdateGear[];
-    Melee?: MissionInventoryUpdateGear[];
+    Melee?: IMissionInventoryUpdateGear[];
-    RawUpgrades?: MissionInventoryUpdateCard[];
+    RawUpgrades?: IMissionInventoryUpdateItem[];
-    MiscItems?: MissionInventoryUpdateItem[];
+    MiscItems?: IMissionInventoryUpdateItem[];
+    Consumables?: IMissionInventoryUpdateItem[];
+    Recipes?: IMissionInventoryUpdateItem[];
     RegularCredits?: number;
-    ChallengeProgress?: MissionInventoryUpdateChallange[];
+    ChallengeProgress?: IMissionInventoryUpdateChallange[];
+    RewardInfo?: IMissionInventoryUpdateRewardInfo;
+    FusionPoints?: number;
+}
+
+export interface IMissionRewardResponse {
+    StoreItem?: string;
+    TypeName: string;
+    UpgradeLevel?: number;
+    ItemCount: number;
+    TweetText: string;
+    ProductCategory: string;
+}
+
+export interface IReward {
+    name: string;
+    chance: number;
+    rotation?: string;
 }

src/types/purchaseTypes.ts

@@ -1,6 +1,5 @@
-/* eslint-disable prettier/prettier */
 import { ISuitDatabase } from "@/src/types/inventoryTypes/SuitTypes";
-import { FlavourItem } from "@/src/types/inventoryTypes/inventoryTypes";
+import { IFlavourItem } from "@/src/types/inventoryTypes/inventoryTypes";
 import { IWeaponResponse } from "@/src/types/inventoryTypes/weaponTypes";
 
 export interface IPurchaseRequest {
@@ -29,7 +28,7 @@ export interface IPurchaseResponse {
         Melee?: IWeaponResponse[];
         PremiumCredits?: number;
         RegularCredits?: number;
-        FlavourItems?: FlavourItem[];
+        FlavourItems?: IFlavourItem[];
     };
 }
 

src/types/session.ts

@@ -1,4 +1,5 @@
-export interface Session {
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export interface ISession {
     sessionId: string;
     creatorId: string;
     maxPlayers: number;
@@ -26,6 +27,6 @@ export interface Session {
     fullReset: number;
 }
 
-export interface FindSessionRequest {
+export interface IFindSessionRequest {
     [key: string]: any;
 }

src/types/shipTypes.ts

@@ -1,7 +1,5 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
 import { Types } from "mongoose";
-import { Oid } from "@/src/types/commonTypes";
+import { IOid } from "@/src/types/commonTypes";
 
 export interface IShip {
     ShipOwnerId: Types.ObjectId;
@@ -10,8 +8,9 @@ export interface IShip {
 }
 
 export interface IShipClassResponse extends IShipClassDatabase {
-    ShipId: Oid;
+    ShipId: IOid;
 }
+
 export interface IShipClassDatabase {
     Rooms: IRoomsClass[];
     Features: string[];

static/data/items.ts

@@ -1,4 +1,4 @@
-import Items, { Item, Weapon } from "warframe-items";
+import Items, { Category, Item, Warframe, Weapon } from "warframe-items";
 
 type MinWeapon = Omit<Weapon, "patchlogs">;
 type MinItem = Omit<Item, "patchlogs">;
@@ -16,3 +16,45 @@ export const items: MinItem[] = new Items({ category: ["All"] }).map(item => {
     delete next.patchlogs;
     return next;
 });
+
+const getNamesObj = (category: Category) =>
+    new Items({ category: [category] }).reduce((acc, item) => {
+        acc[item.name!.replace("'S", "'s")] = item.uniqueName!;
+        return acc;
+    }, {} as ImportAssertions);
+
+export const modNames = getNamesObj("Mods");
+export const resourceNames = getNamesObj("Resources");
+export const miscNames = getNamesObj("Misc");
+export const relicNames = getNamesObj("Relics");
+export const skinNames = getNamesObj("Skins");
+export const arcaneNames = getNamesObj("Arcanes");
+export const gearNames = getNamesObj("Gear");
+
+export const craftNames: ImportAssertions = Object.fromEntries(
+    (
+        new Items({
+            category: [
+                "Warframes",
+                "Gear",
+                "Melee",
+                "Primary",
+                "Secondary",
+                "Sentinels",
+                "Misc",
+                "Arch-Gun",
+                "Arch-Melee"
+            ]
+        }) as Warframe[]
+    )
+        .flatMap(item => item.components || [])
+        .filter(item => item.drops && item.drops[0])
+        .map(item => [item.drops![0].type, item.uniqueName])
+);
+craftNames["Forma Blueprint"] = "/Lotus/Types/Recipes/Components/FormaBlueprint";
+
+export const blueprintNames: ImportAssertions = Object.fromEntries(
+    Object.keys(craftNames)
+        .filter(name => name.includes("Blueprint"))
+        .map(name => [name, craftNames[name]])
+);