protected override object DoWork(LoadPageCommandArgs value)
{
// load the page
ThreadPageMetadata page = value.LoadPage(value.State);
if (page == null)
{
throw new Exception("There was an error loading the requested page.");
}
else
{
this._pageCache.AddPage(page);
}
UpdateStatus("Rendering...");
ThreadPageDataObject dataObject = new ThreadPageDataObject(page);
this._currentThread = MetadataExtensions.FromPageMetadata(page);
this._ratingCommand.ThreadId = page.ThreadID;
this._rating = 0;
this._currentThreadPage = dataObject;
if (TotalPages != page.LastPage)
{
this._items = new ThreadPageSlideViewList(page.LastPage);
SynchronizeSlideView = true;
}
return(dataObject);
}
private SAThreadViewEventArgs CreateViewmodel(Uri parameter)
{
// try and parse a thread page from the html
ThreadPageMetadata page = MetadataExtensions.ThreadPageFromUri(parameter);
// since we have a page, create thread metadata from it
ThreadMetadata thread = new ThreadMetadata()
{
ThreadID = page.ThreadID,
Title = page.ThreadTitle,
PageCount = page.LastPage
};
// create binding wrappers
Data.ThreadDataSource threadSource = new Data.ThreadDataSource(thread);
Data.ThreadPageDataObject pageSource = new Data.ThreadPageDataObject(page);
// create viewmodel
ViewModels.ThreadViewModel viewmodel = new ViewModels.ThreadViewModel();
int pageIndex = pageSource.PageNumber - 1;
viewmodel.UpdateModel(threadSource);
viewmodel.Pages[pageIndex] = pageSource;
// set the current page to page source
viewmodel.SelectedItem = viewmodel.Pages[pageIndex];
viewmodel.SelectedIndex = pageIndex;
return(new SAThreadViewEventArgs(viewmodel));
}
protected override Data.ThreadPageDataSource GetItem(int index)
{
var pageNumber = index + 1;
Data.ThreadPageDataSource page = null;
// var page = this._cache.Where(p => p.PageNumber == pageNumber).FirstOrDefault();
if (_cacheTable.ContainsKey(pageNumber))
{
page = _cacheTable[pageNumber];
}
if (page == null)
{
var metadata = new ThreadPageMetadata()
{
ThreadID = _source.ThreadID, PageNumber = pageNumber
};
page = new Data.ThreadPageDataProxy(metadata)
{
};
UpdateCache(page);
}
return(page);
}
private ThreadPageMetadata LoadPageDelegate(object state)
{
ThreadPageMetadata page = null;
page = state as ThreadPageMetadata;
return(page);
}
private void LoadPage(ThreadPageMetadata page)
{
LoadPageCommandArgs args = new LoadPageCommandArgs();
args.LoadPage = LoadPageDelegate;
args.State = page;
Execute(args);
}
public ThreadPageDataObject(ThreadPageMetadata data)
: base()
{
if (data != null)
{
SetMetadata(data);
}
}
/*
public static ThreadPageMetadata ParseThreadPage(Uri threadPageUri)
{
var client = new AwfulWebClient();
var htmlDoc = client.FetchHtml(threadPageUri.AbsoluteUri);
return ParseThreadPage(htmlDoc);
}
*/
private static ThreadPageMetadata ProcessThreadPage(HtmlNode top)
{
// first, let's generate data about the thread
ThreadPageMetadata page = new ThreadPageMetadata()
.ProcessParent(top)
.ParsePageNumberAndMaxPages(top)
.ParsePostTable(top)
.ParseIsThreadBookmarked(top)
.ParseTargetPostIndex();
return page;
}
public virtual ThreadPageDataSource Refresh()
{
ThreadPageDataSource result = null;
ThreadPageMetadata metadata = Data != null ? Data : new ThreadPageMetadata()
{
ThreadID = ThreadID, PageNumber = PageNumber
};
var page = metadata.Refresh();
if (page != null)
{
result = new ThreadPageDataObject(page);
}
return(result);
}
public void SetMetadata(ThreadPageMetadata data)
{
this._data = data;
this.ThreadID = data.ThreadID;
this.PageNumber = data.PageNumber;
if (!data.Posts.IsNullOrEmpty())
{
foreach (var post in data.Posts)
{
this.Posts.Add(new ThreadPostSource(post));
}
this.Html = MetroStyler.Metrofy(data.Posts);
}
OnPropertyChanged("Data");
OnPropertyChanged("Posts");
OnPropertyChanged("Items");
}
private ThreadPageMetadata LoadPageFromWeb(int pageNumber)
{
ThreadPageMetadata page = null;
if (pageNumber == (int)ThreadPageType.NewPost)
{
page = Thread.Data.FirstUnreadPost();
}
else if (pageNumber == (int)ThreadPageType.Last)
{
page = Thread.Data.LastPage();
}
else
{
page = Thread.Data.Page(pageNumber);
}
return(page);
}
protected override object DoWork(int parameter)
{
ThreadViewPageState state = null;
ThreadPageMetadata page = LoadPageFromWeb(parameter);
if (page == null)
{
throw new NullReferenceException("Thread page must not be null.");
}
else
{
var pageData = new Data.ThreadPageDataObject(page);
// mine data about the thread from the page
Thread.Title = page.ThreadTitle;
if (page.LastPage > 0)
{
Thread.PageCount = page.LastPage;
}
// set the selected index to that of the loaded page
SelectedIndex = page.PageNumber - 1;
// create page state and save immeadiately so we don't have to load this again
state = new ThreadViewPageState(Thread, pageData);
try { ThreadViewPageState.Save(state); }
catch (Exception) { }
// setup page proxy and insert page at proper index
SetPages(Thread.PageCount);
Pages[SelectedIndex] = pageData;
}
return(state);
}
public void OnNewThreadCreated(ThreadPageMetadata threadPage)
{
Task.Delay(10).ContinueWith(task =>
{
AccessTokenMessage message = new AccessTokenMessage();
NotificationService.Default.Notify(this, message);
var tab = new ThreadDataItemFromPage(threadPage, message.Token);
this.viewModelWrapper.Threads.Add(tab);
this.viewModelWrapper.CurrentThread = tab;
}, TaskScheduler.FromCurrentSynchronizationContext());
}
/*
public static ThreadPageMetadata ParseThreadPage(Uri threadPageUri)
{
var client = new AwfulWebClient();
var htmlDoc = client.FetchHtml(threadPageUri.AbsoluteUri);
return ParseThreadPage(htmlDoc);
}
*/
private static ThreadPageMetadata ProcessThreadPage(HtmlNode top)
{
AwfulDebugger.AddLog(top, AwfulDebugger.Level.Debug, "Parsing HTML for posts...");
// first, let's generate data about the thread
ThreadPageMetadata page = new ThreadPageMetadata()
.ProcessParent(top)
.ParsePageNumberAndMaxPages(top)
.ParsePostTable(top)
.ParseTargetPostIndex();
return page;
}
public ThreadPageDataProxy(ThreadPageMetadata metadata)
{
_page = new ThreadPageDataObject(metadata);
}
