/// <summary>
/// Initializes a new instance of the <see cref="CreatedItemResult{T}"/> class.
/// </summary>
/// <param name="entity">The created entity.</param>
/// <param name="controller">The controller from which to obtain the dependencies needed for execution.</param>
public CreatedItemResult(T entity, ODataController controller)
: base(entity, HttpStatusCode.Created, controller)
{
Contract.Requires <ArgumentNullException>(controller != null);
_controller = controller;
}
public ODataHttpActionResult(ODataController controller, object content, Type contentType, Type formatType)
{
_controller = controller;
_content = content;
_contentType = contentType;
_formatType = formatType;
}
public static void OnChangeSetFailure(this ODataController oDataController, Action onFailureAction)
{
Contract.Requires <ArgumentNullException>(oDataController != null);
Contract.Requires <ArgumentNullException>(onFailureAction != null);
OnChangeSetFailure(oDataController, new Task(onFailureAction));
}
// DFTODO - this cannot be the final solution - way to much overhead
public static T GetKeyFromLinkUri <T>(this ODataController controller, Uri link)
{
Contract.Requires(null != link);
T key = default(T);
IHttpRoute route = controller.Request.GetRouteData().Route;
IHttpRoute newRoute = new HttpRoute(
route.RouteTemplate
,
new HttpRouteValueDictionary(route.Defaults)
,
new HttpRouteValueDictionary(route.Constraints)
,
new HttpRouteValueDictionary(route.DataTokens), route.Handler
);
var newRequest = new HttpRequestMessage(HttpMethod.Get, link);
var routeData = newRoute.GetRouteData(controller.Request.GetConfiguration().VirtualPathRoot, newRequest);
if (null != routeData)
{
ODataPath path = newRequest.ODataProperties().Path;
System.Diagnostics.Trace.Assert(null != path);
var segment = path.Segments.OfType <KeyValuePathSegment>().FirstOrDefault();
if (null != segment)
{
key = (T)ODataUriUtils.ConvertFromUriLiteral(segment.Value, ODataVersion.V3);
}
}
return(key);
}
public ODataHttpActionResult(ODataController controller, object content, Type contentType, Type formatType)
{
_controller = controller;
_content = content;
_contentType = contentType;
_formatType = formatType;
}
public void DoResponseAcceptedForControllerNotContainingControllerValueInRouteDataThrowsODataErrorException()
{
controller = Mock.Create <ODataController>();
Mock.Arrange(() => controller.ControllerContext.RouteData.Values.ContainsKey("controller"))
.Returns(false)
.MustBeCalled();
Mock.Assert(controller);
ODataControllerHelper.ResponseAccepted(controller, new BaseEntity(1));
}
/// <summary>
/// Sets a synchronous function to call when the changeset is complete.
/// </summary>
/// <param name="oDataController"></param>
/// <param name="completionFunction"></param>
/// <returns></returns>
/// <remarks>
/// If there is no containing changeset, this method will result in the completionFunction being called synchronously, so it can block for a while.
/// </remarks>
public static void OnChangeSetSuccess(this ODataController oDataController, Action completionFunction)
{
Contract.Requires <ArgumentNullException>(oDataController != null);
Contract.Requires <ArgumentNullException>(completionFunction != null);
var task = OnChangeSetSuccess(oDataController, new Task(completionFunction));
if (!task.IsCompleted)
{
task.RunSynchronously();
}
}
public static void OnChangeSetFailure(this ODataController oDataController, Task onFailureTask)
{
Contract.Requires <ArgumentNullException>(oDataController != null);
Contract.Requires <ArgumentNullException>(onFailureTask != null);
ChangeSetContext changeSetContext = oDataController.Request.GetChangeSetContext();
if (changeSetContext != null)
{
changeSetContext.AddOnChangeSetFailureTask(onFailureTask);
}
}
public static ODataController InitODataControllerForTest(ODataController controller)
{
var httpContext = new DefaultHttpContext();
var actionContext = new ActionContext
{
HttpContext = httpContext,
RouteData = new RouteData(),
ActionDescriptor = new ControllerActionDescriptor()
};
controller.ControllerContext = new ControllerContext(actionContext);
return(controller);
}
public static IHttpActionResult GetOKHttpActionResult(ODataController controller, object propertyValue)
{
var okMethod = default(MethodInfo);
var methods = controller.GetType().GetMethods(BindingFlags.Instance | BindingFlags.NonPublic);
foreach (var method in methods)
{
if (method.Name == "Ok" && method.GetParameters().Length == 1)
{
okMethod = method;
break;
}
}
okMethod = okMethod.MakeGenericMethod(propertyValue.GetType());
var returnValue = okMethod.Invoke(controller, new object[] { propertyValue });
return (IHttpActionResult)returnValue;
}
/// <summary>
/// Set the async task to call when the changeset is complete, if the current request is within a changeset.
/// If the current request is not within a changeset, <paramref name="completionTask"/> is returned.
/// </summary>
/// <param name="oDataController"></param>
/// <param name="completionTask"></param>
//public static Task<HttpResponseMessage> OnChangeSetSuccess(this ODataController oDataController, Task<HttpResponseMessage> completionTask)
//{
// Contract.Requires<ArgumentNullException>(oDataController != null);
// Contract.Requires<ArgumentNullException>(completionTask != null);
// ChangeSetContext changeSetContext = oDataController.Request.GetChangeSetContext();
// if (changeSetContext == null)
// { // Not in a ChangeSet, so execute completionTask immediately
// return completionTask;
// }
// else
// {
// changeSetContext.AddOnChangeSetSuccessTask(completionTask);
// return new Task<HttpResponseMessage>(() => new HttpResponseMessage(HttpStatusCode.Accepted)
// { Content = new StringContent("Changeset action method called; pending completion task.") });
// }
//}
public static Task OnChangeSetSuccess(this ODataController oDataController, Task completionTask)
{
Contract.Requires <ArgumentNullException>(oDataController != null);
Contract.Requires <ArgumentNullException>(completionTask != null);
ChangeSetContext changeSetContext = oDataController.Request.GetChangeSetContext();
if (changeSetContext == null)
{ // Not in a ChangeSet, so return completionTask so it is executed next
return(completionTask);
}
else
{
changeSetContext.AddOnChangeSetSuccessTask(completionTask);
return(Task.FromResult(true));
}
}
public static string GetServiceRootUri(ODataController controller)
{
var routeName = controller.Request.ODataProperties().RouteName;
ODataRoute odataRoute = controller.Configuration.Routes[routeName] as ODataRoute;
var prefixName = odataRoute.RoutePrefix;
if (!string.IsNullOrEmpty(prefixName))
{
var requestUri = controller.Request.RequestUri.ToString();
var serviceRootUri = requestUri.Substring(0, requestUri.IndexOf(prefixName, StringComparison.InvariantCultureIgnoreCase) + prefixName.Length);
return(serviceRootUri);
}
else
{
return(controller.Url.Content("~/"));
}
}
public void DoResponseCreatedReturnsHttpResponseMessageWithStatusCreated()
{
controller = Mock.Create <ODataController>();
Mock.Arrange(() => controller.Request).Returns(httpRequestMessage).MustBeCalled();
Mock.Arrange(() => controller.ControllerContext.RouteData.Values.ContainsKey("controller"))
.Returns(true)
.MustBeCalled();
Mock.Arrange(() => controller.ControllerContext.RouteData.Values["controller"])
.Returns("test")
.MustBeCalled();
Mock.Arrange(() => controller.Url.CreateODataLink(Arg.IsAny <string>(), Arg.IsAny <IODataPathHandler>(), Arg.IsAny <IList <ODataPathSegment> >()))
.Returns(ODATA_LINK).MustBeCalled();
var response = ODataControllerHelper.ResponseCreated(controller, new BaseEntity(1));
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
Mock.Assert(controller);
}
public static IHttpActionResult GetOKHttpActionResult(ODataController controller, object propertyValue)
{
var okMethod = default(MethodInfo);
var methods = controller.GetType().GetMethods(BindingFlags.Instance | BindingFlags.NonPublic);
foreach (var method in methods)
{
if (method.Name == "Ok" && method.GetParameters().Length == 1)
{
okMethod = method;
break;
}
}
okMethod = okMethod.MakeGenericMethod(propertyValue.GetType());
var returnValue = okMethod.Invoke(controller, new object[] { propertyValue });
return((IHttpActionResult)returnValue);
}
private static HttpResponseMessage CreateResponseWithETagAndLocation <T>(ODataController controller, T entity, string key, HttpStatusCode httpStatusCode)
{
var segments = new List <ODataPathSegment>();
if (!controller.ControllerContext.RouteData.Values.ContainsKey("controller"))
{
const string msg = "Controller RouteData is missing 'controller' value!";
System.Diagnostics.Debug.WriteLine(msg);
throw new ODataErrorException(msg);
}
segments.Add(new EntitySetPathSegment(controller.ControllerContext.RouteData.Values["controller"].ToString()));
var propertyInfo = entity.GetType().GetProperty(key);
var value = propertyInfo.GetValue(entity, null);
segments.Add(new KeyValuePathSegment(
value is string
?
string.Format("'{0}'", value)
:
value.ToString())
);
var uri = new Uri(controller.Url.CreateODataLink(
controller.Request.ODataProperties().RouteName
,
controller.Request.ODataProperties().PathHandler
,
segments
));
var response = controller.Request.CreateResponse(httpStatusCode, entity);
response.Headers.Location = uri;
var eTag = string.Format("\"{0}\"", System.Convert.ToString(DateTime.UtcNow.ToBinary()));
response.Headers.ETag = new EntityTagHeaderValue(eTag);
return(response);
}
public override async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
if (context.Controller == null)
{
throw new ArgumentNullException(nameof(context), "Controller is null");
}
Controller = context.Controller as Controller;
if (Controller == null)
{
throw DoesNotImplementException(context.Controller, typeof(Controller));
}
ODataController = Controller as IODataCrudController;
if (ODataController == null)
{
throw new ArgumentException($"{context.Controller.GetType()} does not implement {nameof(IODataCrudController)}");
}
ODataController.SetModel(context);
await ActionExecutionAsync(context);
await base.OnActionExecutionAsync(context, next);
}
public static SerializableError CreateSerializableErrorFromModelState(this ODataController controller)
{
// https://source.dot.net/#Microsoft.AspNetCore.Mvc.Core/SerializableError.cs,19bc9a1c61ce7ae0
var serializableError = new SerializableError();
foreach (var keyModelStatePair in controller.ModelState)
{
var key = keyModelStatePair.Key;
var errors = keyModelStatePair.Value.Errors;
if (errors != null && errors.Count > 0)
{
var errorMessages = errors.Select(error =>
{
return(string.IsNullOrEmpty(error.ErrorMessage) ? "The input was not valid." : error.ErrorMessage);
}).ToArray();
serializableError.Add(key, errorMessages);
foreach (var error in errors)
{
if (error.Exception != null)
{
// Add more error details.
// e.g.
// ```
// One or more errors occurred. (
// One or more errors occurred. (
// A null value was found for the property named 'UnitPrice', which has the expected type 'Edm.Decimal[Nullable=False]'.
// The expected type 'Edm.Decimal[Nullable=False]' does not allow null values.
// )
// )
// ```
serializableError.Add("MessageDetail", error.Exception.Message);
}
}
}
}
return(serializableError);
}
public static IActionResult CreateOKHttpActionResult(this ODataController controller, object propertyValue)
{
var okMethod = default(MethodInfo);
// find the ok method on the current controller
var methods = controller.GetType().GetMethods(BindingFlags.Instance | BindingFlags.NonPublic);
foreach (var method in methods)
{
if (method.Name == "Ok" && method.GetParameters().Length == 1)
{
okMethod = method;
break;
}
}
// invoke the method, passing in the propertyValue
okMethod = okMethod.MakeGenericMethod(propertyValue.GetType());
var returnValue = okMethod.Invoke(controller, new object[] { propertyValue });
return((IActionResult)returnValue);
}
public Logging.CBLoggers build(ODataController controller, LevelType level, LoggerType type, string message = null)
{
string sid = CBAuth.getMemberID(controller.User as ClaimsPrincipal);
string logger = _controllerTag + "-" + type.ToString();
if (message == null)
{
switch (type)
{
case LoggerType.GET:
case LoggerType.GETbyIID:
message = controller.Request.RequestUri.PathAndQuery.ToString();
break;
default:
message = "No Message";
break;
}
}
return(CBLoggerBuilder.Build(sid, level, logger, message));
}
public void DoResponseAcceptedReturnsHttpResponseMessageWithLocationSetInHeaders()
{
controller = Mock.Create <ODataController>();
Mock.Arrange(() => controller.Request)
.Returns(httpRequestMessage)
.MustBeCalled();
Mock.Arrange(() => controller.ControllerContext.RouteData.Values.ContainsKey("controller"))
.Returns(true)
.MustBeCalled();
Mock.Arrange(() => controller.ControllerContext.RouteData.Values["controller"])
.Returns("test")
.MustBeCalled();
Mock.Arrange(() => controller.Url.CreateODataLink(Arg.IsAny <string>(), Arg.IsAny <IODataPathHandler>(), Arg.IsAny <IList <ODataPathSegment> >()))
.Returns(ODATA_LINK)
.MustBeCalled();
var response = ODataControllerHelper.ResponseAccepted(controller, new BaseEntity(1));
Assert.IsNotNull(response.Headers.Location);
Assert.AreEqual(ODATA_LINK, response.Headers.Location.ToString());
Mock.Assert(controller);
}
public ODataHttpActionResult(ODataController controller, object content, Type contentType)
: this(controller, content, contentType, contentType)
{
}
internal static IHttpActionResult BadRequest(this ODataController controller, string errorCode, string message) =>
controller.BadRequest(new ODataError()
{
ErrorCode = errorCode, Message = message
});
public static HttpResponseMessage ResponseAccepted <T>(ODataController controller, T entity, string key = "Id")
{
return(CreateResponseWithETagAndLocation(controller, entity, key, HttpStatusCode.Accepted));
}
internal static IHttpActionResult BadRequest(this ODataController controller, ODataError error) => new NegotiatedContentResult <ODataError>(HttpStatusCode.BadRequest, error, controller);
internal static IHttpActionResult Forbidden(this ODataController controller, string errorCode, string message) =>
controller.Forbidden(new ODataError()
{
ErrorCode = errorCode, Message = message
});
internal static IHttpActionResult Forbidden(this ODataController controller, ODataError error) => new NegotiatedContentResult <ODataError>(HttpStatusCode.Forbidden, error, controller);
internal SYSTEM(string URL, string username, string password, string SystemName)
{
oDataController = new ODataController(URL, username, password);
this.SystemName = SystemName;
}
public ODataHttpActionResult(ODataController controller, object content, Type contentType)
: this(controller, content, contentType, contentType)
{
}
public UserMock(ODataController controller, string name)
{
_controller = controller;
Name = name;
}
public static bool InChangeSet(this ODataController oDataController)
{
Contract.Requires <ArgumentNullException>(oDataController != null);
return(oDataController.Request.InChangeSet());
}
