public void Login(string username, string password, Action <ILoginResult> callback)
{
try
{
database.ClearServerTimeOffsetMillis();
IGuestControllerClient guestControllerClient = guestControllerClientFactory.Create("NoSwid");
guestControllerClient.LogIn(new LogInRequest
{
loginValue = username,
password = password
}, delegate(GuestControllerResult <LogInResponse> r)
{
if (!r.Success)
{
logger.Error("Login failed");
callback(new LoginFailedAuthenticationResult());
}
else
{
HandleLoginSuccess(r, callback);
}
});
}
catch (Exception arg)
{
logger.Critical("Unhandled exception: " + arg);
callback(new LoginResult(success: false, null));
}
}
public static void Unfriend(AbstractLogger logger, INotificationQueue notificationQueue, IMixWebCallFactory mixWebCallFactory, string friendSwid, Action successCallback, Action failureCallback)
{
try
{
RemoveFriendshipRequest removeFriendshipRequest = new RemoveFriendshipRequest();
removeFriendshipRequest.FriendUserId = friendSwid;
RemoveFriendshipRequest request = removeFriendshipRequest;
IWebCall <RemoveFriendshipRequest, RemoveFriendshipResponse> webCall = mixWebCallFactory.FriendshipDeletePost(request);
webCall.OnResponse += delegate(object sender, WebCallEventArgs <RemoveFriendshipResponse> e)
{
RemoveFriendshipResponse response = e.Response;
RemoveFriendshipNotification notification = response.Notification;
if (NotificationValidator.Validate(notification))
{
notificationQueue.Dispatch(notification, successCallback, failureCallback);
}
else
{
logger.Critical("Failed to validate remove friendship response: " + JsonParser.ToJson(response));
failureCallback();
}
};
webCall.OnError += delegate
{
failureCallback();
};
webCall.Execute();
}
catch (Exception arg)
{
logger.Critical("Unhandled exception: " + arg);
failureCallback();
}
}
private static void HandleGetStateSuccess(AbstractLogger logger, IEpochTime epochTime, IDatabase database, IUserDatabase userDatabase, INotificationQueue notificationQueue, GetStateResponse response, IMixWebCallFactory mixWebCallFactory, Action <GetStateResponse> successCallback, Action failureCallback)
{
try
{
if (ValidateResponse(response))
{
epochTime.ReferenceTime = response.Timestamp.Value;
database.SetServerTimeOffsetMillis((long)epochTime.Offset.TotalMilliseconds);
logger.Debug("New time offset: " + epochTime.Offset);
successCallback(response);
notificationQueue.LatestSequenceNumber = response.NotificationSequenceCounter.Value;
}
else
{
logger.Critical("Error validating get state response: " + JsonParser.ToJson(response));
failureCallback();
notificationQueue.Clear();
}
}
catch (Exception ex)
{
logger.Critical("Unhandled exception: " + ex);
failureCallback();
notificationQueue.Clear();
}
}
public static void ModerateText(AbstractLogger logger, IMixWebCallFactory mixWebCallFactory, string text, bool isTrusted, Action <ModerateTextResponse> successCallback, Action failureCallback)
{
try
{
ModerateTextRequest moderateTextRequest = new ModerateTextRequest();
moderateTextRequest.Text = text;
moderateTextRequest.ModerationPolicy = (isTrusted ? "Trusted" : "UnTrusted");
ModerateTextRequest request = moderateTextRequest;
IWebCall <ModerateTextRequest, ModerateTextResponse> webCall = mixWebCallFactory.ModerationTextPut(request);
webCall.OnResponse += delegate(object sender, WebCallEventArgs <ModerateTextResponse> e)
{
ModerateTextResponse response = e.Response;
if (ValidateModerateTextResponse(response))
{
successCallback(response);
}
else
{
logger.Critical("Failed to validate moderate text response: " + JsonParser.ToJson(response));
failureCallback();
}
};
webCall.OnError += delegate
{
failureCallback();
};
webCall.Execute();
}
catch (Exception ex)
{
logger.Critical("Unhandled exception: " + ex);
failureCallback();
}
}
public void Reuse(string swid, string accessToken, string refreshToken, string displayName, string proposedDisplayName, string proposedDisplayNameStatus, string firstName, string etag, string ageBand, string accountStatus, string countryCode, Action <IReuseExistingGuestControllerLoginResult> callback)
{
try
{
database.ClearServerTimeOffsetMillis();
database.StoreSession(swid, accessToken, refreshToken, displayName, firstName, etag, ageBand, proposedDisplayName, proposedDisplayNameStatus, accountStatus, updateLastProfileRefreshTime: false, countryCode);
mixSessionStarter.Start(swid, accessToken, delegate
{
HandleMixSessionStartSuccess(swid, callback);
}, delegate
{
callback(new ReuseExistingGuestControllerLoginResult(success: false, null));
});
}
catch (CorruptionException ex)
{
logger.Fatal("Corruption detected during session reuse: " + ex);
callback(new ReuseExistingGuestControllerLoginCorruptionDetectedResult());
}
catch (Exception ex2)
{
logger.Critical("Unhandled exception: " + ex2);
callback(new ReuseExistingGuestControllerLoginResult(success: false, null));
}
}
public void Register(bool isTestProfile, string username, string password, string firstName, string lastName, string email, string parentEmail, string languagePreference, string assertedCountry, DateTime?dateOfBirth, IEnumerable <KeyValuePair <IMarketingItem, bool> > marketingAgreements, IEnumerable <ILegalDocument> acceptedLegalDocuments, Action <IRegisterResult> callback)
{
try
{
database.ClearServerTimeOffsetMillis();
List <Disney.Mix.SDK.Internal.GuestControllerDomain.MarketingItem> marketing = (from p in marketingAgreements
select new Disney.Mix.SDK.Internal.GuestControllerDomain.MarketingItem
{
code = p.Key.Id,
subscribed = p.Value
}).ToList();
object obj;
if (!dateOfBirth.HasValue)
{
obj = new BaseRegisterProfile();
}
else
{
RegisterProfile registerProfile = new RegisterProfile();
registerProfile.dateOfBirth = dateOfBirth.Value.ToString("yyyy-MM-dd");
obj = registerProfile;
}
BaseRegisterProfile baseRegisterProfile = (BaseRegisterProfile)obj;
baseRegisterProfile.testProfileFlag = (isTestProfile ? "Y" : "N");
baseRegisterProfile.username = username;
baseRegisterProfile.firstName = firstName;
baseRegisterProfile.lastName = lastName;
baseRegisterProfile.email = email;
baseRegisterProfile.parentEmail = parentEmail;
baseRegisterProfile.languagePreference = languagePreference;
baseRegisterProfile.region = assertedCountry;
BaseRegisterProfile profile = baseRegisterProfile;
List <string> legalAssertions = (from doc in acceptedLegalDocuments
select doc.Id).ToList();
RegisterRequest registerRequest = new RegisterRequest();
registerRequest.password = password;
registerRequest.profile = profile;
registerRequest.marketing = marketing;
registerRequest.legalAssertions = legalAssertions;
RegisterRequest request = registerRequest;
IGuestControllerClient guestControllerClient = guestControllerClientFactory.Create("NoSwid");
guestControllerClient.Register(request, delegate(GuestControllerResult <LogInResponse> r)
{
HandleRegisterSuccess(r, marketing, callback);
});
}
catch (CorruptionException arg)
{
logger.Fatal("Corruption detected during registration: " + arg);
callback(new RegisterCorruptionDetectedResult());
}
catch (Exception arg2)
{
logger.Critical("Unhandled exception: " + arg2);
callback(new RegisterResult(success: false, null, null));
}
}
public static void Send(AbstractLogger logger, INotificationQueue notificationQueue, IMixWebCallFactory mixWebCallFactory, string inviteeDisplayName, bool requestTrust, Action <long> successCallback, Action <ISendFriendInvitationResult> failureCallback)
{
try
{
AddFriendshipInvitationRequest addFriendshipInvitationRequest = new AddFriendshipInvitationRequest();
addFriendshipInvitationRequest.InviteeDisplayName = inviteeDisplayName;
addFriendshipInvitationRequest.IsTrusted = requestTrust;
AddFriendshipInvitationRequest request = addFriendshipInvitationRequest;
IWebCall <AddFriendshipInvitationRequest, AddFriendshipInvitationResponse> webCall = mixWebCallFactory.FriendshipInvitationPut(request);
webCall.OnResponse += delegate(object sender, WebCallEventArgs <AddFriendshipInvitationResponse> e)
{
AddFriendshipInvitationResponse response = e.Response;
if (NotificationValidator.Validate(response.Notification))
{
notificationQueue.Dispatch(response.Notification, delegate
{
successCallback(response.Notification.Invitation.FriendshipInvitationId.Value);
}, delegate
{
failureCallback(new SendFriendInvitationResult(success: false, null));
});
}
else
{
logger.Critical("Failed to validate invitation: " + JsonParser.ToJson(response));
failureCallback(new SendFriendInvitationResult(success: false, null));
}
};
webCall.OnError += delegate(object sender, WebCallErrorEventArgs e)
{
string status = e.Status;
string message = e.Message;
string text = status;
if (text != null && text == "INVITATION_ALREADY_EXISTS")
{
logger.Error("Failed to send invitation because it already exists: " + message);
failureCallback(new SendFriendInvitationAlreadyExistsResult(success: false, null));
}
else
{
failureCallback(new SendFriendInvitationResult(success: false, null));
}
};
webCall.Execute();
}
catch (Exception ex)
{
logger.Critical("Unhandled exception: " + ex);
failureCallback(new SendFriendInvitationResult(success: false, null));
}
}
public static void UpdateDisplayName(AbstractLogger logger, IMixWebCallFactory mixWebCallFactory, string displayName, Action <IUpdateDisplayNameResult> callback)
{
try
{
SetDisplayNameRequest setDisplayNameRequest = new SetDisplayNameRequest();
setDisplayNameRequest.DisplayName = displayName;
SetDisplayNameRequest request = setDisplayNameRequest;
IWebCall <SetDisplayNameRequest, SetDisplayNameResponse> webCall = mixWebCallFactory.DisplaynamePut(request);
webCall.OnResponse += delegate(object sender, WebCallEventArgs <SetDisplayNameResponse> e)
{
SetDisplayNameResponse response = e.Response;
if (ValidateSetDisplayNameResponse(response))
{
callback(new UpdateDisplayNameResult(success: true));
}
else
{
logger.Critical("Failed to validate update display name response!");
callback(new UpdateDisplayNameResult(success: false));
}
};
webCall.OnError += delegate(object sender, WebCallErrorEventArgs e)
{
switch (e.Status)
{
case "DISPLAYNAME_MODERATION_FAILED":
logger.Warning("Failed to update display name due to moderation failure: " + e.Message);
callback(new UpdateDisplayNameFailedModerationResult(success: false));
break;
case "DISPLAYNAME_ASSIGNMENT_FAILED":
logger.Warning("Failed to update display name due to assignment failure: " + e.Message);
callback(new UpdateDisplayNameExistsResult(success: false));
break;
default:
callback(new UpdateDisplayNameResult(success: false));
break;
}
};
webCall.Execute();
}
catch (Exception ex)
{
logger.Critical("Unhandled exception: " + ex);
callback(new UpdateDisplayNameResult(success: false));
}
}
public static void LinkChild(AbstractLogger logger, IGuestControllerClient guestControllerClient, string childSwid, string childAccessToken, Action <ILinkChildResult> callback)
{
try
{
LinkChildRequest linkChildRequest = new LinkChildRequest();
linkChildRequest.authZToken = childAccessToken;
LinkChildRequest request = linkChildRequest;
guestControllerClient.LinkChild(request, childSwid, delegate(GuestControllerResult <GuestControllerWebCallResponse> r)
{
if (!r.Success)
{
callback(MakeGenericFailure());
}
else if (r.Response.error != null)
{
callback(ParseError(r.Response));
}
else
{
callback(new LinkChildResult(success: true));
}
});
}
catch (Exception ex)
{
logger.Critical("Unhandled exception: " + ex);
callback(MakeGenericFailure());
}
}
public static void LinkClaimableChildren(AbstractLogger logger, IGuestControllerClient guestControllerClient, IEnumerable <string> childSwids, Action <ILinkChildResult> callback)
{
try
{
LinkClaimableChildrenRequest linkClaimableChildrenRequest = new LinkClaimableChildrenRequest();
linkClaimableChildrenRequest.swids = childSwids.ToArray();
LinkClaimableChildrenRequest request = linkClaimableChildrenRequest;
guestControllerClient.LinkClaimableChildren(request, delegate(GuestControllerResult <GuestControllerWebCallResponse> r)
{
if (!r.Success)
{
callback(MakeGenericFailure());
}
else if (r.Response.error != null)
{
callback(ParseError(r.Response));
}
else
{
callback(new LinkChildResult(success: true));
}
});
}
catch (Exception ex)
{
logger.Critical("Unhandled exception: " + ex);
callback(MakeGenericFailure());
}
}
public void Send(string lookupValue, string languageCode, Action <ISendMultipleAccountsResolutionResult> callback)
{
try
{
guestControllerClient.ResolveMase(new RecoverRequest
{
lookupValue = lookupValue
}, languageCode, delegate(GuestControllerResult <NotificationResponse> r)
{
if (!r.Success)
{
callback(new SendMultipleAccountsResolutionResult(success: false));
}
else
{
ISendMultipleAccountsResolutionResult resolveMaseResult = GuestControllerErrorParser.GetResolveMaseResult(r.Response.error);
if (resolveMaseResult != null)
{
callback(resolveMaseResult);
}
else
{
callback(new SendMultipleAccountsResolutionResult(r.Response.data != null));
}
}
});
}
catch (Exception ex)
{
logger.Critical("Unhandled exception: " + ex);
callback(new SendMultipleAccountsResolutionResult(success: false));
}
}
public static void Report(AbstractLogger logger, IMixWebCallFactory mixWebCallFactory, string userId, ReportUserReason reason, Action successCallback, Action failureCallback)
{
try
{
ReportPlayerRequest reportPlayerRequest = new ReportPlayerRequest();
reportPlayerRequest.ReportedUserId = userId;
reportPlayerRequest.Reason = reason.ToString();
ReportPlayerRequest request = reportPlayerRequest;
IWebCall <ReportPlayerRequest, BaseResponse> webCall = mixWebCallFactory.ModerationReportPlayerPut(request);
webCall.OnResponse += delegate
{
successCallback();
};
webCall.OnError += delegate
{
failureCallback();
};
webCall.Execute();
}
catch (Exception ex)
{
logger.Critical("Unhandled exception: " + ex);
failureCallback();
}
}
public static void GetState(AbstractLogger logger, IEpochTime epochTime, string clientVersion, IDatabase database, IUserDatabase userDatabase, INotificationQueue notificationQueue, IMixWebCallFactory mixWebCallFactory, string localUserId, long lastNotificationTime, Action <GetStateResponse> successCallback, Action failureCallback)
{
try
{
GetStateRequest getStateRequest = new GetStateRequest();
getStateRequest.UserId = localUserId;
getStateRequest.ClientVersion = clientVersion;
GetStateRequest request = getStateRequest;
IWebCall <GetStateRequest, GetStateResponse> webCall = mixWebCallFactory.StatePost(request);
webCall.OnResponse += delegate(object sender, WebCallEventArgs <GetStateResponse> e)
{
HandleGetStateSuccess(logger, epochTime, database, userDatabase, notificationQueue, e.Response, mixWebCallFactory, successCallback, failureCallback);
};
webCall.OnError += delegate
{
failureCallback();
};
webCall.Execute();
}
catch (Exception ex)
{
logger.Critical("Unhandled exception: " + ex);
failureCallback();
}
}
public static void GetRequirements(AbstractLogger logger, string countryCode, IMixWebCallFactory mixWebCallFactory, Action <bool, bool> successCallback, Action failureCallback)
{
try
{
PilCheckRequest pilCheckRequest = new PilCheckRequest();
pilCheckRequest.PersonalInformationUsage = "PUBLIC_DISCLOSURE";
pilCheckRequest.CountryCode = countryCode;
PilCheckRequest request = pilCheckRequest;
IWebCall <PilCheckRequest, PilCheckResponse> webCall = mixWebCallFactory.PilCheckPost(request);
webCall.OnResponse += delegate(object sender, WebCallEventArgs <PilCheckResponse> e)
{
bool?adultVerificationRequired = e.Response.AdultVerificationRequired;
bool?adultVerificationAvailable = e.Response.AdultVerificationAvailable;
if (!adultVerificationRequired.HasValue || !adultVerificationAvailable.HasValue)
{
failureCallback();
}
else
{
successCallback(adultVerificationRequired.Value, adultVerificationAvailable.Value);
}
};
webCall.OnError += delegate
{
failureCallback();
};
webCall.Execute();
}
catch (Exception ex)
{
logger.Critical("Unhandled exception: " + ex);
failureCallback();
}
}
public static void SetAway(AbstractLogger logger, IMixWebCallFactory mixWebCallFactory, Action <BaseResponse> successCallback, Action failureCallback)
{
try
{
SetPresenceRequest setPresenceRequest = new SetPresenceRequest();
setPresenceRequest.State = "away";
SetPresenceRequest request = setPresenceRequest;
IWebCall <SetPresenceRequest, BaseResponse> webCall = mixWebCallFactory.PresencePut(request);
webCall.OnResponse += delegate(object sender, WebCallEventArgs <BaseResponse> e)
{
BaseResponse response = e.Response;
successCallback(response);
};
webCall.OnError += delegate
{
failureCallback();
};
webCall.Execute();
}
catch (Exception arg)
{
logger.Critical("Unhandled exception: " + arg);
failureCallback();
}
}
public void Send(string lookupValue, string languageCode, Action <ISendNonRegisteredTransactorUpgradeResult> callback)
{
try
{
guestControllerClient.UpgradeNrt(new RecoverRequest
{
lookupValue = lookupValue
}, languageCode, delegate(GuestControllerResult <NotificationResponse> r)
{
if (!r.Success)
{
callback(new SendNonRegisteredTransactorUpgradeResult(success: false));
}
else
{
ISendNonRegisteredTransactorUpgradeResult upgradeNrtResult = GuestControllerErrorParser.GetUpgradeNrtResult(r.Response.error);
if (upgradeNrtResult != null)
{
callback(upgradeNrtResult);
}
else
{
callback(new SendNonRegisteredTransactorUpgradeResult(r.Response.data != null));
}
}
});
}
catch (Exception ex)
{
logger.Critical("Unhandled exception: " + ex);
callback(new SendNonRegisteredTransactorUpgradeResult(success: false));
}
}
public void Send(string lookupValue, string languageCode, Action <ISendUsernameRecoveryResult> callback)
{
try
{
RecoverRequest recoverRequest = new RecoverRequest();
recoverRequest.lookupValue = lookupValue;
RecoverRequest request = recoverRequest;
guestControllerClient.RecoverUsername(request, languageCode, delegate(GuestControllerResult <NotificationResponse> r)
{
if (!r.Success)
{
callback(new SendUsernameRecoveryResult(success: false));
}
else
{
ISendUsernameRecoveryResult recoverUsernameResult = GuestControllerErrorParser.GetRecoverUsernameResult(r.Response.error);
if (recoverUsernameResult != null)
{
callback(recoverUsernameResult);
}
else
{
callback(new SendUsernameRecoveryResult(r.Response.data != null));
}
}
});
}
catch (Exception ex)
{
logger.Critical("Unhandled exception: " + ex);
callback(new SendUsernameRecoveryResult(success: false));
}
}
public static void GetPermission(AbstractLogger logger, IGuestControllerClient guestControllerClient, string activityCode, string childSwid, Action <IPermissionResult> callback)
{
if (string.IsNullOrEmpty(childSwid) || string.IsNullOrEmpty(activityCode))
{
callback(new PermissionFailedInvalidResult());
return;
}
try
{
guestControllerClient.GetPermission(childSwid, delegate(GuestControllerResult <GetPermissionsResponse> r)
{
if (!r.Success)
{
callback(MakeGenericFailure());
}
else if (r.Response.error != null || r.Response.data == null)
{
callback(MakeGenericFailure());
}
else
{
Permission permission = r.Response.data.activityPermissions.FirstOrDefault((Permission ap) => ap.activityCode == activityCode);
ActivityApprovalStatus status = ((permission == null) ? ActivityApprovalStatus.Unknown : ActivityApprovalStatusConverter.Convert(permission.approvalStatus));
callback(new PermissionResult(success: true, status));
}
});
}
catch (Exception ex)
{
logger.Critical("Unhandled exception: " + ex);
callback(MakeGenericFailure());
}
}
public static bool StoreProfile(AbstractLogger logger, IDatabase database, IEpochTime epochTime, string swid, ProfileData profileData)
{
Disney.Mix.SDK.Internal.GuestControllerDomain.DisplayName displayNameData = profileData.displayName;
if (displayNameData != null)
{
try
{
database.UpdateSessionDocument(swid, delegate(SessionDocument doc)
{
doc.DisplayNameText = displayNameData.displayName;
doc.ProposedDisplayName = displayNameData.proposedDisplayName;
doc.ProposedDisplayNameStatus = displayNameData.proposedStatus;
doc.FirstName = profileData.profile.firstName;
doc.LastProfileRefreshTime = epochTime.Seconds;
doc.AccountStatus = profileData.profile.status;
});
}
catch (Exception arg)
{
logger.Critical("Unhandled exception: " + arg);
return(false);
}
}
return(true);
}
public void Get(Action <IInternalGetRegistrationConfigurationResult> callback)
{
try
{
IGuestControllerClient guestControllerClient = guestControllerClientFactory.Create("NoSWID");
guestControllerClient.GetSiteConfiguration(delegate(GuestControllerResult <SiteConfigurationResponse> r)
{
HandleResult(r, callback);
});
}
catch (Exception arg)
{
logger.Critical("Unhandled exception: " + arg);
callback(new GetRegistrationConfigurationResult(success: false, null));
}
}
private static void HandleGetLinkedChildrenResult(AbstractLogger logger, IMixWebCallFactory mixWebCallFactory, Action <IGetLinkedUsersResult> callback, GuestControllerResult <ChildrenResponse> result)
{
try
{
if (!result.Success || result.Response.error != null)
{
callback(MakeGenericFailure());
}
else
{
List <Profile> list = (result.Response.data == null) ? null : result.Response.data.children;
if (list == null)
{
callback(MakeGenericFailure());
}
else
{
LinkedUsersGetter.Get(logger, mixWebCallFactory, list, delegate(LinkedUser[] users)
{
callback((users == null) ? MakeGenericFailure() : new GetLinkedUsersResult(success: true, users));
});
}
}
}
catch (Exception arg)
{
logger.Critical("Unhandled exception: " + arg);
callback(MakeGenericFailure());
}
}
private void Start(string swid, string guestControllerAccessToken, RSAParameters rsaParameters, Action<MixSessionStartResult> successCallback, Action failureCallback)
{
try
{
ISessionRefresher sessionRefresher = sessionRefresherFactory.Create(this);
IMixWebCallFactory mixWebCallFactory = mixWebCallFactoryFactory.Create(sessionStartEncryptor, swid, guestControllerAccessToken, sessionRefresher);
StartUserSessionRequest request = BuildRequest(swid, rsaParameters);
IWebCall<StartUserSessionRequest, StartUserSessionResponse> webCall = mixWebCallFactory.SessionUserPut(request);
webCall.OnResponse += delegate(object sender, WebCallEventArgs<StartUserSessionResponse> e)
{
StartUserSessionResponse response = e.Response;
if (!ValidateResponse(response))
{
logger.Critical("Error parsing the session start response: " + JsonParser.ToJson(response));
failureCallback();
}
else
{
long sessionId = response.SessionId.Value;
byte[] ciphertext = Convert.FromBase64String(response.EncryptedSymmetricKey);
byte[] symmetricKey = rsaEncryptor.Decrypt(ciphertext, rsaParameters);
keychain.PushNotificationKey = symmetricKey;
database.UpdateSessionDocument(swid, delegate(SessionDocument doc)
{
doc.PreviousSymmetricEncryptionKey = doc.CurrentSymmetricEncryptionKey;
doc.CurrentSymmetricEncryptionKey = symmetricKey;
doc.SessionId = sessionId;
doc.LatestNotificationSequenceNumber = 0L;
});
IWebCallEncryptor webCallEncryptor = webCallEncryptorFactory.Create(symmetricKey, sessionId);
MixSessionStartResult obj = new MixSessionStartResult(webCallEncryptor);
successCallback(obj);
}
};
webCall.OnError += delegate
{
failureCallback();
};
webCall.Execute(force: true);
}
catch (Exception ex)
{
logger.Critical("Unhandled exception: " + ex);
failureCallback();
}
}
private static void Enable(AbstractLogger logger, IDatabase database, IMixWebCallFactory mixWebCallFactory, string token, string tokenType, string provisionId, bool enableVisible, string swid, Action successCallback, Action failureCallback)
{
try
{
TogglePushNotificationRequest togglePushNotificationRequest = new TogglePushNotificationRequest();
togglePushNotificationRequest.PushToken = new PushToken
{
Token = token,
TokenType = tokenType
};
togglePushNotificationRequest.State = (enableVisible ? "ALL" : "ONLY_SILENT");
togglePushNotificationRequest.IosProvisioningId = provisionId;
TogglePushNotificationRequest request = togglePushNotificationRequest;
IWebCall <TogglePushNotificationRequest, BaseResponse> webCall = mixWebCallFactory.PushNotificationsSettingPost(request);
webCall.OnResponse += delegate
{
try
{
database.UpdateSessionDocument(swid, delegate(SessionDocument sessionDoc)
{
sessionDoc.PushNotificationToken = token;
sessionDoc.PushNotificationTokenType = tokenType;
sessionDoc.VisiblePushNotificationsEnabled = enableVisible;
sessionDoc.ProvisionId = provisionId;
});
successCallback();
}
catch (Exception ex2)
{
logger.Critical("Unhandled exception: " + ex2);
failureCallback();
}
};
webCall.OnError += delegate
{
failureCallback();
};
webCall.Execute();
}
catch (Exception ex)
{
logger.Critical("Unhandled exception: " + ex);
failureCallback();
}
}
private IEnumerator Update()
{
while (!IsDisposed)
{
if (!sessionStatus.IsPaused)
{
try
{
notificationPoller.Update();
}
catch (Exception ex)
{
logger.Critical("Exception during Update(): " + ex);
}
}
yield return(null);
}
}
public static void DisableAllPushNotifications(AbstractLogger logger, IDatabase database, IMixWebCallFactory mixWebCallFactory, string swid, Action <IDisableAllPushNotificationsResult> callback)
{
try
{
SessionDocument sessionDocument = database.GetSessionDocument(swid);
if (sessionDocument.PushNotificationToken == null)
{
callback(new DisableAllPushNotificationsResult(success: false));
}
else
{
BaseUserRequest request = new BaseUserRequest();
IWebCall <BaseUserRequest, BaseResponse> webCall = mixWebCallFactory.PushNotificationsSettingDeletePost(request);
webCall.OnResponse += delegate
{
try
{
database.UpdateSessionDocument(swid, delegate(SessionDocument d)
{
d.PushNotificationToken = null;
d.PushNotificationTokenType = null;
d.VisiblePushNotificationsEnabled = false;
});
callback(new DisableAllPushNotificationsResult(success: true));
}
catch (Exception arg2)
{
logger.Critical("Unhandled exception: " + arg2);
callback(new DisableAllPushNotificationsResult(success: false));
}
};
webCall.OnError += delegate
{
callback(new DisableAllPushNotificationsResult(success: false));
};
webCall.Execute();
}
}
catch (Exception arg)
{
logger.Critical("Unhandled exception: " + arg);
callback(new DisableAllPushNotificationsResult(success: false));
}
}
public static void Search(AbstractLogger logger, IMixWebCallFactory mixWebCallFactory, string displayName, IUserDatabase userDatabase, Action <IInternalUnidentifiedUser> successCallback, Action failureCallback)
{
try
{
DisplayNameSearchRequest displayNameSearchRequest = new DisplayNameSearchRequest();
displayNameSearchRequest.DisplayName = displayName;
DisplayNameSearchRequest request = displayNameSearchRequest;
IWebCall <DisplayNameSearchRequest, DisplayNameSearchResponse> webCall = mixWebCallFactory.SearchDisplaynamePost(request);
webCall.OnResponse += delegate(object sender, WebCallEventArgs <DisplayNameSearchResponse> e)
{
DisplayNameSearchResponse response = e.Response;
if (ValidateResponse(response))
{
userDatabase.InsertUserDocument(new UserDocument
{
DisplayName = response.DisplayName,
FirstName = response.FirstName,
Swid = null,
HashedSwid = null
});
IInternalUnidentifiedUser obj = RemoteUserFactory.CreateUnidentifiedUser(response.DisplayName, response.FirstName, userDatabase);
successCallback(obj);
}
else
{
logger.Critical("Failed to validate display name search response: " + JsonParser.ToJson(response));
failureCallback();
}
};
webCall.OnError += delegate(object sender, WebCallErrorEventArgs e)
{
logger.Debug("Failed to find user: "******"Unhandled exception: " + arg);
failureCallback();
}
}
private static void HandleResult(WwwCallResult result, string log, byte[] bytes, Uri uri, StringBuilder timeoutLogs, int numAttempts, Action <LoadAssetResult> callback, Action <Uri, Action <LoadAssetResult>, StringBuilder, int> retry, AbstractLogger logger)
{
switch (result)
{
case WwwCallResult.Success:
logger.Debug(log);
callback(new LoadAssetResult(success: true, bytes));
break;
case WwwCallResult.TooManyTimeoutsError:
logger.Critical("Too many timeouts: " + uri.AbsoluteUri + "\nPrevious logs:\n" + timeoutLogs);
callback(new LoadAssetResult(success: false, null));
break;
case WwwCallResult.TooManyServerErrors:
logger.Critical("Too many server errors:\n" + log);
callback(new LoadAssetResult(success: false, null));
break;
case WwwCallResult.RetryTimeout:
logger.Error(log);
timeoutLogs.Append(log);
timeoutLogs.Append("\n\n");
retry(uri, callback, timeoutLogs, numAttempts + 1);
break;
case WwwCallResult.RetryServerError:
logger.Error(log);
retry(uri, callback, timeoutLogs, numAttempts + 1);
break;
case WwwCallResult.OfflineError:
logger.Error(log);
callback(new LoadAssetResult(success: false, null));
break;
case WwwCallResult.ClientError:
logger.Critical(log);
callback(new LoadAssetResult(success: false, null));
break;
}
}
public static void UpdateProfile(AbstractLogger logger, IGuestControllerClient guestControllerClient, IDatabase database, string swid, IEpochTime epochTime, IInternalRegistrationProfile profile, string firstName, string lastName, string displayName, string email, string parentEmail, DateTime?dateOfBirth, IEnumerable <KeyValuePair <IMarketingItem, bool> > marketingAgreements, IEnumerable <ILegalDocument> acceptedLegalDocuments, Action <IUpdateProfileResult> callback)
{
try
{
Dictionary <string, string> dictionary = new Dictionary <string, string>();
if (!string.IsNullOrEmpty(firstName))
{
dictionary.Add("firstName", firstName);
}
if (!string.IsNullOrEmpty(lastName))
{
dictionary.Add("lastName", lastName);
}
if (!string.IsNullOrEmpty(email))
{
dictionary.Add("email", email);
}
if (!string.IsNullOrEmpty(parentEmail))
{
dictionary.Add("parentEmail", parentEmail);
}
if (dateOfBirth.HasValue)
{
string value = dateOfBirth.Value.ToString("yyyy-MM-dd");
dictionary.Add("dateOfBirth", value);
}
List <Disney.Mix.SDK.Internal.GuestControllerDomain.MarketingItem> marketing = marketingAgreements?.Select((KeyValuePair <IMarketingItem, bool> pair) => new Disney.Mix.SDK.Internal.GuestControllerDomain.MarketingItem
{
code = pair.Key.Id,
subscribed = pair.Value
}).ToList();
List <string> legalAssertions = acceptedLegalDocuments?.Select((ILegalDocument doc) => doc.Id).ToList();
SessionDocument sessionDocument = database.GetSessionDocument(swid);
guestControllerClient.UpdateProfile(new UpdateProfileRequest
{
etag = sessionDocument.GuestControllerEtag,
profile = dictionary,
marketing = marketing,
displayName = new RegisterDisplayName
{
proposedDisplayName = displayName
},
legalAssertions = legalAssertions
}, delegate(GuestControllerResult <ProfileResponse> r)
{
HandleUpdateProfileResult(logger, database, swid, epochTime, r, profile, callback);
});
}
catch (Exception arg)
{
logger.Critical("Unhandled exception: " + arg);
callback(new UpdateProfileResult(success: false, null));
}
}
public static void ValidateDisplayName(AbstractLogger logger, IGuestControllerClient guestControllerClient, IMixWebCallFactory mixWebCallFactory, string displayName, Action <IValidateDisplayNameResult> callback)
{
try
{
ModerateTextRequest moderateTextRequest = new ModerateTextRequest();
moderateTextRequest.ModerationPolicy = "DisplayName";
moderateTextRequest.Text = displayName;
ModerateTextRequest request = moderateTextRequest;
IWebCall <ModerateTextRequest, ModerateTextResponse> webCall = mixWebCallFactory.ModerationTextPut(request);
webCall.OnResponse += delegate(object sender, WebCallEventArgs <ModerateTextResponse> e)
{
ModerateTextResponse response = e.Response;
if (ValidateModerateTextResponse(response))
{
if (response.Moderated.Value)
{
callback(new ValidateDisplayNameFailedModerationResult(success: false));
}
else
{
CheckForValidation(guestControllerClient, displayName, callback);
}
}
else
{
logger.Critical("Failed to validate moderate display name response!");
callback(new ValidateDisplayNameResult(success: false));
}
};
webCall.OnError += delegate
{
callback(new ValidateDisplayNameResult(success: false));
};
webCall.Execute();
}
catch (Exception ex)
{
logger.Critical("Unhandled exception: " + ex);
callback(new ValidateDisplayNameExistsResult(success: false));
}
}
private static void HandleGetUsersByIdSuccess(AbstractLogger logger, GetUsersResponse response, IList <Profile> profiles, Action <LinkedUser[]> callback)
{
try
{
if (response.Users == null)
{
logger.Critical("Returned users array is null");
callback(null);
return;
}
Dictionary <Profile, User> profileToUser = new Dictionary <Profile, User>();
foreach (Profile profile2 in profiles)
{
List <User> users = response.Users;
Func <User, bool> predicate = (User u) => profile2.swid == u.UserId;
User user = users.FirstOrDefault(predicate);
if (user == null)
{
logger.Critical("Returned users doesn't have " + profile2.swid + ": " + response.Users);
callback(null);
return;
}
profileToUser[profile2] = user;
}
LinkedUser[] obj = profiles.Select(delegate(Profile profile)
{
DateTime?dateOfBirth = GuestControllerUtils.ParseDateTime(logger, profile.dateOfBirth);
AgeBandType ageBand = AgeBandTypeConverter.Convert(profile.ageBand);
User user2 = profileToUser[profile];
DisplayName displayName = new DisplayName(user2.DisplayName);
return(new LinkedUser(profile.username, profile.firstName, profile.lastName, displayName, profile.email, profile.parentEmail, ageBand, dateOfBirth, profile.swid));
}).ToArray();
callback(obj);
}
catch (Exception ex)
{
logger.Critical("Unhandled exception: " + ex);
callback(null);
}
}
