Add customerId outgoing call filter. Migrate more endpoints to orleans

Author: brasky

src/OWS.Grains/CharacterGrain.cs

@@ -8,6 +8,10 @@
 using OWSShared.Options;
 using RabbitMQ.Client;
 using OWS.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+using OWSData.Models.Composites;
+using Orleans.Runtime;
+using System.Text.RegularExpressions;
 
 namespace OWS.Grains
 {
@@ -17,23 +21,136 @@ public class CharacterGrain : Grain, ICharacterGrain
         private readonly IUsersRepository _usersRepository;
         private readonly ICharactersRepository _charactersRepository;
         private readonly IOptions<RabbitMQOptions> _rabbitMQOptions;
+        private readonly ICustomCharacterDataSelector _customCharacterDataSelector;
+        private readonly IGetReadOnlyPublicCharacterData _getReadOnlyPublicCharacterData;
 
         public CharacterGrain(
 
             ILogger<CharacterGrain> logger,
             IUsersRepository usersRepository,
             ICharactersRepository charactersRepository,
-            IOptions<RabbitMQOptions> rabbitMQOptions)
+            IOptions<RabbitMQOptions> rabbitMQOptions,
+            ICustomCharacterDataSelector customCharacterDataSelector,
+            IGetReadOnlyPublicCharacterData getReadOnlyPublicCharacterData)
         {
             _logger = logger;
             _usersRepository = usersRepository;
             _charactersRepository = charactersRepository;
             _rabbitMQOptions = rabbitMQOptions;
+            _customCharacterDataSelector = customCharacterDataSelector;
+            _getReadOnlyPublicCharacterData = getReadOnlyPublicCharacterData;
         }
 
-        public async Task<JoinMapByCharName> GetServerToConnectTo(Guid customerGuid, string zoneName, int playerGroupType)
+        public async Task<CreateCharacter> Create(Guid userSessionId, string className)
+        {
+            if (Guid.TryParse(RequestContext.Get("CustomerId") as string, out var customerGuid))
+            {
+                throw new ArgumentException("Invalid Customer ID");
+            }
+
+            var charName = this.GetPrimaryKeyString();
+
+            string errorMessage = string.Empty;
+            //Test for empty Character Names or Character Names that are shorter than the minimum Character name Length
+            if (String.IsNullOrEmpty(charName) || charName.Length < 4)
+            {
+                errorMessage = "Please enter a valid Character Name that is at least 4 characters in length.";
+            }
+
+            Regex regex = new Regex(@"^\w+$");
+            //Test for Character Names that use characters other than Letters (uppercase and lowercase) and Numbers.
+            if (!regex.IsMatch(charName))
+            {
+                errorMessage = "Please enter a Character Name that only contains letters and numbers.";
+            }
+
+            if (!String.IsNullOrEmpty(errorMessage))
+            {
+                CreateCharacter createCharacterErrorMessage = new CreateCharacter();
+                createCharacterErrorMessage.ErrorMessage = errorMessage;
+                return createCharacterErrorMessage;
+            }
+
+            var output = await _usersRepository.CreateCharacter(customerGuid, userSessionId, charName, className);
+
+            return output;
+        }
+
+        public async Task<CharacterAndCustomData> PublicGetByNameRequest(Guid userSessionId)
+        {
+            if (Guid.TryParse(RequestContext.Get("CustomerId") as string, out var customerGuid))
+            {
+                throw new ArgumentException("Invalid Customer ID");
+            }
+
+            CharacterAndCustomData Output = new CharacterAndCustomData();
+
+            var characterName = this.GetPrimaryKeyString();
+
+            //Get the User Session
+            GetUserSession userSession = await _usersRepository.GetUserSession(customerGuid, userSessionId);
+
+            //Make sure the User Session is valid
+            if (userSession == null || !userSession.UserGuid.HasValue)
+            {
+                //TODO: rework to be able to return success bool / error msg instead of throwing
+                throw new ArgumentException("User session is not valid");
+            }
+
+            //Get character data
+            GetCharByCharName characterData = await _charactersRepository.GetCharByCharName(customerGuid, characterName);
+
+            //Make sure the character data is valid and in the right User Session
+            if (characterData == null || !characterData.UserGuid.HasValue || characterData.UserGuid != userSession.UserGuid)
+            {
+                return Output;
+            }
+
+            //Assign the character data to the output object
+            Output.CharacterData = characterData;
+
+            //Get custom character data
+            IEnumerable<CustomCharacterData> customCharacterDataItems = await _charactersRepository.GetCustomCharacterData(customerGuid, characterName);
+
+            //Initialize the list
+            Output.CustomCharacterDataRows = new List<CustomCharacterDataDTO>();
+
+            //Loop through all the CustomCharacterData rows
+            foreach (CustomCharacterData currentCustomCharacterData in customCharacterDataItems)
+            {
+                //Use the ICustomCharacterDataSelector implementation to filter which fields are returned
+                if (_customCharacterDataSelector.ShouldExportThisCustomCharacterDataField(currentCustomCharacterData.CustomFieldName))
+                {
+                    CustomCharacterDataDTO customCharacterDataDTO = new CustomCharacterDataDTO()
+                    {
+                        CustomFieldName = currentCustomCharacterData.CustomFieldName,
+                        FieldValue = currentCustomCharacterData.FieldValue
+                    };
+
+                    //Add the filtered Custom Character Data
+                    Output.CustomCharacterDataRows.Add(customCharacterDataDTO);
+                }
+            }
+
+            //Add Read-only Character Data
+            CustomCharacterDataDTO readOnlyCharacterData = new CustomCharacterDataDTO()
+            {
+                CustomFieldName = "ReadOnlyCharacterData",
+                FieldValue = await _getReadOnlyPublicCharacterData.GetReadOnlyPublicCharacterData(characterData.CharacterId)
+            };
+            Output.CustomCharacterDataRows.Add(readOnlyCharacterData);
+
+            return Output;
+        }
+
+        public async Task<JoinMapByCharName> GetServerToConnectTo(string zoneName, int playerGroupType)
         {
             var Output = new JoinMapByCharName();
+            
+            if (Guid.TryParse(RequestContext.Get("CustomerId") as string, out var customerGuid))
+            {
+                throw new ArgumentException("Invalid Customer ID");
+            }
 
             //If ZoneName is empty, look it up from the character.  This is used for the inital login.
             if (String.IsNullOrEmpty(zoneName) || zoneName == "GETLASTZONENAME")
@@ -77,16 +194,6 @@ public async Task<JoinMapByCharName> GetServerToConnectTo(Guid customerGuid, str
             //There is no zone server running that will accept our connection, so start up a new one
             if (joinMapByCharacterName.NeedToStartupMap)
             {
-
-                //var serverGrain = GrainFactory.GetGrain<IServerGrain>(joinMapByCharacterName.WorldServerID);
-                //await serverGrain.RequestServerSpinUpAsync(
-                //    customerGuid: customerGuid,
-                //    zoneInstanceId: joinMapByCharacterName.MapInstanceID,
-                //    zoneName: joinMapByCharacterName.MapNameToStart,
-                //    port: joinMapByCharacterName.Port);
-                //bool requestSuccess = await RequestServerSpinUp(joinMapByCharacterName.WorldServerID, joinMapByCharacterName.MapInstanceID, joinMapByCharacterName.MapNameToStart, joinMapByCharacterName.Port);\
-
-
                 ConnectionFactory factory = new()
                 {
                     HostName = _rabbitMQOptions.Value.RabbitMQHostName,
@@ -120,15 +227,22 @@ public async Task<JoinMapByCharName> GetServerToConnectTo(Guid customerGuid, str
                                              body: body);
                     }
                 }
-                //Wait OWSGeneralConfig.SecondsToWaitBeforeFirstPollForSpinUp seconds before the first CheckMapInstanceStatus to give it time to spin up
 
+                //TODO: it doesnt make any sense to delay before giving the client a server to connect to
+                //If we have begun to spin up a server, we should just give the client the ip and let them try to connect
+                //If it takes too long client-side then they should reach back out to the api to get a new server.
+                //i.e. why make the client _and_ the api server wait when we could just make the client wait.
+
+                //Wait OWSGeneralConfig.SecondsToWaitBeforeFirstPollForSpinUp seconds before the first CheckMapInstanceStatus to give it time to spin up
                 //Thread.Sleep(owsGeneralConfig.Value.SecondsToWaitBeforeFirstPollForSpinUp);
 
                 //readyForPlayersToConnect = await WaitForServerReadyToConnect(CustomerGUID, joinMapByCharacterName.MapInstanceID);
             }
             //We found a zone server we can connect to, but it is still spinning up.  Wait until it is ready to connect to (up to OWSGeneralConfig.SecondsToWaitForServerSpinUp seconds).
             else if (joinMapByCharacterName.MapInstanceID > 0 && joinMapByCharacterName.MapInstanceStatus == 1)
             {
+                //see comment above for why this doesn't make sense.
+
                 //CheckMapInstanceStatus every OWSGeneralConfig.SecondsToWaitInBetweenSpinUpPolling seconds for up to OWSGeneralConfig.SecondsToWaitForServerSpinUp seconds
                 //readyForPlayersToConnect = await WaitForServerReadyToConnect(CustomerGUID, joinMapByCharacterName.MapInstanceID);
             }
@@ -150,5 +264,72 @@ public async Task<JoinMapByCharName> GetServerToConnectTo(Guid customerGuid, str
             Output.ErrorMessage = "";
             return Output;
         }
+
+        public async Task AddOrUpdateCustomData(AddOrUpdateCustomCharacterData request)
+        {
+            if (Guid.TryParse(RequestContext.Get("CustomerId") as string, out var customerGuid))
+            {
+                throw new ArgumentException("Invalid Customer ID");
+            }
+
+            await _charactersRepository.AddOrUpdateCustomCharacterData(customerGuid, request);
+        }
+
+        public async Task<GetCharByCharName> GetByName()
+        {
+            if (Guid.TryParse(RequestContext.Get("CustomerId") as string, out var customerGuid))
+            {
+                throw new ArgumentException("Invalid Customer ID");
+            }
+
+            return await _charactersRepository.GetCharByCharName(customerGuid, this.GetPrimaryKeyString());
+        }
+
+        public async Task<CustomCharacterDataRows> GetCustomData()
+        {
+            if (Guid.TryParse(RequestContext.Get("CustomerId") as string, out var customerGuid))
+            {
+                throw new ArgumentException("Invalid Customer ID");
+            }
+
+            CustomCharacterDataRows output = new CustomCharacterDataRows();
+
+            output.Rows = await _charactersRepository.GetCustomCharacterData(customerGuid, this.GetPrimaryKeyString());
+
+            return output;
+        }
+
+        public async Task UpdateCharacterPosition(string mapName)
+        {
+            //TODO: UpdateAllPlayerPositions probably merits a MapGrain
+        }
+
+        public async Task<SuccessAndErrorMessage> UpdateCharacterStats(UpdateCharacterStats stats)
+        {
+            SuccessAndErrorMessage successAndErrorMessage = new SuccessAndErrorMessage();
+            successAndErrorMessage.Success = true;
+
+            try
+            {
+                await _charactersRepository.UpdateCharacterStats(stats);
+            }
+            catch (Exception ex)
+            {
+                successAndErrorMessage.ErrorMessage = ex.Message;
+                successAndErrorMessage.Success = false;
+            }
+
+            return successAndErrorMessage;
+        }
+
+        public async Task Logout()
+        {
+            if (Guid.TryParse(RequestContext.Get("CustomerId") as string, out var customerGuid))
+            {
+                throw new ArgumentException("Invalid Customer ID");
+            }
+
+            await _charactersRepository.PlayerLogout(customerGuid, this.GetPrimaryKeyString());
+        }
     }
 }

src/OWS.Grains/UserGrain.cs

@@ -2,6 +2,7 @@
 using OWSData.Models.StoredProcs;
 using OWSData.Repositories.Interfaces;
 using OWS.Interfaces;
+using Orleans.Runtime;
 
 namespace OWS.Grains
 {
@@ -18,8 +19,13 @@ public UserGrain(
             _usersRepository = usersRepository;
         }
 
-        public async Task<GetUserSession> GetUserSessionAsync(Guid customerGuid)
+        public async Task<GetUserSession> GetUserSessionAsync()
         {
+            if (Guid.TryParse(RequestContext.Get("CustomerId") as string, out var customerGuid))
+            {
+                throw new ArgumentException("Invalid Customer ID");
+            }
+
             var session = await _usersRepository.GetUserSession(customerGuid, this.GetPrimaryKey());
             return session;
         }

src/OWS.Interfaces/ICharacterGrain.cs

@@ -1,9 +1,17 @@
-using OWSData.Models.StoredProcs;
+using OWSData.Models.Composites;
+using OWSData.Models.StoredProcs;
 
 namespace OWS.Interfaces
 {
     public interface ICharacterGrain : IGrainWithStringKey
     {
-        Task<JoinMapByCharName> GetServerToConnectTo(Guid customerGuid, string zoneName, int playerGroupType);
+        Task<CharacterAndCustomData> PublicGetByNameRequest(Guid userSessionId);
+        Task<GetCharByCharName> GetByName();
+        Task<JoinMapByCharName> GetServerToConnectTo(string zoneName, int playerGroupType);
+        Task AddOrUpdateCustomData(AddOrUpdateCustomCharacterData request);
+        Task<CustomCharacterDataRows> GetCustomData();
+        Task<SuccessAndErrorMessage> UpdateCharacterStats(UpdateCharacterStats stats);
+        Task Logout();
+        Task<CreateCharacter> Create(Guid userSessionId, string className);
     }
 }

src/OWS.Interfaces/IServerGrain.cs

@@ -4,6 +4,6 @@ namespace OWS.Interfaces
 {
     public interface IUserGrain : IGrainWithGuidKey
     {
-        Task<GetUserSession> GetUserSessionAsync(Guid customerGuid);
+        Task<GetUserSession> GetUserSessionAsync();
     }
 }