/// <summary>
/// populates the JSON string to parse on the return trip
/// </summary>
protected override void ResponseCallback(System.Net.HttpWebResponse webResponse)
{
using(var reader = new StreamReader(webResponse.GetResponseStream()))
{
JsonResult = reader.ReadToEnd();
}
SitAndWait.Set();
}
private static void LogResponse(System.Net.HttpWebResponse response)
{
Console.WriteLine("\r\n# RESPONSE");
Console.WriteLine("HTTP/1.1 {0} {1}", (int)response.StatusCode, response.StatusDescription);
foreach (var key in response.Headers.AllKeys)
Console.WriteLine("{0}: {1}", key, response.Headers[key]);
Console.WriteLine("\r\n" + new StreamReader(response.GetResponseStream()).ReadToEnd());
}
static string GetResponseContent(System.Net.HttpWebResponse response)
{
Stream dataStream = response.GetResponseStream();
StreamReader reader = new StreamReader(dataStream);
string result = reader.ReadToEnd();
reader.Close();
dataStream.Close();
return result;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="response">Response of type System.Net.WebResponse</param>
internal ExecutionResult(System.Net.WebResponse response)
{
this.status = ((HttpWebResponse)response).StatusDescription;
dataStream = response.GetResponseStream();
StreamReader reader = new StreamReader(dataStream);
responseFromServer = reader.ReadToEnd();
reader.Close();
dataStream.Close();
this.response = response;
response.Close();
}
public override TaskResult GetResult(System.Net.WebResponse response)
{
var result = new TaskResult();
using(StreamReader reader = new StreamReader(response.GetResponseStream(), DefaultEncoding))
{
result.Message = reader.ReadToEnd();
Regex regex = new Regex("<span class=\"cuti yanse_hongse\">(\\d+)</span>"); //get the code.
result.IsSucceed = regex.IsMatch(result.Message);
if (result.IsSucceed)
result.Code = regex.Match(result.Message).Groups[1].Value;
}
return result;
}
public override bool GetResponse(System.Net.HttpWebResponse webresponse)
{
//http://www.c-sharpcorner.com/Code/2003/Dec/ReadingWebPageSources.asp
System.IO.StreamReader stream = new System.IO.StreamReader
(webresponse.GetResponseStream(), System.Text.Encoding.ASCII);
this.Uri = webresponse.ResponseUri; // we *may* have been redirected... and we want the *final* URL
this.Length = webresponse.ContentLength;
this.All = stream.ReadToEnd();
this.Title = System.IO.Path.GetFileName(this.Uri.AbsoluteUri);
this.Description = base.GetDescriptionFromWordsOnly(WordsOnly);
stream.Close();
return true;
}
public ICommandResponse ParseResponse(System.Net.WebResponse webResponse)
{
var responseStream = webResponse.GetResponseStream();
if ((responseStream == null) || (!responseStream.CanRead)) return new ListIsoPermissionsResponse();
var responseDocument = XDocument.Load(responseStream);
var templatePermission = responseDocument.Elements().Elements()
.Where(e => e.Name.LocalName.Equals("templatepermission", StringComparison.InvariantCultureIgnoreCase))
.FirstOrDefault();
if (templatePermission == null) return new ListIsoPermissionsResponse();
return new ListIsoPermissionsResponse
{
Id = int.Parse(templatePermission.ExtractValue("id")),
Accounts = templatePermission.ExtractValue("accounts"),
DomainId = int.Parse(templatePermission.ExtractValue("domainId")),
IsPublic = bool.Parse(templatePermission.ExtractValue("isPublic"))
};
}
public static byte[] ConvertWebResponseToByteArray(System.Net.WebResponse res)
{
System.IO.BinaryReader br = new BinaryReader(res.GetResponseStream());
//download and buffer the binary stream into a memory stream
System.IO.MemoryStream stm = new MemoryStream();
int pos = 0;
int maxread = BufferSize;
while(true) {
byte[] content = br.ReadBytes(maxread);
if(content.Length <= 0) break;
if(content.Length < maxread) maxread = maxread - content.Length;
stm.Write(content, 0, content.Length);
pos += content.Length;
}
br.Close();
stm.Position = 0;
byte[] final = new byte[(int)stm.Length];
stm.Read(final, 0, final.Length);
stm.Close();
return final;
}
public static string GetTextFromWebResponse(System.Net.WebResponse response)
{
StringBuilder sb = new StringBuilder(1000);
using (Stream ReceiveStream = response.GetResponseStream())
{
Encoding encode = Encoding.GetEncoding("utf-8");
// Pipe the stream to a higher level stream reader with the required encoding format.
using (StreamReader readStream = new StreamReader(ReceiveStream, encode))
{
Char[] read = new Char[256];
int count = readStream.Read(read, 0, 256);
while (count > 0)
{
// Dump the 256 characters on a string and display the string onto the console.
sb.Append(new String(read, 0, count));
count = readStream.Read(read, 0, 256);
}
readStream.Close();
}
}
return sb.ToString();
}
/// <summary>
/// Write something about the response to the Log and raise some exceptions if the upload failed.
/// </summary>
/// <param name="response">The WebResponse</param>
private void HandleResponse(System.Net.HttpWebResponse response)
{
using (var reader = new StreamReader(response.GetResponseStream()))
{
Log.Instance.Write("### Begin of response ##########################" + Environment.NewLine + reader.ReadToEnd().Replace("\n", "\r\n"));
Log.Instance.Write("### End of response ##########################");
}
switch (response.StatusCode)
{
case System.Net.HttpStatusCode.OK:
Log.Instance.Write("Upload successfull!");
break;
case System.Net.HttpStatusCode.PartialContent:
Log.Instance.Write("Upload finished with warnings.");
break;
case System.Net.HttpStatusCode.Unauthorized:
Log.Instance.Write("Not Authorized!");
throw new NotAuthorizedException();
default:
Log.Instance.Write("Upload failed!");
throw new UploadFailedException();
}
response.Close();
}
private string retrieveFromURL(System.Net.WebResponse response)
{
if (response.ContentType != "application/octet-stream")
{
StringBuilder sb = new StringBuilder(1000);
Stream ReceiveStream = response.GetResponseStream();
Encoding encode = System.Text.Encoding.GetEncoding("utf-8");
// Pipe the stream to a higher level stream reader with the required encoding format.
StreamReader readStream = new StreamReader(ReceiveStream, encode);
Char[] read = new Char[256];
int count = readStream.Read(read, 0, 256);
while (count > 0)
{
// Dump the 256 characters on a string and display the string onto the console.
String str = new String(read, 0, count);
sb.Append(str);
count = readStream.Read(read, 0, 256);
}
readStream.Close();
// Release the resources of response object.
response.Close();
return sb.ToString();
}
lblRequestStatus.Text = "Saving...";
lblRequestStatus.Refresh();
string filenameHeader = response.Headers["Content-Disposition"];
string filename = filenameHeader.Substring(filenameHeader.IndexOf("filename=") + "filename=".Length);
// 2. Get the Stream Object from the response
System.IO.Stream responseStream = response.GetResponseStream();
WriteStreamToFile(responseStream, Path.Combine(Path.GetDirectoryName(Application.ExecutablePath), filename));
// 3. Create a stream reader and associate it with the stream object
System.IO.StreamReader reader = new System.IO.StreamReader(responseStream);
// 4. read the entire stream
lblRequestStatus.Text = "Finished";
return "";
//return reader.ReadToEnd();
}
public string ProcessResponse(System.Net.HttpWebResponse Response, bool AddHeaders = false)
{
StringBuilder Html = new StringBuilder();
Stream receiveStream = Response.GetResponseStream();
Encoding encode = System.Text.Encoding.GetEncoding("utf-8");
StreamReader readStream = new StreamReader(receiveStream, encode);
Char[] read = new Char[257];
int count = readStream.Read(read, 0, 256);
if (AddHeaders == true)
Html.Append(Response.Headers.ToString());
while (count > 0) {
String str = new String(read, 0, count);
Html.Append(str);
count = readStream.Read(read, 0, 256);
}
readStream.Close();
Response.Close();
return Html.ToString();
}
/// <summary>
/// See http://blogs.msdn.com/feroze_daud/archive/2004/03/30/104440.aspx
/// </summary>
/// <param name="w"></param>
/// <returns></returns>
public static String DecodeData(System.Net.WebResponse w)
{
//
// first see if content length header has charset = calue
//
String charset = null;
String ctype = w.Headers["content-type"];
if (ctype != null)
{
int ind = ctype.IndexOf("charset=");
if (ind != -1)
{
charset = ctype.Substring(ind + 8);
Debug.WriteLine("CT: charset=" + charset);
}
}
// save data to a memorystream
MemoryStream rawdata = new MemoryStream();
byte[] buffer = new byte[1024];
Stream rs = w.GetResponseStream();
int read = rs.Read(buffer, 0, buffer.Length);
while (read > 0)
{
rawdata.Write(buffer, 0, read);
read = rs.Read(buffer, 0, buffer.Length);
}
rs.Close();
//
// if ContentType is null, or did not contain charset, we search in body
//
if (charset == null)
{
MemoryStream ms = rawdata;
ms.Seek(0, SeekOrigin.Begin);
StreamReader srr = new StreamReader(ms, Encoding.ASCII);
String meta = srr.ReadToEnd();
if (meta != null)
{
int start_ind = meta.IndexOf("charset=");
int end_ind = -1;
if (start_ind != -1)
{
end_ind = meta.IndexOf("\"", start_ind);
if (end_ind != -1)
{
int start = start_ind + 8;
charset = meta.Substring(start, end_ind - start + 1);
charset = charset.TrimEnd(new Char[] { '>', '"' });
Debug.WriteLine("META: charset=" + charset);
}
}
}
}
Encoding e = null;
if (charset == null)
{
e = Encoding.ASCII; //default encoding
}
else
{
try
{
e = Encoding.GetEncoding(charset);
}
catch (Exception ee)
{
Debug.WriteLine("Exception: GetEncoding: " + charset);
Debug.WriteLine(ee.ToString());
e = Encoding.ASCII;
}
}
rawdata.Seek(0, SeekOrigin.Begin);
StreamReader sr = new StreamReader(rawdata, e);
String s = sr.ReadToEnd();
return s;//.ToLower();
}
private void ProcessContent(System.Net.HttpWebResponse resp)
{
Int64 iContentLength = resp.ContentLength;
if (HttpProtocol.MAX_CONTENT >= 0 &&
iContentLength > HttpProtocol.MAX_CONTENT)
{
iContentLength = HttpProtocol.MAX_CONTENT;
}
MemoryStream memStream = new MemoryStream();
const int BUFFER_SIZE = 4096;
int iRead = 0;
int idx = 0;
Int64 iSize = 0;
memStream.SetLength(BUFFER_SIZE);
while(true)
{
byte [] respBuffer = new byte[BUFFER_SIZE];
try
{
iRead = resp.GetResponseStream().Read(respBuffer, 0, BUFFER_SIZE);
}
catch (System.Exception e)
{
Trace.WriteLine(e.Message);
}
if (iRead == 0)
{
break;
}
iSize += iRead;
memStream.SetLength(iSize);
memStream.Write(respBuffer, 0, iRead);
idx += iRead;
}
m_content = memStream.ToArray();
memStream.Close();
}
public GithubResponse GetGithubResponseFromWebResponse(System.Net.HttpWebResponse response)
{
var responseString = new System.IO.StreamReader(response.GetResponseStream()).ReadToEnd();
var responseToReturn = new GithubResponse
{
RateLimitLimit = int.Parse(response.Headers["X-RateLimit-Limit"]),
RateLimitRemaining = int.Parse(response.Headers["X-RateLimit-Remaining"]),
Response = responseString,
StatusCode = (int)response.StatusCode,
StatusText = response.StatusDescription
};
if (!string.IsNullOrEmpty(response.Headers.Get("Link")))
{
responseToReturn = ParsePagingLinks(
responseToReturn,
response.Headers.Get("Link"));
}
return responseToReturn;
}
/// <summary>
/// Handles the response from server
/// </summary>
/// <param name="response"></param>
/// <returns></returns>
public bool GetResponse(System.Net.HttpWebResponse response)
{
string enc = "utf-8"; // default
if (response.ContentEncoding != String.Empty)
{
// Use the HttpHeader Content-Type in preference to the one set in META
this.Encoding = response.ContentEncoding;
}
else
{
this.Encoding = enc; // default
}
System.IO.StreamReader stream = new System.IO.StreamReader
(response.GetResponseStream(), System.Text.Encoding.GetEncoding(this.Encoding));
//store final URl if it was a redirect
this.PageToRetrieve = response.ResponseUri;
this.Length = response.ContentLength;
this.Content = stream.ReadToEnd();
stream.Close();
return true; //success
}
public static string GetResponseContent(System.Net.WebResponse res)
{
string result = "";
using (var rs = res.GetResponseStream())
{
byte[] buff = new byte[res.ContentLength];
rs.Read(buff, 0, (int)res.ContentLength);
result = Encoding.UTF8.GetString(buff);
}
return result;
}
internal static byte[] ProcessContent(System.Net.HttpWebResponse resp)
{
Int64 iContentLength = resp.ContentLength;
MemoryStream memStream = new MemoryStream();
const int BUFFER_SIZE = 4096;
int iRead = 0;
int idx = 0;
Int64 iSize = 0;
memStream.SetLength(BUFFER_SIZE);
while (true)
{
byte[] respBuffer = new byte[BUFFER_SIZE];
try
{
iRead = resp.GetResponseStream().Read(respBuffer, 0, BUFFER_SIZE);
}
catch (System.Exception e)
{
System.Diagnostics.Debug.WriteLine(e.Message);
}
if (iRead == 0)
{
break;
}
iSize += iRead;
memStream.SetLength(iSize);
memStream.Write(respBuffer, 0, iRead);
idx += iRead;
}
byte[] contentBytes = memStream.ToArray();
memStream.Close();
return contentBytes;
}
public override bool GetResponse(System.Net.HttpWebResponse webresponse)
{
string enc = "utf-8"; // default
if (webresponse.ContentEncoding != String.Empty)
{
// Use the HttpHeader Content-Type in preference to the one set in META
this.Encoding = webresponse.ContentEncoding;
}
else if (this.Encoding == String.Empty)
{
// TODO: if still no encoding determined, try to readline the stream until we find either
// * META Content-Type or * </head> (ie. stop looking for META)
this.Encoding = enc; // default
}
//http://www.c-sharpcorner.com/Code/2003/Dec/ReadingWebPageSources.asp
System.IO.StreamReader stream = new System.IO.StreamReader
(webresponse.GetResponseStream(), System.Text.Encoding.GetEncoding(this.Encoding));
this.Uri = webresponse.ResponseUri; // we *may* have been redirected... and we want the *final* URL
this.Length = webresponse.ContentLength;
this.All = stream.ReadToEnd();
stream.Close();
return true; //success
}
private static string RetrieveFromURL(System.Net.WebResponse response)
{
if (response.ContentType != "application/octet-stream")
{
// Error occurred - we did not receive a file, but text instead
StringBuilder sb = new StringBuilder(1000);
Stream ReceiveStream = response.GetResponseStream();
Encoding encode = Encoding.GetEncoding("utf-8");
// Pipe the stream to a higher level stream reader with the required encoding format.
StreamReader readStream = new StreamReader(ReceiveStream, encode);
Char[] read = new Char[256];
int count = readStream.Read(read, 0, 256);
while (count > 0)
{
// Dump the 256 characters on a string and display the string onto the console.
String str = new String(read, 0, count);
sb.Append(str);
count = readStream.Read(read, 0, 256);
}
readStream.Close();
// Release the resources of response object.
response.Close();
return sb.ToString();
}
// We received a file, now save it
string filenameHeader = response.Headers["Content-Disposition"];
string filename = filenameHeader.Substring(filenameHeader.IndexOf("filename=") + "filename=".Length);
// 2. Get the Stream Object from the response
System.IO.Stream responseStream = response.GetResponseStream();
WriteStreamToFile(responseStream, Path.Combine(Path.GetDirectoryName(System.Windows.Forms.Application.ExecutablePath), filename));
return "";
}
