public IInternalSession Create(string swid)
{
byte[] localStorageKey = keychain.LocalStorageKey;
IDocumentCollection <AlertDocument> documentCollection = GetDocumentCollection <AlertDocument>(swid, "Alerts", databaseDirectoryCreator, localStorageKey, documentCollectionFactory);
IDocumentCollection <FriendDocument> documentCollection2 = GetDocumentCollection <FriendDocument>(swid, "Friends", databaseDirectoryCreator, localStorageKey, documentCollectionFactory);
IDocumentCollection <FriendInvitationDocument> documentCollection3 = GetDocumentCollection <FriendInvitationDocument>(swid, "FriendInvitations", databaseDirectoryCreator, localStorageKey, documentCollectionFactory);
IDocumentCollection <UserDocument> documentCollection4 = GetDocumentCollection <UserDocument>(swid, "Users", databaseDirectoryCreator, localStorageKey, documentCollectionFactory);
databaseCorruptionHandler.Add(documentCollection4);
string dirPath = BuildDocCollectionPath(databaseDirectoryCreator, swid);
UserDatabase userDatabase = new UserDatabase(documentCollection, documentCollection2, documentCollection3, documentCollection4, localStorageKey, dirPath, epochTime, documentCollectionFactory, databaseCorruptionHandler, coroutineManager);
database.ClearServerTimeOffsetMillis();
epochTime.OffsetMilliseconds = database.GetServerTimeOffsetMillis() ?? 0;
logger.Debug("Initial time offset: " + epochTime.Offset);
SessionDocument sessionDocument = database.GetSessionDocument(swid);
keychain.PushNotificationKey = sessionDocument.CurrentSymmetricEncryptionKey;
IWebCallEncryptor webCallEncryptor = webCallEncryptorFactory.Create(sessionDocument.CurrentSymmetricEncryptionKey, sessionDocument.SessionId);
IGuestControllerClient guestControllerClient = guestControllerClientFactory.Create(swid);
ISessionRefresher sessionRefresher = sessionRefresherFactory.Create(mixSessionStarter, guestControllerClient);
IMixWebCallFactory mixWebCallFactory = mixWebCallFactoryFactory.Create(webCallEncryptor, swid, sessionDocument.GuestControllerAccessToken, sessionRefresher);
guestControllerClient.OnAccessTokenChanged += delegate(object sender, AbstractGuestControllerAccessTokenChangedEventArgs e)
{
mixWebCallFactory.GuestControllerAccessToken = e.GuestControllerAccessToken;
};
AssetLoader assetLoader = new AssetLoader(logger, wwwCallFactory);
IList <IInternalFriend> friends = CreateFriends(userDatabase);
AgeBandType ageBandType = AgeBandTypeConverter.Convert(sessionDocument.AgeBand);
DateTime lastRefreshTime = epochTime.FromSeconds(sessionDocument.LastProfileRefreshTime);
RegistrationProfile registrationProfile = new RegistrationProfile(logger, sessionDocument.DisplayNameText, sessionDocument.ProposedDisplayName, sessionDocument.ProposedDisplayNameStatus, sessionDocument.FirstName, sessionDocument.AccountStatus, lastRefreshTime, sessionDocument.CountryCode);
GetStateResponseParser getStateResponseParser = new GetStateResponseParser(logger);
NotificationPoller notificationPoller = new NotificationPoller(logger, mixWebCallFactory, notificationQueue, pollCountdownStopwatch, getStateResponseParser, epochTime, random, database, swid);
DisplayName displayName = new DisplayName(sessionDocument.DisplayNameText);
LocalUser localUser = new LocalUser(logger, displayName, swid, friends, ageBandType, database, userDatabase, registrationProfile, mixWebCallFactory, guestControllerClient, notificationQueue, encryptor, epochTime);
Session session = new Session(logger, localUser, sessionDocument.GuestControllerAccessToken, sessionDocument.PushNotificationToken != null, notificationPoller, coroutineManager, database, userDatabase, guestControllerClient, mixWebCallFactory, epochTime, databaseCorruptionHandler, sessionStatus, keychain, getStateResponseParser, clientVersion, notificationQueue);
try
{
NotificationHandler.Handle(notificationDispatcher, userDatabase, localUser, epochTime);
notificationQueue.LatestSequenceNumber = sessionDocument.LatestNotificationSequenceNumber;
IEnumerable <IncomingFriendInvitation> incomingFriendInvitations = GetIncomingFriendInvitations(userDatabase, localUser);
foreach (IncomingFriendInvitation item in incomingFriendInvitations)
{
localUser.AddIncomingFriendInvitation(item);
}
IEnumerable <OutgoingFriendInvitation> outgoingFriendInvitations = GetOutgoingFriendInvitations(userDatabase, localUser);
foreach (OutgoingFriendInvitation item2 in outgoingFriendInvitations)
{
localUser.AddOutgoingFriendInvitation(item2);
}
}
catch (Exception)
{
session.Dispose();
throw;
}
return(session);
}
public LocalUser(AbstractLogger logger, IDisplayName displayName, string swid, IList <IInternalFriend> friends, AgeBandType ageBandType, IDatabase database, IUserDatabase userDatabase, IInternalRegistrationProfile registrationProfile, IMixWebCallFactory mixWebCallFactory, IGuestControllerClient guestControllerClient, INotificationQueue notificationQueue, IEncryptor encryptor, IEpochTime epochTime)
{
DisplayName = displayName;
FirstName = registrationProfile.FirstName;
Swid = swid;
Id = swid;
this.logger = logger;
this.registrationProfile = registrationProfile;
this.mixWebCallFactory = mixWebCallFactory;
this.friends = friends;
this.ageBandType = ageBandType;
this.database = database;
this.userDatabase = userDatabase;
incomingFriendInvitations = new List <IInternalIncomingFriendInvitation>();
outgoingFriendInvitations = new List <IInternalOutgoingFriendInvitation>();
oldInvitationIds = new List <long>();
unidentifiedUsers = new List <IInternalUnidentifiedUser>();
this.guestControllerClient = guestControllerClient;
this.notificationQueue = notificationQueue;
this.encryptor = encryptor;
this.epochTime = epochTime;
guestControllerClient.OnLegalMarketingUpdateRequired += delegate(object sender, AbstractLegalMarketingUpdateRequiredEventArgs e)
{
this.OnLegalMarketingUpdateRequired(this, e);
};
}
public Session(AbstractLogger logger, IInternalLocalUser localUser, string guestControllerAccessToken, bool pushNotificationsEnabled, INotificationPoller notificationPoller, ICoroutineManager coroutineManager, IDatabase database, IUserDatabase userDatabase, IGuestControllerClient guestControllerClient, IMixWebCallFactory mixWebCallFactory, IEpochTime epochTime, DatabaseCorruptionHandler databaseCorruptionHandler, ISessionStatus sessionStatus, IKeychain keychain, IGetStateResponseParser getStateResponseParser, string clientVersion, INotificationQueue notificationQueue)
{
this.logger = logger;
this.localUser = localUser;
this.notificationPoller = notificationPoller;
this.coroutineManager = coroutineManager;
this.database = database;
this.userDatabase = userDatabase;
this.guestControllerClient = guestControllerClient;
this.mixWebCallFactory = mixWebCallFactory;
this.epochTime = epochTime;
this.databaseCorruptionHandler = databaseCorruptionHandler;
this.sessionStatus = sessionStatus;
this.keychain = keychain;
this.getStateResponseParser = getStateResponseParser;
this.clientVersion = clientVersion;
this.notificationQueue = notificationQueue;
GuestControllerAccessToken = guestControllerAccessToken;
guestControllerClient.OnAccessTokenChanged += HandleGuestControllerAccessTokenChanged;
guestControllerClient.OnAuthenticationLost += HandleAuthenticationLost;
mixWebCallFactory.OnAuthenticationLost += HandleAuthenticationLost;
localUser.OnPushNotificationsToggled += HandlePushNotificationsToggled;
localUser.OnPushNotificationReceived += HandlePushNotificationReceived;
localUser.OnDisplayNameUpdated += HandleDisplayNameUpdated;
databaseCorruptionHandler.OnCorruptionDetected += HandleCorruptionDetected;
updateEnumerator = Update();
coroutineManager.Start(updateEnumerator);
notificationPoller.OnNotificationsPolled += HandleNotificationsPolled;
notificationPoller.UsePollIntervals = !pushNotificationsEnabled;
this.sessionStatus.IsPaused = true;
notificationPoller.OnSynchronizationError += HandleNotificationPollerSynchronizationError;
}
private static void CheckForValidation(IGuestControllerClient guestControllerClient, string displayName, Action <IValidateDisplayNameResult> callback)
{
ValidateRequest validateRequest = new ValidateRequest();
validateRequest.displayName = displayName;
ValidateRequest request = validateRequest;
guestControllerClient.Validate(request, delegate(GuestControllerResult <ValidateResponse> r)
{
if (!r.Success)
{
callback(new ValidateDisplayNameResult(success: false));
}
else
{
ValidateResponse response = r.Response;
if (response.error == null)
{
callback(new ValidateDisplayNameResult(success: true));
}
else
{
callback(new ValidateDisplayNameExistsResult(success: false));
}
}
});
}
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 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 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 void ValidateChildAccount(AbstractLogger logger, IGuestControllerClient guestControllerClient, string username, string password, Action <IValidateNewAccountResult> callback)
{
Send(logger, guestControllerClient, new ValidateRequest
{
username = username,
password = password
}, callback);
}
public static void ValidateAdultAccount(AbstractLogger logger, IGuestControllerClient guestControllerClient, string email, string password, Action <IValidateNewAccountResult> callback)
{
Send(logger, guestControllerClient, new ValidateRequest
{
email = email,
password = password
}, callback);
}
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 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 AnswerQuiz(AbstractLogger logger, IGuestControllerClient guestControllerClient, IVerifyAdultQuizAnswers answers, Action <IVerifyAdultResult> callback)
{
if (string.IsNullOrEmpty(answers.Id) || answers.Answers == null || answers.Answers.Count == 0)
{
callback(new VerifyAdultFailedMissingInfoResult());
}
else if (!ValidateAnswers(answers))
{
callback(new VerifyAdultFailedInvalidDataResult());
}
else
{
try
{
AdultVerificationQuizRequest adultVerificationQuizRequest = new AdultVerificationQuizRequest();
adultVerificationQuizRequest.applicationId = answers.Id;
adultVerificationQuizRequest.answers = (from keyValue in answers.Answers
select new AdultVerificationQuizAnswer
{
choice = keyValue.Value,
questionId = keyValue.Key.QuestionId
}).ToList();
AdultVerificationQuizRequest request = adultVerificationQuizRequest;
guestControllerClient.SendAdultVerificationQuiz(request, delegate(GuestControllerResult <AdultVerificationQuizResponse> r)
{
if (!r.Success)
{
callback(MakeGenericFailure());
}
else if (r.Response.error != null)
{
callback(ParseError(r.Response));
}
else if (r.Response.data == null)
{
callback(MakeGenericFailure());
}
else
{
callback(new VerifyAdultResult(r.Response.data.verified, r.Response.data.maxAttempts));
}
});
}
catch (Exception arg)
{
logger.Critical("Unhandled exception: " + arg);
callback(MakeGenericFailure());
}
}
}
public static void ApprovePermission(AbstractLogger logger, IGuestControllerClient guestControllerClient, string activityCode, string childSwid, ActivityApprovalStatus desiredStatus, Action <IPermissionResult> callback)
{
if (string.IsNullOrEmpty(childSwid) || string.IsNullOrEmpty(activityCode) || desiredStatus == ActivityApprovalStatus.Pending || desiredStatus == ActivityApprovalStatus.Unknown)
{
callback(new PermissionFailedInvalidResult());
return;
}
try
{
ApprovePermissionRequest approvePermissionRequest = new ApprovePermissionRequest();
approvePermissionRequest.activityCode = activityCode;
approvePermissionRequest.approvalStatus = ActivityApprovalStatusConverter.Convert(desiredStatus);
approvePermissionRequest.swid = childSwid;
ApprovePermissionRequest request = approvePermissionRequest;
guestControllerClient.ApprovePermission(request, childSwid, delegate(GuestControllerResult <PermissionResponse> r)
{
if (!r.Success)
{
callback(MakeGenericFailure());
}
else
{
PermissionResponse response = r.Response;
if (response.error != null || response.data == null)
{
callback(ParseError(response));
}
else
{
string activityCode2 = response.data.activityCode;
ActivityApprovalStatus activityApprovalStatus = ActivityApprovalStatusConverter.Convert(response.data.approvalStatus);
if (activityCode2 != activityCode || activityApprovalStatus != desiredStatus)
{
callback(new PermissionFailedInvalidResult());
}
else
{
callback(new PermissionResult(success: true, activityApprovalStatus));
}
}
}
});
}
catch (Exception ex)
{
logger.Critical("Unhandled exception: " + ex);
callback(MakeGenericFailure());
}
}
public static void GetChildren(AbstractLogger logger, IGuestControllerClient guestControllerClient, IMixWebCallFactory mixWebCallFactory, Action <IGetLinkedUsersResult> callback)
{
try
{
guestControllerClient.GetClaimableChildren(delegate(GuestControllerResult <ChildrenResponse> r)
{
HandleGetClaimableChildrenResult(logger, mixWebCallFactory, callback, r);
});
}
catch (Exception arg)
{
logger.Critical("Unhandled exception: " + arg);
callback(MakeGenericFailure());
}
}
public static void GetProfile(AbstractLogger logger, IGuestControllerClient guestControllerClient, Action <ProfileData> callback)
{
try
{
guestControllerClient.GetProfile(delegate(GuestControllerResult <ProfileResponse> r)
{
callback(r.Success ? r.Response.data : null);
});
}
catch (Exception ex)
{
logger.Critical("Unhandled exception: " + ex);
callback(null);
}
}
public void Get(string countryCode, Action <IInternalGetRegistrationConfigurationResult> callback)
{
try
{
IGuestControllerClient guestControllerClient = guestControllerClientFactory.Create("NoSWID");
guestControllerClient.GetSiteConfiguration(countryCode, delegate(GuestControllerResult <SiteConfigurationResponse> r)
{
HandleResult(r, callback);
});
}
catch (Exception arg)
{
logger.Critical("Unhandled exception: " + arg);
callback(new GetRegistrationConfigurationResult(success: false, null));
}
}
public NewAccountValidator(IKeychain keychain, AbstractLogger logger, string localStorageDirPath, string guestControllerHostUrl, string guestControllerSpoofedIpAddress, string oneIdClientId, ICoroutineManager coroutineManager)
{
this.logger = logger;
SystemStopwatchFactory stopwatchFactory = new SystemStopwatchFactory();
SystemWwwFactory wwwFactory = new SystemWwwFactory();
WwwCallFactory wwwCallFactory = new WwwCallFactory(logger, coroutineManager, stopwatchFactory, wwwFactory);
FileSystem fileSystem = new FileSystem();
DatabaseDirectoryCreator directoryCreator = new DatabaseDirectoryCreator(fileSystem, localStorageDirPath);
DocumentCollectionFactory documentCollectionFactory = new DocumentCollectionFactory();
SystemRandom random = new SystemRandom();
DatabaseCorruptionHandler databaseCorruptionHandler = new DatabaseCorruptionHandler(logger, fileSystem, localStorageDirPath);
SystemEpochTime epochTime = new SystemEpochTime();
Database database = new Database(keychain.LocalStorageKey, random, epochTime, directoryCreator, documentCollectionFactory, databaseCorruptionHandler);
guestControllerClient = new GuestControllerClient(wwwCallFactory, guestControllerSpoofedIpAddress, database, string.Empty, guestControllerHostUrl, oneIdClientId, logger);
}
public static void RequestPermission(AbstractLogger logger, IGuestControllerClient guestControllerClient, string activityCode, Action <IPermissionResult> callback)
{
try
{
guestControllerClient.RequestPermission(new RequestPermissionRequest
{
activityCode = activityCode
}, delegate(GuestControllerResult <PermissionResponse> r)
{
HandleResult(activityCode, callback, r);
});
}
catch (Exception ex)
{
logger.Critical("Unhandled exception: " + ex);
callback(MakeGenericFailure());
}
}
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));
}
}
public static void VerifyAdult(AbstractLogger logger, IGuestControllerClient guestControllerClient, IVerifyAdultFormUnitedStates form, Action <IVerifyAdultResult> callback)
{
try
{
AdultVerificationRequest adultVerificationRequest = new AdultVerificationRequest();
adultVerificationRequest.address = new AdultVerificationAddress
{
addressLine1 = form.AddressLine1,
postalCode = form.PostalCode
};
adultVerificationRequest.dateOfBirth = form.DateOfBirth.ToString("yyyy-MM-dd");
adultVerificationRequest.firstName = form.FirstName;
adultVerificationRequest.lastName = form.LastName;
adultVerificationRequest.ssn = form.Ssn;
AdultVerificationRequest request = adultVerificationRequest;
guestControllerClient.VerifyAdultUnitedStates(request, delegate(GuestControllerResult <AdultVerificationResponse> r)
{
if (!r.Success)
{
callback(MakeGenericFailure());
}
else if (r.Response.error != null)
{
callback(ParseError(r.Response));
}
else if (r.Response.data == null)
{
callback(MakeGenericFailure());
}
else
{
callback(new VerifyAdultResult(r.Response.data.verified, r.Response.data.maxAttempts));
}
});
}
catch (Exception ex)
{
logger.Critical("Unhandled exception: " + ex);
callback(MakeGenericFailure());
}
}
public static void GetAdultVerificationStatus(AbstractLogger logger, IGuestControllerClient guestControllerClient, Action <IGetAdultVerificationStatusResult> callback)
{
try
{
guestControllerClient.GetAdultVerificationStatus(delegate(GuestControllerResult <AdultVerificationStatusResponse> r)
{
if (!r.Success || r.Response.error != null || r.Response.data == null)
{
callback(new GetAdultVerificationStatusResult(success: false, verifiedAsAdult: false, maxAttempts: false));
}
else
{
callback(new GetAdultVerificationStatusResult(success: true, r.Response.data.verified, r.Response.data.maxAttempts));
}
});
}
catch (Exception ex)
{
logger.Critical("Unhandled exception: " + ex);
callback(new GetAdultVerificationStatusResult(success: false, verifiedAsAdult: false, maxAttempts: false));
}
}
private static void Send(AbstractLogger logger, IGuestControllerClient guestControllerClient, ValidateRequest request, Action <IValidateNewAccountResult> callback)
{
try
{
guestControllerClient.Validate(request, delegate(GuestControllerResult <ValidateResponse> r)
{
if (!r.Success)
{
callback(new ValidateNewAccountResult(success: false, null));
}
else
{
ValidateResponse response = r.Response;
if (response.error == null)
{
callback(new ValidateNewAccountResult(success: true, null));
}
else
{
IValidateNewAccountResult validateResult = GuestControllerErrorParser.GetValidateResult(response.error);
if (validateResult != null)
{
callback(validateResult);
}
else
{
IEnumerable <IValidateNewAccountError> validationErrors = GuestControllerErrorParser.GetValidationErrors(response.error);
callback(new ValidateNewAccountResult(success: false, validationErrors));
}
}
}
});
}
catch (Exception arg)
{
logger.Critical("Unhandled exception: " + arg);
callback(new ValidateNewAccountResult(success: false, null));
}
}
public void RestoreLastSession(Action <IRestoreLastSessionResult> callback)
{
try
{
database.ClearServerTimeOffsetMillis();
SessionDocument lastSessionDoc = database.GetLastLoggedInSessionDocument();
if (lastSessionDoc == null)
{
callback(new RestoreLastSessionNotFoundResult());
}
else
{
IGuestControllerClient guestControllerClient = guestControllerClientFactory.Create(lastSessionDoc.Swid);
guestControllerClient.Refresh(delegate(GuestControllerResult <RefreshResponse> r)
{
if (r.Response == null)
{
logger.Error("Error refreshing auth token");
callback(new RestoreLastSessionResult(success: false, null));
}
else
{
HandleRefreshSuccess(callback, r, lastSessionDoc);
}
});
}
}
catch (CorruptionException arg)
{
logger.Fatal("Corruption detected during session restoration: " + arg);
callback(new RestoreLastSessionCorruptionDetectedResult());
}
catch (Exception arg2)
{
logger.Critical("Unhandled exception: " + arg2);
callback(new RestoreLastSessionResult(success: false, null));
}
}
public UsernameRecoverySender(AbstractLogger logger, IGuestControllerClient guestControllerClient)
{
this.logger = logger;
this.guestControllerClient = guestControllerClient;
}
private void HandleLoginSuccess(GuestControllerResult <LogInResponse> result, Action <ILoginResult> callback)
{
try
{
LogInResponse response = result.Response;
LogInData data = response.data;
GuestApiErrorCollection gcErrorCollection = response.error;
ILoginResult loginResult = GuestControllerErrorParser.GetLoginResult(gcErrorCollection);
bool flag = false;
string hallPassToken = string.Empty;
string swid = string.Empty;
if (data != null || loginResult == null)
{
goto IL_015d;
}
if (loginResult is ILoginFailedParentalConsentResult)
{
foreach (GuestApiError error in gcErrorCollection.errors)
{
TemporaryToken data2 = error.data;
if (data2 != null)
{
flag = true;
hallPassToken = data2.accessToken;
swid = data2.swid;
break;
}
}
if (flag)
{
goto IL_015d;
}
callback(loginResult);
}
else
{
callback(loginResult);
}
goto end_IL_0018;
IL_015d:
if (data == null && !flag)
{
if (gcErrorCollection != null)
{
logger.Critical("Received unhandled error exception: " + JsonParser.ToJson(gcErrorCollection));
}
callback(new LoginResult(success: false, null));
}
else if (flag)
{
database.StoreSession(swid, hallPassToken, null, null, null, null, null, null, null, null, updateLastProfileRefreshTime: false, null);
IGuestControllerClient guestControllerClient = guestControllerClientFactory.Create(swid);
ProfileGetter.GetProfile(logger, guestControllerClient, delegate(ProfileData profileData)
{
if (profileData == null)
{
database.DeleteSession(swid);
callback(new LoginFailedParentalConsentResult());
}
else
{
StoreSession(swid, hallPassToken, null, profileData.etag, profileData.displayName, profileData.profile);
HandleRefreshProfileSuccess(callback, loginResult, gcErrorCollection, profileData.profile, profileData.displayName, profileData.marketing, swid, hallPassToken);
}
});
}
else if (!ValidateLogInData(data))
{
logger.Critical("Error parsing the login data:" + JsonParser.ToJson(data));
callback(new LoginResult(success: false, null));
}
else
{
Token token = data.token;
StoreSession(token.swid, token.access_token, token.refresh_token, data.etag, data.displayName, data.profile);
HandleRefreshProfileSuccess(callback, loginResult, gcErrorCollection, data.profile, data.displayName, data.marketing, token.swid, token.access_token);
}
end_IL_0018 :;
}
catch (CorruptionException arg)
{
logger.Fatal("Corruption detected during login: "******"Unhandled exception: " + arg2);
callback(new LoginResult(success: false, null));
}
}
public ISessionRefresher Create(IMixSessionStarter mixSessionStarter, IGuestControllerClient guestControllerClient)
{
this.guestControllerClient = guestControllerClient;
return(new SessionRefresher(webCallQueue, guestControllerClient, mixSessionStarter));
}
public static void SendVerificationEmail(AbstractLogger logger, string languageCode, IGuestControllerClient guestControllerClient, Action <ISendVerificationEmailResult> callback)
{
try
{
guestControllerClient.SendVerificationEmail(languageCode, delegate(GuestControllerResult <NotificationResponse> r)
{
callback(new SendVerificationEmailResult(r.Success && r.Response.error == null && r.Response.data != null));
});
}
catch (Exception arg)
{
logger.Critical("Unhandled exception: " + arg);
callback(new SendVerificationEmailResult(success: false));
}
}
public SessionRefresher(IMixWebCallQueue webCallQueue, IGuestControllerClient guestControllerClient, IMixSessionStarter mixSessionStarter)
{
this.webCallQueue = webCallQueue;
this.guestControllerClient = guestControllerClient;
this.mixSessionStarter = mixSessionStarter;
}
public NrtUpgradeSender(AbstractLogger logger, IGuestControllerClient guestControllerClient)
{
this.logger = logger;
this.guestControllerClient = guestControllerClient;
}
