public async Task BuyBookFromLitres(Book book, CancellationToken cancellationToken)
{
//If acoount not exits - create
CatalitCredentials creds = _credentialsProvider.ProvideCredentials(cancellationToken);
if (creds == null)
{
creds = await _profileProvider.RegisterDefault(cancellationToken);
_credentialsProvider.RegisterCredentials(creds, cancellationToken);
}
bool isNokiaBook = false;
if (_deviceInfoService.IsNokiaDevice && !string.IsNullOrEmpty(book.InGifts) && book.InGifts.Equals("1"))
{
var nokiaBook =
await
_catalogProvider.GetBookByCollection(
(int) BooksByCategoryViewModel.BooksViewModelTypeEnum.NokiaCollection, book.Id,
cancellationToken);
if (nokiaBook != null) isNokiaBook = true;
}
if (isNokiaBook)
{
await _catalogProvider.TakeBookFromCollectionBySubscription(book.Id, cancellationToken);
UpdateBook(book);
}
else
{
var parameters = new Dictionary<string, object>
{
{"art", book.Id},
{"lfrom", _deviceInfoService.LitresInnerRefId},
{"pin", _deviceInfoService.DeviceModel}
};
LitresPurchaseResponse purchase = null;
try
{
purchase = await _client.LitresPurchaseBook(parameters, cancellationToken, book.isHiddenBook);
}
catch (CatalitPurchaseException e)
{
if (((CatalitPurchaseException) e).ErrorCode == 3)
{
_inAppPurchaseService.CheckProductIsUsed(book.InappName);
}
purchase = new LitresPurchaseResponse {Account = "-1", Art = "-1"};
}
if (purchase.Account == "-1" && purchase.Art == "-1") UpdateBookFailed(book);
else
{
if (book.InappName != null)
_inAppPurchaseService.CheckProductIsUsed(book.InappName);
UpdateBook(book);
}
}
}
public async Task GetFullBook(Book book, CancellationToken token)
{
await GetDocument(async cancellationToken =>
{
var parameters = new Dictionary<string, object>
{
{ "art", book.Id },
{ "type", "fb2.zip" }
};
if (book.IsUnpackedDrm)//book.Id == 6883340)
{
var timeResp = await _awareConnection.ProcessRequest<ServerTimeResponse>("catalit_browser", false, true, token, new Dictionary<string, object> { { "art", 0 } });
var umd5 = MD5.GetMd5String(string.Format("{0}:{1}:{2}", timeResp.UnixTime, book.Description.Hidden.DocumentInfo.Id, "6193449b38c80b4f50bc3bdab32c61a8c95068bb"));
parameters = new Dictionary<string, object>
{
{"uuid", book.Description.Hidden.DocumentInfo.Id},
{"libapp", 6},
{"timestamp", timeResp.UnixTime},
{"umd5", umd5}
};
}
else if ((!book.IsExpiredBook && !string.IsNullOrEmpty(book.ExpiredDateStr)))
{
var timeResp = await _awareConnection.ProcessRequest<ServerTimeResponse>("catalit_browser", false, true, token, new Dictionary<string, object> { { "art", 0 } });
var umd5 = MD5.GetMd5String(string.Format("{0}:{1}:{2}", timeResp.UnixTime, book.Description.Hidden.DocumentInfo.Id, (1078 % (2 * 5)).ToString() + DKey1 + DKey2 + DKey3 + DKey4 + (68103 / 987).ToString()));
parameters = new Dictionary<string, object>
{
{"uuid", book.Description.Hidden.DocumentInfo.Id},
{"libapp", _deviceInfoService.LibAppId},
{"timestamp", timeResp.UnixTime},
{"umd5", umd5}
};
}
if (book.IsFreeBook) Analytics.Instance.sendMessage(Analytics.ActionGetFree);
return await _awareConnection.ProcessRequest<RawFile>("catalit_download_book", true, true, token, parameters);
},
token,
book);
var exists = await GetExistBooks(CancellationToken.None);
if (exists.All(x => x.Id != book.Id))
{
exists.Insert(0, book);
_dataCacheService.PutItem(exists, StorageSettingName, CancellationToken.None);
}
}
public async Task GetTrialBook(Book book, CancellationToken token)
{
var exists = await GetExistBooks(CancellationToken.None);
var exist = exists.FirstOrDefault(x => x.Id == book.Id);
if (exist != null)
{
await GetFullBook(exist, token);
}
var bookname = book.Id.ToString(CultureInfo.InvariantCulture) + ".trial";
string id = string.Format("{0:00000000}", book.Id);
string url = string.Format("trials/{0}/{1}/{2}/{3}.fb2.zip", id.Substring(0, 2), id.Substring(2, 2), id.Substring(4, 2), id);
await GetDocument(
cancellationToken => _awareConnection.ProcessStaticSecureRequest<RawFile>(url, cancellationToken),
token,
book
);
}
private async Task<ProductListing> FindProductForBook( Book book )
{
if( string.IsNullOrWhiteSpace( book.InappName ) )
{
throw new CatalitPurchaseException( "Книга не содержит описания продукта", 100 );
}
if( _listings == null )
{
await GetInformationFromStore();
}
var res = _listings.ProductListings.Count;
Debug.WriteLine(res);
if (_listings != null && _listings.ProductListings.Any( x => x.Key == book.InappName ) )
{
return _listings.ProductListings[book.InappName];
}
throw new CatalitPurchaseException( "Продукт не найден", 100 );
}
private void OnBannerTap(object sender, TappedRoutedEventArgs e)
{
var banner = (Banner) ((Image) sender).Tag;
switch (banner.Type)
{
case "author":
_frame.Navigate(typeof(Person), XParameters.Create("Id", banner.ContentId));
break;
case "book":
var book = new Book { Id = int.Parse(banner.ContentId) };
_frame.Navigate(typeof(LitRes.Views.Book), XParameters.Create("BookEntity", book));
break;
case "collection":
_frame.Navigate(typeof(LitRes.Views.BooksByCategory),
XParameters.Create("category", int.Parse(banner.ContentId)));
break;
case "application":
var url = banner.ContentId;
Launch(url);
break;
}
Analytics.Instance.sendMessage(Analytics.ActionGotoBaner);
}
private async Task BuyBookFromLitres(Session session, Book book)
{
UserInformation userInfo = null;
try
{
userInfo = await _profileProvider.GetUserInfo(session.Token, true);
}
catch (Exception ex)
{
await new MessageDialog("Авторизируйтесь, пожалуйста.").ShowAsync();
}
if (userInfo == null) return;
if (!string.IsNullOrEmpty(book.InGifts) && book.InGifts.Equals("1"))
{
await _litresPurchaseService.BuyBookFromLitres(book, session.Token);
}
else if (userInfo.Account - book.Price >= 0)
{
var dialog = new MessageDialog(string.Format("Подтвердите покупку книги за {0} руб.", book.Price), "Подтвердите покупку");
dialog.DefaultCommandIndex = 0;
dialog.CancelCommandIndex = 1;
dialog.Commands.Add(new UICommand("купить", command => Task.Run(async () => await _litresPurchaseService.BuyBookFromLitres(book, session.Token))));
dialog.Commands.Add(new UICommand("отмена") { Id = 1 });
await dialog.ShowAsync();
//var result = Microsoft.Xna.Framework.GamerServices.Guide.BeginShowMessageBox(
//"Подтвердите покупку",
//string.Format("Подтвердите покупку книги за {0} руб.", Entity.Price),
//new string[] { "купить", "отмена" },
//0,
//Microsoft.Xna.Framework.GamerServices.MessageBoxIcon.None,
//null,
//null);
//result.AsyncWaitHandle.WaitOne();
//int? choice = Microsoft.Xna.Framework.GamerServices.Guide.EndShowMessageBox(result);
//if (choice.HasValue && choice.Value == 0)
//{
// await _litresPurchaseService.BuyBookFromLitres(book, session.Token);
//}
}
else
{
OnPropertyChanged(new PropertyChangedEventArgs("ChoosePaymentMethod"));
}
}
private async Task BuyBookAsync(Session session, Book book)
{
await _litresPurchaseService.BuyBook(book, CancellationToken.None);
}
private void Notify(Book book)
{
if (Debugger.IsAttached) Debug.WriteLine("Notify");
foreach (var expiredCallBack in _expiredCallBacks)
{
if (expiredCallBack != null)
{
expiredCallBack.ExpiredCallBack(book);
}
}
}
private void UpdateBook( Book curBook, bool withNavigate = false )
{
Analytics.Instance.sendMessage(Analytics.ActionBuyFullCardOk);
_purchaseServiceDecorator.UpdateBook(curBook);
}
public async Task UpdateExistBook(Book book)
{
await _bookProvider.UpdateExistBook(book, CancellationToken.None);
UpdateBook(book);
}
public void UpdateBook(Book book)
{
try
{
if(_myBooks != null) _myBooks.First(bk => bk.Id == book.Id).Update(book);
}
catch (Exception){}
try
{
if (_myBooksByTime != null) _myBooksByTime.First(bk => bk.Id == book.Id).Update(book);
}
catch (Exception) { }
}
public async Task AddFragmentToMyBasket(Book book, CancellationToken token)
{
if (book != null)
{
book.IsMyBook = false;
book.isFragment = true;
var parameters = new Dictionary<string, object>
{
{"hub_id", book.Id},
#if PDF_ENABLED
{"search_types", "0,4"},
#else
{"type", "2"},
#endif
};
await _client.AddBookToBasket(parameters, token);
}
}
public async Task DeleteBook(Book book, bool fromAnywhere = false)
{
bool isBought = await CheckBoughtBook(book.Id, CancellationToken.None);
bool isTrial = false;
if (_bookProvider.FullBookExistsInLocalStorage(book.Id))
{
await _bookProvider.RemoveFullBookInLocalStorage(book);
}
else if (_bookProvider.TrialBookExistsInLocalStorage(book.Id))
{
_bookProvider.RemoveTrialBookInLocalStorage(book);
isTrial = true;
}
book.isFragment = false;
if (!isBought || book.IsExpiredBook || fromAnywhere)
{
if(isTrial || book.isFragment) book.IsMyBook = false;
book.isFragment = false;
if (_myBooksIds != null && _myBooksIds.Contains(book.Id))
{
_myBooksIds.Remove(book.Id);
}
_dataCacheService.PutItem(_myBooksIds, AllMyBooksIdCacheItemName, CancellationToken.None);
if (_myBooks != null)
{
try
{
var bookToDel = _myBooks.First(bk => bk.Id == book.Id);
_myBooks.BeginUpdate();
_myBooks.Remove(bookToDel);
_myBooks.EndUpdate();
}
catch (Exception){}
}
_dataCacheService.PutItem(_myBooks, AllMyBooksCacheItemName, CancellationToken.None);
_dataCacheService.PutItem(GetTileBooksFromBookCollection(_myBooks), AllMyBooksTileCacheItemName, CancellationToken.None);
if (_myBooksByTime != null)
{
try
{
var bookToDel = _myBooksByTime.First(bk => bk.Id == book.Id);
_myBooksByTime.BeginUpdate();
_myBooksByTime.Remove(bookToDel);
_myBooksByTime.EndUpdate();
}
catch (Exception){}
}
_dataCacheService.PutItem(_myBooksByTime, ReadingBooksCacheItemName, CancellationToken.None);
var existsBooks = await _bookProvider.GetExistBooks(CancellationToken.None);
if (existsBooks != null && existsBooks.Count > 0)
{
try
{
var bookToDel = existsBooks.First(bk => bk.Id == book.Id);
existsBooks.BeginUpdate();
existsBooks.Remove(bookToDel);
existsBooks.EndUpdate();
}
catch (Exception){}
}
_dataCacheService.PutItem(existsBooks, "ExistBooks", CancellationToken.None);
}
}
public async Task AddFragmentToMyBooks(Book book, CancellationToken cancellationToken)
{
if (book != null)
{
book.IsMyBook = false;
book.isFragment = true;
if (_myBooks == null)
{
_myBooks = await GetAllMyBooksFromCache(cancellationToken);
_myBooks = _myBooks ?? new XCollection<Book>();
}
if (_myBooksByTime == null)
{
_myBooksByTime = await GetMyBooksFromCache(cancellationToken);
_myBooksByTime = _myBooksByTime ?? new XCollection<Book>();
}
var foundedBook = _myBooks.FirstOrDefault(bk => bk.Id.Equals(book.Id));
if (foundedBook == null)
{
_myBooks.BeginUpdate();
_myBooks.Insert(0, book);
_myBooks.EndUpdate();
_dataCacheService.PutItem(_myBooks, AllMyBooksCacheItemName, CancellationToken.None);
_dataCacheService.PutItem(GetTileBooksFromBookCollection(_myBooks), AllMyBooksTileCacheItemName, CancellationToken.None);
}
var foundedInMyBooks = _myBooksByTime.FirstOrDefault(bk => bk.Id.Equals(book.Id));
_myBooksByTime.BeginUpdate();
if (foundedInMyBooks != null)
{
_myBooksByTime.Remove(foundedInMyBooks);
}
_myBooksByTime.Insert(0, book);
if (_myBooksByTime.Count > BooksInPage)
{
_myBooksByTime = new XCollection<Book>(_myBooksByTime.Take(BooksInPage).ToArray());
}
_myBooksByTime.EndUpdate();
_dataCacheService.PutItem(_myBooksByTime, ReadingBooksCacheItemName, CancellationToken.None);
AddIdsToMyBooks(new List<Book> { book });
}
}
public async Task AddToHistory( Book book, CancellationToken cancellationToken )
{
if( book != null )
{
await GetBooksIdsFromHistory( cancellationToken );
if( _myHistoryBooksIds.Contains( book.Id ) )
{
_myHistoryBooksIds.Remove( book.Id );
}
_myHistoryBooksIds.Insert( 0, book.Id );
_dataCacheService.PutItem( _myHistoryBooksIds, ReadHistoryBooksIdCacheItemName, cancellationToken );
}
}
private async Task ProcessPurchase(Book book, string orderId, CancellationToken cancellationToken, int intensity = 15)
{
var startTimeout = DateTime.Now;
var startSecond = startTimeout;
do
{
if (cancellationToken.IsCancellationRequested)
{
return;
}
if ((DateTime.Now - startSecond).Seconds >= intensity)
{
var checkParameters = new Dictionary<string, object> { { "order_id", orderId } };
var purchResponse = await _client.CheckPurchaseState(checkParameters, cancellationToken);
if (purchResponse.State.Equals("failed"))
{
//Deployment.Current.Dispatcher.BeginInvoke(() => MessageBox.Show("При совершении платежа произошла непредвиденная ошибка."));
await new MessageDialog("При совершении платежа произошла непредвиденная ошибка.").ShowAsync();
return;
}
if (purchResponse.State.Equals("closed_ok"))
{
await BuyBookFromLitres(book, cancellationToken);
return;
}
startSecond = DateTime.Now;
}
} while ((DateTime.Now - startTimeout).Minutes < 5);
await new MessageDialog("Совершение платежа завершено по таймауту.").ShowAsync();
//Deployment.Current.Dispatcher.BeginInvoke(() => MessageBox.Show("Совершение платежа завершено по таймауту."));
}
public async Task TakeBookFromLitres(Book book, CancellationToken cancellationToken)
{
try
{
_purchaseServiceDecorator.UpdateBook(book, true);
}
catch (Exception e)
{
await new MessageDialog("Невозможно получить книгу").ShowAsync();
//MessageBox.Show("Невозможно получить книгу");
}
}
public async Task<Purchase> BuyBook( Book book )
{
ProductListing product = await FindProductForBook( book );
string receiptString;
try
{
if( CurrentApp.LicenseInformation.ProductLicenses[product.ProductId].IsActive )
{
receiptString = await CurrentApp.GetProductReceiptAsync( product.ProductId );
}
else
{
receiptString = await CurrentApp.RequestProductPurchaseAsync( product.ProductId, true );
}
}
catch( COMException e)
{
return null;
}
try
{
var document = XDocument.Parse( receiptString );
var receipt = document.DescendantNodes().OfType<XElement>().FirstOrDefault(x => x.Name.LocalName == "ProductReceipt");
if( receipt != null )
{
var productIdAttribute = receipt.Attribute( "ProductId" );
if( productIdAttribute == null || productIdAttribute.Value != product.ProductId )
{
throw new InvalidOperationException( "Windows Store purchase failed." );
}
}
else
{
throw new InvalidOperationException( "Windows Store purchase failed." );
}
}
catch( InvalidOperationException )
{
throw;
}
catch( Exception ex )
{
throw new InvalidOperationException( "Windows Store purchase failed.", ex );
}
return new Purchase { Art = book.Id, Win8Inapp = receiptString, ProductId = product.ProductId };
}
private void UpdateBookFailed( Book art )
{
_purchaseServiceDecorator.UpdateBookFailed( art );
}
public async Task BuyBook( Book book, CancellationToken cancellationToken)
{
//If acoount not exits - create
CatalitCredentials creds = _credentialsProvider.ProvideCredentials( cancellationToken );
if (creds == null)
{
creds = await _profileProvider.RegisterDefault( cancellationToken );
_credentialsProvider.RegisterCredentials( creds, cancellationToken );
}
bool isNokiaBook = false;
if (_deviceInfoService.IsNokiaDevice && !string.IsNullOrEmpty(book.InGifts) && book.InGifts.Equals("1"))
{
var nokiaBook = await _catalogProvider.GetBookByCollection((int)BooksByCategoryViewModel.BooksViewModelTypeEnum.NokiaCollection, book.Id, cancellationToken);
if (nokiaBook != null) isNokiaBook = true;
}
if (isNokiaBook)
{
await _catalogProvider.TakeBookFromCollectionBySubscription(book.Id, cancellationToken);
UpdateBook(book);
}
else
{
try
{
Purchase newPurchase = await _inAppPurchaseService.BuyBook(book);
//purchase cancelled or not exist
if (newPurchase == null) return;
var parameters = new Dictionary<string, object>
{
{"inapp_data", newPurchase.Win8Inapp},
{"lfrom", _deviceInfoService.LitresInAppRefId},
{"art", book.Id}
};
PurchaseResponse purchase = null;
try
{
purchase = await _client.PurchaseBook(parameters, cancellationToken, book.isHiddenBook);
}
catch (CatalitInappProcessingFailedException e)
{
if (e.ErrorCode == 309)
{
_inAppPurchaseService.CheckProductIsUsed(book.InappName);
}
purchase = new PurchaseResponse {State = "failed"};
}
switch (purchase.State)
{
case "pending":
break;
case "unknown":
case "closed_ok_book_failed":
case "failed":
UpdateBookFailed(book);
break;
case "closed_ok":
//ToDo: Do something
_inAppPurchaseService.CheckProductIsUsed(book.InappName);
UpdateBook(book);
break;
}
}
catch (Exception ex)
{
var dialog = new MessageDialog("Оплата через Windows Store временно недоступна, пожалуйста, выберите другой вариант оплаты")
{
DefaultCommandIndex = 0
};
dialog.Commands.Add(new UICommand("Ок") { Id = 1 });
await dialog.ShowAsync();
Debug.WriteLine(ex.Message);
}
}
}
public void AddBook(Book book)
{
if (Debugger.IsAttached) Debug.WriteLine("AddBook and StartGuardian");
StartGuardian();
}
public async Task<string> GiftBook(Book book, CancellationToken cancellationToken)
{
var parameters = new Dictionary<string, object>
{
{"art", book.Id}
};
string result = "";
result = await _client.GetGiftBook(parameters, cancellationToken, book.isHiddenBook);
if (result.Contains("failed "))
{
var responce = new PresentErrorResponce();
using (var textReader = new StringReader(result))
{
var serializer = new XmlSerializer(typeof(PresentErrorResponce));
responce = (PresentErrorResponce) serializer.Deserialize(textReader);
return responce.ErrorCode.ToString();
}
}
return "Ok";
}
public void RefreshBook(Book book)
{
if (FoundBooks.Count > 0)
{
for (int i = 0; i < FoundBooks.Count; ++i)
{
if (FoundBooks[i].Id == book.Id)
{
FoundBooks.BeginUpdate();
FoundBooks[i] = book;
FoundBooks.EndUpdate();
break;
}
}
}
}
public async Task MobileCommerceInit(double sum, string phone,Book book, CancellationToken cancellationToken)
{
var parameters = new Dictionary<string, object>
{
{ "sum", sum },
{ "phone", phone }
};
var response = await _client.MobileCommerceInit(parameters, cancellationToken);
if (response.State.Equals("success"))
{
await ProcessPurchase(book, response.OrderId, cancellationToken);
}
else if (response.State.Equals("failed"))
{
string messageBoxBody;
switch (response.Error)
{
case 1:
messageBoxBody = "заказ или пользователь не найдены";
break;
case 2:
messageBoxBody = "указан неправильный номер телефона";
break;
case 3:
messageBoxBody = "указана недопустимая сумма";
break;
case 4:
messageBoxBody = "таймаут платежей";
break;
case 5:
messageBoxBody = "внутренняя ошибка";
break;
default:
messageBoxBody = string.Empty;
break;
}
if (!string.IsNullOrEmpty(messageBoxBody))
{
await new MessageDialog(messageBoxBody).ShowAsync();
//Deployment.Current.Dispatcher.BeginInvoke(() => MessageBox.Show(messageBoxBody));
}
}
}
private async Task GetGiftAsync(Session session, Book book)
{
var result = await _litresPurchaseService.GiftBook(book, CancellationToken.None);
if (result.Contains("Ok"))
OnPropertyChanged(new PropertyChangedEventArgs("PresentOk"));
else
{
OnPropertyChanged(new PropertyChangedEventArgs("PresentError"));
ErrorCode = result;
}
}
public async Task StartSmsPaymentListener(Book book, CancellationToken cancellationToken)
{
var startTimeout = DateTime.Now;
var startSecond = startTimeout;
do
{
if (cancellationToken.IsCancellationRequested)
{
//System.Windows.Deployment.Current.Dispatcher.BeginInvoke(() =>
//{
// MessageBox.Show("Совершение платежа отменено.");
//});
return;
}
if ((DateTime.Now - startSecond).Seconds >= 15)
{
var parameters = new Dictionary<string, object>{{ "art", 0 }};
LitresPurchaseResponse purchase = null;
try
{
purchase = await _client.LitresPurchaseBook(parameters, cancellationToken, book.isHiddenBook);
}
catch (CatalitPurchaseException e) {}
if (purchase!=null && Convert.ToDouble(purchase.Account) >= book.Price)
{
await BuyBookFromLitres(book, cancellationToken);
break;
}
startSecond = DateTime.Now;
}
} while ((DateTime.Now - startTimeout).Minutes < 5);
}
private async void BuyBookFromLitresAsync(Book book)
{
OnPropertyChanged(new PropertyChangedEventArgs("BuyBookStart"));
Book = book;
await Load(new Session(BuyBookLitresPart));
}
public async Task<bool> CreditCardPayment(Book book, double sum, bool isAuth, bool preventrebil, IDictionary<string, object> parameters, CancellationToken cancellationToken)
{
CreditCardInitResponse response = null;
string orderId = null;
Dictionary<string, object> param = null;
try
{
response = await CreditCardInit(sum, isAuth, preventrebil, cancellationToken);
_termUrl = response.TermUrl;
param = new Dictionary<string, object>();
foreach (var _param in response.Params)
{
if (_param.Substitute != null && parameters != null && parameters.ContainsKey(_param.Substitute)) param.Add(_param.Name, parameters[_param.Substitute]);
else param.Add(_param.Name, _param.Value);
if (_param.Name.Equals("OrderID")) orderId = _param.Value;
}
param.Add("ContentType", "xml");
}
catch (Exception ex)
{
await new MessageDialog("Ошибка инициализации карты.").ShowAsync();
//Deployment.Current.Dispatcher.BeginInvoke(() => MessageBox.Show("Ошибка инициализации карты."));
return true;
}
ProcessingResponse processingCenterResponse = null;
try
{
processingCenterResponse = await _client.ProcessingServerRequest(response.Url, response.Method, param, cancellationToken);
if (processingCenterResponse != null)
{
if (processingCenterResponse.Result.Equals("Error"))
{
if (processingCenterResponse.Code == 6001)
{
_processingCenterResponse = processingCenterResponse;
_3dsBook = book;
_3dsOrderId = orderId;
return false;
}
var errorMessage = "Произошла ошибка во время оплаты.";
if (processingCenterResponse.Code == 6100 && processingCenterResponse.ErrorCode == 2 && processingCenterResponse.Status.Equals("Declined"))
{
errorMessage = "Невозможно совершить платеж из Вашего региона.";
}
await new MessageDialog(errorMessage).ShowAsync();
//Deployment.Current.Dispatcher.BeginInvoke(() => MessageBox.Show(errorMessage));
return true;
}
if (orderId != null)
{
try
{
var cred = _credentialsProvider.ProvideCredentials(cancellationToken) ?? new CatalitCredentials();
var user = await _profileProvider.GetUserInfo(cancellationToken, true);
if (user != null)
{
cred.UserId = user.UserId;
cred.CanRebill = "1";
if (isAuth && !preventrebil) cred.CanRebill = "0";
if (parameters!=null && parameters.ContainsKey("number"))
{
var numbers = parameters["number"].ToString();
if (numbers.Length >= 4)
{
cred.CreditCardLastNumbers = numbers.Substring(numbers.Length - 4, 4);
}
numbers = null;
}
_credentialsProvider.RegisterCredentials(cred, cancellationToken);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
try
{
await ProcessPurchase(book, orderId, cancellationToken, 3);
return true;
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
}
}
catch (Exception ex)
{
if (processingCenterResponse != null && processingCenterResponse.Code == 6001)
{
_processingCenterResponse = processingCenterResponse;
_3dsBook = book;
_3dsOrderId = orderId;
return false;
}
if (processingCenterResponse != null &&
processingCenterResponse.Code == 6100 &&
processingCenterResponse.ErrorCode == 2 &&
processingCenterResponse.Status.Equals("Declined") &&
processingCenterResponse.Result.Equals("Error"))
{
await new MessageDialog("Невозможно совершить платеж из Вашего региона.").ShowAsync();
//Deployment.Current.Dispatcher.BeginInvoke(() => MessageBox.Show("Невозможно совершить платеж из Вашего региона."));
}
else
{
await new MessageDialog("Произошла ошибка во время оплаты.").ShowAsync();
//Deployment.Current.Dispatcher.BeginInvoke(() => MessageBox.Show("Произошла ошибка во время оплаты."));
}
return true;
}
return true;
}
private void NavigateToBook( Book book )
{
if( book != null && !book.IsEmptyElement )
{
_navigationService.Navigate( "Book", XParameters.Create( "BookEntity", book ) );
}
}
public async Task UpdateExistBook(Book book, CancellationToken token)
{
var exists = await GetExistBooks(token);
var bk = exists.FirstOrDefault((x => x.Id == book.Id));
if (bk != null)
{
exists.Remove(bk);
exists.Add(book);
_dataCacheService.PutItem(exists, StorageSettingName, CancellationToken.None);
}
}
