private void ResetData()
{
RestartRequired = false;
DisablePropertyChange();
PropertyInfo[] UserConfigurationProperties = typeof(UserConfigurationObject).GetProperties();
foreach (PropertyInfo Property in UserConfigurationProperties)
{
Property.SetValue(UserConfiguration, Property.GetValue(App.CORE.UserConfiguration));
}
SiteExtensionObjects.Clear();
DatabaseExtensionObjects.Clear();
// Load Extensions
IEnumerable <EnabledExtensionObject> EnabledSiteExtensionObjects = UserConfiguration.EnabledExtensions.Where(ext => Equals(ext.ExtensionType, typeof(ISiteExtension).Name));
IEnumerable <EnabledExtensionObject> EnabledDatabaseExtensionObjects = UserConfiguration.EnabledExtensions.Where(ext => Equals(ext.ExtensionType, typeof(IDatabaseExtension).Name));
foreach (EnabledExtensionObject EnabledSiteExtensionObject in EnabledSiteExtensionObjects)
{
ISiteExtension SiteExtension = App.CORE.SiteExtensions[EnabledSiteExtensionObject.Name, EnabledSiteExtensionObject.Language];
SiteExtensionObjects.Add(new ExtensionObject(SiteExtension, EnabledSiteExtensionObject.Enabled));
}
foreach (ISiteExtension SiteExtension in App.CORE.SiteExtensions)
{
String Name = String.Format("{0} ({1})", SiteExtension.ExtensionDescriptionAttribute.Name, SiteExtension.ExtensionDescriptionAttribute.Language);
ExtensionObject SiteExtensionObject = SiteExtensionObjects.FirstOrDefault(seo => Equals(seo.Name, Name));
if (Equals(SiteExtensionObject, null))
{
SiteExtensionObjects.Add(new ExtensionObject(SiteExtension, false));
}
}
foreach (EnabledExtensionObject EnabledDatabaseExtensionObject in EnabledDatabaseExtensionObjects)
{
IDatabaseExtension DatabaseExtension = App.CORE.DatabaseExtensions[EnabledDatabaseExtensionObject.Name, EnabledDatabaseExtensionObject.Language];
DatabaseExtensionObjects.Add(new ExtensionObject(DatabaseExtension, EnabledDatabaseExtensionObject.Enabled));
}
foreach (IDatabaseExtension DatabaseExtension in App.CORE.DatabaseExtensions)
{
String Name = String.Format("{0} ({1})", DatabaseExtension.ExtensionDescriptionAttribute.Name, DatabaseExtension.ExtensionDescriptionAttribute.Language);
ExtensionObject DatabaseExtensionObject = DatabaseExtensionObjects.FirstOrDefault(seo => Equals(seo.Name, Name));
if (Equals(DatabaseExtensionObject, null))
{
DatabaseExtensionObjects.Add(new ExtensionObject(DatabaseExtension, false));
}
}
MangaCount = App.MangaCacheObjects.Count(mco =>
Equals(mco.MangaObject.MangaType, MangaObjectType.Manga));
ManhwaCount = App.MangaCacheObjects.Count(mco =>
Equals(mco.MangaObject.MangaType, MangaObjectType.Manhua));
ManhwaCount += App.MangaCacheObjects.Count(mco =>
Equals(mco.MangaObject.MangaType, MangaObjectType.Manhwa));
UnknownCount = App.MangaCacheObjects.Count(mco =>
Equals(mco.MangaObject.MangaType, MangaObjectType.Unknown));
TotalCount = MangaCount + ManhwaCount + UnknownCount;
EnablePropertyChange();
}
public async Task DownloadAsync(MangaObject MangaObject, ChapterObject ChapterObject, PageObject PageObject, IProgress <Int32> ProgressReporter = null)
{
String CK = CacheKey(MangaObject, ChapterObject, PageObject);
if (ActiveDownloadsCache.Contains(CK))
{
return;
}
ActiveDownloadsCache.Set(CK, true, DateTimeOffset.MaxValue);
try
{
// Only load page from we if ImgUrl is empty.
if (String.IsNullOrWhiteSpace(PageObject.ImgUrl))
{
await Task.Delay(TimeSpan.FromSeconds(1));
// Load the PageObject via Async and LimitedTaskFactory
PageObject = await ContentTaskFactory.StartNew(() => LoadPageObjectAsync(
MangaObject,
ChapterObject,
PageObject,
cts.Token,
ProgressReporter)).Unwrap();
ChapterObject = await StorePageObject(MangaObject, ChapterObject, PageObject);
}
ISiteExtension SiteExtension = CORE.SiteExtensions.First(_SiteExtension =>
{ return(PageObject.Url.Contains(_SiteExtension.ExtensionDescriptionAttribute.URLFormat)); });
// Start the DownloadImage task, don't wait.
DownloadImage(PageObject.ImgUrl, PageObject.Url, SiteExtension.Cookies, SavePath(MangaObject, ChapterObject), Path.GetFileName(new Uri(PageObject.ImgUrl).LocalPath));
}
catch (Exception ex)
{
if (!Equals(CORE.Logger, null))
{
CORE.Logger.Warn(String.Format("[ContentDownloadManager] An exception was thrown while processing {0}.", MangaObject.Name), ex);
}
throw ex;
}
finally
{
if (!Equals(ProgressReporter, null))
{
ProgressReporter.Report(100);
}
ActiveDownloadsCache.Remove(CK);
}
}
private async Task <PageObject> LoadPageObjectAsync(MangaObject MangaObject, ChapterObject ChapterObject, PageObject PageObject, CancellationToken ct, IProgress <Int32> progress)
{
try
{
await TaskConcurrencySemaphore.WaitAsync(ct);
ct.ThrowIfCancellationRequested();
ISiteExtension SiteExtension = CORE.SiteExtensions.First(_SiteExtension => PageObject.Url.Contains(_SiteExtension.ExtensionDescriptionAttribute.URLFormat));
using (WebDownloader WebDownloader = new WebDownloader(SiteExtension.Cookies))
{
WebDownloader.Referer = SiteExtension.ExtensionDescriptionAttribute.RefererHeader;
DownloadProgressChangedEventHandler ProgressEventHandler = (s, e) =>
{
if (!Equals(progress, null))
{
progress.Report((Int32)Math.Round((Double)e.ProgressPercentage * 0.9));
}
ct.ThrowIfCancellationRequested();
};
WebDownloader.DownloadProgressChanged += ProgressEventHandler;
String PageWebContent = await WebDownloader.DownloadStringTaskAsync(PageObject.Url).Retry(DOWNLOAD_TIMEOUT);
PageObject = SiteExtension.ParsePageObject(PageWebContent);
WebDownloader.DownloadProgressChanged -= ProgressEventHandler;
}
if (!Equals(progress, null))
{
progress.Report(100);
}
return(PageObject);
}
finally { TaskConcurrencySemaphore.Release(); }
}
static MangaObject LoadMangaObject(String Link, ISiteExtension ise)
{
MangaObject MangaObj = null;
ISiteExtensionDescriptionAttribute isea = ise.GetType().GetCustomAttribute<ISiteExtensionDescriptionAttribute>(false);
HttpWebRequest request = WebRequest.Create(Link) as HttpWebRequest;
request.Referer = isea.RefererHeader ?? request.Host;
request.AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip;
using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)
{
using (StreamReader streamReader = new StreamReader(response.GetResponseStream()))
{
MangaObj = ise.ParseMangaObject(streamReader.ReadToEnd());
MangaObj.Locations.Add(new LocationObject() { ExtensionName = isea.Name, Url = Link });
}
}
return MangaObj;
}
private async Task <List <MangaObject> > SearchMangaObjectAsync(String SearchTerm, CancellationToken ct, IProgress <Int32> progress)
{
List <MangaObject> SearchResults = new List <MangaObject>();
if (!Equals(progress, null))
{
progress.Report(5);
}
Boolean firstResponse = true;
IEnumerable <Task <ExtensionContentResult> > ExtensionContentTasksQuery =
from Extension in ValidExtensions(CORE.Extensions, CORE.UserConfiguration.EnabledExtensions)
select LoadExtensionSearchContent(Extension, SearchTerm);
List <Task <ExtensionContentResult> > ExtensionContentTasks = ExtensionContentTasksQuery.ToList();
Int32 OriginalExtensionContentTasksCount = ExtensionContentTasks.Count;
if (!Equals(progress, null))
{
progress.Report(10);
}
while (ExtensionContentTasks.Count > 0)
{ // Load Content via Async and process as they complete.
ct.ThrowIfCancellationRequested();
Task <ExtensionContentResult> completedTask = await Task.WhenAny(ExtensionContentTasks);
ExtensionContentTasks.Remove(completedTask);
ct.ThrowIfCancellationRequested();
ExtensionContentResult LoadedExtensionContentResult = await completedTask;
if (!Equals(LoadedExtensionContentResult, null))
{
String Content = LoadedExtensionContentResult.Content;
if (LoadedExtensionContentResult.Extension is ISiteExtension)
{ // Extension was a ISiteExtension
ISiteExtension SiteExtension = LoadedExtensionContentResult.Extension as ISiteExtension;
List <SearchResultObject> SearchResultObjects = SiteExtension.ParseSearch(Content);
foreach (SearchResultObject SearchResultObject in SearchResultObjects)
{
MangaObject MangaObject = SearchResultObject.ConvertToMangaObject(),
ExistingMangaObject = SearchResults.FirstOrDefault(_MangaObject =>
{ // Locate an Existing MangaObject
List <String> ExistingMangaObjectNames = new List <String>(_MangaObject.AlternateNames),
MangaObjectNames = new List <String>(MangaObject.AlternateNames);
ExistingMangaObjectNames.Insert(0, _MangaObject.Name);
MangaObjectNames.Insert(0, MangaObject.Name);
ExistingMangaObjectNames = ExistingMangaObjectNames.Select(_ExistingMangaObjectName => SafeAlphaNumeric.Replace(_ExistingMangaObjectName.ToLower(), String.Empty)).ToList();
MangaObjectNames = MangaObjectNames.Select(_MangaObjectNames => SafeAlphaNumeric.Replace(_MangaObjectNames.ToLower(), String.Empty)).ToList();
return(ExistingMangaObjectNames.Intersect(MangaObjectNames).Any());
});
if (Equals(ExistingMangaObject, null))
{
SearchResults.Add(MangaObject);
}
else
{
ExistingMangaObject.Merge(MangaObject);
}
}
}
else if (LoadedExtensionContentResult.Extension is IDatabaseExtension)
{ // Extension was a IDatabaseExtension
IDatabaseExtension DatabaseExtension = LoadedExtensionContentResult.Extension as IDatabaseExtension;
List <DatabaseObject> DatabaseObjects = DatabaseExtension.ParseSearch(Content);
foreach (DatabaseObject DatabaseObject in DatabaseObjects)
{
MangaObject ExistingMangaObject = SearchResults.FirstOrDefault(_MangaObject =>
{ // Locate an Existing MangaObject
List <String> ExistingMangaObjectNames = new List <String>(_MangaObject.AlternateNames),
DatabaseObjectNames = new List <String>(DatabaseObject.AlternateNames);
ExistingMangaObjectNames.Insert(0, _MangaObject.Name);
DatabaseObjectNames.Insert(0, DatabaseObject.Name);
ExistingMangaObjectNames = ExistingMangaObjectNames.Select(_ExistingMangaObjectName => SafeAlphaNumeric.Replace(_ExistingMangaObjectName.ToLower(), String.Empty)).ToList();
DatabaseObjectNames = DatabaseObjectNames.Select(_DatabaseObjectNames => SafeAlphaNumeric.Replace(_DatabaseObjectNames.ToLower(), String.Empty)).ToList();
Int32 IntersectCount = ExistingMangaObjectNames.Intersect(DatabaseObjectNames).Count(),
ExistingHalfCount = (Int32)Math.Ceiling((Double)ExistingMangaObjectNames.Count / 2);
return(IntersectCount >= ExistingHalfCount);
});
if (Equals(ExistingMangaObject, null))
{
MangaObject databaseMangaObject = new MangaObject();
databaseMangaObject.AttachDatabase(DatabaseObject, true, true);
SearchResults.Add(databaseMangaObject);
}
else
{
if (Equals(ExistingMangaObject.DatabaseLocations.FindIndex(_DatabaseLocation => Equals(
_DatabaseLocation.ExtensionName,
DatabaseExtension.ExtensionDescriptionAttribute.Name)), -1))
{
ExistingMangaObject.AttachDatabase(DatabaseObject, preferDatabaseDescription: true);
}
}
}
}
}
firstResponse = Equals(SearchResults.Count, 0);
Int32 ExtensionContentTasksProgress = (Int32)Math.Round(((Double)(OriginalExtensionContentTasksCount - ExtensionContentTasks.Count) / (Double)OriginalExtensionContentTasksCount) * 70);
if (!Equals(progress, null))
{
progress.Report(10 + ExtensionContentTasksProgress);
}
}
if (!Equals(progress, null))
{
progress.Report(85);
}
ct.ThrowIfCancellationRequested();
// Remove Database only results
Int32 RemoveCount = SearchResults.RemoveAll(_ => Equals(_.Locations.Count, 0));
if (!Equals(progress, null))
{
progress.Report(100);
}
ct.ThrowIfCancellationRequested();
return(SearchResults);
}
private async Task <ChapterObject> LoadChapterObjectAsync(MangaObject MangaObject, ChapterObject ChapterObject, CancellationToken ct, IProgress <Int32> progress)
{
try
{
await TaskConcurrencySemaphore.WaitAsync(ct);
ct.ThrowIfCancellationRequested();
// Store valid ISiteExtension
IEnumerable <ISiteExtension> ValidSiteExtensions = ValidExtensions(CORE.SiteExtensions, CORE.UserConfiguration.EnabledExtensions).Cast <ISiteExtension>();
// Re-Order the Chapter's LocationObjects to the EnabledExtensions order.
IEnumerable <LocationObject> OrderedChapterObjectLocations = from EnExt in CORE.UserConfiguration.EnabledExtensions
where ChapterObject.Locations.Exists(LocObj => EnExt.EqualsLocationObject(LocObj))
select ChapterObject.Locations.FirstOrDefault(LocObj => EnExt.EqualsLocationObject(LocObj));
foreach (LocationObject LocationObject in OrderedChapterObjectLocations)
{
ct.ThrowIfCancellationRequested();
ISiteExtension SiteExtension = ValidSiteExtensions.FirstOrDefault(_ => LocationObjectExtension(_, LocationObject));
if (Equals(SiteExtension, null))
{
continue; // Continue with the foreach loop
}
ct.ThrowIfCancellationRequested();
using (WebDownloader WebDownloader = new WebDownloader(SiteExtension.Cookies))
{
WebDownloader.Encoding = System.Text.Encoding.UTF8;
WebDownloader.Referer = SiteExtension.ExtensionDescriptionAttribute.RefererHeader;
DownloadProgressChangedEventHandler ProgressEventHandler = (s, e) =>
{
if (!Equals(progress, null))
{
progress.Report((Int32)Math.Round((Double)e.ProgressPercentage * 0.9));
}
ct.ThrowIfCancellationRequested();
};
WebDownloader.DownloadProgressChanged += ProgressEventHandler;
String ChapterWebContent = await WebDownloader.DownloadStringTaskAsync(LocationObject.Url).Retry(DOWNLOAD_TIMEOUT);
ChapterObject DownloadedChapterObject = SiteExtension.ParseChapterObject(ChapterWebContent);
WebDownloader.DownloadProgressChanged -= ProgressEventHandler;
ct.ThrowIfCancellationRequested();
if (!Equals(DownloadedChapterObject, null))
{
ChapterObject.Merge(DownloadedChapterObject);
ChapterObject.Pages = DownloadedChapterObject.Pages;
break; // Break free of the foreach loop
}
}
}
if (!Equals(progress, null))
{
progress.Report(100);
}
ct.ThrowIfCancellationRequested();
return(ChapterObject);
}
finally { TaskConcurrencySemaphore.Release(); }
}
