From a85eb5b5c0c5f6189fd3b485a83937fa815c4a12 Mon Sep 17 00:00:00 2001 From: CWX <91418059+CWXDEV@users.noreply.github.com> Date: Sun, 12 Jan 2025 16:42:09 +0000 Subject: [PATCH] new itemRouters, missing enums, fix method sigs (#41) * callbacks * controllers * Router override * make requests use interface * create Routers * extra parts * fix method sig on callbacks * add two missing enums as static classes * add missing serializers (not complete) * complete ItemEventRouters --- Core/Callbacks/InventoryCallbacks.cs | 22 ++-- Core/Models/Enums/HideoutEventActions.cs | 20 ++++ Core/Models/Enums/ItemEventActions.cs | 33 ++++++ .../CustomizationItemEventRouter.cs | 44 +++++++ .../ItemEvents/HealthItemEventRouter.cs | 47 ++++++++ .../ItemEvents/HideoutItemEventRouter.cs | 82 +++++++++++++ .../ItemEvents/InsuranceItemEventRouter.cs | 41 +++++++ .../ItemEvents/InventoryItemEventRouter.cs | 112 ++++++++++++++++++ .../Routers/ItemEvents/NoteItemEventRouter.cs | 47 ++++++++ .../ItemEvents/QuestItemEventRouter.cs | 50 ++++++++ .../ItemEvents/RagfairItemEventRouter.cs | 46 +++++++ .../ItemEvents/RepairItemEventRouter.cs | 43 +++++++ .../ItemEvents/TradeItemEventRouter.cs | 46 +++++++ .../ItemEvents/WishlistItemEventRouter.cs | 47 ++++++++ Core/Routers/Serializers/BundleSerializer.cs | 6 + Core/Routers/Serializers/NotifySerializer.cs | 6 + Core/Routers/Static/RagfairStaticRouter.cs | 88 ++++++++++++++ Core/Routers/Static/WeatherStaticRouter.cs | 41 +++++++ 18 files changed, 810 insertions(+), 11 deletions(-) create mode 100644 Core/Models/Enums/HideoutEventActions.cs create mode 100644 Core/Models/Enums/ItemEventActions.cs create mode 100644 Core/Routers/ItemEvents/CustomizationItemEventRouter.cs create mode 100644 Core/Routers/ItemEvents/HealthItemEventRouter.cs create mode 100644 Core/Routers/ItemEvents/HideoutItemEventRouter.cs create mode 100644 Core/Routers/ItemEvents/InsuranceItemEventRouter.cs create mode 100644 Core/Routers/ItemEvents/InventoryItemEventRouter.cs create mode 100644 Core/Routers/ItemEvents/NoteItemEventRouter.cs create mode 100644 Core/Routers/ItemEvents/QuestItemEventRouter.cs create mode 100644 Core/Routers/ItemEvents/RagfairItemEventRouter.cs create mode 100644 Core/Routers/ItemEvents/RepairItemEventRouter.cs create mode 100644 Core/Routers/ItemEvents/TradeItemEventRouter.cs create mode 100644 Core/Routers/ItemEvents/WishlistItemEventRouter.cs create mode 100644 Core/Routers/Serializers/BundleSerializer.cs create mode 100644 Core/Routers/Serializers/NotifySerializer.cs create mode 100644 Core/Routers/Static/RagfairStaticRouter.cs create mode 100644 Core/Routers/Static/WeatherStaticRouter.cs diff --git a/Core/Callbacks/InventoryCallbacks.cs b/Core/Callbacks/InventoryCallbacks.cs index 2ebe275b..8239571b 100644 --- a/Core/Callbacks/InventoryCallbacks.cs +++ b/Core/Callbacks/InventoryCallbacks.cs @@ -45,7 +45,7 @@ public class InventoryCallbacks /// /// /// - public ItemEventRouterResponse RemoveItem(PmcData pmcData, InventoryRemoveRequestData info, string sessionID) + public ItemEventRouterResponse RemoveItem(PmcData pmcData, InventoryRemoveRequestData info, string sessionID, ItemEventRouterResponse output) { // _inventoryController.RemoveItem(pmcData, info, sessionID, output); // TODO: InventoryController is not implemented rn @@ -60,7 +60,7 @@ public class InventoryCallbacks /// /// /// - public ItemEventRouterResponse SplitItem(PmcData pmcData, InventorySplitRequestData info, string sessionID) + public ItemEventRouterResponse SplitItem(PmcData pmcData, InventorySplitRequestData info, string sessionID, ItemEventRouterResponse output) { // _inventoryController.SplitItem(pmcData, info, sessionID, output); // TODO: InventoryController is not implemented rn @@ -75,7 +75,7 @@ public class InventoryCallbacks /// /// /// - public ItemEventRouterResponse MergeItem(PmcData pmcData, InventoryMergeRequestData info, string sessionID) + public ItemEventRouterResponse MergeItem(PmcData pmcData, InventoryMergeRequestData info, string sessionID, ItemEventRouterResponse output) { // _inventoryController.MergeItem(pmcData, info, sessionID, output); // TODO: InventoryController is not implemented rn @@ -90,7 +90,7 @@ public class InventoryCallbacks /// /// /// - public ItemEventRouterResponse TransferItem(PmcData pmcData, InventoryTransferRequestData info, string sessionID) + public ItemEventRouterResponse TransferItem(PmcData pmcData, InventoryTransferRequestData info, string sessionID, ItemEventRouterResponse output) { // _inventoryController.TransferItem(pmcData, info, sessionID, output); // TODO: InventoryController is not implemented rn @@ -165,7 +165,7 @@ public class InventoryCallbacks /// /// /// - public ItemEventRouterResponse BindItem(PmcData pmcData, InventoryBindRequestData info, string sessionID) + public ItemEventRouterResponse BindItem(PmcData pmcData, InventoryBindRequestData info, string sessionID, ItemEventRouterResponse output) { // _inventoryController.BindItem(pmcData, info, sessionID, output); // TODO: InventoryController is not implemented rn @@ -180,7 +180,7 @@ public class InventoryCallbacks /// /// /// - public ItemEventRouterResponse UnBindItem(PmcData pmcData, InventoryBindRequestData info, string sessionID) + public ItemEventRouterResponse UnBindItem(PmcData pmcData, InventoryBindRequestData info, string sessionID, ItemEventRouterResponse output) { // _inventoryController.UnBindItem(pmcData, info, sessionID, output); // TODO: InventoryController is not implemented rn @@ -195,7 +195,7 @@ public class InventoryCallbacks /// /// /// - public ItemEventRouterResponse ExamineItem(PmcData pmcData, InventoryExamineRequestData info, string sessionID) + public ItemEventRouterResponse ExamineItem(PmcData pmcData, InventoryExamineRequestData info, string sessionID, ItemEventRouterResponse output) { // _inventoryController.ExamineItem(pmcData, info, sessionID, output); // TODO: InventoryController is not implemented rn @@ -225,7 +225,7 @@ public class InventoryCallbacks /// /// /// - public ItemEventRouterResponse SortInventory(PmcData pmcData, InventorySortRequestData info, string sessionID) + public ItemEventRouterResponse SortInventory(PmcData pmcData, InventorySortRequestData info, string sessionID, ItemEventRouterResponse output) { // _inventoryController.SortInventory(pmcData, info, sessionID, output); // TODO: InventoryController is not implemented rn @@ -240,7 +240,7 @@ public class InventoryCallbacks /// /// /// - public ItemEventRouterResponse CreateMapMarker(PmcData pmcData, InventoryCreateMarkerRequestData info, string sessionID) + public ItemEventRouterResponse CreateMapMarker(PmcData pmcData, InventoryCreateMarkerRequestData info, string sessionID, ItemEventRouterResponse output) { // _inventoryController.CreateMapMarker(pmcData, info, sessionID, output); // TODO: InventoryController is not implemented rn @@ -255,7 +255,7 @@ public class InventoryCallbacks /// /// /// - public ItemEventRouterResponse DeleteMapMarker(PmcData pmcData, InventoryDeleteMarkerRequestData info, string sessionID) + public ItemEventRouterResponse DeleteMapMarker(PmcData pmcData, InventoryDeleteMarkerRequestData info, string sessionID, ItemEventRouterResponse output) { // _inventoryController.DeleteMapMarker(pmcData, info, sessionID, output); // TODO: InventoryController is not implemented rn @@ -270,7 +270,7 @@ public class InventoryCallbacks /// /// /// - public ItemEventRouterResponse EditMapMarker(PmcData pmcData, InventoryEditMarkerRequestData info, string sessionID) + public ItemEventRouterResponse EditMapMarker(PmcData pmcData, InventoryEditMarkerRequestData info, string sessionID, ItemEventRouterResponse output) { // _inventoryController.EditMapMarker(pmcData, info, sessionID, output); // TODO: InventoryController is not implemented rn diff --git a/Core/Models/Enums/HideoutEventActions.cs b/Core/Models/Enums/HideoutEventActions.cs new file mode 100644 index 00000000..d7d0662e --- /dev/null +++ b/Core/Models/Enums/HideoutEventActions.cs @@ -0,0 +1,20 @@ +namespace Core.Models.Enums; + +public class HideoutEventActions +{ + public const string HIDEOUT_UPGRADE = "HideoutUpgrade"; + public const string HIDEOUT_UPGRADE_COMPLETE = "HideoutUpgradeComplete"; + public const string HIDEOUT_PUT_ITEMS_IN_AREA_SLOTS = "HideoutPutItemsInAreaSlots"; + public const string HIDEOUT_TAKE_ITEMS_FROM_AREA_SLOTS = "HideoutTakeItemsFromAreaSlots"; + public const string HIDEOUT_TOGGLE_AREA = "HideoutToggleArea"; + public const string HIDEOUT_SINGLE_PRODUCTION_START = "HideoutSingleProductionStart"; + public const string HIDEOUT_SCAV_CASE_PRODUCTION_START = "HideoutScavCaseProductionStart"; + public const string HIDEOUT_CONTINUOUS_PRODUCTION_START = "HideoutContinuousProductionStart"; + public const string HIDEOUT_TAKE_PRODUCTION = "HideoutTakeProduction"; + public const string HIDEOUT_RECORD_SHOOTING_RANGE_POINTS = "RecordShootingRangePoints"; + public const string HIDEOUT_IMPROVE_AREA = "HideoutImproveArea"; + public const string HIDEOUT_CANCEL_PRODUCTION_COMMAND = "HideoutCancelProductionCommand"; + public const string HIDEOUT_CIRCLE_OF_CULTIST_PRODUCTION_START = "HideoutCircleOfCultistProductionStart"; + public const string HIDEOUT_DELETE_PRODUCTION_COMMAND = "HideoutDeleteProductionCommand"; + public const string HIDEOUT_CUSTOMIZATION_APPLY_COMMAND = "HideoutCustomizationApply"; +} diff --git a/Core/Models/Enums/ItemEventActions.cs b/Core/Models/Enums/ItemEventActions.cs new file mode 100644 index 00000000..e65ceb6d --- /dev/null +++ b/Core/Models/Enums/ItemEventActions.cs @@ -0,0 +1,33 @@ +namespace Core.Models.Enums; + +public class ItemEventActions +{ + public const string MOVE = "Move"; + public const string REMOVE = "Remove"; + public const string SPLIT = "Split"; + public const string MERGE = "Merge"; + public const string TRANSFER = "Transfer"; + public const string SWAP = "Swap"; + public const string FOLD = "Fold"; + public const string TOGGLE = "Toggle"; + public const string TAG = "Tag"; + public const string BIND = "Bind"; + public const string UNBIND = "Unbind"; + public const string EXAMINE = "Examine"; + public const string READ_ENCYCLOPEDIA = "ReadEncyclopedia"; + public const string APPLY_INVENTORY_CHANGES = "ApplyInventoryChanges"; + public const string CREATE_MAP_MARKER = "CreateMapMarker"; + public const string DELETE_MAP_MARKER = "DeleteMapMarker"; + public const string EDIT_MAP_MARKER = "EditMapMarker"; + public const string OPEN_RANDOM_LOOT_CONTAINER = "OpenRandomLootContainer"; + public const string HIDEOUT_QTE_EVENT = "HideoutQuickTimeEvent"; + public const string SAVE_WEAPON_BUILD = "SaveWeaponBuild"; + public const string REMOVE_WEAPON_BUILD = "RemoveWeaponBuild"; + public const string REMOVE_BUILD = "RemoveBuild"; + public const string SAVE_EQUIPMENT_BUILD = "SaveEquipmentBuild"; + public const string REMOVE_EQUIPMENT_BUILD = "RemoveEquipmentBuild"; + public const string REDEEM_PROFILE_REWARD = "RedeemProfileReward"; + public const string SET_FAVORITE_ITEMS = "SetFavoriteItems"; + public const string QUEST_FAIL = "QuestFail"; + public const string PIN_LOCK = "PinLock"; +} diff --git a/Core/Routers/ItemEvents/CustomizationItemEventRouter.cs b/Core/Routers/ItemEvents/CustomizationItemEventRouter.cs new file mode 100644 index 00000000..fc34cac3 --- /dev/null +++ b/Core/Routers/ItemEvents/CustomizationItemEventRouter.cs @@ -0,0 +1,44 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.Common; +using Core.Models.Eft.Customization; +using Core.Models.Eft.ItemEvent; + +namespace Core.Routers.ItemEvents; + +[Injectable(InjectableTypeOverride = typeof(ItemEventRouterDefinition))] +public class CustomizationItemEventRouter : ItemEventRouterDefinition +{ + protected CustomizationCallbacks _customizationCallbacks; + + public CustomizationItemEventRouter + ( + CustomizationCallbacks customizationCallbacks + ) + { + _customizationCallbacks = customizationCallbacks; + } + + protected override List GetHandledRoutes() + { + return new() + { + new HandledRoute("CustomizationBuy", false), + new HandledRoute("CustomizationSet", false) + }; + } + + public override object HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output) + { + switch (url) + { + case "CustomizationBuy": + return _customizationCallbacks.BuyClothing(pmcData, body as BuyClothingRequestData, sessionID); + case "CustomizationSet": + return _customizationCallbacks.SetClothing(pmcData, body as CustomizationSetRequest, sessionID); + default: + throw new Exception($"CustomizationItemEventRouter being used when it cant handle route {url}"); + } + } +} diff --git a/Core/Routers/ItemEvents/HealthItemEventRouter.cs b/Core/Routers/ItemEvents/HealthItemEventRouter.cs new file mode 100644 index 00000000..1b850eb1 --- /dev/null +++ b/Core/Routers/ItemEvents/HealthItemEventRouter.cs @@ -0,0 +1,47 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.Common; +using Core.Models.Eft.Health; +using Core.Models.Eft.ItemEvent; + +namespace Core.Routers.ItemEvents; + +[Injectable(InjectableTypeOverride = typeof(ItemEventRouterDefinition))] +public class HealthItemEventRouter : ItemEventRouterDefinition +{ + protected HealthCallbacks _healthCallbacks; + + public HealthItemEventRouter + ( + HealthCallbacks healthCallbacks + ) + { + _healthCallbacks = healthCallbacks; + } + + protected override List GetHandledRoutes() + { + return new() + { + new HandledRoute("Eat", false), + new HandledRoute("Heal", false), + new HandledRoute("RestoreHealth", false) + }; + } + + public override object HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output) + { + switch (url) + { + case "Eat": + return _healthCallbacks.OffraidEat(pmcData, body as OffraidEatRequestData, sessionID); + case "Heal": + return _healthCallbacks.OffraidHeal(pmcData, body as OffraidHealRequestData, sessionID); + case "RestoreHealth": + return _healthCallbacks.HealthTreatment(pmcData, body as HealthTreatmentRequestData, sessionID); + default: + throw new Exception($"HealthItemEventRouter being used when it cant handle route {url}"); + } + } +} diff --git a/Core/Routers/ItemEvents/HideoutItemEventRouter.cs b/Core/Routers/ItemEvents/HideoutItemEventRouter.cs new file mode 100644 index 00000000..43f50174 --- /dev/null +++ b/Core/Routers/ItemEvents/HideoutItemEventRouter.cs @@ -0,0 +1,82 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.Common; +using Core.Models.Eft.Hideout; +using Core.Models.Eft.ItemEvent; +using Core.Models.Enums; + +namespace Core.Routers.ItemEvents; + +[Injectable(InjectableTypeOverride = typeof(ItemEventRouterDefinition))] +public class HideoutItemEventRouter : ItemEventRouterDefinition +{ + protected HideoutCallbacks _hideoutCallbacks; + + public HideoutItemEventRouter + ( + HideoutCallbacks hideoutCallbacks) + { + _hideoutCallbacks = hideoutCallbacks; + } + + protected override List GetHandledRoutes() + { + return new() + { + new HandledRoute(HideoutEventActions.HIDEOUT_UPGRADE, false), + new HandledRoute(HideoutEventActions.HIDEOUT_UPGRADE_COMPLETE, false), + new HandledRoute(HideoutEventActions.HIDEOUT_PUT_ITEMS_IN_AREA_SLOTS, false), + new HandledRoute(HideoutEventActions.HIDEOUT_TAKE_ITEMS_FROM_AREA_SLOTS, false), + new HandledRoute(HideoutEventActions.HIDEOUT_TOGGLE_AREA, false), + new HandledRoute(HideoutEventActions.HIDEOUT_SINGLE_PRODUCTION_START, false), + new HandledRoute(HideoutEventActions.HIDEOUT_SCAV_CASE_PRODUCTION_START, false), + new HandledRoute(HideoutEventActions.HIDEOUT_CONTINUOUS_PRODUCTION_START, false), + new HandledRoute(HideoutEventActions.HIDEOUT_TAKE_PRODUCTION, false), + new HandledRoute(HideoutEventActions.HIDEOUT_RECORD_SHOOTING_RANGE_POINTS, false), + new HandledRoute(HideoutEventActions.HIDEOUT_IMPROVE_AREA, false), + new HandledRoute(HideoutEventActions.HIDEOUT_CANCEL_PRODUCTION_COMMAND, false), + new HandledRoute(HideoutEventActions.HIDEOUT_CIRCLE_OF_CULTIST_PRODUCTION_START, false), + new HandledRoute(HideoutEventActions.HIDEOUT_DELETE_PRODUCTION_COMMAND, false), + new HandledRoute(HideoutEventActions.HIDEOUT_CUSTOMIZATION_APPLY_COMMAND, false) + }; + } + + public override object HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output) + { + switch (url) { + case HideoutEventActions.HIDEOUT_UPGRADE: + return _hideoutCallbacks.Upgrade(pmcData, body as HideoutUpgradeRequestData, sessionID, output); + case HideoutEventActions.HIDEOUT_UPGRADE_COMPLETE: + return _hideoutCallbacks.UpgradeComplete(pmcData, body as HideoutUpgradeCompleteRequestData, sessionID, output); + case HideoutEventActions.HIDEOUT_PUT_ITEMS_IN_AREA_SLOTS: + return _hideoutCallbacks.PutItemsInAreaSlots(pmcData, body as HideoutPutItemInRequestData, sessionID); + case HideoutEventActions.HIDEOUT_TAKE_ITEMS_FROM_AREA_SLOTS: + return _hideoutCallbacks.TakeItemsFromAreaSlots(pmcData, body as HideoutTakeItemOutRequestData, sessionID); + case HideoutEventActions.HIDEOUT_TOGGLE_AREA: + return _hideoutCallbacks.ToggleArea(pmcData, body as HideoutToggleAreaRequestData, sessionID); + case HideoutEventActions.HIDEOUT_SINGLE_PRODUCTION_START: + return _hideoutCallbacks.SingleProductionStart(pmcData, body as HideoutSingleProductionStartRequestData, sessionID); + case HideoutEventActions.HIDEOUT_SCAV_CASE_PRODUCTION_START: + return _hideoutCallbacks.ScavCaseProductionStart(pmcData, body as HideoutScavCaseStartRequestData, sessionID); + case HideoutEventActions.HIDEOUT_CONTINUOUS_PRODUCTION_START: + return _hideoutCallbacks.ContinuousProductionStart(pmcData, body as HideoutContinuousProductionStartRequestData, sessionID); + case HideoutEventActions.HIDEOUT_TAKE_PRODUCTION: + return _hideoutCallbacks.TakeProduction(pmcData, body as HideoutTakeProductionRequestData, sessionID); + case HideoutEventActions.HIDEOUT_RECORD_SHOOTING_RANGE_POINTS: + return _hideoutCallbacks.RecordShootingRangePoints(pmcData, body as RecordShootingRangePoints, sessionID, output); + case HideoutEventActions.HIDEOUT_IMPROVE_AREA: + return _hideoutCallbacks.ImproveArea(pmcData, body as HideoutImproveAreaRequestData, sessionID); + case HideoutEventActions.HIDEOUT_CANCEL_PRODUCTION_COMMAND: + return _hideoutCallbacks.CancelProduction(pmcData, body as HideoutImproveAreaRequestData, sessionID); + case HideoutEventActions.HIDEOUT_CIRCLE_OF_CULTIST_PRODUCTION_START: + return _hideoutCallbacks.CicleOfCultistProductionStart(pmcData, body as HideoutCircleOfCultistProductionStartRequestData, sessionID); + case HideoutEventActions.HIDEOUT_DELETE_PRODUCTION_COMMAND: + return _hideoutCallbacks.HideoutDeleteProductionCommand(pmcData, body as HideoutDeleteProductionRequestData, sessionID); + case HideoutEventActions.HIDEOUT_CUSTOMIZATION_APPLY_COMMAND: + return _hideoutCallbacks.HideoutCustomizationApplyCommand(pmcData, body as HideoutCustomizationApplyRequestData, sessionID); + default: + throw new Exception($"HideoutItemEventRouter being used when it cant handle route {url}"); + } + } +} diff --git a/Core/Routers/ItemEvents/InsuranceItemEventRouter.cs b/Core/Routers/ItemEvents/InsuranceItemEventRouter.cs new file mode 100644 index 00000000..bde9c88f --- /dev/null +++ b/Core/Routers/ItemEvents/InsuranceItemEventRouter.cs @@ -0,0 +1,41 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.Common; +using Core.Models.Eft.Insurance; +using Core.Models.Eft.ItemEvent; + +namespace Core.Routers.ItemEvents; + +[Injectable(InjectableTypeOverride = typeof(ItemEventRouterDefinition))] +public class InsuranceItemEventRouter : ItemEventRouterDefinition +{ + protected InsuranceCallbacks _insuranceCallbacks; + + public InsuranceItemEventRouter + ( + InsuranceCallbacks insuranceCallbacks + ) + { + _insuranceCallbacks = insuranceCallbacks; + } + + protected override List GetHandledRoutes() + { + return new() + { + new HandledRoute("Insure", false) + }; + } + + public override object HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output) + { + switch (url) + { + case "Insure": + return _insuranceCallbacks.Insure(pmcData, body as InsureRequestData, sessionID); + default: + throw new Exception($"InsuranceItemEventRouter being used when it cant handle route {url}"); + } + } +} diff --git a/Core/Routers/ItemEvents/InventoryItemEventRouter.cs b/Core/Routers/ItemEvents/InventoryItemEventRouter.cs new file mode 100644 index 00000000..6ddde132 --- /dev/null +++ b/Core/Routers/ItemEvents/InventoryItemEventRouter.cs @@ -0,0 +1,112 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.Common; +using Core.Models.Eft.Hideout; +using Core.Models.Eft.Inventory; +using Core.Models.Eft.ItemEvent; +using Core.Models.Eft.Quests; +using Core.Models.Enums; + +namespace Core.Routers.ItemEvents; + +[Injectable(InjectableTypeOverride = typeof(ItemEventRouterDefinition))] +public class InventoryItemEventRouter : ItemEventRouterDefinition +{ + protected InventoryCallbacks _inventoryCallbacks; + protected HideoutCallbacks _hideoutCallbacks; + + public InventoryItemEventRouter + ( + InventoryCallbacks inventoryCallbacks, + HideoutCallbacks hideoutCallbacks + ) + { + _inventoryCallbacks = inventoryCallbacks; + _hideoutCallbacks = hideoutCallbacks; + } + + protected override List GetHandledRoutes() + { + return new() + { + new HandledRoute(ItemEventActions.MOVE, false), + new HandledRoute(ItemEventActions.REMOVE, false), + new HandledRoute(ItemEventActions.SPLIT, false), + new HandledRoute(ItemEventActions.MERGE, false), + new HandledRoute(ItemEventActions.TRANSFER, false), + new HandledRoute(ItemEventActions.SWAP, false), + new HandledRoute(ItemEventActions.FOLD, false), + new HandledRoute(ItemEventActions.TOGGLE, false), + new HandledRoute(ItemEventActions.TAG, false), + new HandledRoute(ItemEventActions.BIND, false), + new HandledRoute(ItemEventActions.UNBIND, false), + new HandledRoute(ItemEventActions.EXAMINE, false), + new HandledRoute(ItemEventActions.READ_ENCYCLOPEDIA, false), + new HandledRoute(ItemEventActions.APPLY_INVENTORY_CHANGES, false), + new HandledRoute(ItemEventActions.CREATE_MAP_MARKER, false), + new HandledRoute(ItemEventActions.DELETE_MAP_MARKER, false), + new HandledRoute(ItemEventActions.EDIT_MAP_MARKER, false), + new HandledRoute(ItemEventActions.OPEN_RANDOM_LOOT_CONTAINER, false), + new HandledRoute(ItemEventActions.HIDEOUT_QTE_EVENT, false), + new HandledRoute(ItemEventActions.REDEEM_PROFILE_REWARD, false), + new HandledRoute(ItemEventActions.SET_FAVORITE_ITEMS, false), + new HandledRoute(ItemEventActions.QUEST_FAIL, false), + new HandledRoute(ItemEventActions.PIN_LOCK, false) + }; + } + + public override object HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output) + { + switch (url) { + case ItemEventActions.MOVE: + return _inventoryCallbacks.MoveItem(pmcData, body as InventoryMoveRequestData, sessionID, output); + case ItemEventActions.REMOVE: + return _inventoryCallbacks.RemoveItem(pmcData, body as InventoryRemoveRequestData, sessionID, output); + case ItemEventActions.SPLIT: + return _inventoryCallbacks.SplitItem(pmcData, body as InventorySplitRequestData, sessionID, output); + case ItemEventActions.MERGE: + return _inventoryCallbacks.MergeItem(pmcData, body as InventoryMergeRequestData, sessionID, output); + case ItemEventActions.TRANSFER: + return _inventoryCallbacks.TransferItem(pmcData, body as InventoryTransferRequestData, sessionID, output); + case ItemEventActions.SWAP: + return _inventoryCallbacks.SwapItem(pmcData, body as InventorySwapRequestData, sessionID); + case ItemEventActions.FOLD: + return _inventoryCallbacks.FoldItem(pmcData, body as InventoryFoldRequestData, sessionID); + case ItemEventActions.TOGGLE: + return _inventoryCallbacks.ToggleItem(pmcData, body as InventoryToggleRequestData, sessionID); + case ItemEventActions.TAG: + return _inventoryCallbacks.TagItem(pmcData, body as InventoryTagRequestData, sessionID); + case ItemEventActions.BIND: + return _inventoryCallbacks.BindItem(pmcData, body as InventoryBindRequestData, sessionID, output); + case ItemEventActions.UNBIND: + return _inventoryCallbacks.UnBindItem(pmcData, body as InventoryBindRequestData, sessionID, output); + case ItemEventActions.EXAMINE: + return _inventoryCallbacks.ExamineItem(pmcData, body as InventoryExamineRequestData, sessionID, output); + case ItemEventActions.READ_ENCYCLOPEDIA: + return _inventoryCallbacks.ReadEncyclopedia(pmcData, body as InventoryReadEncyclopediaRequestData, sessionID); + case ItemEventActions.APPLY_INVENTORY_CHANGES: + return _inventoryCallbacks.SortInventory(pmcData, body as InventorySortRequestData, sessionID, output); + case ItemEventActions.CREATE_MAP_MARKER: + return _inventoryCallbacks.CreateMapMarker(pmcData, body as InventoryCreateMarkerRequestData, sessionID, output); + case ItemEventActions.DELETE_MAP_MARKER: + return _inventoryCallbacks.DeleteMapMarker(pmcData, body as InventoryDeleteMarkerRequestData, sessionID, output); + case ItemEventActions.EDIT_MAP_MARKER: + return _inventoryCallbacks.EditMapMarker(pmcData, body as InventoryEditMarkerRequestData, sessionID, output); + case ItemEventActions.OPEN_RANDOM_LOOT_CONTAINER: + return _inventoryCallbacks.OpenRandomLootContainer(pmcData, body as OpenRandomLootContainerRequestData, sessionID, output); + case ItemEventActions.HIDEOUT_QTE_EVENT: + return _hideoutCallbacks.HandleQTEEvent(pmcData, body as HandleQTEEventRequestData, sessionID, output); + case ItemEventActions.REDEEM_PROFILE_REWARD: + return _inventoryCallbacks.RedeemProfileReward(pmcData, body as RedeemProfileRequestData, sessionID, output); + case ItemEventActions.SET_FAVORITE_ITEMS: + return _inventoryCallbacks.SetFavoriteItem(pmcData, body as SetFavoriteItems, sessionID, output); + case ItemEventActions.QUEST_FAIL: + return _inventoryCallbacks.FailQuest(pmcData, body as FailQuestRequestData, sessionID, output); + case ItemEventActions.PIN_LOCK: + return _inventoryCallbacks.PinOrLock(pmcData, body as PinOrLockItemRequest, sessionID, output); + default: + throw new Exception($"InventoryItemEventRouter being used when it cant handle route {url}"); + } + } +} diff --git a/Core/Routers/ItemEvents/NoteItemEventRouter.cs b/Core/Routers/ItemEvents/NoteItemEventRouter.cs new file mode 100644 index 00000000..c56a09c9 --- /dev/null +++ b/Core/Routers/ItemEvents/NoteItemEventRouter.cs @@ -0,0 +1,47 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.Common; +using Core.Models.Eft.ItemEvent; +using Core.Models.Eft.Notes; + +namespace Core.Routers.ItemEvents; + +[Injectable(InjectableTypeOverride = typeof(ItemEventRouterDefinition))] +public class NoteItemEventRouter : ItemEventRouterDefinition +{ + protected NoteCallbacks _noteCallbacks; + + public NoteItemEventRouter + ( + NoteCallbacks noteCallbacks + ) + { + _noteCallbacks = noteCallbacks; + } + + protected override List GetHandledRoutes() + { + return new() + { + new HandledRoute("AddNote", false), + new HandledRoute("EditNote", false), + new HandledRoute("DeleteNote", false) + }; + } + + public override object HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output) + { + switch (url) + { + case "AddNote": + return _noteCallbacks.AddNote(pmcData, body as NoteActionData, sessionID); + case "EditNote": + return _noteCallbacks.EditNote(pmcData, body as NoteActionData, sessionID); + case "DeleteNote": + return _noteCallbacks.DeleteNote(pmcData, body as NoteActionData, sessionID); + default: + throw new Exception($"NoteItemEventRouter being used when it cant handle route {url}"); + } + } +} diff --git a/Core/Routers/ItemEvents/QuestItemEventRouter.cs b/Core/Routers/ItemEvents/QuestItemEventRouter.cs new file mode 100644 index 00000000..7d6171ec --- /dev/null +++ b/Core/Routers/ItemEvents/QuestItemEventRouter.cs @@ -0,0 +1,50 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.Common; +using Core.Models.Eft.ItemEvent; +using Core.Models.Eft.Quests; +using ILogger = Core.Models.Utils.ILogger; + +namespace Core.Routers.ItemEvents; + +[Injectable(InjectableTypeOverride = typeof(ItemEventRouterDefinition))] +public class QuestItemEventRouter : ItemEventRouterDefinition +{ + protected QuestCallbacks _questCallbacks; + + public QuestItemEventRouter + ( + QuestCallbacks questCallbacks + ) + { + _questCallbacks = questCallbacks; + } + + protected override List GetHandledRoutes() + { + return new() + { + new HandledRoute("QuestAccept", false), + new HandledRoute("QuestComplete", false), + new HandledRoute("QuestHandover", false), + new HandledRoute("RepeatableQuestChange", false) + }; + } + + public override object HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output) + { + switch (url) { + case "QuestAccept": + return _questCallbacks.AcceptQuest(pmcData, body as AcceptQuestRequestData, sessionID); + case "QuestComplete": + return _questCallbacks.CompleteQuest(pmcData, body as CompleteQuestRequestData, sessionID); + case "QuestHandover": + return _questCallbacks.HandoverQuest(pmcData, body as HandoverQuestRequestData, sessionID); + case "RepeatableQuestChange": + return _questCallbacks.ChangeRepeatableQuest(pmcData, body as RepeatableQuestChangeRequest, sessionID); + default: + throw new Exception($"QuestItemEventRouter being used when it cant handle route {url}"); + } + } +} diff --git a/Core/Routers/ItemEvents/RagfairItemEventRouter.cs b/Core/Routers/ItemEvents/RagfairItemEventRouter.cs new file mode 100644 index 00000000..08734564 --- /dev/null +++ b/Core/Routers/ItemEvents/RagfairItemEventRouter.cs @@ -0,0 +1,46 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.Common; +using Core.Models.Eft.ItemEvent; +using Core.Models.Eft.Ragfair; + +namespace Core.Routers.ItemEvents; + +[Injectable(InjectableTypeOverride = typeof(ItemEventRouterDefinition))] +public class RagfairItemEventRouter : ItemEventRouterDefinition +{ + protected RagfairCallbacks _ragfairCallbacks; + + public RagfairItemEventRouter + ( + RagfairCallbacks ragfairCallbacks + ) + { + _ragfairCallbacks = ragfairCallbacks; + } + + protected override List GetHandledRoutes() + { + return new() + { + new HandledRoute("RagFairAddOffer", false), + new HandledRoute("RagFairRemoveOffer", false), + new HandledRoute("RagFairRenewOffer", false), + }; + } + + public override object HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output) + { + switch (url) { + case "RagFairAddOffer": + return _ragfairCallbacks.AddOffer(pmcData, body as AddOfferRequestData, sessionID); + case "RagFairRemoveOffer": + return _ragfairCallbacks.RemoveOffer(pmcData, body as RemoveOfferRequestData, sessionID); + case "RagFairRenewOffer": + return _ragfairCallbacks.ExtendOffer(pmcData, body as ExtendOfferRequestData, sessionID); + default: + throw new Exception($"CustomizationItemEventRouter being used when it cant handle route {url}"); + } + } +} diff --git a/Core/Routers/ItemEvents/RepairItemEventRouter.cs b/Core/Routers/ItemEvents/RepairItemEventRouter.cs new file mode 100644 index 00000000..c30e0fc8 --- /dev/null +++ b/Core/Routers/ItemEvents/RepairItemEventRouter.cs @@ -0,0 +1,43 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.Common; +using Core.Models.Eft.ItemEvent; +using Core.Models.Eft.Repair; + +namespace Core.Routers.ItemEvents; + +[Injectable(InjectableTypeOverride = typeof(ItemEventRouterDefinition))] +public class RepairItemEventRouter : ItemEventRouterDefinition +{ + protected RepairCallbacks _repairCallbacks; + + public RepairItemEventRouter + ( + RepairCallbacks repairCallbacks + ) + { + _repairCallbacks = repairCallbacks; + } + + protected override List GetHandledRoutes() + { + return new() + { + new HandledRoute("Repair", false), + new HandledRoute("TraderRepair", false) + }; + } + + public override object HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output) + { + switch (url) { + case "Repair": + return _repairCallbacks.Repair(pmcData, body as RepairActionDataRequest, sessionID); + case "TraderRepair": + return _repairCallbacks.TraderRepair(pmcData, body as TraderRepairActionDataRequest, sessionID); + default: + throw new Exception($"RepairItemEventRouter being used when it cant handle route {url}"); + } + } +} diff --git a/Core/Routers/ItemEvents/TradeItemEventRouter.cs b/Core/Routers/ItemEvents/TradeItemEventRouter.cs new file mode 100644 index 00000000..67bd8f0a --- /dev/null +++ b/Core/Routers/ItemEvents/TradeItemEventRouter.cs @@ -0,0 +1,46 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.Common; +using Core.Models.Eft.ItemEvent; +using Core.Models.Eft.Trade; + +namespace Core.Routers.ItemEvents; + +[Injectable(InjectableTypeOverride = typeof(ItemEventRouterDefinition))] +public class TradeItemEventRouter : ItemEventRouterDefinition +{ + protected TradeCallbacks _tradeCallbacks; + + public TradeItemEventRouter + ( + TradeCallbacks tradeCallbacks + ) + { + _tradeCallbacks = tradeCallbacks; + } + + protected override List GetHandledRoutes() + { + return new() + { + new HandledRoute("TradingConfirm", false), + new HandledRoute("RagFairBuyOffer", false), + new HandledRoute("SellAllFromSavage", false) + }; + } + + public override object HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output) + { + switch (url) { + case "TradingConfirm": + return _tradeCallbacks.ProcessTrade(pmcData, body as ProcessBaseTradeRequestData, sessionID); + case "RagFairBuyOffer": + return _tradeCallbacks.ProcessRagfairTrade(pmcData, body as ProcessRagfairTradeRequestData, sessionID); + case "SellAllFromSavage": + return _tradeCallbacks.SellAllFromSavage(pmcData, body as SellScavItemsToFenceRequestData, sessionID); + default: + throw new Exception($"TradeItemEventRouter being used when it cant handle route {url}"); + } + } +} diff --git a/Core/Routers/ItemEvents/WishlistItemEventRouter.cs b/Core/Routers/ItemEvents/WishlistItemEventRouter.cs new file mode 100644 index 00000000..d86af900 --- /dev/null +++ b/Core/Routers/ItemEvents/WishlistItemEventRouter.cs @@ -0,0 +1,47 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.Common; +using Core.Models.Eft.ItemEvent; +using Core.Models.Eft.Wishlist; + +namespace Core.Routers.ItemEvents; + +[Injectable(InjectableTypeOverride = typeof(ItemEventRouterDefinition))] +public class WishlistItemEventRouter : ItemEventRouterDefinition +{ + protected WishlistCallbacks _wishlistCallbacks; + + public WishlistItemEventRouter + ( + WishlistCallbacks wishlistCallbacks + ) + { + _wishlistCallbacks = wishlistCallbacks; + } + + protected override List GetHandledRoutes() + { + return new() + { + new HandledRoute("AddToWishList", false), + new HandledRoute("RemoveFromWishList", false), + new HandledRoute("ChangeWishlistItemCategory", false) + }; + } + + public override object HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output) + { + switch (url) + { + case "AddToWishList": + return _wishlistCallbacks.AddToWishlist(pmcData, body as AddToWishlistRequest, sessionID); + case "RemoveFromWishList": + return _wishlistCallbacks.RemoveFromWishlist(pmcData, body as RemoveFromWishlistRequest, sessionID); + case "ChangeWishlistItemCategory": + return _wishlistCallbacks.ChangeWishlistItemCategory(pmcData, body as ChangeWishlistItemCategoryRequest, sessionID); + default: + throw new Exception($"CustomizationItemEventRouter being used when it cant handle route {url}"); + } + } +} diff --git a/Core/Routers/Serializers/BundleSerializer.cs b/Core/Routers/Serializers/BundleSerializer.cs new file mode 100644 index 00000000..36e24e61 --- /dev/null +++ b/Core/Routers/Serializers/BundleSerializer.cs @@ -0,0 +1,6 @@ +namespace Core.Routers.Serializers; + +public class BundleSerializer +{ + +} diff --git a/Core/Routers/Serializers/NotifySerializer.cs b/Core/Routers/Serializers/NotifySerializer.cs new file mode 100644 index 00000000..b8b565da --- /dev/null +++ b/Core/Routers/Serializers/NotifySerializer.cs @@ -0,0 +1,6 @@ +namespace Core.Routers.Serializers; + +public class NotifySerializer +{ + +} diff --git a/Core/Routers/Static/RagfairStaticRouter.cs b/Core/Routers/Static/RagfairStaticRouter.cs new file mode 100644 index 00000000..3dee68e9 --- /dev/null +++ b/Core/Routers/Static/RagfairStaticRouter.cs @@ -0,0 +1,88 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.Common; +using Core.Models.Eft.Ragfair; +using Core.Utils; + +namespace Core.Routers.Static; + +[Injectable(InjectableTypeOverride = typeof(StaticRouter))] +public class RagfairStaticRouter : StaticRouter +{ + protected static RagfairCallbacks _ragfairCallbacks; + + public RagfairStaticRouter( + JsonUtil jsonUtil, + RagfairCallbacks ragfairCallbacks + ) : base( + jsonUtil, + [ + new RouteAction( + "/client/ragfair/search", + ( + url, + info, + sessionID, + output + ) => _ragfairCallbacks.Search(url, info as SearchRequestData, sessionID), + typeof(SearchRequestData)), + new RouteAction( + "/client/ragfair/find", + ( + url, + info, + sessionID, + output + ) => _ragfairCallbacks.Search(url, info as SearchRequestData, sessionID), + typeof(SearchRequestData)), + new RouteAction( + "/client/ragfair/itemMarketPrice", + ( + url, + info, + sessionID, + output + ) => _ragfairCallbacks.GetMarketPrice(url, info as GetMarketPriceRequestData, sessionID), + typeof(GetMarketPriceRequestData)), + new RouteAction( + "/client/ragfair/offerfees", + ( + url, + info, + sessionID, + output + ) => _ragfairCallbacks.StorePlayerOfferTaxAmount(url, info as StorePlayerOfferTaxAmountRequestData, sessionID), + typeof(StorePlayerOfferTaxAmountRequestData)), + new RouteAction( + "/client/reports/ragfair/send", + ( + url, + info, + sessionID, + output + ) => _ragfairCallbacks.SendReport(url, info as SendRagfairReportRequestData, sessionID), + typeof(SendRagfairReportRequestData)), + new RouteAction( + "/client/items/prices", + ( + url, + info, + sessionID, + output + ) => _ragfairCallbacks.GetFleaPrices(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/ragfair/offer/findbyid", + ( + url, + info, + sessionID, + output + ) => _ragfairCallbacks.GetFleaOfferById(url, info as GetRagfairOfferByIdRequest, sessionID), + typeof(GetRagfairOfferByIdRequest)) + ] + ) + { + _ragfairCallbacks = ragfairCallbacks; + } +} diff --git a/Core/Routers/Static/WeatherStaticRouter.cs b/Core/Routers/Static/WeatherStaticRouter.cs new file mode 100644 index 00000000..882bb3d1 --- /dev/null +++ b/Core/Routers/Static/WeatherStaticRouter.cs @@ -0,0 +1,41 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.Common; +using Core.Utils; + +namespace Core.Routers.Static; + +[Injectable(InjectableTypeOverride = typeof(StaticRouter))] +public class WeatherStaticRouter : StaticRouter +{ + protected static WeatherCallbacks _weatherCallbacks; + + public WeatherStaticRouter( + JsonUtil jsonUtil, + WeatherCallbacks weatherCallbacks + ) : base( + jsonUtil, + [ + new RouteAction( + "", + ( + url, + info, + sessionID, + output + ) => _weatherCallbacks.GetWeather(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "", + ( + url, + info, + sessionID, + output + ) => _weatherCallbacks.GetLocalWeather(url, info as EmptyRequestData, sessionID)), + ] + ) + { + _weatherCallbacks = weatherCallbacks; + } +}