void PageBrowser_NavigationFailed(object sender, System.Windows.Navigation.NavigationFailedEventArgs e)
{
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "Event: PageBrowser_NavigationFailed");
try
{
// ignore javascript uri navigation failures
if (e.Uri.AbsoluteUri.Contains("javascript"))
{
return;
}
else if (e.Uri.OriginalString.Contains(Constants.THREAD_VIEWER_FILENAME))
{
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Critical, "Thread View Initialization failed.");
this.InitializeBrowserForPageView(sender as WebBrowser);
}
else
{
this.IsReady = false;
}
}
catch (Exception ex) {
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Critical, ex);
this.IsReady = false;
}
}
private Uri ReplyToThread(ThreadMetadata thread, string text)
{
var threadID = thread.ThreadID;
ThreadReplyData?data = GetReplyData(threadID, text);
if (data.HasValue)
{
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "ThreadReplyService");
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "Begin Reply data...");
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "ThreadID: " + data.Value.THREADID);
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "Begin Text...");
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, data.Value.TEXT);
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "...End Text.");
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "Form key: " + data.Value.FORMKEY);
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "Form cookie: " + data.Value.FORMCOOKIE);
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "...End reply data.");
return(InitiateReply(data.Value));
}
else
{
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Critical, "ThreadReplyService - ReplyAsync failed on null ThreadReplyData.");
return(null);
}
}
public IEnumerable <ForumMetadata> Private_FetchAllForums()
{
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "START FetchAllForums()");
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Info, "Fetching Forums from SA...");
string url = string.Format("{0}/{1}?forumid=1", CoreConstants.BASE_URL, CoreConstants.FORUM_PAGE_URI);
var web = new AwfulWebClient();
var doc = web.FetchHtml(url).ToHtmlDocument();
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Info, "Forum fetch complete. Parsing...");
var result = ForumParser.ParseForumList(doc);
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Info, "Parse complete.");
#if DEBUG
Debug.WriteLine("Performing Sanitization Check...");
bool clear = SanitizationCheck(result);
Debug.WriteLine("Check Result: " + clear);
foreach (var forum in result)
{
Debug.WriteLine(forum);
}
#endif
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "END FetchAllForums()");
return(result);
}
private void FetchHtmlStateAsync(string url, Action <FetchHtmlState> callback, int timeout = DefaultTimeoutInMilliseconds)
{
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, string.Format("START FetchHtml({0}, {1})", url, timeout));
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Info, "Performing authentication check...");
Authenticate();
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Info, "Authentication check complete.");
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Info, string.Format("Requesting html from url '{0}'...", url));
if (!NetworkInterface.GetIsNetworkAvailable())
{
throw new Exception("The network is unavailable. Check your network settings and please try again.");
}
if (SimulateTimeout)
{
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Info, "SimulateTimeout = true.");
Random random = new Random();
int value = random.Next(1, 101);
if (value <= SimulateTimeoutChance)
{
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Info, "Timeout generated.");
throw new TimeoutException("Artificial timeout generated!");
}
}
FetchHtmlState state = new FetchHtmlState(timeout);
state.Callback = callback;
state.Request = AwfulWebRequest.CreateGetRequest(url);
state.Request.BeginGetResponse(FetchHtmlAsyncResponse, state);
state.StartTimer();
}
private void ManageScriptAction(string action)
{
if (IgnoreInteractions)
{
return;
}
if (this._eventManager.ContainsKey(action))
{
this._eventManager[action](null);
}
else
{
// check for delimiter in action
var delim = JS_ARG_DELIMITER.ToCharArray();
var tokens = action.Split(delim, StringSplitOptions.RemoveEmptyEntries);
if (this._eventManager.ContainsKey(tokens[0]))
{
this._eventManager[tokens[0]](action);
}
else
{
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, action);
#if DEBUG
MessageBox.Show(action, "debug: script action", MessageBoxButton.OK);
#endif
}
}
}
private byte[] GetReplyMultipartFormData(ThreadReplyData data)
{
Stream dataStream = new MemoryStream();
StringBuilder sb = new StringBuilder();
AddFormDataString(sb, "action", REPLY_ACTION_REQUEST, REPLY_HEADER);
AddFormDataString(sb, "threadid", data.THREADID, REPLY_HEADER);
AddFormDataString(sb, "formkey", data.FORMKEY, REPLY_HEADER);
AddFormDataString(sb, "form_cookie", data.FORMCOOKIE, REPLY_HEADER);
AddFormDataString(sb, "message", data.TEXT, REPLY_HEADER);
AddFormDataString(sb, "parseurl", PARSEURL_REQUEST, REPLY_HEADER);
AddFormDataString(sb, "submit", SUBMIT_REQUEST, REPLY_HEADER);
sb.AppendLine(REPLY_FOOTER);
string content = sb.ToString();
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "Begin form data...");
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, content);
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "..End form data.");
dataStream.Write(encoding.GetBytes(content), 0, content.Length);
dataStream.Position = 0;
byte[] formData = new byte[dataStream.Length];
dataStream.Read(formData, 0, formData.Length);
dataStream.Close();
return(formData);
}
private byte[] GetEditMultipartFormData(PostEditData data)
{
Stream dataStream = new MemoryStream();
StringBuilder sb = new StringBuilder();
AddFormDataString(sb, "action", EDIT_ACTION_REQUEST, EDIT_HEADER);
AddFormDataString(sb, "postid", data.POSTID, EDIT_HEADER);
AddFormDataString(sb, "message", data.TEXT, EDIT_HEADER);
AddFormDataString(sb, "parseurl", PARSEURL_REQUEST, EDIT_HEADER);
AddFormDataString(sb, "bookmark", BOOKMARK_REQUEST, EDIT_HEADER);
AddFormDataString(sb, "submit", SUBMIT_REQUEST, EDIT_HEADER);
sb.AppendLine(EDIT_FOOTER);
string content = sb.ToString();
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "Begin form data...");
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, content);
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "...End form data.");
dataStream.Write(encoding.GetBytes(content), 0, content.Length);
dataStream.Position = 0;
byte[] formData = new byte[dataStream.Length];
dataStream.Read(formData, 0, formData.Length);
dataStream.Close();
return(formData);
}
private void FetchHtmlAsyncResponse(IAsyncResult result)
{
FetchHtmlState state = result.AsyncState as FetchHtmlState;
state.IgnoreTimeout = true;
try
{
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "START ProcessResponse()");
using (var response = state.Request.EndGetResponse(result))
using (var stream = new StreamReader(response.GetResponseStream(),
Encoding.GetEncoding(CoreConstants.WEB_RESPONSE_ENCODING)))
{
state.Html = stream.ReadToEnd();
}
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "END ProcessResponse()");
if (string.IsNullOrEmpty(state.Html))
{
throw new NullReferenceException("fetch html result is null or empty");
}
}
catch (Exception ex) { state.Error = ex; }
state.Callback(state);
}
private static ThreadPageMetadata ParsePostTable(this ThreadPageMetadata page, HtmlNode top)
{
if (page.Posts == null)
{
page.Posts = new List <ThreadPostMetadata>();
}
AwfulDebugger.AddLog(top, AwfulDebugger.Level.Debug, "Parsing post data...");
var postArray = top.Descendants(THREAD_POST_HTML_ELEMENT)
.Where(tables => tables.GetAttributeValue(THREAD_POST_HTML_ATTRIBUTE, "").Equals(THREAD_POST_HTML_VALUE))
.ToArray();
int index = 1;
foreach (var postNode in postArray)
{
ThreadPostMetadata post = PostParser.ParsePost(postNode);
post.PageIndex = index;
page.Posts.Add(post);
index++;
}
// check if there is at least one post on the page. If not, there was a parsing error.
if (page.Posts.Count == 0)
{
throw new Exception("Parse Error: Could not parse the posts on this page.");
}
AwfulDebugger.AddLog(top, AwfulDebugger.Level.Debug, "Thread page parsing complete.");
return(page);
}
public static bool SaveBinaryToIsoStore(this byte[] bytes, string filePath,
IsolatedStorageFile storage = null)
{
bool success = false;
try
{
if (storage == null)
{
storage = IsolatedStorageFile.GetUserStoreForApplication();
}
if (storage.FileExists(filePath))
{
storage.DeleteFile(filePath);
}
if (BuildPath(storage, filePath))
{
using (BinaryWriter writer = new BinaryWriter(
new IsolatedStorageFileStream(filePath, FileMode.OpenOrCreate, FileAccess.Write, storage)))
{
writer.Write(bytes);
success = true;
}
}
}
catch (Exception ex) {
AwfulDebugger.AddLog(new object(), AwfulDebugger.Level.Critical, ex);
success = false;
}
return(success);
}
void PageBrowser_Navigating(object sender, NavigatingEventArgs e)
{
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "Event: PageBrowser_Navigating");
if (e.Uri.OriginalString.Contains(Constants.THREAD_VIEWER_FILENAME))
{
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "Loading View Html in browser...");
}
}
private string BeginGetTextFromWebForm(string webUrl)
{
var web = new AwfulWebClient();
var url = webUrl;
var doc = web.FetchHtml(url).ToHtmlDocument();
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, string.Format("ThreadReplyServer - Retrieving text from '{0}'.", url));
string bodyText = GetFormText(doc.DocumentNode);
return(HttpUtility.HtmlDecode(bodyText));
}
private void Authenticate()
{
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "START Authenticate");
// first, check iso storage for cookies.
// TODO: the above.
// else, login using the supplied username and password.
var login = new AwfulLoginClient();
int tries = 0;
while (!AwfulWebRequest.CanAuthenticate && tries < 3)
{
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Info, "Authentication failed, attempting to try again...");
var loginArgs = OnLoginRequired(this);
if (loginArgs == null)
{
throw new Exception("You need to attach an event listener for login required!");
}
loginArgs.Signal.WaitOne();
if (loginArgs.Ignore)
{
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Info, "Ignoring authentication request. Moving on...");
return;
}
else if (!loginArgs.Cancel)
{
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Info, "User has input credentials; retrying...");
Username = loginArgs.Username;
Password = loginArgs.Password;
AwfulWebRequest.SetCookieJar(login.Authenticate(Username, Password));
tries++;
}
// automatically fail on cancel
else
{
throw new Exception("User cancelled authentication.");
}
}
// after too many tries throw the white flag.
if (tries > 3)
{
throw new Exception("User failed to authenticate.");
}
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "END Authenticate()");
}
private Uri HandleGetResponse(IAsyncResult result)
{
//Logger.AddEntry("ThreadReplyService - GetResponse initiated.");
HttpWebRequest webRequest = result.AsyncState as HttpWebRequest;
HttpWebResponse response = webRequest.EndGetResponse(result) as HttpWebResponse;
string html = string.Empty;
using (StreamReader reader = new StreamReader(response.GetResponseStream()))
{
string text = reader.ReadToEnd();
html = text;
}
// Check if response was successful - Look for redirect data.
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Verbose, "Begin server response...");
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Verbose, html);
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Verbose, "...End server response.");
HtmlDocument responseHtml = new HtmlDocument();
responseHtml.LoadHtml(html);
HtmlNode responseRedirectMeta = responseHtml.DocumentNode.Descendants("meta")
.Where(meta => meta.GetAttributeValue("http-equiv", "").Equals("Refresh"))
.SingleOrDefault();
// try to parse redirect url
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "Attempting to parse redirect url...");
Uri redirect = null;
try
{
string delim = "URL=";
string contentValue = responseRedirectMeta.GetAttributeValue("content", "");
var tokens = contentValue.Split(new string[] { delim }, StringSplitOptions.RemoveEmptyEntries);
string redirectValue = tokens[1];
redirectValue = HttpUtility.HtmlDecode(redirectValue);
redirect = new Uri(string.Format("{0}/{1}", CoreConstants.BASE_URL, redirectValue));
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, string.Format("Url: '{0}'", redirect.AbsoluteUri));
}
catch (Exception ex)
{
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Critical, "Redirect parsing failed.");
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Critical, ex);
}
return(redirect);
}
/*
* 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);
}
private void InitThreadTagCache(object state)
{
string tagListUrl = state as string;
// download the tag list
HttpWebRequest request = HttpWebRequest.CreateHttp(tagListUrl);
try { request.BeginGetResponse(InitThreadTagCacheResponse, request); }
catch (Exception ex)
{
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Critical, ex);
ThreadTagNextUpdate = 0;
}
}
public static void StopLogging()
{
if (Instance.IsInDesignMode)
{
return;
}
try
{
AwfulDebugger.SaveAndDispose();
}
catch (Exception) { }
}
public static byte[] ReadFileFromResourceStore(string filePath)
{
byte[] result = null;
try
{
Stream stream = Application.GetResourceStream(new Uri(filePath, UriKind.RelativeOrAbsolute)).Stream;
using (BinaryReader reader = new BinaryReader(stream))
{
result = reader.ReadBytes((int)stream.Length);
}
}
catch (Exception ex) { AwfulDebugger.AddLog(new object(), AwfulDebugger.Level.Critical, ex); }
return(result);
}
private static ThreadPageMetadata ParsePageNumberAndMaxPages(this ThreadPageMetadata page, HtmlNode top)
{
// now, let's parse page number
AwfulDebugger.AddLog(top, AwfulDebugger.Level.Debug, "Parsing page number...");
int pageNumber = -1;
int lastPage = -1;
var currentPageNode = top.Descendants(THREAD_PAGE_NUMBER_ELEMENT_1)
.Where(node => node.GetAttributeValue(THREAD_PAGE_NUMBER_ATTRIBUTE_1, "").Contains(THREAD_PAGE_NUMBER_VALUE_1))
.FirstOrDefault();
if (currentPageNode != null)
{
var currentPageOptions = currentPageNode.Descendants(THREAD_PAGE_NUMBER_ELEMENT_2);
var currentPageOption = currentPageOptions
.Where(node => node.GetAttributeValue(THREAD_PAGE_NUMBER_ATTRIBUTE_2, "").Equals(THREAD_PAGE_NUMBER_VALUE_2))
.FirstOrDefault();
AwfulDebugger.AddLog(top, AwfulDebugger.Level.Debug, "Parsing total number of pages...");
var lastPageOption = currentPageOptions.LastOrDefault();
if (currentPageOption != null)
{
int.TryParse(currentPageOption.GetAttributeValue(THREAD_PAGE_NUMBER_ATTRIBUTE_3, ""), out pageNumber);
}
if (lastPageOption != null)
{
int.TryParse(lastPageOption.GetAttributeValue(THREAD_PAGE_NUMBER_ATTRIBUTE_3, ""), out lastPage);
}
page.PageNumber = pageNumber;
page.LastPage = lastPage;
}
else
{
AwfulDebugger.AddLog(top, AwfulDebugger.Level.Debug, "Page number parsing failed.");
// set page number
page.PageNumber = 1;
page.LastPage = 1;
}
return(page);
}
private Uri InitiateReply(ThreadReplyData data, int timeout = DEFAULT_TIMEOUT)
{
// create request
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "Creating Reply Request...");
string url = "http://forums.somethingawful.com/newreply.php";
var request = AwfulWebRequest.CreateFormDataPostRequest(url, REPLY_CONTENT_TYPE);
if (request == null)
{
throw new NullReferenceException("request is not an http request.");
}
request.AllowAutoRedirect = true;
// begin request stream
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "Beginning Request Stream...");
var signal = new AutoResetEvent(false);
var result = request.BeginGetRequestStream(callback => { signal.Set(); }, request);
signal.WaitOne();
// process request
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "Creating Form Data...");
FormDataDelegate replyFormData = () => { return(GetReplyMultipartFormData(data)); };
var success = ProcessReplyRequest(result, replyFormData);
// begin response
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "Waiting for response...");
request = result.AsyncState as HttpWebRequest;
result = request.BeginGetResponse(callback => { signal.Set(); }, request);
signal.WaitOne(timeout);
if (!result.IsCompleted)
{
throw new TimeoutException("Thread Reply: timeout reached");
}
// process response and return status value
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "Processing response...");
Uri redirect = HandleGetResponse(result);
return(redirect);
}
public static bool CopyResourceFileToIsoStore(string source, string destination)
{
bool success = false;
try
{
var bytes = ReadFileFromResourceStore(source);
success = bytes.SaveBinaryToIsoStore(destination);
}
catch (Exception ex)
{
AwfulDebugger.AddLog(new object(), AwfulDebugger.Level.Critical, ex);
success = false;
}
return(success);
}
protected virtual string ParseNode(HtmlNode node)
{
StringBuilder builder = new StringBuilder();
while (node != null)
{
try { ProcessNode(node, builder); }
catch (Exception ex)
{
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Critical, ex);
}
node = node.NextSibling;
}
return(builder.ToString());
}
public void SaveStateToIsoStorage()
{
try
{
MainDataSource.Instance.Pins.SaveToFile("pins.xml");
MainDataSource.Instance.Bookmarks.SaveToFile("bookmarks.xml");
MainDataSource.Instance.ThreadTable.SaveToFile("threads.xml");
MainDataSource.Instance.Forums.SaveToFile("forums.xml");
}
catch (Exception ex) { AwfulDebugger.AddLog(this, AwfulDebugger.Level.Critical, ex); }
finally
{
AwfulDebugger.SaveAndDispose();
}
}
private Uri InitiateEditRequest(PostEditData data, int timeout = CoreConstants.DEFAULT_TIMEOUT_IN_MILLISECONDS)
{
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "Begin Edit Request...");
string url = "http://forums.somethingawful.com/editpost.php";
var request = AwfulWebRequest.CreateFormDataPostRequest(url, EDIT_CONTENT_TYPE);
if (request == null)
{
throw new NullReferenceException("request is not an http request.");
}
request.AllowAutoRedirect = true;
// begin request stream
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "Processing request stream...");
var signal = new AutoResetEvent(false);
var result = request.BeginGetRequestStream(callback => { signal.Set(); }, request);
signal.WaitOne();
// process request
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "Creating form data...");
FormDataDelegate editFormData = () => { return(GetEditMultipartFormData(data)); };
var success = ProcessReplyRequest(result, editFormData);
// begin response
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "Waiting for server response...");
request = result.AsyncState as HttpWebRequest;
result = request.BeginGetResponse(callback => { signal.Set(); }, request);
signal.WaitOne(timeout);
if (!result.IsCompleted)
{
throw new TimeoutException("The timeout was reached while trying to send an edit request.");
}
// process response and return status value
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Debug, "Processing server response...");
Uri redirect = HandleGetResponse(result);
return(redirect);
}
public static bool DeleteFileFromStorage(string filepath)
{
bool deleted = false;
try
{
IsolatedStorageFile storage = IsolatedStorageFile.GetUserStoreForApplication();
if (storage.FileExists(filepath))
{
storage.DeleteFile(filepath);
deleted = true;
}
}
catch (Exception ex) { AwfulDebugger.AddLog(new object(), AwfulDebugger.Level.Critical, ex); }
return(deleted);
}
// Code to execute on Unhandled Exceptions
private void Application_UnhandledException(object sender, ApplicationUnhandledExceptionEventArgs e)
{
string stackTrace = e.ExceptionObject.StackTrace == null
? e.ExceptionObject.InnerException.StackTrace.ToString()
: e.ExceptionObject.StackTrace.ToString();
string message = e.ExceptionObject.Message == null
? e.ExceptionObject.InnerException.Message
: e.ExceptionObject.Message;
AwfulDebugger.AddLog(sender, AwfulDebugger.Level.Critical, e.ExceptionObject);
MessageBox.Show(stackTrace, message, MessageBoxButton.OK);
if (System.Diagnostics.Debugger.IsAttached)
{
// An unhandled exception has occurred; break into the debugger
System.Diagnostics.Debugger.Break();
}
}
private void LoadFromQuery()
{
var query = NavigationContext.QueryString;
if (query.ContainsKey("link"))
{
string value = query["link"];
try
{
this.threadSlideView.ControlViewModel.LoadPageFromUri(new Uri(value));
}
catch (Exception ex)
{
AwfulDebugger.AddLog(this, AwfulDebugger.Level.Critical, ex);
NavigationService.GoBack();
}
}
else if (query.ContainsKey("id") && query.ContainsKey("nav"))
{
string ThreadID = query["id"];
ThreadMetadata thread = new ThreadMetadata()
{
ThreadID = ThreadID
};
switch (query["nav"])
{
case "unread":
this.threadSlideView.ControlViewModel.LoadFirstUnreadPost(thread);
break;
case "last":
this.threadSlideView.ControlViewModel.LoadLastPost(thread);
break;
case "page":
int pageNumber = -1;
int.TryParse(query["pagenumber"], out pageNumber);
this.threadSlideView.ControlViewModel.LoadPageNumber(thread, pageNumber);
break;
}
}
}
public static bool SaveToFile <T>(this T item, string filePath)
{
AwfulDebugger.AddLog(item, AwfulDebugger.Level.Debug, "START SaveToFile()");
AwfulDebugger.AddLog(item, AwfulDebugger.Level.Debug, "Filepath: " + filePath);
bool result = false;
try
{
AwfulDebugger.AddLog(item, AwfulDebugger.Level.Debug, "Getting application user store...");
var storage = IsolatedStorageFile.GetUserStoreForApplication();
if (storage.BuildPath(filePath))
{
AwfulDebugger.AddLog(item, AwfulDebugger.Level.Debug, "Creating DataContractSerializer...");
DataContractSerializer dcs = new DataContractSerializer(item.GetType());
using (IsolatedStorageFileStream fileStream = new IsolatedStorageFileStream(filePath,
System.IO.FileMode.Create, System.IO.FileAccess.Write, storage))
{
AwfulDebugger.AddLog(item, AwfulDebugger.Level.Debug, "Writing serlialized object to filestream...");
dcs.WriteObject(fileStream, item);
result = true;
AwfulDebugger.AddLog(item, AwfulDebugger.Level.Debug, "Write complete.");
AwfulDebugger.AddLog(item, AwfulDebugger.Level.Info, "Save successful!");
}
}
}
catch (Exception ex)
{
AwfulDebugger.AddLog(item, AwfulDebugger.Level.Info, "Save failed.");
AwfulDebugger.AddLog(item, AwfulDebugger.Level.Critical, ex);
result = false;
#if DEBUG
throw ex;
#endif
}
AwfulDebugger.AddLog(item, AwfulDebugger.Level.Debug, "END SaveToFile()");
return(result);
}
private static bool BuildPath(this IsolatedStorageFile storage, string path)
{
bool success = false;
try
{
var folders = path.Split('/');
for (int i = 0; i < folders.Length - 1; i++)
{
if (!storage.DirectoryExists(folders[i]))
{
storage.CreateDirectory(folders[i]);
}
}
success = true;
}
catch (Exception ex) {
AwfulDebugger.AddLog(new object(), AwfulDebugger.Level.Critical, ex);
success = false;
}
return(success);
}
private static ThreadMetadata ParseColorCategory(this ThreadMetadata thread, HtmlNode node)
{
// code block example: <td class="star bm0">
var colorNode = node.Descendants("td").Where(aNode => aNode.GetAttributeValue("class", "")
.Contains("star")).FirstOrDefault();
if (colorNode != null)
{
try
{
string colorValue = colorNode.GetAttributeValue("class", "");
string categoryToken = colorValue.Split(new char[] { ' ' })[1];
thread.ColorCategory = ConvertColorValueToBookmarkCategory(categoryToken);
}
catch (Exception ex)
{
AwfulDebugger.AddLog(thread, AwfulDebugger.Level.Info, ex);
thread.ColorCategory = BookmarkColorCategory.Unknown;
}
}
return(thread);
}
