First pass at implementing item event handling

Core/Callbacks/CustomizationCallbacks.cs

@@ -49,9 +49,9 @@ public class CustomizationCallbacks(
     /// <param name="info"></param>
     /// <param name="sessionID"></param>
     /// <returns></returns>
-    public ItemEventRouterResponse BuyClothing(PmcData pmcData, BuyClothingRequestData info, string sessionID)
+    public ItemEventRouterResponse BuyCustomisation(PmcData pmcData, BuyClothingRequestData info, string sessionID)
     {
-        return _customizationController.BuyClothing(pmcData, info, sessionID);
+        return _customizationController.BuyCustomisation(pmcData, info, sessionID);
     }
 
     /// <summary>

Core/Controllers/BotController.cs

@@ -148,7 +148,7 @@ public class BotController
             var botNameKey = botType.ToLower();
             foreach (var (difficultyName, difficultyValues) in botDetails.BotDifficulty)
             {
-                // Bot doesnt exist in result, add
+                // Bot doesn't exist in result, add
                 if (!result.ContainsKey(botNameKey))
                 {
                     result.TryAdd(botNameKey, new Dictionary<string, DifficultyCategories>());

Core/Controllers/CustomizationController.cs

@@ -77,7 +77,7 @@ public class CustomizationController
     /// <param name="buyClothingRequest">Request object</param>
     /// <param name="sessionId">Session id</param>
     /// <returns>ItemEventRouterResponse</returns>
-    public ItemEventRouterResponse BuyClothing(
+    public ItemEventRouterResponse BuyCustomisation(
         PmcData pmcData,
         BuyClothingRequestData buyClothingRequest,
         string sessionId)

Core/DI/Router.cs

@@ -101,13 +101,11 @@ public abstract class DynamicRouter : Router
 // So instead I added the definition
 public abstract class ItemEventRouterDefinition : Router
 {
-    public abstract object HandleItemEvent(
-        string url,
+    public abstract Task<ItemEventRouterResponse>? HandleItemEvent(string url,
         PmcData pmcData,
         object body,
         string sessionID,
-        ItemEventRouterResponse output
-    );
+        ItemEventRouterResponse output);
 }
 
 public abstract class SaveLoadRouter : Router

Core/Models/Utils/ISptLogger.cs

@@ -1,3 +1,4 @@
+using Core.Models.Eft.ItemEvent;
 using Core.Models.Logging;
 
 namespace Core.Models.Utils;
@@ -14,4 +15,5 @@ public interface ISptLogger<T>
     void Info(string data, Exception? ex = null);
     void Debug(string data, Exception? ex = null);
     void Critical(string data, Exception? ex = null);
+    void WriteToLogFile(object body);
 }

Core/Routers/EventOutputHolder.cs

@@ -75,7 +75,7 @@ public class EventOutputHolder
         });
     }
 
-    public void UpdateOutputProperties()
+    public void UpdateOutputProperties(string sessionId)
     {
         throw new NotImplementedException();
     }

Core/Routers/ItemEventRouter.cs

@@ -0,0 +1,75 @@
+using Core.Annotations;
+using Core.DI;
+using Core.Helpers;
+using Core.Models.Eft.HttpResponse;
+using Core.Models.Eft.ItemEvent;
+using Core.Models.Enums;
+using Core.Models.Utils;
+using Core.Services;
+using Core.Utils;
+using Core.Utils.Cloners;
+using Microsoft.AspNetCore.Http;
+
+namespace Core.Routers
+{
+    [Injectable]
+    public class ItemEventRouter
+    {
+        protected ISptLogger<ItemEventRouter> _logger;
+        private readonly HttpResponseUtil _httpResponseUtil;
+        protected ProfileHelper _profileHelper;
+        protected LocalisationService _localisationService;
+        protected EventOutputHolder _eventOutputHolder;
+        protected List<ItemEventRouterDefinition> _itemEventRouters;
+        protected ICloner _cloner;
+
+        public ItemEventRouter(
+            ISptLogger<ItemEventRouter> logger,
+            HttpResponseUtil httpResponseUtil,
+            ProfileHelper profileHelper,
+            LocalisationService localisationService,
+            EventOutputHolder eventOutputHolder,
+            IEnumerable<ItemEventRouterDefinition> itemEventRouters,
+            ICloner cloner
+            )
+        {
+            _logger = logger;
+            _httpResponseUtil = httpResponseUtil;
+            _profileHelper = profileHelper;
+            _localisationService = localisationService;
+            _eventOutputHolder = eventOutputHolder;
+            _itemEventRouters = itemEventRouters.ToList();
+            _cloner = cloner;
+        }
+
+        public async Task<ItemEventRouterResponse> HandleEvents(ItemEventRouterRequest info, string sessionID)
+        {
+            var output = _eventOutputHolder.GetOutput(sessionID);
+
+            foreach (var body in info.Data) {
+                var pmcData = _profileHelper.GetPmcProfile(sessionID);
+
+                var eventRouter = _itemEventRouters.FirstOrDefault((r) => r.CanHandle(body.Action));
+                if (eventRouter is not null)
+                {
+                    _logger.Debug("event: ${ body.Action}");
+                    await eventRouter.HandleItemEvent(body.Action, pmcData, body, sessionID, output);
+                    if (output.Warnings.Count > 0) {
+                        break;
+                    }
+                } else {
+                    _logger.Error(_localisationService.GetText("event-unhandled_event", body.Action));
+                    _logger.WriteToLogFile(body);
+                }
+            }
+
+            _eventOutputHolder.UpdateOutputProperties(sessionID);
+
+            // Clone output before resetting the output object ready for use next time
+            var outputClone = _cloner.Clone(output);
+            _eventOutputHolder.ResetOutput(sessionID);
+
+            return outputClone;
+        }
+    }
+}

Core/Routers/ItemEvents/CustomizationItemEventRouter.cs

@@ -1,22 +1,26 @@
-using Core.Annotations;
+using Core.Annotations;
 using Core.Callbacks;
 using Core.DI;
 using Core.Models.Eft.Common;
 using Core.Models.Eft.Customization;
 using Core.Models.Eft.ItemEvent;
+using Core.Models.Utils;
 
 namespace Core.Routers.ItemEvents;
 
 [Injectable(InjectableTypeOverride = typeof(ItemEventRouterDefinition))]
 public class CustomizationItemEventRouter : ItemEventRouterDefinition
 {
+    protected ISptLogger<CustomizationItemEventRouter> _logger;
     protected CustomizationCallbacks _customizationCallbacks;
 
     public CustomizationItemEventRouter
     (
+        ISptLogger<CustomizationItemEventRouter> logger,
         CustomizationCallbacks customizationCallbacks
     )
     {
+        _logger = logger;
         _customizationCallbacks = customizationCallbacks;
     }
 
@@ -29,14 +33,14 @@ public class CustomizationItemEventRouter : ItemEventRouterDefinition
         };
     }
 
-    public override object HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output)
+    public override Task<ItemEventRouterResponse> HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output)
     {
         switch (url)
         {
             case "CustomizationBuy":
-                return _customizationCallbacks.BuyClothing(pmcData, body as BuyClothingRequestData, sessionID);
+                return Task.FromResult(_customizationCallbacks.BuyCustomisation(pmcData, body as BuyClothingRequestData, sessionID));
             case "CustomizationSet":
-                return _customizationCallbacks.SetClothing(pmcData, body as CustomizationSetRequest, sessionID);
+                return Task.FromResult(_customizationCallbacks.SetClothing(pmcData, body as CustomizationSetRequest, sessionID));
             default:
                 throw new Exception($"CustomizationItemEventRouter being used when it cant handle route {url}");
         }

Core/Routers/ItemEvents/HealthItemEventRouter.cs

@@ -1,4 +1,4 @@
-using Core.Annotations;
+using Core.Annotations;
 using Core.Callbacks;
 using Core.DI;
 using Core.Models.Eft.Common;
@@ -30,16 +30,16 @@ public class HealthItemEventRouter : ItemEventRouterDefinition
         };
     }
 
-    public override object HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output)
+    public override Task<ItemEventRouterResponse>? HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output)
     {
         switch (url)
         {
             case "Eat":
-                return _healthCallbacks.OffraidEat(pmcData, body as OffraidEatRequestData, sessionID);
+                return Task.FromResult(_healthCallbacks.OffraidEat(pmcData, body as OffraidEatRequestData, sessionID));
             case "Heal":
-                return _healthCallbacks.OffraidHeal(pmcData, body as OffraidHealRequestData, sessionID);
+                return Task.FromResult(_healthCallbacks.OffraidHeal(pmcData, body as OffraidHealRequestData, sessionID));
             case "RestoreHealth":
-                return _healthCallbacks.HealthTreatment(pmcData, body as HealthTreatmentRequestData, sessionID);
+                return Task.FromResult(_healthCallbacks.HealthTreatment(pmcData, body as HealthTreatmentRequestData, sessionID));
             default:
                 throw new Exception($"HealthItemEventRouter being used when it cant handle route {url}");
         }

Core/Routers/ItemEvents/HideoutItemEventRouter.cs

@@ -43,41 +43,41 @@ public class HideoutItemEventRouter : ItemEventRouterDefinition
         };
     }
 
-    public override object HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output)
+    public override Task<ItemEventRouterResponse> 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);
+                return Task.FromResult(_hideoutCallbacks.Upgrade(pmcData, body as HideoutUpgradeRequestData, sessionID, output));
             case HideoutEventActions.HIDEOUT_UPGRADE_COMPLETE:
-                return _hideoutCallbacks.UpgradeComplete(pmcData, body as HideoutUpgradeCompleteRequestData, sessionID, output);
+                return Task.FromResult(_hideoutCallbacks.UpgradeComplete(pmcData, body as HideoutUpgradeCompleteRequestData, sessionID, output));
             case HideoutEventActions.HIDEOUT_PUT_ITEMS_IN_AREA_SLOTS:
-                return _hideoutCallbacks.PutItemsInAreaSlots(pmcData, body as HideoutPutItemInRequestData, sessionID);
+                return Task.FromResult(_hideoutCallbacks.PutItemsInAreaSlots(pmcData, body as HideoutPutItemInRequestData, sessionID));
             case HideoutEventActions.HIDEOUT_TAKE_ITEMS_FROM_AREA_SLOTS:
-                return _hideoutCallbacks.TakeItemsFromAreaSlots(pmcData, body as HideoutTakeItemOutRequestData, sessionID);
+                return Task.FromResult(_hideoutCallbacks.TakeItemsFromAreaSlots(pmcData, body as HideoutTakeItemOutRequestData, sessionID));
             case HideoutEventActions.HIDEOUT_TOGGLE_AREA:
-                return _hideoutCallbacks.ToggleArea(pmcData, body as HideoutToggleAreaRequestData, sessionID);
+                return Task.FromResult(_hideoutCallbacks.ToggleArea(pmcData, body as HideoutToggleAreaRequestData, sessionID));
             case HideoutEventActions.HIDEOUT_SINGLE_PRODUCTION_START:
-                return _hideoutCallbacks.SingleProductionStart(pmcData, body as HideoutSingleProductionStartRequestData, sessionID);
+                return Task.FromResult(_hideoutCallbacks.SingleProductionStart(pmcData, body as HideoutSingleProductionStartRequestData, sessionID));
             case HideoutEventActions.HIDEOUT_SCAV_CASE_PRODUCTION_START:
-                return _hideoutCallbacks.ScavCaseProductionStart(pmcData, body as HideoutScavCaseStartRequestData, sessionID);
+                return Task.FromResult(_hideoutCallbacks.ScavCaseProductionStart(pmcData, body as HideoutScavCaseStartRequestData, sessionID));
             case HideoutEventActions.HIDEOUT_CONTINUOUS_PRODUCTION_START:
-                return _hideoutCallbacks.ContinuousProductionStart(pmcData, body as HideoutContinuousProductionStartRequestData, sessionID);
+                return Task.FromResult(_hideoutCallbacks.ContinuousProductionStart(pmcData, body as HideoutContinuousProductionStartRequestData, sessionID));
             case HideoutEventActions.HIDEOUT_TAKE_PRODUCTION:
-                return _hideoutCallbacks.TakeProduction(pmcData, body as HideoutTakeProductionRequestData, sessionID);
+                return Task.FromResult(_hideoutCallbacks.TakeProduction(pmcData, body as HideoutTakeProductionRequestData, sessionID));
             case HideoutEventActions.HIDEOUT_RECORD_SHOOTING_RANGE_POINTS:
-                return _hideoutCallbacks.RecordShootingRangePoints(pmcData, body as RecordShootingRangePoints, sessionID, output);
+                return Task.FromResult(_hideoutCallbacks.RecordShootingRangePoints(pmcData, body as RecordShootingRangePoints, sessionID, output));
             case HideoutEventActions.HIDEOUT_IMPROVE_AREA:
-                return _hideoutCallbacks.ImproveArea(pmcData, body as HideoutImproveAreaRequestData, sessionID);
+                return Task.FromResult(_hideoutCallbacks.ImproveArea(pmcData, body as HideoutImproveAreaRequestData, sessionID));
             case HideoutEventActions.HIDEOUT_CANCEL_PRODUCTION_COMMAND:
-                return _hideoutCallbacks.CancelProduction(pmcData, body as HideoutImproveAreaRequestData, sessionID);
+                return Task.FromResult(_hideoutCallbacks.CancelProduction(pmcData, body as HideoutImproveAreaRequestData, sessionID));
             case HideoutEventActions.HIDEOUT_CIRCLE_OF_CULTIST_PRODUCTION_START:
-                return _hideoutCallbacks.CicleOfCultistProductionStart(pmcData, body as HideoutCircleOfCultistProductionStartRequestData, sessionID);
+                return Task.FromResult(_hideoutCallbacks.CicleOfCultistProductionStart(pmcData, body as HideoutCircleOfCultistProductionStartRequestData, sessionID));
             case HideoutEventActions.HIDEOUT_DELETE_PRODUCTION_COMMAND:
-                return _hideoutCallbacks.HideoutDeleteProductionCommand(pmcData, body as HideoutDeleteProductionRequestData, sessionID);
+                return Task.FromResult(_hideoutCallbacks.HideoutDeleteProductionCommand(pmcData, body as HideoutDeleteProductionRequestData, sessionID));
             case HideoutEventActions.HIDEOUT_CUSTOMIZATION_APPLY_COMMAND:
-                return _hideoutCallbacks.HideoutCustomizationApplyCommand(pmcData, body as HideoutCustomizationApplyRequestData, sessionID);
+                return Task.FromResult(_hideoutCallbacks.HideoutCustomizationApplyCommand(pmcData, body as HideoutCustomizationApplyRequestData, sessionID));
             case HideoutEventActions.HIDEOUT_CUSTOMIZATION_SET_MANNEQUIN_POSE:
-                return _hideoutCallbacks.HideoutCustomizationSetMannequinPose(pmcData, body as HideoutCustomizationSetMannequinPoseRequest, sessionID);
+                return Task.FromResult(_hideoutCallbacks.HideoutCustomizationSetMannequinPose(pmcData, body as HideoutCustomizationSetMannequinPoseRequest, sessionID));
             default:
                 throw new Exception($"HideoutItemEventRouter being used when it cant handle route {url}");
         }

Core/Routers/ItemEvents/InsuranceItemEventRouter.cs

@@ -1,4 +1,4 @@
-using Core.Annotations;
+using Core.Annotations;
 using Core.Callbacks;
 using Core.DI;
 using Core.Models.Eft.Common;
@@ -28,12 +28,12 @@ public class InsuranceItemEventRouter : ItemEventRouterDefinition
         };
     }
 
-    public override object HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output)
+    public override Task<ItemEventRouterResponse> HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output)
     {
         switch (url)
         {
             case "Insure":
-                return _insuranceCallbacks.Insure(pmcData, body as InsureRequestData, sessionID);
+                return Task.FromResult(_insuranceCallbacks.Insure(pmcData, body as InsureRequestData, sessionID));
             default:
                 throw new Exception($"InsuranceItemEventRouter being used when it cant handle route {url}");
         }

Core/Routers/ItemEvents/InventoryItemEventRouter.cs

@@ -1,4 +1,4 @@
-using Core.Annotations;
+using Core.Annotations;
 using Core.Callbacks;
 using Core.DI;
 using Core.Models.Eft.Common;
@@ -56,55 +56,55 @@ public class InventoryItemEventRouter : ItemEventRouterDefinition
         };
     }
 
-    public override object HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output)
+    public override Task<ItemEventRouterResponse> 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);
+                return Task.FromResult(_inventoryCallbacks.MoveItem(pmcData, body as InventoryMoveRequestData, sessionID, output));
             case ItemEventActions.REMOVE:
-                return _inventoryCallbacks.RemoveItem(pmcData, body as InventoryRemoveRequestData, sessionID, output);
+                return Task.FromResult(_inventoryCallbacks.RemoveItem(pmcData, body as InventoryRemoveRequestData, sessionID, output));
             case ItemEventActions.SPLIT:
-                return _inventoryCallbacks.SplitItem(pmcData, body as InventorySplitRequestData, sessionID, output);
+                return Task.FromResult(_inventoryCallbacks.SplitItem(pmcData, body as InventorySplitRequestData, sessionID, output));
             case ItemEventActions.MERGE:
-                return _inventoryCallbacks.MergeItem(pmcData, body as InventoryMergeRequestData, sessionID, output);
+                return Task.FromResult(_inventoryCallbacks.MergeItem(pmcData, body as InventoryMergeRequestData, sessionID, output));
             case ItemEventActions.TRANSFER:
-                return _inventoryCallbacks.TransferItem(pmcData, body as InventoryTransferRequestData, sessionID, output);
+                return Task.FromResult(_inventoryCallbacks.TransferItem(pmcData, body as InventoryTransferRequestData, sessionID, output));
             case ItemEventActions.SWAP:
-                return _inventoryCallbacks.SwapItem(pmcData, body as InventorySwapRequestData, sessionID);
+                return Task.FromResult(_inventoryCallbacks.SwapItem(pmcData, body as InventorySwapRequestData, sessionID));
             case ItemEventActions.FOLD:
-                return _inventoryCallbacks.FoldItem(pmcData, body as InventoryFoldRequestData, sessionID);
+                return Task.FromResult(_inventoryCallbacks.FoldItem(pmcData, body as InventoryFoldRequestData, sessionID));
             case ItemEventActions.TOGGLE:
-                return _inventoryCallbacks.ToggleItem(pmcData, body as InventoryToggleRequestData, sessionID);
+                return Task.FromResult(_inventoryCallbacks.ToggleItem(pmcData, body as InventoryToggleRequestData, sessionID));
             case ItemEventActions.TAG:
-                return _inventoryCallbacks.TagItem(pmcData, body as InventoryTagRequestData, sessionID);
+                return Task.FromResult(_inventoryCallbacks.TagItem(pmcData, body as InventoryTagRequestData, sessionID));
             case ItemEventActions.BIND:
-                return _inventoryCallbacks.BindItem(pmcData, body as InventoryBindRequestData, sessionID, output);
+                return Task.FromResult(_inventoryCallbacks.BindItem(pmcData, body as InventoryBindRequestData, sessionID, output));
             case ItemEventActions.UNBIND:
-                return _inventoryCallbacks.UnBindItem(pmcData, body as InventoryBindRequestData, sessionID, output);
+                return Task.FromResult(_inventoryCallbacks.UnBindItem(pmcData, body as InventoryBindRequestData, sessionID, output));
             case ItemEventActions.EXAMINE:
-                return _inventoryCallbacks.ExamineItem(pmcData, body as InventoryExamineRequestData, sessionID, output);
+                return Task.FromResult(_inventoryCallbacks.ExamineItem(pmcData, body as InventoryExamineRequestData, sessionID, output));
             case ItemEventActions.READ_ENCYCLOPEDIA:
-                return _inventoryCallbacks.ReadEncyclopedia(pmcData, body as InventoryReadEncyclopediaRequestData, sessionID);
+                return Task.FromResult(_inventoryCallbacks.ReadEncyclopedia(pmcData, body as InventoryReadEncyclopediaRequestData, sessionID));
             case ItemEventActions.APPLY_INVENTORY_CHANGES:
-                return _inventoryCallbacks.SortInventory(pmcData, body as InventorySortRequestData, sessionID, output);
+                return Task.FromResult(_inventoryCallbacks.SortInventory(pmcData, body as InventorySortRequestData, sessionID, output));
             case ItemEventActions.CREATE_MAP_MARKER:
-                return _inventoryCallbacks.CreateMapMarker(pmcData, body as InventoryCreateMarkerRequestData, sessionID, output);
+                return Task.FromResult(_inventoryCallbacks.CreateMapMarker(pmcData, body as InventoryCreateMarkerRequestData, sessionID, output));
             case ItemEventActions.DELETE_MAP_MARKER:
-                return _inventoryCallbacks.DeleteMapMarker(pmcData, body as InventoryDeleteMarkerRequestData, sessionID, output);
+                return Task.FromResult(_inventoryCallbacks.DeleteMapMarker(pmcData, body as InventoryDeleteMarkerRequestData, sessionID, output));
             case ItemEventActions.EDIT_MAP_MARKER:
-                return _inventoryCallbacks.EditMapMarker(pmcData, body as InventoryEditMarkerRequestData, sessionID, output);
+                return Task.FromResult(_inventoryCallbacks.EditMapMarker(pmcData, body as InventoryEditMarkerRequestData, sessionID, output));
             case ItemEventActions.OPEN_RANDOM_LOOT_CONTAINER:
-                return _inventoryCallbacks.OpenRandomLootContainer(pmcData, body as OpenRandomLootContainerRequestData, sessionID, output);
+                return Task.FromResult(_inventoryCallbacks.OpenRandomLootContainer(pmcData, body as OpenRandomLootContainerRequestData, sessionID, output));
             case ItemEventActions.HIDEOUT_QTE_EVENT:
-                return _hideoutCallbacks.HandleQTEEvent(pmcData, body as HandleQTEEventRequestData, sessionID, output);
+                return Task.FromResult(_hideoutCallbacks.HandleQTEEvent(pmcData, body as HandleQTEEventRequestData, sessionID, output));
             case ItemEventActions.REDEEM_PROFILE_REWARD:
-                return _inventoryCallbacks.RedeemProfileReward(pmcData, body as RedeemProfileRequestData, sessionID, output);
+                return Task.FromResult(_inventoryCallbacks.RedeemProfileReward(pmcData, body as RedeemProfileRequestData, sessionID, output));
             case ItemEventActions.SET_FAVORITE_ITEMS:
-                return _inventoryCallbacks.SetFavoriteItem(pmcData, body as SetFavoriteItems, sessionID, output);
+                return Task.FromResult(_inventoryCallbacks.SetFavoriteItem(pmcData, body as SetFavoriteItems, sessionID, output));
             case ItemEventActions.QUEST_FAIL:
-                return _inventoryCallbacks.FailQuest(pmcData, body as FailQuestRequestData, sessionID, output);
+                return Task.FromResult(_inventoryCallbacks.FailQuest(pmcData, body as FailQuestRequestData, sessionID, output));
             case ItemEventActions.PIN_LOCK:
-                return _inventoryCallbacks.PinOrLock(pmcData, body as  PinOrLockItemRequest, sessionID, output);
+                return Task.FromResult(_inventoryCallbacks.PinOrLock(pmcData, body as  PinOrLockItemRequest, sessionID, output));
             default:
                 throw new Exception($"InventoryItemEventRouter being used when it cant handle route {url}");
         }

Core/Routers/ItemEvents/NoteItemEventRouter.cs

@@ -1,4 +1,4 @@
-using Core.Annotations;
+using Core.Annotations;
 using Core.Callbacks;
 using Core.DI;
 using Core.Models.Eft.Common;
@@ -30,16 +30,16 @@ public class NoteItemEventRouter : ItemEventRouterDefinition
         };
     }
 
-    public override object HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output)
+    public override Task<ItemEventRouterResponse> HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output)
     {
         switch (url)
         {
             case "AddNote":
-                return _noteCallbacks.AddNote(pmcData, body as NoteActionData, sessionID);
+                return Task.FromResult(_noteCallbacks.AddNote(pmcData, body as NoteActionData, sessionID));
             case "EditNote":
-                return _noteCallbacks.EditNote(pmcData, body as NoteActionData, sessionID);
+                return Task.FromResult(_noteCallbacks.EditNote(pmcData, body as NoteActionData, sessionID));
             case "DeleteNote":
-                return _noteCallbacks.DeleteNote(pmcData, body as NoteActionData, sessionID);
+                return Task.FromResult(_noteCallbacks.DeleteNote(pmcData, body as NoteActionData, sessionID));
             default:
                 throw new Exception($"NoteItemEventRouter being used when it cant handle route {url}");
         }

Core/Routers/ItemEvents/QuestItemEventRouter.cs

@@ -1,4 +1,4 @@
-using Core.Annotations;
+using Core.Annotations;
 using Core.Callbacks;
 using Core.DI;
 using Core.Models.Eft.Common;
@@ -32,17 +32,17 @@ public class QuestItemEventRouter : ItemEventRouterDefinition
         };
     }
 
-    public override object HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output)
+    public override Task<ItemEventRouterResponse> HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output)
     {
         switch (url) {
             case "QuestAccept":
-                return _questCallbacks.AcceptQuest(pmcData, body as AcceptQuestRequestData, sessionID);
+                return Task.FromResult(_questCallbacks.AcceptQuest(pmcData, body as AcceptQuestRequestData, sessionID));
             case "QuestComplete":
-                return _questCallbacks.CompleteQuest(pmcData, body as CompleteQuestRequestData, sessionID);
+                return Task.FromResult(_questCallbacks.CompleteQuest(pmcData, body as CompleteQuestRequestData, sessionID));
             case "QuestHandover":
-                return _questCallbacks.HandoverQuest(pmcData, body as HandoverQuestRequestData, sessionID);
+                return Task.FromResult(_questCallbacks.HandoverQuest(pmcData, body as HandoverQuestRequestData, sessionID));
             case "RepeatableQuestChange":
-                return _questCallbacks.ChangeRepeatableQuest(pmcData, body as RepeatableQuestChangeRequest, sessionID);
+                return Task.FromResult(_questCallbacks.ChangeRepeatableQuest(pmcData, body as RepeatableQuestChangeRequest, sessionID));
             default:
                 throw new Exception($"QuestItemEventRouter being used when it cant handle route {url}");
         }

Core/Routers/ItemEvents/RagfairItemEventRouter.cs

@@ -1,4 +1,4 @@
-using Core.Annotations;
+using Core.Annotations;
 using Core.Callbacks;
 using Core.DI;
 using Core.Models.Eft.Common;
@@ -30,15 +30,15 @@ public class RagfairItemEventRouter : ItemEventRouterDefinition
         };
     }
 
-    public override object HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output)
+    public override Task<ItemEventRouterResponse> HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output)
     {
         switch (url) {
             case "RagFairAddOffer":
-                return _ragfairCallbacks.AddOffer(pmcData, body as AddOfferRequestData, sessionID);
+                return Task.FromResult(_ragfairCallbacks.AddOffer(pmcData, body as AddOfferRequestData, sessionID));
             case "RagFairRemoveOffer":
-                return _ragfairCallbacks.RemoveOffer(pmcData, body as RemoveOfferRequestData, sessionID);
+                return Task.FromResult(_ragfairCallbacks.RemoveOffer(pmcData, body as RemoveOfferRequestData, sessionID));
             case "RagFairRenewOffer":
-                return _ragfairCallbacks.ExtendOffer(pmcData, body as ExtendOfferRequestData, sessionID);
+                return Task.FromResult(_ragfairCallbacks.ExtendOffer(pmcData, body as ExtendOfferRequestData, sessionID));
             default:
                 throw new Exception($"CustomizationItemEventRouter being used when it cant handle route {url}");
         }

Core/Routers/ItemEvents/RepairItemEventRouter.cs

@@ -1,4 +1,4 @@
-using Core.Annotations;
+using Core.Annotations;
 using Core.Callbacks;
 using Core.DI;
 using Core.Models.Eft.Common;
@@ -29,13 +29,13 @@ public class RepairItemEventRouter : ItemEventRouterDefinition
         };
     }
 
-    public override object HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output)
+    public override Task<ItemEventRouterResponse> HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output)
     {
         switch (url) {
             case "Repair":
-                return _repairCallbacks.Repair(pmcData, body as RepairActionDataRequest, sessionID);
+                return Task.FromResult(_repairCallbacks.Repair(pmcData, body as RepairActionDataRequest, sessionID));
             case "TraderRepair":
-                return _repairCallbacks.TraderRepair(pmcData, body as TraderRepairActionDataRequest, sessionID);
+                return Task.FromResult(_repairCallbacks.TraderRepair(pmcData, body as TraderRepairActionDataRequest, sessionID));
             default:
                 throw new Exception($"RepairItemEventRouter being used when it cant handle route {url}");
         }

Core/Routers/ItemEvents/TradeItemEventRouter.cs

@@ -1,4 +1,4 @@
-using Core.Annotations;
+using Core.Annotations;
 using Core.Callbacks;
 using Core.DI;
 using Core.Models.Eft.Common;
@@ -30,15 +30,15 @@ public class TradeItemEventRouter : ItemEventRouterDefinition
         };
     }
 
-    public override object HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output)
+    public override Task<ItemEventRouterResponse> HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output)
     {
         switch (url) {
             case "TradingConfirm":
-                return _tradeCallbacks.ProcessTrade(pmcData, body as ProcessBaseTradeRequestData, sessionID);
+                return Task.FromResult(_tradeCallbacks.ProcessTrade(pmcData, body as ProcessBaseTradeRequestData, sessionID));
             case "RagFairBuyOffer":
-                return _tradeCallbacks.ProcessRagfairTrade(pmcData, body as ProcessRagfairTradeRequestData, sessionID);
+                return Task.FromResult(_tradeCallbacks.ProcessRagfairTrade(pmcData, body as ProcessRagfairTradeRequestData, sessionID));
             case "SellAllFromSavage":
-                return _tradeCallbacks.SellAllFromSavage(pmcData, body as SellScavItemsToFenceRequestData, sessionID);
+                return Task.FromResult(_tradeCallbacks.SellAllFromSavage(pmcData, body as SellScavItemsToFenceRequestData, sessionID));
             default:
                 throw new Exception($"TradeItemEventRouter being used when it cant handle route {url}");
         }

Core/Routers/ItemEvents/WishlistItemEventRouter.cs

@@ -1,4 +1,4 @@
-using Core.Annotations;
+using Core.Annotations;
 using Core.Callbacks;
 using Core.DI;
 using Core.Models.Eft.Common;
@@ -30,16 +30,16 @@ public class WishlistItemEventRouter : ItemEventRouterDefinition
         };
     }
 
-    public override object HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output)
+    public override Task<ItemEventRouterResponse> HandleItemEvent(string url, PmcData pmcData, object body, string sessionID, ItemEventRouterResponse output)
     {
         switch (url)
         {
             case "AddToWishList":
-                return _wishlistCallbacks.AddToWishlist(pmcData, body as AddToWishlistRequest, sessionID);
+                return Task.FromResult(_wishlistCallbacks.AddToWishlist(pmcData, body as AddToWishlistRequest, sessionID));
             case "RemoveFromWishList":
-                return _wishlistCallbacks.RemoveFromWishlist(pmcData, body as RemoveFromWishlistRequest, sessionID);
+                return Task.FromResult(_wishlistCallbacks.RemoveFromWishlist(pmcData, body as RemoveFromWishlistRequest, sessionID));
             case "ChangeWishlistItemCategory":
-                return _wishlistCallbacks.ChangeWishlistItemCategory(pmcData, body as ChangeWishlistItemCategoryRequest, sessionID);
+                return Task.FromResult(_wishlistCallbacks.ChangeWishlistItemCategory(pmcData, body as ChangeWishlistItemCategoryRequest, sessionID));
             default:
                 throw new Exception($"CustomizationItemEventRouter being used when it cant handle route {url}");
         }

Core/Services/SeasonalEventService.cs

@@ -744,7 +744,7 @@ public class SeasonalEventService
     }
 
     /// <summary>
-    /// Add lootble items from backpack into patrol.ITEMS_TO_DROP difficulty property
+    /// Add lootable items from backpack into patrol.ITEMS_TO_DROP difficulty property
     /// </summary>
     protected void AddLootItemsToGifterDropItemsList()
     {

Server/Logger/WebApplicationLogger.cs

@@ -1,4 +1,5 @@
 using Core.Annotations;
+using Core.Models.Eft.ItemEvent;
 using Core.Models.Logging;
 using Core.Models.Utils;
 
@@ -76,4 +77,15 @@ public class SptWebApplicationLogger<T> : ISptLogger<T>
     {
         _logger.LogCritical(ex, GetColorizedText(data, LogTextColor.Black, LogBackgroundColor.Red));
     }
+
+    public void WriteToLogFile(Daum body)
+    {   
+        throw new NotImplementedException();
+    }
+
+    public void WriteToLogFile(object data)
+    {
+        //TODO - implement + turn object into json
+        _logger.LogError("NOT IMPLEMENTED - WriteToLogFile");
+    }
 }