public static OperationImportSegment ShouldHaveParameterCount(this OperationImportSegment segment, int count)
{
Assert.NotNull(segment);
Assert.NotNull(segment.Parameters);
Assert.Equal(count, segment.Parameters.Count());
return(segment);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public ActionResult GetSimpleFunction()
{
var ds = HttpContext.ODataFeature().RequestContainer.GetService(typeof(IDataSource)) as IDataSource;
var path = Request.ODataFeature().Path;
OperationImportSegment seg = path.Segments[0] as OperationImportSegment;
IEdmType edmType = seg.EdmType;
IEdmType elementType = edmType.TypeKind == EdmTypeKind.Collection
? (edmType as IEdmCollectionType).ElementType.Definition
: edmType;
ODataQueryContext queryContext = new ODataQueryContext(Request.GetModel(), elementType, path);
ODataQueryOptions queryOptions = new ODataQueryOptions(queryContext, Request);
var ri = new RequestInfo(ds.Name)
{
Method = MethodType.Function,
Target = seg.Identifier,
QueryOptions = queryOptions
};
return(Excute(ri, () =>
{
return ds.InvokeFunction(ri.QueryOptions);
}));
}
/// <summary>
/// Initializes a new instance of the <see cref="FunctionImportSegmentTemplate" /> class.
/// </summary>
/// <param name="segment">The input function import segment.</param>
public FunctionImportSegmentTemplate(OperationImportSegment segment)
{
if (segment == null)
{
throw Error.ArgumentNull(nameof(segment));
}
IEdmOperationImport operationImport = segment.OperationImports.First();
if (!operationImport.IsFunctionImport())
{
throw new ODataException(Error.Format(SRResources.SegmentShouldBeKind, "FunctionImport", "FunctionImportSegmentTemplate"));
}
FunctionImport = (IEdmFunctionImport)operationImport;
NavigationSource = segment.EntitySet;
ParameterMappings = OperationHelper.BuildParameterMappings(segment.Parameters, operationImport.Name);
// join the parameters as p1={p1}
string routeKey = ParameterMappings.BuildRouteKey();
string parameterStr = ParameterMappings.Count == 0 ? "()" : $"({{{routeKey}}})";
Literal = FunctionImport.Name + parameterStr;
IsSingle = FunctionImport.Function.ReturnType.TypeKind() != EdmTypeKind.Collection;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public ActionResult DoAction(ODataActionParameters parameters)
{
var ds = HttpContext.ODataFeature().RequestContainer.GetService(typeof(IDataSource)) as IDataSource;
var path = Request.ODataFeature().Path;
OperationImportSegment seg = path.Segments[0] as OperationImportSegment;
JObject jobj = null;
string s = Request.GetRawBodyStringAsync().Result;
if (!string.IsNullOrEmpty(s) && s != "null")
{
jobj = JObject.Parse(s);
}
var ri = new RequestInfo(ds.Name)
{
Method = MethodType.Action,
Target = seg.Identifier,
QueryOptions = null
};
return(Excute(ri, () =>
{
IEdmAction a = null;
foreach (var item in seg.OperationImports)
{
a = item.Operation as IEdmAction;
}
return ds.DoAction(a, jobj);
}));
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public ActionResult GetFuncResultCount()
{
var ds = HttpContext.ODataFeature().RequestContainer.GetService(typeof(IDataSource)) as IDataSource;
var options = GetQueryOptions();
var path = Request.ODataFeature().Path;
OperationImportSegment seg = path.Segments[0] as OperationImportSegment;
JObject pars = new JObject();
foreach (var p in seg.Parameters)
{
try
{
var n = (p.Value as ConstantNode).Value;
pars.Add(p.Name, new JValue(n));
}
catch (Exception ex)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, ex));
}
}
var ri = new RequestInfo(ds.Name)
{
Method = MethodType.Count,
Parameters = pars,
Target = seg.Identifier,
QueryOptions = options
};
return(Excute(ri, () =>
{
return ds.GetFuncResultCount(ri.QueryOptions);
}));
}
public void CtorFunctionImportSegmentTemplate_SetsProperties()
{
// Arrange & Act
FunctionImportSegmentTemplate functionImportSegment = new FunctionImportSegmentTemplate(_functionImport, null);
// Assert
Assert.Same(_functionImport, functionImportSegment.FunctionImport);
Assert.Null(functionImportSegment.NavigationSource);
Assert.NotNull(functionImportSegment.ParameterMappings);
Assert.Collection(functionImportSegment.ParameterMappings,
e =>
{
Assert.Equal("name", e.Key);
Assert.Equal("name", e.Value);
},
e =>
{
Assert.Equal("title", e.Key);
Assert.Equal("title", e.Value);
});
// Arrange & Act
OperationImportSegment importSegment = new OperationImportSegment(_functionImport, null);
functionImportSegment = new FunctionImportSegmentTemplate(importSegment);
Assert.Empty(functionImportSegment.ParameterMappings);
}
public static string ToUriLiteral(this OperationImportSegment segment)
{
if (segment == null)
{
throw Error.ArgumentNull("segment");
}
IEdmActionImport action = segment.OperationImports.Single() as IEdmActionImport;
if (action != null)
{
return(action.Name);
}
else
{
// Translate the nodes in ODL path to string literals as parameter of BoundFunctionPathSegment.
Dictionary <string, string> parameterValues = segment.Parameters.ToDictionary(
parameterValue => parameterValue.Name,
parameterValue => TranslateNode(parameterValue.Value));
// TODO: refactor the function literal for parameter alias
IEdmFunctionImport function = (IEdmFunctionImport)segment.OperationImports.Single();
IEnumerable <string> parameters = parameterValues.Select(v => String.Format(CultureInfo.InvariantCulture, "{0}={1}", v.Key, v.Value));
return(String.Format(CultureInfo.InvariantCulture, "{0}({1})", function.Name, String.Join(",", parameters)));
}
}
/// <summary>
/// Handle a OperationImportSegment
/// </summary>
/// <param name="segment">the segment to Handle</param>
public override void Handle(OperationImportSegment segment)
{
Contract.Assert(segment != null);
NavigationSource = segment.EntitySet;
IEdmActionImport actionImport = segment.OperationImports.Single() as IEdmActionImport;
if (actionImport != null)
{
_path.Add(actionImport.Name);
}
else
{
IEdmFunctionImport function = (IEdmFunctionImport)segment.OperationImports.Single();
IList <string> parameterValues = new List <string>();
foreach (var parameter in segment.Parameters)
{
var functionParameter = function.Function.Parameters.FirstOrDefault(p => p.Name == parameter.Name);
if (functionParameter == null)
{
continue;
}
parameterValues.Add(functionParameter.Type.FullName());
}
string literal = string.Format(CultureInfo.InvariantCulture, "{0}({1})", function.Name, string.Join(",", parameterValues));
_path.Add(literal);
}
}
/// <summary>
/// Selects the controller for OData requests.
/// </summary>
/// <param name="odataPath">The OData path.</param>
/// <returns>
/// <c>null</c> if the request isn't handled by this convention; otherwise, the name of the selected controller
/// </returns>
internal static SelectControllerResult SelectControllerImpl(ODataPath odataPath)
{
ODataPathSegment firstSegment = odataPath.Segments.FirstOrDefault();
// entity set
EntitySetSegment entitySetSegment = firstSegment as EntitySetSegment;
if (entitySetSegment != null)
{
return(new SelectControllerResult(entitySetSegment.EntitySet.Name, null));
}
// singleton
SingletonSegment singletonSegment = firstSegment as SingletonSegment;
if (singletonSegment != null)
{
return(new SelectControllerResult(singletonSegment.Singleton.Name, null));
}
// operation import
OperationImportSegment importSegment = firstSegment as OperationImportSegment;
if (importSegment != null)
{
// There's two options: Each one has advantages/disadvantanges. Here picks #1.
// 1) map all operation import to a certain controller, for example: ODataOperationImportController
return(new SelectControllerResult("ODataOperationImport", null));
// 2) map operation import to controller named using operation improt name, for example: ResetDataController
// return new SelectControllerResult(importSegment.OperationImports.FirstOrDefault().Name, null);
}
return(null);
}
public void ComputedTypeCanBeRelatedToEntitySetByInheritance()
{
OperationImportSegment segment = new OperationImportSegment(HardCodedTestModel.GetFunctionImportForGetBestManager(), HardCodedTestModel.GetPeopleSet());
segment.EdmType.Should().BeSameAs(HardCodedTestModel.GetManagerType());
segment.EntitySet.Should().BeSameAs(HardCodedTestModel.GetPeopleSet());
}
/// <inheritdoc/>
internal static string SelectActionImpl(ODataPath odataPath, IWebApiControllerContext controllerContext,
IWebApiActionMap actionMap)
{
OperationImportSegment operationImportSegment = null;
if (odataPath.PathTemplate == "~/unboundfunction" &&
ODataRequestMethod.Get == controllerContext.Request.Method)
{
// The same function name may be used multiple times within a schema, each with a different set of parameters.
// For unbound overloads the combination of the function name and the unordered set of parameter names
// MUST identify a particular function overload.
operationImportSegment = (OperationImportSegment)odataPath.Segments[0];
}
else if (odataPath.PathTemplate == "~/unboundaction" &&
ODataRequestMethod.Post == controllerContext.Request.Method)
{
// The same action name may be used multiple times within a schema provided there is at most one unbound overload
operationImportSegment = (OperationImportSegment)odataPath.Segments[0];
}
string actionName = SelectAction(operationImportSegment, actionMap);
if (actionName != null)
{
controllerContext.AddFunctionParameterToRouteData(operationImportSegment);
return(actionName);
}
return(null);
}
public async Task VisitAsync(ODataPath path)
{
NotFound = false;
BadRequest = false;
Result = null;
ResultType = null;
PropertySetter = null;
Index = 0;
foreach (var segment in path)
{
await(segment switch
{
TypeSegment typeSegment => VisitAsync(typeSegment),
NavigationPropertySegment navigationPropertySegment => VisitAsync(navigationPropertySegment),
EntitySetSegment entitySetSegment => VisitAsync(entitySetSegment),
SingletonSegment singletonSegment => VisitAsync(singletonSegment),
KeySegment keySegment => VisitAsync(keySegment),
PropertySegment propertySegment => VisitAsync(propertySegment),
AnnotationSegment annotationSegment => VisitAsync(annotationSegment),
OperationImportSegment operationImportSegment => VisitAsync(operationImportSegment),
OperationSegment operationSegment => VisitAsync(operationSegment),
DynamicPathSegment dynamicPathSegment => VisitAsync(dynamicPathSegment),
CountSegment countSegment => VisitAsync(countSegment),
FilterSegment filterSegment => VisitAsync(filterSegment),
ReferenceSegment referenceSegment => VisitAsync(referenceSegment),
EachSegment eachSegment => VisitAsync(eachSegment),
NavigationPropertyLinkSegment navigationPropertyLinkSegment => VisitAsync(navigationPropertyLinkSegment),
ValueSegment valueSegment => VisitAsync(valueSegment),
BatchSegment batchSegment => VisitAsync(batchSegment),
BatchReferenceSegment batchReferenceSegment => VisitAsync(batchReferenceSegment),
MetadataSegment metadataSegment => VisitAsync(metadataSegment),
PathTemplateSegment pathTemplateSegment => VisitAsync(pathTemplateSegment),
_ => throw new NotSupportedException()
});
/// <summary>
/// Handle a OperationImportSegment
/// </summary>
/// <param name="segment">the segment to Handle</param>
public override void Handle(OperationImportSegment segment)
{
_navigationSource = segment.EntitySet;
IEdmActionImport actionImport = segment.OperationImports.Single() as IEdmActionImport;
if (actionImport != null)
{
_pathTemplate.Add(ODataSegmentKinds.UnboundAction); // unbound action
_pathUriLiteral.Add(actionImport.Name);
}
else
{
_pathTemplate.Add(ODataSegmentKinds.UnboundFunction); // unbound function
// Translate the nodes in ODL path to string literals as parameter of UnboundFunctionPathSegment.
Dictionary <string, string> parameterValues = segment.Parameters.ToDictionary(
parameterValue => parameterValue.Name,
parameterValue => TranslateNode(parameterValue.Value));
IEdmFunctionImport function = (IEdmFunctionImport)segment.OperationImports.Single();
IEnumerable <string> parameters = parameterValues.Select(v => String.Format(CultureInfo.InvariantCulture, "{0}={1}", v.Key, v.Value));
string literal = String.Format(CultureInfo.InvariantCulture, "{0}({1})", function.Name, String.Join(",", parameters));
_pathUriLiteral.Add(literal);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="FunctionImportSegmentTemplate" /> class.
/// </summary>
/// <param name="segment">The input function import segment.</param>
public FunctionImportSegmentTemplate(OperationImportSegment segment)
{
if (segment == null)
{
throw Error.ArgumentNull(nameof(segment));
}
IEdmOperationImport operationImport = segment.OperationImports.First();
if (!operationImport.IsFunctionImport())
{
throw new ODataException(Error.Format(SRResources.SegmentShouldBeKind, "FunctionImport", "FunctionImportSegmentTemplate"));
}
FunctionImport = (IEdmFunctionImport)operationImport;
NavigationSource = segment.EntitySet;
ParameterMappings = OperationHelper.BuildParameterMappings(segment.Parameters, operationImport.Name);
// join the parameters as p1={p1}
Literal = FunctionImport.Name + "(" + string.Join(",", ParameterMappings.Select(a => $"{a.Key}={{{a.Value}}}")) + ")";
IsSingle = FunctionImport.Function.ReturnType.TypeKind() != EdmTypeKind.Collection;
}
public void TranslateFunctionImportSegmentTemplate_ReturnsODataFunctionImportSegment_WithOptionalParameter()
{
// Arrange
_function.AddOptionalParameter("min", IntPrimitive);
_function.AddOptionalParameter("max", IntPrimitive);
EdmModel model = new EdmModel();
model.AddElement(_function);
model.AddElement(_container);
IDictionary <string, string> parameters = new Dictionary <string, string>
{
{ "name", "{nameTemp}" },
{ "title", "{titleTemp}" },
{ "min", "{minTemp}" },
};
FunctionImportSegmentTemplate template = new FunctionImportSegmentTemplate(parameters, _functionImport, null);
RouteValueDictionary routeValues = new RouteValueDictionary(new { nameTemp = "'pt'", titleTemp = "'abc'", minTemp = "42" });
HttpContext httpContext = new DefaultHttpContext();
ODataTemplateTranslateContext context = new ODataTemplateTranslateContext(httpContext, routeValues, model);
// Act
ODataPathSegment actual = template.Translate(context);
// Assert
Assert.NotNull(actual);
OperationImportSegment functionImportSegment = Assert.IsType <OperationImportSegment>(actual);
Assert.Same(_function, functionImportSegment.OperationImports.First().Operation);
Assert.Equal("pt", routeValues["nameTemp"]);
Assert.Equal("abc", routeValues["titleTemp"]);
Assert.Equal(42, routeValues["minTemp"]);
}
public void Translate_ReturnsODataFunctionImportSegment()
{
// Arrange
var primitive = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, false);
EdmFunction function = new EdmFunction("NS", "MyFunction", primitive, false, null, false);
function.AddParameter("name", primitive);
function.AddParameter("title", primitive);
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
EdmFunctionImport functionImport = new EdmFunctionImport(container, "MyFunctionImport", function);
FunctionImportSegmentTemplate template = new FunctionImportSegmentTemplate(functionImport, null);
Mock <HttpContext> httpContext = new Mock <HttpContext>();
Mock <IEdmModel> edmModel = new Mock <IEdmModel>();
ODataTemplateTranslateContext context = new ODataTemplateTranslateContext(httpContext.Object,
new RouteValueDictionary(), edmModel.Object);
// Act
ODataPathSegment actual = template.Translate(context);
// Assert
Assert.NotNull(actual);
OperationImportSegment functionImportSegment = Assert.IsType <OperationImportSegment>(actual);
Assert.Same(function, functionImportSegment.OperationImports.First().Operation);
}
private List <KeyValuePair <String, Object> > GetParameters(OperationImportSegment importSegment, Stream requestStream, String contentType)
{
var parameters = new List <KeyValuePair <String, Object> >();
foreach (OperationSegmentParameter segmentParameter in importSegment.Parameters)
{
Object value;
var constantNode = segmentParameter.Value as ConstantNode;
if (constantNode == null)
{
value = OeEdmClrHelper.GetValue(_model, segmentParameter.Value);
}
else
{
value = OeEdmClrHelper.GetValue(_model, constantNode.Value);
}
parameters.Add(new KeyValuePair <String, Object>(segmentParameter.Name, value));
}
var operation = (EdmOperation)importSegment.OperationImports.Single().Operation;
if (parameters.Count == 0 && requestStream != null)
{
FillParameters(parameters, requestStream, operation, contentType);
}
OrderParameters(operation.Parameters, parameters);
return(parameters);
}
private static Microsoft.OData.UriParser.ODataPath ConvertPath(ODataPath path)
{
if (path == null)
{
return(null);
}
if (IsOperationPath(path))
{
var lastSegment = path.Segments.Last();
OperationSegment operation = lastSegment as OperationSegment;
if (operation != null && operation.EntitySet != null)
{
return(GeneratePath(operation.EntitySet));
}
OperationImportSegment operationImport = lastSegment as OperationImportSegment;
if (operationImport != null && operationImport.EntitySet != null)
{
return(GeneratePath(operationImport.EntitySet));
}
return(null);
}
return(path.Path);
}
public static OperationImportSegment ShouldBeOperationImportSegment(this ODataPathSegment segment, params IEdmOperationImport[] operationImports)
{
Assert.NotNull(segment);
OperationImportSegment operationImportSegment = Assert.IsType <OperationImportSegment>(segment);
operationImportSegment.OperationImports.ContainExactly(operationImports);
return(operationImportSegment);
}
public static AndConstraint <OperationImportSegment> ShouldBeOperationImportSegment(this ODataPathSegment segment, params IEdmOperationImport[] operationImports)
{
segment.Should().BeOfType <OperationImportSegment>();
OperationImportSegment operationImportSegment = segment.As <OperationImportSegment>();
operationImportSegment.OperationImports.Should().ContainExactly(operationImports);
return(new AndConstraint <OperationImportSegment>(operationImportSegment));
}
public void CandidateServiceOperationsSetCorrectly()
{
OperationImportSegment segment = new OperationImportSegment(new List <IEdmOperationImport>()
{
HardCodedTestModel.GetFunctionImportForGetCoolestPerson()
}, HardCodedTestModel.GetPeopleSet());
segment.OperationImports.Should().OnlyContain(x => x.Name == HardCodedTestModel.GetFunctionImportForGetCoolestPerson().Name);
}
public void EntitySetIsCorrect()
{
OperationImportSegment segment = new OperationImportSegment(new List <IEdmOperationImport>()
{
HardCodedTestModel.GetFunctionImportForGetCoolestPerson()
}, HardCodedTestModel.GetPeopleSet());
segment.EntitySet.Should().BeSameAs(HardCodedTestModel.GetPeopleSet());
}
public static OperationImportSegment ShouldHaveConstantParameter <TValue>(this OperationImportSegment segment, string name, TValue value)
{
Assert.NotNull(segment);
OperationSegmentParameter parameter = segment.Parameters.SingleOrDefault(p => p.Name == name);
Assert.NotNull(parameter);
parameter.ShouldBeConstantParameterWithValueType(name, value);
return(segment);
}
public void CandidateServiceOperationsSetCorrectly()
{
OperationImportSegment segment = new OperationImportSegment(new List <IEdmOperationImport>()
{
HardCodedTestModel.GetFunctionImportForGetCoolestPerson()
}, HardCodedTestModel.GetPeopleSet());
var operationImport = Assert.Single(segment.OperationImports);
Assert.Equal(HardCodedTestModel.GetFunctionImportForGetCoolestPerson().Name, operationImport.Name);
}
public void ParametersSetCorrectly()
{
OperationImportSegment segment = new OperationImportSegment(new List <IEdmOperationImport>()
{
HardCodedTestModel.GetFunctionImportForGetCoolestPerson()
},
HardCodedTestModel.GetPeopleSet(),
new[] { new OperationSegmentParameter("stuff", new ConstantNode(new ODataPrimitiveValue(true))), });
segment.ShouldHaveConstantParameter("stuff", new ODataPrimitiveValue(true));
}
public void IfOperationsAllHaveSameReturnTypeThenReturnTypeIsSet()
{
var operations = new List <IEdmOperationImport> {
this.functionImportIntToInt,
this.functionImportDecimalToInt,
this.functionImportIntToInt,
};
var segment = new OperationImportSegment(operations, null);
// All operations in the list return int, so we can set the return type to that.
segment.EdmType.ShouldBeEquivalentTo(operations.First().Operation.ReturnType.Definition);
}
public void EqualityIsCorrect()
{
OperationImportSegment segment1 = new OperationImportSegment(new List <IEdmOperationImport>()
{
HardCodedTestModel.GetFunctionImportForGetCoolestPerson()
}, HardCodedTestModel.GetPeopleSet());
OperationImportSegment segment2 = new OperationImportSegment(new List <IEdmOperationImport>()
{
HardCodedTestModel.GetFunctionImportForGetCoolestPerson()
}, HardCodedTestModel.GetPeopleSet());
segment1.Equals(segment2).Should().BeTrue();
}
/// <summary>
/// Initializes a new instance of the <see cref="ActionImportSegmentTemplate" /> class.
/// </summary>
/// <param name="segment">The operation import segment.</param>
public ActionImportSegmentTemplate(OperationImportSegment segment)
{
Segment = segment ?? throw Error.ArgumentNull(nameof(segment));
IEdmOperationImport operationImport = segment.OperationImports.FirstOrDefault();
if (!operationImport.IsActionImport())
{
throw new ODataException(Error.Format(SRResources.SegmentShouldBeKind, "ActionImport", "ActionImportSegmentTemplate"));
}
ActionImport = (IEdmActionImport)operationImport;
}
/// <inheritdoc/>
public override bool TryMatch(ODataPathSegment pathSegment, IDictionary <string, object> values)
{
OperationImportSegment other = pathSegment as OperationImportSegment;
if (other == null)
{
return(false);
}
IEdmOperationImport operationImport = Segment.OperationImports.First();
IEdmOperationImport otherImport = other.OperationImports.First();
// for unbound action, just compare the action import
if (operationImport.IsActionImport() && otherImport.IsActionImport())
{
return(operationImport == otherImport);
}
else if (operationImport.IsFunctionImport() && otherImport.IsFunctionImport())
{
// but for unbound function, we should compare the parameter names and
// process the parameter values into odata routes.
if (operationImport.Name != otherImport.Name)
{
return(false);
}
IDictionary <string, object> parameterValues = new Dictionary <string, object>();
foreach (var parameter in other.Parameters)
{
object value = other.GetParameterValue(parameter.Name);
parameterValues[parameter.Name] = value;
}
if (RoutingConventionHelpers.TryMatch(ParameterMappings, parameterValues, values))
{
foreach (var operationSegmentParameter in other.Parameters)
{
string name = operationSegmentParameter.Name;
object value = parameterValues[name];
RoutingConventionHelpers.AddFunctionParameters((IEdmFunction)otherImport.Operation, name,
value, values, values, ParameterMappings);
}
return(true);
}
}
return(false);
}
/// <summary>
/// Translate a OperationImportSegment
/// </summary>
/// <param name="segment">the segment to Translate</param>
/// <returns>Translated the path segment template.</returns>
public override ODataSegmentTemplate Translate(OperationImportSegment segment)
{
if (segment == null)
{
throw Error.ArgumentNull(nameof(segment));
}
if (segment.OperationImports.First().IsActionImport())
{
return(new ActionImportSegmentTemplate(segment));
}
return(new FunctionImportSegmentTemplate(segment));
}
public void IfOperationsAllHaveSameReturnTypeThenReturnTypeIsSet()
{
var operations = new List<IEdmOperationImport> {
this.functionImportIntToInt,
this.functionImportDecimalToInt,
this.functionImportIntToInt,
};
var segment = new OperationImportSegment(operations, null);
// All operations in the list return int, so we can set the return type to that.
segment.EdmType.ShouldBeEquivalentTo(operations.First().Operation.ReturnType.Definition);
}
public void Translate_OperationImportSegment_To_UnboundActionPathSegment_Works()
{
// Arrange
IEdmEntitySet entityset = _model.FindDeclaredEntitySet("SalesPeople");
IEnumerable<IEdmOperationImport> operationImports = _model.FindDeclaredOperationImports("GetSalesPersonById");
OperationImportSegment segment = new OperationImportSegment(operationImports, entityset);
// Act
IEnumerable<ODataPathSegment> segments = _translator.Translate(segment);
// Assert
ODataPathSegment pathSegment = Assert.Single(segments);
UnboundActionPathSegment unboundActionPathSegment = Assert.IsType<UnboundActionPathSegment>(pathSegment);
Assert.Same(operationImports.First(), unboundActionPathSegment.Action);
}
public void IfOperationsHaveDifferentReturnTypeThenWeThrowInEdmTypeProperty()
{
var operations = new List<IEdmOperationImport> {
this.functionImportIntToInt,
this.functionImportDecimalToInt,
this.functionImportIntToString,
};
var segment = new OperationImportSegment(operations, null);
try
{
// Dummy code, just need to access property to get the exception
var type = segment.EdmType;
Assert.Fail("The EdmType getter returned '" + type + "', but should have thrown.");
}
catch (ODataException e)
{
e.Message.Should().Be("No type could be computed for this Segment since there were multiple possible operations with varying return types.");
}
}
public void ComputedTypeCanBeRelatedToEntitySetByInheritance()
{
OperationImportSegment segment = new OperationImportSegment(HardCodedTestModel.GetFunctionImportForGetBestManager(), HardCodedTestModel.GetPeopleSet());
segment.EdmType.Should().BeSameAs(HardCodedTestModel.GetManagerType());
segment.EntitySet.Should().BeSameAs(HardCodedTestModel.GetPeopleSet());
}
public void EntitySetIsCorrect()
{
OperationImportSegment segment = new OperationImportSegment(new List<IEdmOperationImport>() { HardCodedTestModel.GetFunctionImportForGetCoolestPerson() }, HardCodedTestModel.GetPeopleSet());
segment.EntitySet.Should().BeSameAs(HardCodedTestModel.GetPeopleSet());
}
public void SingleOperationSetCorrectly()
{
OperationImportSegment segment = new OperationImportSegment(HardCodedTestModel.GetFunctionImportForGetCoolestPerson(), HardCodedTestModel.GetPeopleSet());
segment.OperationImports.Single().Should().BeSameAs(HardCodedTestModel.GetFunctionImportForGetCoolestPerson());
}
public override void Handle(OperationImportSegment segment)
{
this.ThrowIfResolved();
this.NavigationSource = segment.EntitySet;
this.Property = null;
this.Type = segment.EdmType;
this.ElementType = this.GetElementType(this.Type);
this.IsOperation = true;
this.PushParentSegment();
this.childSegments.Add(segment);
this.canonicalSegments.Add(segment);
}
public void ParametersSetCorrectly()
{
OperationImportSegment segment = new OperationImportSegment(new List<IEdmOperationImport>() { HardCodedTestModel.GetFunctionImportForGetCoolestPerson() },
HardCodedTestModel.GetPeopleSet(),
new[] { new OperationSegmentParameter("stuff", new ConstantNode(new ODataPrimitiveValue(true))), });
segment.ShouldHaveConstantParameter("stuff", new ODataPrimitiveValue(true));
}
public void EqualityIsCorrect()
{
OperationImportSegment segment1 = new OperationImportSegment(new List<IEdmOperationImport>() { HardCodedTestModel.GetFunctionImportForGetCoolestPerson() }, HardCodedTestModel.GetPeopleSet());
OperationImportSegment segment2 = new OperationImportSegment(new List<IEdmOperationImport>() { HardCodedTestModel.GetFunctionImportForGetCoolestPerson() }, HardCodedTestModel.GetPeopleSet());
segment1.Equals(segment2).Should().BeTrue();
}
private bool TryCreateSegmentForOperationImport(string identifier, string parenthesisExpression)
{
ICollection<OperationSegmentParameter> resolvedParameters;
IEdmOperationImport singleImport;
if (!TryBindingParametersAndMatchingOperationImport(identifier, parenthesisExpression, this.configuration, out resolvedParameters, out singleImport))
{
return false;
}
IEdmTypeReference returnType = singleImport.Operation.ReturnType;
IEdmEntitySetBase targetset = null;
if (returnType != null)
{
targetset = singleImport.GetTargetEntitySet(null, this.configuration.Model);
}
// TODO: change constructor to take single import
ODataPathSegment segment = new OperationImportSegment(new[] { singleImport }, targetset, resolvedParameters);
DetermineEntitySetForSegment(identifier, returnType, segment, targetset, singleImport.Operation);
this.parsedSegments.Add(segment);
this.TryBindKeySegmentIfNoResolvedParametersAndParathesisValueExsts(parenthesisExpression, returnType, resolvedParameters, segment);
return true;
}
public void InequalityIsCorrect()
{
OperationImportSegment operationSegment1 = new OperationImportSegment(new List<IEdmOperationImport>() { HardCodedTestModel.GetFunctionImportForGetCoolestPerson() }, HardCodedTestModel.GetPeopleSet());
OperationImportSegment operationSegment2 = new OperationImportSegment(new List<IEdmOperationImport>() { HardCodedTestModel.GetFunctionImportForGetCoolestPerson() }, null);
OperationImportSegment operationSegment3 = new OperationImportSegment(new List<IEdmOperationImport>() { HardCodedTestModel.GetFunctionImportForGetCoolPeople() }, HardCodedTestModel.GetPeopleSet());
BatchSegment segment = BatchSegment.Instance;
operationSegment1.Equals(operationSegment2).Should().BeFalse();
operationSegment1.Equals(operationSegment3).Should().BeFalse();
operationSegment1.Equals(segment).Should().BeFalse();
}
public void EdmTypeComputedFromOperationReturnTypeForSingleOperation()
{
OperationImportSegment segment = new OperationImportSegment(HardCodedTestModel.GetFunctionImportForGetCoolestPerson(), HardCodedTestModel.GetPeopleSet());
segment.EdmType.Should().BeSameAs(HardCodedTestModel.GetFunctionImportForGetCoolestPerson().Operation.ReturnType.Definition);
}
public void CandidateServiceOperationsSetCorrectly()
{
OperationImportSegment segment = new OperationImportSegment(new List<IEdmOperationImport>() { HardCodedTestModel.GetFunctionImportForGetCoolestPerson() }, HardCodedTestModel.GetPeopleSet());
segment.OperationImports.Should().OnlyContain(x => x.Name == HardCodedTestModel.GetFunctionImportForGetCoolestPerson().Name);
}
/// <summary>
/// Handle an OperationSegment
/// </summary>
/// <param name="segment">the segment to Handle</param>
public virtual void Handle(OperationImportSegment segment)
{
throw new NotImplementedException();
}
