private async Task DeletePublication(int bookId, DlStatusEnum dlStatus, UserCredential userCredential)
{
var localDlBook = publicationAccess.GetDlBookByBookId(bookId, userCredential);
if (localDlBook != null)
{
await localDlBook.DeleteDlBookInstallFile();
if (dlStatus == DlStatusEnum.RemovedByUser)
{
var removedByUserSuccess = (publicationAccess.UpdateDlBookStatus(bookId, DlStatusEnum.RemovedByUser, userCredential) > 0);
if (removedByUserSuccess)
{
ClearRelevantDlBookData(bookId, userCredential);
}
var pingSuccess = await connectionMonitor.PingService(null);
if (pingSuccess)
{
bool removeSuccess = await RemoveDlFromServer(localDlBook, userCredential);
if (removeSuccess)
{
RemoveDlBookFromDb(bookId, userCredential);
}
}
}
else if (dlStatus == DlStatusEnum.RemovedByEreader)
{
ClearRelevantDlBookData(bookId, userCredential);
RemoveDlBookFromDb(bookId, userCredential);
}
}
}
/// <summary>
/// login process
/// </summary>
/// <param name="email">your email account</param>
/// <param name="password">password</param>
/// <param name="countryCode">countrycode</param>
/// <returns></returns>
public async Task <LoginStatusEnum> ValidateUserLogin(string email, string password, string countryCode)
{
//Verify the legitimacy of the account information
LoginStatusEnum loginStatus = User.ValidateUserInfo(email, password, countryCode);
try
{
User user = null;
var pingResult = await connectionMonitor.PingService(countryCode);
if (!pingResult)
{//offline
//user = this.loginDomainService.LoginOffline(email, password, countryCode);
loginStatus = user == null ? LoginStatusEnum.NetDisconnected : loginStatus = LoginStatusEnum.NetDisconnected;
}
else
{
var onlineResult = await loginDomainService.LoginOnline(email, password, countryCode);
user = onlineResult.Item1;
loginStatus = onlineResult.Item2;
}
if (loginStatus == LoginStatusEnum.LoginSuccess)
{
GlobalAccess.Instance.CurrentUserInfo = loginDomainService.UpdateCurrentUser(user);
await DomainEvents.Publish(new LoginSuccessEvent(GlobalAccess.Instance.CurrentUserInfo));
}
}
catch (CusNetDisConnectedException)
{
loginStatus = LoginStatusEnum.NetDisconnected;
}
catch (MaxDeviceExceededException)
{
loginStatus = LoginStatusEnum.DeviceLimit;
}
catch (Exception ex)
{
loginStatus = LoginStatusEnum.LoginFailure;
Logger.Log("ValidateUserLogin" + ex.ToString());
}
return(loginStatus);
}
public async void Log()
{
try
{
Logger.Log("-------------------------------------");
Stopwatch timer = new Stopwatch();
for (int i = 0; i < 20; i++)
{
timer.Start();
await connectionMonitor.PingService("AU");
await ServiceAgent.RestFullPingServiceRequest(new Uri("http://192.168.1.101/ln.red/service/ds.webservice/AuthenticationService.svc"), "/Islive", new CancellationToken());
timer.Stop();
Logger.Log(timer.ElapsedMilliseconds.ToString());
timer.Reset();
}
}
catch (Exception)
{
throw;
}
}
private async Task PerformSync()
{
try
{
var task = annotationSyncQueue.Dequeue();
while (task != null)
{
var pingResult = await connectionMonitor.PingService(task.CountryCode);
if (pingResult)
{
AnnotationTaskContext context = new AnnotationTaskContext(task, syncService, annotationAccess);
foreach (var action in actions)
{
//if (task.IsSyncTagsOnly)
//{
// if (action.SyncActionName == SyncActionName.AnnCategoryTagSyncAction)
// await action.PerformAction(context);
// break;
//}
//else
//{
// await action.PerformAction(context);
//}
}
}
else
{
break;
}
task = annotationSyncQueue.Count > 0 ? annotationSyncQueue.Dequeue() : null;
}
}
catch (Exception ex)
{
Logger.Log(ex.ToString());
}
finally
{
//End Queue Processor....
isSyncRunning = false;
}
}
/// <summary>
/// get remote publications in online mode
/// </summary>
/// <returns>Task<OnlinePublicationResult></returns>
public async Task <OnlinePublicationResult> GetPublicationOnline()
{
OnlinePublicationResult onlinePublicationResult = new OnlinePublicationResult {
RequestStatus = RequestStatusEnum.Failure
};
//onlinePublicationResult.Publications = GetPublicationOffline();
//onlinePublicationResult.RequestStatus = RequestStatusEnum.Success;
//return onlinePublicationResult;
try
{
if (Interlocked.Increment(ref GetPublicationOnlineFlag) == 1)
{
var pingSuccess = await connectionMonitor.PingService(null);
if (!pingSuccess)
{
return(onlinePublicationResult);
}
// await publicationDomainService.RemoveDlBooksFromServer(GlobalAccess.Instance.UserCredential);
var onlineDlBooks = await publicationDomainService.GetOnlineDlBooks(GlobalAccess.Instance.Email);
var localDlBooks = publicationAccess.GetAllDlBooks(GlobalAccess.Instance.UserCredential);
var exceptDlBooks = GetLocalDlBooksExceptOnlineDlBooks(onlineDlBooks, localDlBooks);
var additionalDlBooks = publicationDomainService.GetAdditionalDlBooks(exceptDlBooks);
onlinePublicationResult.Publications = additionalDlBooks.ToPublications();
var toBeDeletedDlBooks = exceptDlBooks.Except(additionalDlBooks, new DlBookEqualityComparer());
await publicationDomainService.DeleteDlBooksByEreader(toBeDeletedDlBooks);
if (toBeDeletedDlBooks != null && toBeDeletedDlBooks.Count() > 0)
{
if (RecenthistoryChanged != null)
{
RecenthistoryChanged();
}
}
bool noReturnFromServer = (onlineDlBooks == null || onlineDlBooks.Count == 0);
if (noReturnFromServer)
{//user did not Assign dlbook
onlinePublicationResult.RequestStatus = RequestStatusEnum.Success;
return(onlinePublicationResult);
}
var updatedPublications = publicationDomainService.UpdateLocalDlBooks(onlineDlBooks, localDlBooks);
onlinePublicationResult.Publications.AddRange(updatedPublications);
onlinePublicationResult.Publications = onlinePublicationResult.Publications
.OrderBy(p => p.OrderBy)
.ThenByDescending(p => p.RowId)
.ToList();
onlinePublicationResult.RequestStatus = RequestStatusEnum.Success;
await DomainEvents.Publish(new GetPublicationOnlineEvent());
}
}
catch (Exception ex)
{
Logger.Log("GetPublicationOnline" + ex.ToString());
}
finally
{
Interlocked.Decrement(ref GetPublicationOnlineFlag);
}
return(onlinePublicationResult);
}