OpenWF/SpaceNinjaServer
12
6
Fork 15
Code Issues 44 Pull Requests 5 Actions Packages Projects Releases Activity

saveLoadout and misc. #99

Merged
OrdisPrime merged 11 commits from saveLoadout2 into main 2023-12-14 08:34:15 -08:00
Conversation 0 Commits 11 Files Changed 36 +149 -111
5 changed files with 149 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit f271898ced - Show all commits

9
src/app.ts
View File

@ -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();
});

59
src/controllers/api/saveLoadout.ts
View File

@ -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)) {
console.log(loadout[_loadoutId].s);
for (const [loadoutId, loadoutConfig] of Object.entries(loadout)) {
// 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;

5
src/models/inventoryModels/inventoryModel.ts
View File

@ -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,

122
src/models/inventoryModels/loadoutModel.ts
View File

@ -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>({
$oid: String
});
const oidSchema = new Schema<IOid>(
{
$oid: String
},
{
_id: false
}
);
//create a mongoose schema based on interface M
const modSchema = new Schema<M>({
ItemId: {
type: oidSchema,
default: { $oid: "000000000000000000000000" }
const EquipmentSelectionSchema = new Schema<IEquipmentSelection>(
{
ItemId: {
type: oidSchema,
default: { $oid: "000000000000000000000000" }
},
mod: Number,
cus: Number
},
mod: Number,
cus: Number
{
_id: false
}
);
const loadoutConfigSchema = new Schema<ILoadoutConfigDatabase>({
PresetIcon: String,
Favorite: Boolean,
s: EquipmentSelectionSchema,
p: EquipmentSelectionSchema,
l: EquipmentSelectionSchema,
m: EquipmentSelectionSchema
});
//default initialization for
const loadoutConfigSchema = new Schema<ILoadoutConfig>(
{
PresetIcon: String,
Favorite: Boolean,
s: {},
p: {},
l: {},
m: {}
},
{
virtuals: {
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.virtual("ItemId").get(function (): string {
return this._id.toString();
});
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>;
SENTINEL: Types.DocumentArray<ILoadoutConfig>;
ARCHWING: Types.DocumentArray<ILoadoutConfig>;
NORMAL_PVP: Types.DocumentArray<ILoadoutConfig>;
LUNARO: Types.DocumentArray<ILoadoutConfig>;
OPERATOR: Types.DocumentArray<ILoadoutConfig>;
KDRIVE: Types.DocumentArray<ILoadoutConfig>;
DATAKNIFE: Types.DocumentArray<ILoadoutConfig>;
MECH: Types.DocumentArray<ILoadoutConfig>;
OPERATOR_ADULT: Types.DocumentArray<ILoadoutConfig>;
DRIFTER: Types.DocumentArray<ILoadoutConfig>;
NORMAL: Types.DocumentArray<ILoadoutConfigDatabase>;
SENTINEL: Types.DocumentArray<ILoadoutConfigDatabase>;
ARCHWING: Types.DocumentArray<ILoadoutConfigDatabase>;
NORMAL_PVP: Types.DocumentArray<ILoadoutConfigDatabase>;
LUNARO: Types.DocumentArray<ILoadoutConfigDatabase>;
OPERATOR: Types.DocumentArray<ILoadoutConfigDatabase>;
KDRIVE: Types.DocumentArray<ILoadoutConfigDatabase>;
DATAKNIFE: Types.DocumentArray<ILoadoutConfigDatabase>;
MECH: Types.DocumentArray<ILoadoutConfigDatabase>;
OPERATOR_ADULT: Types.DocumentArray<ILoadoutConfigDatabase>;
DRIFTER: Types.DocumentArray<ILoadoutConfigDatabase>;
};
type loadoutModelType = Model<ILoadoutDatabase, {}, loadoutDocumentProps>;

65
src/types/saveLoadoutTypes.ts
View File

@ -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 {
NORMAL: ILoadoutKey;
SENTINEL: ILoadoutKey;
ARCHWING: ILoadoutKey;
NORMAL_PVP: ILoadoutKey;
LUNARO: ILoadoutKey;
OPERATOR: ILoadoutKey;
KDRIVE: ILoadoutKey;
DATAKNIFE: ILoadoutKey;
MECH: ILoadoutKey;
OPERATOR_ADULT: ILoadoutKey;
DRIFTER: ILoadoutKey;
export interface ILoadoutRequest extends Omit<ILoadoutDatabase, "_id"> {}
export interface ILoadoutResponse extends ILoadoutDatabase {
ItemId: IOid;
}
export interface ILoadoutDatabase {
NORMAL: ILoadoutConfig;
SENTINEL: ILoadoutConfig;
ARCHWING: ILoadoutConfig;
NORMAL_PVP: ILoadoutConfig;
LUNARO: ILoadoutConfig;
OPERATOR: ILoadoutConfig;
KDRIVE: ILoadoutConfig;
DATAKNIFE: ILoadoutConfig;
MECH: ILoadoutConfig;
OPERATOR_ADULT: ILoadoutConfig;
DRIFTER: ILoadoutConfig;
NORMAL: ILoadoutConfigDatabase;
SENTINEL: ILoadoutConfigDatabase;
ARCHWING: ILoadoutConfigDatabase;
NORMAL_PVP: ILoadoutConfigDatabase;
LUNARO: ILoadoutConfigDatabase;
OPERATOR: ILoadoutConfigDatabase;
KDRIVE: ILoadoutConfigDatabase;
DATAKNIFE: ILoadoutConfigDatabase;
MECH: ILoadoutConfigDatabase;
OPERATOR_ADULT: ILoadoutConfigDatabase;
DRIFTER: ILoadoutConfigDatabase;
}
export interface ILoadoutKey {
[key: string]: ILoadoutConfig;
[key: string]: ILoadoutConfigClient;
}
export type ILoadoutConfigDocument = ILoadoutConfig & Document;
export interface ILoadoutConfig {
// for request and response from and to client
export interface ILoadoutConfigClient {
ItemId: IOid;
PresetIcon: string;
Favorite: boolean;
s: M;
p: M;
l: M;
m: M;
s: IEquipmentSelection;
p: IEquipmentSelection;
l: IEquipmentSelection;
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