public AdminUserController(IUserAccess userAccess, IUserCopier userCopier, IRoleCopier roleCopier, IRequestReader requestReader)
{
_userAccess = userAccess;
_userCopier = userCopier;
_roleCopier = roleCopier;
_requestReader = requestReader;
}
private async Task <Options> ExecuteOptionsAsync(IRequestReader reader, ResponseBuilder response)
{
Options options = await Endpoint.OptionsAsync();
response.AddOptions(options);
return(options);
}
private async Task <ResourceBody> ExecuteGetAsync(IRequestReader reader, ResponseBuilder response)
{
ResourceBody resourceBody = await Endpoint.GetAsync(reader.GetQuery());
response.AddResource(resourceBody);
return(resourceBody);
}
public SendEmailFunction(
FunctionConfiguration configuration,
IRequestReader requestReader,
Func <ISmtpClient> smtpClientFactory)
{
_configuration = configuration;
_requestReader = requestReader;
_smtpClientFactory = smtpClientFactory;
}
private async Task <Feedback> ExecuteModifyAsync(IRequestReader reader, ResponseBuilder response)
{
var method = (UnsafeMethod)Enum.Parse(typeof(UnsafeMethod), reader.RequestMethod, true);
ResourceBody requestBody = reader.GetRequestBody();
Feedback feedback = await Endpoint.CommandAsync(method, requestBody);
response.AddFeedback(feedback);
return(feedback);
}
private async Task <bool> CheckModifyAsync(IRequestReader reader, ResponseBuilder response)
{
if (Endpoint.EvaluatePreconditions(reader.GetPreconditions()))
{
return(true);
}
response.SetStatusCode(HttpStatusCode.PreconditionFailed);
return(false);
}
public TimerController(ITimerAccess timerAccess, IRequestReader requestReader, ITimeBuilder timeBuilder, ITimerCalculator timerCalculator, IOvertimeAccess overtimeAccess)
{
_timerAccess = timerAccess;
_requestReader = requestReader;
_timeBuilder = timeBuilder;
_timerCalculator = timerCalculator;
_overtimeAccess = overtimeAccess;
_timeZoneInfo = _timeBuilder.GetTimeZoneInfo(_requestReader.Read(HttpHeaders.Request.CurrentTimeZone));
}
/// <summary>
/// Initializes a new instance of the <see cref="InsolvencyOrderAddressCollectionResponse" /> class.
/// </summary>
/// <param name="addressResolver">The <see cref="IAddressResolver" /> used for resolving address routes.</param>
/// <param name="pagingLinks">The <see cref="IPagingLinks" /> used to generate a paged resource.</param>
/// <param name="requestReader">The <see cref="IRequestReader" /> used to read the request.</param>
public InsolvencyOrderAddressCollectionResponse(IAddressResolver addressResolver, IPagingLinks pagingLinks, IRequestReader requestReader)
{
Requires.NotNull(addressResolver, nameof(addressResolver));
Requires.NotNull(pagingLinks, nameof(pagingLinks));
Requires.NotNull(requestReader, nameof(requestReader));
this.addressResolver = addressResolver;
this.pagingLinks = pagingLinks;
this.requestReader = requestReader;
}
public ChartController(ITimerAccess timerAccess, ITimeBuilder timeBuilder, ITimeGetter timeGetter, IRequestReader requestReader, ITimerCalculator timerCalculator)
{
_timerAccess = timerAccess;
_timeBuilder = timeBuilder;
_timeGetter = timeGetter;
_requestReader = requestReader;
_timerCalculator = timerCalculator;
_timeZoneInfo = _timeBuilder.GetTimeZoneInfo(_requestReader.Read(TypeScript.HttpHeaders.Request.CurrentTimeZone));
}
public async Task <object> ExecuteAsync(IRequestReader reader, ResponseBuilder response)
{
switch (reader.RequestMethod)
{
case "POST":
case "PUT":
case "PATCH":
return(await ExecuteWithRequeryAsync(reader, response));
default:
return(_executor.ExecuteAsync(reader, response));
}
}
public void ConstructingADisputeCollectionResponse_WithNullRequestReader_ThrowsArgumentNullException()
{
// Arrange
const IRequestReader requestReader = null;
var addressResolverMock = new Mock <IAddressResolver>();
var mockPagingLinks = new Mock <IPagingLinks>();
// Act
void ConstructResponseObject() => new DisputeCollectionResponse(addressResolverMock.Object, mockPagingLinks.Object, requestReader);
// Assert
Assert.ThrowsException <ArgumentNullException>((Action)ConstructResponseObject);
}
public void ConstructingADisputeCollectionResponse_WithNullRequestReader_HasCorrectParameterNameInException()
{
// Arrange
const string expectedParameterName = "requestReader";
const IRequestReader requestReader = null;
var addressResolverMock = new Mock <IAddressResolver>();
var mockPagingLinks = new Mock <IPagingLinks>();
// Act
void ConstructResponseObject() => new DisputeCollectionResponse(addressResolverMock.Object, mockPagingLinks.Object, requestReader);
// Assert
ExceptionAssert.HasCorrectParameterNameForArgumentException(ConstructResponseObject, expectedParameterName);
}
private async Task <bool> CheckPreconditions(IRequestReader reader, ResponseBuilder response)
{
switch (reader.RequestMethod)
{
case "GET":
return(await CheckGetAsync(reader, response));
case "POST":
case "PUT":
case "PATCH":
case "DELETE":
return(await CheckModifyAsync(reader, response));
default:
return(true);
}
}
private async Task <object> ExecuteWithRequeryAsync(IRequestReader reader, ResponseBuilder response)
{
object returnValue = await _executor.ExecuteAsync(reader, response);
IRestEndpoint endpoint = _executor.Endpoint;
if (returnValue is AcknowledgmentFeedback ackFeedback &&
ackFeedback.Acknowledgment is CreatedItemAcknowledgment created)
{
endpoint = endpoint.Next(new RawNextPath(created.NewIdentifier.ToString()));
Debug.Assert(endpoint != null);
}
ResourceBody resourceBody = await endpoint.GetAsync(reader.GetQuery());
response.AddResource(resourceBody);
return(returnValue);
}
public AddressResolver(
IQueryStringReader queryStringReader,
IRequestReader requestReader,
IBaseQueryStringCreator queryStringCreator,
IList <IBaseQueryStringWriter> baseQueryStringWriters,
IActionDescriptorCollectionProvider actionDescriptorCollectionProvider)
{
Requires.NotNull(queryStringReader, nameof(queryStringReader));
Requires.NotNull(requestReader, nameof(requestReader));
Requires.NotNull(queryStringCreator, nameof(queryStringCreator));
Requires.NotNull(baseQueryStringWriters, nameof(baseQueryStringWriters));
Requires.NotNull(actionDescriptorCollectionProvider, nameof(actionDescriptorCollectionProvider));
this.requestReader = requestReader;
this.queryStringCreator = queryStringCreator;
this.queryStringReader = queryStringReader;
this.baseQueryStringWriters = baseQueryStringWriters;
this.actionDescriptorCollectionProvider = actionDescriptorCollectionProvider;
}
public async Task <object> ExecuteAsync(IRequestReader reader, ResponseBuilder response)
{
switch (reader.RequestMethod)
{
case "GET":
return(await ExecuteGetAsync(reader, response));
case "OPTIONS":
return(await ExecuteOptionsAsync(reader, response));
case "POST":
case "PUT":
case "PATCH":
case "DELETE":
return(await ExecuteModifyAsync(reader, response));
default:
response.SetStatusCode(HttpStatusCode.MethodNotAllowed);
return(null);
}
}
public JsonRpcMiddleware(RequestDelegate next, IRequestReader requestReader, ILogger <JsonRpcMiddleware> log)
{
this.next = next;
this.requestReader = requestReader;
this.log = log;
}
public static Task <object> Read(this IRequestReader reader, RequestBinderContext context)
{
return(reader.Read(new RequestReaderContext(context.Configuration, context.RequestContext)));
}
public OrgDivDataHandler(ILoggerFactory loggerFactory, IRequestReader reader)
{
_logger = loggerFactory.CreateLogger(this.GetType().FullName);
_reader = reader;
}
public AccountController(IRequestReader requestReader, IAuthAccess authAccess)
{
_requestReader = requestReader;
_authAccess = authAccess;
}
public QueryStringValidationFilter(IRequestReader requestReader)
{
Requires.NotNull(requestReader, nameof(requestReader));
this.requestReader = requestReader;
}
public async Task <object> ExecuteAsync(IRequestReader reader, ResponseBuilder response)
{
return(await CheckPreconditions(reader, response)
? await _executor.ExecuteAsync(reader, response)
: null);
}
