/// <summary>
/// Создать дефолтные настройки для новых типов.
/// </summary>
/// <param name="context">Контекст подключения к БД.</param>
/// <param name="databaseConfig">Настройки приложения.</param>
/// <returns>Коллекция всех настроек.</returns>
private static async Task CreateDefaultMangaSettings(RepositoryContext context, DatabaseConfig databaseConfig)
{
var settings = await context.Get <MangaSetting>().ToListAsync().ConfigureAwait(false);
var plugins = ConfigStorage.Plugins;
foreach (var plugin in plugins)
{
if (settings.Any(s => Equals(s.Manga, plugin.MangaGuid)))
{
continue;
}
var setting = new MangaSetting
{
Folder = AppConfig.DownloadFolderName,
Manga = plugin.MangaGuid,
MangaName = plugin.Name,
DefaultCompression = Compression.CompressionMode.Manga,
ProxySetting = await context.Get <ProxySetting>().SingleAsync(s => s.SettingType == ProxySettingType.Parent).ConfigureAwait(false),
Login = await Login.Get(plugin.LoginType).ConfigureAwait(false)
};
await context.Save(setting).ConfigureAwait(false);
settings.Add(setting);
}
MangaSettingCache.Set(new MangaSettingCache(databaseConfig));
foreach (var setting in settings.Where(s => s.ProxySetting != null))
{
MangaSettingCache.Set(new MangaSettingCache(setting));
}
}
public async Task ChangeProxySetting()
{
using (var context = Repository.GetEntityContext())
{
var proxySetting = new ProxySetting(ProxySettingType.Manual);
await context.Save(proxySetting).ConfigureAwait(false);
var pseudoPluginType = typeof(ProxyTests);
MangaSettingCache.Set(new MangaSettingCache(pseudoPluginType, proxySetting));
var cache = MangaSettingCache.Get(pseudoPluginType);
var proxy = cache.Proxy;
void AssertCacheEquals()
{
Assert.AreEqual(proxySetting.Id, cache.ProxySettingId);
Assert.AreEqual(pseudoPluginType, cache.Plugin);
Assert.AreEqual(ProxySettingType.Manual, cache.SettingType);
}
AssertCacheEquals();
Assert.AreEqual(proxy, cache.Proxy);
proxySetting.UserName = "******";
await context.Save(proxySetting).ConfigureAwait(false);
AssertCacheEquals();
Assert.AreNotEqual(proxy, cache.Proxy);
await context.Delete(proxySetting).ConfigureAwait(false);
}
}
public override Task BeforeSave(ChangeTrackerArgs args)
{
if (!args.IsNewEntity && !args.CanAddEntities)
{
var proxyState = args.GetPropertyState <ProxySetting>(nameof(ProxySetting));
if (proxyState.IsChanged)
{
MangaSettingCache.RevalidateSetting(MangaSettingCache.RootPluginType, proxyState.Value);
}
}
return(base.BeforeSave(args));
}
/// <summary>
/// Скачать страницу.
/// </summary>
/// <param name="chapterFolder">Папка для файлов.</param>
public async Task Download(string chapterFolder)
{
this.IsDownloaded = false;
if (restartCounter > MaxAttempt)
{
throw new DownloadAttemptFailed(restartCounter, this);
}
try
{
await DownloadManager.CheckPause().ConfigureAwait(false);
using (await ThrottleService.WaitAsync().ConfigureAwait(false))
{
await DownloadManager.CheckPause().ConfigureAwait(false);
if (!DirectoryHelpers.ValidateSettingPath(chapterFolder))
{
throw new DirectoryNotFoundException($"Попытка скачивания в папку {chapterFolder}, папка не существует.");
}
if (!Directory.Exists(chapterFolder))
{
Directory.CreateDirectory(chapterFolder);
}
var manga = Chapter?.Volume?.Manga ?? Chapter?.Manga ?? Manga;
var plugin = ConfigStorage.Plugins.Single(p => p.MangaType == manga.GetType());
var cache = MangaSettingCache.Get(plugin.GetType());
var file = await DownloadManager.DownloadImage(this.ImageLink, cache).ConfigureAwait(false);
if (!file.Exist)
{
OnDownloadFailed();
}
var fileName = this.Number.ToString(CultureInfo.InvariantCulture).PadLeft(4, '0') + "." + file.Extension;
await file.Save(Path.Combine(chapterFolder, fileName)).ConfigureAwait(false);
this.IsDownloaded = true;
}
}
catch (System.Exception ex)
{
Log.Exception(ex, this.Uri.OriginalString);
++restartCounter;
await Download(chapterFolder).ConfigureAwait(false);
}
}
public async Task <ISiteHttpClient> GetCookieClient(bool withLogin)
{
var login = await LoginCache.Get(MangaGuid).ConfigureAwait(false);
var mainUri = login.MainUri;
var client = SiteHttpClientFactory.Get(mainUri, MangaSettingCache.Get(typeof(T)).Proxy, CookieContainer);
await this.ConfigureCookieClient(client, login).ConfigureAwait(false);
if (withLogin && !login.IsLogined(MangaGuid))
{
await login.DoLogin(MangaGuid).ConfigureAwait(false);
}
return(client);
}
protected override async Task ProtectedConvert(IProcess process)
{
using (var context = Repository.GetEntityContext())
{
var settingProxySetting = await context
.Get <ProxySetting>()
.Where(s => s.SettingType == ProxySettingType.Parent)
.SingleAsync().ConfigureAwait(false);
var settings = await context.Get <MangaSetting>().Where(s => s.ProxySetting == null).ToListAsync().ConfigureAwait(false);
foreach (var setting in settings)
{
setting.ProxySetting = settingProxySetting;
MangaSettingCache.Set(new MangaSettingCache(setting));
}
await settings.SaveAll(context).ConfigureAwait(false);
}
}
public virtual IWebProxy GetProxy()
{
switch (SettingType)
{
case ProxySettingType.NoProxy:
return(null);
case ProxySettingType.System:
return(SystemProxy.Value);
case ProxySettingType.Manual:
return(new WebProxy(Address, true, null, new NetworkCredential(UserName, Password)));
case ProxySettingType.Parent:
return(MangaSettingCache.Get(MangaSettingCache.RootPluginType).Proxy);
default:
throw new ArgumentOutOfRangeException();
}
}
public async Task ChangeMangaSetting()
{
using (var context = Repository.GetEntityContext())
{
var proxySetting = new ProxySetting(ProxySettingType.Manual);
await context.Save(proxySetting).ConfigureAwait(false);
var mangaSetting = await context.Get <MangaReader.Core.Services.MangaSetting>()
.FirstOrDefaultAsync(s => s.ProxySetting.SettingType == ProxySettingType.Parent)
.ConfigureAwait(false);
var pluginType = MangaSettingCache.GetPluginType(mangaSetting);
var cache = MangaSettingCache.Get(pluginType);
var proxy = cache.Proxy;
Assert.AreEqual(pluginType, cache.Plugin);
Assert.AreNotEqual(proxySetting.Id, cache.ProxySettingId);
Assert.AreNotEqual(ProxySettingType.Manual, cache.SettingType);
Assert.AreEqual(proxy, cache.Proxy);
var originalProxy = mangaSetting.ProxySetting;
mangaSetting.ProxySetting = proxySetting;
await context.Save(mangaSetting).ConfigureAwait(false);
Assert.AreEqual(pluginType, cache.Plugin);
Assert.AreEqual(proxySetting.Id, cache.ProxySettingId);
Assert.AreEqual(ProxySettingType.Manual, cache.SettingType);
Assert.AreNotEqual(proxy, cache.Proxy);
mangaSetting.ProxySetting = originalProxy;
await context.Save(mangaSetting).ConfigureAwait(false);
Assert.AreEqual(pluginType, cache.Plugin);
await context.Delete(proxySetting).ConfigureAwait(false);
}
}
public override Task BeforeSave(ChangeTrackerArgs args)
{
if (!args.IsNewEntity && !args.CanAddEntities)
{
var typeState = args.GetPropertyState <ProxySettingType>(nameof(SettingType));
if (typeState.IsChanged)
{
MangaSettingCache.RevalidateSetting(this);
}
else
{
var userNameState = args.GetPropertyState <string>(nameof(UserName));
var passwordState = args.GetPropertyState <string>(nameof(Password));
var addressState = args.GetPropertyState <Uri>(nameof(Address));
if (userNameState.IsChanged || passwordState.IsChanged || addressState.IsChanged)
{
MangaSettingCache.RevalidateSetting(this);
}
}
}
return(base.BeforeSave(args));
}
public async Task ChangeDatabaseConfig([Values] bool withParentSettingChange)
{
using (var context = Repository.GetEntityContext())
{
var proxySetting = new ProxySetting(ProxySettingType.Parent);
await context.Save(proxySetting).ConfigureAwait(false);
var pseudoPluginType = typeof(Repository);
MangaSettingCache.Set(new MangaSettingCache(pseudoPluginType, proxySetting));
var settingCache = MangaSettingCache.Get(pseudoPluginType);
var settingCacheProxy = settingCache.Proxy;
void AssertCacheEquals()
{
Assert.AreEqual(proxySetting.Id, settingCache.ProxySettingId);
Assert.AreEqual(pseudoPluginType, settingCache.Plugin);
Assert.AreEqual(ProxySettingType.Parent, settingCache.SettingType);
}
AssertCacheEquals();
Assert.AreEqual(settingCacheProxy, settingCache.Proxy);
ProxySetting setting = null;
if (withParentSettingChange)
{
var databaseConfig = await context.Get <DatabaseConfig>().SingleAsync().ConfigureAwait(false);
setting = databaseConfig.ProxySetting;
databaseConfig.ProxySetting = await context.Get <ProxySetting>().SingleAsync(p => p.SettingType == ProxySettingType.NoProxy).ConfigureAwait(false);
await context.Save(databaseConfig).ConfigureAwait(false);
}
var parentCache = MangaSettingCache.Get(MangaSettingCache.RootPluginType);
Assert.AreNotEqual(settingCache, parentCache);
if (withParentSettingChange)
{
Assert.AreNotEqual(settingCacheProxy, parentCache.Proxy);
Assert.AreEqual(settingCache.Proxy, parentCache.Proxy);
Assert.AreNotEqual(settingCacheProxy, settingCache.Proxy);
AssertCacheEquals();
}
else
{
Assert.AreEqual(settingCacheProxy, parentCache.Proxy);
Assert.AreEqual(settingCache.Proxy, parentCache.Proxy);
}
if (withParentSettingChange)
{
var databaseConfig = await context.Get <DatabaseConfig>().SingleAsync().ConfigureAwait(false);
databaseConfig.ProxySetting = setting;
await context.Save(databaseConfig).ConfigureAwait(false);
AssertCacheEquals();
Assert.AreEqual(settingCache.Proxy, parentCache.Proxy);
}
await context.Delete(proxySetting).ConfigureAwait(false);
}
}
public MangachanClient()
{
Proxy = MangaSettingCache.Get(typeof(MangachanPlugin)).Proxy;
}
public ReadmangaClient()
{
this.Proxy = MangaSettingCache.Get(typeof(ReadmangaPlugin)).Proxy;
}
public AcomicsClient()
{
Proxy = MangaSettingCache.Get(typeof(AcomicsPlugin)).Proxy;
}
public Hentai2ReadClient()
{
Proxy = MangaSettingCache.Get(typeof(Hentai2ReadPlugin)).Proxy;
}
