public async Task<UserInformation> Authorize( CatalitCredentials credentials, CancellationToken cancellationToken )
{
if( credentials != null )
{
var encodedPass = WebUtility.UrlEncode(credentials.Password);
var parameters = new Dictionary<string, object>
{
{"login", credentials.Login},
{"pwd", credentials.Password}
};
if(!string.IsNullOrEmpty(credentials.Sid)) parameters.Add("sid", credentials.Sid);
var result = await _client.Authorize( parameters, cancellationToken );
if( result != null )
{
UserInformation = result;
//Activate Coupone if nokia
if( _deviceInfoService.IsNokiaDevice )
{
try
{
await ActivateNokiaCoupone(result.SessionId, CancellationToken.None);
}
catch( CatalitActivateCouponeException )
{
}
}
return result;
}
}
throw new CatalitNoCredentialException();
}
private async Task ChangePasswordProceed( Session session )
{
UserInformation uinfo = session.Parameters.GetValue<UserInformation>( ChangePasswordParameter );
await _profileProvider.ChangeUserInfo( uinfo, session.Token );
var creds = _credentialsProvider.ProvideCredentials( session.Token );
creds.Password = uinfo.NewPassword;
_credentialsProvider.RegisterCredentials( creds, session.Token );
Credentials = creds;
}
public async Task<UserInformation> Register(CatalitCredentials credentials, CancellationToken cancellationToken, CatalitCredentials oldCredentials = null, bool additionalParams = true)
{
if( credentials != null )
{
var parameters = new Dictionary<string, object>
{
{"new_login", credentials.Login},
{"new_pwd1", credentials.Password},
{"phone", credentials.Phone}
};
if( credentials.IsRealAccount )
{
parameters.Add( "mail", credentials.Login );
}
//result contains only sid
var result = await _client.Register( parameters, cancellationToken, additionalParams );
if( result != null )
{
UserInformation = result;
//Activate Coupone if nokia
if (_deviceInfoService.IsNokiaDevice)
{
try
{
await ActivateNokiaCoupone(result.SessionId, CancellationToken.None);
}
catch (CatalitActivateCouponeException)
{
}
}
//if (oldCredentials != null)
//{
// if (!oldCredentials.IsRealAccount)
// {
// try
// {
// await ActivateRegistrationCoupone(result.SessionId, CancellationToken.None);
// }
// catch (CatalitActivateCouponeException)
// {
// }
// }
//}
return result;
}
}
throw new CatalitNoCredentialException();
}
public async Task<CatalitCredentials> MigrateFromWp8ToWp10()
{
var storage = IsolatedStorageFile.GetUserStoreForApplication();
if (storage.FileExists("__ApplicationSettings"))
{
try
{
CatalitCredentials returnCred = new CatalitCredentials();
using (var fileStream = await ApplicationData.Current.LocalFolder.OpenStreamForReadAsync("__ApplicationSettings"))
{
using (var streamReader = new StreamReader(fileStream))
{
var line = streamReader.ReadLine() ?? string.Empty;
fileStream.Position = line.Length + Environment.NewLine.Length;
var serializer = new DataContractSerializer(typeof (Dictionary<string, object>));
var xmls = (Dictionary<string, object>) serializer.ReadObject(fileStream);
foreach (var credentials in from xml in xmls
where string.Equals(xml.Key, "credentials")
let xmlSerializer = new XmlSerializer(typeof (CatalitCredentials))
select (CatalitCredentials)xmlSerializer.Deserialize(new MemoryStream(Encoding.UTF8.GetBytes((string) xml.Value))))
{
RegisterCredentials(credentials, CancellationToken.None);
returnCred = credentials;
}
}
}
storage = IsolatedStorageFile.GetUserStoreForApplication();
storage.DeleteFile("__ApplicationSettings");
DeleteDirectoryRecursively(storage, "MyBooks");
return returnCred;
}
catch
{
// ignored
}
}
return null;
}
public void RegisterCredentials(CatalitCredentials credentials, CancellationToken cancellationToken)
{
_dataCacheService.PutItem( credentials, CacheItemName, cancellationToken );
}
public void ForgetCredentialsRebill(CatalitCredentials credentials, CancellationToken cancellationToken)
{
credentials.CanRebill = "0";
credentials.CreditCardLastNumbers = string.Empty;
credentials.UserId = string.Empty;
_dataCacheService.PutItem(credentials, CacheItemName, cancellationToken);
}
public Task<bool> ShouldRetryAuthentication(CatalitCredentials credentials, CancellationToken cancellationToken)
{
return Task.FromResult(false);
}
public async Task<UserInformation> MergeAccounts( string userAccountSid, CatalitCredentials mergedAccount, CancellationToken cancellationToken )
{
if( mergedAccount != null )
{
var parameters = new Dictionary<string, object>
{
{"sid", userAccountSid},
{"user_login", mergedAccount.Login},
{"user_passwd", mergedAccount.Password},
};
var userInfo = await _client.MergeAccounts( parameters, cancellationToken );
UserInformation = userInfo;
return userInfo;
}
throw new CatalitNoCredentialException();
}
public async Task<CatalitCredentials> RegisterDefault( CancellationToken cancellationToken )
{
string login = "******" + _deviceInfoService.DeviceId;//.Substring( 0, 16 );
var creds = new CatalitCredentials {
IsRealAccount = false,
Password = "******",
Login = login
};
bool relogin = false;
try
{
var userInfo = await Register(creds, cancellationToken, additionalParams: false);
creds.Sid = userInfo.SessionId;
}
catch (CatalitRegistrationException e)
{
//already exists
if (e.ErrorCode == 1 || e.ErrorCode == 100)
{
relogin = true;
}
else
{
throw;
}
}
catch (Exception ex)
{
ex = ex;
throw;
}
if( relogin )
{
try
{
var userInfo = await Authorize(creds, cancellationToken);
creds.Sid = userInfo.SessionId;
}
catch (Exception ex)
{
var stackTace = ex.StackTrace;
}
}
UserInformation = null;
return creds;
}
private async Task LoadCredentialsProceed( Session session )
{
var credentials = _credentialsProvider.ProvideCredentials( session.Token );
Credentials = credentials;
}
public async Task Register(CatalitCredentials credentials)
{
Session session = new Session( RegistrationPart );
session.AddParameter(RegistrationParameter, credentials);
await Load(session);
}
public async Task Login(CatalitCredentials credentials)
{
Session session = new Session( LoginPart );
session.AddParameter( LoginParameter, credentials );
await Load( session );
}
