private Task ClearDownloadedFiles(DlBook dlBook, DownLoadEnum downloadStatus, int previousDownloadVersion)
{
return(Task.Run(async() =>
{
try
{
if (dlBook != null)
{
await dlBook.DeleteDlBookZipFile();
}
bool hasNewVersion = (previousDownloadVersion != 0 && dlBook.LastDownloadedVersion != previousDownloadVersion);
if (downloadStatus == DownLoadEnum.Success && hasNewVersion)
{
string lastVersionDirectory = Path.Combine(dlBook.ServiceCode,
dlBook.Email,
Constants.DLFiles,
dlBook.BookId + "V" + previousDownloadVersion);
if (await GlobalAccess.DirectoryService.DirectoryExists(lastVersionDirectory))
{
await GlobalAccess.DirectoryService.DeleteDirectory(lastVersionDirectory);
}
}
}
catch (Exception ex)
{
Logger.Log("ClearDownloadedFiles error:" + ex.ToString());
}
}));
}
public async void RefreshLocalDlBook()
{
DlBook serverDl = new DlBook
{
SubCategory = "SubCategory",
PracticeArea = "PracticeArea",
AddedGuideCard = "AddedGuideCard",
CurrentVersion = 20,
Size = 2000
};
DlBook localDl = new DlBook
{
DlStatus = (short)DlStatusEnum.NotdDownloaded
};
domainContainer.Arrange <IDeliveryService>((deliveryService) => deliveryService.DlMetadata(null)).IgnoreArguments()
.Returns(GetDlMetadata());
domainContainer.Arrange <IDeliveryService>((deliveryService) => deliveryService.DlVersionChangeHistory(null)).IgnoreArguments()
.Returns(GetDlBookChangeHistory());
await domainContainer.Instance.RefreshLocalDlBook(serverDl, localDl, "");
Assert.IsTrue(localDl.SubCategory == serverDl.SubCategory);
Assert.IsTrue(localDl.PracticeArea == serverDl.PracticeArea);
var localAddedGuideCard = JsonConvert.DeserializeObject <List <GuideCard> >(localDl.AddedGuideCard);
Assert.IsTrue(localAddedGuideCard[0].Name == serverDl.AddedGuideCard);
Assert.IsTrue(localDl.LastDownloadedVersion == serverDl.CurrentVersion);
Assert.IsTrue(localDl.LocalSize == serverDl.Size);
}
private List <Annotation> GetAnnotationsByDocId(string docId, DlBook dlBook)
{
//var annotations = annotationAccess.GetAnnotations(GlobalAccess.Instance.Email, GlobalAccess.Instance.ServiceCode, dlBook.BookId, docId);
//if (annotations == null)
// return null;
// return AnnotationFactory.CreateAnnotations(annotations, this.tagDomainService.Tags, new List<DlBook> { dlBook });
return(null);
}
/// <summary>
/// RenderHyperLink
/// </summary>
/// <param name="url"></param>
/// <returns></returns>
public string RenderHyperLink(string strHtml, int currentBookId)
{
string result = strHtml;
try
{
RefreshCurrentPublication(currentBookId).Wait();
currentBook = GlobalAccess.Instance.CurrentPublication.DlBook;
interBookDictionary.Clear();
intraBookDictionary.Clear();
allContentLinkDetailList.Clear();
intraBookLinkDictionary.Clear();
HtmlDocument doc = new HtmlDocument();
doc.LoadHtml(strHtml);
var hyperlinkList = doc.DocumentNode.DescendantsAndSelf().Where(e => e.Name.Equals("a")).ToList();
foreach (HtmlNode link in hyperlinkList)
{
if (link.GetAttributeValue(CSS_CLASS, "") == CSS_HIDDEN_HYPER_LINK || link.GetAttributeValue(CSS_CLASS, "") == CSS_PLAIN_TEXT)
{
break;
}
string url = link.GetAttributeValue("href", "");
link.SetAttributeValue(CSS_CLASS_KEY, CSS_EXTERNAL_CLASS);
if (!String.IsNullOrEmpty(url))
{
//Hyperlink hyperlink = BuildHyperLink(currentBook.BookId, url, link.GetAttributeValue(TOCID, ""));
//if (hyperlink != null)
//{
// if (hyperlink.LinkType == HyperLinkType.Hiddenlink)
// link.SetAttributeValue(CSS_NONE_DISPLAY_KEY, CSS_NONE_DISPLAY_VALUE);
// else if (hyperlink.LinkType == HyperLinkType.ExternalHyperlink)
// link.SetAttributeValue(CSS_CLASS_KEY, CSS_EXTERNAL_CLASS);
// else
// link.SetAttributeValue(CSS_CLASS_KEY, CSS_INTERBOOK_CLASS);
//}
}
else
{
link.SetAttributeValue(CSS_CLASS, CSS_PLAIN_TEXT);
}
}
//RemoveCompendiumLink(doc);
using (Stream st = new MemoryStream())
{
doc.Save(st, Encoding.UTF8);
result = Encoding.UTF8.GetString((st as MemoryStream).ToArray(), 0, (st as MemoryStream).ToArray().Count());
}
return(result);
}
catch (Exception ex)
{
Logger.Log("Render Hyper Link Failed : " + ex.Message);
return(strHtml);
}
}
public AnnotationSyncTask(DlBook publication, string deviceId, LoginUserDetails currentUser)
: this(deviceId, currentUser)
{
//BookIds = new List<int> { publication.BookId };
//CurrentVersion = new Dictionary<int, int>
//{
// {publication.BookId, publication.CurrentVersion}
//};
}
public static async Task <bool> RestFullServiceRequestForFileDownload(DlBook dlBook, CancellationToken cancelToken, DownloadProgressEventHandler downloadHandler)
{
HttpResponseMessage response = await hclient.GetAsync(new Uri(dlBook.FileUrl), HttpCompletionOption.ResponseHeadersRead, cancelToken);
if (response.StatusCode != HttpStatusCode.OK)
{
throw new Exception(Constants.STATUS_CODE_MESSAGE + response.StatusCode);
}
return(await ResponseStreamToFile(response, cancelToken, dlBook.GetDlBookZipFileName(), dlBook.Size, downloadHandler));
}
private async Task UpdateCurrentPublication(DlBook dlBook)
{
var isSamePublication = (GlobalAccess.Instance.CurrentPublication != null &&
GlobalAccess.Instance.CurrentPublication.DlBook.BookId == dlBook.BookId);
//update currentPublication infomation when current publication is the downloaded publication
if (isSamePublication)
{
await DomainEvents.Publish(new PublicationOpeningEvent(dlBook, true));
}
}
private int DeleteOrphanedRecentHistory(DlBook dlBook)
{
//var recentHistorys = recentHistoryAccess.GetAllRecentHistoriesByBookID(dlBook.Email, dlBook.ServiceCode, dlBook.BookId);
//if (recentHistorys != null)
//{
// var tocDetails = packageAccess.GetAllTOCNodeDetails(dlBook.GetDecryptedDbFullName());
// string docidInCondition = BuildDocIDInCondition(recentHistorys, tocDetails);
// var deleteResult = recentHistoryAccess.DeleteRecentHistoryByDocIDs(docidInCondition, dlBook.BookId, dlBook.Email, dlBook.ServiceCode);
// return deleteResult;
//}
return(-1);
}
public Task InstallDlBook(DlBook dlBook, string symmetricKey, CancellationToken cancelToken)
{
return(Task.Run(async() =>
{
InstallResultEnum installResult = InstallResultEnum.Failure;
PublicationContent publicationContent = null;
try
{
var contentKey = await dlBook.GetContentKey(symmetricKey).WithCancellation <byte[]>(cancelToken);
publicationContent = new PublicationContent(dlBook, contentKey);
bool hasNotInstalled = (!await publicationContent.DlBook.IsSqliteDecryped());
if (hasNotInstalled)
{
await publicationContent.DlBook.UnZipFile(cancelToken);
if (cancelToken.IsCancellationRequested)
{
cancelToken.ThrowIfCancellationRequested();
}
await publicationContent.DecryptDataBase();
await publicationContent.DlBook.DeleteOriginalSqlite();
installResult = InstallResultEnum.Success;
}
else
{//has been installed
installResult = InstallResultEnum.Success;
}
}
catch (OperationCanceledException ex)
{
if (cancelToken.IsCancellationRequested)
{
installResult = InstallResultEnum.Cancel;
}
throw ex;
}
catch (Exception ex)
{
Logger.Log("Install error:" + ex.ToString());
installResult = InstallResultEnum.Failure;
throw ex;
}
finally
{
if (publicationContent != null && installResult != InstallResultEnum.Success)
{
publicationContent.DlBook.DeleteDlBookInstallFile().Wait();
}
}
}));
}
private void ProcessOrphanedAnnotations(DlBook dlBook)
{
//var annotations = annotationAccess.GetAnnotations(dlBook.Email, dlBook.ServiceCode, dlBook.BookId);
//if (annotations != null)
//{
// if (dlBook != null)
// {
// var tocDetails = packageAccess.GetAllTOCNodeDetails(dlBook.GetDecryptedDbFullName());
// var annos = from anno in annotations.Where(o => o.Status != (int)AnnotationStatusEnum.Orphaned)
// where !tocDetails.Exists(o => o.DocID == anno.DocumentID)
// select UpdateAnnotationToOrphaned(anno);
// }
//}
}
public void BuildExternalHyperlinkTest1()
{
DlBook tempDlBook = new DlBook
{
BookId = 2,
DpsiCode = "0JVV",
CurrentVersion = 2
};
container.Arrange <IPublicationAccess>(publicationAccess => publicationAccess.GetDlBookByBookId(0, null)).IgnoreArguments().Returns(tempDlBook);
var link = container.Instance.BuildHyperLink(tempDlBook.BookId, "looseleaf://...citeref?ctype=case&element=citefrag_span&decisiondate_year=2001&caseref_ID=cr000118&caseref_spanref=cr000118-001&reporter_value=nswlr&volume_num=53&page_num=198&LinkName=(2001) 53 NSWLR 198", "");
Assert.IsTrue(link is ExternalHyperlink);
}
public void BuildIntraHyperlinkTest()
{
DlBook tempDlBook = new DlBook
{
BookId = 2,
DpsiCode = "P-0098",
CurrentVersion = 2,
Email = GlobalAccess.Instance.CurrentUserInfo.Email,
ServiceCode = GlobalAccess.Instance.CurrentUserInfo.Country.CountryCode
};
container.Arrange <IPublicationAccess>(publicationAccess => publicationAccess.GetDlBookByBookId(0, null)).IgnoreArguments().Returns(tempDlBook);
var link = container.Instance.BuildHyperLink(tempDlBook.BookId, "looseleaf://opendocument?dpsi=P-0098&refpt=CPV.RC1GD.64-01-600&remotekey1=REFPTID&service=DOC-ID&LinkName=[I 64.01.600]", "");
Assert.IsTrue(link is IntraHyperlink);
}
public void BuildAttachmentHyperlinkTest()
{
DlBook tempDlBook = new DlBook
{
BookId = 2,
DpsiCode = "P-00988",
CurrentVersion = 2,
Email = GlobalAccess.Instance.CurrentUserInfo.Email,
ServiceCode = GlobalAccess.Instance.CurrentUserInfo.Country.CountryCode,
DlStatus = (int)DlStatusEnum.Downloaded
};
container.Arrange <IPublicationAccess>(publicationAccess => publicationAccess.GetDlBookByBookId(0, null)).IgnoreArguments().Returns(tempDlBook);
var link = container.Instance.BuildHyperLink(2, "looseleaf://opendocument?linktype=urjpdf&citation=BC201109206&filename=1109206.pdf", "");
Assert.IsTrue(link is ExternalHyperlink);
}
public async Task <DlBook> RefreshLocalDlBook(DlBook serverDlBook, DlBook localDlBook, string deviceid)
{
if (localDlBook == null)
{
return(null);
}
//update SubCategory PracticeArea
var metaData = await SetDlBookMetaData(serverDlBook.BookId,
new UserCredential(serverDlBook.Email, serverDlBook.ServiceCode),
deviceid);
if (metaData != null)
{
localDlBook.SubCategory = metaData.SubCategory;
localDlBook.PracticeArea = metaData.PracticeArea;
}
var changeHistory = await GetDlBookChangeHistory(serverDlBook.BookId, serverDlBook.CurrentVersion, serverDlBook.Email, deviceid);
if (changeHistory != null)
{
localDlBook.AddedGuideCard = JsonConvert.SerializeObject(changeHistory.AddedGuideCard);
localDlBook.DeletedGuideCard = JsonConvert.SerializeObject(changeHistory.DeletedGuideCard);
localDlBook.UpdatedGuideCard = JsonConvert.SerializeObject(changeHistory.UpdatedGuideCard);
}
bool validDlbook = (localDlBook.DlStatus == (short)DlStatusEnum.NotDownloaded ||
localDlBook.DlStatus == (short)DlStatusEnum.Downloaded);
if (validDlbook)
{
localDlBook.LastDownloadedVersion = serverDlBook.CurrentVersion;
localDlBook.InstalledDate = DateTime.Now;
localDlBook.CurrencyDate = serverDlBook.LastUpdatedDate;
localDlBook.LocalSize = serverDlBook.Size;
localDlBook.DlStatus = (short)DlStatusEnum.Downloaded;
localDlBook.Size = serverDlBook.Size;
localDlBook.UpdateFromServer(serverDlBook, true);
return(localDlBook);
}
else
{
Logger.Log("DlStatus Error");
return(null);
}
}
public void BuildExternalHyperlinkTest2()
{
DlBook tempDlBook = new DlBook
{
BookId = 13,
DpsiCode = "007S",
CurrentVersion = 4,
LastDownloadedVersion = 4,
Email = GlobalAccess.Instance.CurrentUserInfo.Email,
ServiceCode = GlobalAccess.Instance.CurrentUserInfo.Country.CountryCode
};
// container.Arrange<IPublicationAccess>(publicationAccess => publicationAccess.GetDlBookByBookId(13, null)).IgnoreArguments().Returns(tempDlBook);
var link = PublicationContentUtil.Instance.BuildHyperLink(tempDlBook.BookId, "looseleaf://opendocument?dpsi=0I09&refpt=MC.DIV_II.GC001.GROUP1&remotekey1=REFPTID&service=DOC-ID&LinkName=[I 64.01.600]", "");
var link1 = PublicationContentUtil.Instance.BuildHyperLink(tempDlBook.BookId, "looseleaf://opendocument?dpsi=05CC&refpt=UCPN.CPA.CPAN05.S2.1&remotekey1=REFPTID&service=DOC-ID&LinkName=[I 64.01.600]", "");
var link2 = PublicationContentUtil.Instance.BuildHyperLink(tempDlBook.BookId, "looseleaf://opendocument?dpsi=05CC&refpt=UCPN.CPA.CPAN05.S2.1&remotekey1=REFPTID&service=DOC-ID&LinkName=[I 64.01.600]", "");
var link3 = PublicationContentUtil.Instance.BuildHyperLink(tempDlBook.BookId, "looseleaf://opendocument?dpsi=05CC&refpt=UCPN.CPA.CPAN05.S2.1&remotekey1=REFPTID&service=DOC-ID&LinkName=[I 64.01.600]", "");
var link4 = PublicationContentUtil.Instance.BuildHyperLink(tempDlBook.BookId, "looseleaf://opendocument?dpsi=0I09&refpt=MC.DIV_II.GC001.GROUP1&remotekey1=REFPTID&service=DOC-ID&LinkName=[I 64.01.600]", "");
Assert.IsTrue(link is ExternalHyperlink);
}
public void Init()
{
autoMockSettings = new AutoMockSettings
{
ConstructorArgTypes = new Type[] {
typeof(IPublicationAccess),
typeof(IDeliveryService),
typeof(IConnectionMonitor),
typeof(INetwork),
typeof(IAnnotationAccess),
typeof(IPackageAccess)
}
};
source = new CancellationTokenSource();
pingTaskFailure = new Task <bool>(() => { return(false); });
pingTaskSuccess = new Task <bool>(() => { return(true); });
pingTaskFailure.Start();
pingTaskSuccess.Start();
validateResult = new Task <HttpResponse>(() =>
{
return(new HttpResponse
{
IsSuccess = true,
Content = JsonConvert.SerializeObject(new LoginUserValidationResponse {
ValidUser = true
})
});
});
validateResult.Start();
container = new MockingContainer <PublicationUtil>(autoMockSettings);
dlBook = new DlBook
{
Size = 100,
FileUrl = "",
CurrentVersion = 1,
BookId = 1,
InitVector = "QDFCMmMzRDRlNUY2ZzdIOA==",
K2Key = "cldADc+tjskTH1G5H9R19IFNOLRaVBaQYSL9QZe/FB4=",
HmacKey = "N2IhLPP0CO58AXHy4QGfbFHZ+Yw="
};
}
/// <summary>
/// GetBookByPriority
/// </summary>
/// <param name="targetFtcDlbook"></param>
/// <param name="targetStandardDlbook"></param>
/// <param name="targetDlbook"></param>
/// <returns></returns>
private static DlBook GetBookByPriority(DlBook targetFtcDlbook, DlBook targetStandardDlbook, DlBook targetDlbook)
{
bool isFtcExpired = true;
bool isStatndardExpired = true;
isFtcExpired = targetFtcDlbook == null || targetFtcDlbook.ValidTo == null || (targetFtcDlbook.ValidTo != null && targetFtcDlbook.ValidTo.Value.DaysRemaining() < 0);
isStatndardExpired = targetStandardDlbook == null || targetStandardDlbook.ValidTo == null || (targetStandardDlbook.ValidTo != null && targetStandardDlbook.ValidTo.Value.DaysRemaining() < 0);
if (targetFtcDlbook != null && targetStandardDlbook != null)
{
targetDlbook = isFtcExpired ? targetStandardDlbook : targetFtcDlbook;
}
else if (targetFtcDlbook != null)
{
targetDlbook = targetFtcDlbook;
}
else if (targetFtcDlbook == null && targetStandardDlbook != null)
{
targetDlbook = targetStandardDlbook;
}
return(targetDlbook);
}
public PublicationContentUtilTest()
{
LoginUtil.Instance.ValidateUserLogin(TestHelper.TestUsers[0].UserName, TestHelper.TestUsers[0].Password, TestHelper.TestUsers[0].CountryCode).Wait();
dlBook = new DlBook
{
BookId = bookId,
InitVector = "QDFCMmMzRDRlNUY2ZzdIOA==",
K2Key = "MXdi9JQDDUY1hf5TZCEHjeBtjKL605dInVG3xYTF76U=",
HmacKey = "9jU0MAYPOPufUZoZJCW7qhsQe20=",
LastDownloadedVersion = 1,
ServiceCode = GlobalAccess.Instance.CurrentUserInfo.Country.CountryCode,
Email = GlobalAccess.Instance.CurrentUserInfo.Email
};
//var contentKey = dlBook.GetContentKey(GlobalAccess.Instance.CurrentUserInfo.SymmetricKey).Result;
//GlobalAccess.Instance.CurrentPublication = new PublicationContent(dlBook, contentKey);
autoMockSettings = new AutoMockSettings
{
ConstructorArgTypes = new Type[] { typeof(IPublicationAccess), typeof(IPackageAccess), typeof(IRecentHistoryAccess) }
};
container = new MockingContainer <PublicationContentUtil>(autoMockSettings);
}
private async Task <bool> RemoveDlFromServer(DlBook localDlBook, UserCredential userCredential)
{
// in consideration of deleting dlbook in offline mode
int deleteVersion = localDlBook.LastDownloadedVersion == 0 ? localDlBook.CurrentVersion : localDlBook.LastDownloadedVersion;
// Used to validate the Status Code given by eReader.
// Status Code : 1 => DL file Successfully downloaded by eReader.
// Status Code : 2 => DL file deleted by the user.
// Status Code : 3 => DL file deleted by eReader(backend).
string dlDeletedStatus = "2";
DlFileStatusUpdate dlFileStatusUpdate = new DlFileStatusUpdate
{
DeviceId = GlobalAccess.DeviceId,
Email = userCredential.Email,
DLId = localDlBook.BookId,
Ver = deleteVersion.ToString(),
StatusCode = dlDeletedStatus
};
var updateResult = await deliveryService.DlFileStatusUpdate(dlFileStatusUpdate);
return(updateResult);
}
private async Task EnforceRefreshCurrentPublicationByDlBook(DlBook dlBook)
{
//dlBook = new DlBook { BookId = 1, Author = "Allen", Email = "*****@*****.**", ServiceCode = "AUNZ", DlStatus = (short)DlStatusEnum.Downloaded, CurrencyDate = DateTime.Now, Description = "在程序开发的世界里，各路前辈们为了提高所谓的编码速度，搞出了各式各样的代码生成器，来避免所谓的重复的人为机械地粘贴和复制", Name = "枢纽", ColorPrimary = "#00FF00", ColorSecondary = "#C0C0C0", FontColor = "#000000", DpsiCode = "0299" };
//if (dlBook != null)
//{
// var contentKey = await dlBook.GetContentKey(GlobalAccess.Instance.CurrentUserInfo.SymmetricKey);
// var publicationContent = new PublicationContent(dlBook, contentKey);
// publicationContent.HasPage = packageAccess.HasPage(publicationContent.DecryptedDbFullName);
// if (publicationContent.HasPage)
// {
// publicationContent.Pages = packageAccess.GetPageList(publicationContent.DecryptedDbFullName);
// }
// GlobalAccess.Instance.CurrentPublication = publicationContent;
//}
//else
//{
// Logger.Log("RefreshCurrentPublication DlBookNoneExistsException");
// //throw new DlBookNoneExistsException();
//}
}
public Task <Dictionary <string, string> > GetContentDataFromTOC(int bookId, TOCNode tocNode, bool performSaveHistory = true, bool renderHyperlink = true)
{
return(Task.Run(async() =>
{
string content = string.Empty;
Dictionary <string, string> contentDic = new Dictionary <string, string>();
try
{
await RefreshCurrentPublication(bookId);
currentBook = GlobalAccess.Instance.CurrentPublication.DlBook;
var dbpath = GlobalAccess.Instance.CurrentPublication.DecryptedDbFullName;
var tOCNodeDetails = publicationContentService.GetTOCNodeDetails(tocNode.ID, dbpath);
if (tOCNodeDetails != null)
{
foreach (var tOCNodeDetail in tOCNodeDetails)
{
content = await GlobalAccess.Instance.CurrentPublication.DecryptTOCContent(tOCNodeDetail.FileName);
if (renderHyperlink)
{
content = RenderHyperLink(content, bookId);
}
content = GlobalAccess.Instance.CurrentPublication.UpdateContentImgSrcValue(content);
contentDic.Add(tOCNodeDetail.DocID, content);
}
if (performSaveHistory)
{
publicationContentService.SaveRecentHistory(tocNode.ID,
tocNode.Title,
GlobalAccess.Instance.Email,
GlobalAccess.Instance.ServiceCode);
}
}
}
catch (Exception ex)
{
Logger.Log("GetContentFromTOC:" + ex.ToString());
}
return contentDic;
}));
}
public void Test_Init()
{
Stopwatch time = new Stopwatch();
time.Start();
TestInit.Init().Wait();
LoginUtil.Instance.ValidateUserLogin(TestHelper.TestUsers[0].UserName, TestHelper.TestUsers[0].Password, TestHelper.TestUsers[0].CountryCode).Wait();
DlBook dlBook = new DlBook
{
BookId = 111,
InitVector = "QDFCMmMzRDRlNUY2ZzdIOA==",
K2Key = "MXdi9JQDDUY1hf5TZCEHjeBtjKL605dInVG3xYTF76U=",
HmacKey = "9jU0MAYPOPufUZoZJCW7qhsQe20=",
LastDownloadedVersion = 1,
ServiceCode = GlobalAccess.Instance.CurrentUserInfo.Country.CountryCode,
Email = GlobalAccess.Instance.CurrentUserInfo.Email
};
var contentKey = dlBook.GetContentKey(GlobalAccess.Instance.CurrentUserInfo.SymmetricKey).Result;
GlobalAccess.Instance.CurrentPublication = new PublicationContent(dlBook, contentKey);
time.Stop();
Console.Out.WriteLine("Time : " + time.ElapsedMilliseconds);
}
public void Test_Init()
{
Stopwatch time = new Stopwatch();
time.Start();
TestInit.Init().Wait();
LoginUtil.Instance.ValidateUserLogin(TestHelper.TestUsers[0].UserName, TestHelper.TestUsers[0].Password, TestHelper.TestUsers[0].CountryCode).Wait();
DlBook dlBook = new DlBook
{
BookId = 41,
InitVector = "QDFCMmMzRDRlNUY2ZzdIOA==",
K2Key = "PhlFIzSW3nR9Vq6wg1g3bwqN9uAz0IqBdlJDobzzEUI=",
HmacKey = "+wlxbpoqFZ1h0dMv9p/mmqAdJ9Y=",
LastDownloadedVersion = 1,
ServiceCode = GlobalAccess.Instance.CurrentUserInfo.Country.CountryCode,
Email = GlobalAccess.Instance.CurrentUserInfo.Email
};
var contentKey = dlBook.GetContentKey(GlobalAccess.Instance.CurrentUserInfo.SymmetricKey).Result;
GlobalAccess.Instance.CurrentPublication = new PublicationContent(dlBook, contentKey);
time.Stop();
Console.Out.WriteLine("Time : " + time.ElapsedMilliseconds);
}
public void Test_Init()
{
Stopwatch time = new Stopwatch();
time.Start();
TestInit.Init().Wait();
LoginUtil.Instance.ValidateUserLogin(TestHelper.TestUsers[0].UserName, TestHelper.TestUsers[0].Password, TestHelper.TestUsers[0].CountryCode).Wait();
DlBook dlBook = new DlBook
{
BookId = 26,
InitVector = "QDFCMmMzRDRlNUY2ZzdIOA==",
K2Key = "Kd7qQHCj9qT05gDAAAgXsj74kxQpHA2r2Flf3FH7XLQ=",
HmacKey = "7PPPQbvLEVsMRwpXJJqQv49fU7c=",
LastDownloadedVersion = 18,
ServiceCode = GlobalAccess.Instance.CurrentUserInfo.Country.ServiceCode,
// CountryCode = GlobalAccess.Instance.CurrentUserInfo.Country.CountryCode,
Email = GlobalAccess.Instance.CurrentUserInfo.Email
};
var contentKey = dlBook.GetContentKey(GlobalAccess.Instance.CurrentUserInfo.SymmetricKey).Result;
GlobalAccess.Instance.CurrentPublication = new PublicationContent(dlBook, contentKey);
time.Stop();
Console.Out.WriteLine("Time : " + time.ElapsedMilliseconds);
}
public async Task DownLoadDlBook(DlBook serverDlBook, CancellationToken cancelToken, DownloadProgressEventHandler downloadHandler)
{
var downLoadSuccess = await deliveryService.DlFileDownload(serverDlBook, cancelToken, downloadHandler);
if (!downLoadSuccess)
{
throw new Exception("DlFileDownload failure");
}
DlFileStatusUpdate dlFileStatusUpdate = new DlFileStatusUpdate
{
DeviceId = GlobalAccess.DeviceId,
Email = GlobalAccess.Instance.CurrentUserInfo.Email,
//DLId = serverDlBook.BookId,
Ver = serverDlBook.CurrentVersion.ToString(),
StatusCode = ((int)DlStatusEnum.Downloaded).ToString()
};
var updateSuccess = await deliveryService.DlFileStatusUpdate(dlFileStatusUpdate, cancelToken);
if (!updateSuccess)
{
throw new Exception("DlFileStatusUpdate failure");
}
}
public void InsertDlBook(DlBook newBook)
{
Insert <DlBook>(MainDbPath, newBook);
}
public int Update(DlBook entity)
{
return(Update <DlBook>(MainDbPath, entity));
}
public PublicationOpeningEvent(DlBook dlBook, bool enforceUpdate)
{
DlBook = dlBook;
EnforceUpdate = enforceUpdate;
}
public async Task <bool> DlFileDownload(DlBook dlBook, CancellationToken cancellationToken, DownloadProgressEventHandler downloadHandler)
{
return(await ServiceAgent.RestFullServiceRequestForFileDownload(dlBook, cancellationToken, downloadHandler));
}
public async Task <DownloadResult> DownloadPublicationByBookId(int bookId, CancellationToken cancelToken
, DownloadProgressEventHandler downloadHandler
, bool checkNetLimitation = true)
{
DownloadResult downloadResult = new DownloadResult {
DownloadStatus = DownLoadEnum.Failure
};
DlBook localDlBook = null, serverDlBook = null;
int previousDownloadVersion = 0;
try
{
var currentUser = GlobalAccess.Instance.CurrentUserInfo;
var userCredential = GlobalAccess.Instance.UserCredential;
await redLock.Enter().WithCancellation(cancelToken);
var pingSuccess = await connectionMonitor.PingService(currentUser.Country.CountryCode, cancelToken);
if (!pingSuccess)
{
downloadResult.DownloadStatus = DownLoadEnum.NetDisconnected;
return(downloadResult);
}
serverDlBook = await publicationDomainService.GetLatestDlBookDetail(userCredential,
GlobalAccess.DeviceId,
bookId,
cancelToken);
if (checkNetLimitation)
{
publicationDomainService.VerifyNetwork(serverDlBook.Size);
}
await publicationDomainService.DownLoadDlBook(serverDlBook, cancelToken, downloadHandler)
.WithCancellation(cancelToken);
localDlBook = publicationAccess.GetDlBookByBookId(bookId, userCredential);
previousDownloadVersion = localDlBook.LastDownloadedVersion;
localDlBook = await publicationDomainService.RefreshLocalDlBook(serverDlBook, localDlBook, GlobalAccess.DeviceId)
.WithCancellation <DlBook>(cancelToken);
if (downloadHandler != null)
{
downloadHandler(90, serverDlBook.Size);
await publicationDomainService.InstallDlBook(localDlBook, currentUser.SymmetricKey, cancelToken);
downloadResult.Publication = localDlBook.ToPublication();
await DomainEvents.Publish <DownloadCompletedEvent>(new DownloadCompletedEvent(localDlBook, RecenthistoryChanged));
bool updateSuccess = (publicationAccess.Update(localDlBook) > 0);
if (updateSuccess)
{
downloadResult.DownloadStatus = DownLoadEnum.Success;
}
await ClearDownloadedFiles(localDlBook, downloadResult.DownloadStatus, previousDownloadVersion);
downloadHandler(100, serverDlBook.Size);
}
}
catch (NullUserException)
{
}
catch (ExceedLimitationException)
{
downloadResult.DownloadStatus = DownLoadEnum.OverLimitation;
}
catch (OperationCanceledException)
{
if (cancelToken.IsCancellationRequested)
{
downloadResult.DownloadStatus = DownLoadEnum.Canceled;
}
}
catch (CusNetDisConnectedException)
{
downloadResult.DownloadStatus = DownLoadEnum.NetDisconnected;
}
catch (Exception ex)
{
Logger.Log("DownloadPublicationByBookId:" + ex.ToString());
}
finally
{
redLock.Release();
ClearDownloadedFiles(localDlBook, downloadResult.DownloadStatus, previousDownloadVersion).Wait();
}
return(downloadResult);
}
