public async Task <AnfBookshelfItem> GetAsync(long bookshelfId, string address)
{
var key = KeyGenerator.Concat(ReadingKey, bookshelfId, address);
var entities = await database.HashGetAllAsync(key);
return(ToBookselfItem(entities));
}
public async Task <UserSnapshot> GetTokenInfoAsync(string token)
{
var key = KeyGenerator.Concat(UserMapKey, token);
var val = await database.StringGetAsync(key);
return(val.Get <UserSnapshot>());
}
public async Task <IActionResult> GetEntity([FromQuery] string url)
{
if (string.IsNullOrEmpty(url))
{
return(BadRequest());
}
var key = KeyGenerator.Concat(EntityKey, url);
var res = memoryCache.Get <AnfComicEntityTruck>(key);
if (res == null)
{
res = await rootFetcher.FetchEntityAsync(url);
memoryCache.Set(key, res, new MemoryCacheEntryOptions
{
SlidingExpiration = CacheTime
});
}
if (res != null)
{
await comicRankService.IncVisitAsync(res.ComicUrl, 1);
await visitStatisticalService.AddAsync(new AnfVisitCount
{
Address = url,
IP = HttpContext.Connection.RemoteIpAddress?.ToString(),
Time = DateTime.Now,
UserId = HttpContext.Features.Get <UserSnapshot>()?.Id
});
}
return(Ok(res));
}
public async Task <string> SetIdentityAsync(UserSnapshot snapshot)
{
var tk = Guid.NewGuid().ToString("N");
var key = KeyGenerator.Concat(UserMapKey, tk);
var bytes = JsonSerializer.SerializeToUtf8Bytes(snapshot);
await database.StringSetAsync(key, bytes, ExpireTime);
return(tk);
}
private Task <IResourceLocker> CreateLockerAsync(string part)
{
if (resourceLockerFactory is null)
{
throw new NotSupportedException("The IResourceLockerFactory is not provided, the function is not support");
}
var key = KeyGenerator.Concat(FetckKey, part, Url);
return(resourceLockerFactory.CreateLockerAsync(key));
}
public async Task <IActionResult> Search([FromQuery] string provider, [FromQuery] string keyword, [FromQuery] int skip = 0, [FromQuery] int take = 20)
{
if (string.IsNullOrEmpty(keyword))
{
return(base.Problem("The keyword can't be null"));
}
if (searchEngine.Count == 0)
{
return(base.Problem("The search engine nothing"));
}
var prov = searchEngine[0];
if (!string.IsNullOrEmpty(provider))
{
prov = searchEngine.FirstOrDefault(x => x.Name == provider);
if (prov is null)
{
prov = searchEngine[0];
}
}
var key = KeyGenerator.Concat(SearchKey, provider, keyword);
var ds = memoryCache.Get(key);
if (ds != null)
{
await comicRankService.IncSearchAsync(keyword, 1);
return(Ok(ds));
}
using var scope = searchEngine.ServiceScopeFactory.CreateScope();
var eng = (ISearchProvider)scope.ServiceProvider.GetService(prov);
var data = await eng.SearchAsync(keyword, skip, take);
await comicRankService.IncSearchAsync(keyword, 1);
await searchStatisticalService.AddAsync(new AnfSearchCount
{
Content = keyword,
IP = HttpContext.Connection.RemoteIpAddress?.ToString(),
Time = DateTime.Now,
UserId = HttpContext.Features.Get <UserSnapshot>()?.Id
});
var r = new EntityResult <SearchComicResult> {
Data = data
};
memoryCache.Set(key, r, new MemoryCacheEntryOptions
{
SlidingExpiration = CacheTime
});
return(Ok(r));
}
public async Task <AnfBookshelfItem[]> BatchGetAsync(ReadingIdentity[] identities)
{
var keys = identities.Select(x => KeyGenerator.Concat(ReadingKey, x.BookshelfId, x.Address));
var batch = database.CreateBatch();
var tasks = keys.Select(x => batch.HashGetAllAsync(x)).ToArray();
batch.Execute();
var entities = await Task.WhenAll(tasks);
return(entities.Where(x => x != null)
.Select(x => ToBookselfItem(x))
.ToArray());
}
public async Task <IActionResult> GetChapter([FromQuery] string url, [FromQuery] string entityUrl)
{
if (string.IsNullOrEmpty(url))
{
return(BadRequest());
}
var key = KeyGenerator.Concat(ChapterKey, url);
var res = memoryCache.Get <WithPageChapter>(key);
if (res != null)
{
return(Ok(res));
}
res = await rootFetcher.FetchChapterAsync(url, entityUrl);
if (res != null)
{
memoryCache.Set(key, res, new MemoryCacheEntryOptions
{
SlidingExpiration = CacheTime
});
}
return(Ok(res));
}
