/// <summary> /// Check if user has purchased the subscription and eligible to play /// </summary> /// <param name="callback"> Returns the boolean result whether the user is subscribed and eligible to play the game via callback when the operation is completed</param> public void GetUserEligibleToPlay(ResultCallback <bool> callback) { Report.GetFunctionLog(this.GetType().Name); ResultCallback <ItemInfo> onGotItemInfo = (itemInfoResult) => { if (itemInfoResult.IsError) { callback.TryError(itemInfoResult.Error.Code); return; } string[] skus = itemInfoResult.Value.features; string[] appIds = { AccelBytePlugin.Config.AppId }; AccelBytePlugin.GetEntitlement().GetUserEntitlementOwnershipAny(null, appIds, skus, (ownershipResult) => { if (ownershipResult.IsError) { callback.TryError(ownershipResult.Error.Code); return; } callback.TryOk(ownershipResult.Value.owned); }); }; AccelBytePlugin.GetItems().GetItemByAppId(AccelBytePlugin.Config.AppId, onGotItemInfo); }
private void ReplaceUserRecordRecursive(int remainingAttempt, string key, Dictionary <string, object> recordRequest, ResultCallback callback, Func <Dictionary <string, object>, Dictionary <string, object> > payloadModifier) { if (remainingAttempt <= 0) { callback.TryError(new Error(ErrorCode.PreconditionFailed, "Exhaust all retry attempt to modify game record. Please try again.")); return; } GetUserRecord(key, getUserRecordResult => { var updateRequest = new ConcurrentReplaceRequest(); if (getUserRecordResult.IsError) { if (getUserRecordResult.Error.Code == ErrorCode.PlayerRecordNotFound) { updateRequest.value = recordRequest; updateRequest.updatedAt = DateTime.Now; this.coroutineRunner.Run( this.api.ReplaceUserRecord( this.@namespace, this.session.UserId, this.session.AuthorizationToken, key, updateRequest, callback, () => { ReplaceUserRecordRecursive(remainingAttempt - 1, key, recordRequest, callback, payloadModifier); })); } else { callback.TryError(getUserRecordResult.Error); } } else { getUserRecordResult.Value.value = payloadModifier(getUserRecordResult.Value.value); updateRequest.value = getUserRecordResult.Value.value; updateRequest.updatedAt = getUserRecordResult.Value.updated_at; this.coroutineRunner.Run( this.api.ReplaceUserRecord( this.@namespace, this.session.UserId, this.session.AuthorizationToken, key, updateRequest, callback, () => { ReplaceUserRecordRecursive(remainingAttempt - 1, key, recordRequest, callback, payloadModifier); })); } }); }
public IEnumerator GetSessionId(string accessToken, ResultCallback <ServerSessionResponse> callback) { Assert.IsNotNull(accessToken, "Can't check session ID! accessToken parameter is null!"); if (this.serverType == ServerType.NONE) { callback.TryError(new Error(ErrorCode.NotFound, "Server not registered yet")); yield break; } var request = HttpRequestBuilder.CreateGet(this.baseUrl + "/namespaces/{namespace}/servers/{server}/session") .WithPathParam("namespace", this.namespace_) .WithPathParam("server", serverSetup.pod_name) .WithBearerAuth(accessToken) .WithContentType(MediaType.ApplicationJson) .Accepts(MediaType.ApplicationJson) .GetResult(); IHttpResponse response = null; yield return(this.httpClient.SendRequest(request, rsp => response = rsp)); var result = response.TryParseJson <ServerSessionResponse>(); callback.Try(result); }
public IEnumerator RegisterLocalServer(RegisterLocalServerRequest registerRequest, string accessToken, ResultCallback callback) { Assert.IsNotNull(registerRequest, "Register failed. registerRequest is null!"); Assert.IsNotNull(accessToken, "Can't update a slot! accessToken parameter is null!"); if (this.serverType != ServerType.NONE) { callback.TryError(ErrorCode.Conflict, "Server is already registered."); yield break; } var request = HttpRequestBuilder.CreatePost(this.baseUrl + "/namespaces/{namespace}/servers/local/register") .WithPathParam("namespace", this.namespace_) .WithBearerAuth(accessToken) .WithContentType(MediaType.ApplicationJson) .Accepts(MediaType.ApplicationJson) .WithBody(registerRequest.ToUtf8Json()) .GetResult(); IHttpResponse response = null; yield return(this.httpClient.SendRequest(request, rsp => response = rsp)); var result = response.TryParse(); if (!result.IsError) { serverType = ServerType.LOCALSERVER; serverSetup.pod_name = registerRequest.name; } callback.Try(result); }
/// <summary> /// Ban a Single User. /// Only Moderator that can ban other user. /// </summary> /// <param name="userId">Ban user's user ID</param> /// <param name="banType">The type of Ban</param> /// <param name="reason">The reason of Banning</param> /// <param name="endDate">The date when the ban is lifted</param> /// <param name="comment">The detail or comment about the banning</param> /// <param name="notifyUser">Notify user via email or not</param> /// <param name="callback">Returns a result via callback when completed</param> public void BanUser(string userId, BanType banType, BanReason reason, DateTime endDate, string comment, bool notifyUser, ResultCallback <UserBanResponseV3> callback) { Report.GetFunctionLog(this.GetType().Name); if (!this.loginSession.IsValid()) { callback.TryError(ErrorCode.IsNotLoggedIn); return; } var banRequest = new BanCreateRequest { ban = banType.ToString(), comment = comment, endDate = endDate.ToString("o"), reason = reason.ToString(), skipNotif = !notifyUser }; this.coroutineRunner.Run( this.userAccount.BanUser( AccelBytePlugin.Config.Namespace, this.loginSession.AuthorizationToken, userId, banRequest, callback)); }
public IEnumerator ShutdownServer(ShutdownServerRequest shutdownServerRequest, string accessToken, ResultCallback callback) { Assert.IsNotNull(shutdownServerRequest, "Register failed. shutdownServerNotif is null!"); Assert.IsNotNull(accessToken, "Can't update a slot! accessToken parameter is null!"); if (this.serverType != ServerType.CLOUDSERVER) { callback.TryError(ErrorCode.Conflict, "Server not registered as Cloud Server."); yield break; } shutdownServerRequest.pod_name = serverSetup.pod_name; var request = HttpRequestBuilder.CreatePost(this.baseUrl + "/namespaces/{namespace}/servers/shutdown") .WithPathParam("namespace", this.namespace_) .WithBearerAuth(accessToken) .WithContentType(MediaType.ApplicationJson) .Accepts(MediaType.ApplicationJson) .WithBody(shutdownServerRequest.ToUtf8Json()) .GetResult(); IHttpResponse response = null; yield return(this.httpClient.SendRequest(request, rsp => response = rsp)); var result = response.TryParse(); serverType = ServerType.NONE; callback.Try(result); }
/// <summary> /// Register server to DSM and mark this machine as ready /// </summary> /// <param name="podName">Should be taken from "POD_NAME" environment variable</param> /// <param name="port">Exposed port number to connect to</param> /// <param name="callback">Returns a Result via callback when completed</param> public void RegisterServer(string podName, int portNumber, ResultCallback callback) { Report.GetFunctionLog(this.GetType().Name); Assert.IsNotNull(podName, "Can't Register server; podName is null!"); if (!this.serverSession.IsValid()) { Debug.Log("Server RegisterServer session is not valid"); callback.TryError(ErrorCode.IsNotLoggedIn); return; } this.name = podName; var request = new RegisterServerRequest { pod_name = this.name, port = portNumber }; this.coroutineRunner.Run(this.api.RegisterServer(request, this.serverSession.AuthorizationToken, callback)); if (this.isHeartBeatAutomatic) { this.heartBeatCoroutine = this.coroutineRunner.Run(RunPeriodicHeartBeat()); } }
public IEnumerator Update(UpdateUserRequest updateUserRequest, ResultCallback <UserData> callback) { Report.GetFunctionLog(this.GetType().Name); Assert.IsNotNull(updateUserRequest, "Update failed. updateUserRequest is null!"); if (!string.IsNullOrEmpty(updateUserRequest.emailAddress)) { Error error = new Error(ErrorCode.BadRequest, "Cannot update user email using this function. Use UpdateEmail instead."); callback.TryError(error); } var request = HttpRequestBuilder.CreatePatch(this.baseUrl + "/v4/public/namespaces/{namespace}/users/me") .WithPathParam("namespace", this.@namespace) .WithBearerAuth(this.session.AuthorizationToken) .WithContentType(MediaType.ApplicationJson) .WithBody(updateUserRequest.ToUtf8Json()) .Accepts(MediaType.ApplicationJson) .GetResult(); IHttpResponse response = null; yield return(this.httpClient.SendRequest(request, rsp => response = rsp)); var result = response.TryParseJson <UserData>(); callback.Try(result); }
/// <summary> /// Redeem Campaign Code to Receive In Game Item. /// </summary> /// <param name="code">The campaign code to redeem.</param> /// <param name="region">Region of the item. If not set, the region from the access token will be used.</param> /// <param name="language">Display language.null If not set, the language from the access token will be used.</param> /// <param name="callback">Returns a Result that contains EntitlementInfo via callback when completed</param> public void RedeemCode(string code, string region, string language, ResultCallback <FulfillmentResult> callback) { Report.GetFunctionLog(this.GetType().Name); Assert.IsNotNull(code, "Can't redeem code! code parameter is null!"); if (!this.session.IsValid()) { callback.TryError(ErrorCode.IsNotLoggedIn); return; } FulFillCodeRequest fulFillCodeRequest = new FulFillCodeRequest { code = code, region = region, language = language }; this.coroutineRunner.Run( this.api.RedeemCode( this.@namespace, this.session.UserId, this.session.AuthorizationToken, fulFillCodeRequest, callback)); }
private IEnumerator <ITask> LoginWithOtherPlatformAsync(PlatformType platformType, string platformToken, ResultCallback callback) { if (this.IsLoggedIn) { this.Logout(); } Result <TokenData> loginResult = null; yield return(Task.Await(this.authApi.GetUserTokenWithOtherPlatform(this.@namespace, this.clientId, this.clientSecret, platformType, platformToken, result => { loginResult = result; }))); if (loginResult.IsError) { callback.TryError(ErrorCode.GenerateTokenFailed, "cannot generate platform token for " + platformType, loginResult.Error); yield break; } this.tokenData = loginResult.Value; this.nextRefreshTime = User.ScheduleNormalRefresh(this.tokenData.expires_in); callback.TryOk(); }
/// <summary> /// Query user entitlements. /// </summary> /// <param name="entitlementName">The name of the entitlement (optional)</param> /// <param name="itemId">Item's id (optional)</param> /// <param name="offset">Offset of the list that has been sliced based on Limit parameter (optional, default = 0)</param> /// <param name="limit">The limit of item on page (optional)</param> /// <param name="callback">Returns a Result that contains EntitlementPagingSlicedResult via callback when completed</param> /// <param name="entitlementClazz">Class of the entitlement (optional)</param> /// <param name="entitlementAppType">This is the type of application that entitled (optional)</param> public void QueryUserEntitlements(string entitlementName, string itemId, int offset, int limit, ResultCallback <EntitlementPagingSlicedResult> callback, EntitlementClazz entitlementClazz = EntitlementClazz.NONE, EntitlementAppType entitlementAppType = EntitlementAppType.NONE) { Report.GetFunctionLog(this.GetType().Name); Assert.IsNotNull(entitlementName, "Can't query user entitlements! EntitlementName parameter is null!"); Assert.IsNotNull(itemId, "Can't query user entitlements! ItemId parameter is null!"); if (!this.session.IsValid()) { callback.TryError(ErrorCode.IsNotLoggedIn); return; } this.coroutineRunner.Run( this.api.QueryUserEntitlements( this.@namespace, this.session.UserId, this.session.AuthorizationToken, entitlementName, itemId, offset, limit, entitlementClazz, entitlementAppType, callback)); }
public IEnumerator DeregisterLocalServer(string name, string accessToken, ResultCallback callback) { Assert.IsNotNull(name, "Deregister failed. name is null!"); Assert.IsNotNull(accessToken, "Can't update a slot! accessToken parameter is null!"); if (this.serverType != ServerType.LOCALSERVER) { callback.TryError(ErrorCode.Conflict, "Server not registered as Local Server."); yield break; } var request = HttpRequestBuilder.CreatePost(this.baseUrl + "/namespaces/{namespace}/servers/local/deregister") .WithPathParam("namespace", this.namespace_) .WithBearerAuth(accessToken) .WithContentType(MediaType.ApplicationJson) .Accepts(MediaType.ApplicationJson) .WithBody(string.Format("{{\"name\": \"{0}\"}}", name)) .GetResult(); IHttpResponse response = null; yield return(this.httpWorker.SendRequest(request, rsp => response = rsp)); var result = response.TryParse(); serverType = ServerType.NONE; callback.Try(result); }
private IEnumerator <ITask> LoginWithDeviceIdAsync(DeviceProvider deviceProvider, ResultCallback callback) { if (this.IsLoggedIn) { this.Logout(); } Result <TokenData> loginResult = null; yield return(Task.Await( this.authApi.GetUserTokenWithDeviceId( this.@namespace, this.clientId, this.clientSecret, deviceProvider.DeviceType, deviceProvider.DeviceId, result => loginResult = result))); if (loginResult.IsError) { callback.TryError(loginResult.Error.Code, loginResult.Error.Message); yield break; } this.tokenData = loginResult.Value; this.nextRefreshTime = User.ScheduleNormalRefresh(this.tokenData.expires_in); callback.TryOk(); }
/// <summary> /// Register local server to DSM and mark this machine as ready /// </summary> /// <param name="ip">Local IP Address</param> /// <param name="port">Port number</param> /// <param name="name">Name to uniquely identify this local server</param> /// <param name="callback">Returns a Result via callback when completed</param> public void RegisterLocalServer(string ip, uint port, string name, ResultCallback callback) { Report.GetFunctionLog(this.GetType().Name); Assert.IsNotNull(name, "Can't Register server; podName is null!"); if (!this.serverSession.IsValid()) { callback.TryError(ErrorCode.IsNotLoggedIn); return; } this.name = name; var request = new RegisterLocalServerRequest { ip = ip, port = port, name = name }; string authToken = this.serverSession.AuthorizationToken; this.coroutineRunner.Run(this.api.RegisterLocalServer(request, authToken, callback)); if (this.isHeartBeatAutomatic) { this.heartBeatCoroutine = this.coroutineRunner.Run(RunPeriodicHeartBeat()); } }
public IEnumerator LoginWithDeviceId(ResultCallback callback) { Report.GetFunctionLog(this.GetType().Name); DeviceProvider deviceProvider = DeviceProvider.GetFromSystemInfo(); IHttpRequest request = HttpRequestBuilder.CreatePost(this.baseUrl + "/oauth/platforms/{platformId}/token") .WithPathParam("platformId", deviceProvider.DeviceType) .WithBasicAuth(this.clientId, this.clientSecret) .WithContentType(MediaType.ApplicationForm) .Accepts(MediaType.ApplicationJson) .WithFormParam("device_id", deviceProvider.DeviceId) .WithFormParam("namespace", this.@namespace) .GetResult(); IHttpResponse response = null; yield return(this.httpWorker.SendRequest(request, rsp => response = rsp)); Result <TokenData> result = response.TryParseJson <TokenData>(); this.tokenData = result.Value; if (!result.IsError) { this.maintainAccessTokenCoroutine = this.coroutineRunner.Run(MaintainAccessToken()); callback.TryOk(); } else { callback.TryError(result.Error); } }
public IEnumerator LoginWithUsername(string username, string password, ResultCallback callback) { Report.GetFunctionLog(this.GetType().Name); Assert.IsNotNull(username, "Username parameter is null."); Assert.IsNotNull(password, "Password parameter is null."); var request = HttpRequestBuilder.CreatePost(this.baseUrl + "/oauth/token") .WithBasicAuth(this.clientId, this.clientSecret) .WithContentType(MediaType.ApplicationForm) .Accepts(MediaType.ApplicationJson) .WithFormParam("grant_type", "password") .WithFormParam("username", username) .WithFormParam("password", password) .WithFormParam("namespace", this.@namespace) .GetResult(); IHttpResponse response = null; yield return(this.httpWorker.SendRequest(request, rsp => response = rsp)); Result <TokenData> result = response.TryParseJson <TokenData>(); this.tokenData = result.Value; if (!result.IsError) { this.maintainAccessTokenCoroutine = this.coroutineRunner.Run(MaintainAccessToken()); callback.TryOk(); } else { callback.TryError(result.Error); } }
public IEnumerator LoginWithOtherPlatform(PlatformType platformType, string platformToken, ResultCallback callback) { Report.GetFunctionLog(this.GetType().Name); Assert.IsNotNull(platformToken, "PlatformToken parameter is null."); var request = HttpRequestBuilder.CreatePost(this.baseUrl + "/oauth/platforms/{platformId}/token") .WithPathParam("platformId", platformType.ToString().ToLower()) .WithBasicAuth(this.clientId, this.clientSecret) .WithContentType(MediaType.ApplicationForm) .Accepts(MediaType.ApplicationJson) .WithFormParam("platform_token", platformToken) .WithFormParam("namespace", this.@namespace) .GetResult(); IHttpResponse response = null; yield return(this.httpWorker.SendRequest(request, rsp => response = rsp)); Result <TokenData> result = response.TryParseJson <TokenData>(); this.tokenData = result.Value; if (!result.IsError) { this.maintainAccessTokenCoroutine = this.coroutineRunner.Run(MaintainAccessToken()); callback.TryOk(); } else { callback.TryError(result.Error); } }
private IEnumerator LoginAsync(Func <ResultCallback, IEnumerator> loginMethod, ResultCallback callback) { if (this.sessionAdapter.IsValid()) { callback.TryError(ErrorCode.InvalidRequest, "User is already logged in."); yield break; } Result loginResult = null; yield return(loginMethod(r => loginResult = r)); if (loginResult.IsError) { callback.TryError(loginResult.Error); yield break; } this.sessionAdapter.AuthorizationToken = this.loginSession.AuthorizationToken; if (this.needsUserId) { Result <UserData> userDataResult = null; yield return(RefreshDataAsync(result => userDataResult = result)); if (userDataResult.IsError) { callback.TryError(userDataResult.Error); yield break; } this.sessionAdapter.UserId = this.userDataCache.userId; } else { this.sessionAdapter.UserId = this.loginSession.UserId; } callback.TryOk(); }
/// <summary> /// Get current active season. /// </summary> /// <param name="language">The language of the Season.</param> /// <param name="callback">Returns a Result that contains SeasonInfo via callback when completed.</param> public void GetCurrentSeason(string language, ResultCallback <SeasonInfo> callback) { Report.GetFunctionLog(this.GetType().Name); if (!this.session.IsValid()) { callback.TryError(ErrorCode.IsNotLoggedIn); return; } this.coroutineRunner.Run(this.api.GetCurrentSeason(this.@namespace, this.session.AuthorizationToken, language, callback)); }
/// <summary> /// Get user profile for current logged in user. /// </summary> /// <param name="callback">Returns a Result that contains UserProfile via callback when completed.</param> public void GetUserProfile(ResultCallback <UserProfile> callback) { Report.GetFunctionLog(this.GetType().Name); if (!this.session.IsValid()) { callback.TryError(ErrorCode.IsNotLoggedIn); return; } this.coroutineRunner.Run(this.api.GetUserProfile(this.@namespace, this.session.AuthorizationToken, callback)); }
/// <summary> /// Enqueue Game Server to Joinable Session Queue. /// this will make this server joinable by other parties while already in a session. /// </summary> /// <param name="body">the session's data (get this data from QuerySessionStatus)</param> /// <param name="callback">the result of this operation</param> public void EnqueueJoinableSession(MatchmakingResult body, ResultCallback callback) { Report.GetFunctionLog(this.GetType().Name); if (!this.serverSession.IsValid()) { callback.TryError(ErrorCode.IsNotLoggedIn); return; } coroutineRunner.Run(api.EnqueueJoinableSession(this.@namespace, serverSession.AuthorizationToken, body, callback)); }
/// <summary> /// Claim Season Rewards. /// </summary> /// <param name="rewardRequest">Detail information for the Reward Request.</param> /// <param name="callback">Returns a Result that contains SeasonClaimRewardResponse via callback when completed.</param> public void ClaimRewards(SeasonClaimRewardRequest rewardRequest, ResultCallback <SeasonClaimRewardResponse> callback) { Report.GetFunctionLog(this.GetType().Name); if (!this.session.IsValid()) { callback.TryError(ErrorCode.IsNotLoggedIn); return; } this.coroutineRunner.Run(this.api.ClaimRewards(this.@namespace, this.session.AuthorizationToken, this.session.UserId, rewardRequest, callback)); }
/// <summary> /// Get all profiles of specified users /// </summary> /// <param name="userIds">Id of some users to get</param> /// <param name="callback">Returns all profiles for specified users via callback when completed.</param> public void BatchGetGameProfiles(ICollection <string> userIds, ResultCallback <UserGameProfiles[]> callback) { Report.GetFunctionLog(this.GetType().Name); if (!this.session.IsValid()) { callback.TryError(ErrorCode.IsNotLoggedIn); return; } this.coroutineRunner.Run( this.api.BatchGetGameProfiles(this.@namespace, userIds, this.session.AuthorizationToken, callback)); }
/// <summary> /// Get user data from another user by email /// </summary> /// <param name="emailOrDisplayName"> email or display name that needed to get user data</param> /// <param name="callback"> Return a Result that contains UserData when completed. </param> public void SearchUsers(string emailOrDisplayName, ResultCallback <PagedPublicUsersInfo> callback) { Report.GetFunctionLog(this.GetType().Name); if (!this.sessionAdapter.IsValid()) { callback.TryError(ErrorCode.IsNotLoggedIn); return; } this.coroutineRunner.Run(this.userAccount.SearchUsers(emailOrDisplayName, callback)); }
/// <summary> /// Get user data from another user by user id /// </summary> /// <param name="userId"> user id that needed to get user data</param> /// <param name="callback"> Return a Result that contains UserData when completed. </param> public void GetUserByUserId(string userId, ResultCallback <UserData> callback) { Report.GetFunctionLog(this.GetType().Name); if (!this.sessionAdapter.IsValid()) { callback.TryError(ErrorCode.IsNotLoggedIn); return; } this.coroutineRunner.Run(this.userAccount.GetUserByUserId(userId, callback)); }
/// <summary> /// Get array of other platforms this user linked to /// </summary> /// <param name="callback">Returns a Result that contains PlatformLink array via callback when /// completed.</param> public void GetPlatformLinks(ResultCallback <PagedPlatformLinks> callback) { Report.GetFunctionLog(this.GetType().Name); if (!this.sessionAdapter.IsValid()) { callback.TryError(ErrorCode.IsNotLoggedIn); return; } this.coroutineRunner.Run(this.userAccount.GetPlatformLinks(callback)); }
/// <summary> /// Unlink other platform that has been linked to the currently logged in user. The change will take effect /// after user has been re-login. /// </summary> /// <param name="platformType">Other platform's type (Google, Steam, Facebook, etc)</param> /// <param name="platformTicket">Ticket / token from other platform to unlink from this user</param> /// <param name="callback">Returns a result via callback when completed</param> public void UnlinkOtherPlatform(PlatformType platformType, string platformTicket, ResultCallback callback) { Report.GetFunctionLog(this.GetType().Name); if (!this.sessionAdapter.IsValid()) { callback.TryError(ErrorCode.IsNotLoggedIn); return; } this.coroutineRunner.Run(this.userAccount.UnlinkOtherPlatform(platformType, callback)); }
public IEnumerator ShutdownServer(ShutdownServerRequest shutdownServerRequest, string accessToken, ResultCallback callback) { if (IsCurrentProvider(Provider.AGONES) && serverType != ServerType.LOCALSERVER) { #if ENABLE_AGONES_PLUGIN yield return(ShutdownAgones(callback)); #else callback.TryError(ErrorCode.NotFound, "Can't request shutdown server. Agones provider arguments is passed but Agones plugin is not found."); #endif yield break; } Assert.IsNotNull(shutdownServerRequest, "Register failed. shutdownServerNotif is null!"); Assert.IsNotNull(accessToken, "Can't update a slot! accessToken parameter is null!"); if (this.serverType != ServerType.CLOUDSERVER) { callback.TryError(ErrorCode.Conflict, "Server not registered as Cloud Server."); yield break; } shutdownServerRequest.pod_name = serverSetup.pod_name; var request = HttpRequestBuilder.CreatePost(this.dsmServerUrl + "/dsm/namespaces/{namespace}/servers/shutdown") .WithPathParam("namespace", this.namespace_) .WithBearerAuth(accessToken) .WithContentType(MediaType.ApplicationJson) .Accepts(MediaType.ApplicationJson) .WithBody(shutdownServerRequest.ToUtf8Json()) .GetResult(); IHttpResponse response = null; yield return(this.httpWorker.SendRequest(request, rsp => response = rsp)); var result = response.TryParse(); serverType = ServerType.NONE; callback.Try(result); }
private IEnumerator GetUserEntitlementOwnershipTokenAsync(string key, string[] itemIds, string[] appIds, string[] skus, bool verifyPublicKey, bool verifyExpiration, bool verifyUserId, ResultCallback <OwnershipEntitlement[]> callback) { if (!this.session.IsValid()) { callback.TryError(ErrorCode.IsNotLoggedIn); yield break; } Result <OwnershipToken> result = null; yield return(this.api.GetUserEntitlementOwnershipToken( AccelBytePlugin.Config.PublisherNamespace, this.session.AuthorizationToken, itemIds, appIds, skus, r => result = r)); if (result.IsError) { callback.TryError(result.Error.Code); yield break; } if (!JsonWebToken.TryDecodeToken <OwnershipTokenPayload>(key, result.Value.ownershipToken, out var payloadResult, verifyPublicKey, verifyExpiration)) { callback.TryError(ErrorCode.InvalidResponse); yield break; } if (verifyUserId && this.session.UserId != payloadResult.sub) { callback.TryError(ErrorCode.InvalidResponse); yield break; } callback.TryOk(payloadResult.entitlements); }
/// <summary> /// Send any data with class T to Telemetry service. The data type must be serializable by implementing /// DataContract attribute. /// </summary> /// <param name="eventTag">Event tag</param> /// <param name="eventData">Event data</param> /// <param name="callback">Returns a Result via callback when completed.</param> /// <typeparam name="T">A class that implements DataContract and DataMember attribute</typeparam> public void SendEvent <T>(TelemetryEventTag eventTag, T eventData, ResultCallback callback) where T : class { if (!this.user.IsLoggedIn) { callback.TryError(ErrorCode.IsNotLoggedIn); return; } if (eventData is string) { callback.TryError(ErrorCode.InvalidRequest, "string is not allowed as event data"); return; } this.taskDispatcher.Start( Task.Retry( cb => this.api.SendEvent(this.user.Namespace, this.clientId, this.user.UserId, eventTag, eventData, result => cb(result)), result => this.coroutineRunner.Run(() => callback((Result)result)), this.user)); }