private void GenerateTokens(CallbackResponse callback)
{
try
{
_logger.LogError($"GenerateTokens:{_config.QbConfig}");
var oAuth2Client = new OAuth2Client(_config.QbConfig.ClientID, _config.QbConfig.ClientSecret, _config.QbConfig.RedirectUri, _config.QbConfig.Environment);
var response = oAuth2Client.GetBearerTokenAsync(callback.Code).Result;
var curDateTime = DateTime.Now;
if (response.HttpStatusCode == System.Net.HttpStatusCode.OK)
{
_logger.LogInformation("status is ok.");
var token = new QBToken
{
AccessToken = response.AccessToken,
RefreshToken = response.RefreshToken,
RefreshTokenExpiresIn = curDateTime.AddSeconds(response.RefreshTokenExpiresIn),
AccessTokenExpiresIn = curDateTime.AddSeconds(response.AccessTokenExpiresIn)
};
SaveToStorage(JsonConvert.SerializeObject(token));
var tokenPath = Path.Combine(Model.Constants.RootPath, "response", "QBToken.json");
Common.SaveJson(tokenPath, JsonConvert.SerializeObject(token));
}
else
{
_logger.LogError($"Error: {response.Error}, Error Description:{response.ErrorDescription}");
}
}
catch (Exception ex)
{
_logger.LogError($"Error occured:{JsonConvert.SerializeObject(ex)}", ex);
}
}
void OnLeaderboardComplete(CallbackResponse <LeaderboardData> response)
{
Debug.Log("OnLeaderboardComplete");
if (response.Status == CallbackStatus.Success)
{
LeaderboardData ld = response.Result;
GameObject prefab = Resources.Load("Prefabs/LeaderboardItemPanel") as GameObject;
var canvas = GameObject.Find("Canvas");
var container = canvas.transform.FindChild("LeaderboardContainer");
int row = 0;
int rowSize = 50;
foreach (LeaderboardItem li in ld.Items)
{
Vector2 startPosition = new Vector2(0, 0);
var item = Instantiate(prefab);
var renderer = item.GetComponent <LeaderboardItemRenderer>();
item.transform.SetParent(container.transform);
item.SetActive(true);
var rectTransform = item.GetComponent <RectTransform>();
if (rectTransform)
{
rectTransform.anchorMin = new Vector2(0f, 1f);
rectTransform.anchorMax = rectTransform.anchorMin;
rectTransform.anchoredPosition = new Vector2(startPosition.x, startPosition.y - (row * rowSize));
}
renderer.Initialize(li.Rank.ToString(), li.Gamertag, li.Value);
row++;
}
}
}
private async Task <CallbackResponse> CompleteOrderAsync(Uri resultUrl)
{
ResultUrlRequest request = _platronClient.ResultUrl.Parse(resultUrl);
CallbackResponse response = _platronClient.ResultUrl.ReturnOk(request, "Order completed");
return(await Task.FromResult(response));
}
public async Task <string> Callback()
{
try
{
_logger.LogInformation("Callback");
path = Path.Combine(Model.Constants.RootPath, "response", "response.json");
//var filepath = _appSettings.CallbackConfig.Path;
var queryString = Request.QueryString.ToString();
var arr = queryString.Split("&");
var callback = new CallbackResponse
{
Code = arr[0].Replace("?", "").Replace("code=", ""),
State = arr[1].Replace("state=", ""),
RealmId = arr[2].Replace("realmId=", "")
};
GenerateTokens(callback);
var data = JsonConvert.SerializeObject(callback);
Common.SaveJson(path, data);
//Debug.WriteLine(bodyContent);
return("successully saved code");
}
catch (Exception ex)
{
_logger.LogError("Error occured:", ex);
return(null);
}
}
private IEnumerator DeleteByIDInternal <T>(string id, Action <CallbackResponse> onDeleteCompleted)
where T : AppServiceObjectBase
{
using (UnityWebRequest www = AppServiceUtilities.BuildAppServiceWebRequest
(GetEasyTablesUrl <T>() + "/" + WWW.EscapeURL(id), HttpMethod.Delete.ToString(), null, AuthenticationToken))
{
yield return(www.Send());
if (Globals.DebugFlag)
{
Debug.Log(www.responseCode);
}
CallbackResponse response = new CallbackResponse();
if (Utilities.IsWWWError(www))
{
if (Globals.DebugFlag)
{
Debug.Log(www.error);
}
Utilities.BuildResponseObjectOnFailure(response, www);
}
else
{
response.Status = CallBackResult.Success;
}
onDeleteCompleted(response);
}
}
private IEnumerator PostDataInternal <T>(T data, Action <CallbackResponse> onPostDataCompleted)
where T : class
{
string json = JsonUtility.ToJson(data);
using (UnityWebRequest www = EventHubUtilities.BuildEventHubWebRequest(Url, HttpMethod.Post.ToString(), json, Key, KeyName))
{
yield return(www.Send());
if (Globals.DebugFlag)
{
Debug.Log(www.responseCode);
}
CallbackResponse response = new CallbackResponse();
if (Utilities.IsWWWError(www))
{
if (Globals.DebugFlag)
{
Debug.Log(www.error ?? "Error " + www.responseCode);
}
Utilities.BuildResponseObjectOnFailure(response, www);
}
else
{
response.Status = CallBackResult.Success;
}
onPostDataCompleted(response);
}
}
//////////////// Commands ////////////////
private void OnReLoginCommand(bool boolValue, int intValue, CallbackResponse response)
{
var playerState = _playerManager.CurrentPlayerProvider.PlayerState;
playerState.IsLoggedIn = false;
_playerManager.CurrentPlayerProvider.PlayerState = playerState;
_playerManager.CurrentPlayerProvider.ReAuth();
}
private void prettyPrintSuccess(string apiName, CallbackResponse response)
{
if (response.Status == CallbackStatus.Failure)
{
text.text = "\n" + apiName + "API call succeeded.\n" + text.text + "\n";
}
}
void OnListingInformationCompleted(CallbackResponse <ListingInformation> response)
{
if (response.Status == CallbackStatus.Success)
{
listingInformation = response.Result;
PopulatePrices(listingInformation.ProductListings);
}
}
private void OnPauseCommand(bool boolValue, int intValue, CallbackResponse response)
{
if (_playerManager.CurrentPlayerProvider.PlayerState.ServiceName == null)
return;
_plugin.DisplayMessage("Paused playback.");
_playerManager.CurrentPlayerProvider.SetPauseOrPlay(false);
}
private void OnBackCommand(bool boolValue, int intValue, CallbackResponse response)
{
if (_playerManager.CurrentPlayerProvider.PlayerState.ServiceName == null)
return;
_plugin.DisplayMessage("Going back a track.");
_playerManager.CurrentPlayerProvider.SetSkip(false);
}
private void OnNextCommand(bool boolValue, int intValue, CallbackResponse response)
{
if (_playerManager.CurrentPlayerProvider.PlayerState.ServiceName == null)
return;
_plugin.DisplayMessage("Skipping to next track.");
_playerManager.CurrentPlayerProvider.SetSkip(true);
}
private void OnVolumeCommand(bool boolValue, int intValue, CallbackResponse response)
{
if (_playerManager.CurrentPlayerProvider.PlayerState.ServiceName == null)
return;
_plugin.DisplayMessage($"Set volume to: {intValue}");
_playerManager.CurrentPlayerProvider.SetVolume(intValue);
}
private void OnDisplayCommand(bool boolValue, int intValue, CallbackResponse response)
{
_plugin.Configuration.PlayerSettings.PlayerWindowShown = response switch
{
CallbackResponse.SetValue => boolValue,
CallbackResponse.ToggleValue => !_plugin.Configuration.PlayerSettings.PlayerWindowShown,
_ => _plugin.Configuration.PlayerSettings.PlayerWindowShown
};
}
private IEnumerator CallAPIInternal <T, P>(string apiname,
HttpMethod method, Action <CallbackResponse <T[]> > onInvokeAPICompleted, EasyAPIReturnType returnType, P instance = null)
where T : class
where P : class
{
string json = null;
if (instance != null)
{
json = JsonUtility.ToJson(instance);
}
using (UnityWebRequest www = AppServiceUtilities.BuildAppServiceWebRequest(GetApiUrl(apiname),
method.ToString(), json, AuthenticationToken))
{
yield return(www.Send());
if (Globals.DebugFlag)
{
Debug.Log(www.responseCode);
}
CallbackResponse <T[]> response = new CallbackResponse <T[]>();
if (Utilities.IsWWWError(www))
{
if (Globals.DebugFlag)
{
Debug.Log(www.error);
}
Utilities.BuildResponseObjectOnFailure(response, www);
}
else if (www.downloadHandler != null) //all OK
{
try
{
T[] returnObject = null;
if (returnType == EasyAPIReturnType.MultipleResults)
{
returnObject = JsonHelper.GetJsonArray <T>(www.downloadHandler.text);
}
else if (returnType == EasyAPIReturnType.SingleResult)
{
var returnObjectSingle = JsonUtility.FromJson <T>(www.downloadHandler.text);
returnObject = new T[] { returnObjectSingle };
}
response.Status = CallBackResult.Success;
response.Result = returnObject;
}
catch (Exception ex)
{
response.Status = CallBackResult.DeserializationFailure;
response.Exception = ex;
}
}
onInvokeAPICompleted(response);
}
}
public bool GetMessage(int recognize, out CallbackResponse message)
{
message = null;
if (!dicMessage.ContainsKey(recognize))
{
return(false);
}
return(dicMessage[recognize].TryDequeue(out message));
}
void OnReportConsumableFulfillmentFinished(CallbackResponse <FulfillmentResult> result)
{
if (result.Status == CallbackStatus.Success)
{
MessageBoxHelper.ShowModelessMessage(Constants.Display_ConsumableFulfilled);
}
else
{
MessageBoxHelper.ShowModelessError(Constants.Display_ErrorFulfillingConsumable);
}
}
private void OnPlayCommand(bool boolValue, int intValue, CallbackResponse response)
{
if (_playerManager.CurrentPlayerProvider.PlayerState.ServiceName == null)
return;
string displayInfo = null;
if (_playerManager.CurrentPlayerProvider.PlayerState.CurrentlyPlaying.Id != null)
displayInfo = _playerManager.CurrentPlayerProvider.PlayerState.CurrentlyPlaying.Name;
_plugin.DisplaySongTitle(displayInfo); //$"Playing '{displayInfo}'..."
_playerManager.CurrentPlayerProvider.SetPauseOrPlay(true);
}
public PlatronModule(PlatronClient platronClient)
{
// IoC container will make us super-duper happy and gives us a client.
_platronClient = platronClient;
Get["/platron/result", true] = async(_, ct) =>
{
CallbackResponse response = await CompleteOrderAsync(Request.Url);
return(AsXml(response));
};
}
public void OnConfigCommand(bool boolValue, int intValue, CallbackResponse response)
{
if (response == CallbackResponse.SetValue)
{
_plugin.Configuration.ConfigShown = boolValue;
}
if (response == CallbackResponse.ToggleValue)
{
_plugin.Configuration.ConfigShown = !_plugin.Configuration.ConfigShown;
}
}
private Response AsXml(CallbackResponse response)
{
return(new Response
{
ContentType = "application/xml; charset:utf-8",
Contents = stream =>
{
var data = Encoding.UTF8.GetBytes(response.Content);
stream.Write(data, 0, data.Length);
},
StatusCode = HttpStatusCode.OK
});
}
private bool IsUsernameInDatabase(ref CallbackResponse <SelectFilteredResult <User> > selectResponse, ref string username)
{
foreach (var item in selectResponse.Result.results)
{
// Check for the usernames found that only match the input username exactly
if (item.username.Equals(username, StringComparison.Ordinal))
{
//Debug.Log(item.username);
return(true);
}
}
return(false);
}
void OnSimulatorLicenseLoaded(CallbackResponse cr)
{
if (cr.Status == CallbackStatus.Success)
{
Store.LoadListingInformation(OnListingInformationCompleted);
isSimulatorLicenseLoaded = true;
}
#if DEBUG
else
{
MessageBoxHelper.ShowModelessError("Simulator load failed");
}
#endif
}
private void OnShuffleCommand(bool boolValue, int intValue, CallbackResponse response)
{
if (_playerManager.CurrentPlayerProvider.PlayerState.ServiceName == null)
{
return;
}
switch (response)
{
case CallbackResponse.SetValue:
{
if (boolValue)
{
_plugin.DisplayMessage("Turned on shuffle.");
}
if (!boolValue)
{
_plugin.DisplayMessage("Turned off shuffle.");
}
_playerManager.CurrentPlayerProvider.SetShuffle(boolValue);
break;
}
case CallbackResponse.ToggleValue:
{
if (!_playerManager.CurrentPlayerProvider.PlayerState.ShuffleState)
{
_plugin.DisplayMessage("Turned on shuffle.");
}
if (_playerManager.CurrentPlayerProvider.PlayerState.ShuffleState)
{
_plugin.DisplayMessage("Turned off shuffle.");
}
_playerManager.CurrentPlayerProvider.SetShuffle(!_playerManager.CurrentPlayerProvider.PlayerState
.ShuffleState);
break;
}
case CallbackResponse.None:
break;
default:
throw new ArgumentOutOfRangeException(nameof(response), response, null);
}
}
private void prettyPrintErrors(string apiName, CallbackResponse response)
{
if (response.Status == CallbackStatus.Failure)
{
text.text = "\n" + apiName + "API call failed.\n" + response.Exception.Message + "\n" + text.text + "\n";
Debug.LogError(apiName + " API call failed");
if (response.Exception != null)
{
Debug.LogError(apiName + " Exception: " + response.Exception.Message);
}
Debug.LogError(apiName + " Exiting without doing anything");
}
}
private IEnumerator InsertInternal <T>(T instance, Action <CallbackResponse <T> > onInsertCompleted)
where T : AppServiceObjectBase
{
string json = JsonUtility.ToJson(instance);
using (UnityWebRequest www = AppServiceUtilities.BuildAppServiceWebRequest(GetEasyTablesUrl <T>(),
HttpMethod.Post.ToString(), json, AuthenticationToken))
{
yield return(www.Send());
if (Globals.DebugFlag)
{
Debug.Log(www.responseCode);
}
CallbackResponse <T> response = new CallbackResponse <T>();
if (Utilities.IsWWWError(www))
{
if (Globals.DebugFlag)
{
Debug.Log(www.error);
}
Utilities.BuildResponseObjectOnFailure(response, www);
}
else if (www.downloadHandler != null) //all OK
{
//let's get the new object that was created
try
{
T newObject = JsonUtility.FromJson <T>(www.downloadHandler.text);
if (Globals.DebugFlag)
{
Debug.Log("new object ID is " + newObject.id);
}
response.Status = CallBackResult.Success;
response.Result = newObject;
}
catch (Exception ex)
{
response.Status = CallBackResult.DeserializationFailure;
response.Exception = ex;
}
}
onInsertCompleted(response);
}
}
public override Task <IHttpResponse> InstigateInternal(IApplication httpApp,
IHttpRequest request, ParameterInfo parameterInfo,
Func <object, Task <IHttpResponse> > onSuccess)
{
SPAHtmlResponse responseDelegate =
(filename, manipulateHtml) =>
{
var httpApiApp = httpApp as IApiApplication;
var response = new CallbackResponse(request, this.StatusCode,
httpApiApp, filename, manipulateHtml);
return(UpdateResponse(parameterInfo, httpApp, request, response));
};
return(onSuccess(responseDelegate));
}
TResponse TryDeserialize <TResponse>(string responseJson) where TResponse : class, IKernelResponse
{
JObject responseObject = (JObject)JsonConvert.DeserializeObject(responseJson, new JsonSerializerSettings
{
DateParseHandling = DateParseHandling.None
}) !;
if (responseObject.ContainsKey("error"))
{
ErrorResponse errorResponse = responseObject.ToObject <ErrorResponse>() !;
throw new JsiiException(errorResponse, null);
}
if (typeof(TResponse).IsAssignableFrom(typeof(HelloResponse)))
{
return(responseObject.ToObject <TResponse>() !);
}
if (responseObject.ContainsKey("callback"))
{
CallbackResponse callbackResponse = responseObject.ToObject <CallbackResponse>() !;
Callback callback = callbackResponse.Callback;
object?result = callback.InvokeCallback(_referenceMap, _frameworkToJsiiConverter, out string?error);
return(Send <SynchronousCompleteRequest, TResponse>(new SynchronousCompleteRequest
(
new CompleteRequest(callback.CallbackId, error, result)
)));
}
if (responseObject.ContainsKey("pending"))
{
// TODO: What does this mean?
throw new NotImplementedException();
}
if (responseObject.ContainsKey("ok"))
{
OkResponse <TResponse> okResponse = responseObject.ToObject <OkResponse <TResponse> >() !;
return(okResponse.Ok);
}
throw new ArgumentException("Unrecognized response format", nameof(responseJson));
}
public static TOut Handle <T, TOut>(T instance, CallbackResponse response, Action <string> action = null)
{
var type = typeof(T);
object result = null;
foreach (var item in type.GetMethods())
{
var attr = item.GetCustomAttributes(typeof(VkMethod), true).FirstOrDefault() as VkMethod;
if (attr != null && attr.Method == response.Type)
{
var pars = item.GetParameters();
var parlist = new List <object>();
foreach (var par in pars)
{
if (par.ParameterType == typeof(CallbackResponse))
{
parlist.Add(response);
}
else if (par.ParameterType == typeof(JsonElement))
{
parlist.Add(response.Object);
}
else
{
throw new ArgumentException("Unknown parameters");
}
}
action?.Invoke(response.Type);
attr.Process();
result = item.Invoke(instance, parlist.ToArray());
}
}
if (result is TOut)
{
return((TOut)result);
}
else
{
return(default);
private IEnumerator InsertCoroutine <T>(T instance, Action <CallbackResponse <T> > onInsertCompleted)
where T : EasyTablesObjectBase
{
string functionUrl = url + "/api/Insert?code=" + hostKey;
// Server expects a json arrary with the format:
// [{"access_token":"value"},{"tableName":"value"},{instanceJson}]
string instanceJson = JsonUtility.ToJson(instance);
string jsonArray = string.Format("[{0}, {1}, {2}]", GetAccessTokenJson(), GetTableNameJson <T>(), instanceJson);
using (UnityWebRequest www = WebRequestUtilities.BuildWebRequest(functionUrl, UnityWebRequest.kHttpVerbPOST, jsonArray))
{
yield return(www.SendWebRequest());
var response = new CallbackResponse <T>();
if (WebRequestUtilities.IsWWWError(www))
{
Debug.Log("Error: " + www.error);
WebRequestUtilities.BuildResponseObjectOnFailure(response, www);
}
else if (www.downloadHandler != null) // all OK.
{
//let's get the new object that was created
try
{
Debug.Log(www.downloadHandler.text);
T newObject = JsonUtility.FromJson <T>(www.downloadHandler.text);
Debug.Log("Got this back from the server: " + newObject.ToString());
response.Status = CallBackResult.Success;
response.Result = newObject;
}
catch (Exception ex)
{
Debug.Log("Exception!: " + ex.ToString());
response.Status = CallBackResult.DeserializationFailure;
response.Exception = ex;
}
}
onInsertCompleted(response);
}
}
