diff --git a/Core/Routers/Dynamic/BotDynamicRouter.cs b/Core/Routers/Dynamic/BotDynamicRouter.cs new file mode 100644 index 00000000..4e4f9650 --- /dev/null +++ b/Core/Routers/Dynamic/BotDynamicRouter.cs @@ -0,0 +1,65 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.Common; +using Core.Utils; + +namespace Core.Routers.Dynamic; + +[Injectable(InjectableTypeOverride = typeof(DynamicRouter))] +public class BotDynamicRouter : DynamicRouter +{ + protected static BotCallbacks _botCallbacks; + + public BotDynamicRouter( + JsonUtil jsonUtil, + BotCallbacks botCallbacks + ) : base( + jsonUtil, + [ + new RouteAction( + "/singleplayer/settings/bot/limit/", + ( + url, + info, + sessionID, + output + ) => _botCallbacks.GetBotLimit(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/singleplayer/settings/bot/difficulty/", + ( + url, + info, + sessionID, + output + ) => _botCallbacks.GetBotDifficulty(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/singleplayer/settings/bot/difficulties", + ( + url, + info, + sessionID, + output + ) => _botCallbacks.GetAllBotDifficulties(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/singleplayer/settings/bot/maxCap", + ( + url, + info, + sessionID, + output + ) => _botCallbacks.GetBotCap(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/singleplayer/settings/bot/getBotBehaviours/", + ( + url, + info, + sessionID, + output + ) => _botCallbacks.GetBotBehaviours()) + ] + ) + { + _botCallbacks = botCallbacks; + } +} diff --git a/Core/Routers/Dynamic/BundleDynamicRouter.cs b/Core/Routers/Dynamic/BundleDynamicRouter.cs new file mode 100644 index 00000000..ae8a6ebe --- /dev/null +++ b/Core/Routers/Dynamic/BundleDynamicRouter.cs @@ -0,0 +1,33 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.Common; +using Core.Utils; + +namespace Core.Routers.Dynamic; + +[Injectable(InjectableTypeOverride = typeof(DynamicRouter))] +public class BundleDynamicRouter : DynamicRouter +{ + protected static BundleCallbacks _bundleCallbacks; + + public BundleDynamicRouter( + JsonUtil jsonUtil, + BundleCallbacks bundleCallbacks + ) : base( + jsonUtil, + [ + new RouteAction( + "/files/bundle", + ( + url, + info, + sessionID, + output + ) => _bundleCallbacks.GetBundle(url, info as EmptyRequestData, sessionID)) + ] + ) + { + _bundleCallbacks = bundleCallbacks; + } +} diff --git a/Core/Routers/Dynamic/CustomizationDynamicRouter.cs b/Core/Routers/Dynamic/CustomizationDynamicRouter.cs new file mode 100644 index 00000000..cd91d78b --- /dev/null +++ b/Core/Routers/Dynamic/CustomizationDynamicRouter.cs @@ -0,0 +1,33 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.Common; +using Core.Utils; + +namespace Core.Routers.Dynamic; + +[Injectable(InjectableTypeOverride = typeof(DynamicRouter))] +public class CustomizationDynamicRouter : DynamicRouter +{ + protected static CustomizationCallbacks _customizationCallbacks; + + public CustomizationDynamicRouter( + JsonUtil jsonUtil, + CustomizationCallbacks customizationCallbacks + ) : base( + jsonUtil, + [ + new RouteAction( + "", + ( + url, + info, + sessionID, + output + ) => _customizationCallbacks.GetTraderSuits(url, info as EmptyRequestData, sessionID)) + ] + ) + { + _customizationCallbacks = customizationCallbacks; + } +} diff --git a/Core/Routers/Dynamic/DataDynamicRouter.cs b/Core/Routers/Dynamic/DataDynamicRouter.cs new file mode 100644 index 00000000..9e10f619 --- /dev/null +++ b/Core/Routers/Dynamic/DataDynamicRouter.cs @@ -0,0 +1,49 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.Common; +using Core.Utils; + +namespace Core.Routers.Dynamic; + +[Injectable(InjectableTypeOverride = typeof(DynamicRouter))] +public class DataDynamicRouter : DynamicRouter +{ + protected static DataCallbacks _dataCallbacks; + + public DataDynamicRouter( + JsonUtil jsonUtil, + DataCallbacks dataCallbacks + ) : base( + jsonUtil, + [ + new RouteAction( + "/client/menu/locale/", + ( + url, + info, + sessionID, + output + ) => _dataCallbacks.GetLocalesMenu(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/locale/", + ( + url, + info, + sessionID, + output + ) => _dataCallbacks.GetLocalesGlobal(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/items/prices/", + ( + url, + info, + sessionID, + output + ) => _dataCallbacks.GetItemPrices(url, info as EmptyRequestData, sessionID)), + ] + ) + { + _dataCallbacks = dataCallbacks; + } +} diff --git a/Core/Routers/Dynamic/InraidDynamicRouter.cs b/Core/Routers/Dynamic/InraidDynamicRouter.cs new file mode 100644 index 00000000..a8957640 --- /dev/null +++ b/Core/Routers/Dynamic/InraidDynamicRouter.cs @@ -0,0 +1,39 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.InRaid; +using Core.Utils; + +namespace Core.Routers.Dynamic; + +[Injectable(InjectableTypeOverride = typeof(DynamicRouter))] +public class InraidDynamicRouter : DynamicRouter +{ + protected static InraidCallbacks _inraidCallbacks; + + public InraidDynamicRouter( + JsonUtil jsonUtil, + InraidCallbacks inraidCallbacks + ) : base( + jsonUtil, + [ + new RouteAction( + "/client/location/getLocalloot", + ( + url, + info, + sessionID, + output + ) => _inraidCallbacks.RegisterPlayer(url, info as RegisterPlayerRequestData, sessionID), + typeof(RegisterPlayerRequestData)) + ] + ) + { + _inraidCallbacks = inraidCallbacks; + } + + public override string GetTopLevelRoute() + { + return "spt-name"; + } +} diff --git a/Core/Routers/Dynamic/LocationDynamicRouter.cs b/Core/Routers/Dynamic/LocationDynamicRouter.cs new file mode 100644 index 00000000..6459343e --- /dev/null +++ b/Core/Routers/Dynamic/LocationDynamicRouter.cs @@ -0,0 +1,25 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Utils; + +namespace Core.Routers.Dynamic; + +[Injectable(InjectableTypeOverride = typeof(DynamicRouter))] +public class LocationDynamicRouter : DynamicRouter +{ + + public LocationDynamicRouter( + JsonUtil jsonUtil + ) : base( + jsonUtil, + [] + ) + { + } + + public override string GetTopLevelRoute() + { + return "spt-loot"; + } +} diff --git a/Core/Routers/Dynamic/NotifierDynamicRouter.cs b/Core/Routers/Dynamic/NotifierDynamicRouter.cs new file mode 100644 index 00000000..8a2d66ea --- /dev/null +++ b/Core/Routers/Dynamic/NotifierDynamicRouter.cs @@ -0,0 +1,56 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Utils; + +namespace Core.Routers.Dynamic; + +[Injectable(InjectableTypeOverride = typeof(DynamicRouter))] +public class NotifierDynamicRouter : DynamicRouter +{ + protected static NotifierCallbacks _notifierCallbacks; + + public NotifierDynamicRouter( + JsonUtil jsonUtil, + NotifierCallbacks notifierCallbacks + ) : base( + jsonUtil, + [ + new RouteAction( + "/?last_id", + ( + url, + info, + sessionID, + output + ) => _notifierCallbacks.Notify(url, info, sessionID)), + new RouteAction( + "/notifierServer", + ( + url, + info, + sessionID, + output + ) => _notifierCallbacks.Notify(url, info, sessionID)), + new RouteAction( + "/push/notifier/get/", + ( + url, + info, + sessionID, + output + ) => _notifierCallbacks.GetNotifier(url, info, sessionID)), + new RouteAction( + "/push/notifier/getwebsocket/", + ( + url, + info, + sessionID, + output + ) => _notifierCallbacks.GetNotifier(url, info, sessionID)), + ] + ) + { + _notifierCallbacks = notifierCallbacks; + } +} diff --git a/Core/Routers/Dynamic/TraderDynamicRouter.cs b/Core/Routers/Dynamic/TraderDynamicRouter.cs new file mode 100644 index 00000000..b2fe30f1 --- /dev/null +++ b/Core/Routers/Dynamic/TraderDynamicRouter.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.Dynamic; + +[Injectable(InjectableTypeOverride = typeof(DynamicRouter))] +public class TraderDynamicRouter : DynamicRouter +{ + protected static TraderCallbacks _traderCallbacks; + + public TraderDynamicRouter( + JsonUtil jsonUtil, + TraderCallbacks traderCallbacks + ) : base( + jsonUtil, + [ + new RouteAction( + "/client/trading/api/getTrader/", + ( + url, + info, + sessionID, + output + ) => _traderCallbacks.GetTrader(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/trading/api/getTraderAssort/", + ( + url, + info, + sessionID, + output + ) => _traderCallbacks.GetAssort(url, info as EmptyRequestData, sessionID)), + ] + ) + { + _traderCallbacks = traderCallbacks; + } +} diff --git a/Core/Routers/Static/AchievementStaticRouter.cs b/Core/Routers/Static/AchievementStaticRouter.cs new file mode 100644 index 00000000..2f883537 --- /dev/null +++ b/Core/Routers/Static/AchievementStaticRouter.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 AchievementStaticRouter : StaticRouter +{ + protected static AchievementCallbacks _achievementCallbacks; + + public AchievementStaticRouter( + JsonUtil jsonUtil, + AchievementCallbacks achievementCallbacks + ) : base( + jsonUtil, + [ + new RouteAction( + "/client/achievement/list", + ( + url, + info, + sessionID, + output + ) => _achievementCallbacks.GetAchievements(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/achievement/statistic", + ( + url, + info, + sessionID, + output + ) => _achievementCallbacks.Statistic(url, info as EmptyRequestData, sessionID)), + ] + ) + { + _achievementCallbacks = achievementCallbacks; + } +} diff --git a/Core/Routers/Static/BotStaticRouter.cs b/Core/Routers/Static/BotStaticRouter.cs new file mode 100644 index 00000000..89c681c2 --- /dev/null +++ b/Core/Routers/Static/BotStaticRouter.cs @@ -0,0 +1,34 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.Bot; +using Core.Utils; + +namespace Core.Routers.Static; + +[Injectable(InjectableTypeOverride = typeof(StaticRouter))] +public class BotStaticRouter : StaticRouter +{ + protected static BotCallbacks _botCallbacks; + + public BotStaticRouter( + JsonUtil jsonUtil, + BotCallbacks botCallbacks + ) : base( + jsonUtil, + [ + new RouteAction( + "", + ( + url, + info, + sessionID, + outout + ) => _botCallbacks.GenerateBots(url, info as GenerateBotsRequestData, sessionID), + typeof(GenerateBotsRequestData)) + ] + ) + { + _botCallbacks = botCallbacks; + } +} diff --git a/Core/Routers/Static/BuildStaticRouter.cs b/Core/Routers/Static/BuildStaticRouter.cs new file mode 100644 index 00000000..250c16a2 --- /dev/null +++ b/Core/Routers/Static/BuildStaticRouter.cs @@ -0,0 +1,70 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.Builds; +using Core.Models.Eft.Common; +using Core.Models.Eft.PresetBuild; +using Core.Utils; + +namespace Core.Routers.Static; + +[Injectable(InjectableTypeOverride = typeof(StaticRouter))] +public class BuildStaticRouter : StaticRouter +{ + protected static BuildsCallbacks _buildsCallbacks; + public BuildStaticRouter( + JsonUtil jsonUtil, + BuildsCallbacks buildsCallbacks + ) : base( + jsonUtil, + [ + new RouteAction( + "/client/builds/list", + ( + url, + info, + sessionID, + output + ) => _buildsCallbacks.GetBuilds(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/builds/magazine/save", + ( + url, + info, + sessionID, + output + ) => _buildsCallbacks.CreateMagazineTemplate(url, info as SetMagazineRequest, sessionID), + typeof(SetMagazineRequest)), + new RouteAction( + "/client/builds/weapon/save", + ( + url, + info, + sessionID, + output + ) => _buildsCallbacks.SetWeapon(url, info as PresetBuildActionRequestData, sessionID), + typeof(PresetBuildActionRequestData)), + new RouteAction( + "/client/builds/equipment/save", + ( + url, + info, + sessionID, + output + ) => _buildsCallbacks.SetEquipment(url, info as PresetBuildActionRequestData, sessionID), + typeof(PresetBuildActionRequestData)), + new RouteAction( + "/client/builds/delete", + ( + url, + info, + sessionID, + output + ) => _buildsCallbacks.DeleteBuild(url, info as RemoveBuildRequestData, sessionID), + typeof(RemoveBuildRequestData)), + ] + ) + { + _buildsCallbacks = buildsCallbacks; + } +} diff --git a/Core/Routers/Static/BundleStaticRouter.cs b/Core/Routers/Static/BundleStaticRouter.cs new file mode 100644 index 00000000..525ff3b8 --- /dev/null +++ b/Core/Routers/Static/BundleStaticRouter.cs @@ -0,0 +1,33 @@ +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 BundleStaticRouter : StaticRouter +{ + protected static BundleCallbacks _bundleCallbacks; + + public BundleStaticRouter( + JsonUtil jsonUtil, + BundleCallbacks bundleCallbacks + ) : base( + jsonUtil, + [ + new RouteAction( + "/singleplayer/bundles", + ( + url, + info, + sessionID, + output + ) => _bundleCallbacks.GetBundles(url, info as EmptyRequestData, sessionID)) + ] + ) + { + _bundleCallbacks = bundleCallbacks; + } +} diff --git a/Core/Routers/Static/ClientLogStaticRouter.cs b/Core/Routers/Static/ClientLogStaticRouter.cs new file mode 100644 index 00000000..9796772b --- /dev/null +++ b/Core/Routers/Static/ClientLogStaticRouter.cs @@ -0,0 +1,50 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Spt.Logging; +using Core.Utils; + +namespace Core.Routers.Static; + +[Injectable(InjectableTypeOverride = typeof(StaticRouter))] +public class ClientLogStaticRouter : StaticRouter +{ + protected static ClientLogCallbacks _clientLogCallbacks; + + public ClientLogStaticRouter( + JsonUtil jsonUtil, + ClientLogCallbacks clientLogCallbacks + ) : base( + jsonUtil, + [ + new RouteAction( + "/singleplayer/log", + ( + url, + info, + sessionID, + output + ) => _clientLogCallbacks.ClientLog(url, info as ClientLogRequest, sessionID), + typeof(ClientLogRequest)), + new RouteAction( + "/singleplayer/release", + ( + url, + info, + sessionID, + output + ) => _clientLogCallbacks.ReleaseNotes()), + new RouteAction( + "/singleplayer/enableBSGlogging", + ( + url, + info, + sessionID, + output + ) => _clientLogCallbacks.BsgLogging()) + ] + ) + { + _clientLogCallbacks = clientLogCallbacks; + } +} diff --git a/Core/Routers/Static/CustomizationStaticRouter.cs b/Core/Routers/Static/CustomizationStaticRouter.cs new file mode 100644 index 00000000..41163802 --- /dev/null +++ b/Core/Routers/Static/CustomizationStaticRouter.cs @@ -0,0 +1,49 @@ +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 CustomizationStaticRouter : StaticRouter +{ + protected static CustomizationCallbacks _customizationCallbacks; + + public CustomizationStaticRouter( + JsonUtil jsonUtil, + CustomizationCallbacks customizationCallbacks + ) : base( + jsonUtil, + [ + new RouteAction( + "/client/trading/customization/storage", + ( + url, + info, + sessionID, + output + ) => _customizationCallbacks.GetSuits(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/hideout/customization/offer/list", + ( + url, + info, + sessionID, + output + ) => _customizationCallbacks.GetHideoutCustomisation(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/customization/storage", + ( + url, + info, + sessionID, + output + ) => _customizationCallbacks.GetStorage(url, info as EmptyRequestData, sessionID)), + ] + ) + { + _customizationCallbacks = customizationCallbacks; + } +} diff --git a/Core/Routers/Static/DataStaticRouter.cs b/Core/Routers/Static/DataStaticRouter.cs new file mode 100644 index 00000000..c277d5be --- /dev/null +++ b/Core/Routers/Static/DataStaticRouter.cs @@ -0,0 +1,112 @@ +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 DataStaticRouter : StaticRouter +{ + protected static DataCallbacks _dataCallbacks; + + public DataStaticRouter( + JsonUtil jsonUtil, + DataCallbacks dataCallbacks + ) : base( + jsonUtil, + [ + new RouteAction( + "/client/settings", + ( + url, + info, + sessionID, + output + ) => _dataCallbacks.GetSettings(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/globals", + ( + url, + info, + sessionID, + output + ) => _dataCallbacks.GetGlobals(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/items", + ( + url, + info, + sessionID, + output + ) => _dataCallbacks.GetTemplateItems(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/handbook/templates", + ( + url, + info, + sessionID, + output + ) => _dataCallbacks.GetTemplateHandbook(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/customization", + ( + url, + info, + sessionID, + output + ) => _dataCallbacks.GetTemplateSuits(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/account/customization", + ( + url, + info, + sessionID, + output + ) => _dataCallbacks.GetTemplateCharacter(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/hideout/production/recipes", + ( + url, + info, + sessionID, + output + ) => _dataCallbacks.GetHideoutProduction(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/hideout/settings", + ( + url, + info, + sessionID, + output + ) => _dataCallbacks.GetHideoutSettings(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/hideout/areas", + ( + url, + info, + sessionID, + output + ) => _dataCallbacks.GetHideoutAreas(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/languages", + ( + url, + info, + sessionID, + output + ) => _dataCallbacks.GetLocalesLanguages(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/hideout/qte/list", + ( + url, + info, + sessionID, + output + ) => _dataCallbacks.GetQteList(url, info as EmptyRequestData, sessionID)),] + ) + { + _dataCallbacks = dataCallbacks; + } +} diff --git a/Core/Routers/Static/DialogStaticRouter.cs b/Core/Routers/Static/DialogStaticRouter.cs new file mode 100644 index 00000000..b58493ef --- /dev/null +++ b/Core/Routers/Static/DialogStaticRouter.cs @@ -0,0 +1,266 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.Common; +using Core.Models.Eft.Common.Request; +using Core.Models.Eft.Dialog; +using Core.Utils; + +namespace Core.Routers.Static; + +[Injectable(InjectableTypeOverride = typeof(StaticRouter))] +public class DialogStaticRouter : StaticRouter +{ + protected static DialogueCallbacks _dialogueCallbacks; + + public DialogStaticRouter( + JsonUtil jsonUtil, + DialogueCallbacks dialogueCallbacks + ) : base( + jsonUtil, + [ + new RouteAction( + "/client/chatServer/list", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.GetChatServerList(url, info as GetChatServerListRequestData, sessionID), + typeof(GetChatServerListRequestData)), + new RouteAction( + "/client/mail/dialog/list", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.GetMailDialogList(url, info as GetMailDialogListRequestData, sessionID), + typeof(GetMailDialogListRequestData)), + new RouteAction( + "/client/mail/dialog/view", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.GetMailDialogView(url, info as GetMailDialogViewRequestData, sessionID), + typeof(GetMailDialogViewRequestData)), + new RouteAction( + "/client/mail/dialog/info", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.GetMailDialogInfo(url, info as GetMailDialogInfoRequestData, sessionID), + typeof(GetMailDialogInfoRequestData)), + new RouteAction( + "/client/mail/dialog/remove", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.RemoveDialog(url, info as RemoveDialogRequestData, sessionID), + typeof(RemoveDialogRequestData)), + new RouteAction( + "/client/mail/dialog/pin", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.PinDialog(url, info as PinDialogRequestData, sessionID), + typeof(PinDialogRequestData)), + new RouteAction( + "/client/mail/dialog/unpin", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.UnpinDialog(url, info as PinDialogRequestData, sessionID), + typeof(PinDialogRequestData)), + new RouteAction( + "/client/mail/dialog/read", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.SetRead(url, info as SetDialogReadRequestData, sessionID), + typeof(SetDialogReadRequestData)), + new RouteAction( + "/client/mail/dialog/remove", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.RemoveMail(url, info as RemoveMailMessageRequest, sessionID), + typeof(RemoveMailMessageRequest)), + new RouteAction( + "/client/mail/dialog/getAllAttachments", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.GetAllAttachments(url, info as GetAllAttachmentsRequestData, sessionID), + typeof(GetAllAttachmentsRequestData)), + new RouteAction( + "/client/mail/msg/send", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.SendMessage(url, info as SendMessageRequest, sessionID), + typeof(SendMessageRequest)), + new RouteAction( + "client/mail/dialog/clear", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.ClearMail(url, info as ClearMailMessageRequest, sessionID), + typeof(ClearMailMessageRequest)), + new RouteAction( + "/client/mail/dialog/group/create", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.CreateGroupMail(url, info as CreateGroupMailRequest, sessionID), + typeof(CreateGroupMailRequest)), + new RouteAction( + "/client/mail/dialog/group/owner/change", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.ChangeMailGroupOwner(url, info as ChangeGroupMailOwnerRequest, sessionID), + typeof(ChangeGroupMailOwnerRequest)), + new RouteAction( + "/client/mail/dialog/group/users/add", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.AddUserToMail(url, info as AddUserGroupMailRequest, sessionID), + typeof(AddUserGroupMailRequest)), + new RouteAction( + "/client/mail/dialog/group/users/remove", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.RemoveUserFromMail(url, info as RemoveUserGroupMailRequest, sessionID), + typeof(RemoveUserGroupMailRequest)), + new RouteAction( + "/client/friend/list", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.GetFriendList(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/friend/request/list/outbox", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.ListOutbox(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/friend/request/list/inbox", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.ListInbox(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/friend/request/send", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.SendFriendRequest(url, info as FriendRequestData, sessionID), + typeof(FriendRequestData)), + new RouteAction( + "/client/friend/request/accept-all", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.AcceptAllFriendRequests(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/friend/request/accept", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.AcceptFriendRequest(url, info as AcceptFriendRequestData, sessionID), + typeof(AcceptFriendRequestData)), + new RouteAction( + "/client/friend/request/decline", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.DeclineFriendRequest(url, info as DeclineFriendRequestData, sessionID), + typeof(DeclineFriendRequestData)), + new RouteAction( + "/client/friend/request/cancel", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.CancelFriendRequest(url, info as CancelFriendRequestData, sessionID), + typeof(CancelFriendRequestData)), + new RouteAction( + "/client/friend/delete", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.DeleteFriend(url, info as DeleteFriendRequest, sessionID), + typeof(DeleteFriendRequest)), + new RouteAction( + "/client/friend/ignore/set", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.IgnoreFriend(url, info as UIDRequestData, sessionID), + typeof(UIDRequestData)), + new RouteAction( + "", + ( + url, + info, + sessionID, + output + ) => _dialogueCallbacks.UnIgnoreFriend(url, info as UIDRequestData, sessionID), + typeof(UIDRequestData)), + ] + ) + { + _dialogueCallbacks = dialogueCallbacks; + } +} diff --git a/Core/Routers/Static/GameStaticRouter.cs b/Core/Routers/Static/GameStaticRouter.cs new file mode 100644 index 00000000..95f2fb6b --- /dev/null +++ b/Core/Routers/Static/GameStaticRouter.cs @@ -0,0 +1,168 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.Controllers; +using Core.DI; +using Core.Models.Eft.Common; +using Core.Models.Eft.Common.Request; +using Core.Models.Eft.Common.Tables; +using Core.Models.Eft.Game; +using Core.Servers; +using Core.Utils; + +namespace Core.Routers.Static; + +[Injectable(InjectableTypeOverride = typeof(StaticRouter))] +public class GameStaticRouter : StaticRouter +{ + protected static GameCallbacks _gameCallbacks; + + public GameStaticRouter( + JsonUtil jsonUtil, + GameCallbacks gameCallbacks + ) : base + ( + jsonUtil, + [ + new RouteAction( + "/client/game/config", + ( + url, + info, + sessionID, + output + ) => _gameCallbacks.GetGameConfig(url, info as GameEmptyCrcRequestData, sessionID), + typeof(GameEmptyCrcRequestData)), + new RouteAction( + "/client/game/mode", + ( + url, + info, + sessionID, + output + ) => _gameCallbacks.GetGameMode(url, info as GameModeRequestData, sessionID), + typeof(GameModeRequestData)), + new RouteAction( + "/client/server/list", + ( + url, + info, + sessionID, + output + ) => _gameCallbacks.GetServer(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/match/group/current", + ( + url, + info, + sessionID, + output + ) => _gameCallbacks.GetCurrentGroup(url, info as EmptyRequestData, sessionID), + typeof(GameModeRequestData)), + new RouteAction( + "/client/game/version/validate", + ( + url, + info, + sessionID, + output + ) => _gameCallbacks.VersionValidate(url, info as VersionValidateRequestData, sessionID), + typeof(VersionValidateRequestData)), + new RouteAction( + "/client/game/start", + ( + url, + info, + sessionID, + output + ) => _gameCallbacks.GameStart(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/game/logout", + ( + url, + info, + sessionID, + output + ) => _gameCallbacks.GameLogout(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/checkVersion", + ( + url, + info, + sessionID, + output + ) => _gameCallbacks.ValidateGameVersion(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/game/keepalive", + ( + url, + info, + sessionID, + output + ) => _gameCallbacks.GameKeepalive(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/singleplayer/settings/version", + ( + url, + info, + sessionID, + output + ) => _gameCallbacks.GetVersion(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/reports/lobby/send", + ( + url, + info, + sessionID, + output + ) => _gameCallbacks.ReportNickname(url, info as UIDRequestData, sessionID), + typeof(UIDRequestData)), + new RouteAction( + "/client/report/send", + ( + url, + info, + sessionID, + output + ) => _gameCallbacks.ReportNickname(url, info as UIDRequestData, sessionID), + typeof(GameModeRequestData)), + new RouteAction( + "/singleplayer/settings/getRaidTime", + ( + url, + info, + sessionID, + output + ) => _gameCallbacks.GetRaidTime(url, info as GetRaidTimeRequest, sessionID), + typeof(GetRaidTimeRequest)), + new RouteAction( + "/client/survey", + ( + url, + info, + sessionID, + output + ) => _gameCallbacks.GetSurvey(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/survey/view", + ( + url, + info, + sessionID, + output + ) => _gameCallbacks.GetSurveyView(url, info as SendSurveyOpinionRequest, sessionID), + typeof(SendSurveyOpinionRequest)), + new RouteAction( + "/client/survey/opinion", + ( + url, + info, + sessionID, + output + ) => _gameCallbacks.SendSurveyOpinion(url, info as SendSurveyOpinionRequest, sessionID), + typeof(SendSurveyOpinionRequest)), + ] + ) + { + _gameCallbacks = gameCallbacks; + } +} diff --git a/Core/Routers/Static/HealthStaticRouter.cs b/Core/Routers/Static/HealthStaticRouter.cs new file mode 100644 index 00000000..a48eac3b --- /dev/null +++ b/Core/Routers/Static/HealthStaticRouter.cs @@ -0,0 +1,34 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.Health; +using Core.Utils; + +namespace Core.Routers.Static; + +[Injectable(InjectableTypeOverride = typeof(StaticRouter))] +public class HealthStaticRouter : StaticRouter +{ + protected static HealthCallbacks _healthCallbacks; + + public HealthStaticRouter( + JsonUtil jsonUtil, + HealthCallbacks healthCallbacks + ) : base( + jsonUtil, + [ + new RouteAction( + "/client/hideout/workout", + ( + url, + info, + sessionID, + output + ) => _healthCallbacks.handleWorkoutEffects(url, info as WorkoutData, sessionID), + typeof(WorkoutData)), + ] + ) + { + _healthCallbacks = healthCallbacks; + } +} diff --git a/Core/Routers/Static/InraidStaticRouter.cs b/Core/Routers/Static/InraidStaticRouter.cs new file mode 100644 index 00000000..a8bce39f --- /dev/null +++ b/Core/Routers/Static/InraidStaticRouter.cs @@ -0,0 +1,53 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.Common; +using Core.Models.Eft.InRaid; +using Core.Utils; +using Microsoft.AspNetCore.Components.Web; + +namespace Core.Routers.Static; + +[Injectable(InjectableTypeOverride = typeof(StaticRouter))] +public class InraidStaticRouter : StaticRouter +{ + public InraidStaticRouter(InraidCallbacks inraidCallbacks, JsonUtil jsonUtil) : base( + jsonUtil, + [ + new RouteAction( + "/raid/profile/scavsave", + ( + url, + info, + sessionID, + output + ) => inraidCallbacks.SaveProgress(url, info as ScavSaveRequestData, sessionID), + typeof(ScavSaveRequestData)), + new RouteAction( + "/singleplayer/settings/raid/menu", + ( + url, + info, + sessionID, + output + ) => inraidCallbacks.GetRaidMenuSettings()), + new RouteAction( + "/singleplayer/scav/traitorscavhostile", + ( + url, + info, + sessionID, + output + ) => inraidCallbacks.GetTraitorScavHostileChance(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/singleplayer/bossconvert", + ( + url, + info, + sessionID, + output + ) => inraidCallbacks.GetBossConvertSettings(url, info as EmptyRequestData, sessionID)), + ]) + { + } +} diff --git a/Core/Routers/Static/InsuranceStaticRouter.cs b/Core/Routers/Static/InsuranceStaticRouter.cs new file mode 100644 index 00000000..0d97f0fa --- /dev/null +++ b/Core/Routers/Static/InsuranceStaticRouter.cs @@ -0,0 +1,34 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.Insurance; +using Core.Utils; + +namespace Core.Routers.Static; + +[Injectable(InjectableTypeOverride = typeof(StaticRouter))] +public class InsuranceStaticRouter : StaticRouter +{ + protected static InsuranceCallbacks _insuranceCallbacks; + + public InsuranceStaticRouter( + JsonUtil jsonUtil, + InsuranceCallbacks insuranceCallbacks + ) : base( + jsonUtil, + [ + new RouteAction( + "/client/insurance/items/list/cost", + ( + url, + info, + sessionID, + output + ) => _insuranceCallbacks.GetInsuranceCost(url, info as GetInsuranceCostRequestData, sessionID), + typeof(GetInsuranceCostRequestData)) + ] + ) + { + _insuranceCallbacks = insuranceCallbacks; + } +} diff --git a/Core/Routers/Static/ItemEventStaticRouter.cs b/Core/Routers/Static/ItemEventStaticRouter.cs new file mode 100644 index 00000000..213d5b37 --- /dev/null +++ b/Core/Routers/Static/ItemEventStaticRouter.cs @@ -0,0 +1,34 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.ItemEvent; +using Core.Utils; + +namespace Core.Routers.Static; + +[Injectable(InjectableTypeOverride = typeof(StaticRouter))] +public class ItemEventStaticRouter : StaticRouter +{ + protected static ItemEventCallbacks _itemEventCallbacks; + + public ItemEventStaticRouter( + JsonUtil jsonUtil, + ItemEventCallbacks itemEventCallbacks + ) : base( + jsonUtil, + [ + new RouteAction( + "/client/game/profile/items/moving", + ( + url, + info, + sessionID, + output + ) => _itemEventCallbacks.HandleEvents(url, info as ItemEventRouterRequest, sessionID), + typeof(ItemEventRouterRequest)) + ] + ) + { + _itemEventCallbacks = itemEventCallbacks; + } +} diff --git a/Core/Routers/Static/LocationStaticRouter.cs b/Core/Routers/Static/LocationStaticRouter.cs new file mode 100644 index 00000000..424f3b86 --- /dev/null +++ b/Core/Routers/Static/LocationStaticRouter.cs @@ -0,0 +1,43 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.Common; +using Core.Models.Eft.Location; +using Core.Utils; + +namespace Core.Routers.Static; + +[Injectable(InjectableTypeOverride = typeof(StaticRouter))] +public class LocationStaticRouter : StaticRouter +{ + protected static LocationCallbacks _locationCallbacks; + + public LocationStaticRouter( + JsonUtil jsonUtil, + LocationCallbacks locationCallbacks + ) : base( + jsonUtil, + [ + new RouteAction( + "/client/locations", + ( + url, + info, + sessionID, + output + ) => _locationCallbacks.GetLocationData(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/airdrop/loot", + ( + url, + info, + sessionID, + output + ) => _locationCallbacks.GetAirdropLoot(url, info as GetAirdropLootRequest, sessionID), + typeof(GetAirdropLootRequest)) + ] + ) + { + _locationCallbacks = locationCallbacks; + } +} diff --git a/Core/Routers/Static/MatchStaticRouter.cs b/Core/Routers/Static/MatchStaticRouter.cs new file mode 100644 index 00000000..eed1b082 --- /dev/null +++ b/Core/Routers/Static/MatchStaticRouter.cs @@ -0,0 +1,266 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.Common; +using Core.Models.Eft.Match; +using Core.Utils; + +namespace Core.Routers.Static; + +[Injectable(InjectableTypeOverride = typeof(StaticRouter))] +public class MatchStaticRouter : StaticRouter +{ + protected static MatchCallbacks _matchCallbacks; + + public MatchStaticRouter( + JsonUtil jsonUtil, + MatchCallbacks matchCallbacks + ) : base( + jsonUtil, + [ + new RouteAction( + "/client/match/available", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.ServerAvailable(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/match/updatePing", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.UpdatePing(url, info as UpdatePingRequestData, sessionID), + typeof(UpdatePingRequestData)), + new RouteAction( + "/client/match/join", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.JoinMatch(url, info as MatchGroupStartGameRequest, sessionID), + typeof(MatchGroupStartGameRequest)), + new RouteAction( + "/client/match/exit", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.ExitMatch(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/match/group/delete", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.DeleteGroup(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/match/group/leave", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.LeaveGroup(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/match/group/status", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.GetGroupStatus(url, info as MatchGroupStatusRequest, sessionID), + typeof(MatchGroupStatusRequest)), + new RouteAction( + "/client/match/group/start_game", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.JoinMatch(url, info as MatchGroupStartGameRequest, sessionID), + typeof(MatchGroupStartGameRequest)), + new RouteAction( + "/client/match/group/exit_from_menu", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.ExitFromMenu(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/match/group/current", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.GroupCurrent(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/match/group/looking/start", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.StartGroupSearch(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/match/group/looking/stop", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.StopGroupSearch(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/match/group/invite/send", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.SendGroupInvite(url, info as MatchGroupInviteSendRequest, sessionID), + typeof(MatchGroupInviteSendRequest)), + new RouteAction( + "/client/match/group/invite/accept", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.AcceptGroupInvite(url, info as RequestIdRequest, sessionID), + typeof(RequestIdRequest)), + new RouteAction( + "/client/match/group/invite/decline", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.DeclineGroupInvite(url, info as RequestIdRequest, sessionID), + typeof(RequestIdRequest)), + new RouteAction( + "/client/match/group/invite/cancel", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.CancelGroupInvite(url, info as RequestIdRequest, sessionID), + typeof(RequestIdRequest)), + new RouteAction( + "/client/match/group/invite/cancel-all", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.CancelAllGroupInvite(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/match/group/transfer", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.TransferGroup(url, info as MatchGroupTransferRequest, sessionID), + typeof(MatchGroupTransferRequest)), + new RouteAction( + "/client/match/group/raid/ready", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.RaidReady(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/match/group/raid/not-ready", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.NotRaidReady(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/putMetrics", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.PutMetrics(url, info as PutMetricsRequestData, sessionID), + typeof(PutMetricsRequestData)), + new RouteAction( + "/client/analytics/event-disconnect", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.EventDisconnect(url, info as PutMetricsRequestData, sessionID), + typeof(PutMetricsRequestData)), + new RouteAction( + "/client/getMetricsConfig", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.GetMetrics(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/raid/configuration", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.GetRaidConfiguration(url, info as GetRaidConfigurationRequestData, sessionID), + typeof(GetRaidConfigurationRequestData)), + new RouteAction( + "/client/raid/configuration-by-profile", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.GetConfigurationByProfile(url, info as GetRaidConfigurationRequestData, sessionID), + typeof(GetRaidConfigurationRequestData)), + new RouteAction( + "/client/match/group/player/remove", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.RemovePlayerFromGroup(url, info as MatchGroupPlayerRemoveRequest, sessionID), + typeof(MatchGroupPlayerRemoveRequest)), + new RouteAction( + "/client/match/local/start", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.StartLocalRaid(url, info as StartLocalRaidRequestData, sessionID), + typeof(StartLocalRaidRequestData)), + new RouteAction( + "/client/match/local/end", + ( + url, + info, + sessionID, + output + ) => _matchCallbacks.EndLocalRaid(url, info as EndLocalRaidRequestData, sessionID), + typeof(EndLocalRaidRequestData)) + ] + ) + { + _matchCallbacks = matchCallbacks; + } +} diff --git a/Core/Routers/Static/NotifierStaticRouter.cs b/Core/Routers/Static/NotifierStaticRouter.cs new file mode 100644 index 00000000..a560cc3c --- /dev/null +++ b/Core/Routers/Static/NotifierStaticRouter.cs @@ -0,0 +1,43 @@ +using Core.Annotations; +using Core.Callbacks; +using Core.DI; +using Core.Models.Eft.Common; +using Core.Models.Eft.Common.Request; +using Core.Utils; + +namespace Core.Routers.Static; + +[Injectable(InjectableTypeOverride = typeof(StaticRouter))] +public class NotifierStaticRouter : StaticRouter +{ + protected static NotifierCallbacks _notifierCallbacks; + + public NotifierStaticRouter( + JsonUtil jsonUtil, + NotifierCallbacks notifierCallbacks + ) : base( + jsonUtil, + [ + new RouteAction( + "/client/notifier/channel/create", + ( + url, + info, + sessionID, + output + ) => _notifierCallbacks.CreateNotifierChannel(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/game/profile/select", + ( + url, + info, + sessionID, + output + ) => _notifierCallbacks.SelectProfile(url, info as UIDRequestData, sessionID), + typeof(UIDRequestData)), + ] + ) + { + _notifierCallbacks = notifierCallbacks; + } +} diff --git a/Core/Routers/Static/PrestigeStaticRouter.cs b/Core/Routers/Static/PrestigeStaticRouter.cs new file mode 100644 index 00000000..796eb39f --- /dev/null +++ b/Core/Routers/Static/PrestigeStaticRouter.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 PrestigeStaticRouter : StaticRouter +{ + protected static PrestigeCallbacks _presetCallbacks; + + public PrestigeStaticRouter( + JsonUtil jsonUtil, + PrestigeCallbacks prestigeCallbacks + ) : base( + jsonUtil, + [ + new RouteAction( + "/client/prestige/list", + ( + url, + info, + sessionID, + output + ) => _presetCallbacks.GetPrestige(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/client/prestige/obtain", + ( + url, + info, + sessionID, + output + ) => _presetCallbacks.ObtainPrestige(url, info as EmptyRequestData, sessionID)) + ] + ) + { + _presetCallbacks = prestigeCallbacks; + } +} diff --git a/Core/Routers/Static/QuestStaticRouter.cs b/Core/Routers/Static/QuestStaticRouter.cs new file mode 100644 index 00000000..37240fdf --- /dev/null +++ b/Core/Routers/Static/QuestStaticRouter.cs @@ -0,0 +1,40 @@ +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 QuestStaticRouter : StaticRouter +{ + protected static QuestCallbacks _questCallbacks; + + public QuestStaticRouter( + JsonUtil jsonUtil, + QuestCallbacks questCallbacks + ) : base( + jsonUtil, + [ + new RouteAction( + "", + ( + url, + info, + sessionID, + output + ) => _questCallbacks.ListQuests(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "", + ( + url, + info, + sessionID, + output + ) => _questCallbacks.GetBuilds(url, info as EmptyRequestData, sessionID)),] + ) + { + _questCallbacks = questCallbacks; + } +} diff --git a/Core/Routers/Static/TraderStaticRouter.cs b/Core/Routers/Static/TraderStaticRouter.cs new file mode 100644 index 00000000..b7ce7201 --- /dev/null +++ b/Core/Routers/Static/TraderStaticRouter.cs @@ -0,0 +1,42 @@ +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 TraderStaticRouter : StaticRouter +{ + protected static TraderCallbacks _traderCallbacks; + + public TraderStaticRouter( + JsonUtil jsonUtil, + TraderCallbacks traderCallbacks + ) : base + ( + jsonUtil, + [ + new RouteAction( + "/client/trading/api/traderSettings", + ( + url, + info, + sessionID, + output + ) => _traderCallbacks.GetTraderSettings(url, info as EmptyRequestData, sessionID)), + new RouteAction( + "/singleplayer/moddedTraders", + ( + url, + info, + sessionID, + output + ) => _traderCallbacks.GetModdedTraderData(url, info as EmptyRequestData, sessionID)) + ] + ) + { + _traderCallbacks = traderCallbacks; + } +} diff --git a/Core/Utils/App.cs b/Core/Utils/App.cs index 6c7a3421..5ef4b347 100644 --- a/Core/Utils/App.cs +++ b/Core/Utils/App.cs @@ -80,23 +80,10 @@ public class App _logger.Debug("Commit: ${ProgramStatics.COMMIT}"); } */ - foreach (var onLoad in _onLoad) - { - Console.WriteLine($"Start Onload: {onLoad.GetRoute()}"); + foreach (var onLoad in _onLoad) await onLoad.OnLoad(); - Console.WriteLine($"finish Onload: {onLoad.GetRoute()}"); - } - new Timer(_ => - { - Console.WriteLine($"Start OnUpdate"); - Update(_onUpdate); - Console.WriteLine($"Finish OnUpdate"); - - }, - null, - TimeSpan.Zero, - TimeSpan.FromMilliseconds(5000)); + new Timer(_ => Update(_onUpdate), null, TimeSpan.Zero, TimeSpan.FromMilliseconds(5000)); } protected async Task Update(IEnumerable onUpdateComponents)