public async ValueTask <bool> DeleteTagType(long tagTypeId)
{
using var context = Context;
var mangaTagMappingService = new MangaTagMappingService(context);
var tagService = new TagService(context);
var tagTypeService = new TagTypeService(context);
try
{
context.BeginTran();
var tags = await tagService.GetListAsync(it => it.TypeId == tagTypeId);
var keys = tags.Select(it => it.Key).ToList();
await mangaTagMappingService.DeleteAsync(it => keys.Contains(it.TagId));
await tagService.DeleteAsync(it => it.TypeId == tagTypeId);
await tagTypeService.DeleteAsync(it => it.ObjectId == tagTypeId);
context.CommitTran();
return(true);
}
catch (Exception e)
{
context.RollbackTran();
throw;
}
}
public async ValueTask <List <Tag> > GetTags(List <long> tagIds, int offset, int limit)
{
using var context = Context;
var tagService = new TagService(context);
tagIds = tagIds.Skip(offset).Take(limit).ToList();
return((await tagService
.GetListAsync(it => tagIds.Contains(it.ObjectId)))
.ToList()
.OrderBy(it => tagIds.IndexOf(it.ObjectId))
.ToList());
}
public async ValueTask <bool> DeleteTag(long tagId)
{
using var context = Context;
var mangaTagMappingService = new MangaTagMappingService(context);
var tagService = new TagService(context);
context.BeginTran();
try
{
context.BeginTran();
var tag = await tagService.GetSingleAsync(it => it.ObjectId == tagId);
if (tag.Key == tag.ObjectId)
{
var keyTagList = await tagService.GetListAsync(it => it.Key == tagId && it.ObjectId != tagId);
if (keyTagList.Count != 0)
{
var newKey = keyTagList.First().ObjectId;
await tagService.UpdateKey(tagId, newKey);
await mangaTagMappingService.Update(tagId, newKey);
}
else
{
await mangaTagMappingService.DeleteAsync(it => it.TagId == tagId);
}
}
await tagService.DeleteAsync(it => it.ObjectId == tagId);
context.CommitTran();
FtsIndexService.DeleteTagFtxIndex(tagId);
return(true);
}
catch (Exception e)
{
context.RollbackTran();
throw;
}
}
public async ValueTask <bool> Update(Tag tag)
{
using var context = Context;
try
{
context.BeginTran();
var tagService = new TagService(context);
var toBeMapping = new HashSet <long>();
var mangaTagMappingService = new MangaTagMappingService(context);
var oldTag = await tagService.GetTagWithAliases(it => it.ObjectId == tag.ObjectId);
// Update metadata
if (oldTag == null || !await tagService.Update(tag))
{
context.RollbackTran();
return(false);
}
// Check type of key tag == type of tag
if (oldTag.Key != tag.Key)
{
var keyTag = await tagService.GetSingleAsync(it => it.ObjectId == tag.Key);
if (tag.TypeId != keyTag?.TypeId)
{
context.RollbackTran();
return(false);
}
toBeMapping.Add(oldTag.Key);
}
// Recover all removed aliases
foreach (var alias in oldTag.Aliases.Where(oldTagAlias => tag.Aliases.All(it => it.ObjectId != oldTagAlias.ObjectId)))
{
var oldTagAlias = await tagService.GetSingleAsync(it => it.ObjectId == alias.ObjectId);
oldTagAlias.Key = oldTagAlias.ObjectId;
if (!await tagService.Update(oldTagAlias))
{
context.RollbackTran();
return(false);
}
}
for (int i = 0; i < tag.Aliases.Count; i++)
{
var tagAlias = tag.Aliases[i];
var oldAlias = await tagService.GetSingleAsync(it => it.ObjectId == tagAlias.ObjectId);
if (oldAlias.TypeId != tag.TypeId)
{
context.RollbackTran();
return(false);
}
oldAlias.Aliases = await tagService.GetListAsync(it => it.Key == tagAlias.ObjectId && it.Key != it.ObjectId);
if (oldAlias.Aliases != null)
{
tag.Aliases.AddRange(oldAlias.Aliases);
}
if (oldAlias.Key == tag.Key)
{
continue;
}
toBeMapping.Add(oldAlias.Key);
oldAlias.Key = tag.Key;
if (await tagService.Update(oldAlias))
{
continue;
}
context.RollbackTran();
return(false);
}
foreach (var oldKey in toBeMapping)
{
await mangaTagMappingService.Update(oldKey, tag.Key);
}
FtsIndexService.UpdateFtsIndex(tag);
context.CommitTran();
return(true);
}
catch (Exception e)
{
context.RollbackTran();
throw;
}
}
