public void ConstructorNullReaderQuotas()
{
JsonReaderWriterFactory.CreateJsonReader(GetInput("{}"), null);
}
internal void UpdateTask()
{
Global.UpdateModel = null;
if (!UserSettings.All.CheckForUpdates)
{
return;
}
#if !UWP
try
{
var request = (HttpWebRequest)WebRequest.Create("https://api.github.com/repos/NickeManarin/ScreenToGif/releases/latest");
request.UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.79 Safari/537.36 Edge/14.14393";
request.Proxy = WebHelper.GetProxy();
var response = (HttpWebResponse)request.GetResponse();
using (var resultStream = response.GetResponseStream())
{
if (resultStream == null)
{
return;
}
using (var reader = new StreamReader(resultStream))
{
var result = reader.ReadToEnd();
var jsonReader = JsonReaderWriterFactory.CreateJsonReader(Encoding.UTF8.GetBytes(result), new System.Xml.XmlDictionaryReaderQuotas());
var release = XElement.Load(jsonReader);
var version = Version.Parse(release.XPathSelectElement("tag_name")?.Value ?? "0.1");
if (version.Major == 0 || version <= Assembly.GetExecutingAssembly().GetName().Version)
{
return;
}
Global.UpdateModel = new UpdateModel
{
Version = version,
Description = release.XPathSelectElement("body")?.Value ?? "",
InstallerDownloadUrl = release.XPathSelectElement("assets/item[2]/browser_download_url")?.Value ?? "",
InstallerSize = Convert.ToInt64(release.XPathSelectElement("assets/item[2]/size")?.Value ?? "0"),
PortableDownloadUrl = release.XPathSelectElement("assets/item[1]/browser_download_url")?.Value ?? "",
PortableSize = Convert.ToInt64(release.XPathSelectElement("assets/item[1]/size")?.Value ?? "0")
};
Application.Current.Dispatcher.Invoke(() => NotificationManager.AddNotification(string.Format(LocalizationHelper.Get("Update.NewRelease.Verbose"), Global.UpdateModel.Version), StatusType.Update, "update", UpdateAction));
}
}
}
catch (Exception ex)
{
LogWriter.Log(ex, "Check for update task");
}
#endif
GC.Collect();
}
protected override void DownloadHTMLPage()
{
List <string> thumbs = new List <string>();
string htmlPage = "";
string str = "";
string baseURL = "//i.4cdn.org/" + URL.Split('/')[3] + "/";
string JURL = "http://a.4cdn.org/" + URL.Split('/')[3] + "/thread/" + URL.Split('/')[5] + ".json";
try
{
//Add a UserAgent to prevent 403
using (var web = new WebClient())
{
web.Headers["User-Agent"] = "Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:47.0) Gecko/20100101 Firefox/47.0";
htmlPage = web.DownloadString(URL);
//Prevent the html from being destroyed by the anti adblock script
htmlPage = htmlPage.Replace("f=\"to\"", "f=\"penis\"");
string json = web.DownloadString(JURL);
byte[] bytes = Encoding.ASCII.GetBytes(json);
using (var stream = new MemoryStream(bytes))
{
var quotas = new XmlDictionaryReaderQuotas();
var jsonReader = JsonReaderWriterFactory.CreateJsonReader(stream, quotas);
var xml = XDocument.Load(jsonReader);
str = xml.ToString();
}
}
XmlDocument doc = new XmlDocument();
doc.LoadXml(str);
XmlNodeList xmlTim = doc.DocumentElement.SelectNodes("/root/posts/item/tim");
XmlNodeList xmlExt = doc.DocumentElement.SelectNodes("/root/posts/item/ext");
XmlNodeList xmlFilenames = doc.DocumentElement.SelectNodes("/root/posts/item/filename");
for (int i = 0; i < xmlExt.Count; i++)
{
string old = baseURL + xmlTim[i].InnerText + xmlExt[i].InnerText;
string rep = xmlTim[i].InnerText + xmlExt[i].InnerText;
htmlPage = htmlPage.Replace(old, rep);
//get the actual filename saved
string filename = Path.GetFileNameWithoutExtension(new ImageLink(baseURL + xmlTim[i].InnerText + xmlExt[i].InnerText, xmlFilenames[i].InnerText).GenerateNewFilename((ImageFileNameFormat)Properties.Settings.Default.imageFilenameFormat));
//Save thumbs for files that need it
if (rep.Split('.')[1] == "webm" /*|| rep.Split('.')[1] == ""*/)
{
old = "//t.4cdn.org/" + URL.Split('/')[3] + "/" + xmlTim[i].InnerText + "s.jpg";
thumbs.Add("http:" + old);
htmlPage = htmlPage.Replace(xmlTim[i].InnerText, filename);
htmlPage = htmlPage.Replace("//i.4cdn.org/" + URL.Split('/')[3] + "/" + filename, "thumb/" + xmlTim[i].InnerText);
}
else
{
string thumbName = rep.Split('.')[0] + "s";
htmlPage = htmlPage.Replace(thumbName + ".jpg", rep.Split('.')[0] + "." + rep.Split('.')[1]);
htmlPage = htmlPage.Replace("/" + thumbName, thumbName);
htmlPage = htmlPage.Replace("//i.4cdn.org/" + URL.Split('/')[3] + "/" + xmlTim[i].InnerText, xmlTim[i].InnerText);
htmlPage = htmlPage.Replace(xmlTim[i].InnerText, filename); //easy fix for images
}
htmlPage = htmlPage.Replace("//is2.4chan.org/" + URL.Split('/')[3] + "/" + xmlTim[i].InnerText, xmlTim[i].InnerText); //bandaid fix for is2 urls
htmlPage = htmlPage.Replace("/" + rep, rep);
}
htmlPage = htmlPage.Replace("=\"//", "=\"http://");
//Save thumbs for files that need it
for (int i = 0; i < thumbs.Count; i++)
{
Utils.DownloadToDir(thumbs[i], SaveTo + "\\thumb");
}
if (!string.IsNullOrWhiteSpace(htmlPage))
{
File.WriteAllText(SaveTo + "\\Thread.html", htmlPage);
}
}
catch (Exception ex)
{
Program.Log(ex);
}
}
public static WeatherForecast GetForecast(string area)
{
WeatherForecast f = new WeatherForecast();
try
{
string json = GetJson(area, "forecast");
if (!json.Equals(string.Empty) && !json.Contains("error data"))
{
XmlDictionaryReader reader = JsonReaderWriterFactory.CreateJsonReader(Encoding.UTF8.GetBytes(json), XmlDictionaryReaderQuotas.Max);
XmlDocument xdoc = new XmlDocument();
xdoc.Load(reader);
Log.WriteDebug("GetForecast>xdoc>>>>>" + xdoc.InnerText);
#region 输出完整的XML，分析格式
//StringWriter stringWriter = new StringWriter();
//XmlTextWriter xmlTextWriter = new XmlTextWriter(stringWriter);
//xmlTextWriter.Formatting = Formatting.Indented;
//foreach (XmlNode xmlNode in xdoc)
//{
// xmlNode.WriteTo(xmlTextWriter);
//}
//Log.WriteLog(stringWriter.ToString());
#endregion
#region 用xml解析json,并为相关的成员变量赋值
///获取到的属性信息
XmlNode info = xdoc.FirstChild.SelectSingleNode("c");
f.AreaID = info.SelectSingleNode("c1").InnerText;
f.ENName = info.SelectSingleNode("c2").InnerText;
f.CNName = info.SelectSingleNode("c3").InnerText;
f.ENCityName = info.SelectSingleNode("c4").InnerText;
f.CNCityName = info.SelectSingleNode("c5").InnerText;
f.ENProvName = info.SelectSingleNode("c6").InnerText;
f.CNProvName = info.SelectSingleNode("c7").InnerText;
f.ENCountryName = info.SelectSingleNode("c8").InnerText;
f.CNCountryName = info.SelectSingleNode("c9").InnerText;
f.CityLevel = uint.Parse(info.SelectSingleNode("c10").InnerText);
f.CityAreaCode = info.SelectSingleNode("c11").InnerText;
f.PostCode = uint.Parse(info.SelectSingleNode("c12").InnerText);
f.Longitude = float.Parse(info.SelectSingleNode("c13").InnerText);
f.Latitude = float.Parse(info.SelectSingleNode("c14").InnerText);
f.Altitude = int.Parse(info.SelectSingleNode("c15").InnerText);
f.RadarStationNo = info.SelectSingleNode("c16").InnerText;
///f0 数据发布时间
IFormatProvider culture = new System.Globalization.CultureInfo("fr-FR", true);
f.PublishTime = System.DateTime.ParseExact(xdoc.FirstChild.SelectSingleNode("f").SelectSingleNode("f0").FirstChild.InnerText, "yyyyMMddHHmm", culture);
///第一天
XmlNode DayOne = xdoc.FirstChild.SelectSingleNode("f").SelectSingleNode("f1").FirstChild;
f.DayWeatherCodeOne = DayOne.SelectSingleNode("fa").InnerText;
f.NightWeatherCodeOne = DayOne.SelectSingleNode("fb").InnerText;
f.DayTemperatureOne = DayOne.SelectSingleNode("fc").InnerText;
f.NightTemperatureOne = DayOne.SelectSingleNode("fd").InnerText;
f.DayWindDirectionOne = DayOne.SelectSingleNode("fe").InnerText;
f.NightWindDirectionOne = DayOne.SelectSingleNode("ff").InnerText;
f.DayWindForceOne = DayOne.SelectSingleNode("fg").InnerText;
f.NightWindForceOne = DayOne.SelectSingleNode("fh").InnerText;
f.SunriseTimeOne = DayOne.SelectSingleNode("fi").InnerText.Split('|')[0];
f.SunsetTimeOne = DayOne.SelectSingleNode("fi").InnerText.Split('|')[1];
///第二天
XmlNode DayTwo = DayOne.NextSibling;
f.DayWeatherCodeTwo = DayTwo.SelectSingleNode("fa").InnerText;
f.NightWeatherCodeTwo = DayTwo.SelectSingleNode("fb").InnerText;
f.DayTemperatureTwo = DayTwo.SelectSingleNode("fc").InnerText;
f.NightTemperatureTwo = DayTwo.SelectSingleNode("fd").InnerText;
f.DayWindDirectionTwo = DayTwo.SelectSingleNode("fe").InnerText;
f.NightWindDirectionTwo = DayTwo.SelectSingleNode("ff").InnerText;
f.DayWindForceTwo = DayTwo.SelectSingleNode("fg").InnerText;
f.NightWindForceTwo = DayTwo.SelectSingleNode("fh").InnerText;
f.SunriseTimeTwo = DayTwo.SelectSingleNode("fi").InnerText.Split('|')[0];
f.SunsetTimeTwo = DayTwo.SelectSingleNode("fi").InnerText.Split('|')[1];
///第三天
XmlNode DayThree = DayTwo.NextSibling;
f.DayWeatherCodeThree = DayThree.SelectSingleNode("fa").InnerText;
f.NightWeatherCodeThree = DayThree.SelectSingleNode("fb").InnerText;
f.DayTemperatureThree = DayThree.SelectSingleNode("fc").InnerText;
f.NightTemperatureThree = DayThree.SelectSingleNode("fd").InnerText;
f.DayWindDirectionThree = DayThree.SelectSingleNode("fe").InnerText;
f.NightWindDirectionThree = DayThree.SelectSingleNode("ff").InnerText;
f.DayWindForceThree = DayThree.SelectSingleNode("fg").InnerText;
f.NightWindForceThree = DayThree.SelectSingleNode("fh").InnerText;
f.SunriseTimeThree = DayThree.SelectSingleNode("fi").InnerText.Split('|')[0];
f.SunsetTimeThree = DayThree.SelectSingleNode("fi").InnerText.Split('|')[1];
#endregion
}
}
catch (Exception ex)
{
Log.WriteError("GetForecast错误>>>>>" + ex.Message);
}
return(f);
}
public async Task UpdatePackageInfoAsync(PipPackageView package, CancellationToken cancel)
{
string description = null;
List <string> versions = null;
using (var client = new WebClient()) {
Stream data;
try {
data = await client.OpenReadTaskAsync(new Uri(_index ?? DefaultIndex, package.Name + "/json"));
} catch (WebException) {
// No net access
return;
}
try {
using (var reader = JsonReaderWriterFactory.CreateJsonReader(data, new XmlDictionaryReaderQuotas())) {
var doc = XDocument.Load(reader);
// TODO: Get package URL
//url = (string)doc.Document
// .Elements("root")
// .Elements("info")
// .Elements("package_url")
// .FirstOrDefault();
description = (string)doc.Document
.Elements("root")
.Elements("info")
.Elements("description")
.FirstOrDefault();
versions = doc.Document
.Elements("root")
.Elements("releases")
.Elements()
.Attributes("item")
.Select(a => a.Value)
.ToList();
}
} catch (InvalidOperationException) {
}
}
cancel.ThrowIfCancellationRequested();
bool changed = false;
await _cacheLock.WaitAsync();
try {
PipPackageView inCache;
if (!_cache.TryGetValue(package.Name, out inCache))
{
inCache = _cache[package.Name] = new PipPackageView(this, package.Name, null, null);
}
if (!string.IsNullOrEmpty(description))
{
var lines = description.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None);
var firstLine = string.Join(
" ",
lines.TakeWhile(s => !IsSeparatorLine(s)).Select(s => s.Trim())
);
if (firstLine.Length > 500)
{
firstLine = firstLine.Substring(0, 497) + "...";
}
if (firstLine == "UNKNOWN")
{
firstLine = string.Empty;
}
inCache.Description = firstLine;
package.Description = firstLine;
changed = true;
}
if (versions != null)
{
var updateVersion = Pep440Version.TryParseAll(versions)
.Where(v => v.IsFinalRelease)
.OrderByDescending(v => v)
.FirstOrDefault();
inCache.UpgradeVersion = updateVersion;
package.UpgradeVersion = updateVersion;
changed = true;
}
} finally {
_cacheLock.Release();
}
if (changed)
{
TriggerWriteCacheToDisk();
}
}
protected override void OnWriteBodyContents(XmlDictionaryWriter writer)
{
writer.WriteNode(JsonReaderWriterFactory.CreateJsonReader(this.jsonStream, XmlDictionaryReaderQuotas.Max), false);
writer.Flush();
}
/// <summary>
/// RequestAPI implementation
/// </summary>
/// <param name="uri">full uri</param>
/// <param name="method">using method for HTTP negotiation</param>
/// <param name="param">additional parameters</param>
/// <param name="request">used request</param>
/// <returns>XML documents</returns>
public sealed override XDocument RequestAPI(string uri, RequestMethod method, IEnumerable <KeyValuePair <string, string> > param, out HttpWebRequest request)
{
// validate arguments
if (String.IsNullOrEmpty(uri))
{
throw new ArgumentNullException(uri);
}
else if (uri.Length < 5)
{
throw new ArgumentException("uri is too short.");
}
string target = uri;
// detection return type of api
var docType = DocumentTypes.Invalid;
if (target.EndsWith("xml"))
{
docType = DocumentTypes.Xml;
}
else if (target.EndsWith("json"))
{
docType = DocumentTypes.Json;
}
else
{
throw new ArgumentException("format can't identify. uriPartial is must ends with .xml or .json.");
}
// pre-validation authentication
if (String.IsNullOrEmpty(Token) || String.IsNullOrEmpty(Secret))
{
throw new WebException("OAuth Not Validated", WebExceptionStatus.ProtocolError);
}
var reg = GetHeader(target, method, param);
try
{
var ps = JoinParamAsUrl(param);
byte[] body = null;
if (!String.IsNullOrWhiteSpace(ps))
{
if (method == RequestMethod.GET)
{
target += "?" + ps;
}
if (method == RequestMethod.POST)
{
body = Encoding.ASCII.GetBytes(ps);
}
}
request = Http.CreateRequest(new Uri(target), method.ToString(), contentType: "application/x-www-form-urlencoded");
request.Headers.Add("Authorization", "OAuth " + reg);
var ret = Http.WebConnect <XDocument>(request,
responseconv: res =>
{
switch (docType)
{
case DocumentTypes.Xml:
return(this.XDocumentGenerator(res));
case DocumentTypes.Json:
return(this.XDocumentGenerator(res, (s) => JsonReaderWriterFactory.CreateJsonReader(s, XmlDictionaryReaderQuotas.Max)));
default:
throw new NotSupportedException("Invalid format.");
}
}, senddata: body);
if (ret.Succeeded)
{
return(ret.Data);
}
else
{
if (ret.ThrownException != null)
{
throw ret.ThrownException;
}
else
{
throw new WebException();
}
}
}
catch (WebException)
{
throw;
}
catch (XmlException)
{
throw;
}
catch (IOException)
{
throw;
}
}
private void ProcessJsonFromPostRequest()
{
XmlReader reader =
JsonReaderWriterFactory
.CreateJsonReader(Encoding.UTF8.GetBytes(this.ResponseContent), new XmlDictionaryReaderQuotas());
XElement root = XElement.Load(reader);
XElement postqueryElm = root.XPathSelectElement("//postquery");
if (postqueryElm != null)
{
XElement elapsedTimeElm = postqueryElm.Element("ElapsedTime");
if (elapsedTimeElm != null)
{
this.QueryElapsedTime = elapsedTimeElm.Value;
}
XElement propertiesElm = postqueryElm.Element("Properties");
if (propertiesElm != null && propertiesElm.HasElements)
{
if (propertiesElm.Element("results") != null)
{
foreach (var item in propertiesElm.Element("results").Elements("item"))
{
if (item != null && item.Element("Key") != null)
{
if (item.Element("Key").Value == "SerializedQuery")
{
this.SerializedQuery = item.Element("Value").Value;
}
}
}
}
}
#region Triggered Rules
XElement triggeredRulesElm = postqueryElm.Element("TriggeredRules");
if (triggeredRulesElm != null && triggeredRulesElm.HasElements)
{
if (triggeredRulesElm.Element("results") != null)
{
this.TriggeredRules = new List <string>();
foreach (var item in triggeredRulesElm.Element("results").Elements("item"))
{
this.TriggeredRules.Add(item.Value);
}
}
}
#endregion
#region Primary Query Results
XElement primaryQueryResult = postqueryElm.Element("PrimaryQueryResult");
if (primaryQueryResult != null)
{
this.PrimaryQueryResult = new QueryResult();
if (primaryQueryResult.Element("QueryId") != null)
{
this.PrimaryQueryResult.QueryId = (string)primaryQueryResult.Element("QueryId");
}
if (primaryQueryResult.Element("QueryRuleId") != null)
{
this.PrimaryQueryResult.QueryRuleId = (string)primaryQueryResult.Element("QueryRuleId");
}
#region Relevant Results
var relevantResults = primaryQueryResult.Element("RelevantResults");
if (relevantResults != null)
{
if (relevantResults.Element("TotalRows") != null)
{
this.PrimaryQueryResult.TotalRows = (int)relevantResults.Element("TotalRows");
}
if (relevantResults.Element("TotalRowsIncludingDuplicates") != null)
{
this.PrimaryQueryResult.TotalRowsIncludingDuplicates = (int)relevantResults.Element("TotalRowsIncludingDuplicates");
}
XElement queryMod = relevantResults.Descendants("Key").FirstOrDefault(e => e.Value == "QueryModification");
if (queryMod != null)
{
this.PrimaryQueryResult.QueryModification = queryMod.XPathSelectElement("..").Element("Value").Value;
}
var table = relevantResults.Element("Table");
if (table != null && table.HasElements)
{
var rows = table.Element("Rows");
if (rows != null && rows.Element("results") != null && rows.Element("results").HasElements)
{
List <ResultItem> resultItems = new List <ResultItem>();
var items = rows.Element("results").Elements("item");
foreach (var item in items)
{
ResultItem resultItem = new ResultItem();
if (item.Element("Cells") != null && item.Element("Cells").Element("results") != null &&
item.Element("Cells").Element("results").HasElements)
{
var itemValues = item.Element("Cells").Element("results").Elements("item");
foreach (var itemValue in itemValues)
{
resultItem.Add(itemValue.Element("Key").Value, itemValue.Element("Value").Value);
}
}
resultItems.Add(resultItem);
}
this.PrimaryQueryResult.RelevantResults = resultItems;
}
}
}
#endregion
#region Refinement Results
var refinementResults = primaryQueryResult.Element("RefinementResults");
if (refinementResults != null)
{
var refiners = refinementResults.Element("Refiners");
if (refiners != null && refiners.HasElements)
{
var results = refiners.Element("results");
if (results != null && results.HasElements)
{
List <RefinerResult> refinerResults = new List <RefinerResult>();
var items = results.Elements("item");
foreach (var item in items)
{
RefinerResult refinerResult = new RefinerResult();
refinerResult.Name = (string)item.Element("Name");
if (item.Element("Entries") != null && item.Element("Entries").Element("results") != null &&
item.Element("Entries").Element("results").HasElements)
{
var entries = item.Element("Entries").Element("results").Elements("item");
foreach (var entry in entries)
{
refinerResult.Add(new RefinementItem
{
Count = (long)entry.Element("RefinementCount"),
Name = (string)entry.Element("RefinementName"),
Token = (string)entry.Element("RefinementToken"),
Value = (string)entry.Element("RefinementValue"),
});
}
}
refinerResults.Add(refinerResult);
}
this.PrimaryQueryResult.RefinerResults = refinerResults;
}
}
}
#endregion
}
#endregion
#region Secondary Query Results
XElement secondaryQueryResults = postqueryElm.Element("SecondaryQueryResults");
if (secondaryQueryResults != null && secondaryQueryResults.Element("results") != null)
{
var resultsElm = secondaryQueryResults.Element("results");
if (resultsElm.HasElements)
{
this.SecondaryQueryResults = new List <QueryResult>();
var resultItems = resultsElm.Elements("item");
foreach (var resultItem in resultItems)
{
QueryResult secondaryQueryResult = new QueryResult();
if (resultItem.Element("QueryId") != null)
{
secondaryQueryResult.QueryId = (string)resultItem.Element("QueryId");
}
if (resultItem.Element("QueryRuleId") != null)
{
secondaryQueryResult.QueryRuleId = (string)resultItem.Element("QueryRuleId");
}
var relevantResults = resultItem.Element("RelevantResults");
if (relevantResults != null)
{
if (relevantResults.Element("TotalRows") != null)
{
secondaryQueryResult.TotalRows = (int)relevantResults.Element("TotalRows");
}
if (relevantResults.Element("TotalRowsIncludingDuplicates") != null)
{
secondaryQueryResult.TotalRowsIncludingDuplicates = (int)relevantResults.Element("TotalRowsIncludingDuplicates");
}
XElement queryMod = relevantResults.Descendants("Key").FirstOrDefault(e => e.Value == "QueryModification");
if (queryMod != null)
{
secondaryQueryResult.QueryModification = queryMod.XPathSelectElement("..").Element("Value").Value;
}
var table = relevantResults.Element("Table");
if (table != null && table.HasElements)
{
var rows = table.Element("Rows");
if (rows != null && rows.Element("results") != null && rows.Element("results").HasElements)
{
List <ResultItem> resultRows = new List <ResultItem>();
var items = rows.Element("results").Elements("item");
foreach (var item in items)
{
ResultItem resultRow = new ResultItem();
if (item.Element("Cells") != null && item.Element("Cells").Element("results") != null &&
item.Element("Cells").Element("results").HasElements)
{
var itemValues = item.Element("Cells").Element("results").Elements("item");
foreach (var itemValue in itemValues)
{
resultRow.Add(itemValue.Element("Key").Value, itemValue.Element("Value").Value);
}
}
resultRows.Add(resultRow);
}
secondaryQueryResult.RelevantResults = resultRows;
}
}
}
this.SecondaryQueryResults.Add(secondaryQueryResult);
}
}
}
#endregion
}
}
private void downloadHTMLPage()
{
List <string> thumbs = new List <string>();
string htmlPage = "";
string str = "";
string baseURL = "//i.4cdn.org/" + getURL().Split('/')[3] + "/";
string JURL = "http://a.4cdn.org/" + getURL().Split('/')[3] + "/thread/" + getURL().Split('/')[5] + ".json";
try
{
//Add a UserAgent to prevent 403
WebClient web = new WebClient();
web.Headers["User-Agent"] = "Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:47.0) Gecko/20100101 Firefox/47.0";
htmlPage = web.DownloadString(getURL());
//Prevent the html from being destroyed by the anti adblock script
htmlPage = htmlPage.Replace("f=\"to\"", "f=\"penis\"");
string json = web.DownloadString(JURL);
byte[] bytes = Encoding.ASCII.GetBytes(json);
using (var stream = new MemoryStream(bytes))
{
var quotas = new XmlDictionaryReaderQuotas();
var jsonReader = JsonReaderWriterFactory.CreateJsonReader(stream, quotas);
var xml = XDocument.Load(jsonReader);
str = xml.ToString();
}
XmlDocument doc = new XmlDocument();
doc.LoadXml(str);
XmlNodeList xmlTim = doc.DocumentElement.SelectNodes("/root/posts/item/tim");
XmlNodeList xmlExt = doc.DocumentElement.SelectNodes("/root/posts/item/ext");
for (int i = 0; i < xmlExt.Count; i++)
{
string old = baseURL + xmlTim[i].InnerText + xmlExt[i].InnerText;
string rep = xmlTim[i].InnerText + xmlExt[i].InnerText;
htmlPage = htmlPage.Replace(old, rep);
//Save thumbs for files that need it
if (rep.Split('.')[1] == "webm" /*|| rep.Split('.')[1] == ""*/)
{
old = "//t.4cdn.org/" + getURL().Split('/')[3] + "/" + xmlTim[i].InnerText + "s.jpg";
thumbs.Add("http:" + old);
htmlPage = htmlPage.Replace("//i.4cdn.org/" + getURL().Split('/')[3] + "/" + xmlTim[i].InnerText, "thumb/" + xmlTim[i].InnerText);
}
else
{
string thumbName = rep.Split('.')[0] + "s";
htmlPage = htmlPage.Replace(thumbName + ".jpg", rep.Split('.')[0] + "." + rep.Split('.')[1]);
htmlPage = htmlPage.Replace("/" + thumbName, thumbName);
htmlPage = htmlPage.Replace("//i.4cdn.org/" + getURL().Split('/')[3] + "/" + xmlTim[i].InnerText, xmlTim[i].InnerText);
}
htmlPage = htmlPage.Replace("//is2.4chan.org/" + getURL().Split('/')[3] + "/" + xmlTim[i].InnerText, xmlTim[i].InnerText);
htmlPage = htmlPage.Replace("/" + rep, rep);
}
htmlPage = htmlPage.Replace("=\"//", "=\"http://");
//Save thumbs for files that need it
for (int i = 0; i < thumbs.Count; i++)
{
General.DownloadToDir(thumbs[i], SaveTo + "\\thumb");
}
if (!string.IsNullOrWhiteSpace(htmlPage))
{
File.WriteAllText(SaveTo + "\\Thread.html", htmlPage);
}
}
catch
{
throw;
}
}
/// <summary>
/// Called during deserialization to read an object of the specified <paramref name="type"/>
/// from the specified <paramref name="readStream"/>.
/// </summary>
/// <param name="type">The type of object to read.</param>
/// <param name="readStream">The <see cref="Stream"/> from which to read.</param>
/// <param name="content">The <see cref="HttpContent"/> for the content being written.</param>
/// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param>
/// <returns>A <see cref="Task"/> whose result will be the object instance that has been read.</returns>
public override Task <object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
if (type == null)
{
throw Error.ArgumentNull("type");
}
if (readStream == null)
{
throw Error.ArgumentNull("readStream");
}
return(TaskHelpers.RunSynchronously <object>(() =>
{
HttpContentHeaders contentHeaders = content == null ? null : content.Headers;
// If content length is 0 then return default value for this type
if (contentHeaders != null && contentHeaders.ContentLength == 0)
{
return GetDefaultValueForType(type);
}
// Get the character encoding for the content
Encoding effectiveEncoding = SelectCharacterEncoding(contentHeaders);
try
{
if (UseDataContractJsonSerializer)
{
DataContractJsonSerializer dataContractSerializer = GetDataContractSerializer(type);
using (XmlReader reader = JsonReaderWriterFactory.CreateJsonReader(new NonClosingDelegatingStream(readStream), effectiveEncoding, _readerQuotas, null))
{
return dataContractSerializer.ReadObject(reader);
}
}
else
{
using (JsonTextReader jsonTextReader = new JsonTextReader(new StreamReader(readStream, effectiveEncoding))
{
CloseInput = false, MaxDepth = _maxDepth
})
{
JsonSerializer jsonSerializer = JsonSerializer.Create(_jsonSerializerSettings);
if (formatterLogger != null)
{
// Error must always be marked as handled
// Failure to do so can cause the exception to be rethrown at every recursive level and overflow the stack for x64 CLR processes
jsonSerializer.Error += (sender, e) =>
{
Exception exception = e.ErrorContext.Error;
formatterLogger.LogError(e.ErrorContext.Path, exception);
e.ErrorContext.Handled = true;
};
}
return jsonSerializer.Deserialize(jsonTextReader, type);
}
}
}
catch (Exception e)
{
if (formatterLogger == null)
{
throw;
}
formatterLogger.LogError(String.Empty, e);
return GetDefaultValueForType(type);
}
}));
}
private string MessageToString(ref Message message, bool isRequest)
{
WebContentFormat messageFormat = this.GetMessageContentFormat(message);
MemoryStream ms = new MemoryStream();
XmlDictionaryWriter writer = null;
switch (messageFormat)
{
case WebContentFormat.Default:
case WebContentFormat.Xml:
writer = XmlDictionaryWriter.CreateTextWriter(ms);
break;
case WebContentFormat.Json:
writer = JsonReaderWriterFactory.CreateJsonWriter(ms);
break;
case WebContentFormat.Raw:
return(CreateRawResponse(ref message));
}
message.WriteMessage(writer);
writer.Flush();
string messageBody = Encoding.UTF8.GetString(ms.ToArray());
// Here would be a good place to change the message body, if so desired.
// now that the message was read, it needs to be recreated.
ms.Position = 0;
// if the message body was modified, needs to reencode it, as show below
// ms = new MemoryStream(Encoding.UTF8.GetBytes(messageBody));
XmlDictionaryReader reader;
XmlDictionaryReader xreader;
//parse request - find field and its value
if (messageFormat == WebContentFormat.Json)
{
xreader = JsonReaderWriterFactory.CreateJsonReader(ms, XmlDictionaryReaderQuotas.Max);
}
else
{
xreader = XmlDictionaryReader.CreateTextReader(ms, XmlDictionaryReaderQuotas.Max);
}
this.ParseRequest(xreader);
ms.Position = 0;
if (messageFormat == WebContentFormat.Json)
{
reader = JsonReaderWriterFactory.CreateJsonReader(ms, XmlDictionaryReaderQuotas.Max);
}
else
{
reader = XmlDictionaryReader.CreateTextReader(ms, XmlDictionaryReaderQuotas.Max);
}
Message newMessage = Message.CreateMessage(reader, int.MaxValue, message.Version);
newMessage.Properties.CopyProperties(message.Properties);
newMessage.Headers.CopyHeadersFrom(message.Headers);
message = newMessage;
return(messageBody);
}
/// <summary>Creates an instance from a given stream and source uri</summary>
public ComposerFile(Stream input, string sourceUri = "(stream)")
{
this.input = JsonReaderWriterFactory.CreateJsonReader(input, new XmlDictionaryReaderQuotas());
SourceUri = sourceUri;
}
public static bool FilesViaCloud(string[] localfilepaths, string usertoken, string lcid, string desturl)
{
/* 1. open a session
* DL20180917DSSD */
var command = String.Format("{0}/svc/endpoints/mobile/mobile.aspx?platform={1}&lcid={2}&verb={3}&token={4}&nonce={5}",
desturl,
"sherm",
lcid,
"CAN_HAS_SESSION",
usertoken,
Guid.NewGuid().ToString("N").ToLowerInvariant()
);
try
{
sherm.core.mobile.model.Session session;
string connraw;
using (var wc = new HttpClient())
{
var tconnraw = wc.GetStringAsync(command);
tconnraw.Wait();
connraw = tconnraw.Result;
if (connraw.StartsWith(TransmissionConstants.cstNOK))
{
throw new UnauthorizedAccessException(String.Format("Could not connect to \"{0}\" using token \"{1}\".", desturl, usertoken));
}
}
using (var reader = JsonReaderWriterFactory.CreateJsonReader(System.Text.UTF8Encoding.UTF8.GetBytes(connraw), new System.Xml.XmlDictionaryReaderQuotas {
}))
{
var js = new DataContractJsonSerializer(typeof(sherm.core.mobile.model.SessionRoot));
var sr = (sherm.core.mobile.model.SessionRoot)js.ReadObject(reader);
session = sr.session;
}
if (String.IsNullOrEmpty(session.sessionid))
{
/* could not obtain the session */
LastTransmissionError = String.Format(@"Failed to create a session on ""{0}""", desturl);
return(false);
}
else
{
/* 2. transmit all files that are in this subqueue */
foreach (var file in localfilepaths)
{
var postableurl = String.Format("{0}/svc/endpoints/mobile/mobile.aspx", desturl);
var xmr = TransmitSingleFile(session, postableurl, file);
if (xmr.outcome == TransmissionConstants.cstOK)
{
/* coming this far means no more error */
LastTransmissionError = null;
}
else
{
LastTransmissionError = String.Format(@"Failed to transmit the ""{0}"" file to ""{1}""", file, desturl);
}
}
/* 3. close the session */
command = String.Format("{0}/svc/endpoints/mobile/mobile.aspx?platform={1}&lcid={2}&verb={3}&session={4}&nonce={5}",
desturl,
"shermios",
lcid,
"KTHXBYE",
session.sessionid,
Guid.NewGuid().ToString("N").ToLowerInvariant()
);
using (var wc = new HttpClient())
{
var tbye = wc.GetStringAsync(command);
tbye.Wait();
}
}
/* succeeded */
return(true);
}
catch (Exception ex)
{
LastTransmissionError = ex.Message;
LastTransmissionErrorDetails = ex.ToString();
return(false);
}
}
public void ConstructorNullEncodingAndReaderClose()
{
JsonReaderWriterFactory.CreateJsonReader(GetInput("{}"), null, new XmlDictionaryReaderQuotas(), null);
}
/// <summary>
/// makes HTTP call to Twitter API
/// </summary>
/// <param name="url">URL with all query info</param>
/// <param name="reqProc">Request Processor for Async Results</param>
/// <returns>XML Respose from Twitter</returns>
public string QueryTwitter <T>(string url, IRequestProcessor <T> reqProc)
{
//Log
WriteLog(url, "QueryTwitter");
var uri = new Uri(url);
string responseXml = string.Empty;
string httpStatus = string.Empty;
try
{
this.LastUrl = uri.AbsoluteUri;
var req = this.AuthorizedClient.Get(url);
#if SILVERLIGHT
var reqEx = req as HttpWebRequest;
reqEx.BeginGetResponse(
new AsyncCallback(
ar =>
{
var res = reqEx.EndGetResponse(ar) as HttpWebResponse;
//httpStatus = res.Headers["Status"];
responseXml = GetTwitterResponse(res);
List <T> responseObj = reqProc.ProcessResults(responseXml);
(AsyncCallback as Action <IEnumerable <T> >)(responseObj);
}), null);
#else
Exception asyncException = null;
var resetEvent = new ManualResetEvent(initialState: false);
req.BeginGetResponse(
new AsyncCallback(
ar =>
{
try
{
var res = req.EndGetResponse(ar) as HttpWebResponse;
httpStatus = res.Headers["Status"];
responseXml = GetTwitterResponse(res);
}
catch (Exception ex)
{
asyncException = ex;
}
finally
{
resetEvent.Set();
}
}), null);
resetEvent.WaitOne();
if (asyncException != null)
{
throw asyncException;
}
#endif
}
catch (WebException wex)
{
var twitterQueryEx = CreateTwitterQueryException(wex);
throw twitterQueryEx;
}
if (uri.LocalPath.EndsWith("json"))
{
var stream = new MemoryStream(Encoding.UTF8.GetBytes(responseXml));
XmlDictionaryReader reader = JsonReaderWriterFactory.CreateJsonReader(stream, XmlDictionaryReaderQuotas.Max);
var doc = XDocument.Load(reader);
responseXml = doc.ToString();
}
#if !SILVERLIGHT
CheckResultsForTwitterError(responseXml, httpStatus);
#endif
return(responseXml);
}
/// <summary>
/// Runs a single test. Error messages are displayed to Console.Error, and the return value indicates
/// general success/failure.
/// </summary>
public static bool RunTest(string typeName, string file, byte[] inputData)
{
WriteLine("Benchmarking {0} with file {1}", typeName, file);
IMessage defaultMessage;
try
{
defaultMessage = MessageUtil.GetDefaultMessage(typeName);
}
catch (ArgumentException e)
{
Console.Error.WriteLine(e.Message);
return(false);
}
try
{
ExtensionRegistry registry = ExtensionRegistry.Empty;
inputData = inputData ?? File.ReadAllBytes(file);
MemoryStream inputStream = new MemoryStream(inputData);
ByteString inputString = ByteString.CopyFrom(inputData);
IMessage sampleMessage =
defaultMessage.WeakCreateBuilderForType().WeakMergeFrom(inputString, registry).WeakBuild();
IDictionary <string, object> dictionary = null;
byte[] jsonBytes = null, xmlBytes = null; /*no pun intended, well... maybe for xml*/
if (OtherFormats)
{
using (MemoryStream temp = new MemoryStream())
{
XmlFormatWriter.CreateInstance(temp).WriteMessage(sampleMessage);
xmlBytes = temp.ToArray();
}
using (MemoryStream temp = new MemoryStream())
{
JsonFormatWriter.CreateInstance(temp).WriteMessage(sampleMessage);
jsonBytes = temp.ToArray();
}
dictionary = new Dictionary <string, object>(StringComparer.Ordinal);
new DictionaryWriter(dictionary).WriteMessage(sampleMessage);
}
//Serializers
if (!FastTest)
{
RunBenchmark("Serialize to byte string", inputData.Length, () => sampleMessage.ToByteString());
}
RunBenchmark("Serialize to byte array", inputData.Length, () => sampleMessage.ToByteArray());
if (!FastTest)
{
RunBenchmark("Serialize to memory stream", inputData.Length,
() => sampleMessage.WriteTo(new MemoryStream()));
}
if (OtherFormats)
{
RunBenchmark("Serialize to xml", xmlBytes.Length,
() =>
{
XmlFormatWriter.CreateInstance(new MemoryStream(), Encoding.UTF8).WriteMessage(sampleMessage);
});
RunBenchmark("Serialize to json", jsonBytes.Length,
() => { JsonFormatWriter.CreateInstance().WriteMessage(sampleMessage); });
RunBenchmark("Serialize to json via xml", jsonBytes.Length,
() =>
XmlFormatWriter.CreateInstance(
JsonReaderWriterFactory.CreateJsonWriter(new MemoryStream(), Encoding.UTF8))
.SetOptions(XmlWriterOptions.OutputJsonTypes)
.WriteMessage(sampleMessage)
);
RunBenchmark("Serialize to dictionary", sampleMessage.SerializedSize,
() => new DictionaryWriter().WriteMessage(sampleMessage));
}
//Deserializers
if (!FastTest)
{
RunBenchmark("Deserialize from byte string", inputData.Length,
() => defaultMessage.WeakCreateBuilderForType()
.WeakMergeFrom(inputString, registry)
.WeakBuild()
);
}
RunBenchmark("Deserialize from byte array", inputData.Length,
() => defaultMessage.WeakCreateBuilderForType()
.WeakMergeFrom(CodedInputStream.CreateInstance(inputData), registry)
.WeakBuild()
);
if (!FastTest)
{
RunBenchmark("Deserialize from memory stream", inputData.Length,
() =>
{
inputStream.Position = 0;
defaultMessage.WeakCreateBuilderForType().WeakMergeFrom(
CodedInputStream.CreateInstance(inputStream), registry)
.WeakBuild();
});
}
if (OtherFormats)
{
RunBenchmark("Deserialize from xml", xmlBytes.Length,
() =>
XmlFormatReader.CreateInstance(xmlBytes).Merge(
defaultMessage.WeakCreateBuilderForType()).WeakBuild());
RunBenchmark("Deserialize from json", jsonBytes.Length,
() =>
JsonFormatReader.CreateInstance(jsonBytes).Merge(
defaultMessage.WeakCreateBuilderForType()).WeakBuild());
RunBenchmark("Deserialize from json via xml", jsonBytes.Length,
() =>
XmlFormatReader.CreateInstance(JsonReaderWriterFactory.CreateJsonReader(jsonBytes, XmlDictionaryReaderQuotas.Max))
.SetOptions(XmlReaderOptions.ReadNestedArrays).Merge(
defaultMessage.WeakCreateBuilderForType()).WeakBuild());
RunBenchmark("Deserialize from dictionary", sampleMessage.SerializedSize,
() =>
new DictionaryReader(dictionary).Merge(defaultMessage.WeakCreateBuilderForType()).
WeakBuild());
}
WriteLine(String.Empty);
return(true);
}
catch (Exception e)
{
Console.Error.WriteLine("Error: {0}", e.Message);
Console.Error.WriteLine();
Console.Error.WriteLine("Detailed exception information: {0}", e);
return(false);
}
}
internal static DeviceInfo ParseDeviceInfo(string deviceJsonText, out string[] errors, out XElement systemInfoElement, out List <GraphicsTypeElement> graphicsTypeElements)
{
var errorList = new List <string>();
graphicsTypeElements = new List <GraphicsTypeElement>();
XElement root;
DeviceInfo deviceInfo;
try
{
root = XElement.Load(JsonReaderWriterFactory.CreateJsonReader(Encoding.UTF8.GetBytes(deviceJsonText), new XmlDictionaryReaderQuotas()));
deviceInfo = JsonUtility.FromJson <DeviceInfo>(deviceJsonText);
}
catch (Exception)
{
errorList.Add("Failed parsing JSON. Make sure this is a valid JSON file.");
errors = errorList.ToArray();
systemInfoElement = null;
return(null);
}
var versionElement = root.Element("version");
if (versionElement == null)
{
errorList.Add("Mandatory field [version] is missing");
}
else if (versionElement.Value != "1")
{
errorList.Add("[version] field is set to an unknown value. The newest version is 1");
}
var friendlyNameElement = root.Element("friendlyName");
if (friendlyNameElement == null)
{
errorList.Add("Mandatory field [friendlyName] is missing");
}
else if (string.IsNullOrEmpty(friendlyNameElement.Value))
{
errorList.Add("[friendlyName] field is empty, which is not allowed");
}
systemInfoElement = root.Element("systemInfo");
if (systemInfoElement == null)
{
errorList.Add("Mandatory field [systemInfo] is missing");
}
else
{
var operatingSystemElement = systemInfoElement.Element("operatingSystem");
if (operatingSystemElement == null)
{
errorList.Add("Mandatory field [systemInfo -> operatingSystem] is missing. [operatingSystem] must be set to a string containing either <android> or <ios>");
}
else if (!operatingSystemElement.Value.ToLower().Contains("android") && !operatingSystemElement.Value.ToLower().Contains("ios"))
{
errorList.Add("[systemInfo -> operatingSystem] field must be set to a string containing either <android> or <ios>, other platforms are not supported at the moment");
}
var graphicsSystemInfoArray = systemInfoElement.Element("graphicsDependentData");
if (graphicsSystemInfoArray != null)
{
var graphicsSystemInfo = graphicsSystemInfoArray.Elements("item").ToArray();
var graphicsTypes = new HashSet <GraphicsDeviceType>();
for (int i = 0; i < graphicsSystemInfo.Length; i++)
{
var graphicsDeviceElement = graphicsSystemInfo[i].Element("graphicsDeviceType");
if (graphicsDeviceElement == null)
{
errorList.Add($"Mandatory field [systemInfo -> graphicsDependentData[{i}] -> graphicsDeviceType] is missing. [graphicsDependentData] must contain [graphicsDeviceType]");
}
else if (!int.TryParse(graphicsDeviceElement.Value, out var typeInt) || !Enum.IsDefined(typeof(GraphicsDeviceType), typeInt))
{
errorList.Add($"[systemInfo -> graphicsDependentData[{i}] -> graphicsDeviceType] is set to a value that could not be parsed as GraphicsDeviceType");
}
else
{
var type = deviceInfo.systemInfo.graphicsDependentData[i].graphicsDeviceType;
if (graphicsTypes.Contains(type))
{
errorList.Add($"Multiple [systemInfo -> graphicsDependentData] fields have the same GraphicsDeviceType {type}.");
}
else
{
graphicsTypes.Add(type);
}
graphicsTypeElements.Add(new GraphicsTypeElement {
element = graphicsSystemInfo[i], type = type
});
}
}
}
}
var screensElement = root.Element("screens");
if (screensElement == null)
{
errorList.Add("Mandatory field [screens] is missing. [screens] array must contain at least one screen");
}
else
{
var screenElements = screensElement.Elements("item").ToArray();
if (!screenElements.Any())
{
errorList.Add("[screens] array must contain at least one screen");
}
else
{
for (var i = 0; i < screenElements.Length; i++)
{
var screen = deviceInfo.screens[i];
if (screenElements[i].Element("width") == null)
{
errorList.Add($"Mandatory field [screens[{i}] -> width] is missing");
}
else if (screen.width < 4 || screen.width > 8192)
{
errorList.Add($"[screens[{i}] -> width] field is set to an incorrect value {screen.width}. Screen width must be larger than 4 and smaller than 8192.");
}
if (screenElements[i].Element("height") == null)
{
errorList.Add($"Mandatory field [screens[{i}] -> height] is missing");
}
else if (screen.height < 4 || screen.height > 8192)
{
errorList.Add($"[screens[{i}] -> height] field is set to an incorrect value {screen.height}. Screen height must be larger than 4 and smaller than 8192.");
}
if (screenElements[i].Element("dpi") == null)
{
errorList.Add($"Mandatory field [screens[{i}] -> dpi] is missing");
}
else if (screen.dpi < 0.0001f || screen.dpi > 10000f)
{
errorList.Add($"[screens[{i}] -> dpi] field is set to an incorrect value {screen.dpi}. Screen dpi must be larger than 0 and smaller than 10000.");
}
}
}
}
errors = errorList.ToArray();
return(errors.Length == 0 ? deviceInfo : null);
}
override public void download()
{
string[] URLs;
string[] thumbs;
string strThumbs = "";
string website = "";
string str;
if (General.loadHTML) // if HTML download activated get HTML, thumbnails, do some magic
{
try {
website = new WebClient().DownloadString(this.getURL());
string JURL = this.getURL().Replace(".html", ".json");
string Content = new WebClient().DownloadString(JURL);
byte[] bytes = Encoding.ASCII.GetBytes(Content);
using (var stream = new MemoryStream(bytes)) {
var quotas = new XmlDictionaryReaderQuotas();
var jsonReader = JsonReaderWriterFactory.CreateJsonReader(stream, quotas);
var xml = XDocument.Load(jsonReader);
str = xml.ToString();
}
// get single images
XmlDocument doc = new XmlDocument();
doc.LoadXml(str);
XmlNodeList xmlTim = doc.DocumentElement.SelectNodes("/root/posts/item/tim");
XmlNodeList xmlExt = doc.DocumentElement.SelectNodes("/root/posts/item/ext");
for (int i = 0; i < xmlExt.Count; i++)
{
string ext = xmlExt[i].InnerText;
// if(ext == ".webm")
// ext = ".jpg";
strThumbs = strThumbs + "https://8ch.net/" + getURL().Split('/')[3] + "/thumb/" + xmlTim[i].InnerText + ext + "\n";
website = website.Replace("https://8ch.net/" + getURL().Split('/')[3] + "/thumb/" + xmlTim[i].InnerText + ext, "thumb/" + xmlTim[i].InnerText + ext);
website = website.Replace("=\"/" + getURL().Split('/')[3] + "/thumb/" + xmlTim[i].InnerText + ext, "=\"thumb/" + xmlTim[i].InnerText + ext);
website = website.Replace("=\"/" + getURL().Split('/')[3] + "/src/" + xmlTim[i].InnerText + ext, "=\"" + xmlTim[i].InnerText + ext);
website = website.Replace("https://8ch.net/" + getURL().Split('/')[3] + "/thumb/" + xmlTim[i].InnerText + ext, "thumb/" + xmlTim[i].InnerText + ext);
website = website.Replace("https://media.8ch.net/" + getURL().Split('/')[3] + "/thumb/" + xmlTim[i].InnerText + ext, "thumb/" + xmlTim[i].InnerText + ext);
website = website.Replace("https://media.8ch.net/" + getURL().Split('/')[3] + "/src/" + xmlTim[i].InnerText + ext, xmlTim[i].InnerText + ext);
website = website.Replace("https://8ch.net/" + getURL().Split('/')[3] + "/src/" + xmlTim[i].InnerText + ext, xmlTim[i].InnerText + ext);
}
// get images of posts with multiple images
xmlTim = doc.DocumentElement.SelectNodes("/root/posts/item/extra_files/item/tim");
xmlExt = doc.DocumentElement.SelectNodes("/root/posts/item/extra_files/item/ext");
for (int i = 0; i < xmlExt.Count; i++)
{
string ext = xmlExt[i].InnerText;
// if(ext == ".webm")
// ext = ".jpg";
strThumbs = strThumbs + "https://8ch.net/" + getURL().Split('/')[3] + "/thumb/" + xmlTim[i].InnerText + ext + "\n";
website = website.Replace("https://8ch.net/" + getURL().Split('/')[3] + "/thumb/" + xmlTim[i].InnerText + ext, "thumb/" + xmlTim[i].InnerText + ext);
website = website.Replace("=\"/" + getURL().Split('/')[3] + "/thumb/" + xmlTim[i].InnerText + ext, "=\"thumb/" + xmlTim[i].InnerText + ext);
website = website.Replace("=\"/" + getURL().Split('/')[3] + "/src/" + xmlTim[i].InnerText + ext, "=\"" + xmlTim[i].InnerText + ext);
website = website.Replace("https://8ch.net/" + getURL().Split('/')[3] + "/thumb/" + xmlTim[i].InnerText + ext, "thumb/" + xmlTim[i].InnerText + ext);
website = website.Replace("https://media.8ch.net/" + getURL().Split('/')[3] + "/thumb/" + xmlTim[i].InnerText + ext, "thumb/" + xmlTim[i].InnerText + ext);
website = website.Replace("https://media.8ch.net/" + getURL().Split('/')[3] + "/src/" + xmlTim[i].InnerText + ext, xmlTim[i].InnerText + ext);
website = website.Replace("https://8ch.net/" + getURL().Split('/')[3] + "/src/" + xmlTim[i].InnerText + ext, xmlTim[i].InnerText + ext);
}
website = website.Replace("=\"/", "=\"https://8ch.net/");
if (!Directory.Exists(this.SaveTo))
{
Directory.CreateDirectory(this.SaveTo);
}
thumbs = strThumbs.Split('\n');
for (int i = 0; i < thumbs.Length - 1; i++)
{
General.dlTo(thumbs[i], this.SaveTo + "\\thumb");
}
} catch (WebException webEx) {
// I think I should handle this
}
if (website != "")
{
if (!Directory.Exists(this.SaveTo))
{
Directory.CreateDirectory(this.SaveTo);
}
File.WriteAllText(this.SaveTo + "\\Thread.html", website); // save thread
}
}
try {
URLs = Regex.Split(getLinks(), "\n");
} catch (WebException webEx) {
if (((int)webEx.Status) == 7)
{
this.Gone = true;
}
return;
}
for (int y = 0; y < URLs.Length - 1; y++)
{
General.dlTo(URLs[y], this.SaveTo); // download images
}
}
override protected string getLinks()
{
string exed = "";
string JSONUrl = "http://a.4cdn.org/" + getURL().Split('/')[3] + "/thread/" + getURL().Split('/')[5] + ".json";
string baseURL = "http://i.4cdn.org/" + getURL().Split('/')[3] + "/";
string str = "";
XmlNodeList xmlTim;
XmlNodeList xmlExt;
XmlNodeList xmlFilename;
try {
string Content;
using (WebClient wc = new WebClient()){
wc.Headers.Add("User-Agent: " + Adv.Default.UserAgent);
Content = wc.DownloadString(JSONUrl);
}
byte[] bytes = Encoding.ASCII.GetBytes(Content);
using (var stream = new MemoryStream(bytes)) {
var quotas = new XmlDictionaryReaderQuotas();
var jsonReader = JsonReaderWriterFactory.CreateJsonReader(stream, quotas);
var xml = XDocument.Load(jsonReader);
str = xml.ToString();
stream.Flush();
stream.Close();
}
XmlDocument doc = new XmlDocument();
doc.LoadXml(str);
if (getURL().Split('/')[3] == "f")
{
xmlTim = doc.DocumentElement.SelectNodes("/root/posts/item/filename");
}
else
{
xmlTim = doc.DocumentElement.SelectNodes("/root/posts/item/tim");
}
xmlFilename = doc.DocumentElement.SelectNodes("/root/posts/item/filename");
xmlExt = doc.DocumentElement.SelectNodes("/root/posts/item/ext");
for (int i = 0; i < xmlExt.Count; i++)
{
exed = exed + baseURL + xmlTim[i].InnerText + xmlExt[i].InnerText + "\n";
// MessageBox.Show(exed);
}
return(exed);
}
catch (WebException webEx) {
if (((int)webEx.Status) == 7)
{
this.Gone = true;
}
else
{
ErrorLog.reportWebError(webEx);
}
throw webEx;
}
catch (Exception ex) {
ErrorLog.reportError(ex.ToString()); throw ex;
}
}
private static void uploadFile(string filename)
{
WebClient myWebClient = new WebClient();
string responseStr;
byte[] responseArray;
bool expectArray = true;
string hash = md5file(filename);
try
{
if (fileExists(hash))
{
//MessageBox.Show(baseURL + "/api/file/" + hash);
Stream stream = openRead(baseURL + "/api/file/" + hash);
responseArray = readStreamFully(stream);
expectArray = false;
}
else
{
responseArray = myWebClient.UploadFile(baseURL + "/api/upload" + (accessKey != "" ? "?accessKey=" + accessKey : ""), filename);
}
}
catch (WebException wex)
{
if (((HttpWebResponse)wex.Response).StatusCode == HttpStatusCode.Forbidden)
{
string key = promptForText("Access Key", "Permission denied. Please enter access key.");
if (key != "")
{
accessKey = key;
uploadFile(filename);
}
}
else
{
MessageBox.Show("Error: " + wex.ToString());
}
return;
}
responseStr = System.Text.Encoding.UTF8.GetString(responseArray);
var jsonReader = JsonReaderWriterFactory.CreateJsonReader(Encoding.UTF8.GetBytes(responseStr), new System.Xml.XmlDictionaryReaderQuotas());
// For that you will need to add reference to System.Xml and System.Xml.Linq
var root = XElement.Load(jsonReader);
XElement element = root.XPathSelectElement("//result");
if (expectArray && element.Elements().Count() < 1)
{
MessageBox.Show("Cannot upload empty files");
return;
}
XElement firstFile;
if (expectArray)
{
firstFile = element.Elements().First();
}
else
{
firstFile = element;
}
string raw = firstFile.Element("links").Element("raw").Value;
string download = firstFile.Element("links").Element("download").Value;
setClipboardText(download);
Form prompt = new Form()
{
Width = 450,
Height = 220,
FormBorderStyle = FormBorderStyle.FixedDialog,
Text = "File Drop",
StartPosition = FormStartPosition.CenterScreen
};
Label textLabelDownload = new Label()
{
Left = 10, Top = 20, Text = "Download:"
};
TextBox textBoxDownload = new TextBox()
{
Left = 10, Top = 40, Width = 400, Text = download
};
Label textLabelRaw = new Label()
{
Left = 10, Top = 70, Text = "Raw:"
};
TextBox textBoxRaw = new TextBox()
{
Left = 10, Top = 90, Width = 400, Text = raw
};
Label textLabelClipboardNotice = new Label()
{
Left = 10, Top = 120, Width = 400, Text = "Note: Download link copied to clipboard!"
};
Button confirmation = new Button()
{
Text = "Ok", Left = 175, Width = 100, Top = 145, DialogResult = DialogResult.OK
};
confirmation.Click += (sender, e) => { prompt.Close(); };
prompt.Controls.Add(textBoxDownload);
prompt.Controls.Add(textLabelDownload);
prompt.Controls.Add(textBoxRaw);
prompt.Controls.Add(textLabelRaw);
prompt.Controls.Add(textLabelClipboardNotice);
prompt.Controls.Add(confirmation);
prompt.AcceptButton = confirmation;
prompt.ShowDialog();
}
public static WeatherIndex GetIndex(string area)
{
WeatherIndex i = new WeatherIndex();
try
{
string json = GetJson(area, "index");
if (!json.Equals(string.Empty) && !json.Contains("error data"))
{
XmlDictionaryReader reader = JsonReaderWriterFactory.CreateJsonReader(Encoding.UTF8.GetBytes(json), XmlDictionaryReaderQuotas.Max);
XmlDocument xdoc = new XmlDocument();
xdoc.Load(reader);
Log.WriteDebug(xdoc.InnerText);
#region 输出完整的XML，分析格式
//StringWriter stringWriter = new StringWriter();
//XmlTextWriter xmlTextWriter = new XmlTextWriter(stringWriter);
//xmlTextWriter.Formatting = Formatting.Indented;
//foreach (XmlNode xmlNode in xdoc)
//{
// xmlNode.WriteTo(xmlTextWriter);
//}
//Log.WriteLog(stringWriter.ToString());
#endregion
#region 用xml解析json,并为相关的成员变量赋值
try
{
///获取到的属性信息
XmlNode clIndex = xdoc.FirstChild.SelectSingleNode("i").FirstChild;
i.cl = clIndex.SelectSingleNode("i1").InnerText;
i.clCN = clIndex.SelectSingleNode("i2").InnerText;
i.clCNAlias = clIndex.SelectSingleNode("i3").InnerText;
i.clLevel = clIndex.SelectSingleNode("i4").InnerText;
i.clDetails = clIndex.SelectSingleNode("i5").InnerText;
XmlNode coIndex = clIndex.NextSibling;
i.co = coIndex.SelectSingleNode("i1").InnerText;
i.coCN = coIndex.SelectSingleNode("i2").InnerText;
i.coCNAlias = coIndex.SelectSingleNode("i3").InnerText;
i.coLevel = coIndex.SelectSingleNode("i4").InnerText;
i.coDetails = coIndex.SelectSingleNode("i5").InnerText;
XmlNode ctIndex = coIndex.NextSibling;
i.ct = ctIndex.SelectSingleNode("i1").InnerText;
i.ctCN = ctIndex.SelectSingleNode("i2").InnerText;
i.ctCNAlias = ctIndex.SelectSingleNode("i3").InnerText;
i.ctLevel = ctIndex.SelectSingleNode("i4").InnerText;
i.ctDetails = ctIndex.SelectSingleNode("i5").InnerText;
}
catch (Exception ex)
{
Log.WriteError("GetIndex>>>>>" + ex.Message);
}
#endregion
}
}
catch (Exception ex)
{
Log.WriteError("GetIndex错误>>>>>" + ex.Message);
}
return(i);
}
public void ChirpUserStream()
{
_thread = new Thread(() =>
{
while (true)
{
try
{
DateTime time;
using (var reader = new StreamReader(FetchStream(OAuthBase.HttpVerbs.Get, "https://userstream.twitter.com/2/user.json", null, out time)))
{
_failureCount = 0;
while (!reader.EndOfStream)
{
var line = reader.ReadLine();
if (string.IsNullOrWhiteSpace(line))
{
continue;
}
using (var jsonReader = JsonReaderWriterFactory.CreateJsonReader(Encoding.UTF8.GetBytes(line), XmlDictionaryReaderQuotas.Max))
{
var element = XElement.Load(jsonReader);
if (element.Element("delete") != null)
{
var status = new Status
{
Id = (ulong)element.Element("delete").Element("status").Element("id")
};
UserStreamUpdated(this, new StatusEventArgs(status)
{
Action = StatusAction.Deleted
});
}
else if (element.Element("user") != null)
{
var status = new Status
{
Id = (ulong)element.Element("id"),
CreatedAt = DateTime.ParseExact(element.Element("created_at").Value, "ddd MMM dd HH:mm:ss zzzz yyyy", System.Globalization.DateTimeFormatInfo.InvariantInfo),
Text = element.Element("text").Value,
Source = element.Element("source").Value,
Favorited = (bool)element.Element("favorited"),
Sender = new User
{
Id = (int)element.Element("user").Element("id"),
ScreenName = element.Element("user").Element("screen_name").Value,
Name = element.Element("user").Element("name").Value,
ImageUrl = element.Element("user").Element("profile_image_url").Value,
Description = element.Element("user").Element("description").Value,
Protected = (bool)element.Element("user").Element("protected"),
Location = element.Element("user").Element("location").Value,
},
};
if (element.Element("retweeted_status") != null)
{
status.ReTweetedStatus = new Status
{
Id = (ulong)element.Element("retweeted_status").Element("id"),
CreatedAt = DateTime.ParseExact(element.Element("retweeted_status").Element("created_at").Value, "ddd MMM dd HH:mm:ss zzzz yyyy", System.Globalization.DateTimeFormatInfo.InvariantInfo),
Text = element.Element("retweeted_status").Element("text").Value,
Source = element.Element("retweeted_status").Element("source").Value,
Favorited = (bool)element.Element("retweeted_status").Element("favorited"),
Sender = new User
{
Id = (int)element.Element("retweeted_status").Element("user").Element("id"),
ScreenName = element.Element("retweeted_status").Element("user").Element("screen_name").Value,
Name = element.Element("retweeted_status").Element("user").Element("name").Value,
ImageUrl = element.Element("retweeted_status").Element("user").Element("profile_image_url").Value,
Description = element.Element("retweeted_status").Element("user").Element("description").Value,
Protected = (bool)element.Element("retweeted_status").Element("user").Element("protected"),
Location = element.Element("retweeted_status").Element("user").Element("location").Value,
},
};
}
if (!string.IsNullOrEmpty(element.Element("in_reply_to_status_id").Value))
{
status.InReplyToStatusId = (ulong)element.Element("in_reply_to_status_id");
}
if (!string.IsNullOrEmpty(element.Element("in_reply_to_user_id").Value))
{
status.InReplyToUserId = (int)element.Element("in_reply_to_user_id");
}
status.IsAuthor = status.Sender.Id == LoginedUser.Id;
status.IsMention = status.InReplyToUserId == LoginedUser.Id;
UserStreamUpdated(this, new StatusEventArgs(status)
{
Action = StatusAction.Update
});
}
else if (element.Element("event") != null)
{
if (element.Element("event").Value == "favorite")
{
var status = new Status
{
Id = (ulong)element.Element("target_object").Element("id"),
Sender = new User
{
Id = (int)element.Element("source").Element("id")
}
};
UserStreamUpdated(this, new StatusEventArgs(status)
{
Action = StatusAction.Favorited
});
}
else if (element.Element("event").Value == "unfavorite")
{
var status = new Status
{
Id = (ulong)element.Element("target_object").Element("id"),
Sender = new User
{
Id = (int)element.Element("source").Element("id")
}
};
UserStreamUpdated(this, new StatusEventArgs(status)
{
Action = StatusAction.Unfavorited
});
}
}
}
}
}
_failureCount = 1;
}
catch
{
_failureCount++;
if (_failureCount > 10)
{
_failureCount = 10;
}
}
finally
{
Thread.Sleep(1000 * (int)Math.Pow(_failureCount, _failureCount));
}
}
});
_thread.IsBackground = true;
_thread.Start();
}
public PowerBISettings(string settingsFilePath = null, PowerBIEnvironmentType targetEnvironmentType = PowerBIEnvironmentType.Public, bool refreshGlobalServiceConfig = false)
{
if (string.IsNullOrEmpty(settingsFilePath))
{
var executingDirectory = DirectoryUtility.GetExecutingDirectory();
settingsFilePath = Path.Combine(executingDirectory, FileName);
}
if (!File.Exists(settingsFilePath))
{
throw new FileNotFoundException("Unable to find setting configuration", settingsFilePath);
}
PowerBIConfiguration configuration = null;
using (var fileReader = File.OpenRead(settingsFilePath))
{
var serializer = new DataContractJsonSerializer(typeof(PowerBIConfiguration));
using (var jsonReader = JsonReaderWriterFactory.CreateJsonReader(fileReader, Encoding.UTF8, XmlDictionaryReaderQuotas.Max, null))
{
configuration = serializer.ReadObject(jsonReader) as PowerBIConfiguration;
}
}
this.Settings = configuration.Settings;
var targetEnvironment = configuration.Environments
.FirstOrDefault(e => Enum.TryParse(e.Name, out PowerBIEnvironmentType result) && result == targetEnvironmentType);
var globalServiceEndpoint = (targetEnvironment != null && targetEnvironment.GlobalService != null) ? targetEnvironment.GlobalService : "https://api.powerbi.com";
var cloudEnvironments = GetGlobalServiceConfig(globalServiceEndpoint, enforceRefresh: refreshGlobalServiceConfig).Result;
if (cloudEnvironments != null)
{
// Ignore non-valid environments
var environments = configuration.Environments
.Where(e => Enum.TryParse(e.Name, out PowerBIEnvironmentType result))
.Select(e =>
{
if (!string.IsNullOrEmpty(e.CloudName))
{
string cloudName = e.CloudName;
var cloudEnvironment = cloudEnvironments.Environments.FirstOrDefault(c => c.CloudName.Equals(cloudName, StringComparison.OrdinalIgnoreCase));
if (cloudEnvironment == null)
{
throw new NotSupportedException($"Unable to find cloud name: {cloudName}");
}
var backendService = cloudEnvironment.Services.First(s => s.Name.Equals("powerbi-backend", StringComparison.OrdinalIgnoreCase));
var redirectApp = cloudEnvironment.Clients.First(s => s.Name.Equals(e.RedirectApp, StringComparison.OrdinalIgnoreCase));
return(new PowerBIEnvironment()
{
Name = (PowerBIEnvironmentType)Enum.Parse(typeof(PowerBIEnvironmentType), e.Name),
AzureADAuthority = cloudEnvironment.Services.First(s => s.Name.Equals("aad", StringComparison.OrdinalIgnoreCase)).Endpoint,
AzureADClientId = redirectApp.AppId,
AzureADRedirectAddress = redirectApp.RedirectUri,
AzureADResource = backendService.ResourceId,
GlobalServiceEndpoint = backendService.Endpoint
});
}
else
{
// Debug environments
string cloudName = "GlobalCloud";
var cloudEnvironment = cloudEnvironments.Environments.FirstOrDefault(c => c.CloudName.Equals(cloudName, StringComparison.OrdinalIgnoreCase));
if (cloudEnvironment == null)
{
throw new NotSupportedException($"Unable to find cloud name: {cloudName}");
}
var redirectApp = cloudEnvironment.Clients.First(s => s.Name.Equals(e.RedirectApp, StringComparison.OrdinalIgnoreCase));
return(new PowerBIEnvironment()
{
Name = (PowerBIEnvironmentType)Enum.Parse(typeof(PowerBIEnvironmentType), e.Name),
AzureADAuthority = e.Authority,
AzureADClientId = redirectApp.AppId,
AzureADRedirectAddress = redirectApp.RedirectUri,
AzureADResource = e.Resource,
GlobalServiceEndpoint = e.GlobalService
});
}
})
.Cast <IPowerBIEnvironment>().ToDictionary(e => e.Name, e => e);
this.Environments = environments;
}
}
private void downloadHTMLPage()
{
List <string> thumbs = new List <string>();
string htmlPage = "";
string str;
try
{
htmlPage = new WebClient().DownloadString(this.getURL());
string JURL = this.getURL().Replace(".html", ".json");
string Content = new WebClient().DownloadString(JURL);
byte[] bytes = Encoding.ASCII.GetBytes(Content);
using (var stream = new MemoryStream(bytes))
{
var quotas = new XmlDictionaryReaderQuotas();
var jsonReader = JsonReaderWriterFactory.CreateJsonReader(stream, quotas);
var xml = XDocument.Load(jsonReader);
str = xml.ToString();
}
// get single images
XmlDocument doc = new XmlDocument();
doc.LoadXml(str);
XmlNodeList xmlTim = doc.DocumentElement.SelectNodes("/root/posts/item/tim");
XmlNodeList xmlExt = doc.DocumentElement.SelectNodes("/root/posts/item/ext");
for (int i = 0; i < xmlExt.Count; i++)
{
string ext = xmlExt[i].InnerText;
// if(ext == ".webm")
// ext = ".jpg";
thumbs.Add("https://8ch.net/file_store/thumb/" + xmlTim[i].InnerText + ext);
htmlPage = htmlPage.Replace("https://8ch.net/file_store/thumb/" + xmlTim[i].InnerText + ext, "thumb/" + xmlTim[i].InnerText + ext);
htmlPage = htmlPage.Replace("=\"/file_store/thumb/" + xmlTim[i].InnerText + ext, "=\"thumb/" + xmlTim[i].InnerText + ext);
htmlPage = htmlPage.Replace("=\"/file_store/" + xmlTim[i].InnerText + ext, "=\"" + xmlTim[i].InnerText + ext);
htmlPage = htmlPage.Replace("https://media.8ch.net/file_store/thumb/" + xmlTim[i].InnerText + ext, "thumb/" + xmlTim[i].InnerText + ext);
htmlPage = htmlPage.Replace("https://media.8ch.net/file_store/" + xmlTim[i].InnerText + ext, xmlTim[i].InnerText + ext);
htmlPage = htmlPage.Replace("https://8ch.net/file_store/" + xmlTim[i].InnerText + ext, xmlTim[i].InnerText + ext);
}
// get images of posts with multiple images
xmlTim = doc.DocumentElement.SelectNodes("/root/posts/item/extra_files/item/tim");
xmlExt = doc.DocumentElement.SelectNodes("/root/posts/item/extra_files/item/ext");
for (int i = 0; i < xmlExt.Count; i++)
{
string ext = xmlExt[i].InnerText;
// if(ext == ".webm")
// ext = ".jpg";
thumbs.Add("https://8ch.net/file_store/thumb/" + xmlTim[i].InnerText + ext);
htmlPage = htmlPage.Replace("https://8ch.net/file_store/thumb/" + xmlTim[i].InnerText + ext, "thumb/" + xmlTim[i].InnerText + ext);
htmlPage = htmlPage.Replace("=\"/file_store/thumb/" + xmlTim[i].InnerText + ext, "=\"thumb/" + xmlTim[i].InnerText + ext);
htmlPage = htmlPage.Replace("=\"/file_store/" + xmlTim[i].InnerText + ext, "=\"" + xmlTim[i].InnerText + ext);
htmlPage = htmlPage.Replace("https://media.8ch.net/file_store/thumb/" + xmlTim[i].InnerText + ext, "thumb/" + xmlTim[i].InnerText + ext);
htmlPage = htmlPage.Replace("https://media.8ch.net/file_store/" + xmlTim[i].InnerText + ext, xmlTim[i].InnerText + ext);
htmlPage = htmlPage.Replace("https://8ch.net/file_store/" + xmlTim[i].InnerText + ext, xmlTim[i].InnerText + ext);
}
htmlPage = htmlPage.Replace("=\"/", "=\"https://8ch.net/");
for (int i = 0; i < thumbs.Count; i++)
{
General.DownloadToDir(new FileInformation(thumbs[i]), this.SaveTo + "\\thumb");
}
if (!String.IsNullOrWhiteSpace(htmlPage))
{
File.WriteAllText(this.SaveTo + "\\Thread.html", htmlPage); // save thread
}
}
catch
{
throw;
}
}
static IEnumerable <string> GetModifiedFilesRemotely(Harness harness, int pull_request)
{
var path = Path.Combine(harness.LogDirectory, "pr" + pull_request + "-remote-files.log");
if (!File.Exists(path))
{
Directory.CreateDirectory(harness.LogDirectory);
using (var client = CreateClient()) {
var rv = new List <string> ();
var url = $"https://api.github.com/repos/xamarin/xamarin-macios/pulls/{pull_request}/files?per_page=100"; // 100 items per page is max
do
{
byte [] data;
try {
data = client.DownloadData(url);
} catch (WebException we) {
harness.Log("Could not load pull request files: {0}\n{1}", we, new StreamReader(we.Response.GetResponseStream()).ReadToEnd());
File.WriteAllText(path, string.Empty);
return(new string [] { });
}
var reader = JsonReaderWriterFactory.CreateJsonReader(data, new XmlDictionaryReaderQuotas());
var doc = new XmlDocument();
doc.Load(reader);
foreach (XmlNode node in doc.SelectNodes("/root/item/filename"))
{
rv.Add(node.InnerText);
}
url = null;
var link = client.ResponseHeaders ["Link"];
try {
if (link != null)
{
var ltIdx = link.IndexOf('<');
var gtIdx = link.IndexOf('>', ltIdx + 1);
while (ltIdx >= 0 && gtIdx > ltIdx)
{
var linkUrl = link.Substring(ltIdx + 1, gtIdx - ltIdx - 1);
if (link [gtIdx + 1] != ';')
{
break;
}
var commaIdx = link.IndexOf(',', gtIdx + 1);
string rel;
if (commaIdx != -1)
{
rel = link.Substring(gtIdx + 3, commaIdx - gtIdx - 3);
}
else
{
rel = link.Substring(gtIdx + 3);
}
if (rel == "rel=\"next\"")
{
url = linkUrl;
break;
}
if (commaIdx == -1)
{
break;
}
ltIdx = link.IndexOf('<', commaIdx);
gtIdx = link.IndexOf('>', ltIdx + 1);
}
}
} catch (Exception e) {
harness.Log("Could not paginate github response: {0}: {1}", link, e.Message);
}
} while (url != null);
File.WriteAllLines(path, rv.ToArray());
return(rv);
}
}
return(File.ReadAllLines(path));
}
private string MessageToString(ref Message message)
{
WebContentFormat messageFormat = this.GetMessageContentFormat(message);
MemoryStream ms = new MemoryStream();
XmlDictionaryWriter writer = null;
switch (messageFormat)
{
case WebContentFormat.Default:
// If we can't determine the message body format, we should ignore message body instead of creating the instance of writer object.
break;
case WebContentFormat.Xml:
writer = XmlDictionaryWriter.CreateTextWriter(ms);
break;
case WebContentFormat.Json:
writer = JsonReaderWriterFactory.CreateJsonWriter(ms);
break;
case WebContentFormat.Raw:
// special case for raw, easier implemented separately
return(this.ReadRawBody(ref message));
}
// Message body can't be determined, so writer object will be null.
if (writer == null)
{
return(string.Empty);
}
message.WriteMessage(writer);
writer.Flush();
string messageBody = Encoding.UTF8.GetString(ms.ToArray());
// Here would be a good place to change the message body, if so desired.
// now that the message was read, it needs to be recreated.
ms.Position = 0;
// if the message body was modified, needs to reencode it, as show below
// ms = new MemoryStream(Encoding.UTF8.GetBytes(messageBody));
XmlDictionaryReader reader;
if (messageFormat == WebContentFormat.Json)
{
reader = JsonReaderWriterFactory.CreateJsonReader(ms, XmlDictionaryReaderQuotas.Max);
}
else
{
reader = XmlDictionaryReader.CreateTextReader(ms, XmlDictionaryReaderQuotas.Max);
}
Message newMessage = Message.CreateMessage(reader, int.MaxValue, message.Version);
newMessage.Properties.CopyProperties(message.Properties);
message = newMessage;
return(messageBody);
}
private async Task <bool> CheckOnGithub()
{
try
{
//If the app was installed by Chocolatey, avoid this.
if (AppDomain.CurrentDomain.BaseDirectory.EndsWith(@"Chocolatey\lib\screentogif\content\"))
{
return(true);
}
#region GraphQL equivalent
//query {
// repository(owner: "NickeManarin", name: "ScreenToGif") {
// releases(first: 1, orderBy: { field: CREATED_AT, direction: DESC}) {
// nodes {
// name
// tagName
// createdAt
// url
// isPrerelease
// description
// releaseAssets(last: 2) {
// nodes {
// name
// downloadCount
// downloadUrl
// size
// }
// }
// }
// }
// }
//}
#endregion
var request = (HttpWebRequest)WebRequest.Create("https://api.github.com/repos/NickeManarin/ScreenToGif/releases/latest");
request.UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.79 Safari/537.36 Edge/14.14393";
request.Proxy = WebHelper.GetProxy();
var response = (HttpWebResponse)await request.GetResponseAsync();
using (var resultStream = response.GetResponseStream())
{
if (resultStream == null)
{
return(false);
}
using (var reader = new StreamReader(resultStream))
{
var result = await reader.ReadToEndAsync();
var jsonReader = JsonReaderWriterFactory.CreateJsonReader(Encoding.UTF8.GetBytes(result), new System.Xml.XmlDictionaryReaderQuotas());
var release = XElement.Load(jsonReader);
var version = Version.Parse(release.XPathSelectElement("tag_name")?.Value ?? "0.1");
if (version.Major == 0 || version <= Assembly.GetExecutingAssembly().GetName().Version)
{
return(true);
}
Global.UpdateAvailable = new UpdateAvailable
{
Version = version,
Description = release.XPathSelectElement("body")?.Value ?? "",
PortableDownloadUrl = release.XPathSelectElement("assets/item[1]/browser_download_url")?.Value ?? "",
PortableSize = Convert.ToInt64(release.XPathSelectElement("assets/item[1]/size")?.Value ?? "0"),
PortableName = release.XPathSelectElement("assets/item[1]/name")?.Value ?? "ScreenToGif.zip",
InstallerDownloadUrl = release.XPathSelectElement("assets/item[2]/browser_download_url")?.Value ?? "",
InstallerSize = Convert.ToInt64(release.XPathSelectElement("assets/item[2]/size")?.Value ?? "0"),
InstallerName = release.XPathSelectElement("assets/item[2]/name")?.Value ?? "ScreenToGif.Setup.msi",
};
Application.Current.Dispatcher?.BeginInvoke(new Action(() => NotificationManager.AddNotification(string.Format(LocalizationHelper.Get("S.Updater.NewRelease.Info"),
Global.UpdateAvailable.Version), StatusType.Update, "update", PromptUpdate)));
//Download update to be installed when the app closes.
if (UserSettings.All.InstallUpdates && !string.IsNullOrEmpty(Global.UpdateAvailable.InstallerDownloadUrl))
{
await DownloadUpdate();
}
}
}
return(true);
}
catch (Exception ex)
{
LogWriter.Log(ex, "Impossible to check for updates on Github");
return(false);
}
finally
{
GC.Collect();
}
}
/// <summary>
/// Called after an inbound message has been received but before the message is dispatched to the intended operation.
/// </summary>
/// <param name="request">The request message.</param>
/// <param name="channel">The incoming channel.</param>
/// <param name="instanceContext">The current service instance.</param>
/// <returns>The object used to correlate state. This object is passed back in the <see cref="M:System.ServiceModel.Dispatcher.IDispatchMessageInspector.BeforeSendReply(System.ServiceModel.Channels.Message@,System.Object)" /> method.</returns>
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
if (!request.Properties.ContainsKey("Via"))
{
return(request); // Nothing much we can do here
}
if (!request.Properties.ContainsKey("httpRequest"))
{
return(request); // Same here
}
var httpRequest = request.Properties["httpRequest"] as HttpRequestMessageProperty;
if (httpRequest == null)
{
return(request);
}
var httpMethod = httpRequest.Method.ToUpper();
var uri = request.Properties["Via"] as Uri;
if (uri == null)
{
return(request); // Still nothing much we can do
}
var url = uri.AbsoluteUri;
var urlFragment = url;
if (urlFragment.ToLower().StartsWith(_rootUrlLower))
{
urlFragment = urlFragment.Substring(_rootUrlLower.Length);
}
var operationInfo = RestHelper.GetMethodNameFromUrlFragmentAndContract(urlFragment, httpMethod, _contractType);
var urlParameters = RestHelper.GetUrlParametersFromUrlFragmentAndContract(urlFragment, httpMethod, _contractType);
if (httpMethod == "GET")
{
// TODO: Support GET if at all possible
throw new Exception("REST-GET operations are not currently supported in the chosen hosting environment. Please use a different HTTP Verb, or host in a different environment (such as WebApi). We hope to add this feature in a future version.");
// This is a REST GET operation. Therefore, there is no posted message. Instead, we have to decode the input parameters from the URL
var parameters = operationInfo.GetParameters();
if (parameters.Length != 1)
{
throw new NotSupportedException("Only service methods/operations with a single input parameter can be mapped to REST-GET operations. Method " + operationInfo.Name + " has " + parameters.Length + " parameters. Consider changing the method to have a single object with multiple properties instead.");
}
var parameterType = parameters[0].ParameterType;
var parameterInstance = Activator.CreateInstance(parameterType);
foreach (var propertyName in urlParameters.Keys)
{
var urlProperty = parameterType.GetProperty(propertyName);
if (urlProperty == null)
{
continue;
}
urlProperty.SetValue(parameterInstance, urlParameters[propertyName], null);
}
// Seralize the object back into a new request message
// TODO: We only need to do this for methods OTHER than GET
var format = GetMessageContentFormat(request);
switch (format)
{
case WebContentFormat.Xml:
var xmlStream = new MemoryStream();
var xmlSerializer = new DataContractSerializer(parameterInstance.GetType());
xmlSerializer.WriteObject(xmlStream, parameterInstance);
var xmlReader = XmlDictionaryReader.CreateTextReader(StreamHelper.ToArray(xmlStream), XmlDictionaryReaderQuotas.Max);
var newXmlMessage = Message.CreateMessage(xmlReader, int.MaxValue, request.Version);
newXmlMessage.Properties.CopyProperties(request.Properties);
newXmlMessage.Headers.CopyHeadersFrom(request.Headers);
if (format == WebContentFormat.Default)
{
if (newXmlMessage.Properties.ContainsKey(WebBodyFormatMessageProperty.Name))
{
newXmlMessage.Properties.Remove(WebBodyFormatMessageProperty.Name);
}
newXmlMessage.Properties.Add(WebBodyFormatMessageProperty.Name, WebContentFormat.Xml);
}
request = newXmlMessage;
break;
case WebContentFormat.Default:
case WebContentFormat.Json:
var jsonStream = new MemoryStream();
var serializer = new DataContractJsonSerializer(parameterInstance.GetType());
serializer.WriteObject(jsonStream, parameterInstance);
var jsonReader = JsonReaderWriterFactory.CreateJsonReader(StreamHelper.ToArray(jsonStream), XmlDictionaryReaderQuotas.Max);
var newMessage = Message.CreateMessage(jsonReader, int.MaxValue, request.Version);
newMessage.Properties.CopyProperties(request.Properties);
newMessage.Headers.CopyHeadersFrom(request.Headers);
if (format == WebContentFormat.Default)
{
if (newMessage.Properties.ContainsKey(WebBodyFormatMessageProperty.Name))
{
newMessage.Properties.Remove(WebBodyFormatMessageProperty.Name);
}
newMessage.Properties.Add(WebBodyFormatMessageProperty.Name, WebContentFormat.Json);
}
request = newMessage;
break;
default:
throw new NotSupportedException("Mesage format " + format.ToString() + " is not supported form REST/JSON operations");
}
}
return(null);
}
public string GetDotNetExecutable(string directory)
{
if (directory == null)
{
throw new ArgumentNullException(nameof(directory));
}
lock (dotnet_executables) {
if (dotnet_executables.TryGetValue(directory, out var value))
{
return(value);
}
}
// Find the first global.json up the directory hierarchy (stopping at the root directory)
string global_json = null;
var dir = directory;
while (dir.Length > 2)
{
global_json = Path.Combine(dir, "global.json");
if (File.Exists(global_json))
{
break;
}
dir = Path.GetDirectoryName(dir);
}
if (!File.Exists(global_json))
{
throw new Exception($"Could not find any global.json file in {directory} or above");
}
// Parse the global.json we found, and figure out if it tells us to use .NET 3.1.100 / 5.X.XXX or not.
var contents = File.ReadAllBytes(global_json);
using var reader = JsonReaderWriterFactory.CreateJsonReader(contents, new XmlDictionaryReaderQuotas());
var doc = new XmlDocument();
doc.Load(reader);
var version = doc.SelectSingleNode("/root/sdk").InnerText;
string executable;
switch (version [0])
{
case '3':
case '5':
executable = dotnetPath;
break;
default:
executable = dotnet6Path;
break;
}
getLog()?.WriteLine($"Mapped .NET SDK version {version} to {executable} for {directory}");
lock (dotnet_executables) {
dotnet_executables [directory] = executable;
}
return(executable);
}
public void ConstructorNullStream()
{
JsonReaderWriterFactory.CreateJsonReader((Stream)null, new XmlDictionaryReaderQuotas());
}
