async Task DownloadImages()
{
if (DownloadedImages.Count >= LoadedWork.PageCount)
{
return;
}
var lworkid = LoadedWork.Id;
using (await locker.LockAsync())
{
try
{
if (lworkid != LoadedWork.Id)
{
return;
}
SetProgressBar(true);
for (int i = 0; i < LoadedWork.PageCount; i++)
{
// if page is not yet downloaded, download it
ImageSource dimg = null;
var page = DownloadedImages.Find(x => x.Page == i + 1);
if (page == null)
{
// start downloading it - befor and after download - check if work has been switched
if (isClosing || lworkid != LoadedWork.Id)
{
break;
}
dimg = await Task.Run(() => PixivWork.GetImage(LoadedWork.GetImageUri(LoadedWork.OriginalImageUrl, i)));
if (isClosing || lworkid != LoadedWork.Id)
{
break;
}
}
else
{
dimg = page.ImageData;
}
// cache image and update status
var dwImage = new DownloadedImageData(i + 1, dimg);
DownloadedImages.Add(dwImage);
CacheDownloads(lworkid.Value, dwImage);
SetPageStatus();
ImageDownloaded?.Invoke(this, dimg);
}
}
finally
{
isClosing = false;
SetProgressBar(false);
}
}
}
public DownloaderProgress(PixivWork work, int pageNumber, string filename,
double progress, double totalProgress)
{
this.AssociatedWork = work;
this.PageNumber = pageNumber;
this.FileName = filename;
this.Progress = progress;
this.TotalProgress = totalProgress;
}
public WorkDetails(PixivWork work)
{
InitializeComponent();
// setup window
SetWindow();
if (wasMaximized)
{
WindowState = WindowState.Maximized;
}
// set datacontext
DataContext = this;
// setup event handlers
this.Closing += WorkDetails_Closing;
this.StateChanged += (a, b) => wasMaximized = WindowState == WindowState.Maximized;
// load given work
LoadWork(work);
}
private void Initialize(UserDetailParameter parameter, bool full = true)
{
_categoryService.UpdateCategory();
if (parameter == null)
{
// オフライン
IsFollowing = false;
_isOffline = true;
return;
}
SelectedIndex = (int)parameter.ProfileType;
if (parameter.ProfileType == ProfileType.Work)
{
SubSelectedIndex1 = (int)parameter.ContentType;
}
else
{
SubSelectedIndex2 = parameter.ContentType == ContentType.Illust ? 0 : 1;
}
Username = parameter.Detail.User.Name;
ScreenName = $"@{parameter.Detail.User.AccountName}";
Url = parameter.Detail.Profile.Webpage;
IsFollowing = parameter.Detail.User.IsFollowed;
_id = parameter.Detail.User.Id;
if (!string.IsNullOrWhiteSpace(parameter.Detail.Profile.Webpage))
{
NavigateUrl = new Uri(parameter.Detail.Profile.Webpage);
}
if (full)
{
Thumbnailable = new PixivUserImage(parameter.Detail.User, _imageStoreService);
if (string.IsNullOrWhiteSpace(parameter.Detail.Profile.BackgroundImageUrl))
{
Thumbnailable2 = new PixivUserImage(parameter.Detail.User, _imageStoreService);
}
else
{
Thumbnailable2 = new PixivUrlImage(parameter.Detail.Profile.BackgroundImageUrl, _imageStoreService);
}
}
var param1 = new UserDetailParameter
{
Detail = parameter.Detail,
ProfileType = ProfileType.Work,
ContentType = ContentType.Illust
};
var param2 = (UserDetailParameter)param1.Clone();
param2.ProfileType = ProfileType.Favorite;
Parameter = new List <object>
{
new DetailByIdParameter {
Id = parameter.Detail.User.Id
},
param1,
param2
};
if (parameter.ProfileType == ProfileType.Work)
{
InitializeSubMenu(param1, true);
if (!full)
{
return;
}
_pixivWork = new PixivWork(parameter.Detail.User.Id, parameter.ContentType, _pixivClient, _queryCacheService);
if (parameter.ContentType != ContentType.Novel)
{
ModelHelper.ConnectTo(Collection, _pixivWork, w => w.Illusts, CreatePixivImage).AddTo(this);
}
else
{
ModelHelper.ConnectTo(Collection, _pixivWork, w => w.Novels, CreatePixivNovel).AddTo(this);
}
}
else
{
InitializeSubMenu(param1, false);
if (!full)
{
return;
}
_pixivFavorite = new PixivFavorite(_pixivClient, _queryCacheService);
if (parameter.ContentType != ContentType.Novel)
{
ModelHelper.ConnectTo(Collection, _pixivFavorite, w => w.ResultIllusts, CreatePixivImage)
.AddTo(this);
}
else
{
ModelHelper.ConnectTo(Collection, _pixivFavorite, w => w.ResultNovels, CreatePixivNovel).AddTo(this);
}
_pixivFavorite.Query(new FavoriteOptionParameter
{
Restrict = RestrictType.Public,
Type = parameter.ContentType.ToSearchType(),
Tag = "",
UserId = parameter.Detail.User.Id
});
}
}
protected override void ExcuteCore(object param)
{
var manager = new ManagerCollection();
var wc = new XWebClient();
var now = DateTime.Now;
var time = now.AddDays(-2);
var list = manager.AdminPixivPickUsers.Items.Where(p => p.LastPickTime < time).ToList();
if (list.Count == 0)
return;
//登录逻辑
wc.Post("https://www.secure.pixiv.net/login.php", new { mode = "login", pixiv_id = "*****@*****.**", pass = "******", skip = 1 });
foreach (var user in list)
{
var isEnd = false;
var pixivworkList = new List<PixivWork>();
//查看作品列表
var page = 1;
while (true)
{
var html = wc.Get("http://www.pixiv.net/member_illust.php?type=illust&id=" + user.PixivUserID + "&p=" + page);
//var html = wc.Get("http://www.pixiv.net/member_illust.php?type=illust&id=" + 163536 + "&p=" + page);
var doc = new HtmlDocument();
doc.LoadHtml(html);
var workList = doc.DocumentNode.SelectNodes(SelectorToXPath(".work._work"));
foreach (var item in workList)
{
try
{
var work = new PixivWork();
var href = "http://www.pixiv.net" + item.Attributes["href"].Value;
work.From = href;
var workHtml = wc.Get(href);
var workDoc = new HtmlDocument();
workDoc.LoadHtml(workHtml);
var publishDateTimeNode = workDoc.DocumentNode.SelectSingleNode(SelectorToXPath(".work-info .meta") + "/li[1]");
var publishDateTime = Convert.ToDateTime(publishDateTimeNode.InnerText);
if (publishDateTime < user.LastPickTime)
{
isEnd = true;
break;
}
foreach (var tagNode in workDoc.DocumentNode.SelectNodes(SelectorToXPath(".tag .text")))
{
work.Tags.Add(HttpUtility.HtmlDecode(tagNode.InnerText));
}
var sourceNode = workDoc.DocumentNode.SelectSingleNode(SelectorToXPath(".original-image"));
var source = sourceNode.Attributes["data-src"].Value;
work.Source = source;
var usernameNode = workDoc.DocumentNode.SelectSingleNode(SelectorToXPath(".user-link h1.user"));
var username = usernameNode.InnerText;
work.Username = username;
var titleNode = workDoc.DocumentNode.SelectSingleNode(SelectorToXPath(".work-info .title"));
var title = titleNode.InnerText;
work.Title = title;
pixivworkList.Add(work);
}
catch { }
}
page++;
if (isEnd == true || workList.Count < 20)
break;
}
manager.Transaction(() =>
{
foreach (var item in pixivworkList)
{
var mtextList = new List<string>();
item.Tags.ForEach(t =>
{
var tag = manager.AdminPixivTags.CreateIfNotExist(new AdminPixivTag { PText = t }, a => a.PText == t);
tag.CitationCount++;
if (string.IsNullOrWhiteSpace(tag.MText) == false)
mtextList.Add(tag.MText);
manager.AdminPixivTags.Update(tag);
});
var strTag = "";
foreach (var t in mtextList.Distinct())
{
strTag += string.Format("#{0}#", t);
}
manager.Picks.Add(item.From, item.Source, user.PackageID, string.Format("{0}[{1}]/[{2}]", strTag, item.Title, item.Username));
}
user.LastPickTime = now;
manager.AdminPixivPickUsers.Update(user);
});
}
}
public void LoadWork(PixivWork newWork, bool doAnimation = false)
{
timestamp = DateTime.Now; // used for doubleclicking
// load work
LoadedWork = newWork;
// set to initial values
currentPage = 1;
DownloadedImages.Clear();
mainImage.Source = null;
img = null;
// reset datacontext to refresh bindings
DataContext = null; DataContext = this;
// load cached results if available
var prevd = PreviousDownloadsCache.GetFromCache(x => x.Item1 == newWork.Id.Value);
if (prevd != null)
{
DownloadedImages = new List <DownloadedImageData>(prevd.Select(x => x.Item2).OrderBy(a => a.Page));
}
// set work info
comboTags.ItemsSource = GetTranslatedTags(LoadedWork.Tags);
txtClipboard.Text = "Click on tag to copy it!";
txtScore.Text = $"Score: {LoadedWork.Stats?.Score ?? LoadedWork.TotalBookmarks}";
txtArtist.Text = LoadedWork.User.Name;
txtResolution.Text = $"{LoadedWork.Width}x{LoadedWork.Height}";
txtTitle.Text = LoadedWork.Title;
Title = $"Work Details - ({LoadedWork.Id}) {LoadedWork.Title}";
SetPageStatus();
// set cached image if exists or use thumbnail
if (DownloadedImages.Find(x => x.Page == 1) != null)
{
if (doAnimation)
{
AnimateImageShift(() => SetImage(1));
}
else
{
SetImage(1);
}
}
else if (LoadedWork.img != null)
{
if (doAnimation)
{
AnimateImageShift(() => mainImage.Source = LoadedWork.ImageThumbnail);
}
else
{
mainImage.Source = LoadedWork.ImageThumbnail;
}
}
// start downloading images
DownloadImages();
// once first image is downloaded, show it
ImageDownloaded += (a, b) =>
{
if (DownloadedImages.Count == 1)
{
SetImage(1);
}
};
}
