public async Task ConnectAsync_AddCustomHeaders_Success(Uri server)
{
using (var cws = new ClientWebSocket())
{
cws.Options.SetRequestHeader("X-CustomHeader1", "Value1");
cws.Options.SetRequestHeader("X-CustomHeader2", "Value2");
using (var cts = new CancellationTokenSource(TimeOutMilliseconds))
{
Task taskConnect = cws.ConnectAsync(server, cts.Token);
Assert.True(
(cws.State == WebSocketState.None) ||
(cws.State == WebSocketState.Connecting) ||
(cws.State == WebSocketState.Open),
"State immediately after ConnectAsync incorrect: " + cws.State);
await taskConnect;
}
Assert.Equal(WebSocketState.Open, cws.State);
byte[] buffer = new byte[65536];
var segment = new ArraySegment<byte>(buffer, 0, buffer.Length);
WebSocketReceiveResult recvResult;
using (var cts = new CancellationTokenSource(TimeOutMilliseconds))
{
recvResult = await cws.ReceiveAsync(segment, cts.Token);
}
Assert.Equal(WebSocketMessageType.Text, recvResult.MessageType);
string headers = WebSocketData.GetTextFromBuffer(segment);
Assert.True(headers.Contains("X-CustomHeader1:Value1"));
Assert.True(headers.Contains("X-CustomHeader2:Value2"));
await cws.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
}
}
// properties
// methods
/// <devdoc>
/// <para>Adds a <see cref='System.Net.NetworkCredential'/>
/// instance to the credential cache.</para>
/// </devdoc>
// UEUE
public void Add(Uri uriPrefix, string authType, NetworkCredential cred) {
//
// parameter validation
//
if (uriPrefix==null) {
throw new ArgumentNullException("uriPrefix");
}
if (authType==null) {
throw new ArgumentNullException("authType");
}
if ((cred is SystemNetworkCredential)
#if !FEATURE_PAL
&& !((string.Compare(authType, NtlmClient.AuthType, StringComparison.OrdinalIgnoreCase)==0)
|| (DigestClient.WDigestAvailable && (string.Compare(authType, DigestClient.AuthType, StringComparison.OrdinalIgnoreCase)==0))
|| (string.Compare(authType, KerberosClient.AuthType, StringComparison.OrdinalIgnoreCase)==0)
|| (string.Compare(authType, NegotiateClient.AuthType, StringComparison.OrdinalIgnoreCase)==0))
#endif
) {
throw new ArgumentException(SR.GetString(SR.net_nodefaultcreds, authType), "authType");
}
++m_version;
CredentialKey key = new CredentialKey(uriPrefix, authType);
GlobalLog.Print("CredentialCache::Add() Adding key:[" + key.ToString() + "], cred:[" + cred.Domain + "],[" + cred.UserName + "]");
cache.Add(key, cred);
if (cred is SystemNetworkCredential) {
++m_NumbDefaultCredInCache;
}
}
private async void Launch_Click(object sender, RoutedEventArgs e)
{
if (FacebookClientID.Text == "")
{
rootPage.NotifyUser("Please enter an Client ID.", NotifyType.StatusMessage);
return;
}
var uri = new Uri("https://graph.facebook.com/me");
HttpClient httpClient = GetAutoPickerHttpClient(FacebookClientID.Text);
DebugPrint("Getting data from facebook....");
var request = new HttpRequestMessage(HttpMethod.Get, uri);
try
{
var response = await httpClient.SendRequestAsync(request);
if (response.IsSuccessStatusCode)
{
string userInfo = await response.Content.ReadAsStringAsync();
DebugPrint(userInfo);
}
else
{
string str = "";
if (response.Content != null)
str = await response.Content.ReadAsStringAsync();
DebugPrint("ERROR: " + response.StatusCode + " " + response.ReasonPhrase + "\r\n" + str);
}
}
catch (Exception ex)
{
DebugPrint("EXCEPTION: " + ex.Message);
}
}
/// <summary>
/// Invoked when this page is about to be displayed in a Frame.
/// </summary>
/// <param name="e">Event data that describes how this page was reached. The Parameter
/// property is typically used to configure the page.</param>
protected override void OnNavigatedTo(NavigationEventArgs e)
{
Uri uri = new Uri((string)e.Parameter);
bool bAuto = false;
string[] _params = uri.Query.Replace("?", "").Split('&');
//TODO case "warect"
//
for (int i = 0; i < _params.Length; i++) {
string[] fields = _params[i].Split('=');
string _name = fields[0];
string _val = fields[1];
switch (_name) {
case "waplay":
if (_val == "auto")
bAuto = true;
break;
}
}
string path = "mov/";
string fileName = uri.LocalPath.Replace("/", "");
string name = fileName;
mediaMain.AutoPlay = bAuto;
string fullPath = String.Format("ms-appdata:///local/{0}", (path + name ));
Uri videoUrl = new Uri(fullPath);
mediaMain.Source = videoUrl;
}
public BaseAppelRequstHandler(HttpRequest Request, HttpResponse Response, Uri Prefix, string VersionHeader)
{
this.Request = Request;
this.Response = Response;
this.Prefix = Prefix;
this.VersionHeader = VersionHeader;
}
static string PostStream (Mono.Security.Protocol.Tls.SecurityProtocolType protocol, string url, byte[] buffer)
{
Uri uri = new Uri (url);
string post = "POST " + uri.AbsolutePath + " HTTP/1.0\r\n";
post += "Content-Type: application/x-www-form-urlencoded\r\n";
post += "Content-Length: " + (buffer.Length + 5).ToString () + "\r\n";
post += "Host: " + uri.Host + "\r\n\r\n";
post += "TEST=";
byte[] bytes = Encoding.Default.GetBytes (post);
IPHostEntry host = Dns.Resolve (uri.Host);
IPAddress ip = host.AddressList [0];
Socket socket = new Socket (ip.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
socket.Connect (new IPEndPoint (ip, uri.Port));
NetworkStream ns = new NetworkStream (socket, false);
SslClientStream ssl = new SslClientStream (ns, uri.Host, false, protocol);
ssl.ServerCertValidationDelegate += new CertificateValidationCallback (CertificateValidation);
ssl.Write (bytes, 0, bytes.Length);
ssl.Write (buffer, 0, buffer.Length);
ssl.Flush ();
StreamReader reader = new StreamReader (ssl, Encoding.UTF8);
string result = reader.ReadToEnd ();
int start = result.IndexOf ("\r\n\r\n") + 4;
start = result.IndexOf ("\r\n\r\n") + 4;
return result.Substring (start);
}
void ProcessDocument(Uri url)
{
Console.Error.WriteLine ("Processing {0}...", url);
var doc = FetchXmlDocument (url);
var baseTable = doc.SelectSingleNode ("//table[@class='jd-inheritance-table']");
var baseTypeName = baseTable.SelectSingleNode ("tr[last() - 1]/td[last()]").InnerText;
fs1.WriteLine ("<class name='{0}' url='{1}' base='{2}'>", GetName (url), url, baseTypeName);
/*
var table = doc.SelectSingleNode ("//table[@id='lattrs']");
if (table != null) {
var nodes = table.SelectNodes ("tr[contains(@class,'api')]");
foreach (XmlNode node in nodes) {
var attr = node.SelectSingleNode ("td[1]//text()");
var method = node.SelectSingleNode ("td[2]//text()");
var a = attr.InnerText;
fs1.WriteLine ("<a>{0}</a>", a);//node.SelectSingleNode ("td[1]"));
if (!atts.Contains (a))
atts.Add (a);
}
}
*/
fs1.WriteLine ("</class>");
fs1.Flush ();
}
public static BitmapImage ImageFromRelativePath(FrameworkElement parent, string path)
{
var uri = new Uri(parent.BaseUri, path);
BitmapImage result = new BitmapImage();
result.UriSource = uri;
return result;
}
// Maps a URI to an Object containing the actual resource.
public override Object GetEntity(Uri uri, string role, Type typeOfObjectToReturn)
{
if (uri == null)
{
throw new ArgumentNullException(nameof(uri));
}
if (typeOfObjectToReturn != null && typeOfObjectToReturn != typeof(Stream) && typeOfObjectToReturn != typeof(Object))
{
throw new XmlException(SR.Xml_UnsupportedClass, string.Empty);
}
string filePath = uri.OriginalString;
if (uri.IsAbsoluteUri)
{
if (!uri.IsFile)
throw new XmlException(SR.Format(SR.Xml_SystemPathResolverCannotOpenUri, uri.ToString()));
filePath = uri.LocalPath;
}
try
{
return new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
}
catch (ArgumentException e)
{
throw new XmlException(SR.Format(SR.Xml_SystemPathResolverCannotOpenUri, uri.ToString()), e);
}
}
protected void Page_Load(object sender, EventArgs e)
{
rptEntities.DataSource = companyFac.GetAllEntities();
rptEntities.DataBind();
int id = Convert.ToInt32(Request.QueryString["ID"]);
if (id != 0)
{
ShowCompany.Attributes.Remove("hidden");
comp = companyFac.GetEntityByID(id);
PopulateFields();
}
else if (Request.QueryString["NewItem"] == "true")
{
ShowCompany.Attributes.Remove("hidden");
comp = new Company();
}
else if (Convert.ToInt32(Request.QueryString["DID"]) > 0)
{
int deleteID = Convert.ToInt32(Request.QueryString["DID"]);
companyFac.Delete(deleteID);
var uri = new Uri(Request.Url.AbsoluteUri);
string path = uri.GetLeftPart(UriPartial.Path);
Response.Redirect(path);
}
}
public void Accept_SetThenGetValidValue_ExpectSameValue(Uri remoteServer)
{
HttpWebRequest request = WebRequest.CreateHttp(remoteServer);
string acceptType = "*/*";
request.Accept = acceptType;
Assert.Equal(acceptType, request.Accept);
}
public VolumeSource (Gnome.Vfs.Volume vol)
{
this.Volume = vol;
this.Name = vol.DisplayName;
try {
mount_point = new Uri (vol.ActivationUri).LocalPath;
} catch (System.Exception e) {
System.Console.WriteLine (e);
}
uri = mount_point;
if (this.Icon == null)
this.Icon = PixbufUtils.LoadThemeIcon (vol.Icon, 32);
if (this.IsIPodPhoto)
this.Icon = PixbufUtils.LoadThemeIcon ("gnome-dev-ipod", 32);
if (this.Icon == null && this.IsCamera)
this.Icon = PixbufUtils.LoadThemeIcon ("gnome-dev-media-cf", 32);
try {
if (this.Icon == null)
this.Icon = new Gdk.Pixbuf (vol.Icon);
} catch (System.Exception e) {
System.Console.WriteLine (e.ToString ());
}
}
/// <summary>
/// Retrieve the URL that the client should redirect the user to to perform the OAuth authorization
/// </summary>
/// <param name="provider"></param>
/// <returns></returns>
protected override string GetAuthorizationUrl(String callbackUrl)
{
OAuthBase auth = new OAuthBase();
String requestUrl = provider.Host + provider.RequestTokenUrl;
Uri url = new Uri(requestUrl);
String requestParams = "";
String signature = auth.GenerateSignature(url, provider.ClientId, provider.Secret, null, null, provider.RequestTokenMethod ?? "POST",
auth.GenerateTimeStamp(), auth.GenerateTimeStamp() + auth.GenerateNonce(), out requestUrl, out requestParams,
new OAuthBase.QueryParameter(OAuthBase.OAuthCallbackKey, auth.UrlEncode(callbackUrl)));
requestParams += "&oauth_signature=" + HttpUtility.UrlEncode(signature);
WebClient webClient = new WebClient();
byte[] response;
if (provider.RequestTokenMethod == "POST" || provider.RequestTokenMethod == null)
{
response = webClient.UploadData(url, Encoding.ASCII.GetBytes(requestParams));
}
else
{
response = webClient.DownloadData(url + "?" + requestParams);
}
Match m = Regex.Match(Encoding.ASCII.GetString(response), "oauth_token=(.*?)&oauth_token_secret=(.*?)&oauth_callback_confirmed=true");
String requestToken = m.Groups[1].Value;
String requestTokenSecret = m.Groups[2].Value;
// we need a way to save the request token & secret, so that we can use it to get the access token later (when they enter the pin)
// just stick it in the session for now
HttpContext.Current.Session[OAUTH1_REQUEST_TOKEN_SESSIONKEY] = requestToken;
HttpContext.Current.Session[OAUTH1_REQUEST_TOKEN_SECRET_SESSIONKEY] = requestTokenSecret;
return provider.Host + provider.UserApprovalUrl + "?oauth_token=" + HttpUtility.UrlEncode(requestToken);
}
private async Task<OAuth> SignInAsyncTask(string username, string password)
{
var o = new OAuth(ConsumerKey, ConsumerSecret);
var uri = new Uri(XAuthUrl);
string xauth = string.Format("x_auth_mode=client_auth&x_auth_password={0}&x_auth_username={1}",
password.UrlEncode(), username.UrlEncode());
uri = o.SignUri(uri, extraSignature: xauth, httpmethod: "POST");
string result = await uri.HttpPost(xauth);
if (result == null)
return null;
string token = "";
string tokensecret = "";
foreach (var val in result.Split('&').Select(item => item.Split('=')))
{
switch (val[0])
{
case "oauth_token":
token = val[1];
break;
case "oauth_token_secret":
tokensecret = val[1];
break;
}
}
o.Token = token;
o.TokenSecret = tokensecret;
return o;
}
public MainPage()
{
this.InitializeComponent();
//
// Every Windows Store application has a unique URI.
// Windows ensures that only this application will receive messages sent to this URI.
// ADAL uses this URI as the application's redirect URI to receive OAuth responses.
//
// To determine this application's redirect URI, which is necessary when registering the app
// in AAD, set a breakpoint on the next line, run the app, and copy the string value of the URI.
// This is the only purposes of this line of code, it has no functional purpose in the application.
//
redirectURI = Windows.Security.Authentication.Web.WebAuthenticationBroker.GetCurrentApplicationCallbackUri();
authContext = new AuthenticationContext(authority);
//
// Out of the box, this sample is *not* configured to work with Windows Integrated Authentication (WIA)
// when used with a federated Azure Active Directory domain. To work with WIA the application manifest
// must enable additional capabilities. These are not configured by default for this sample because
// applications requesting the Enterprise Authentication or Shared User Certificates capabilities require
// a higher level of verification to be accepted into the Windows Store, and not all developers may wish
// to perform the higher level of verification.
//
// To enable Windows Integrated Authentication, in Package.appxmanifest, in the Capabilities tab, enable:
// * Enterprise Authentication
// * Private Networks (Client & Server)
// * Shared User Certificates
//
// Plus uncomment the following line of code:
//
// authContext.UseCorporateNetwork = true;
}
public void ProxyExplicitlyProvided_DefaultCredentials_Ignored()
{
int port;
Task<LoopbackGetRequestHttpProxy.ProxyResult> proxyTask = LoopbackGetRequestHttpProxy.StartAsync(out port, requireAuth: true, expectCreds: true);
Uri proxyUrl = new Uri($"http://localhost:{port}");
var rightCreds = new NetworkCredential("rightusername", "rightpassword");
var wrongCreds = new NetworkCredential("wrongusername", "wrongpassword");
using (var handler = new HttpClientHandler())
using (var client = new HttpClient(handler))
{
handler.Proxy = new UseSpecifiedUriWebProxy(proxyUrl, rightCreds);
handler.DefaultProxyCredentials = wrongCreds;
Task<HttpResponseMessage> responseTask = client.GetAsync(Configuration.Http.RemoteEchoServer);
Task<string> responseStringTask = responseTask.ContinueWith(t => t.Result.Content.ReadAsStringAsync(), TaskScheduler.Default).Unwrap();
Task.WaitAll(proxyTask, responseTask, responseStringTask);
TestHelper.VerifyResponseBody(responseStringTask.Result, responseTask.Result.Content.Headers.ContentMD5, false, null);
Assert.Equal(Encoding.ASCII.GetString(proxyTask.Result.ResponseContent), responseStringTask.Result);
string expectedAuth = $"{rightCreds.UserName}:{rightCreds.Password}";
Assert.Equal(expectedAuth, proxyTask.Result.AuthenticationHeaderValue);
}
}
public CompetitionResultAppelRequestHandler(HttpRequest Request, HttpResponse Response, Uri Prefix, UriTemplate CompetitionResultsTemplate, UriTemplate ResultResourceTemplate, string AcceptHeader)
: base(Request, Response, Prefix, AcceptHeader)
{
this.CompetitionResultsTemplate = CompetitionResultsTemplate;
this.ResultResourceTemplate = ResultResourceTemplate;
processRequest();
}
private string GetParameters(Uri sourcefile)
{
string parameters = "";
string sourceRdl = System.IO.File.ReadAllText(sourcefile.LocalPath);
fyiReporting.RDL.RDLParser parser = new fyiReporting.RDL.RDLParser(sourceRdl);
parser.Parse();
if (parser.Report.UserReportParameters.Count > 0)
{
int count = 0;
foreach (fyiReporting.RDL.UserReportParameter rp in parser.Report.UserReportParameters)
{
parameters += "&" + rp.Name + "=";
}
fyiReporting.RdlGtkViewer.ParameterPrompt prompt = new fyiReporting.RdlGtkViewer.ParameterPrompt();
prompt.Parameters = parameters;
if (prompt.Run() == (int)Gtk.ResponseType.Ok)
{
parameters = prompt.Parameters;
}
prompt.Destroy();
}
return parameters;
}
public void BuildRoute_ValidatesConstraintType_InvalidType()
{
// Arrange
var actions = GetActions();
var builder = new DirectRouteBuilder(actions, targetIsAction: true);
var constraint = new Uri("http://localhost/");
var constraints = new TRouteValueDictionary();
constraints.Add("custom", constraint);
builder.Constraints = constraints;
builder.Template = "c/{id}";
#if ASPNETWEBAPI
string expectedMessage =
"The constraint entry 'custom' on the route with route template 'c/{id}' " +
"must have a string value or be of a type which implements 'System.Web.Http.Routing.IHttpRouteConstraint'.";
#else
string expectedMessage =
"The constraint entry 'custom' on the route with route template 'c/{id}' " +
"must have a string value or be of a type which implements 'System.Web.Routing.IRouteConstraint'.";
#endif
// Act & Assert
Assert.Throws<InvalidOperationException>(() => builder.Build(), expectedMessage);
}
/// <summary>
/// Helper that produces the contents corresponding to a Uri.
/// Uses the C# await pattern to coordinate async operations.
/// </summary>
/// <param name="uri"></param>
/// <returns></returns>
private async Task<IInputStream> GetContentAsync(Uri uri)
{
string path = uri.AbsolutePath;
string contents;
switch (path)
{
case "/default.html":
contents = await MainPage.LoadStringFromPackageFileAsync("stream_example.html");
contents = contents.Replace("%", Windows.ApplicationModel.Package.Current.Id.Name);
break;
case "/stream.css":
contents = "p { color: blue; }";
break;
default:
throw new Exception($"Could not resolve URI \"{uri}\"");
}
// Convert the string to a stream.
IBuffer buffer = CryptographicBuffer.ConvertStringToBinary(contents, BinaryStringEncoding.Utf8);
var stream = new InMemoryRandomAccessStream();
await stream.WriteAsync(buffer);
return stream.GetInputStreamAt(0);
}
private void SearchByApml(Uri url)
{
List<IPublishable> list = new List<IPublishable>();
try
{
Dictionary<Uri, XmlDocument> docs = Utils.FindSemanticDocuments(url, "apml");
if (docs.Count > 0)
{
foreach (Uri key in docs.Keys)
{
list = Search.ApmlMatches(docs[key], 30);
Page.Title = "APML matches for '" + Server.HtmlEncode(key.ToString()) + "'";
break;
}
}
else
{
Page.Title = "APML matches for '" + Server.HtmlEncode(Request.QueryString["q"]) + "'";
}
h1Headline.InnerText = Page.Title;
}
catch
{
}
BindSearchResult(list);
}
public static HttpWebRequest GenerateHttpWebRequest(Uri uri)
{
//all this mess below is my attempt to resolve some of the issues in taking on various conflicts in httpreqeust.
//code is left in
//if infact requests vary may need to switch(key) on differnet sites?
HttpWebRequest httpRequest = (HttpWebRequest)WebRequest.Create(uri);
httpRequest.UserAgent = "Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US) AppleWebKit/534.20 (KHTML, like Gecko) Chrome/11.0.672.2 Safari/534.2";
CookieContainer cc = new CookieContainer();
httpRequest.CookieContainer = cc;//must assing a cookie container for the request to pull the cookies
httpRequest.AllowAutoRedirect = true; //example, Hanes.com
httpRequest.Credentials = CredentialCache.DefaultCredentials;
//httpRequest.Headers.Add("HTTP_USER_AGENT", @"Mozilla/5.0(PC) (Windows; U; Windows NT 5.1; en-US; rv:1.8.0.4) Gecko/20060508 Firefox/1.5.0.4");
// httpRequest.Headers.Add("Agent", "Mozilla/5.0(PC) (Windows; U; Windows NT 5.1; en-US; rv:1.8.0.4) Gecko/20060508 Firefox/1.5.0.4");
// httpRequest.Headers.Add("Accept-Charset", "ISO-8859-1");
/*
httpRequest.Headers.Add("Accept-Language", "en-us,en;q=0.5");
httpRequest.Headers.Add("Accept-Encoding", "gzip,deflate");
httpRequest.Headers.Add("Accept-Charset", "ISO-8859-1,utf-8;q=0.7,*;q=0.7");
// httpRequest.Headers.Add("Set-Cookie", response.Headers("Set-Cookie"));
httpRequest.Headers.Add("Agent", "Mozilla//5.0 (X11; U; Linux i686; en-US; ry; 1.8.0.7) Geck//20060925 Firefox//1.5.0.7");
*/
return httpRequest;
}
public void DocumentationIndexIsUpToDate()
{
var documentationIndexFile = ReadDocumentationFile("../mkdocs.yml");
var docsDirectoryPath = new Uri(docsDirectory.FullName, UriKind.Absolute);
Console.WriteLine(docsDirectoryPath);
foreach (var markdownFile in docsDirectory.EnumerateFiles("*.md", SearchOption.AllDirectories))
{
var fullPath = new Uri(markdownFile.FullName, UriKind.Absolute);
var relativePath = docsDirectoryPath
.MakeRelativeUri(fullPath)
.ToString()
.Replace("docs/", string.Empty);
// The readme file in the docs directory is not supposed to be deployed to ReadTheDocs;
// it's only there for the convenience of contributors wanting to improve the documentation itself.
if (relativePath == "readme.md")
{
continue;
}
documentationIndexFile.ShouldContain(relativePath, () => string.Format("The file '{0}' is not listed in 'mkdocs.yml'.", relativePath));
}
}
public static Evidence CreateEvidenceForUrl(string securityUrl) {
#if !DISABLE_CAS_USE
Evidence evidence = new Evidence();
if (securityUrl != null && securityUrl.Length > 0) {
evidence.AddHostEvidence(new Url(securityUrl));
evidence.AddHostEvidence(Zone.CreateFromUrl(securityUrl));
Uri uri = new Uri(securityUrl, UriKind.RelativeOrAbsolute);
if (uri.IsAbsoluteUri && !uri.IsFile) {
evidence.AddHostEvidence(Site.CreateFromUrl(securityUrl));
}
// Allow same directory access for UNCs (SQLBUDT 394535)
if (uri.IsAbsoluteUri && uri.IsUnc) {
string uncDir = System.IO.Path.GetDirectoryName(uri.LocalPath);
if (uncDir != null && uncDir.Length != 0) {
evidence.AddHostEvidence(new UncDirectory(uncDir));
}
}
}
return evidence;
#else
return null;
#endif
}
public void UriIsWellFormed_NewAbsoluteUnregisteredAsRelative_Throws()
{
Assert.ThrowsAny<FormatException>(() =>
{
Uri test = new Uri("any://foo", UriKind.Relative);
});
}
private async Task<string> GetRequestToken()
{
try
{
const string requestTokenUrl = "http://api.moefou.org/oauth/request_token";
const string httpMethod = "GET";
Uri url = new Uri(requestTokenUrl);
string timeStamp = this.OAuth.GenerateTimeStamp();
string nonce = this.OAuth.GenerateNonce();
string nUrl = null;
string pa = null;
string signature = this.OAuth.GenerateSignature(url, AppConst.MoeAppKey, AppConst.ConsumerSecret, string.Empty, string.Empty, httpMethod, timeStamp, nonce, string.Empty, out nUrl, out pa);
List<QueryParameter> parameters = new List<QueryParameter>();
string requestUrl = string.Format("{0}?{1}&{2}={3}", nUrl, pa, OAuthBase.OAuthSignatureKey, signature);
WebRequest request = WebRequest.Create(requestUrl);
WebResponse response = await request.GetResponseAsync();
using (StreamReader sr = new StreamReader(response.GetResponseStream()))
{
List<QueryParameter> reqPa = this.OAuth.GetQueryParameters(await sr.ReadToEndAsync());
var oauth_token = reqPa.Find(qp => qp.Name.Equals("oauth_token")).Value;
var oauth_token_secret = reqPa.Find(qp => qp.Name.Equals("oauth_token_secret")).Value;
//将为授权的token放入到
Windows.Storage.ApplicationData.Current.LocalSettings.Values["oauth_token"] = oauth_token;
Windows.Storage.ApplicationData.Current.LocalSettings.Values["oauth_token_secret"] = oauth_token_secret;
}
return string.Empty;
}
catch (Exception)
{
throw;
}
}
internal static string UriToString(Uri uri)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(uri != null, "uri != null");
return uri.IsAbsoluteUri ? uri.AbsoluteUri : uri.OriginalString;
}
/// <summary>
/// Get Presence information per user.
/// </summary>
private async void AsyncPresence()
{
var client = new HttpClient();
var uri = new Uri(string.Format(Configurations.PresenceUrl, Configurations.ApiKey, _currentMember.id));
var response = await client.GetAsync(uri);
var statusCode = response.StatusCode;
switch (statusCode)
{
// TODO: Error handling for invalid htpp responses.
}
response.EnsureSuccessStatusCode();
var theResponse = await response.Content.ReadAsStringAsync();
using (var ms = new MemoryStream(Encoding.Unicode.GetBytes(theResponse)))
{
var serializer = new DataContractJsonSerializer(typeof(PresenceRoot));
var presenceObject = serializer.ReadObject(ms) as PresenceRoot;
// This will allow the application to toggle the presence indicator color.
if (presenceObject != null && presenceObject.ok && presenceObject.IsActive())
{
await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
StatusIndicator.Fill = new SolidColorBrush(Color.FromArgb(255, 127, 153, 71));
});
}
// TODO: Add more code for bad replies or invalid requests.
}
}
// Internal constructor
// <param name="uri">URI of the markup page to navigate to.</param>
// <param name="bytesRead">The number of bytes that have already been downloaded.</param>
// <param name="maxBytes">The maximum number of bytes to be downloaded.</param>
// <param name="Navigator">navigator that raised this event</param>
internal NavigationProgressEventArgs(Uri uri, long bytesRead, long maxBytes, object Navigator)
{
_uri = uri;
_bytesRead = bytesRead;
_maxBytes = maxBytes;
_navigator = Navigator;
}
public PolicyBasedWebRequest (Uri uri)
{
this.uri = uri;
allow_read_buffering = true;
method = "GET";
content_length = -1;
}
public ReferenceLink(string shortDescription, string url)
{
ShortDescription = shortDescription;
Uri = new Uri(url);
}
/// <summary>
/// Initializes a new instance of the <see cref="FamilySearchFamilyTree"/> class.
/// </summary>
/// <param name="uri">The URI where the target resides.</param>
/// <param name="stateFactory">The state factory to use for state instantiation.</param>
private FamilySearchFamilyTree(Uri uri, FamilyTreeStateFactory stateFactory)
: this(uri, stateFactory.LoadDefaultClientInt(uri), stateFactory)
{
}
internal static string EndpointReference(Uri uri, string contractName)
{
return(EndpointReference((null != uri) ? uri.ToString() : string.Empty, contractName, true));
}
public async Task UseCallback_ValidCertificate_ExpectedValuesDuringCallback(Configuration.Http.RemoteServer remoteServer, Uri url, bool checkRevocation)
{
HttpClientHandler handler = CreateHttpClientHandler();
using (HttpClient client = CreateHttpClientForRemoteServer(remoteServer, handler))
{
bool callbackCalled = false;
handler.CheckCertificateRevocationList = checkRevocation;
handler.ServerCertificateCustomValidationCallback = (request, cert, chain, errors) => {
callbackCalled = true;
Assert.NotNull(request);
X509ChainStatusFlags flags = chain.ChainStatus.Aggregate(X509ChainStatusFlags.NoError, (cur, status) => cur | status.Status);
bool ignoreErrors = // https://github.com/dotnet/runtime/issues/22644#issuecomment-315555237
RuntimeInformation.IsOSPlatform(OSPlatform.OSX) &&
checkRevocation &&
errors == SslPolicyErrors.RemoteCertificateChainErrors &&
flags == X509ChainStatusFlags.RevocationStatusUnknown;
Assert.True(ignoreErrors || errors == SslPolicyErrors.None, $"Expected {SslPolicyErrors.None}, got {errors} with chain status {flags}");
Assert.True(chain.ChainElements.Count > 0);
Assert.NotEmpty(cert.Subject);
// UWP always uses CheckCertificateRevocationList=true regardless of setting the property and
// the getter always returns true. So, for this next Assert, it is better to get the property
// value back from the handler instead of using the parameter value of the test.
Assert.Equal(
handler.CheckCertificateRevocationList ? X509RevocationMode.Online : X509RevocationMode.NoCheck,
chain.ChainPolicy.RevocationMode);
return true;
};
using (HttpResponseMessage response = await client.GetAsync(url))
{
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
Assert.True(callbackCalled);
}
}
public static void Main(string [] args)
{
int port = 0;
string certfile = null;
string certpass = null;
bool no_sc = false, no_nego = false;
foreach (string arg in args)
{
if (arg == "--help")
{
Usage();
return;
}
if (arg.StartsWith("--port:"))
{
int.TryParse(arg.Substring(7), out port);
continue;
}
if (arg == "--no-sc")
{
no_sc = true;
continue;
}
if (arg == "--no-nego")
{
no_nego = true;
continue;
}
if (arg.StartsWith("--certfile:"))
{
certfile = arg.Substring(11);
continue;
}
if (arg.StartsWith("--certpass:"******"unrecognized option: " + arg);
return;
}
if (certfile == null || certpass == null)
{
Console.WriteLine("specify certificate information to identify this service.");
return;
}
if (port <= 0)
{
port = 8080;
}
Uri listeningUri = new Uri("http://localhost:" + port);
ServiceHost host = new ServiceHost(
typeof(WSTrustSecurityTokenService), listeningUri);
host.Description.Behaviors.Find <ServiceDebugBehavior> ().IncludeExceptionDetailInFaults = true;
ServiceMetadataBehavior smb = new ServiceMetadataBehavior();
smb.HttpGetEnabled = true;
host.Description.Behaviors.Add(smb);
WSHttpBinding binding = new WSHttpBinding();
binding.Security.Message.ClientCredentialType = MessageCredentialType.None;
if (no_sc)
{
binding.Security.Message.EstablishSecurityContext = false;
}
if (no_nego)
{
binding.Security.Message.NegotiateServiceCredential = false;
}
ServiceCredentials credentials = new ServiceCredentials();
credentials.ServiceCertificate.Certificate = new X509Certificate2(certfile, certpass);
//credentials.IssuedTokenAuthentication.AllowUntrustedRsaIssuers = true;
host.Description.Behaviors.Add(credentials);
host.AddServiceEndpoint(
typeof(IWSTrustSecurityTokenService),
binding,
listeningUri);
host.Open();
Console.WriteLine("Type [ENTER] to close ...");
Console.ReadLine();
host.Close();
}
/// <summary>
/// Builds a model using the specified <see cref="DocumentModelAdministrationClient"/> and the specified set of training files. A
/// <see cref="DisposableBuildModel"/> instance is returned. Upon disposal,
/// the associated model will be deleted.
/// </summary>
/// <param name="adminClient">The client to use for building and for deleting the model upon disposal.</param>
/// <param name="trainingFilesUri">An externally accessible Azure storage blob container Uri.</param>
/// <param name="buildMode">The technique to use to build the model.</param>
/// <param name="modelId">Model Id.</param>
/// <returns>A <see cref="DisposableBuildModel"/> instance from which the trained model ID can be obtained.</returns>
public static async Task<DisposableBuildModel> BuildModelAsync(DocumentModelAdministrationClient adminClient, Uri trainingFilesUri, DocumentBuildMode buildMode, string modelId)
{
BuildModelOperation operation = await adminClient.StartBuildModelAsync(trainingFilesUri, buildMode, modelId);
await operation.WaitForCompletionAsync();
Assert.IsTrue(operation.HasValue);
return new DisposableBuildModel(adminClient, operation.Value.ModelId);
}
public override void WriteValue(Uri value)
{
_textWriter.WriteValue(value);
_innerWriter.WriteValue(value);
base.WriteValue(value);
}
/// <summary>
/// Initializes a new instance of the <see cref="FamilySearchFamilyTree"/> class.
/// </summary>
/// <param name="uri">The URI where the target resides.</param>
/// <param name="client">The REST API client to use for API calls.</param>
/// <param name="stateFactory">The state factory to use for state instantiation.</param>
private FamilySearchFamilyTree(Uri uri, IFilterableRestClient client, FamilyTreeStateFactory stateFactory)
: this(new RedirectableRestRequest().Accept(MediaTypes.GEDCOMX_JSON_MEDIA_TYPE).Build(uri, Method.GET), client, stateFactory)
{
}
private string CreateOauthSignature(string resourceUrl, Method method, string oauthNonce, string oauthTimestamp, SortedDictionary requestParameters)
{
//firstly we need to add the standard oauth parameters to the sorted list
requestParameters.Add("oauth_consumer_key", ConsumerKey);
requestParameters.Add("oauth_nonce", oauthNonce);
requestParameters.Add("oauth_signature_method", OauthSignatureMethod);
requestParameters.Add("oauth_timestamp", oauthTimestamp);
requestParameters.Add("oauth_token", AccessToken);
requestParameters.Add("oauth_version", OauthVersion);
var sigBaseString = requestParameters.ToWebString();
var signatureBaseString = string.Concat(method.ToString(), "&", Uri.EscapeDataString(resourceUrl), "&", Uri.EscapeDataString(sigBaseString.ToString()));
//Using this base string, we then encrypt the data using a composite of the
//secret keys and the HMAC-SHA1 algorithm.
var compositeKey = string.Concat(Uri.EscapeDataString(ConsumerKeySecret), "&", Uri.EscapeDataString(AccessTokenSecret));
string oauthSignature;
using (var hasher = new HMACSHA1(Encoding.ASCII.GetBytes(compositeKey)))
{
oauthSignature = Convert.ToBase64String(hasher.ComputeHash(Encoding.ASCII.GetBytes(signatureBaseString)));
}
return(oauthSignature);
}
/// <summary>
/// Initializes a new instance of the <see cref="FamilySearchFamilyTree"/> class.
/// </summary>
/// <param name="uri">The URI where the target collection resides.</param>
public FamilySearchFamilyTree(Uri uri)
: this(uri, new FamilyTreeStateFactory())
{
}
public void RegisterLoadBalancerEndpoint(Uri loadBalancerEndpoint)
{
container.Configure(c => c.For<LoadBalancerMessageModule>().Singleton().Use<LoadBalancerMessageModule>()
.Ctor<Uri>().Is(loadBalancerEndpoint));
}
private string CreateHeader(string resourceUrl, Method method, SortedDictionary requestParameters)
{
var oauthNonce = CreateOauthNonce();
var oauthTimestamp = CreateOAuthTimestamp();
var oauthSignature = CreateOauthSignature(resourceUrl, method, oauthNonce, oauthTimestamp, requestParameters);
//The oAuth signature is then used to generate the Authentication header.
const string headerFormat = "OAuth oauth_nonce=\"{0}\", oauth_signature_method=\"{1}\", " + "oauth_timestamp=\"{2}\", oauth_consumer_key=\"{3}\", " + "oauth_token=\"{4}\", oauth_signature=\"{5}\", " + "oauth_version=\"{6}\""; var authHeader = string.Format(headerFormat, Uri.EscapeDataString(oauthNonce), Uri.EscapeDataString(OauthSignatureMethod), Uri.EscapeDataString(oauthTimestamp), Uri.EscapeDataString(ConsumerKey), Uri.EscapeDataString(AccessToken), Uri.EscapeDataString(oauthSignature), Uri.EscapeDataString(OauthVersion));
return(authHeader);
}
public static Task<string> Get(this IWebClient client, Uri address)
{
return Get(client, null, address);
}
public Activity(Uri uri) : base(uri) { }
public static Task<string> Post(this IWebClient client, Uri address, string data)
{
return Post(client, null, address, data);
}
public static string createTicket(string requester, string tech, string desc, string subj)
{
string input = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
input += "<operation> ";
input += " <Details>";
input += " <parameter>";
input += " <name>REQUESTER</name>";
input += " <value>" + requester + "</value>";
input += " </parameter>";
input += " <parameter>";
input += " <name>SUBJECT</name>";
input += " <value>" + subj + "</value>";
input += " </parameter>";
input += " <parameter>";
input += " <name>REQUESTTEMPLATE</name>";
input += " <value>Default Request</value>";
input += " </parameter>";
input += " <parameter>";
input += " <name>PRIORITY</name>";
input += " <value>Low</value>";
input += " </parameter>";
input += " <parameter>";
input += " <name>IMPACT</name>";
input += " <value>None</value>";
input += " </parameter>";
input += " <parameter>";
input += " <name>URGENCY</name>";
input += " <value>Low</value>";
input += " </parameter>";
input += " <parameter>";
input += " <name>DESCRIPTION</name>";
input += " <value>" + desc + "</value>";
input += " </parameter>";
input += " <parameter>";
//input += " <name>TECHNICIAN</name>";
input += " <name>GROUP</name>";
input += " <value>Production Support</value>";
//input += " <value>" + tech + "</value>";
input += " </parameter>";
input += " <parameter>";
input += " <name>SITE</name>";
input += " <value>Manchester</value>";
input += " </parameter>";
input += " </Details>";
input += "</operation>";
// ee0eb78335d1e4ea02add34a18be2607
// 0b63f1cf2ce5a0f63307bc53836cd910
// ebd6098dbe251cc26eccf68617c8ed49
// string json = GetData(@"https://sdpondemand.manageengine.com/api/request", "?scope=sdpodapi&authtoken=0b63f1cf2ce5a0f63307bc53836cd910&OPERATION_NAME=ADD_REQUEST&INPUT_DATA=" + System.Web.HttpUtility.UrlEncode(input));
string json = GetData(@"https://sdpondemand.manageengine.com/api/request", "?scope=sdpodapi&authtoken=0b63f1cf2ce5a0f63307bc53836cd910&OPERATION_NAME=ADD_REQUEST&INPUT_DATA=" + Uri.EscapeUriString(input));
return json;
}
// IOAuthAuthorizeHandler.AuthorizeAsync implementation.
public Task<IDictionary<string, string>> AuthorizeAsync(Uri serviceUri, Uri authorizeUri, Uri callbackUri)
{
// If the TaskCompletionSource is not null, authorization may already be in progress and should be canceled.
// Try to cancel any existing authentication process.
_taskCompletionSource?.TrySetCanceled();
// Create a task completion source.
_taskCompletionSource = new TaskCompletionSource<IDictionary<string, string>>();
// Create a new Xamarin.Auth.OAuth2Authenticator using the information passed in.
_auth = new OAuth2Authenticator(
clientId: AppClientId,
scope: "",
authorizeUrl: authorizeUri,
redirectUrl: new Uri(OAuthRedirectUrl))
{
ShowErrors = false,
// Allow the user to cancel the OAuth attempt.
AllowCancel = true
};
// Define a handler for the OAuth2Authenticator.Completed event.
_auth.Completed += (o, authArgs) =>
{
try
{
// Dismiss the OAuth UI when complete.
InvokeOnMainThread(() => { UIApplication.SharedApplication.KeyWindow.RootViewController.DismissViewController(true, null); });
// Check if the user is authenticated.
if (authArgs.IsAuthenticated)
{
// If authorization was successful, get the user's account.
Xamarin.Auth.Account authenticatedAccount = authArgs.Account;
// Set the result (Credential) for the TaskCompletionSource.
_taskCompletionSource.SetResult(authenticatedAccount.Properties);
}
else
{
throw new Exception("Unable to authenticate user.");
}
}
catch (Exception ex)
{
// If authentication failed, set the exception on the TaskCompletionSource.
_taskCompletionSource.TrySetException(ex);
// Cancel authentication.
_auth.OnCancelled();
}
};
// If an error was encountered when authenticating, set the exception on the TaskCompletionSource.
_auth.Error += (o, errArgs) =>
{
// If the user cancels, the Error event is raised but there is no exception ... best to check first.
if (errArgs.Exception != null)
{
_taskCompletionSource.TrySetException(errArgs.Exception);
}
else
{
// Login canceled: dismiss the OAuth login.
_taskCompletionSource?.TrySetCanceled();
}
// Cancel authentication.
_auth.OnCancelled();
_auth = null;
};
// Present the OAuth UI (on the app's UI thread) so the user can enter user name and password.
InvokeOnMainThread(() => { UIApplication.SharedApplication.KeyWindow.RootViewController.PresentViewController(_auth.GetUI(), true, null); });
// Return completion source task so the caller can await completion.
return _taskCompletionSource.Task;
}
Task <ReceivedStatus> IReceiverCallback.Received(Uri uri, Envelope[] messages)
{
throw new NotImplementedException();
}
void t1_Tick(object sender, EventArgs e)
{
try
{
WAstatus = WinampLib.GetPlaybackStatus(); // Winamp states: 3=pause,1=play,0=stop
switch (WAstatus)
{
case 1: // Winamp playing
strWATitlePast = strWATitle;
strWATitle = WinampLib.GetCurrentSongTitle();
lbl_CurrentTitle.Text = strWATitle;
if (strWATitle != strWATitlePast) // new song started
{
axWindowsMediaPlayer1.URL = "none.mp3"; // dummy input (else cannot overwrite speech.mp3 with new file)
if (axWindowsMediaPlayer1.playState == WMPLib.WMPPlayState.wmppsPlaying)
{
axWindowsMediaPlayer1.Ctlcontrols.stop();
}
axWindowsMediaPlayer1.close();
// URL encoding
strWATitleTalk = strWATitle.Replace("&", "%26");
strWATitleTalk = strWATitleTalk.Replace("ä", "ae");
strWATitleTalk = strWATitleTalk.Replace("ö", "oe");
strWATitleTalk = strWATitleTalk.Replace("ü", "ue");
strWATitleTalk = strWATitleTalk.Replace("Ä", "Ae");
strWATitleTalk = strWATitleTalk.Replace("Ö", "Oe");
strWATitleTalk = strWATitleTalk.Replace("Ü", "Ue");
// ...
strTTSURL = "http://translate.google.com/translate_tts?tl=" + strLanguage + "&q=" + strWATitleTalk;
//MessageBox.Show(strWATitleTalk); // debug
if ((strWATitle.Length < 100) && (cb_voice.Checked)) // max. length 100 chars
{
// download voice file
using (wc = new WebClient())
{
wc.DownloadFileCompleted += new AsyncCompletedEventHandler(DLCompleted);
//wc.DownloadProgressChanged += new DownloadProgressChangedEventHandler(ProgressChanged);
Uri URL = new Uri(strTTSURL);
try
{
// download
wc.DownloadFileAsync(URL, "speech.mp3");
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
}
}
break;
case 3: // Winamp paused
lbl_CurrentTitle.Text = "P A U S E";
break;
default:
strWATitle = "";
strWATitlePast = "";
strWATitleTalk = "";
lbl_CurrentTitle.Text = "";
break;
}
}
catch { }
}
static void Main(string[] args)
{
try
{
Console.WriteLine("please Enter the TFS Server IP : ");
String TfsServerIp = Console.ReadLine();
String TfsServerPort = "8080";
String TfsServerVirtualPath = "tfs";
String TfsServerUriString = string.Format("http://{0}:{1}/{2}", TfsServerIp, TfsServerPort, TfsServerVirtualPath);
Uri TfsServerUri = new Uri(TfsServerUriString);
TfsConfigurationServer TfsServerconfiguration = TfsConfigurationServerFactory.GetConfigurationServer(TfsServerUri);
ReadOnlyCollection<CatalogNode> ProjectCollectionNodes = TfsServerconfiguration.CatalogNode.QueryChildren(
new[] { CatalogResourceTypes.ProjectCollection },
false, CatalogQueryOptions.None);
Console.WriteLine("please enter the ProjectCollection name : ");
string ProjectCollectionName = Console.ReadLine();
foreach (CatalogNode ProjectCollectionNode in ProjectCollectionNodes)
{
if (ProjectCollectionNode.Resource.DisplayName == ProjectCollectionName)
{
Guid collectionId = new Guid(ProjectCollectionNode.Resource.Properties["InstanceId"]);
TfsTeamProjectCollection TeamProjectCollection = TfsServerconfiguration.GetTeamProjectCollection(collectionId);
TeamProjectCollection.Connect(ConnectOptions.None);
VersionControlServer Vcs = TeamProjectCollection.GetService<VersionControlServer>();
ReadOnlyCollection<CatalogNode> TeamProjectNodes = ProjectCollectionNode.QueryChildren(
new[] { CatalogResourceTypes.TeamProject },
false, CatalogQueryOptions.None);
Console.WriteLine("please enter the Team Project name : ");
String TeamProjectName = Console.ReadLine();
Console.WriteLine("Please enter the Branch name : ");
String BranchName = Console.ReadLine();
foreach (CatalogNode TeamProjectNode in TeamProjectNodes)
{
if (TeamProjectNode.Resource.DisplayName == TeamProjectName)
{
var tp = Vcs.GetTeamProject(TeamProjectNode.Resource.DisplayName);
var ServerPath = String.Format("{0}/Branches/{1}", tp.ServerItem, BranchName);
VersionSpec versionFrom = null;
VersionSpec versionTo = VersionSpec.Latest;
var ChangeSetList = Vcs.QueryHistory(
ServerPath,
VersionSpec.Latest,
0,
RecursionType.Full,
null,
versionFrom,
versionTo,
Int32.MaxValue,
true,
true
).Cast<Changeset>().ToList();
Changeset Lastchangeset = null;
Lastchangeset = ChangeSetList.First();
Console.WriteLine(".....last Changest Report.....");
Console.WriteLine();
Console.WriteLine(string.Format("ID : {0} , Date: {1} , Comment : {2} , by : {3} ", Lastchangeset.ChangesetId, Lastchangeset.CreationDate, Lastchangeset.Comment, Lastchangeset.OwnerDisplayName));
Console.WriteLine();
Console.WriteLine(".....End The Report.....");
}
}
}
}
Console.ReadLine();
}
catch (Exception e)
{
Console.WriteLine(e);
Console.WriteLine(" Warnining ");
Console.WriteLine("-----------please check your TFS Server IP-----------");
Console.ReadLine();
}
}
public static Task<string> Get(this IWebClient client, WebHeaderCollection headers, Uri address)
{
if (client == null) throw new ArgumentNullException("client");
return client.Get(headers, address, (_, r) => r);
}
/// <summary>
/// Adds a service bus host using the MassTransit style URI host name
/// </summary>
/// <param name="configurator">The bus factory configurator</param>
/// <param name="hostAddress">The host address, in MassTransit format (sb://namespace.servicebus.windows.net/scope)</param>
/// <param name="configure">A callback to further configure the service bus</param>
/// <returns>The service bus host</returns>
public static IServiceBusHost Host(this IServiceBusBusFactoryConfigurator configurator, Uri hostAddress,
Action <IServiceBusHostConfigurator> configure)
{
var hostConfigurator = new ServiceBusHostConfigurator(hostAddress);
configure(hostConfigurator);
return(configurator.Host(hostConfigurator.Settings));
}
private void CreateAndShowMainWindow ()
{
// Create the application's main window
mainWindow = new Window ();
mainWindow.Title = "BMP Imaging Sample";
ScrollViewer mySV = new ScrollViewer();
int width = 128;
int height = width;
int stride = width / 8;
byte[] pixels = new byte[height * stride];
// Try creating a new image with a custom palette.
List<System.Windows.Media.Color> colors = new List<System.Windows.Media.Color>();
colors.Add(System.Windows.Media.Colors.Red);
colors.Add(System.Windows.Media.Colors.Blue);
colors.Add(System.Windows.Media.Colors.Green);
BitmapPalette myPalette = new BitmapPalette(colors);
// Creates a new empty image with the pre-defined palette
BitmapSource image = BitmapSource.Create(
width,
height,
96,
96,
PixelFormats.Indexed1,
myPalette,
pixels,
stride);
FileStream stream = new FileStream("new.bmp", FileMode.Create);
BmpBitmapEncoder encoder = new BmpBitmapEncoder();
TextBlock myTextBlock = new TextBlock();
myTextBlock.Text = "Codec Author is: " + encoder.CodecInfo.Author.ToString();
encoder.Frames.Add(BitmapFrame.Create(image));
encoder.Save(stream);
// Open a Stream and decode a BMP image
Stream imageStreamSource = new FileStream("tulipfarm.bmp", FileMode.Open, FileAccess.Read, FileShare.Read);
BmpBitmapDecoder decoder = new BmpBitmapDecoder(imageStreamSource, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
BitmapSource bitmapSource = decoder.Frames[0];
// Draw the Image
Image myImage = new Image();
myImage.Source = bitmapSource;
myImage.Stretch = Stretch.None;
myImage.Margin = new Thickness(20);
// Open a Uri and decode a BMP image
Uri myUri = new Uri("tulipfarm.bmp", UriKind.RelativeOrAbsolute);
BmpBitmapDecoder decoder2 = new BmpBitmapDecoder(myUri, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
BitmapSource bitmapSource2 = decoder2.Frames[0];
// Draw the Image
Image myImage2 = new Image();
myImage2.Source = bitmapSource2;
myImage2.Stretch = Stretch.None;
myImage2.Margin = new Thickness(20);
// Define a StackPanel to host the decoded BMP images
StackPanel myStackPanel = new StackPanel();
myStackPanel.Orientation = Orientation.Vertical;
myStackPanel.VerticalAlignment = VerticalAlignment.Stretch;
myStackPanel.HorizontalAlignment = HorizontalAlignment.Stretch;
// Add the Image and TextBlock to the parent Grid
myStackPanel.Children.Add(myImage);
myStackPanel.Children.Add(myImage2);
myStackPanel.Children.Add(myTextBlock);
// Add the StackPanel as the Content of the Parent Window Object
mySV.Content = myStackPanel;
mainWindow.Content = mySV;
mainWindow.Show();
}
/// <summary>
/// Get method with unencoded query parameter with value
/// 'value1&q2=value2&q3=value3'
/// </summary>
/// <param name='customHeaders'>
/// Headers that will be added to request.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public async Task<AzureOperationResponse> GetSwaggerQueryValidWithHttpMessagesAsync(Dictionary<string, List<string>> customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
string q1 = "value1&q2=value2&q3=value3";
// Tracing
bool _shouldTrace = ServiceClientTracing.IsEnabled;
string _invocationId = null;
if (_shouldTrace)
{
_invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
tracingParameters.Add("q1", q1);
tracingParameters.Add("cancellationToken", cancellationToken);
ServiceClientTracing.Enter(_invocationId, this, "GetSwaggerQueryValid", tracingParameters);
}
// Construct URL
var _baseUrl = this.Client.BaseUri.AbsoluteUri;
var _url = new Uri(new Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "azurespecials/skipUrlEncoding/swagger/query/valid").ToString();
List<string> _queryParameters = new List<string>();
if (q1 != null)
{
_queryParameters.Add(string.Format("q1={0}", q1));
}
if (_queryParameters.Count > 0)
{
_url += "?" + string.Join("&", _queryParameters);
}
// Create HTTP transport objects
HttpRequestMessage _httpRequest = new HttpRequestMessage();
HttpResponseMessage _httpResponse = null;
_httpRequest.Method = new HttpMethod("GET");
_httpRequest.RequestUri = new Uri(_url);
// Set Headers
if (this.Client.GenerateClientRequestId != null && this.Client.GenerateClientRequestId.Value)
{
_httpRequest.Headers.TryAddWithoutValidation("x-ms-client-request-id", Guid.NewGuid().ToString());
}
if (this.Client.AcceptLanguage != null)
{
if (_httpRequest.Headers.Contains("accept-language"))
{
_httpRequest.Headers.Remove("accept-language");
}
_httpRequest.Headers.TryAddWithoutValidation("accept-language", this.Client.AcceptLanguage);
}
if (customHeaders != null)
{
foreach(var _header in customHeaders)
{
if (_httpRequest.Headers.Contains(_header.Key))
{
_httpRequest.Headers.Remove(_header.Key);
}
_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
}
}
// Serialize Request
string _requestContent = null;
// Set Credentials
if (this.Client.Credentials != null)
{
cancellationToken.ThrowIfCancellationRequested();
await this.Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
}
// Send Request
if (_shouldTrace)
{
ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
_httpResponse = await this.Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
if (_shouldTrace)
{
ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
}
HttpStatusCode _statusCode = _httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string _responseContent = null;
if ((int)_statusCode != 200)
{
var ex = new ErrorException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
try
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
Error _errorBody = SafeJsonConvert.DeserializeObject<Error>(_responseContent, this.Client.DeserializationSettings);
if (_errorBody != null)
{
ex.Body = _errorBody;
}
}
catch (JsonException)
{
// Ignore the exception
}
ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
if (_shouldTrace)
{
ServiceClientTracing.Error(_invocationId, ex);
}
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw ex;
}
// Create Result
var _result = new AzureOperationResponse();
_result.Request = _httpRequest;
_result.Response = _httpResponse;
if (_httpResponse.Headers.Contains("x-ms-request-id"))
{
_result.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
}
if (_shouldTrace)
{
ServiceClientTracing.Exit(_invocationId, _result);
}
return _result;
}
/// <summary>
/// AudioRequest from a formatted string
/// </summary>
/// <param name="formattedString">[local|streaming]://reciterId?amount=AudioDownloadAmount&currentAyah=1:2&fromAyah=1:2&to=2:1&repeat=xxx;currentRepeat=2</param>
public AudioRequest(string formattedString)
{
if (string.IsNullOrEmpty(formattedString))
throw new ArgumentNullException("formattedString");
try
{
Uri patternAsUri = new Uri(formattedString);
if (patternAsUri.Scheme.Equals("local", StringComparison.OrdinalIgnoreCase))
IsStreaming = false;
else if (patternAsUri.Scheme.Equals("streaming", StringComparison.OrdinalIgnoreCase))
IsStreaming = true;
else
throw new ArgumentException("scheme");
this.Reciter = AudioUtils.GetReciterById(int.Parse(patternAsUri.Host));
var splitQueryString = patternAsUri.Query.Split(new char[] { '?', '&' });
int currentRepeatIteration = 0;
foreach (var part in splitQueryString)
{
var splitPart = part.Split('=');
if (splitPart[0].Equals("amount", StringComparison.OrdinalIgnoreCase))
{
this.AudioDownloadAmount =
(AudioDownloadAmount) Enum.Parse(typeof (AudioDownloadAmount), splitPart[1]);
}
else if (splitPart[0].Equals("currentAyah", StringComparison.OrdinalIgnoreCase))
{
this.CurrentAyah = QuranAyah.FromString(splitPart[1]);
}
else if (splitPart[0].Equals("fromAyah", StringComparison.OrdinalIgnoreCase))
{
this.FromAyah = QuranAyah.FromString(splitPart[1]);
}
else if (splitPart[0].Equals("toAyah", StringComparison.OrdinalIgnoreCase))
{
this.ToAyah = QuranAyah.FromString(splitPart[1]);
}
else if (splitPart[0].Equals("repeat", StringComparison.OrdinalIgnoreCase))
{
this.RepeatInfo = RepeatInfo.FromString(splitPart[1]);
}
else if (splitPart[0].Equals("currentRepeat", StringComparison.OrdinalIgnoreCase))
{
int.TryParse(splitPart[1], out currentRepeatIteration);
}
}
if (this.CurrentAyah == null)
this.CurrentAyah = this.FromAyah;
this.repeatManager = new RepeatManager(this.RepeatInfo, this.FromAyah, currentRepeatIteration);
}
catch
{
throw new ArgumentException("formattedString");
}
}
/// <summary>
/// Writes a <see cref="Uri"/> value.
/// </summary>
/// <param name="value">The <see cref="Uri"/> value to write.</param>
public override void WriteValue(Uri value)
{
base.WriteValue(value);
AddValue(value, JsonToken.String);
}
internal AsyncRequestString SetUrl(Uri url)
{
this.url = url;
return(this);
}
internal IEnumerator Start()
{
WWW www;
if (this.method == HttpMethod.GET)
{
string urlParams = this.url.AbsoluteUri.Contains("?") ? "&" : "?";
if (this.formData != null)
{
foreach (KeyValuePair <string, string> pair in this.formData)
{
urlParams += string.Format("{0}={1}&", Uri.EscapeDataString(pair.Key), Uri.EscapeDataString(pair.Value));
}
}
Dictionary <string, string> headers = new Dictionary <string, string>();
headers["User-Agent"] = Constants.GraphApiUserAgent;
www = new WWW(this.url + urlParams, null, headers);
}
else
{
// POST or DELETE
if (this.query == null)
{
this.query = new WWWForm();
}
if (this.method == HttpMethod.DELETE)
{
this.query.AddField("method", "delete");
}
if (this.formData != null)
{
foreach (KeyValuePair <string, string> pair in this.formData)
{
this.query.AddField(pair.Key, pair.Value);
}
}
this.query.headers["User-Agent"] = Constants.GraphApiUserAgent;
www = new WWW(this.url.AbsoluteUri, this.query);
}
yield return(www);
if (this.callback != null)
{
this.callback(new GraphResult(www));
}
// after the callback is called, www should be able to be disposed
www.Dispose();
MonoBehaviour.Destroy(this);
}
public static Task<string> Post(this IWebClient client, WebHeaderCollection headers, Uri address, string data)
{
if (client == null) throw new ArgumentNullException("client");
return client.Post(headers, address, data, (responseHeaders, r) => responseHeaders["Location"]);
}
internal Transfer(IRestfulClient restfulClient, TransferResource resource, Uri baseUri, Uri resourceUri, AudioVideoCall parent)
: base(restfulClient, resource, baseUri, resourceUri, parent)
{
if (parent == null)
{
throw new ArgumentNullException(nameof(parent), "AudioVideo is required");
}
m_transferCompleteTcs = new TaskCompletionSource <string>();
}
