Add support for white label login

Author: TobiasBerg

Runtime/Client/LootLockerBaseServerAPI.cs

@@ -12,7 +12,7 @@
 
 namespace LootLocker.LootLockerEnums
 {
-    public enum LootLockerCallerRole { User, Admin, Player };
+    public enum LootLockerCallerRole { User, Admin, Player, Base };
 }
 
 namespace LootLocker
@@ -47,6 +47,9 @@ public void SwitchURL(LootLocker.LootLockerEnums.LootLockerCallerRole mainCaller
                 case LootLocker.LootLockerEnums.LootLockerCallerRole.Player:
                     SERVER_URL = LootLockerConfig.current.playerUrl;
                     break;
+                case LootLocker.LootLockerEnums.LootLockerCallerRole.Base:
+                    SERVER_URL = LootLockerConfig.current.baseUrl;
+                    break;
                 default:
                     SERVER_URL = LootLockerConfig.current.url;
                     break;

Runtime/Client/LootLockerConfig.cs

@@ -25,7 +25,7 @@ public static LootLockerConfig Get()
             return settingsInstance;
         }
 
-        public static bool CreateNewSettings(string apiKey, string gameVersion, platformType platform, bool onDevelopmentMode, DebugLevel debugLevel = DebugLevel.Off, bool allowTokenRefresh = false)
+        public static bool CreateNewSettings(string apiKey, string gameVersion, platformType platform, bool onDevelopmentMode, string domainKey, DebugLevel debugLevel = DebugLevel.Off, bool allowTokenRefresh = false)
         {
             settingsInstance = Resources.Load<LootLockerConfig>("Config/LootLockerConfig");
 
@@ -38,6 +38,7 @@ public static bool CreateNewSettings(string apiKey, string gameVersion, platform
             settingsInstance.developmentMode = onDevelopmentMode;
             settingsInstance.currentDebugLevel = debugLevel;
             settingsInstance.allowTokenRefresh = allowTokenRefresh;
+            settingsInstance.domainKey = domainKey;
 
             return true;
         }
@@ -63,6 +64,8 @@ public static LootLockerConfig current
         [HideInInspector]
         public string adminToken;
         [HideInInspector]
+        public string domainKey;
+        [HideInInspector]
         public int gameID;
         public string game_version = "1.0";
         [HideInInspector]
@@ -78,6 +81,8 @@ public enum platformType { Android, iOS, Steam, PlayStationNetwork }
         public string playerUrl = "https://api.lootlocker.io/player";
         [HideInInspector]
         public string userUrl = "https://api.lootlocker.io/game";
+        [HideInInspector]
+        public string baseUrl = "https://api.lootlocker.io";
         public enum DebugLevel { All, ErrorOnly, NormalOnly, Off }
         public DebugLevel currentDebugLevel;
         public bool allowTokenRefresh = true;

Runtime/Client/LootLockerEndPoints.cs

@@ -7,17 +7,24 @@ namespace LootLocker
     public class LootLockerEndPoints 
     {
         // Authentication
-        [Header("Authentication Endpoints")]
+        [Header("Authentication")]
         public static EndPointClass playerVerification = new EndPointClass("v1/player/verify", LootLockerHTTPMethod.POST);
         public static EndPointClass authenticationRequest = new EndPointClass("v2/session", LootLockerHTTPMethod.POST);
         public static EndPointClass guestSessionRequest = new EndPointClass("v2/session/guest", LootLockerHTTPMethod.POST);
+        public static EndPointClass whiteLabelLoginSessionRequest = new EndPointClass("v2/session/white-label", LootLockerHTTPMethod.POST);
         public static EndPointClass endingSession = new EndPointClass("v1/session", LootLockerHTTPMethod.DELETE);
         public static EndPointClass initialAuthenticationRequest = new EndPointClass("v1/session", LootLockerHTTPMethod.POST);
         public static EndPointClass twoFactorAuthenticationCodeVerification = new EndPointClass("v1/2fa", LootLockerHTTPMethod.POST);
         public static EndPointClass subsequentRequests = new EndPointClass("v1/games", LootLockerHTTPMethod.GET);
 
+        // White Label Login
+        [Header("White Label Login")]
+        public static EndPointClass whiteLabelSignUp = new EndPointClass("white-label-login/sign-up", LootLockerHTTPMethod.POST);
+        public static EndPointClass whiteLabelRequestPasswordReset = new EndPointClass("white-label-login/request-reset-password", LootLockerHTTPMethod.POST);
+        public static EndPointClass whiteLabelRequestAccountVerification = new EndPointClass("white-label-login/request-verification", LootLockerHTTPMethod.POST);
+
         // Player
-        [Header("Player Endpoints")]
+        [Header("Player")]
         public static EndPointClass getPlayerInfo = new EndPointClass("v1/player/info", LootLockerHTTPMethod.GET);
         public static EndPointClass getInventory = new EndPointClass("v1/player/inventory/list", LootLockerHTTPMethod.GET);
         public static EndPointClass getCurrencyBalance = new EndPointClass("v1/player/balance", LootLockerHTTPMethod.GET);
@@ -33,7 +40,7 @@ public class LootLockerEndPoints
         public static EndPointClass setPlayerName = new EndPointClass("player/name", LootLockerHTTPMethod.PATCH);
 
         // Character
-        [Header("Character Endpoints")]
+        [Header("Character")]
         public static EndPointClass characterLoadouts = new EndPointClass("v1/player/character/loadout", LootLockerHTTPMethod.GET);
         public static EndPointClass getOtherPlayersCharacterLoadouts = new EndPointClass("v1/player/character/loadout/{0}?platform={1}", LootLockerHTTPMethod.GET);
         public static EndPointClass updateCharacter = new EndPointClass("v1/player/character/{0}", LootLockerHTTPMethod.PUT);

Runtime/Client/LootLockerServerRequest.cs

@@ -62,6 +62,34 @@ public class LootLockerResponse
 
     }
 
+    /// <summary>
+    /// Convenience factory class for creating some responses that we use often.
+    /// </summary>
+    public class LootLockerResponseFactory
+    {
+        /// <summary>
+        /// Construct an error response to send to the client.
+        /// </summary>
+        public static T Error<T> (string errorMessage) where T : LootLockerResponse, new()
+        {
+            return new T()
+            {
+                success = false,
+                hasError = true,
+                Error = errorMessage,
+                text = errorMessage
+            };
+        }
+
+        /// <summary>
+        /// Construct an error response specifically when the SDK has not been initialized.
+        /// </summary>
+        public static T SDKNotInitializedError<T>() where T : LootLockerResponse, new()
+        {
+            return Error<T>("SDK not initialised");
+        }
+    }
+
     /// <summary>
     /// Construct a request to send to the server.
     /// </summary>
@@ -115,6 +143,34 @@ public static void CallAPI(string endPoint, LootLockerHTTPMethod httpMethod, str
              });
         }
 
+        public static void CallDomainAuthAPI(string endPoint, LootLockerHTTPMethod httpMethod, string body = null, Action<LootLockerResponse> onComplete = null)
+        {
+            if (LootLockerConfig.current.domainKey.ToString().Length == 0)
+            {
+                #if UNITY_EDITOR
+                LootLockerSDKManager.DebugMessage("LootLocker domain key must be set in settings", true);
+                #endif
+                onComplete?.Invoke(LootLockerResponseFactory.Error<LootLockerResponse>("LootLocker domain key must be set in settings"));
+
+                return;
+            }
+
+            Dictionary<string, string> headers = new Dictionary<string, string>();
+            headers.Add("domain-key", LootLockerConfig.current.domainKey);
+
+            if (LootLockerConfig.current.developmentMode)
+            {
+                headers.Add("is-development", "true");
+            }
+
+            LootLockerBaseServerAPI.I.SwitchURL(LootLockerCallerRole.Base);
+
+            new LootLockerServerRequest(endPoint, httpMethod, body, headers, callerRole: LootLockerCallerRole.Base).Send((response) =>
+            {
+                onComplete?.Invoke(response);
+            });
+        }
+
         public static void UploadFile(string endPoint, LootLockerHTTPMethod httpMethod, byte[] file, string fileName = "file", string fileContentType = "text/plain", Dictionary<string, string> body = null, Action<LootLockerResponse> onComplete = null, bool useAuthToken = true, LootLocker.LootLockerEnums.LootLockerCallerRole callerRole = LootLocker.LootLockerEnums.LootLockerCallerRole.User)
         {
             Dictionary<string, string> headers = new Dictionary<string, string>();

Runtime/Editor/ProjectSettings.cs

@@ -56,20 +56,38 @@ private void DrawGameSettings()
             {
                 gameSettings.apiKey = m_CustomSettings.FindProperty("apiKey").stringValue;
             }
+            var content = new GUIContent();
+            content.text = "API key can be found in `Settings > Game settings > API` in the Web Console";
+            EditorGUILayout.HelpBox(content, false);
+            EditorGUILayout.Space();
+
+            EditorGUI.BeginChangeCheck();
+            
+            EditorGUILayout.PropertyField(m_CustomSettings.FindProperty("domainKey"));
+            if (EditorGUI.EndChangeCheck())
+            {
+                gameSettings.domainKey = m_CustomSettings.FindProperty("domainKey").stringValue;
+            }
+            var domainContent = new GUIContent();
+            domainContent.text = "Domain key can be found in `Settings > Game settings > API` in the Web Console";
+            EditorGUILayout.HelpBox(domainContent, false);
+            EditorGUILayout.Space();
 
             EditorGUI.BeginChangeCheck();
             EditorGUILayout.PropertyField(m_CustomSettings.FindProperty("game_version"));
             if (EditorGUI.EndChangeCheck())
             {
                 gameSettings.game_version = m_CustomSettings.FindProperty("game_version").stringValue;
             }
+            EditorGUILayout.Space();
 
             EditorGUI.BeginChangeCheck();
             EditorGUILayout.PropertyField(m_CustomSettings.FindProperty("platform"));
             if (EditorGUI.EndChangeCheck())
             {
                 gameSettings.platform = (LootLockerConfig.platformType)m_CustomSettings.FindProperty("platform").enumValueIndex;
             }
+            EditorGUILayout.Space();
 
             EditorGUI.BeginChangeCheck();
             EditorGUILayout.PropertyField(m_CustomSettings.FindProperty("developmentMode"));
@@ -78,6 +96,7 @@ private void DrawGameSettings()
             {
                 gameSettings.developmentMode = m_CustomSettings.FindProperty("developmentMode").boolValue;
             }
+            EditorGUILayout.Space();
 
             EditorGUI.BeginChangeCheck();
             EditorGUILayout.PropertyField(m_CustomSettings.FindProperty("currentDebugLevel"));
@@ -86,6 +105,7 @@ private void DrawGameSettings()
             {
                 gameSettings.currentDebugLevel = (LootLockerConfig.DebugLevel)m_CustomSettings.FindProperty("currentDebugLevel").enumValueIndex;
             }
+            EditorGUILayout.Space();
 
             EditorGUI.BeginChangeCheck();
             EditorGUILayout.PropertyField(m_CustomSettings.FindProperty("allowTokenRefresh"));
@@ -94,6 +114,7 @@ private void DrawGameSettings()
             {
                 gameSettings.allowTokenRefresh = m_CustomSettings.FindProperty("allowTokenRefresh").boolValue; 
             }
+            EditorGUILayout.Space();
         }
 
         [SettingsProvider]

Runtime/Game/LootLockerSDKManager.cs

@@ -26,11 +26,11 @@ static bool Init()
             return LoadConfig();
         }
 
-        public static bool Init(string apiKey, string gameVersion, platformType platform, bool onDevelopmentMode)
+        public static bool Init(string apiKey, string gameVersion, platformType platform, bool onDevelopmentMode, string domainKey)
         {
             DebugMessage("SDK is Intializing");
             LootLockerServerManager.CheckInit();
-            return LootLockerConfig.CreateNewSettings(apiKey, gameVersion, platform, onDevelopmentMode);
+            return LootLockerConfig.CreateNewSettings(apiKey, gameVersion, platform, onDevelopmentMode, domainKey);
         }
 
         static bool LoadConfig()
@@ -196,6 +196,27 @@ public static void StartSteamSession(string steamId64, Action<LootLockerSessionR
             LootLockerAPIManager.Session(sessionRequest, onComplete);
         }
 
+        /// <summary>
+        /// Create new user using the white label login system.
+        /// 
+        /// White label platform must be enabled in the web console for this to work.
+        /// </summary>
+        public static void StartWhiteLabelSession(string email, string password, Action<LootLockerSessionResponse> onComplete)
+        {
+            if (!CheckInitialized())
+            {
+                LootLockerSessionResponse response = new LootLockerSessionResponse();
+                response.success = false;
+                response.hasError = true;
+                response.Error = "SDk not initialised";
+                response.text = "SDk not initialised";
+                onComplete?.Invoke(response);
+                return;
+            }
+            LootLockerWhiteLabelSessionRequest sessionRequest = new LootLockerWhiteLabelSessionRequest(email, password);
+            LootLockerAPIManager.WhiteLabelSession(sessionRequest, onComplete);
+        }
+
         public static void EndSession(string deviceId, Action<LootLockerSessionResponse> onComplete)
         {
             if (!CheckInitialized())
@@ -213,6 +234,65 @@ public static void EndSession(string deviceId, Action<LootLockerSessionResponse>
         }
         #endregion
 
+        #region White Label Login
+
+        /// <summary>
+        /// Create new user using the white label login system.
+        /// 
+        /// White label platform must be enabled in the web console for this to work.
+        /// </summary>
+        public static void WhiteLabelSignUp(string email, string password, Action<LootLockerWhiteLabelSignupResponse> onComplete)
+        {
+            if (!CheckInitialized())
+            {
+                onComplete?.Invoke(LootLockerResponseFactory.SDKNotInitializedError<LootLockerWhiteLabelSignupResponse>());
+                return;
+            }
+
+            LootLockerWhiteLabelUserRequest input = new LootLockerWhiteLabelUserRequest
+            {
+                email = email,
+                password = password
+            };
+
+            LootLockerAPIManager.WhiteLabelSignUp(input, onComplete);
+        }
+
+        /// <summary>
+        /// Request password reset email for the user.
+        /// 
+        /// White label platform must be enabled in the web console for this to work.
+        /// </summary>
+        public static void WhiteLabelRequestPassword(string email, Action<LootLockerResponse> onComplete)
+        {
+            if (!CheckInitialized())
+            {
+                onComplete?.Invoke(LootLockerResponseFactory.SDKNotInitializedError<LootLockerResponse>());
+                return;
+            }
+
+            LootLockerAPIManager.WhiteLabelRequestPasswordReset(email, onComplete);
+        }
+
+        /// <summary>
+        /// Request verify account email for the user.
+        /// 
+        /// White label platform must be enabled in the web console for this to work.
+        /// Account verification must also be enabled.
+        /// </summary>
+        public static void WhiteLabelRequestVerification(int userID, Action<LootLockerResponse> onComplete)
+        {
+            if (!CheckInitialized())
+            {
+                onComplete?.Invoke(LootLockerResponseFactory.SDKNotInitializedError<LootLockerResponse>());
+                return;
+            }
+
+            LootLockerAPIManager.WhiteLabelRequestAccountVerification(userID, onComplete);
+        }
+
+        #endregion
+
         #region Player
         //Player calls
         public static void GetPlayerInfo(Action<LootLockerGetPlayerInfoResponse> onComplete)

Runtime/Game/Requests/LootLockerSessionRequest.cs

@@ -27,6 +27,21 @@ public LootLockerSessionRequest()
         }
     }
 
+    [System.Serializable]
+    public class LootLockerWhiteLabelSessionRequest : LootLockerGetRequest
+    {
+        public string game_key => LootLockerConfig.current.apiKey?.ToString();
+        public string email { get; private set; }
+        public string password { get; private set; }
+        public string game_version => LootLockerConfig.current.game_version;
+        public bool development_mode => LootLockerConfig.current.developmentMode;
+        public LootLockerWhiteLabelSessionRequest(string email, string password)
+        {
+            this.email = email;
+            this.password = password;
+        }
+    }
+
     [System.Serializable]
     public class LootLockerSessionResponse : LootLockerResponse
     {
@@ -88,6 +103,31 @@ public static void Session(LootLockerGetRequest data, Action<LootLockerSessionRe
              }, false);
         }
 
+        public static void WhiteLabelSession(LootLockerGetRequest data, Action<LootLockerSessionResponse> onComplete)
+        {
+            EndPointClass endPoint = LootLockerEndPoints.whiteLabelLoginSessionRequest;
+
+            string json = "";
+            if (data == null) return;
+            else json = JsonConvert.SerializeObject(data);
+            LootLockerServerRequest.CallAPI(endPoint.endPoint, endPoint.httpMethod, json, (serverResponse) =>
+            {
+                LootLockerSessionResponse response = new LootLockerSessionResponse();
+                if (string.IsNullOrEmpty(serverResponse.Error))
+                {
+                    response = JsonConvert.DeserializeObject<LootLockerSessionResponse>(serverResponse.text);
+                    LootLockerConfig.current.UpdateToken(response.session_token, (data as LootLockerSessionRequest)?.player_identifier);
+                }
+
+                //LootLockerSDKManager.DebugMessage(serverResponse.text, !string.IsNullOrEmpty(serverResponse.Error));
+                response.text = serverResponse.text;
+                response.success = serverResponse.success;
+                response.Error = serverResponse.Error; response.statusCode = serverResponse.statusCode;
+                onComplete?.Invoke(response);
+
+            }, false);
+        }
+
         public static void GuestSession(LootLockerGetRequest data, Action<LootLockerGuestSessionResponse> onComplete)
         {
             EndPointClass endPoint = LootLockerEndPoints.guestSessionRequest;