public void TryParse_Invalid()
{
MediaTypeWithQualityHeaderValue res;
Assert.IsFalse(MediaTypeWithQualityHeaderValue.TryParse("", out res), "#1");
Assert.IsNull(res, "#2");
}
private void CheckValidTryParse(string input, MediaTypeWithQualityHeaderValue expectedResult)
{
MediaTypeWithQualityHeaderValue result = null;
Assert.True(MediaTypeWithQualityHeaderValue.TryParse(input, out result));
Assert.Equal(expectedResult, result);
}
private EurekaRestApiHelper()
{
_httpClient = new HttpClient();
MediaTypeWithQualityHeaderValue.TryParse("application/json", out var ajson);
_httpClient.DefaultRequestHeaders.Accept.Add(ajson);
_httpClient.DefaultRequestHeaders.AcceptEncoding.TryParseAdd("gzip,deflate");
}
public static IEnumerable <MediaTypeWithQualityHeaderValue> GetAcceptTypes(this IHttpRequest req)
=> req.GetHeaders("accept")
.SelectMany(acceptString => acceptString.Split(','))
.TryWhere(
(string acceptString, out MediaTypeWithQualityHeaderValue acceptHeader) =>
MediaTypeWithQualityHeaderValue.TryParse(acceptString, out acceptHeader))
.Select(tpl => tpl.@out);
private void CheckInvalidTryParse(string input)
{
MediaTypeWithQualityHeaderValue result = null;
Assert.False(MediaTypeWithQualityHeaderValue.TryParse(input, out result));
Assert.Null(result);
}
public void TryParse()
{
MediaTypeWithQualityHeaderValue res;
Assert.IsTrue(MediaTypeWithQualityHeaderValue.TryParse("audio/*", out res), "#1");
Assert.AreEqual(0, res.Parameters.Count, "#1");
}
//TODO: there is more into this now in part 18 2016 version, reference section 6.1.1.5 and 6.1.1.6
//exact method to tp determine "SelectedMediaType" is detailed in 6.1.1.7
protected virtual List <MediaTypeHeaderValue> GetRequestedMimeType(IWadoUriRequest request)
{
List <MediaTypeHeaderValue> acceptTypes = new List <MediaTypeHeaderValue>();
bool acceptAll = request.AcceptHeader.Contains(AllMimeType, new MediaTypeHeaderComparer( ));
if (!string.IsNullOrEmpty(request.ContentType))
{
string[] mimeTypes = request.ContentType.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string mime in mimeTypes)
{
MediaTypeWithQualityHeaderValue mediaType;
if (MediaTypeWithQualityHeaderValue.TryParse(mime, out mediaType))
{
if (acceptAll || request.AcceptHeader.Contains(mediaType, new MediaTypeHeaderComparer()))
{
acceptTypes.Add(mediaType);
}
}
else
{
//TODO: throw excpetion?
}
}
}
return(acceptTypes);
}
private async Task SetLicenseIdAsync(int id)
{
string lid = LMSTools.GenerateLicenseId(id);
HttpClient Http = new HttpClient();
Http.DefaultRequestHeaders.Add("Accept", "application/json");
Http.DefaultRequestHeaders.Add("X-RequestDigest", await LMSTools.GetDigestAsync(Navigator.BaseUri));
Http.DefaultRequestHeaders.Add("IF-MATCH", "*");
Http.DefaultRequestHeaders.Add("X-HTTP-Method", "MERGE");
Item data = new Item();
Metadata metadata = new Metadata();
metadata.Type = Settings.LicensesListType;
data.Metadata = metadata;
data.Title = lid;
var myContent = JsonConvert.SerializeObject(data);
var buffer = System.Text.Encoding.UTF8.GetBytes(myContent);
var byteContent = new ByteArrayContent(buffer);
var mediaType = new MediaTypeWithQualityHeaderValue("application/json");
MediaTypeWithQualityHeaderValue.TryParse("application/json;odata=verbose", out mediaType);
byteContent.Headers.ContentType = mediaType;
var response = await Http.PostAsync(Navigator.BaseUri + Settings.BaseURL + "_api/web/lists(guid'" + Settings.LicensesListGuid + "')/items('" + id + "')", byteContent);
if (response.StatusCode == HttpStatusCode.NoContent)
{
Console.WriteLine("Done!, Your License ID is: " + lid);
}
else
{
result = "Filed to Update Title, Your Input Json: ";
Console.WriteLine(result + " : " + JsonConvert.SerializeObject(data));
}
}
public static string[] GetAcceptHeaders(this HttpRequest contextRequest)
=> Array.ConvertAll(
contextRequest.Headers
.GetCommaSeparatedValues("Accept"),
value => MediaTypeWithQualityHeaderValue.TryParse(value, out var header)
? header.MediaType
: null);
private void CheckInvalidParse(string input)
{
Assert.Throws <FormatException>(() => { MediaTypeWithQualityHeaderValue.Parse(input); });
MediaTypeWithQualityHeaderValue result = null;
Assert.False(MediaTypeWithQualityHeaderValue.TryParse(input, out result));
Assert.Null(result);
}
private static HttpContent GetContent(Input input, IDictionary <string, string> headers)
{
//Check if Content-Type exists and is set and valid
var contentTypeIsSetAndValid = false;
MediaTypeWithQualityHeaderValue validContentType = null;
if (headers.TryGetValue("content-type", out string contentTypeValue))
{
contentTypeIsSetAndValid = MediaTypeWithQualityHeaderValue.TryParse(contentTypeValue, out validContentType);
}
return(contentTypeIsSetAndValid
? new StringContent(input.Message ?? "", Encoding.GetEncoding(validContentType.CharSet ?? Encoding.UTF8.WebName))
: new StringContent(input.Message ?? ""));
}
private static async Task <bool> ValidateAcceptHeaderAsync(MediaTypeHeaderValue allowedMediaTypeValue, HttpContext httpContext,
JsonSerializerSettings serializerSettings)
{
StringValues acceptHeaders = httpContext.Request.Headers["Accept"];
if (!acceptHeaders.Any())
{
return(true);
}
bool seenCompatibleMediaType = false;
foreach (string acceptHeader in acceptHeaders)
{
if (MediaTypeWithQualityHeaderValue.TryParse(acceptHeader, out MediaTypeWithQualityHeaderValue headerValue))
{
headerValue.Quality = null;
if (headerValue.MediaType == "*/*" || headerValue.MediaType == "application/*")
{
seenCompatibleMediaType = true;
break;
}
if (allowedMediaTypeValue.Equals(headerValue))
{
seenCompatibleMediaType = true;
break;
}
}
}
if (!seenCompatibleMediaType)
{
await FlushResponseAsync(httpContext.Response, serializerSettings, new Error(HttpStatusCode.NotAcceptable)
{
Title = "The specified Accept header value does not contain any supported media types.",
Detail = $"Please include '{allowedMediaTypeValue}' in the Accept header values."
});
return(false);
}
return(true);
}
private async Task SubmitAsync()
{
HttpClient Http = new HttpClient();
Http.DefaultRequestHeaders.Add("Accept", "application/json");
Http.DefaultRequestHeaders.Add("X-RequestDigest", await VCSTools.GetDigestAsync(Navigator.BaseUri));
Item data = new Item();
Metadata metadata = new Metadata();
metadata.Type = Config.MainListType;
data.Metadata = metadata;
data.OfficeId = office.GetItemId();
data.MeterViolationTypeId = form1Vald.MeterViolationType;
data.ViolationDate = form1Vald.ViolationDate;
data.Region = form1Vald.Region;
data.City = form1Vald.City;
data.Colony = form1Vald.Colony;
data.Street = form1Vald.Street;
data.House = form1Vald.House;
data.AccountNumber = form1Vald.AccountNumber;
data.ViolationDetails = form1Vald.ViolationDetails;
data.DamageDetails = form1Vald.DamageDetails;
data.DiscovererNameId = peoplePicker.GetValue();
data.ViolatorName = form1Vald.ViolatorName;
data.ViolatorType = form1Vald.ViolatorType;
data.ViolatorNationalID = form1Vald.ViolatorNationalID;
data.ViolatorNationalIDType = form1Vald.ViolatorNationalIDType;
data.ViolatorMobile = form1Vald.ViolatorMobile;
data.ViolatorStatement = form1Vald.ViolatorStatement;
data.Stage = 0;
var myContent = JsonConvert.SerializeObject(data);
var buffer = System.Text.Encoding.UTF8.GetBytes(myContent);
var byteContent = new ByteArrayContent(buffer);
var mediaType = new MediaTypeWithQualityHeaderValue("application/json");
MediaTypeWithQualityHeaderValue.TryParse("application/json;odata=verbose", out mediaType);
byteContent.Headers.ContentType = mediaType;
var response = await Http.PostAsync(Navigator.BaseUri + Config.BaseURL + "_api/web/lists(guid'" + Config.MainListGuid + "')/items", byteContent);
if (response.StatusCode == HttpStatusCode.Created)
{
root = JsonConvert.DeserializeObject <Root>(await response.Content.ReadAsStringAsync());
await SetViolationIdAsync(root.Id);
}
}
private static IEnumerable <MediaTypeWithQualityHeaderValue> GetMediaTypes(string headerValues)
{
if (string.IsNullOrEmpty(headerValues))
{
return(new List <MediaTypeWithQualityHeaderValue>());
}
return(headerValues.Split(',')
.Select(headerValue =>
{
var x = MediaTypeWithQualityHeaderValue.TryParse(headerValue, out var mediaTypeHeaderValue)
? mediaTypeHeaderValue
: new MediaTypeWithQualityHeaderValue("application/octed-stream");
return x;
})
.Where(h => h?.Quality.GetValueOrDefault(1) > 0)
.OrderByDescending(mt => mt.Quality.GetValueOrDefault(1)));
}
private async Task SubmitAsync()
{
HttpClient Http = new HttpClient();
Http.DefaultRequestHeaders.Add("Accept", "application/json");
Http.DefaultRequestHeaders.Add("X-RequestDigest", await LMSTools.GetDigestAsync(Navigator.BaseUri));
Item data = new Item();
Metadata metadata = new Metadata();
metadata.Type = Settings.LicensesListType;
data.Metadata = metadata;
data.SystemName = license.SystemName;
data.LicenseName = license.LicenseName;
data.LicenseKey = license.LicenseKey;
data.Description = license.Description;
data.OwnerId = peoplePicker.GetValue();
data.ContractNumber = license.ContractNumber;
data.StartDate = license.StartDate;
data.EndDate = license.EndDate;
data.IssuedDate = license.IssuedDate;
data.PlannedRenewal = license.PlannedRenewal;
data.Quantity = license.Quantity;
data.Utilized = license.Utilized;
data.Cost = license.Cost;
data.TotalCost = license.Quantity * license.Cost;
data.TypeOfCost = license.TypeOfCost;
var myContent = JsonConvert.SerializeObject(data);
var buffer = System.Text.Encoding.UTF8.GetBytes(myContent);
var byteContent = new ByteArrayContent(buffer);
var mediaType = new MediaTypeWithQualityHeaderValue("application/json");
MediaTypeWithQualityHeaderValue.TryParse("application/json;odata=verbose", out mediaType);
byteContent.Headers.ContentType = mediaType;
var response = await Http.PostAsync(Navigator.BaseUri + Settings.BaseURL + "_api/web/lists(guid'" + Settings.LicensesListGuid + "')/items", byteContent);
if (response.StatusCode == HttpStatusCode.Created)
{
root = JsonConvert.DeserializeObject <Root>(await response.Content.ReadAsStringAsync());
await SetLicenseIdAsync(root.Id);
await UploadAsync(root.Id);
}
}
private void CheckValidParse(string input, MediaTypeWithQualityHeaderValue expectedResult)
{
MediaTypeWithQualityHeaderValue result = MediaTypeWithQualityHeaderValue.Parse(input);
Assert.Equal(expectedResult, result);
result = null;
Assert.True(MediaTypeWithQualityHeaderValue.TryParse(input, out result));
Assert.Equal(expectedResult, result);
// New lines are never allowed
for (int i = 0; i < input.Length; i++)
{
CheckInvalidParse(input.Insert(i, "\r"));
CheckInvalidParse(input.Insert(i, "\n"));
CheckInvalidParse(input.Insert(i, "\r\n"));
CheckInvalidParse(input.Insert(i, "\r\n "));
}
}
private void SetHTTPClientHeaders()
{
if (_mySession.CSession["SpotifyAccess"] != null)
{
_callback = (CallbackModel)_mySession.CSession["SpotifyAccess"];
}
lock (_httpClient)
{
_httpClient.DefaultRequestHeaders.Clear();
if (MediaTypeWithQualityHeaderValue.TryParse(_sContentType, out MediaTypeWithQualityHeaderValue mtqhv))
{
_httpClient.DefaultRequestHeaders.Accept.Add(mtqhv);
}
if (_callback != null)
{
_httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _callback.accessToken);
}
}
}
private Task SetContentType(Domain.Model.Request.BaseRequest request, CustomContext c, CancellationToken ct)
{
if (string.IsNullOrWhiteSpace(request.ContentType))
{
if (request.ServiceType == Domain.Enums.ServiceType.RESTful)
{
request.ContentType = "application/json";
}
else if (request.ServiceType == Domain.Enums.ServiceType.SOAP)
{
request.ContentType = "text/xml";
}
}
else
{
if (!MediaTypeWithQualityHeaderValue.TryParse(request.ContentType, out _))
{
c.AddFailure($"{c.PropertyName}.ContentType media type ({request.ContentType}) is invalid.");
}
}
return(Task.CompletedTask);
}
internal bool AllowsAccept(string[]?requestAcceptTypes)
{
if (_acceptMediaTypes is null)
{
return(true);
}
if (requestAcceptTypes is null)
{
throw new ArgumentNullException(nameof(requestAcceptTypes));
}
foreach (var requestAcceptType in requestAcceptTypes)
{
var validAccept = MediaTypeWithQualityHeaderValue.TryParse(requestAcceptType, out var accept);
if (_acceptMediaTypes.Any(mediaType => accept?.MediaType == mediaType))
{
return(true);
}
}
return(false);
}
private async Task SetViolationIdAsync(int id)
{
string vid = VCSTools.GetVid(id);
HttpClient Http = new HttpClient();
Http.DefaultRequestHeaders.Add("Accept", "application/json");
Http.DefaultRequestHeaders.Add("X-RequestDigest", await VCSTools.GetDigestAsync(Navigator.BaseUri));
Http.DefaultRequestHeaders.Add("IF-MATCH", "*");
Http.DefaultRequestHeaders.Add("X-HTTP-Method", "MERGE");
Item data = new Item();
Metadata metadata = new Metadata();
metadata.Type = Config.MainListType;
data.Metadata = metadata;
data.Title = vid;
var myContent = JsonConvert.SerializeObject(data);
var buffer = System.Text.Encoding.UTF8.GetBytes(myContent);
var byteContent = new ByteArrayContent(buffer);
var mediaType = new MediaTypeWithQualityHeaderValue("application/json");
MediaTypeWithQualityHeaderValue.TryParse("application/json;odata=verbose", out mediaType);
byteContent.Headers.ContentType = mediaType;
var response = await Http.PostAsync(Navigator.BaseUri + Config.BaseURL + "_api/web/lists(guid'" + Config.MainListGuid + "')/items('" + id + "')", byteContent);
if (response.StatusCode == HttpStatusCode.NoContent)
{
result = "سجل بنجاح باستخدام رقم التعريف: #" + vid;
bool x = await jsRun.InvokeAsync <bool>("alertx");
Navigator.NavigateTo("default.aspx/forms/workflow/" + id);
}
else
{
result = "فشل السجل في الحفظ";
Console.WriteLine(result + " : " + JsonConvert.SerializeObject(data));
}
}
private static async Task <HttpResponseMessage> GetHttpRequestResponseAsync(HttpClient httpClient, Input input, Options options, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (options.Authentication == Authentication.Basic || options.Authentication == Authentication.OAuth)
{
switch (options.Authentication)
{
case Authentication.Basic:
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic",
Convert.ToBase64String(Encoding.ASCII.GetBytes($"{options.Username}:{options.Password}")));
break;
case Authentication.OAuth:
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer",
options.Token);
break;
}
}
//Do not automtically set expect 100-continue response header
httpClient.DefaultRequestHeaders.ExpectContinue = false;
httpClient.Timeout = TimeSpan.FromSeconds(Convert.ToDouble(options.ConnectionTimeoutSeconds));
//Ignore case for headers and key comparison
var headerDict = input.Headers.ToDictionary(key => key.Name, value => value.Value, StringComparer.InvariantCultureIgnoreCase);
//Check if Content-Type exists and is set and valid
var contentTypeIsSetAndValid = false;
MediaTypeWithQualityHeaderValue validContentType = null;
if (headerDict.TryGetValue("content-type", out string contentTypeValue))
{
contentTypeIsSetAndValid = MediaTypeWithQualityHeaderValue.TryParse(contentTypeValue, out validContentType);
}
using (HttpContent content = contentTypeIsSetAndValid ?
new StringContent(input.Message ?? "", Encoding.GetEncoding(validContentType.CharSet ?? Encoding.UTF8.WebName)) :
new StringContent(input.Message ?? ""))
{
//Clear default headers
content.Headers.Clear();
foreach (var header in headerDict)
{
var requestHeaderAddedSuccessfully = httpClient.DefaultRequestHeaders.TryAddWithoutValidation(header.Key, header.Value);
if (!requestHeaderAddedSuccessfully)
{
//Could not add to request headers try to add to content headers
var contentHeaderAddedSuccessfully = content.Headers.TryAddWithoutValidation(header.Key, header.Value);
if (!contentHeaderAddedSuccessfully)
{
Trace.TraceWarning($"Could not add header {header.Key}:{header.Value}");
}
}
}
var request = new HttpRequestMessage(new HttpMethod(input.Method.ToString()), new Uri(input.Url))
{
Content = input.Method != Method.Get ? content : null
};
var response = await httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false);
if (options.AllowInvalidResponseContentTypeCharSet)
{
response.Content.Headers.ContentType.CharSet = null;
}
return(response);
}
}
private static MediaTypeWithQualityHeaderValue ParseAcceptHeader(string accept)
=> MediaTypeWithQualityHeaderValue.TryParse(accept, out var mediaTypeWithQuality)
? mediaTypeWithQuality
: null;
