public static SAPost Build(HtmlNode node, SAThreadPage page)
{
SAPost result = null;
Awful.Core.Event.Logger.AddEntry("SAPost - Parsing postNode for html...");
int id = Factory.ParsePostID(node);
try
{
result = new SAPost();
result.ID = id;
result.ThreadPageID = page.ID;
Factory.ParseSeenUrl(result, node);
Factory.ParseAuthor(result, node);
Factory.ParsePostDate(result, node);
Factory.ParseUserID(result, node);
result.ContentNode = Factory.ParseContent(node);
Factory.ParseHasSeen(result, node);
Factory.ParseIcon(result, node);
}
catch (Exception ex)
{
string error = string.Format("An error occured while processing the post to the database. [{0}] {1}",
ex.Message, ex.StackTrace);
Awful.Core.Event.Logger.AddEntry(error);
}
return result;
}
public void ShowPreviewAsync(Awful.Core.Models.ActionResult result, SAThreadPage preview)
{
ThreadPool.QueueUserWorkItem(state =>
{
this.HandleResult(result, preview, 0);
}, null);
}
public static Awful.Core.Models.ActionResult Build(SAThreadPage page)
{
// check database for page first (if not refreshing).
var result = Awful.Core.Models.ActionResult.Failure;
result = Factory.LoadFromWeb(page);
return result;
}
public static ICancellable BuildAsync(Action<Awful.Core.Models.ActionResult, SAThreadPage> result, SAThreadPage page)
{
TaskCompletedDelegate completed = (obj, args) =>
{
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
if (args.Cancelled) { result(Awful.Core.Models.ActionResult.Cancelled, page); }
else
{
Awful.Core.Models.ActionResult ar = (Awful.Core.Models.ActionResult)args.Result;
result(ar, page);
}
});
};
DoWorkDelegate work = Factory.BuildAsync_DoWork;
CancellableTask task = new CancellableTask(work, completed);
task.Worker.RunWorkerAsync(page);
return task;
}
public virtual void ReloadCurrentPageAsync(ThreadData thread, int postNumber = -1)
{
this.IsPageLoading = true;
this.ThreadTitle = thread.ThreadTitle;
this.Posts = null;
this._TotalPages = thread.MaxPages;
this._reload = true;
SAThread saThread = thread as SAThread;
SAThreadPage tPage = new SAThreadPage(saThread, this._CurrentPage, this.CurrentUserID);
this._Cancellable = SAThreadPageFactory.BuildAsync((result, page) =>
{
postNumber = thread.LastViewedPostIndex;
thread.LastViewedPageIndex = 0;
thread.LastViewedPostIndex = -1;
ThreadPool.QueueUserWorkItem(state => { this.HandleResult(result, page, postNumber); }, null);
}, tPage);
}
public virtual void LoadThreadPageAsync(ThreadData thread, int pageNumber = 0, int postNumber = -1)
{
if (pageNumber < 0 || pageNumber > thread.MaxPages)
{
string error = string.Format("ThreadViewerViewModel: pageNumber {0} not in range 1 to {1}.",
pageNumber, thread.MaxPages);
Awful.Core.Event.Logger.AddEntry(error);
Awful.Core.Event.Logger.AddEntry("Setting page index to 0 instead, to fetch last page...");
pageNumber = 0;
}
this.IsPageLoading = true;
if (thread.ThreadTitle == null) { this.ThreadTitle = ((SAThread)thread).ThreadURL; }
else { this.ThreadTitle = thread.ThreadTitle; }
this.Posts = null;
this._CurrentPage = pageNumber;
this._TotalPages = thread.MaxPages;
this._currentThreadData = thread;
// else fetch page from cache
SAThread saThread = thread as SAThread;
SAThreadPage tPage = null;
if (this.CurrentUserID == 0) { tPage = this.LoadFromDatabase(saThread, pageNumber); }
if (tPage == null)
{
tPage = new SAThreadPage(saThread, pageNumber, this.CurrentUserID);
this._Cancellable = SAThreadPageFactory.BuildAsync((result, page) =>
{
postNumber = thread.LastViewedPostIndex;
thread.LastViewedPageIndex = 0;
thread.LastViewedPostIndex = -1;
ThreadPool.QueueUserWorkItem(state => { this.HandleResult(result, page, postNumber); }, null);
}, tPage);
}
else
{
ThreadPool.QueueUserWorkItem(state => { this.HandleResult(Awful.Core.Models.ActionResult.Success, tPage, postNumber); }, null);
}
}
private void OnPageRemove(SAThreadPage page)
{
page.Thread = null;
}
private void OnPageAdd(SAThreadPage page)
{
page.Thread = this;
}
public static void Process(SAThreadPage page, HtmlNode parent)
{
Factory.ProcessThreadPage(page, parent);
}
private void ProcessThreadPage(SAThreadPage page, HtmlNode parent)
{
Awful.Core.Event.Logger.AddEntry("SAThreadPage - Parsing HTML for posts...");
var maxPagesNode = parent.Descendants("div")
.Where(node => node.GetAttributeValue("class", "").Equals("pages top"))
.FirstOrDefault();
var threadTitleNode = parent.Descendants("a")
.Where(node => node.GetAttributeValue("class", "").Contains("bclast"))
.FirstOrDefault();
if (threadTitleNode != null)
{
// decode this title
string inner = HttpUtility.HtmlDecode(threadTitleNode.InnerText);
(page.Thread as SAThread).ThreadTitle = inner;
page.ThreadTitle = inner;
}
if (maxPagesNode != null)
{
page.Thread.MaxPages = ParseMaxPagesNode(maxPagesNode);
page.MaxPages = page.Thread.MaxPages;
Awful.Core.Event.Logger.AddEntry(string.Format("SAThreadPage - maxPagesNode found: {0}", page.MaxPages));
}
page.Posts = new List<PostData>();
var postArray = parent.Descendants("table")
.Where(tables => tables.GetAttributeValue("class", "").Equals("post"))
.ToArray();
int index = 1;
foreach (var postNode in postArray)
{
SAPost post = SAPostFactory.Build(postNode, page);
post.PostIndex = index;
page.Posts.Add(post);
index++;
}
int postID = page.Thread.LastViewedPostID;
if (postID != SAPost.NULL_POSTID)
{
PostData selected = null;
selected = page.Posts.Where(post => (post as SAPost).ID == postID).FirstOrDefault();
if (selected != null)
{
page.Thread.LastViewedPostIndex = (selected as SAPost).PostIndex - 1;
page.Thread.LastViewedPostID = SAPost.NULL_POSTID;
}
}
}
private Awful.Core.Models.ActionResult ProcessData(SAThreadPage page, HtmlDocument args)
{
try
{
this.ProcessThreadPage(page, args.DocumentNode);
string content = PostWebViewContentItemBuilder.MergePostsToHtml(page.Posts);
string savedHtmlPath = string.Format("{0}\\{1}_{2}.html",
Globals.Constants.THREADPAGE_DIRECTORY,
page.ThreadID,
page.PageNumber);
content.SaveTextToFile(savedHtmlPath, "\\");
page.HtmlPath = savedHtmlPath;
return Awful.Core.Models.ActionResult.Success;
}
catch (Exception ex)
{
string error = string.Format("An error occured while processing thread page data. [{0}] {1}",
ex.Message, ex.StackTrace);
Awful.Core.Event.Logger.AddEntry(error);
return Awful.Core.Models.ActionResult.Failure;
}
}
private HtmlDocument LoadHtmlFromWeb(SAThreadPage page)
{
HtmlDocument doc = null;
var signal = new AutoResetEvent(false);
var web = new WebGet();
web.LoadAsync(page.Url, (result, docArgs) =>
{
switch (result)
{
case Awful.Core.Models.ActionResult.Success:
doc = docArgs.Document;
if (page.PageNumber == 0) { page.PageNumber = this.ProcessPageNumber(docArgs.Url); }
break;
case Awful.Core.Models.ActionResult.Busy:
break;
case Awful.Core.Models.ActionResult.Failure:
break;
}
signal.Set();
});
signal.WaitOne();
return doc;
}
private Awful.Core.Models.ActionResult LoadFromWeb(SAThreadPage page)
{
HtmlDocument doc = this.LoadHtmlFromWeb(page);
if (doc != null)
{
Awful.Core.Models.ActionResult result = this.ProcessData(page, doc);
return result;
}
return Awful.Core.Models.ActionResult.Failure;
}
private SAThreadPage LoadFromWeb(SAThread thread, int pageNumber, int userID)
{
SAThreadPage page = null;
/// Only do work on nonnegative page numbers. I think I should throw an exception here, to be honest...
if (pageNumber >= 0)
{
page = new SAThreadPage(thread, pageNumber, userID);
HtmlDocument doc = this.LoadHtmlFromWeb(page);
if (doc != null)
{
Awful.Core.Models.ActionResult result = this.ProcessData(page, doc);
if (result == Awful.Core.Models.ActionResult.Failure) return null;
}
}
if (page.PageNumber > 0 && userID == 0)
{
ThreadCache.AddPageToCache(page);
}
return page;
}
private SAThreadPage LoadFromDatabase(SAThreadPage page)
{
if (page.PageNumber >= 1)
{
page = ThreadCache.GetPageFromCache(page.Thread, page.PageNumber);
}
return page;
}
