/// <summary>
/// When sending Http Data requests to the Azure Marketplace, inject authorization header based on the current Access token.
/// </summary>
/// <param name="sender">Event sender.</param>
/// <param name="e">Event arguments.</param>
private void OnSendingRequest(object sender, SendingRequest2EventArgs e)
{
if (e.RequestMessage.GetHeader(AuthorizationHeader) == null)
{
e.RequestMessage.SetHeader(AuthorizationHeader, _tokenProvider.GetAuthorizationHeader());
}
}
private static void VerifyJsonLightRequestHeaders(object sender, SendingRequest2EventArgs args)
{
var requestMessage = args.RequestMessage;
string accept = requestMessage.GetHeader("Accept");
bool isBatch = requestMessage.Url.OriginalString.Contains("$batch");
if (isBatch)
{
Assert.AreEqual("multipart/mixed", accept);
}
else
{
if (args.RequestMessage.Url.OriginalString.Contains("$select"))
{
Assert.AreEqual("application/json;odata.metadata=full", accept);
}
else
{
Assert.AreEqual("application/json;odata.metadata=minimal", accept);
}
}
if (requestMessage.Method != "GET" && requestMessage.Method != "DELETE" && !isBatch)
{
string contentType = requestMessage.GetHeader("Content-Type");
Assert.AreEqual("application/json;odata.metadata=minimal", contentType);
}
}
/// <summary>
/// Raises the AlterRequestAndExpectedHeaders event if there are any consumers
/// </summary>
/// <param name="args">The sending request args</param>
/// <param name="expectedHeaders">The expected headers</param>
internal void RaiseEvent(SendingRequest2EventArgs args, IDictionary <string, string> expectedHeaders)
{
if (this.AlterRequestAndExpectedHeaders != null)
{
this.AlterRequestAndExpectedHeaders(args, expectedHeaders);
}
}
public ShimDataRequestMessage(SendingRequest2EventArgs args)
{
_args = args;
WebRequest = ShimWebHelpers.AddHeaders(HttpWebRequest.CreateHttp(_args.RequestMessage.Url), _args.RequestMessage.Headers);
WebRequest.Method = _args.RequestMessage.Method;
}
/// <summary>
/// When sending Http Data requests to the Azure Marketplace, inject authorization header based on the current Access token.
/// </summary>
/// <param name="sender">Event sender.</param>
/// <param name="e">Event arguments.</param>
private void OnSendingRequest(object sender, SendingRequest2EventArgs e)
{
if (e.RequestMessage.GetHeader(AuthorizationHeader) == null)
{
RefreshToken();
e.RequestMessage.SetHeader(AuthorizationHeader, string.Format(CultureInfo.InvariantCulture, BearerTokenFormat, this._credentials.AccessToken));
}
}
private void ChangeAcceptHeader(object sender, SendingRequest2EventArgs e)
{
if (e.RequestMessage.GetHeader("content-type") != null)
{
e.RequestMessage.SetHeader("content-type", _acceptHeader);
}
e.RequestMessage.SetHeader("accept", _acceptHeader);
}
void OnSendingRequest2(object sender, SendingRequest2EventArgs e)
{
string creds = Login + ":" + Password;
byte[] bCreds = Encoding.ASCII.GetBytes(creds);
string base64Creds = Convert.ToBase64String(bCreds);
e.RequestMessage.SetHeader("Authorization", "Basic " + base64Creds);
}
private void OnSendingRequest(object sender, SendingRequest2EventArgs e)
{
var shimRequest = new ShimDataRequestMessage(e);
// Initialize the request
_httpClient.InitializeRequest(shimRequest.WebRequest);
RaiseSendingRequest(new WebRequestEventArgs(shimRequest.WebRequest));
}
private void Container_SendingRequest2(object sender, SendingRequest2EventArgs e)
{
string svcCredentials = string.Format("{0}:{1}", DEFAULT_USERNAME, DEFAULT_PASSWORD);
byte[] credBytes = System.Text.ASCIIEncoding.ASCII.GetBytes(svcCredentials);
string headerValue = string.Format("Basic {0}", Convert.ToBase64String(credBytes));
e.RequestMessage.SetHeader(HEADER_AUTHORIZATION, headerValue);
}
// use SendingRequest2/SendingRequest2EventArgs since the client does not allow SendingRequest and BuildingRequest registered at the same time
private void InjectAuthenticationCookies(object sender, SendingRequest2EventArgs e)
{
if (this.authenticationHeaders != null)
{
foreach (var header in this.authenticationHeaders)
{
e.RequestMessage.SetHeader(header.Key, header.Value);
}
}
}
public void DataServiceContext_SendingRequest2(object sender, SendingRequest2EventArgs e)
{
var authorisationHeaderValue = GetAuthorisationHeaderValue();
if (default(string) != authorisationHeaderValue)
{
e.RequestMessage.SetHeader(AUTHORIZATION_HEADER_NAME, authorisationHeaderValue);
}
if (SetTenantHeader())
{
e.RequestMessage.SetHeader(TenantHeaderName, TenantID);
}
}
public void DataServiceContext_SendingRequest2(object sender, SendingRequest2EventArgs e)
{
var authorisationHeaderValue = BuildAuthorizationHeaderValue();
if (default(string) != authorisationHeaderValue)
{
e.RequestMessage.SetHeader(Authentication.Header.AUTHORIZATION, authorisationHeaderValue);
}
if (IsTenantSpecified())
{
e.RequestMessage.SetHeader(TenantHeaderName, TenantId);
}
}
private void ContextSendingRequest2(object sender, SendingRequest2EventArgs e)
{
e.RequestMessage.SetHeader("Authorization", $"Bearer {_authService.Token.access_token}");
e.RequestMessage.SetHeader("Account", $"{_authService.GetAccount()}");
if (e.RequestMessage is HttpWebRequestMessage message)
{
Logger.Debug($"Sending request: {message.Method} {message.Url}");
Logger.Debug($"Sending request: {JsonConvert.SerializeObject(message, Formatting.Indented)}");
}
else
{
Logger.Debug($"Sending request: {e.RequestMessage.Method} {e.RequestMessage.Url}");
Logger.Debug($"Sending request: {JsonConvert.SerializeObject(e.RequestMessage, Formatting.Indented)}");
}
}
//*********************************************************************
///
/// <summary>
/// Adds a client certificate to a web request
/// </summary>
/// <param name="sender">Sender of the web request</param>
/// <param name="args">Arguments of the request being sent</param>
///
//*********************************************************************
private void OnSendingRequest_AddCertificate(object sender, SendingRequest2EventArgs args)
{
if (null == ClientCertificate)
{
return;
}
var ReqM = args.RequestMessage as System.Data.Services.Client.HttpWebRequestMessage;
if (null == ReqM)
{
return;
}
//ReqM.Credentials = new System.Net.NetworkCredential("Administrator2", "SecurePassword2");
//ReqM.HttpWebRequest.Credentials = new System.Net.NetworkCredential("Administrator3", "SecurePassword3");
ReqM.HttpWebRequest.ClientCertificates.Add(ClientCertificate);
}
private void AuthenticateRequest(object sender, SendingRequest2EventArgs e)
{
e.RequestMessage.SetHeader(
OAuthHelper.OAuthHeader,
this.OAuthHelper.GetAuthenticationHeader());
}
private void Container_SendingRequest2(object sender, SendingRequest2EventArgs e)
{
Console.WriteLine("\t{0} {1}", e.RequestMessage.Method, e.RequestMessage.Url.ToString());
}
/// <summary>
/// Adds the request version.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="System.Data.Services.Client.SendingRequestEventArgs"/> instance containing the event data.</param>
private void AddClientRequestId(object sender, SendingRequest2EventArgs e)
{
e.RequestMessage.SetHeader(XMsClientRequestId, _requestId.ToString());
}
private void OdataClientOnSendingRequest2(object sender, SendingRequest2EventArgs sendingRequest2EventArgs)
{
((HttpWebRequestMessage)sendingRequest2EventArgs.RequestMessage).HttpWebRequest.ClientCertificates.Add(this.certificate);
}
private static void Container_SendingRequest2(object sender, SendingRequest2EventArgs e)
{
Console.WriteLine("{0} {1}", e.RequestMessage.Method, e.RequestMessage.Url);
}
public static void OnSendingRequest(object sender, SendingRequest2EventArgs e)
{
// Add the cookie to the cookie header to all requests
e.RequestMessage.SetHeader(HttpRequestHeader.Cookie.ToString(), cookies);
}
/// <summary>
/// Adds the request version.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="System.Data.Services.Client.SendingRequestEventArgs"/> instance containing the event data.</param>
private void AddRequestVersion(object sender, SendingRequest2EventArgs e)
{
e.RequestMessage.SetHeader(_xMsVersion, this._serviceVersion.ToString());
}
/// <summary>
/// Loads the metadata and converts it into an EdmModel that is then used by a dataservice context
/// This allows the user to use the DataServiceContext directly without having to manually pass an IEdmModel in the Format
/// </summary>
/// <returns>A service model to be used in format tracking</returns>
internal IEdmModel LoadServiceModelFromNetwork()
{
DataServiceClientRequestMessage httpRequest;
BuildingRequestEventArgs requestEventArgs = null;
// test hook for injecting a network request to use instead of the default
if (InjectMetadataHttpNetworkRequest != null)
{
httpRequest = InjectMetadataHttpNetworkRequest();
}
else
{
requestEventArgs = new BuildingRequestEventArgs(
"GET",
context.GetMetadataUri(),
null,
null,
context.HttpStack);
// fire the right events if they exist to allow user to modify the request
if (context.HasBuildingRequestEventHandlers)
{
requestEventArgs = context.CreateRequestArgsAndFireBuildingRequest(
requestEventArgs.Method,
requestEventArgs.RequestUri,
requestEventArgs.HeaderCollection,
requestEventArgs.ClientHttpStack,
requestEventArgs.Descriptor);
}
DataServiceClientRequestMessageArgs args = new DataServiceClientRequestMessageArgs(
requestEventArgs.Method,
requestEventArgs.RequestUri,
context.UseDefaultCredentials,
context.UsePostTunneling,
requestEventArgs.Headers);
httpRequest = new HttpClientRequestMessage(args);
}
Descriptor descriptor = requestEventArgs != null ? requestEventArgs.Descriptor : null;
// fire the right events if they exist
if (context.HasSendingRequest2EventHandlers)
{
SendingRequest2EventArgs eventArgs = new SendingRequest2EventArgs(
httpRequest,
descriptor,
false);
context.FireSendingRequest2(eventArgs);
}
Task <IODataResponseMessage> asyncResponse =
Task <IODataResponseMessage> .Factory.FromAsync(httpRequest.BeginGetResponse, httpRequest.EndGetResponse,
httpRequest);
IODataResponseMessage response = asyncResponse.GetAwaiter().GetResult();
ReceivingResponseEventArgs responseEvent = new ReceivingResponseEventArgs(response, descriptor);
context.FireReceivingResponseEvent(responseEvent);
using (StreamReader streamReader = new StreamReader(response.GetStream()))
using (XmlReader xmlReader = XmlReader.Create(streamReader))
{
return(CsdlReader.Parse(xmlReader));
}
}
public static void InsertHeaders(object sender, SendingRequest2EventArgs e, string email)
{
e.RequestMessage.SetHeader("X-AnchorMailbox", email);
e.RequestMessage.SetHeader("Prefer", "outlook.timezone=\"" + System.TimeZoneInfo.Local.Id + "\"");
}
private void InsertXAnchorMailboxHeader(object sender, SendingRequest2EventArgs e, string email)
{
e.RequestMessage.SetHeader("X-AnchorMailbox", email);
}
private void SendHeaderAuth(object sender, SendingRequest2EventArgs e)
{
e.RequestMessage.SetHeader("Authorization", "Bearer " + _token);
}
internal void VerifySendingRequest(object sender, SendingRequest2EventArgs args)
{
this.assert.AreSame(this.expectedContext, sender, "Sending request fired by unexpected context");
this.assert.IsNotNull(args, "args");
this.httpTracker.TryCompleteCurrentRequest(this.expectedContext);
this.assert.IsNotNull(args.RequestMessage, "args.RequestMessage");
if (args.RequestMessage.Method == "GET")
{
// Special case: GetReadStream gives a StreamDescriptor
if (!(args.Descriptor is StreamDescriptor))
{
this.assert.IsNull(args.Descriptor, "Descriptor should be null for get requests, except GetReadStream");
}
}
else
{
// Special case : The batch request itself has the method POST yet there's no descriptor for it.
if (args.RequestMessage.Url.OriginalString.Contains("/" + Endpoints.Batch))
{
this.assert.IsNull(args.Descriptor, "Descriptor should be null for batch requests");
}
else if (this.IsInvokeOperationRequest(args.RequestMessage.Url.OriginalString))
{
this.assert.IsNull(args.Descriptor, "Descriptor should be null for action or WebInvoke requests");
}
else
{
this.assert.IsNotNull(args.Descriptor, "Descriptor should not be null for CUD requests");
}
}
if (args.IsBatchPart)
{
var requestMessage = args.RequestMessage;
this.assert.IsNotNull(requestMessage, "RequestMessage should be of type IODataRequestMessage");
}
else
{
if (args.RequestMessage.GetType().Name != "InternalODataRequestMessage")
{
var requestMessage = args.RequestMessage as HttpWebRequestMessage;
this.assert.IsNotNull(requestMessage, "RequestMessage should be of type HttpWebRequestMessage");
var httpWebRequest = requestMessage.HttpWebRequest as HttpWebRequest;
this.assert.IsNotNull(httpWebRequest, "RequestMessage.HttpWebRequest should be of type HttpWebRequest");
#if WIN8
if (this.expectedContext.Credentials != null)
{
this.assert.AreSame(this.expectedContext.Credentials, httpWebRequest.Credentials, "Request credentials were not set");
}
#else
this.assert.AreSame(this.expectedContext.Credentials, httpWebRequest.Credentials, "Request credentials were not set");
#endif
this.assert.IsNull(this.uriFromEvent, "Last uri unexpectedly not null. Test hook did not fire");
this.assert.AreEqual(requestMessage.Url, httpWebRequest.RequestUri, "Request Uri does not match RequestUri from HttpWebRequest");
this.uriFromEvent = httpWebRequest.RequestUri;
this.assert.IsNull(this.methodFromEvent, "Last method unexpectedly not null. Test hook did not fire");
this.methodFromEvent = httpWebRequest.Method;
this.assert.IsNull(this.originalHeadersFromEvent, "Last headers unexpectedly not null. Test hook did not fire");
this.assert.AreEqual(requestMessage.Headers.Count(), httpWebRequest.Headers.Count, "Request Headers count does not match Headers count from HttpWebRequest");
this.originalHeadersFromEvent = requestMessage.Headers.ToDictionary(k => k.Key, v => v.Value);
this.expectedHeaders = new Dictionary <string, string>(this.originalHeadersFromEvent);
if (this.originalHeadersFromEvent.ContainsKey("X-HTTP-Method"))
{
this.methodFromEvent = this.originalHeadersFromEvent["X-HTTP-Method"];
}
if (this.callback != null)
{
this.callback(args, this.expectedHeaders);
}
this.finalHeadersFromEvent = requestMessage.Headers.ToDictionary(k => k.Key, v => v.Value);
}
else
{
this.uriFromEvent = args.RequestMessage.Url;
this.methodFromEvent = args.RequestMessage.Method;
this.originalHeadersFromEvent = args.RequestMessage.Headers.ToDictionary(k => k.Key, v => v.Value);
if (this.originalHeadersFromEvent.ContainsKey("X-HTTP-Method"))
{
this.methodFromEvent = this.originalHeadersFromEvent["X-HTTP-Method"];
}
this.expectedHeaders = new Dictionary <string, string>(this.originalHeadersFromEvent);
if (this.callback != null)
{
this.callback(args, this.expectedHeaders);
}
this.finalHeadersFromEvent = args.RequestMessage.Headers.ToDictionary(k => k.Key, v => v.Value);
}
}
}
public void SetAuthorizationToken(object sender, SendingRequest2EventArgs e)
{
e.RequestMessage.SetHeader("Authorization", SecurityHelper.AccessToken);
}
private static void SetInvalidDataServiceVersion(object obj, SendingRequest2EventArgs args)
{
args.RequestMessage.SetHeader("DataServiceVersion", "99.99;NetFx");
}
private void Client_SendingRequest2(object sender, SendingRequest2EventArgs e)
{
e.RequestMessage.SetHeader("Authorization", $"Bearer {authToken}");
}
private static void SetInvalidETag(object obj, SendingRequest2EventArgs args)
{
args.RequestMessage.SetHeader("If-Match", "W/\"var1\"");
}
