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));
}
public override async Task BeforeDelete(ChangeTrackerArgs args)
{
using (var context = Repository.GetEntityContext())
{
var hasDatabaseConfig = await context.Get <DatabaseConfig>().AnyAsync(c => c.ProxySetting == this).ConfigureAwait(false);
var usedInMangaSettigns = await context.Get <MangaSetting>().Where(s => s.ProxySetting == this).Select(s => s.MangaName).ToListAsync().ConfigureAwait(false);
if (hasDatabaseConfig || usedInMangaSettigns.Any())
{
if (hasDatabaseConfig)
{
usedInMangaSettigns.Add("общие настройки");
}
var usedIn = string.Join(string.Empty, usedInMangaSettigns.Select(s => $"\r\n - {s}"));
throw new EntityException <ProxySetting>($"Настройки прокси уже используются:{usedIn}\r\n", this);
}
}
await base.BeforeDelete(args).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 override async Task BeforeSave(ChangeTrackerArgs args)
{
var debugMessage = string.Empty;
if (!args.IsNewEntity)
{
var uriState = args.GetPropertyState <Uri>(nameof(Uri));
if (uriState.IsChanged)
{
debugMessage += $" uri changed from '{uriState.OldValue}' to '{uriState.Value}'";
using (Repository.GetEntityContext("Manga uri changed"))
{
var settings = ConfigStorage.Plugins.Where(p => p.LoginType == this.Setting.Login.GetType()).Select(p => p.GetSettings());
var allowedUris = settings.Select(s => s.MainUri).ToList();
if (allowedUris.Any(s => s.Host == uriState.OldValue.Host) &&
allowedUris.All(s => s.Host != uriState.Value.Host))
{
throw new MangaSaveValidationException("Нельзя менять источник манги на другой сайт.", this);
}
}
var parseResult = Parser.ParseUri(uriState.Value);
if (!parseResult.CanBeParsed || parseResult.Kind != UriParseKind.Manga)
{
throw new MangaSaveValidationException("Источник манги не поддерживается.", this);
}
}
}
if (!await this.IsValid().ConfigureAwait(false))
{
throw new MangaSaveValidationException("Нельзя сохранять невалидную сущность", this);
}
if (!args.CanAddEntities)
{
Log.Add(Id != 0 ? $"Save {GetType().Name} with id {Id} ({Name})." : $"New {GetType().Name} ({Name}).");
}
RefreshFolder();
args.SetPropertyState(nameof(Folder), Folder);
if (CompressionMode == null)
{
CompressionMode = this.GetDefaultCompression();
args.SetPropertyState(nameof(CompressionMode), CompressionMode);
}
using (var context = Repository.GetEntityContext())
{
if (await context.Get <IManga>().AnyAsync(m => m.Id != this.Id && m.Folder == this.Folder).ConfigureAwait(false))
{
throw new MangaSaveValidationException($"Другая манга уже использует папку {this.Folder}.", this);
}
}
if (!args.IsNewEntity && !args.CanAddEntities)
{
var folderState = args.GetPropertyState <string>(nameof(Folder));
if (folderState.IsChanged)
{
debugMessage += $" folder changed from '{folderState.OldValue}' to '{folderState.Value}'";
}
var dirName = folderState.OldValue;
var newValue = this.GetAbsoluteFolderPath();
var oldValue = DirectoryHelpers.GetAbsoluteFolderPath(dirName);
if (oldValue != null && !DirectoryHelpers.Equals(newValue, oldValue) && Directory.Exists(oldValue))
{
if (Directory.Exists(newValue))
{
throw new MangaDirectoryExists("Папка уже существует.", newValue, this);
}
// Копируем папку на новый адрес при изменении имени.
DirectoryHelpers.MoveDirectory(oldValue, newValue);
}
}
if (!string.IsNullOrWhiteSpace(debugMessage) && !args.CanAddEntities)
{
Log.Add($"Manga {ServerName}({Id}) changed:" + debugMessage);
}
await base.BeforeSave(args).ConfigureAwait(false);
}
public Task BeforeDelete(ChangeTrackerArgs args)
{
throw new NotImplementedException();
}
public override async Task BeforeSave(ChangeTrackerArgs args)
{
if (!DirectoryHelpers.ValidateSettingPath(this.Folder))
{
throw new DirectoryNotFoundException($"Не найдена папка {this.Folder}, папка должна существовать.");
}
if (!args.IsNewEntity)
{
using (var context = Repository.GetEntityContext())
{
var folderState = args.GetPropertyState <string>(nameof(Folder));
if (folderState.IsChanged)
{
var mangaFolders = await context.Get <IManga>().Select(m => m.Folder).ToListAsync().ConfigureAwait(false);
mangaFolders = mangaFolders.Select(DirectoryHelpers.GetAbsoluteFolderPath).ToList();
var settingAbsoluteFolderPath = DirectoryHelpers.GetAbsoluteFolderPath(this.Folder);
if (mangaFolders.Any(f => DirectoryHelpers.Equals(f, settingAbsoluteFolderPath) || DirectoryHelpers.IsSubfolder(f, settingAbsoluteFolderPath)))
{
throw new MangaSettingSaveValidationException($"Папка {this.Folder} используется мангой.", this);
}
}
var uriState = args.GetPropertyState <Uri>(nameof(MainUri));
if (folderState.IsChanged || uriState.IsChanged)
{
if (!args.CanAddEntities)
{
var debugMessage = $"Manga settings {MangaName}({Manga:D}) changed:";
if (folderState.IsChanged)
{
debugMessage += $" folder changed from '{folderState.OldValue}' to '{folderState.Value}'";
}
if (uriState.IsChanged)
{
debugMessage += $" uri changed from '{uriState.OldValue}' to '{uriState.Value}'";
}
Log.Add(debugMessage);
}
// Changed manga will be added to session.
if (args.CanAddEntities)
{
if (uriState.IsChanged &&
Login != null &&
Equals(Login.MainUri, uriState.OldValue) &&
!Equals(Login.MainUri, uriState.Value))
{
Login.MainUri = MainUri;
}
var mangas = await context.Get <IManga>().Where(m => m.Setting == this).ToListAsync().ConfigureAwait(false);
foreach (var manga in mangas)
{
if (uriState.IsChanged)
{
manga.Uri = new Uri(manga.Uri.OriginalString.Replace(uriState.OldValue.GetLeftPart(UriPartial.Authority), uriState.Value.GetLeftPart(UriPartial.Authority)));
}
if (folderState.IsChanged)
{
manga.RefreshFolder();
}
await context.AddToTransaction(manga).ConfigureAwait(false);
}
}
}
}
}
await base.BeforeSave(args).ConfigureAwait(false);
}
public override async Task BeforeSave(ChangeTrackerArgs args)
{
await base.BeforeSave(args).ConfigureAwait(false);
LoginCache.Reset();
}
