/// <summary>Disallows requests that would like the response in json format.</summary>
/// <param name="requestKind">Type of request.</param>
/// <param name="acceptHeader">Accept header value.</param>
private static void DisallowJsonRequests(RequestKind requestKind, string acceptHeader)
{
if (HttpProcessUtils.IsJsonRequest(requestKind, acceptHeader))
{
throw new DomainDataServiceException((int)HttpStatusCode.UnsupportedMediaType, Resource.HttpProcessUtility_UnsupportedMediaType);
}
}
/// <summary>Disallows requests that would like the response in json format.</summary>
/// <param name="requestKind">Type of request.</param>
/// <param name="acceptHeader">Accept header value.</param>
/// <returns>True if request is accepting json response.</returns>
internal static bool IsJsonRequest(RequestKind requestKind, string acceptHeader)
{
string mimeType = null;
switch (requestKind)
{
case RequestKind.ServiceDocument:
mimeType = HttpProcessUtils.SelectRequiredMimeType(
acceptHeader,
HttpProcessUtils.ServiceDocumentMimeTypes,
HttpProcessUtils.MimeApplicationXml);
break;
case RequestKind.MetadataDocument:
mimeType = HttpProcessUtils.SelectRequiredMimeType(
acceptHeader,
HttpProcessUtils.MetadataDocumentMimeTypes,
HttpProcessUtils.MimeApplicationXml);
break;
case RequestKind.ResourceSet:
mimeType = HttpProcessUtils.SelectRequiredMimeType(
acceptHeader,
HttpProcessUtils.ResourceSetMimeTypes,
HttpProcessUtils.MimeApplicationAtom);
break;
case RequestKind.ServiceOperation:
mimeType = HttpProcessUtils.SelectRequiredMimeType(
acceptHeader,
HttpProcessUtils.ServiceOperationMimeTypes,
HttpProcessUtils.MimeApplicationXml);
break;
default:
Debug.Assert(false, "Must never receive any other kind of request.");
break;
}
return(HttpProcessUtils.CompareMimeType(mimeType, HttpProcessUtils.MimeApplicationJson));
}
public void EditRequest(RequestKind requestKind)
{
DefineRequestsForMonth(2014, 6, 1);
var screenModel = new RequestManagementPageViewModel(Application, 2014, 6);
var currentRequestEntityId = screenModel.Requests.SelectableValues.First().EntityId;
object dialogViewModel = null;
Application.WindowManager
.When(w => w.ShowDialog(Arg.Any <object>()))
.Do(c => { dialogViewModel = c[0]; });
screenModel.Requests.Value = screenModel.Requests.SelectableValues.First();
screenModel.EditRequestCommand.Execute(null);
Assert.That(dialogViewModel, Is.InstanceOf <RequestDialogViewModel>());
var dialog = (RequestDialogViewModel)dialogViewModel;
var newDate = dialog.DateProperty.Value.AddDays(2);
dialog.DateProperty.Value = newDate;
dialog.DescriptionProperty.Value = "New Description added";
dialog.RequestKind.Value = requestKind;
dialog.ValueProperty.Value = 77.77;
Application.Repository.ClearReceivedCalls();
dialog.CreateRequestCommand.Execute(null);
var expectedValue = requestKind == RequestKind.Earning ? 77.77 : -77.77;
Application.Repository.Received(1).UpdateRequest(currentRequestEntityId,
Arg.Is <RequestEntityData>(r => r.Description == "New Description added" && Math.Abs(r.Value - expectedValue) < double.Epsilon && dialog.DateProperty.Value == newDate));
Application.Repository.Received(1).CalculateSaldoForMonth(2014, 6);
}
public RequestButton(RequestKind action, string title) : this()
{
Action = action;
Text = title;
}
public RequestButton(RequestKind action, string title, string[] parameters)
{
Action = action;
Text = title;
Parameters = parameters;
}
/// <summary>
/// Sends an API request to the specified URL and returns the response as the specified value if possible.
/// </summary>
/// <typeparam name="T">Type of the expected return value.</typeparam>
/// <param name="url">The URL which the request should be sent to.</param>
/// <param name="parameters">Parameters to be sent with the request.</param>
/// <param name="kind">How the body of the request should be transmitted.</param>
/// <exception cref="UriFormatException">When <paramref name="url"/> can't be parsed to a URL.</exception>
/// <exception cref="InvalidCastException">The response can't be parsed to the type <see cref="T"/>.</exception>
/// <exception cref="ArgumentNullException">When The url is null.</exception>
/// <returns>The response parsed to the specified type, if possible.</returns>
public static async Task <T> SendRequestAsync <T>(string url, Dictionary <string, object> header, Dictionary <string, object> parameters, RequestKind kind)
{
if (url.NullOrWhiteSpace())
{
throw new ArgumentNullException(nameof(url));
}
var client = new HttpClient();
if (header.ContainsKey("Authorization"))
{
client.DefaultRequestHeaders.Authorization = AuthenticationHeaderValue.Parse(header["Authorization"].ToString());
header.Remove("Authorization");
}
var contentType = "application/json";
if (header.ContainsKey("Content-Type"))
{
contentType = header["Content-Type"].ToString();
header.Remove("Content-Type");
}
foreach (var headerPair in header)
{
client.DefaultRequestHeaders.Add(headerPair.Key, headerPair.Value.ToString());
}
if (kind == RequestKind.Get)
{
var param = new List <string>();
foreach (var parameter in parameters)
{
param.Add($"{parameter.Key}={parameter.Value}");
}
var path = url.Trim('/', '\\').ToLowerInvariant().Slugify();
if (param.Count > 0)
{
path += "?" + string.Join('&', param);
path = path.Slugify().ToLowerInvariant();
}
if (Uri.TryCreate(path, UriKind.Absolute, out var requestUri))
{
var response = await client.GetAsync(requestUri);
if (response.IsSuccessStatusCode)
{
var responseString = await response.Content.ReadAsStringAsync();
var parsed = (T)Convert.ChangeType(responseString, typeof(T));
return(parsed);
}
throw new HttpRequestException($"The server responded with the statuscode {response.StatusCode}: {response.ReasonPhrase}.");
}
throw new UriFormatException($"The string \"{url}\" is not a valid URL.");
}
else
{
if (Uri.TryCreate(url, UriKind.Absolute, out var requestUri))
{
var jsonBody = JsonSerializer.Serialize(parameters);
var response = await client.PostAsync(requestUri, new StringContent(jsonBody, Encoding.UTF8, contentType));
if (response.IsSuccessStatusCode)
{
var responseString = await response.Content.ReadAsStringAsync();
var parsed = (T)Convert.ChangeType(responseString, typeof(T));
return(parsed);
}
throw new HttpRequestException($"The server responded with the statuscode {response.StatusCode}: {response.ReasonPhrase}.");
}
throw new UriFormatException($"The string \"{url}\" is not a valid URL.");
}
}
public object evalTemplateNode(XmlNode templateNode0, RequestKind stateMachineProcess)
{
return(mbot.evalTemplateNode(templateNode0, stateMachineProcess, this));
}
internal void evalTemplateNodeInnerXml(XmlNode myNode, RequestKind requestKind)
{
mbot.evalTemplateNodeInnerXml(myNode, requestKind, this);
}
public CallbackQueryHandlerAttribute(RequestKind action, Type name)
{
Action = action;
TypeOfHandler = name;
}
/// <summary>Disallows requests that would like the response in json format.</summary>
/// <param name="requestKind">Type of request.</param>
/// <param name="acceptHeader">Accept header value.</param>
/// <returns>True if request is accepting json response.</returns>
internal static bool IsJsonRequest(RequestKind requestKind, string acceptHeader)
{
string mimeType = null;
switch (requestKind)
{
case RequestKind.ServiceDocument:
mimeType = HttpProcessUtils.SelectRequiredMimeType(
acceptHeader,
HttpProcessUtils.ServiceDocumentMimeTypes,
HttpProcessUtils.MimeApplicationXml);
break;
case RequestKind.MetadataDocument:
mimeType = HttpProcessUtils.SelectRequiredMimeType(
acceptHeader,
HttpProcessUtils.MetadataDocumentMimeTypes,
HttpProcessUtils.MimeApplicationXml);
break;
case RequestKind.ResourceSet:
mimeType = HttpProcessUtils.SelectRequiredMimeType(
acceptHeader,
HttpProcessUtils.ResourceSetMimeTypes,
HttpProcessUtils.MimeApplicationAtom);
break;
case RequestKind.ServiceOperation:
mimeType = HttpProcessUtils.SelectRequiredMimeType(
acceptHeader,
HttpProcessUtils.ServiceOperationMimeTypes,
HttpProcessUtils.MimeApplicationXml);
break;
default:
Debug.Assert(false, "Must never receive any other kind of request.");
break;
}
return HttpProcessUtils.CompareMimeType(mimeType, HttpProcessUtils.MimeApplicationJson);
}
public ListMessage(Address address, RequestKind kind) : base(Opcode.LIST, address)
{
this.Kind = kind;
}
public void EditRequest(RequestKind requestKind)
{
DefineRequestsForMonth(2014, 6, 1);
var screenModel = new RequestManagementPageViewModel(Application, 2014, 6);
var currentRequestEntityId = screenModel.Requests.SelectableValues.First().EntityId;
object dialogViewModel = null;
Application.WindowManager
.When(w => w.ShowDialog(Arg.Any<object>()))
.Do(c => { dialogViewModel = c[0]; });
screenModel.Requests.Value = screenModel.Requests.SelectableValues.First();
screenModel.EditRequestCommand.Execute(null);
Assert.That(dialogViewModel, Is.InstanceOf<RequestDialogViewModel>());
var dialog = (RequestDialogViewModel) dialogViewModel;
var newDate = dialog.DateProperty.Value.AddDays(2);
dialog.DateProperty.Value = newDate;
dialog.DescriptionProperty.Value = "New Description added";
dialog.RequestKind.Value = requestKind;
dialog.ValueProperty.Value = 77.77;
Application.Repository.ClearReceivedCalls();
dialog.CreateRequestCommand.Execute(null);
var expectedValue = requestKind == RequestKind.Earning ? 77.77 : -77.77;
Application.Repository.Received(1).UpdateRequest(currentRequestEntityId,
Arg.Is<RequestEntityData>(r => r.Description == "New Description added" && Math.Abs(r.Value - expectedValue) < double.Epsilon && dialog.DateProperty.Value == newDate));
Application.Repository.Received(1).CalculateSaldoForMonth(2014, 6);
}
public MissingInfoForBuildMessage(RequestKind action, CallbackQuery query, TelegramBotClient owner)
{
this.Action = action;
this.query = query;
this.Owner = owner;
}
public ListMessage(Address address, string host, RequestKind kind) : base(Opcode.LIST, address, host)
{
this.Kind = kind;
}
public RequestMessage(Address address, string host, RequestKind kind, string nexusName) : base(Opcode.REQUEST, address, host)
{
Kind = kind;
NexusName = nexusName;
}
public RequestMessage(RequestKind kind, string nexusName, Address address) : base(Opcode.REQUEST, address)
{
Kind = kind;
NexusName = nexusName;
}
/// <summary>
/// Initializes a new instance of the <see cref="QuotaKeeperRequest"/> struct.
/// </summary>
private QuotaKeeperRequest(long size, RequestKind kind)
{
Size = size;
_kind = kind;
}
/// <summary>Disallows requests that would like the response in json format.</summary>
/// <param name="requestKind">Type of request.</param>
/// <param name="acceptHeader">Accept header value.</param>
private static void DisallowJsonRequests(RequestKind requestKind, string acceptHeader)
{
if (HttpProcessUtils.IsJsonRequest(requestKind, acceptHeader))
{
throw new DomainDataServiceException((int)HttpStatusCode.UnsupportedMediaType, Resource.HttpProcessUtility_UnsupportedMediaType);
}
}
