public static void GettingAllMissions(Action <LootLockerGettingAllMissionsResponse> onComplete)
{
EndPointClass endPoint = LootLockerEndPoints.current.gettingAllMissions;
LootLockerServerRequest.CallAPI(endPoint.endPoint, endPoint.httpMethod, onComplete: (serverResponse) =>
{
LootLockerGettingAllMissionsResponse response = new LootLockerGettingAllMissionsResponse();
if (string.IsNullOrEmpty(serverResponse.Error))
{
response = JsonConvert.DeserializeObject <LootLockerGettingAllMissionsResponse>(serverResponse.text);
response.text = serverResponse.text;
onComplete?.Invoke(response);
}
else
{
response.message = serverResponse.message;
response.Error = serverResponse.Error;
onComplete?.Invoke(response);
}
}, useAuthToken: false);
}
public static void GetBalance(Action <LootLockerBalanceResponse> onComplete)
{
EndPointClass endPoint = LootLockerEndPoints.current.getCurrencyBalance;
LootLockerServerRequest.CallAPI(endPoint.endPoint, endPoint.httpMethod, null, onComplete: (serverResponse) =>
{
LootLockerBalanceResponse response = new LootLockerBalanceResponse();
if (string.IsNullOrEmpty(serverResponse.Error))
{
response = JsonConvert.DeserializeObject <LootLockerBalanceResponse>(serverResponse.text);
response.text = serverResponse.text;
onComplete?.Invoke(response);
}
else
{
response.message = serverResponse.message;
response.Error = serverResponse.Error;
onComplete?.Invoke(response);
}
}, true);
}
public static void GetXpAndLevel(LootLockerGetRequest data, Action <LootLockerXpResponse> onComplete)
{
EndPointClass endPoint = LootLockerEndPoints.getXpAndLevel;
string getVariable = string.Format(endPoint.endPoint, data.getRequests[0], data.getRequests[1]);
LootLockerServerRequest.CallAPI(getVariable, endPoint.httpMethod, null, (serverResponse) =>
{
LootLockerXpResponse response = new LootLockerXpResponse();
if (string.IsNullOrEmpty(serverResponse.Error))
{
response = JsonConvert.DeserializeObject <LootLockerXpResponse>(serverResponse.text);
}
//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);
}, true);
}
public static void GetDeactivatedAssetNotification(Action <LootLockerDeactivatedAssetsResponse> onComplete)
{
EndPointClass endPoint = LootLockerEndPoints.playerAssetDeactivationNotification;
string getVariable = endPoint.endPoint;
LootLockerServerRequest.CallAPI(getVariable, endPoint.httpMethod, null, (serverResponse) =>
{
LootLockerDeactivatedAssetsResponse response = new LootLockerDeactivatedAssetsResponse();
if (string.IsNullOrEmpty(serverResponse.Error))
{
response = JsonConvert.DeserializeObject <LootLockerDeactivatedAssetsResponse>(serverResponse.text);
}
//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);
}, true);
}
public static void ListingTriggeredTriggerEvents(Action <LootLockerListingAllTriggersResponse> onComplete)
{
EndPointClass endPoint = LootLockerEndPoints.current.listingTriggeredTriggerEvents;
LootLockerServerRequest.CallAPI(endPoint.endPoint, endPoint.httpMethod, "", (serverResponse) =>
{
LootLockerListingAllTriggersResponse response = new LootLockerListingAllTriggersResponse();
if (string.IsNullOrEmpty(serverResponse.Error))
{
response = JsonConvert.DeserializeObject <LootLockerListingAllTriggersResponse>(serverResponse.text);
response.text = serverResponse.text;
onComplete?.Invoke(response);
}
else
{
response.message = serverResponse.message;
response.Error = serverResponse.Error;
onComplete?.Invoke(response);
}
}, true);
}
public static void ActivatingARentalAsset(LootLockerGetRequest lootLockerGetRequest, Action <LootLockerCharacterLoadoutResponse> onComplete)
{
EndPointClass endPoint = LootLockerEndPoints.activatingARentalAsset;
string getVariable = string.Format(endPoint.endPoint, lootLockerGetRequest.getRequests[0]);
LootLockerServerRequest.CallAPI(getVariable, endPoint.httpMethod, "", (serverResponse) =>
{
LootLockerCharacterLoadoutResponse response = new LootLockerCharacterLoadoutResponse();
if (string.IsNullOrEmpty(serverResponse.Error))
{
response = JsonConvert.DeserializeObject <LootLockerCharacterLoadoutResponse>(serverResponse.text);
}
//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);
}, true);
}
public static void AddingFilesToAssetCandidates(LootLockerAddingFilesToAssetCandidatesRequest data, LootLockerGetRequest getRequests, Action <LootLockerUserGenerateContentResponse> onComplete)
{
EndPointClass requestEndPoint = LootLockerEndPoints.addingFilesToAssetCandidates;
string endPoint = string.Format(requestEndPoint.endPoint, getRequests.getRequests[0]);
Dictionary <string, string> formData = new Dictionary <string, string>();
formData.Add("purpose", data.filePurpose.ToString());
if (string.IsNullOrEmpty(data.fileName))
{
string[] splitFilePath = data.filePath.Split(new char[] { '\\', '/' });
string defaultFileName = splitFilePath[splitFilePath.Length - 1];
data.fileName = defaultFileName;
}
if (string.IsNullOrEmpty(data.fileContentType))
{
data.fileContentType = "multipart/form-data";
}
byte[] fileData = System.IO.File.ReadAllBytes(data.filePath);
LootLockerServerRequest.UploadFile(endPoint, requestEndPoint.httpMethod, fileData, data.fileName, data.fileContentType,
formData, (serverResponse) =>
{
LootLockerUserGenerateContentResponse response = new LootLockerUserGenerateContentResponse();
if (string.IsNullOrEmpty(serverResponse.Error))
{
response = JsonConvert.DeserializeObject <LootLockerUserGenerateContentResponse>(serverResponse.text);
}
//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);
}, useAuthToken: true, callerRole: LootLocker.LootLockerEnums.LootLockerCallerRole.User);
}
public static void CollectingAnItem(LootLockerCollectingAnItemRequest data, Action <LootLockerCollectingAnItemResponse> onComplete)
{
string json = "";
if (data == null)
{
return;
}
else
{
json = JsonConvert.SerializeObject(data);
}
EndPointClass endPoint = LootLockerEndPoints.collectingAnItem;
LootLockerServerRequest.CallAPI(endPoint.endPoint, endPoint.httpMethod, json, (serverResponse) =>
{
LootLockerCollectingAnItemResponse response = new LootLockerCollectingAnItemResponse();
if (string.IsNullOrEmpty(serverResponse.Error))
{
response = JsonConvert.DeserializeObject <LootLockerCollectingAnItemResponse>(serverResponse.text);
string[] collectableStrings = data.slug.Split('.');
string collectable = collectableStrings[0];
string group = collectableStrings[1];
string item = collectableStrings[2];
response.mainCollectable = response.collectables?.FirstOrDefault(x => x.name == collectable);
response.mainGroup = response.mainCollectable?.groups?.FirstOrDefault(x => x.name == group);
response.mainItem = response.mainGroup?.items?.FirstOrDefault(x => x.name == item);
}
//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);
}, true);
}
public static void GetPlayerName(Action <PlayerNameResponse> onComplete)
{
EndPointClass endPoint = LootLockerEndPoints.getPlayerName;
string getVariable = endPoint.endPoint;
LootLockerServerRequest.CallAPI(getVariable, endPoint.httpMethod, null, (Action <LootLockerResponse>)((serverResponse) =>
{
PlayerNameResponse response = new PlayerNameResponse();
if (string.IsNullOrEmpty(serverResponse.Error))
{
response = JsonConvert.DeserializeObject <PlayerNameResponse>(serverResponse.text);
}
//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);
}), true);
}
public static void GettingAllMaps(Action <LootLockerMapsResponse> onComplete)
{
EndPointClass endPoint = LootLockerEndPoints.current.gettingAllMaps;
string getVariable = endPoint.endPoint;
LootLockerServerRequest.CallAPI(getVariable, endPoint.httpMethod, null, onComplete: (serverResponse) =>
{
LootLockerMapsResponse response = new LootLockerMapsResponse();
if (string.IsNullOrEmpty(serverResponse.Error))
{
LootLockerSDKManager.DebugMessage(serverResponse.text);
response = JsonConvert.DeserializeObject <LootLockerMapsResponse>(serverResponse.text);
onComplete?.Invoke(response);
}
else
{
response.message = serverResponse.message;
response.Error = serverResponse.Error;
onComplete?.Invoke(response);
}
}, true);
}
public static void CreateCharacter(LootLockerCreateCharacterRequest data, Action <LootLockerCharacterLoadoutResponse> onComplete)
{
EndPointClass endPoint = LootLockerEndPoints.createCharacter;
string json = (data == null) ? "" : JsonConvert.SerializeObject(data);
string getVariable = endPoint.endPoint;
LootLockerServerRequest.CallAPI(getVariable, endPoint.httpMethod, json, (serverResponse) =>
{
LootLockerCharacterLoadoutResponse response = new LootLockerCharacterLoadoutResponse();
if (string.IsNullOrEmpty(serverResponse.Error))
{
response = JsonConvert.DeserializeObject <LootLockerCharacterLoadoutResponse>(serverResponse.text);
}
//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);
}, true);
}
public static void RemovingFilesFromAssetCandidates(LootLockerGetRequest data, Action <LootLockerUserGenerateContentResponse> onComplete)
{
EndPointClass requestEndPoint = LootLockerEndPoints.current.removingFilesFromAssetCandidates;
string endPoint = string.Format(requestEndPoint.endPoint, data.getRequests[0], data.getRequests[1]);
LootLockerServerRequest.CallAPI(endPoint, requestEndPoint.httpMethod, onComplete: (serverResponse) =>
{
LootLockerUserGenerateContentResponse response = new LootLockerUserGenerateContentResponse();
if (string.IsNullOrEmpty(serverResponse.Error))
{
LootLockerSDKManager.DebugMessage(serverResponse.text);
response = JsonConvert.DeserializeObject <LootLockerUserGenerateContentResponse>(serverResponse.text);
onComplete?.Invoke(response);
}
else
{
response.message = serverResponse.message;
response.Error = serverResponse.Error;
onComplete?.Invoke(response);
}
}, useAuthToken: true, callerRole: LootLocker.LootLockerEnums.LootLockerCallerRole.User);
}
public static void GettingASingleAssetCandidate(LootLockerGetRequest getRequests, Action <LootLockerUserGenerateContentResponse> onComplete)
{
EndPointClass requestEndPoint = LootLockerEndPoints.current.gettingASingleAssetCandidate;
string endPoint = string.Format(requestEndPoint.endPoint, getRequests.getRequests[0]);
LootLockerServerRequest.CallAPI(endPoint, requestEndPoint.httpMethod, null, (serverResponse) =>
{
LootLockerUserGenerateContentResponse response = new LootLockerUserGenerateContentResponse();
if (string.IsNullOrEmpty(serverResponse.Error))
{
LootLockerSDKManager.DebugMessage(serverResponse.text);
response = JsonConvert.DeserializeObject <LootLockerUserGenerateContentResponse>(serverResponse.text);
onComplete?.Invoke(response);
}
else
{
response.message = serverResponse.message;
response.Error = serverResponse.Error;
onComplete?.Invoke(response);
}
}, true, LootLocker.LootLockerEnums.LootLockerCallerRole.User);
}
public static void PollingOrderStatus(LootLockerGetRequest lootLockerGetRequest, Action <LootLockerCharacterLoadoutResponse> onComplete)
{
EndPointClass endPoint = LootLockerEndPoints.current.pollingOrderStatus;
string getVariable = string.Format(endPoint.endPoint, lootLockerGetRequest.getRequests[0]);
LootLockerServerRequest.CallAPI(getVariable, endPoint.httpMethod, "", (serverResponse) =>
{
LootLockerCharacterLoadoutResponse response = new LootLockerCharacterLoadoutResponse();
if (string.IsNullOrEmpty(serverResponse.Error))
{
response = JsonConvert.DeserializeObject <LootLockerCharacterLoadoutResponse>(serverResponse.text);
response.text = serverResponse.text;
onComplete?.Invoke(response);
}
else
{
response.message = serverResponse.message;
response.Error = serverResponse.Error;
onComplete?.Invoke(response);
}
}, true);
}
public static void StartingEvent(LootLockerGetRequest data, Action <LootLockerStartinEventResponse> onComplete)
{
EndPointClass endPoint = LootLockerEndPoints.current.startingEvent;
string getVariable = string.Format(endPoint.endPoint, data.getRequests[0]);
LootLockerServerRequest.CallAPI(getVariable, endPoint.httpMethod, null, onComplete: (serverResponse) =>
{
LootLockerStartinEventResponse response = new LootLockerStartinEventResponse();
if (string.IsNullOrEmpty(serverResponse.Error))
{
LootLockerSDKManager.DebugMessage(serverResponse.text);
response = JsonConvert.DeserializeObject <LootLockerStartinEventResponse>(serverResponse.text);
onComplete?.Invoke(response);
}
else
{
response.message = serverResponse.message;
response.Error = serverResponse.Error;
onComplete?.Invoke(response);
}
}, true);
}
public static void GetEquipableContextToDefaultCharacter(Action <LootLockerContextResponse> onComplete)
{
EndPointClass endPoint = LootLockerEndPoints.current.getEquipableContextToDefaultCharacter;
string getVariable = endPoint.endPoint;
LootLockerServerRequest.CallAPI(getVariable, endPoint.httpMethod, null, (serverResponse) =>
{
LootLockerContextResponse response = new LootLockerContextResponse();
if (string.IsNullOrEmpty(serverResponse.Error))
{
response = JsonConvert.DeserializeObject <LootLockerContextResponse>(serverResponse.text);
response.text = serverResponse.text;
onComplete?.Invoke(response);
}
else
{
response.message = serverResponse.message;
response.Error = serverResponse.Error;
onComplete?.Invoke(response);
}
}, true);
}
public static void SetProfilePublic(Action <LootLockerStandardResponse> onComplete)
{
EndPointClass endPoint = LootLockerEndPoints.current.setProfilePublic;
string getVariable = endPoint.endPoint;
LootLockerServerRequest.CallAPI(getVariable, endPoint.httpMethod, null, (serverResponse) =>
{
LootLockerStandardResponse response = new LootLockerStandardResponse();
if (string.IsNullOrEmpty(serverResponse.Error))
{
response = JsonConvert.DeserializeObject <LootLockerStandardResponse>(serverResponse.text);
response.text = serverResponse.text;
onComplete?.Invoke(response);
}
else
{
response.message = serverResponse.message;
response.Error = serverResponse.Error;
onComplete?.Invoke(response);
}
}, true);
}
public static void StartingAMission(LootLockerGetRequest data, Action <LootLockerStartingAMissionResponse> onComplete)
{
EndPointClass requestEndPoint = LootLockerEndPoints.current.startingMission;
string endPoint = string.Format(requestEndPoint.endPoint, data.getRequests[0]);
LootLockerServerRequest.CallAPI(endPoint, requestEndPoint.httpMethod, onComplete: (serverResponse) =>
{
LootLockerStartingAMissionResponse response = new LootLockerStartingAMissionResponse();
if (string.IsNullOrEmpty(serverResponse.Error))
{
response = JsonConvert.DeserializeObject <LootLockerStartingAMissionResponse>(serverResponse.text);
response.text = serverResponse.text;
onComplete?.Invoke(response);
}
else
{
response.message = serverResponse.message;
response.Error = serverResponse.Error;
onComplete?.Invoke(response);
}
}, useAuthToken: false);
}
public static void GetOtherPlayersPublicKeyValuePairs(LootLockerGetRequest data, Action <LootLockerGetPersistentStoragResponse> onComplete)
{
EndPointClass endPoint = LootLockerEndPoints.current.getOtherPlayersPublicKeyValuePairs;
string getVariable = string.Format(endPoint.endPoint, data.getRequests[0]);
LootLockerServerRequest.CallAPI(getVariable, endPoint.httpMethod, null, onComplete: (serverResponse) =>
{
LootLockerGetPersistentStoragResponse response = new LootLockerGetPersistentStoragResponse();
if (string.IsNullOrEmpty(serverResponse.Error))
{
response = JsonConvert.DeserializeObject <LootLockerGetPersistentStoragResponse>(serverResponse.text);
response.text = serverResponse.text;
onComplete?.Invoke(response);
}
else
{
response.text = serverResponse.text;
response.message = serverResponse.message;
response.Error = serverResponse.Error;
onComplete?.Invoke(response);
}
}, true);
}
UnityWebRequest CreateWebRequest(string url, LootLockerServerRequest request)
{
UnityWebRequest webRequest;
switch (request.httpMethod)
{
case LootLockerHTTPMethod.UPLOAD:
webRequest = UnityWebRequest.Post(url, request.form);
break;
case LootLockerHTTPMethod.POST:
case LootLockerHTTPMethod.PATCH:
// Defaults are fine for PUT
case LootLockerHTTPMethod.PUT:
if (request.payload == null && request.upload != null)
{
List <IMultipartFormSection> form = new List <IMultipartFormSection>
{
new MultipartFormFileSection(request.uploadName, request.upload, System.DateTime.Now.ToString(), request.uploadType)
};
// generate a boundary then convert the form to byte[]
byte[] boundary = UnityWebRequest.GenerateBoundary();
byte[] formSections = UnityWebRequest.SerializeFormSections(form, boundary);
// Set the content type - NO QUOTES around the boundary
string contentType = String.Concat("multipart/form-data; boundary=--", Encoding.UTF8.GetString(boundary));
//Debug.LogError("Content type Set: " + contentType);
// Make my request object and add the raw body. Set anything else you need here
webRequest = new UnityWebRequest();
webRequest.SetRequestHeader("Content-Type", "multipart/form-data; boundary=--");
webRequest.uri = new Uri(url);
Debug.Log(url); //the url is wrong in some cases
webRequest.uploadHandler = new UploadHandlerRaw(formSections);
webRequest.uploadHandler.contentType = contentType;
webRequest.useHttpContinue = false;
// webRequest.method = "POST";
webRequest.method = UnityWebRequest.kHttpVerbPOST;
}
else
{
string json = (request.payload != null && request.payload.Count > 0) ? JsonConvert.SerializeObject(request.payload) : request.jsonPayload;
#if UNITY_EDITOR
LootLockerSDKManager.DebugMessage("REQUEST BODY = " + json);
#endif
byte[] bytes = System.Text.Encoding.UTF8.GetBytes(string.IsNullOrEmpty(json) ? "{}" : json);
webRequest = UnityWebRequest.Put(url, bytes);
webRequest.method = request.httpMethod.ToString();
}
break;
case LootLockerHTTPMethod.OPTIONS:
case LootLockerHTTPMethod.HEAD:
case LootLockerHTTPMethod.GET:
// Defaults are fine for GET
webRequest = UnityWebRequest.Get(url);
webRequest.method = request.httpMethod.ToString();
break;
case LootLockerHTTPMethod.DELETE:
// Defaults are fine for DELETE
webRequest = UnityWebRequest.Delete(url);
break;
default:
throw new System.Exception("Invalid HTTP Method");
}
if (baseHeaders != null)
{
foreach (KeyValuePair <string, string> pair in baseHeaders)
{
if (pair.Key == "Content-Type" && request.upload != null)
{
continue;
}
webRequest.SetRequestHeader(pair.Key, pair.Value);
}
}
if (request.extraHeaders != null)
{
foreach (KeyValuePair <string, string> pair in request.extraHeaders)
{
webRequest.SetRequestHeader(pair.Key, pair.Value);
}
}
return(webRequest);
}
protected abstract void RefreshTokenAndCompleteCall(LootLockerServerRequest cacheServerRequest, System.Action <LootLockerResponse> OnServerResponse);
public static void GetAssetsOriginal(Action <LootLockerAssetResponse> onComplete, int assetCount, int?idOfLastAsset = null, LootLocker.LootLockerEnums.AssetFilter filter = LootLocker.LootLockerEnums.AssetFilter.none)
{
EndPointClass endPoint = LootLockerEndPoints.current.gettingAssetListWithCount;
string getVariable = string.Format(endPoint.endPoint, assetCount);
if (idOfLastAsset != null && assetCount > 0)
{
endPoint = LootLockerEndPoints.current.gettingAssetListWithAfterAndCount;
getVariable = string.Format(endPoint.endPoint, assetCount, idOfLastAsset.ToString());
}
else if (idOfLastAsset != null && assetCount > 0 && filter != LootLocker.LootLockerEnums.AssetFilter.none)
{
endPoint = LootLockerEndPoints.current.gettingAssetListOriginal;
string filterString = "";
switch (filter)
{
case LootLocker.LootLockerEnums.AssetFilter.purchasable:
filterString = LootLocker.LootLockerEnums.AssetFilter.purchasable.ToString();
break;
case LootLocker.LootLockerEnums.AssetFilter.nonpurchasable:
filterString = "!purchasable";
break;
case LootLocker.LootLockerEnums.AssetFilter.rentable:
filterString = LootLocker.LootLockerEnums.AssetFilter.rentable.ToString();
break;
case LootLocker.LootLockerEnums.AssetFilter.nonrentable:
filterString = "!rentable";
break;
case LootLocker.LootLockerEnums.AssetFilter.popular:
filterString = LootLocker.LootLockerEnums.AssetFilter.popular.ToString();
break;
case LootLocker.LootLockerEnums.AssetFilter.nonpopular:
filterString = "!popular";
break;
}
getVariable = string.Format(endPoint.endPoint, assetCount, idOfLastAsset.ToString(), filterString);
}
LootLockerServerRequest.CallAPI(getVariable, endPoint.httpMethod, null, onComplete: (serverResponse) =>
{
LootLockerAssetResponse response = new LootLockerAssetResponse();
if (string.IsNullOrEmpty(serverResponse.Error))
{
LootLockerSDKManager.DebugMessage(serverResponse.text);
response = JsonConvert.DeserializeObject <LootLockerAssetResponse>(serverResponse.text);
response.text = serverResponse.text;
if (response != null)
{
LootLockerAssetRequest.lastId = response.assets.Last()?.id != null ? response.assets.Last().id : 0;
}
onComplete?.Invoke(response);
}
else
{
response.message = serverResponse.message;
response.Error = serverResponse.Error;
onComplete?.Invoke(response);
}
}, true);
}
public void SendRequest(LootLockerServerRequest request, System.Action <LootLockerResponse> OnServerResponse = null)
{
StartCoroutine(coroutine());
IEnumerator coroutine()
{
//Always wait 1 frame before starting any request to the server to make sure the requesters code has exited the main thread.
yield return(null);
//Build the URL that we will hit based on the specified endpoint, query params, etc
string url = BuildURL(request.endpoint, request.queryParams);
#if UNITY_EDITOR
LootLockerSDKManager.DebugMessage("ServerRequest URL: " + url);
#endif
using (UnityWebRequest webRequest = CreateWebRequest(url, request))
{
webRequest.downloadHandler = new DownloadHandlerBuffer();
float startTime = Time.time;
float maxTimeOut = 5f;
yield return(webRequest.SendWebRequest());
while (!webRequest.isDone)
{
yield return(null);
if (Time.time - startTime >= maxTimeOut)
{
LootLockerSDKManager.DebugMessage("ERROR: Exceeded maxTimeOut waiting for a response from " + request.httpMethod.ToString() + " " + url);
yield break;
}
}
if (!webRequest.isDone)
{
OnServerResponse?.Invoke(new LootLockerResponse()
{
hasError = true, statusCode = 408, Error = "{\"error\": \"" + request.endpoint + " Timed out.\"}"
});
yield break;
}
try
{
#if UNITY_EDITOR
LootLockerSDKManager.DebugMessage("Server Response: " + request.httpMethod + " " + request.endpoint + " completed in " + (Time.time - startTime).ToString("n4") + " secs.\nResponse: " + webRequest.downloadHandler.text);
#endif
}
catch
{
LootLockerSDKManager.DebugMessage(request.httpMethod.ToString(), true);
LootLockerSDKManager.DebugMessage(request.endpoint, true);
LootLockerSDKManager.DebugMessage(webRequest.downloadHandler.text, true);
}
LootLockerResponse response = new LootLockerResponse();
response.statusCode = (int)webRequest.responseCode;
if (webRequest.isHttpError || webRequest.isNetworkError || !string.IsNullOrEmpty(webRequest.error))
{
switch (webRequest.responseCode)
{
case 200:
response.Error = "";
break;
case 400:
response.Error = "Bad Request -- Your request has an error";
break;
case 402:
response.Error = "Payment Required -- Payment failed. Insufficient funds, etc.";
break;
case 401:
response.Error = "Unauthroized -- Your session_token is invalid";
break;
case 403:
response.Error = "Forbidden -- You do not have access";
break;
case 404:
response.Error = "Not Found";
break;
case 405:
response.Error = "Method Not Allowed";
break;
case 406:
response.Error = "Not Acceptable -- Purchasing is disabled";
break;
case 409:
response.Error = "Conflict -- Your state is most likely not aligned with the servers.";
break;
case 429:
response.Error = "Too Many Requests -- You're being limited for sending too many requests too quickly.";
break;
case 500:
response.Error = "Internal Server Error -- We had a problem with our server. Try again later.";
break;
case 503:
response.Error = "Service Unavailable -- We're either offline for maintenance, or an error that should be solvable by calling again later was triggered.";
break;
}
#if UNITY_EDITOR
LootLockerSDKManager.DebugMessage("Response code: " + webRequest.responseCode);
#endif
if (webRequest.responseCode != 401 || !activeConfig.allowTokenRefresh)
{
response.Error += " " + webRequest.downloadHandler.text;
response.text = webRequest.downloadHandler.text;
}
else
{
RefreshTokenAndCompleteCall(request, OnServerResponse);
}
response.status = false;
response.hasError = true;
response.text = webRequest.downloadHandler.text;
OnServerResponse?.Invoke(response);
}
else
{
response.status = true;
response.hasError = false;
response.text = webRequest.downloadHandler.text;
OnServerResponse?.Invoke(response);
}
}
}
}
public static void GetAssetsOriginal(Action <LootLockerAssetResponse> onComplete, int assetCount, int?idOfLastAsset = null, List <LootLocker.LootLockerEnums.AssetFilter> filter = null, bool includeUGC = false, Dictionary <string, string> assetFilters = null, int UGCCreatorPlayerID = 0)
{
EndPointClass endPoint = LootLockerEndPoints.gettingAssetListWithCount;
string getVariable = string.Format(endPoint.endPoint, assetCount);
string tempEndpoint = string.Empty;
string filterString = string.Empty;
if (idOfLastAsset != null)
{
tempEndpoint = $"&after={idOfLastAsset}";
getVariable += tempEndpoint;
}
if (filter != null)
{
filterString = GetStringOfEnum(filter.First());
for (int i = 1; i < filter.Count; i++)
{
filterString += "," + GetStringOfEnum(filter[i]);
}
tempEndpoint = $"&filter={filterString}";
getVariable += tempEndpoint;
}
if (includeUGC)
{
tempEndpoint = $"&include_ugc={includeUGC.ToString().ToLower()}";
getVariable += tempEndpoint;
}
if (UGCCreatorPlayerID > 0)
{
tempEndpoint = $"&ugc_creator_player_id={UGCCreatorPlayerID.ToString().ToLower()}";
getVariable += tempEndpoint;
}
if (assetFilters != null)
{
KeyValuePair <string, string> keys = assetFilters.First();
filterString = $"{keys.Key}={keys.Value}";
int count = 0;
foreach (var kvp in assetFilters)
{
if (count > 0)
{
filterString += $";{kvp.Key}={kvp.Value}";
}
count++;
}
tempEndpoint = $"&asset_filters={filterString}";
getVariable += tempEndpoint;
}
LootLockerServerRequest.CallAPI(getVariable, endPoint.httpMethod, null, onComplete: (serverResponse) =>
{
LootLockerAssetResponse response = new LootLockerAssetResponse();
if (string.IsNullOrEmpty(serverResponse.Error))
{
response = JsonConvert.DeserializeObject <LootLockerAssetResponse>(serverResponse.text);
}
response.text = serverResponse.text;
response.success = serverResponse.success;
response.Error = serverResponse.Error; response.statusCode = serverResponse.statusCode;
onComplete?.Invoke(response);
}, true);
}
protected override void RefreshTokenAndCompleteCall(LootLockerServerRequest cacheServerRequest, Action <LootLockerResponse> OnServerResponse)
{
string platform = LootLockerSDKManager.GetCurrentPlatform();
if (platform == Platforms.Steam)
{
LootLockerSDKManager.DebugMessage("Token has expired and token refresh is not supported for Steam", true);
LootLockerResponse res = new LootLockerResponse();
res.statusCode = 401;
res.Error = "Token Expired";
res.hasError = true;
OnServerResponse?.Invoke(res);
return;
}
if (platform == Platforms.NintendoSwitch)
{
LootLockerSDKManager.DebugMessage("Token has expired and token refresh is not supported for Nintendo Switch", true);
LootLockerResponse res = new LootLockerResponse();
res.statusCode = 401;
res.Error = "Token Expired";
res.hasError = true;
OnServerResponse?.Invoke(res);
return;
}
if (platform == Platforms.Guest)
{
LootLockerSDKManager.StartGuestSession(response =>
{
CompleteCall(cacheServerRequest, OnServerResponse, response);
});
return;
}
else if (platform == Platforms.WhiteLabel)
{
LootLockerSDKManager.StartWhiteLabelSession(response =>
{
CompleteCall(cacheServerRequest, OnServerResponse, response);
});
return;
}
else
{
var sessionRequest = new LootLockerSessionRequest(LootLockerConfig.current.deviceID);
LootLockerAPIManager.Session(sessionRequest, (response) =>
{
CompleteCall(cacheServerRequest, OnServerResponse, response);
});
}
void CompleteCall(LootLockerServerRequest newcacheServerRequest, Action <LootLockerResponse> newOnServerResponse, LootLockerSessionResponse response)
{
if (response.success)
{
Dictionary <string, string> headers = new Dictionary <string, string>();
headers.Add("x-session-token", LootLockerConfig.current.token);
newcacheServerRequest.extraHeaders = headers;
if (newcacheServerRequest.retryCount < 4)
{
SendRequest(newcacheServerRequest, newOnServerResponse);
newcacheServerRequest.retryCount++;
}
else
{
LootLockerSDKManager.DebugMessage("Session refresh failed", true);
LootLockerResponse res = new LootLockerResponse();
res.statusCode = 401;
res.Error = "Token Expired";
res.hasError = true;
newOnServerResponse?.Invoke(res);
}
}
else
{
LootLockerSDKManager.DebugMessage("Session refresh failed", true);
LootLockerResponse res = new LootLockerResponse();
res.statusCode = 401;
res.Error = "Token Expired";
res.hasError = true;
newOnServerResponse?.Invoke(res);
}
}
}
