public static async Task <IRandomAccessStream> OpenPdfFile(LibrelioLocalUrl url)
{
StorageFolder folder = null;
try {
folder = await StorageFolder.GetFolderFromPathAsync(url.FolderPath);
} catch { }
if (folder == null)
{
return(null);
}
var path = !url.IsSampleDownloaded ? url.FullName : url.FullName.Replace("_.", ".");
StorageFile file = null;
try {
file = await folder.GetFileAsync(path);
} catch { }
if (file == null)
{
return(null);
}
var stream = await file.OpenAsync(FileAccessMode.Read);
return(await UnprotectPDFStream(stream));
}
public static LibrelioLocalUrl DeleteLocalUrl(LibrelioLocalUrl url)
{
url.MetadataName = "";
url.FolderPath = "ND";
url.IsSampleDownloaded = false;
return(url);
}
public static LibrelioUrl ConvertFromLocalUrl(LibrelioLocalUrl url)
{
var mag = new LibrelioUrl(url.Index, url.Url.Replace(url.RelativePath, ""), url.RelativePath);
mag.Title = url.Title;
mag.Subtitle = url.Subtitle;
return(mag);
}
private bool UpdataLocalUrlDownloaded(LibrelioLocalUrl url)
{
foreach (var local in _magazinesLocalUrlDownloaded)
{
if (local.FullName == url.FullName)
{
var i = _magazinesLocalUrlDownloaded.IndexOf(local);
_magazinesLocalUrlDownloaded[i] = url;
return true;
}
}
return false;
}
public async Task RemoveDownloadedMetadataEntry(LibrelioLocalUrl magLocal)
{
if (localDownloadedXml == null)
await LoadLocalMetadataDownloaded();
string xpath = "/root/mag[url='" + magLocal.Url + "']";
var mags = localDownloadedXml.SelectNodes(xpath);
if (mags.Count > 0)
{
var parent = mags[0].ParentNode;
parent.RemoveChild(mags[0]);
}
var xmlfile = await _folder.CreateFileAsync("magazines_downloaded.metadata", CreationCollisionOption.OpenIfExists);
await localDownloadedXml.SaveToFileAsync(xmlfile);
}
public async Task AddUpdateMetadataDownloadedEntry(LibrelioLocalUrl magLocal)
{
if (localDownloadedXml == null)
await LoadLocalMetadataDownloaded();
string xpath = "/root/mag[url='" + magLocal.Url + "']";
var mags = localDownloadedXml.SelectNodes(xpath);
if (mags.Count > 0)
{
mags[0].SelectNodes("index")[0].InnerText = magLocal.Index.ToString();
if (magLocal.Title == null) magLocal.Title = "";
mags[0].SelectNodes("title")[0].InnerText = magLocal.Title;
if (magLocal.Subtitle == null) magLocal.Subtitle = "";
mags[0].SelectNodes("subtitle")[0].InnerText = magLocal.Subtitle;
if (magLocal.FolderPath != "ND")
{
mags[0].SelectNodes("path")[0].InnerText = magLocal.FolderPath + magLocal.FullName;
mags[0].SelectNodes("metadata")[0].InnerText = magLocal.FolderPath + magLocal.MetadataName;
}
else
{
mags[0].SelectNodes("path")[0].InnerText = "ND";
mags[0].SelectNodes("metadata")[0].InnerText = "ND";
}
mags[0].SelectNodes("url")[0].InnerText = magLocal.Url;
mags[0].SelectNodes("relPath")[0].InnerText = magLocal.RelativePath;
mags[0].SelectNodes("sampledownloaded")[0].InnerText = magLocal.IsSampleDownloaded ? "true" : "false";
}
else
{
var mag = localDownloadedXml.CreateElement("mag");
var index = localDownloadedXml.CreateElement("index");
index.InnerText = magLocal.Index.ToString();
mag.AppendChild(index);
var title = localDownloadedXml.CreateElement("title");
if (magLocal.Title == null) magLocal.Title = "";
title.InnerText = magLocal.Title;
mag.AppendChild(title);
var subtitle = localDownloadedXml.CreateElement("subtitle");
if (magLocal.Subtitle == null) magLocal.Subtitle = "";
subtitle.InnerText = magLocal.Subtitle;
mag.AppendChild(subtitle);
var path = localDownloadedXml.CreateElement("path");
if (magLocal.FolderPath != "ND")
path.InnerText = magLocal.FolderPath + magLocal.FullName;
else
path.InnerText = "ND";
mag.AppendChild(path);
var metadata = localDownloadedXml.CreateElement("metadata");
if (magLocal.FolderPath != "ND")
metadata.InnerText = magLocal.FolderPath + magLocal.MetadataName;
else
metadata.InnerText = "ND";
mag.AppendChild(metadata);
var url = localDownloadedXml.CreateElement("url");
url.InnerText = magLocal.Url;
mag.AppendChild(url);
var relPath = localDownloadedXml.CreateElement("relPath");
relPath.InnerText = magLocal.RelativePath;
mag.AppendChild(relPath);
var isd = localDownloadedXml.CreateElement("sampledownloaded");
isd.InnerText = magLocal.IsSampleDownloaded ? "true" : "false";
mag.AppendChild(isd);
localDownloadedXml.GetElementsByTagName("root")[0].AppendChild(mag);
}
var xmlfile = await _folder.CreateFileAsync("magazines_downloaded.metadata", CreationCollisionOption.OpenIfExists);
await localDownloadedXml.SaveToFileAsync(xmlfile);
}
public async Task<IRandomAccessStream> DownloadMagazineAsync(LibrelioLocalUrl magUrl, StorageFolder folder, IProgress<int> progress = null, CancellationToken cancelToken = default(CancellationToken))
{
StatusText = "Download in progress";
var stream = await DownloadPDFAsync(magUrl, folder, progress, cancelToken);
if (stream == null || cancelToken.IsCancellationRequested) return null;
await GetUrlsFromPDF(stream);
StatusText = "Downloading 2/" + (links.Count + 1);
magUrl.FolderPath = folder.Path + "\\";
//var url = DownloadManager.ConvertToLocalUrl(magUrl, folder);
if (magUrl != null)
{
await DownloadPDFAssetsAsync(magUrl, links, progress, cancelToken);
}
StatusText = "Done";
return stream;
}
public static async Task<IRandomAccessStream> OpenPdfFile(LibrelioLocalUrl url)
{
StorageFolder folder = null;
try {
folder = await StorageFolder.GetFolderFromPathAsync(url.FolderPath);
} catch { }
if (folder == null) return null;
var path = !url.IsSampleDownloaded ? url.FullName : url.FullName.Replace("_.", ".");
StorageFile file = null;
try {
file = await folder.GetFileAsync(path);
} catch { }
if (file == null) return null;
var stream = await file.OpenAsync(FileAccessMode.Read);
return await UnprotectPDFStream(stream);
}
public static LibrelioUrl ConvertFromLocalUrl(LibrelioLocalUrl url)
{
var mag = new LibrelioUrl(url.Index, url.Url.Replace(url.RelativePath, ""), url.RelativePath);
mag.Title = url.Title;
mag.Subtitle = url.Subtitle;
return mag;
}
public async Task<IRandomAccessStream> DownloadPDFAsync(LibrelioLocalUrl magUrl, StorageFolder folder, IProgress<int> progress = null, CancellationToken cancelToken = default(CancellationToken))
{
//HttpClient client = new HttpClient();
//HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, magUrl.Url);
//int read = 0;
//int offset = 0;
//byte[] responseBuffer = new byte[1024];
//var response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancelToken);
//response.EnsureSuccessStatusCode();
//var length = response.Content.Headers.ContentLength;
//cancelToken.ThrowIfCancellationRequested();
//var stream = new InMemoryRandomAccessStream();
//using (var responseStream = await response.Content.ReadAsStreamAsync())
//{
// do
// {
// cancelToken.ThrowIfCancellationRequested();
// read = await responseStream.ReadAsync(responseBuffer, 0, responseBuffer.Length);
// cancelToken.ThrowIfCancellationRequested();
// await stream.AsStream().WriteAsync(responseBuffer, 0, read);
// offset += read;
// uint val = (uint)(offset * 100 / length);
// if (val >= 100) val = 99;
// if (val <= 0) val = 1;
// progress.Report((int)val);
// }
// while (read != 0);
//}
//progress.Report(100);
//await stream.FlushAsync();
////var folder = await AddMagazineFolderStructure(magUrl);
////var folder = await StorageFolder.GetFolderFromPathAsync(folderUrl);
var file = await folder.CreateFileAsync(magUrl.FullName, CreationCollisionOption.ReplaceExisting);
//using (var protectedStream = await DownloadManager.ProtectPDFStream(stream))
//using (var fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite))
////using (var unprotectedStream = await DownloadManager.UnprotectPDFStream(protectedStream))
//{
// await RandomAccessStream.CopyAsync(protectedStream, fileStream.GetOutputStreamAt(0));
// await fileStream.FlushAsync();
//}
progress.Report(0);
BackgroundDownloader downloader = new BackgroundDownloader();
DownloadOperation download = downloader.CreateDownload(new Uri(magUrl.Url), file);
await HandleDownloadAsync(download, true, progress, cancelToken);
progress.Report(100);
var stream = await download.ResultFile.OpenAsync(FileAccessMode.ReadWrite);
var protectedStram = await DownloadManager.ProtectPDFStream(stream);
await RandomAccessStream.CopyAndCloseAsync(protectedStram.GetInputStreamAt(0), stream.GetOutputStreamAt(0));
await protectedStram.FlushAsync();
await stream.FlushAsync();
protectedStram.Dispose();
stream.Dispose();
var pdfStream = new MagazineData();
pdfStream.folderUrl = folder.Path + "\\";
pdfStream.stream = stream;
//var fileHandle =
// await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFileAsync(@"Assets\test\testmagazine.pdf");
//pdfStream.folderUrl = "C:\\Users\\Dorin\\Documents\\Magazines\\wind_355\\";
//pdfStream.stream = await fileHandle.OpenReadAsync();
return pdfStream.stream;
}
public async Task<IRandomAccessStream> DownloadMagazineAsync(LibrelioLocalUrl magUrl, string redirectUrl, StorageFolder folder, IProgress<int> progress = null, CancellationToken cancelToken = default(CancellationToken))
{
var loader = new ResourceLoader();
StatusText = loader.GetString("download_progress");
var tmpUrl = magUrl.Url;
magUrl.Url = redirectUrl;
var stream = await DownloadPDFAsync(magUrl, folder, progress, cancelToken);
magUrl.Url = tmpUrl;
if (stream == null || cancelToken.IsCancellationRequested) return null;
await GetUrlsFromPDF(stream);
StatusText = loader.GetString("downloading") + " 2/" + (links.Count + 1);
if (magUrl != null)
{
await DownloadPDFAssetsAsync(magUrl, links, progress, cancelToken);
}
StatusText = loader.GetString("done");
return stream;
}
public async Task<BitmapSource> DownloadThumbnailAsync(LibrelioLocalUrl magUrl, StorageFolder folder)
{
string s = ".";
if (magUrl.FullName.Contains("_."))
{
s = "_.";
}
var pos = magUrl.Url.LastIndexOf(s);
var url = magUrl.Url.Substring(0, pos) + ".png";
var stream = await DownloadManager.DownloadFileAsync(url);
await DownloadManager.StoreToFolderAsync(magUrl.FullName.Replace(s + "pdf", ".png"), folder, stream);
var bitmap = new BitmapImage();
try
{
await bitmap.SetSourceAsync(stream);
}
catch
{
bitmap = null;
}
return bitmap;
}
private async Task<StorageFile> DownloadPDFAssetsAsync(LibrelioLocalUrl magUrl, IList<string> list, IProgress<int> progress = null, CancellationToken cancelToken = default(CancellationToken))
{
var folder = await StorageFolder.GetFolderFromPathAsync(magUrl.FolderPath.Substring(0, magUrl.FolderPath.Length-1));
var file = await folder.CreateFileAsync(magUrl.MetadataName, CreationCollisionOption.ReplaceExisting);
var xml = new XmlDocument();
var root = xml.CreateElement("root");
var name = xml.CreateElement("name");
name.InnerText = magUrl.FullName;
var date = xml.CreateElement("date");
date.InnerText = DateTime.Today.Month.ToString() + "/" + DateTime.Today.Day.ToString() + "/" + DateTime.Today.Year.ToString();
xml.AppendChild(root);
root.AppendChild(name);
root.AppendChild(date);
await xml.SaveToFileAsync(file);
cancelToken.ThrowIfCancellationRequested();
for (int i = 0; i < list.Count; i++)
{
var loader = new ResourceLoader();
StatusText = loader.GetString("downloading") + " " + (i + 2) + "/" + (list.Count + 1);
var url = list[i];
cancelToken.ThrowIfCancellationRequested();
string absLink = url;
var pos = absLink.IndexOf('?');
if (pos >= 0) absLink = url.Substring(0, pos);
string fileName = absLink.Replace("http://localhost/", "");
string linkString = "";
linkString = folder.Path + "\\" + absLink.Replace("http://localhost/", "");
pos = magUrl.Url.LastIndexOf('/');
var assetUrl = magUrl.Url.Substring(0, pos + 1);
absLink = absLink.Replace("http://localhost/", assetUrl);
var sampleFile = await folder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);
await DownloadFileAsyncWithProgress(absLink, sampleFile, progress, cancelToken);
var asset = xml.CreateElement("asset");
asset.InnerText = linkString;
root.AppendChild(asset);
await xml.SaveToFileAsync(file);
}
return file;
}
public static LibrelioLocalUrl DeleteLocalUrl(LibrelioLocalUrl url)
{
url.MetadataName = "";
url.FolderPath = "ND";
return url;
}
public async Task MarkAsDownloaded(LibrelioLocalUrl magUrl, StorageFolder currentFolder)
{
if (currentFolder != _folder)
{
if (!UpdataLocalUrl(magUrl))
_magazinesLocalUrl.Add(magUrl);
await AddUpdateMetadataEntry(magUrl);
}
}
public async Task MarkAsDownloaded(LibrelioUrl magUrl, StorageFolder currentFolder, bool isd)
{
if (currentFolder != _folder)
{
var magLocal = new LibrelioLocalUrl(magUrl.Index, magUrl.Title, magUrl.Subtitle, currentFolder.Path + "\\",
magUrl.FullName, magUrl.AbsoluteUrl, magUrl.RelativeUrl, isd);
if (!UpdataLocalUrl(magLocal))
_magazinesLocalUrl.Add(magLocal);
await AddUpdateMetadataEntry(magLocal);
}
}
public static bool IsDownloaded(LibrelioLocalUrl url)
{
return(url.FolderPath != "ND");
}
public async Task MarkAsDownloaded(LibrelioUrl magUrl, StorageFolder currentFolder, bool isd)
{
if (currentFolder != _folder)
{
var magLocal = new LibrelioLocalUrl(magUrl.Index, magUrl.Title, magUrl.Subtitle, currentFolder.Path + "\\",
magUrl.FullName, magUrl.AbsoluteUrl, magUrl.RelativeUrl, isd);
if (!UpdataLocalUrlDownloaded(magLocal))
_magazinesLocalUrlDownloaded.Add(magLocal);
await AddUpdateMetadataDownloadedEntry(magLocal);
var items = _magazinesLocalUrl.Where(magazine => magazine.FullName.Equals(magLocal.FullName));
if (items != null && items.Count() > 0)
{
var magazine = items.First();
var index = _magazinesLocalUrl.IndexOf(magazine);
if (index == -1) return;
_magazinesLocalUrl[index] = magLocal;
}
}
}
public async Task MarkAsDownloaded(LibrelioLocalUrl magUrl, StorageFolder currentFolder)
{
if (currentFolder != _folder)
{
if (!UpdataLocalUrlDownloaded(magUrl))
_magazinesLocalUrlDownloaded.Add(magUrl);
await AddUpdateMetadataDownloadedEntry(magUrl);
var items = _magazinesLocalUrl.Where(magazine => magazine.FullName.Equals(magUrl.FullName));
if (items != null && items.Count() > 0)
{
var magazine = items.First();
var index = _magazinesLocalUrl.IndexOf(magazine);
if (index == -1) return;
_magazinesLocalUrl[index] = magUrl;
}
}
}
public async Task RemoveMagazineDownloaded(LibrelioLocalUrl magLocal)
{
await RemoveDownloadedMetadataEntry(magLocal);
_magazinesLocalUrlDownloaded.Remove(magLocal);
var items = _magazinesLocalUrl.Where(magazine => magazine.FullName.Equals(magLocal.FullName));
if (items != null && items.Count() > 0)
{
var magazine = items.First();
var index = _magazinesLocalUrl.IndexOf(magazine);
if (index == -1) return;
_magazinesLocalUrl[index] = DownloadManager.DeleteLocalUrl(magLocal);
}
}
public static bool IsDownloaded(LibrelioLocalUrl url)
{
return url.FolderPath != "ND";
}
public async Task<StorageFolder> AddMagazineFolderStructure(LibrelioLocalUrl magLocal)
{
var currentFolder = _folder;
var relUrl = magLocal.RelativePath;
var strs = relUrl.Split('/');
for (int i = 0; i < strs.Length - 1; i++)
{
var folder = strs[i];
if (folder != "")
{
try
{
var fld = await currentFolder.CreateFolderAsync(folder, CreationCollisionOption.OpenIfExists);
currentFolder = fld;
}
catch
{
return null;
}
}
}
if (currentFolder != _folder)
{
// var magLocal = new LibrelioLocalUrl(magUrl.Title, magUrl.Subtitle, currentFolder.Path + "\\",
// magUrl.FullName, magUrl.AbsoluteUrl, magUrl.RelativeUrl);
// if (!UpdataLocalUrl(magLocal))
// _magazinesLocalUrl.Add(magLocal);
// await AddUpdateMetadataEntry(magLocal);
return currentFolder;
}
return null;
}
public static LibrelioLocalUrl DeleteLocalUrl(LibrelioLocalUrl url)
{
url.MetadataName = "";
url.FolderPath = "ND";
url.IsSampleDownloaded = false;
return url;
}
public async Task<IRandomAccessStream> DownloadMagazineAsync(LibrelioLocalUrl magUrl, string redirectUrl, StorageFolder folder, IProgress<int> progress = null, CancellationToken cancelToken = default(CancellationToken))
{
StatusText = "Download in progress";
var tmpUrl = magUrl.Url;
magUrl.Url = redirectUrl;
var stream = await DownloadPDFAsync(magUrl, folder, progress, cancelToken);
magUrl.Url = tmpUrl;
await GetUrlsFromPDF(stream);
StatusText = "Downloading 2/" + (links.Count + 1);
if (magUrl != null)
{
await DownloadPDFAssetsAsync(magUrl, links, progress, cancelToken);
}
StatusText = "Done";
return stream;
}
