public void UpdateValues()
{
var ratingConfiguration = _configuration.FetchConfiguration.RatingConfiguration;
SafeCheck = ratingConfiguration.Safe;
QuestionableCheck = ratingConfiguration.Questionable;
ExplicitCheck = ratingConfiguration.Explicit;
CachePath = _configuration.CachePath;
CurrentSite = _configuration.ActiveSite;
}
public Dictionary <string, string> GetPropertyMapping(BooruSiteType booruSiteType)
{
switch (booruSiteType)
{
case BooruSiteType.Danbooru: return(DanbooruPropertyMappings);
case BooruSiteType.Gelbooru: return(GelbooruPropertyMappings);
case BooruSiteType.SafeBooru: return(SafebooruPropertyMappings);
}
throw new NotImplementedException($"Unknown booru site type: {booruSiteType}");
}
public Task <string> FetchPostsAsync(
BooruSiteType type,
int limit = 0,
int pageNumber = 1,
ICollection <string> tags = null,
CancellationToken cancellationToken = default)
{
if (limit == 0)
{
limit = _initLimit;
}
var url = _helper.GetPostsUrl(
type, limit, pageNumber, tags);
return(_httpClient.GetStringAsync(url, cancellationToken));
}
/// <summary>
///
/// </summary>
/// <param name="addImageCallback">Invoke when adding <see cref="BooruImage"/></param>
public async Task GetPosts(
BooruSiteType siteType,
Action <BooruImage> addImageCallback,
IList <string> tags,
int queryPageNumber,
int postLimit,
CancellationToken cancellationToken = default
)
{
BooruPreviewImages = new List <BooruImage>();
Posts = new List <IBooruPost>();
QueryPage = queryPageNumber;
SiteType = siteType;
QueryPostLimit = postLimit;
var ratingTags = _postManager.GetRatingTagString(_configuration.ActiveSite,
_configuration.FetchConfiguration.RatingConfiguration);
Tags = new List <string> {
ratingTags
};
Tags.AddRange(tags);
var postsString =
await _postFetcherService.FetchPostsAsync(
SiteType,
QueryPostLimit,
tags : Tags,
pageNumber : QueryPage,
cancellationToken : cancellationToken).ConfigureAwait(false);
var posts = _postManager.DeserializePosts(
_configuration.ActiveSite, postsString);
foreach (var post in posts)
{
cancellationToken.ThrowIfCancellationRequested();
Posts.Add(post);
await AddBooruImage(post, addImageCallback, cancellationToken);
}
}
public List <IBooruPost> DeserializePosts(BooruSiteType type, string posts)
{
switch (type)
{
case BooruSiteType.Danbooru:
return(new List <IBooruPost>(
JsonConvert.DeserializeObject <List <DanbooruPost> >(posts)));
case BooruSiteType.SafeBooru:
return(new List <IBooruPost>(
JsonConvert.DeserializeObject <List <SafebooruPost> >(posts)));
case BooruSiteType.Gelbooru:
return(new List <IBooruPost>(
JsonConvert.DeserializeObject <List <GelbooruPost> >(posts)));
}
throw new Exception("Unknown booru type for deserialize");
}
public string GetRatingTagString(BooruSiteType type, RatingConfiguration ratingConfiguration)
{
//ToDo maybe configure rating tag value in configuration file
switch (ratingConfiguration.GetEnabledRatingTagCount())
{
case 1:
{
if (ratingConfiguration.Safe)
{
return("rating%3Asafe");
}
if (ratingConfiguration.Explicit)
{
if (type == BooruSiteType.SafeBooru)
{
return(String.Empty);
}
if (type == BooruSiteType.Gelbooru)
{
return("rating%3Aexplicit");
}
return("rating%3Ae");
}
return("rating%3Aquestionable");
}
case 2:
{
if (!ratingConfiguration.Safe)
{
return("-rating%3Asafe");
}
if (!ratingConfiguration.Explicit)
{
return("-rating%3Ae");
}
return("-rating%3Aquestionable");
}
default: return(String.Empty);
}
}
public string GetPostsUrl(BooruSiteType type, int limit, int pageNumber, ICollection <string> tags)
{
switch (type)
{
case BooruSiteType.Danbooru:
var danbooru = _fetchConfiguration.DanbooruUrlConfiguration;
return(danbooru.BaseUrl + AssemblePostsUrl(danbooru.PostsUrl, limit, pageNumber, tags));
case BooruSiteType.SafeBooru:
var safebooru = _fetchConfiguration.SafebooruUrlConfiguration;
return(safebooru.BaseUrl + AssemblePostsUrl(safebooru.PostsUrl, limit, pageNumber, tags));
case BooruSiteType.Gelbooru:
var gelbooru = _fetchConfiguration.GelbooruUrlConfiguration;
return(gelbooru.BaseUrl + AssemblePostsUrl(gelbooru.PostsUrl, limit, pageNumber, tags));
default:
throw new AssemblePostUrlException();
}
}
public List <IBooruPost> DeserializePosts(BooruSiteType type, string posts)
{
switch (type)
{
case BooruSiteType.Danbooru:
_booruContractResolver.SetBooruSite(BooruSiteType.Danbooru);
return(new List <IBooruPost>(
_jsonSerializer.DeserializeBooruPosts <List <DanbooruPost>, DanbooruPost>(posts, _booruContractResolver)));
case BooruSiteType.SafeBooru:
_booruContractResolver.SetBooruSite(BooruSiteType.SafeBooru);
return(new List <IBooruPost>(
_jsonSerializer.DeserializeBooruPosts <List <SafebooruPost>, SafebooruPost>(posts, _booruContractResolver)));
case BooruSiteType.Gelbooru:
_booruContractResolver.SetBooruSite(BooruSiteType.Gelbooru);
return(new List <IBooruPost>(
_jsonSerializer.DeserializeBooruPosts <List <GelbooruPost>, GelbooruPost>(posts, _booruContractResolver)));
}
throw new Exception("Unknown booru type for deserialize");
}
public async Task <List <BooruImage> > GetImagesAsync(
BooruSiteType booruSiteType,
ImageSizeType imageType,
ICollection <IBooruPost> collection,
CancellationToken cancellationToken = default)
{
var images = new List <BooruImage>();
foreach (var booruImage in collection)
{
if (cancellationToken.IsCancellationRequested)
{
cancellationToken.ThrowIfCancellationRequested();
}
//Todo research why hash may be empty
if (string.IsNullOrEmpty(booruImage.Hash))
{
continue;
}
var imageFile = await _imageFetcherService.FetchImageAsync(
booruImage, imageType, cancellationToken : cancellationToken);
if (imageFile == null)
{
continue;
}
var booruImageWrapper = new BooruImage();
booruImageWrapper.Hash = booruImage.Hash;
booruImageWrapper.Image = imageFile;
images.Add(booruImageWrapper);
}
return(images);
}
public void SetBooruSite(BooruSiteType booruSiteType)
{
_siteType = booruSiteType;
}
