src/app.ts

@@ -39,6 +39,15 @@ app.use("/stats", statsRouter);
 app.post("/test", async (req, _res) => {
     console.log("test hit", req.body);
     const newLoadout = new Loadout({});
+    newLoadout.NORMAL.push({
+        _id: "000000000000000000000000",
+        Favorite: false,
+        PresetIcon: "",
+        s: { ItemId: { $oid: "000000000000000000000000" }, mod: 0, cus: 0 },
+        p: { ItemId: { $oid: "000000000000000000000000" }, mod: 0, cus: 0 },
+        l: { ItemId: { $oid: "000000000000000000000000" }, mod: 0, cus: 0 },
+        m: { ItemId: { $oid: "000000000000000000000000" }, mod: 0, cus: 0 }
+    });
     await newLoadout.save();
     _res.end();
 });

src/controllers/api/saveLoadout.ts

@@ -4,17 +4,24 @@ import util from "util";
 import {
     EquipmentCategories,
     IConfigEntry,
-    ILoadout,
+    ILoadoutRequest,
     ILoadoutKey,
     ISaveLoadoutRequest,
-    ISaveLoadoutRequestNoUpgradeVer
+    ISaveLoadoutRequestNoUpgradeVer,
+    ILoadoutConfigDatabase
 } from "@/src/types/saveLoadoutTypes";
+import { LoadoutModel } from "@/src/models/inventoryModels/loadoutModel";
+import { Types } from "mongoose";
 
 export const isEmptyObject = (obj: unknown): boolean => {
     return Boolean(obj && Object.keys(obj).length === 0 && obj.constructor === Object);
 };
 
-export const handleInventoryItemConfigChange = (equipmentChanges: ISaveLoadoutRequestNoUpgradeVer) => {
+//setup default items on account creation or like originally in giveStartingItems.php
+
+//export const updateLoadout = (loadout: ISaveLoadoutRequest, accountId: string) => {};
+
+export const handleInventoryItemConfigChange = async (equipmentChanges: ISaveLoadoutRequestNoUpgradeVer) => {
     for (const [_equipmentName, _equipment] of Object.entries(equipmentChanges)) {
         const equipment = _equipment as ISaveLoadoutRequestNoUpgradeVer[keyof ISaveLoadoutRequestNoUpgradeVer];
         const equipmentName = _equipmentName as keyof ISaveLoadoutRequestNoUpgradeVer;
@@ -28,23 +35,59 @@ export const handleInventoryItemConfigChange = (equipmentChanges: ISaveLoadoutRe
             case "LoadOuts": {
                 console.log("loadout received");
 
-                for (const [_loadoutName, _loadout] of Object.entries(equipment)) {
+                for (const [_loadoutSlot, _loadout] of Object.entries(equipment)) {
+                    const loadoutSlot = _loadoutSlot as keyof ILoadoutRequest;
                     const loadout = _loadout as ILoadoutKey;
-                    const loadoutName = _loadoutName as keyof ILoadout;
 
-                    console.log(_loadoutName, loadout);
+                    //console.log("key", loadoutSlot, "value", loadout);
 
                     if (isEmptyObject(loadout)) {
                         continue;
                     }
                     // all non-empty entries are one loadout slot
-                    for (const [_loadoutId, _loadoutConfig] of Object.entries(loadout)) {
+                    for (const [loadoutId, loadoutConfig] of Object.entries(loadout)) {
-                        console.log(loadout[_loadoutId].s);
+                        // console.log("loadoutId", loadoutId, "loadoutconfig", loadoutConfig);
+                        const loadout = await LoadoutModel.findById("656a184a9cefa0e5627689af");
+                        if (!loadout) {
+                            throw new Error("loadout not found");
+                        }
+
+                        const oldLoadoutConfig = loadout[loadoutSlot].find(
+                            loadout => loadout._id.toString() === loadoutId
+                        );
+
+                        // if no config with this id exists, create a new one
+                        if (!oldLoadoutConfig) {
+                            const { ItemId, ...loadoutConfigItemIdRemoved } = loadoutConfig;
+                            loadout[loadoutSlot].push({
+                                _id: ItemId.$oid,
+                                ...loadoutConfigItemIdRemoved
+                            });
+                            await loadout.save();
+                            continue;
+                        }
+
+                        const loadoutIndex = loadout[loadoutSlot].indexOf(oldLoadoutConfig);
+
+                        if (loadoutIndex === undefined || loadoutIndex === -1) {
+                            throw new Error("loadout index not found");
+                        }
+
+                        //console.log("parent id", oldLoadoutConfig.ownerDocument()._id);
+                        loadout[loadoutSlot][loadoutIndex].set(loadoutConfig);
+                        //loadout.NORMAL[loadoutIndex].overwrite(loadoutConfig);
+                        //console.log("db", loadout[loadoutSlot][loadoutIndex].schema);
+
+                        await loadout.save();
+                        //({ _id: loadoutId }, loadoutConfig);
                     }
                 }
                 break;
             }
             case "LongGuns": {
+                console.log("longgun received");
+                console.log(equipmentName, equipment);
+
                 const longGun = equipment as IConfigEntry;
                 //   longGun["key"].PvpUpgrades;
                 break;

src/models/inventoryModels/inventoryModel.ts

@@ -152,7 +152,10 @@ suitConfigSchema.set("toJSON", {
 
 const suitSchema = new Schema<ISuitDatabase>({
     ItemType: String,
-    Configs: [suitConfigSchema],
+    Configs: {
+        type: [suitConfigSchema],
+        default: [{}, {}, {}]
+    },
     UpgradeVer: Number,
     XP: Number,
     InfestationDate: Date,

src/models/inventoryModels/loadoutModel.ts

@@ -1,67 +1,43 @@
 import { IOid } from "@/src/types/commonTypes";
-import { ILoadout, ILoadoutConfig, ILoadoutConfigDocument, ILoadoutDatabase, M } from "@/src/types/saveLoadoutTypes";
+import { ILoadoutConfigDatabase, ILoadoutDatabase, IEquipmentSelection } from "@/src/types/saveLoadoutTypes";
 import { Model, Schema, Types, model } from "mongoose";
 
-//create a schema for the $oid type
+const oidSchema = new Schema<IOid>(
-const oidSchema = new Schema<IOid>({
+    {
         $oid: String
-});
+    },
+    {
+        _id: false
+    }
+);
 
 //create a mongoose schema based on interface M
-const modSchema = new Schema<M>({
+const EquipmentSelectionSchema = new Schema<IEquipmentSelection>(
+    {
         ItemId: {
             type: oidSchema,
             default: { $oid: "000000000000000000000000" }
         },
         mod: Number,
         cus: Number
-});
+    },
-
-//default initialization for
-const loadoutConfigSchema = new Schema<ILoadoutConfig>(
     {
+        _id: false
+    }
+);
+
+const loadoutConfigSchema = new Schema<ILoadoutConfigDatabase>({
     PresetIcon: String,
     Favorite: Boolean,
-        s: {},
+    s: EquipmentSelectionSchema,
-        p: {},
+    p: EquipmentSelectionSchema,
-        l: {},
+    l: EquipmentSelectionSchema,
-        m: {}
+    m: EquipmentSelectionSchema
-    },
+});
-    {
+
-        virtuals: {
+loadoutConfigSchema.virtual("ItemId").get(function (): string {
-            ItemId: {
-                get() {
     return this._id.toString();
-                }
+});
-            }
-        }
-    }
-);
-
-interface User {
-    firstName: string;
-    lastName: string;
-}
-
-const UserSchema = new Schema(
-    {
-        firstName: String,
-        lastName: String
-    },
-    {
-        virtuals: {
-            fullname: {
-                get() {
-                    return `${this.firstName} ${this.lastName}`;
-                }
-            }
-        }
-    }
-);
-
-// loadoutConfigSchema.virtual("ItemId").get(function (): string {
-//     return this._id
-// });
 
 loadoutConfigSchema.set("toJSON", {
     virtuals: true,
@@ -85,19 +61,31 @@ const loadoutSchema = new Schema<ILoadoutDatabase, loadoutModelType>({
     DRIFTER: [loadoutConfigSchema]
 });
 
+loadoutSchema.virtual("ItemId").get(function (): string {
+    return this._id.toString();
+});
+
+loadoutSchema.set("toJSON", {
+    virtuals: true,
+    transform(_doc, ret, _options) {
+        delete ret._id;
+        delete ret.__v;
+    }
+});
+
 //create database typefor ILoadoutConfig
 type loadoutDocumentProps = {
-    NORMAL: Types.DocumentArray<ILoadoutConfig>;
+    NORMAL: Types.DocumentArray<ILoadoutConfigDatabase>;
-    SENTINEL: Types.DocumentArray<ILoadoutConfig>;
+    SENTINEL: Types.DocumentArray<ILoadoutConfigDatabase>;
-    ARCHWING: Types.DocumentArray<ILoadoutConfig>;
+    ARCHWING: Types.DocumentArray<ILoadoutConfigDatabase>;
-    NORMAL_PVP: Types.DocumentArray<ILoadoutConfig>;
+    NORMAL_PVP: Types.DocumentArray<ILoadoutConfigDatabase>;
-    LUNARO: Types.DocumentArray<ILoadoutConfig>;
+    LUNARO: Types.DocumentArray<ILoadoutConfigDatabase>;
-    OPERATOR: Types.DocumentArray<ILoadoutConfig>;
+    OPERATOR: Types.DocumentArray<ILoadoutConfigDatabase>;
-    KDRIVE: Types.DocumentArray<ILoadoutConfig>;
+    KDRIVE: Types.DocumentArray<ILoadoutConfigDatabase>;
-    DATAKNIFE: Types.DocumentArray<ILoadoutConfig>;
+    DATAKNIFE: Types.DocumentArray<ILoadoutConfigDatabase>;
-    MECH: Types.DocumentArray<ILoadoutConfig>;
+    MECH: Types.DocumentArray<ILoadoutConfigDatabase>;
-    OPERATOR_ADULT: Types.DocumentArray<ILoadoutConfig>;
+    OPERATOR_ADULT: Types.DocumentArray<ILoadoutConfigDatabase>;
-    DRIFTER: Types.DocumentArray<ILoadoutConfig>;
+    DRIFTER: Types.DocumentArray<ILoadoutConfigDatabase>;
 };
 
 type loadoutModelType = Model<ILoadoutDatabase, {}, loadoutDocumentProps>;

src/types/saveLoadoutTypes.ts

@@ -1,8 +1,8 @@
 import { IOid } from "@/src/types/commonTypes";
-import { Document, Mongoose } from "mongoose";
+import { Document, Mongoose, Types } from "mongoose";
 
 export interface ISaveLoadoutRequest {
-    LoadOuts: ILoadout;
+    LoadOuts: ILoadoutRequest;
     LongGuns: IConfigEntry;
     OperatorAmps: IConfigEntry;
     Pistols: IConfigEntry;
@@ -36,51 +36,46 @@ export interface IConfigEntry {
     [key: string]: Config;
 }
 
-export interface ILoadout {
+export interface ILoadoutRequest extends Omit<ILoadoutDatabase, "_id"> {}
-    NORMAL: ILoadoutKey;
+
-    SENTINEL: ILoadoutKey;
+export interface ILoadoutResponse extends ILoadoutDatabase {
-    ARCHWING: ILoadoutKey;
+    ItemId: IOid;
-    NORMAL_PVP: ILoadoutKey;
-    LUNARO: ILoadoutKey;
-    OPERATOR: ILoadoutKey;
-    KDRIVE: ILoadoutKey;
-    DATAKNIFE: ILoadoutKey;
-    MECH: ILoadoutKey;
-    OPERATOR_ADULT: ILoadoutKey;
-    DRIFTER: ILoadoutKey;
 }
 
 export interface ILoadoutDatabase {
-    NORMAL: ILoadoutConfig;
+    NORMAL: ILoadoutConfigDatabase;
-    SENTINEL: ILoadoutConfig;
+    SENTINEL: ILoadoutConfigDatabase;
-    ARCHWING: ILoadoutConfig;
+    ARCHWING: ILoadoutConfigDatabase;
-    NORMAL_PVP: ILoadoutConfig;
+    NORMAL_PVP: ILoadoutConfigDatabase;
-    LUNARO: ILoadoutConfig;
+    LUNARO: ILoadoutConfigDatabase;
-    OPERATOR: ILoadoutConfig;
+    OPERATOR: ILoadoutConfigDatabase;
-    KDRIVE: ILoadoutConfig;
+    KDRIVE: ILoadoutConfigDatabase;
-    DATAKNIFE: ILoadoutConfig;
+    DATAKNIFE: ILoadoutConfigDatabase;
-    MECH: ILoadoutConfig;
+    MECH: ILoadoutConfigDatabase;
-    OPERATOR_ADULT: ILoadoutConfig;
+    OPERATOR_ADULT: ILoadoutConfigDatabase;
-    DRIFTER: ILoadoutConfig;
+    DRIFTER: ILoadoutConfigDatabase;
 }
 
 export interface ILoadoutKey {
-    [key: string]: ILoadoutConfig;
+    [key: string]: ILoadoutConfigClient;
 }
 
-export type ILoadoutConfigDocument = ILoadoutConfig & Document;
+// for request and response from and to client
-
+export interface ILoadoutConfigClient {
-export interface ILoadoutConfig {
     ItemId: IOid;
     PresetIcon: string;
     Favorite: boolean;
-    s: M;
+    s: IEquipmentSelection;
-    p: M;
+    p: IEquipmentSelection;
-    l: M;
+    l: IEquipmentSelection;
-    m: M;
+    m: IEquipmentSelection;
 }
 
-export interface M {
+export interface ILoadoutConfigDatabase extends Omit<ILoadoutConfigClient, "ItemId"> {
+    _id: Types.ObjectId;
+}
+
+export interface IEquipmentSelection {
     ItemId: IOid;
     mod: number;
     cus: number;
@@ -129,7 +124,7 @@ export interface Col {
 }
 
 export type EquipmentCategories =
-    | { LoadOuts: { [key in keyof ILoadout]: LoadOut } }
+    | { LoadOuts: { [key in keyof ILoadoutRequest]: LoadOut } }
     | { LongGuns: Config }
     | { OperatorAmps: Config } // Replace 'any' with the actual type
     | { Pistols: Config } // Replace 'any' with the actual type