public void Apply_AddsFeedSelfLink_ThatThrowsForMissingRoute()
{
// Arrange
Func<FeedContext, Uri> feedSelfLink = null;
var mockEntityType = new Mock<EntityTypeConfiguration>();
var mockEntitySet = new Mock<EntitySetConfiguration>();
mockEntitySet.Setup(entitySet => entitySet.EntityType).Returns(mockEntityType.Object);
mockEntitySet.Setup(entitySet => entitySet.HasFeedSelfLink(It.IsAny<Func<FeedContext, Uri>>()))
.Returns(mockEntitySet.Object)
.Callback<Func<FeedContext, Uri>>(selfLink => { feedSelfLink = selfLink; });
var mockModelBuilder = new Mock<ODataModelBuilder>();
HttpConfiguration configuration = new HttpConfiguration();
HttpRequestMessage request = new HttpRequestMessage();
request.Properties["MS_HttpConfiguration"] = configuration;
FeedContext context = new FeedContext(new Mock<IEdmEntitySet>().Object, new UrlHelper(request), new Product[0]);
// Act
new SelfLinksGenerationConvention().Apply(mockEntitySet.Object, mockModelBuilder.Object);
// Assert
Assert.NotNull(feedSelfLink);
Assert.ThrowsArgument(() => feedSelfLink(context), "name",
"A route named 'OData.Default' could not be found in the route collection");
}
public override Uri BuildFeedSelfLink(FeedContext context)
{
if (FeedSelfLinkBuilder != null)
{
return FeedSelfLinkBuilder(context);
}
return null;
}
public virtual Uri BuildFeedSelfLink(FeedContext context)
{
if (context == null)
{
throw Error.ArgumentNull("context");
}
if (_feedSelfLinkBuilder == null)
{
return null;
}
return _feedSelfLinkBuilder(context);
}
public void BuildFunctionLink_ForFeed_ReturnsLink()
{
// Arrange
FunctionLinkBuilder builder = new FunctionLinkBuilder((FeedContext a) => new Uri("http://localhost:456"),
followsConventions: true);
EntityInstanceContext entityContext = new EntityInstanceContext();
FeedContext feedContext = new FeedContext();
// Act
Uri link = builder.BuildFunctionLink(entityContext);
Uri feedLink = builder.BuildFunctionLink(feedContext);
// Assert
Assert.Null(link);
Assert.NotNull(feedLink);
Assert.Equal("http://localhost:456/", feedLink.AbsoluteUri);
}
public void Execute(FeedContext context)
{
var commentedOn = (int)context.ValueProvider.GetValue("commentedon").ConvertTo(typeof(int));
var limit = 20;
var limitValue = context.ValueProvider.GetValue("limit");
if (limitValue != null)
{
Int32.TryParse(Convert.ToString(limitValue), out limit);
}
var comments = _contentManager
.Query <CommentPart, CommentPartRecord>()
.Where(x => x.CommentsPartRecord.Id == commentedOn && x.Status == CommentStatus.Approved)
.OrderByDescending(x => x.CommentDateUtc)
.Slice(0, limit);
foreach (var comment in comments)
{
context.Builder.AddItem(context, comment);
}
}
/// <summary>
/// Generates an action link following the OData URL conventions for the action <paramref name="action"/> and bound to the
/// collection of entity represented by <paramref name="feedContext"/>.
/// </summary>
/// <param name="feedContext">The <see cref="FeedContext"/> representing the feed for which the action link needs to be generated.</param>
/// <param name="action">The action for which the action link needs to be generated.</param>
/// <returns>The generated action link following OData URL conventions.</returns>
public static Uri GenerateActionLink(this FeedContext feedContext, IEdmOperation action)
{
if (feedContext == null)
{
throw Error.ArgumentNull("feedContext");
}
if (action == null)
{
throw Error.ArgumentNull("action");
}
IEdmOperationParameter bindingParameter = action.Parameters.FirstOrDefault();
if (bindingParameter == null ||
!bindingParameter.Type.IsCollection() ||
!((IEdmCollectionType)bindingParameter.Type.Definition).ElementType.IsEntity())
{
throw Error.Argument("action", SRResources.ActionNotBoundToCollectionOfEntity, action.Name);
}
return(GenerateActionLink(feedContext, bindingParameter.Type.FullName(), action.FullName()));
}
public void WhenFeedActionLinksNotManuallyConfigured_ConventionBasedBuilderUsesConventions()
{
// Arrange
Uri expectedUri = new Uri("http://server/Movies/Default.Watch");
ODataModelBuilder builder = new ODataConventionModelBuilder();
EntityTypeConfiguration <Movie> movie = builder.EntitySet <Movie>("Movies").EntityType;
ActionConfiguration watch = movie.Collection.Action("Watch"); // action bound to collection
IEdmModel model = builder.GetEdmModel();
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://server/Movies");
HttpConfiguration configuration = new HttpConfiguration();
string routeName = "Route";
configuration.MapODataServiceRoute(routeName, null, model);
request.SetConfiguration(configuration);
request.ODataProperties().RouteName = routeName;
UrlHelper urlHelper = new UrlHelper(request);
// Act
IEdmEntityContainer container = model.SchemaElements.OfType <IEdmEntityContainer>().SingleOrDefault();
IEdmAction watchAction = Assert.Single(model.SchemaElements.OfType <IEdmAction>()); // Guard
IEdmEntitySet entitySet = container.EntitySets().SingleOrDefault();
FeedContext context = new FeedContext
{
EntitySetBase = entitySet,
Url = urlHelper,
Request = request
};
ActionLinkBuilder actionLinkBuilder = model.GetAnnotationValue <ActionLinkBuilder>(watchAction);
//Assert
Assert.Equal(expectedUri, watch.GetFeedActionLink()(context));
Assert.NotNull(actionLinkBuilder);
Assert.Equal(expectedUri, actionLinkBuilder.BuildActionLink(context));
}
public void Convention_GeneratesUri_ForFunctionBoundToCollectionOfEntity()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Customer>("Customers");
var function = builder.EntityType <Customer>().Collection.Function("MyFunction").Returns <int>();
function.Parameter <string>("param");
IEdmModel model = builder.GetEdmModel();
// Act
HttpConfiguration configuration = new HttpConfiguration();
configuration.MapODataServiceRoute("odata", "odata", model);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://*****:*****@param)",
link.AbsoluteUri);
}
public async Task Run(PublishedFundingUndoTaskContext taskContext)
{
LogStartingTask();
Guard.ArgumentNotNull(taskContext?.PublishedFundingVersionDetails, nameof(taskContext.PublishedFundingVersionDetails));
UndoTaskDetails details = taskContext.PublishedFundingVersionDetails;
ICosmosDbFeedIterator <PublishedFundingVersion> feed = GetPublishedFundingVersionsFeed(details);
FeedContext <PublishedFundingVersion> feedContext = new FeedContext <PublishedFundingVersion>(taskContext, feed);
IProducerConsumer producerConsumer = ProducerConsumerFactory.CreateProducerConsumer(ProducePublishedFundingVersions,
UndoPublishedFundingVersions,
200,
4,
Logger);
await producerConsumer.Run(feedContext);
await NotifyJobProgress(taskContext);
LogCompletedTask();
}
internal static Uri GenerateFunctionLink(this FeedContext feedContext, string bindingParameterType,
string functionName, IEnumerable <string> parameterNames)
{
Contract.Assert(feedContext != null);
if (feedContext.EntitySetBase is IEdmContainedEntitySet)
{
return(null);
}
IList <ODataPathSegment> functionPathSegments = new List <ODataPathSegment>();
feedContext.GenerateBaseODataPathSegmentsForFeed(functionPathSegments);
// generate link with cast if the navigation source type doesn't match the entity type the function is bound to.
if (feedContext.EntitySetBase.Type.FullTypeName() != bindingParameterType)
{
string elementType = DeserializationHelpers.GetCollectionElementTypeName(bindingParameterType, isNested: false);
Contract.Assert(elementType != null);
functionPathSegments.Add(new CastPathSegment(elementType));
}
Dictionary <string, string> parametersDictionary = new Dictionary <string, string>();
// skip the binding parameter
foreach (string param in parameterNames.Skip(1))
{
parametersDictionary.Add(param, "@" + param);
}
functionPathSegments.Add(new BoundFunctionPathSegment(functionName, parametersDictionary));
string functionLink = feedContext.Url.CreateODataLink(functionPathSegments);
return(functionLink == null ? null : new Uri(functionLink));
}
public void CanManuallyConfigureFeedFunctionLinkFactory()
{
// Arrange
Uri expectedUri = new Uri("http://localhost/service/Customers/Reward");
ODataModelBuilder builder = new ODataModelBuilder();
EntityTypeConfiguration <Customer> customer = builder.EntitySet <Customer>("Customers").EntityType;
customer.HasKey(c => c.CustomerId);
customer.Property(c => c.Name);
FunctionConfiguration reward = customer.Collection.Function("Reward").Returns <int>();
reward.HasFeedFunctionLink(ctx => expectedUri, followsConventions: false);
IEdmModel model = builder.GetEdmModel();
// Act
IEdmFunction rewardFuntion = Assert.Single(model.SchemaElements.OfType <IEdmFunction>()); // Guard
FunctionLinkBuilder functionLinkBuilder = model.GetAnnotationValue <FunctionLinkBuilder>(rewardFuntion);
FeedContext context = new FeedContext();
//Assert
Assert.Equal(expectedUri, reward.GetFeedFunctionLink()(context));
Assert.NotNull(functionLinkBuilder);
Assert.Equal(expectedUri, functionLinkBuilder.BuildFunctionLink(context));
}
public void Populate(FeedContext context)
{
foreach (var feedItem in context.Response.Items.OfType <FeedItem <ContentItem> >())
{
var inspector = new ItemInspector(
feedItem.Item,
_contentManager.GetItemMetadata(feedItem.Item),
_htmlFilters);
// author is intentionally left empty as it could result in unwanted spam
// add to known formats
if (context.Format == "rss")
{
var link = new XElement("link");
var guid = new XElement("guid", new XAttribute("isPermaLink", "true"));
context.Response.Contextualize(requestContext => {
var urlHelper = new UrlHelper(requestContext, _routes);
var uriBuilder = new UriBuilder(urlHelper.MakeAbsolute("/"))
{
Path = urlHelper.RouteUrl(inspector.Link)
};
link.Add(uriBuilder.Uri.OriginalString);
guid.Add(uriBuilder.Uri.OriginalString);
});
feedItem.Element.SetElementValue("title", inspector.Title);
feedItem.Element.Add(link);
feedItem.Element.SetElementValue("description", inspector.Description);
if (inspector.PublishedUtc != null)
{
// RFC833
// The "R" or "r" standard format specifier represents a custom date and time format string that is defined by
// the DateTimeFormatInfo.RFC1123Pattern property. The pattern reflects a defined standard, and the property
// is read-only. Therefore, it is always the same, regardless of the culture used or the format provider supplied.
// The custom format string is "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'". When this standard format specifier is used,
// the formatting or parsing operation always uses the invariant culture.
feedItem.Element.SetElementValue("pubDate", inspector.PublishedUtc.Value.ToString("r"));
}
feedItem.Element.Add(guid);
}
else
{
var feedItem1 = feedItem;
context.Response.Contextualize(requestContext => {
var urlHelper = new UrlHelper(requestContext, _routes);
context.Builder.AddProperty(context, feedItem1, "link", urlHelper.RouteUrl(inspector.Link));
});
context.Builder.AddProperty(context, feedItem, "title", inspector.Title);
context.Builder.AddProperty(context, feedItem, "description", inspector.Description);
if (inspector.PublishedUtc != null)
{
context.Builder.AddProperty(context, feedItem, "published-date", Convert.ToString(inspector.PublishedUtc)); // format? cvt to generic T?
}
}
}
}
/// <summary>
/// Create the <see cref="ODataFeed"/> to be written for the given feed instance.
/// </summary>
/// <param name="feedInstance">The instance representing the feed being written.</param>
/// <param name="feedType">The EDM type of the feed being written.</param>
/// <param name="writeContext">The serializer context.</param>
/// <returns>The created <see cref="ODataFeed"/> object.</returns>
public virtual ODataFeed CreateODataFeed(IEnumerable feedInstance, IEdmCollectionTypeReference feedType,
ODataSerializerContext writeContext)
{
ODataFeed feed = new ODataFeed();
if (writeContext.EntitySet != null)
{
IEdmModel model = writeContext.Model;
EntitySetLinkBuilderAnnotation linkBuilder = model.GetEntitySetLinkBuilder(writeContext.EntitySet);
FeedContext feedContext = new FeedContext
{
Request = writeContext.Request,
RequestContext = writeContext.RequestContext,
EntitySet = writeContext.EntitySet,
Url = writeContext.Url,
FeedInstance = feedInstance
};
Uri feedSelfLink = linkBuilder.BuildFeedSelfLink(feedContext);
if (feedSelfLink != null)
{
feed.SetAnnotation(new AtomFeedMetadata()
{
SelfLink = new AtomLinkMetadata()
{
Relation = "self", Href = feedSelfLink
}
});
}
}
// TODO: Bug 467590: remove the hardcoded feed id. Get support for it from the model builder ?
feed.Id = "http://schemas.datacontract.org/2004/07/" + feedType.FullName();
if (writeContext.ExpandedEntity == null)
{
// If we have more OData format specific information apply it now, only if we are the root feed.
PageResult odataFeedAnnotations = feedInstance as PageResult;
if (odataFeedAnnotations != null)
{
feed.Count = odataFeedAnnotations.Count;
feed.NextPageLink = odataFeedAnnotations.NextPageLink;
}
else if (writeContext.Request != null)
{
feed.NextPageLink = writeContext.Request.GetNextPageLink();
long?inlineCount = writeContext.Request.GetInlineCount();
if (inlineCount.HasValue)
{
feed.Count = inlineCount.Value;
}
}
}
else
{
// nested feed
ITruncatedCollection truncatedCollection = feedInstance as ITruncatedCollection;
if (truncatedCollection != null && truncatedCollection.IsTruncated)
{
feed.NextPageLink = GetNestedNextPageLink(writeContext, truncatedCollection.PageSize);
}
}
return(feed);
}
public void Populate(FeedContext context)
{
foreach (var feedItem in context.Response.Items.OfType <FeedItem <ContentItem> >())
{
var rssPart = feedItem.Item.As <RssPart>();
if (rssPart == null)
{
continue;
}
var settings = rssPart.TypePartDefinition.Settings.GetModel <RssPartSettings>();
// add to known formats
if (context.Format == "rss")
{
if (!String.IsNullOrWhiteSpace(settings.Title))
{
var title = feedItem.Element.Element("title");
if (settings.Title == "-")
{
if (title != null)
{
title.Remove();
}
}
else
{
if (title == null)
{
feedItem.Element.Add(title = new XElement("title"));
}
FeedItem <ContentItem> item = feedItem;
context.Response.Contextualize(requestContext => {
title.Value = _tokenizer.Replace(settings.Title, new { Content = item.Item, Text = title.Value });
});
}
}
if (!String.IsNullOrWhiteSpace(settings.Author))
{
var author = feedItem.Element.Element("author");
if (settings.Author == "-")
{
if (author != null)
{
author.Remove();
}
}
else
{
if (author == null)
{
feedItem.Element.Add(author = new XElement("author"));
}
FeedItem <ContentItem> item = feedItem;
context.Response.Contextualize(requestContext => {
author.Value = _tokenizer.Replace(settings.Title, new { Content = item.Item, Text = author.Value });
});
}
}
if (!String.IsNullOrWhiteSpace(settings.Description))
{
var description = feedItem.Element.Element("description");
if (settings.Description == "-")
{
if (description != null)
{
description.Remove();
}
}
else
{
if (description == null)
{
feedItem.Element.Add(description = new XElement("description"));
}
FeedItem <ContentItem> item = feedItem;
context.Response.Contextualize(requestContext => {
description.Value = _tokenizer.Replace(settings.Description, new { Content = item.Item, Text = description.Value }, new ReplaceOptions {
Encoding = ReplaceOptions.NoEncode
});
});
}
}
if (!String.IsNullOrWhiteSpace(settings.Enclosure))
{
var enclosure = feedItem.Element.Element("enclosure");
if (settings.Enclosure == "-")
{
if (enclosure != null)
{
enclosure.Remove();
}
}
else
{
if (enclosure == null)
{
feedItem.Element.Add(enclosure = new XElement("enclosure"));
}
FeedItem <ContentItem> item = feedItem;
context.Response.Contextualize(requestContext => {
enclosure.Value = _tokenizer.Replace(settings.Enclosure, new { Content = item.Item, Text = enclosure.Value });
});
}
}
if (!String.IsNullOrWhiteSpace(settings.Link))
{
var link = feedItem.Element.Element("link");
if (settings.Link == "-")
{
if (link != null)
{
link.Remove();
}
}
else
{
if (link == null)
{
feedItem.Element.Add(link = new XElement("link"));
}
FeedItem <ContentItem> item = feedItem;
context.Response.Contextualize(requestContext => {
link.Value = _tokenizer.Replace(settings.Link, new { Content = item.Item, Text = link.Value });
});
}
}
if (!String.IsNullOrWhiteSpace(settings.PubDate))
{
var pubDate = feedItem.Element.Element("pubDate");
if (settings.PubDate == "-")
{
if (pubDate != null)
{
pubDate.Remove();
}
}
else
{
if (pubDate == null)
{
feedItem.Element.Add(pubDate = new XElement("pubDate"));
}
FeedItem <ContentItem> item = feedItem;
context.Response.Contextualize(requestContext => {
pubDate.Value = _tokenizer.Replace(settings.PubDate, new { Content = item.Item, Text = pubDate.Value });
});
}
}
if (!String.IsNullOrWhiteSpace(settings.Source))
{
var source = feedItem.Element.Element("source");
if (settings.Source == "-")
{
if (source != null)
{
source.Remove();
}
}
else
{
if (source == null)
{
feedItem.Element.Add(source = new XElement("source"));
}
FeedItem <ContentItem> item = feedItem;
context.Response.Contextualize(requestContext => {
source.Value = _tokenizer.Replace(settings.Source, new { Content = item.Item, Text = source.Value });
});
}
}
if (!String.IsNullOrWhiteSpace(settings.Category))
{
var categories = feedItem.Element.Elements("category").ToArray();
var currentValue = String.Join(",", categories.Select(x => x.Value).ToArray());
if (settings.Category == "-")
{
foreach (var category in categories)
{
category.Remove();
}
}
else
{
foreach (var category in categories)
{
category.Remove();
}
FeedItem <ContentItem> item = feedItem;
context.Response.Contextualize(requestContext => {
var newValue = _tokenizer.Replace(settings.Category, new { Content = item.Item, Text = currentValue });
foreach (var value in newValue.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
feedItem.Element.Add(new XElement("category", value));
}
});
}
}
}
}
}
public virtual ODataOperation CreateODataOperation(IEdmOperation operation, FeedContext feedContext, ODataSerializerContext writeContext)
{
if (operation == null)
{
throw Error.ArgumentNull("operation");
}
if (feedContext == null)
{
throw Error.ArgumentNull("feedContext");
}
if (writeContext == null)
{
throw Error.ArgumentNull("writeContext");
}
ODataMetadataLevel metadataLevel = writeContext.MetadataLevel;
IEdmModel model = writeContext.Model;
if (metadataLevel != ODataMetadataLevel.FullMetadata)
{
return null;
}
ProcedureLinkBuilder builder;
IEdmAction action = operation as IEdmAction;
if (action != null)
{
builder = model.GetActionLinkBuilder(action);
}
else
{
builder = model.GetFunctionLinkBuilder((IEdmFunction)operation);
}
if (builder == null)
{
return null;
}
Uri target = builder.BuildLink(feedContext);
if (target == null)
{
return null;
}
Uri baseUri = new Uri(writeContext.Url.CreateODataLink(new MetadataPathSegment()));
Uri metadata = new Uri(baseUri, "#" + operation.FullName());
ODataOperation odataOperation;
if (action != null)
{
odataOperation = new ODataAction();
}
else
{
odataOperation = new ODataFunction();
}
odataOperation.Metadata = metadata;
// Always omit the title in minimal/no metadata modes.
ODataEntityTypeSerializer.EmitTitle(model, operation, odataOperation);
// Omit the target in minimal/no metadata modes unless it doesn't follow conventions.
if (metadataLevel == ODataMetadataLevel.FullMetadata || !builder.FollowsConventions)
{
odataOperation.Target = target;
}
return odataOperation;
}
public FeedsController(FeedContext context, FeedHelper feedHelper)
{
_context = context;
_feedHelper = feedHelper;
}
public void WhenFeedActionLinksNotManuallyConfigured_ConventionBasedBuilderUsesConventions()
{
// Arrange
Uri expectedUri = new Uri("http://server/Movies/Default.Watch");
ODataModelBuilder builder = new ODataConventionModelBuilder();
EntityTypeConfiguration<Movie> movie = builder.EntitySet<Movie>("Movies").EntityType;
ActionConfiguration watch = movie.Collection.Action("Watch"); // action bound to collection
IEdmModel model = builder.GetEdmModel();
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://server/Movies");
HttpConfiguration configuration = new HttpConfiguration();
string routeName = "Route";
configuration.MapODataServiceRoute(routeName, null, model);
request.SetConfiguration(configuration);
request.ODataProperties().RouteName = routeName;
UrlHelper urlHelper = new UrlHelper(request);
// Act
IEdmEntityContainer container = model.SchemaElements.OfType<IEdmEntityContainer>().SingleOrDefault();
IEdmAction watchAction = Assert.Single(model.SchemaElements.OfType<IEdmAction>()); // Guard
IEdmEntitySet entitySet = container.EntitySets().SingleOrDefault();
FeedContext context = new FeedContext
{
EntitySetBase = entitySet,
Url = urlHelper,
Request = request
};
ActionLinkBuilder actionLinkBuilder = model.GetAnnotationValue<ActionLinkBuilder>(watchAction);
//Assert
Assert.Equal(expectedUri, watch.GetFeedActionLink()(context));
Assert.NotNull(actionLinkBuilder);
Assert.Equal(expectedUri, actionLinkBuilder.BuildActionLink(context));
}
public GetPostsOfFollowersHandler(FeedContext feedContext, IMediator mediator)
{
_feedContext = feedContext;
_mediator = mediator;
_rabbit = new RabbitRPC <List <FeedPostsResponse> >(RabbitMqChannels.GetPostsOfFollowers);
}
public void CreateODataOperations_CreateOperations(bool followConventions)
{
// Arrange
// Arrange
string expectedTarget = "aa://Target";
ODataFeedSerializer serializer = new ODataFeedSerializer(new DefaultODataSerializerProvider());
var builder = new ODataConventionModelBuilder();
builder.EntitySet<FeedCustomer>("Customers");
var function = builder.EntityType<FeedCustomer>().Collection.Function("MyFunction").Returns<int>();
function.HasFeedFunctionLink(a => new Uri(expectedTarget), followConventions);
IEdmModel model = builder.GetEdmModel();
IEdmEntitySet customers = model.EntityContainer.FindEntitySet("Customers");
IEdmFunction edmFunction = model.SchemaElements.OfType<IEdmFunction>().First(f => f.Name == "MyFunction");
string expectedMetadataPrefix = "http://Metadata";
UrlHelper url = CreateMetadataLinkFactory(expectedMetadataPrefix);
HttpRequestMessage request = new HttpRequestMessage();
FeedContext feedContext = new FeedContext
{
EntitySetBase = customers,
Request = request,
Url = url
};
ODataSerializerContext serializerContext = new ODataSerializerContext
{
NavigationSource = customers,
Request = request,
Model = model,
MetadataLevel = ODataMetadataLevel.FullMetadata,
Url = url
};
// Act
ODataOperation actualOperation = serializer.CreateODataOperation(edmFunction, feedContext, serializerContext);
// Assert
Assert.NotNull(actualOperation);
string expectedMetadata = expectedMetadataPrefix + "#Default.MyFunction";
ODataOperation expectedFunction = new ODataFunction
{
Metadata = new Uri(expectedMetadata),
Target = new Uri(expectedTarget),
Title = "MyFunction"
};
AssertEqual(expectedFunction, actualOperation);
}
public void CreateODataOperation_OmitsOperations_WhenNonFullMetadata(ODataMetadataLevel metadataLevel)
{
// Arrange
ODataFeedSerializer serializer = new ODataFeedSerializer(new DefaultODataSerializerProvider());
IEdmTypeReference returnType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
IEdmFunction function = new EdmFunction("NS", "Function", returnType, isBound: true, entitySetPathExpression: null, isComposable: false);
FeedContext feedContext = new FeedContext();
ODataSerializerContext serializerContext = new ODataSerializerContext
{
MetadataLevel = metadataLevel
};
// Act
ODataOperation operation = serializer.CreateODataOperation(function, feedContext, serializerContext);
// Assert
Assert.Null(operation);
}
public void GenerateFunctionLinkForFeed_ThrowsArgumentNull_Function()
{
// Arrange
FeedContext feedContext = new FeedContext();
// Act & Assert
Assert.ThrowsArgumentNull(() => feedContext.GenerateFunctionLink(function: null), "function");
}
public void GenerateFunctionLinkForFeed_ThrowsFunctionNotBoundToCollectionOfEntity_IfFunctionHasNoParameters()
{
// Arrange
FeedContext context = new FeedContext();
Mock<IEdmFunction> function = new Mock<IEdmFunction>();
function.Setup(a => a.Parameters).Returns(Enumerable.Empty<IEdmOperationParameter>());
function.Setup(a => a.Name).Returns("SomeFunction");
// Act & Assert
Assert.ThrowsArgument(
() => context.GenerateFunctionLink(function.Object),
"function",
"The function 'SomeFunction' is not bound to the collection of entity. Only functions that are bound to entities can have function links.");
}
public void GenerateFunctionLinkForFeed_GeneratesLinkWithCast_IfEntitySetTypeDoesnotMatchActionEntityType()
{
// Arrange
HttpRequestMessage request = GetODataRequest(_model.Model);
IEdmFunction function = _model.Model.SchemaElements.OfType<IEdmFunction>().First(a => a.Name == "IsSpecialAllUpgraded");
Assert.NotNull(function); // Guard
var context = new FeedContext
{
Request = request,
EntitySetBase = _model.Customers,
Url = request.GetUrlHelper(),
};
// Act
Uri link = context.GenerateFunctionLink(function);
// Assert
Assert.Equal("http://localhost/Customers/NS.SpecialCustomer/NS.IsSpecialAllUpgraded(param=@param)", link.AbsoluteUri);
}
public void GenerateFunctionLinkForFeed_GeneratesLinkWithDownCast_IfElementTypeDerivesFromBindingParameterType()
{
// Arrange
HttpRequestMessage request = GetODataRequest(_model.Model);
IEdmFunction function = _model.Model.SchemaElements.OfType<IEdmFunction>().First(a => a.Name == "IsAllUpgraded");
Assert.NotNull(function); // Guard
IEdmEntitySet specialCustomers = new EdmEntitySet(_model.Container, "SpecialCustomers", _model.SpecialCustomer);
var context = new FeedContext
{
Request = request,
EntitySetBase = specialCustomers,
Url = request.GetUrlHelper(),
};
// Act
Uri link = context.GenerateFunctionLink(function);
// Assert
Assert.Equal("http://localhost/SpecialCustomers/NS.Customer/NS.IsAllUpgraded(param=@param)", link.AbsoluteUri);
}
public virtual ODataOperation CreateODataOperation(IEdmOperation operation, FeedContext feedContext, ODataSerializerContext writeContext)
{
if (operation == null)
{
throw Error.ArgumentNull("operation");
}
if (feedContext == null)
{
throw Error.ArgumentNull("feedContext");
}
if (writeContext == null)
{
throw Error.ArgumentNull("writeContext");
}
ODataMetadataLevel metadataLevel = writeContext.MetadataLevel;
IEdmModel model = writeContext.Model;
if (metadataLevel != ODataMetadataLevel.FullMetadata)
{
return(null);
}
ProcedureLinkBuilder builder;
IEdmAction action = operation as IEdmAction;
if (action != null)
{
builder = model.GetActionLinkBuilder(action);
}
else
{
builder = model.GetFunctionLinkBuilder((IEdmFunction)operation);
}
if (builder == null)
{
return(null);
}
Uri target = builder.BuildLink(feedContext);
if (target == null)
{
return(null);
}
Uri baseUri = new Uri(writeContext.Url.CreateODataLink(new MetadataPathSegment()));
Uri metadata = new Uri(baseUri, "#" + operation.FullName());
ODataOperation odataOperation;
if (action != null)
{
odataOperation = new ODataAction();
}
else
{
odataOperation = new ODataFunction();
}
odataOperation.Metadata = metadata;
// Always omit the title in minimal/no metadata modes.
ODataEntityTypeSerializer.EmitTitle(model, operation, odataOperation);
// Omit the target in minimal/no metadata modes unless it doesn't follow conventions.
if (metadataLevel == ODataMetadataLevel.FullMetadata || !builder.FollowsConventions)
{
odataOperation.Target = target;
}
return(odataOperation);
}
/// <summary>
/// Create the <see cref="ODataFeed"/> to be written for the given feed instance.
/// </summary>
/// <param name="feedInstance">The instance representing the feed being written.</param>
/// <param name="feedType">The EDM type of the feed being written.</param>
/// <param name="writeContext">The serializer context.</param>
/// <returns>The created <see cref="ODataFeed"/> object.</returns>
public virtual ODataFeed CreateODataFeed(IEnumerable feedInstance, IEdmCollectionTypeReference feedType,
ODataSerializerContext writeContext)
{
ODataFeed feed = new ODataFeed();
if (writeContext.NavigationSource != null)
{
IEdmModel model = writeContext.Model;
NavigationSourceLinkBuilderAnnotation linkBuilder = model.GetNavigationSourceLinkBuilder(writeContext.NavigationSource);
FeedContext feedContext = new FeedContext
{
Request = writeContext.Request,
RequestContext = writeContext.RequestContext,
EntitySet = writeContext.NavigationSource as IEdmEntitySet,
Url = writeContext.Url,
FeedInstance = feedInstance
};
Uri feedSelfLink = linkBuilder.BuildFeedSelfLink(feedContext);
if (feedSelfLink != null)
{
feed.SetAnnotation(new AtomFeedMetadata() { SelfLink = new AtomLinkMetadata() { Relation = "self", Href = feedSelfLink } });
}
}
feed.Id = new Uri("http://schemas.datacontract.org/2004/07/" + feedType.FullName());
if (writeContext.ExpandedEntity == null)
{
// If we have more OData format specific information apply it now, only if we are the root feed.
PageResult odataFeedAnnotations = feedInstance as PageResult;
if (odataFeedAnnotations != null)
{
feed.Count = odataFeedAnnotations.Count;
feed.NextPageLink = odataFeedAnnotations.NextPageLink;
}
else if (writeContext.Request != null)
{
feed.NextPageLink = writeContext.Request.ODataProperties().NextLink;
long? countValue = writeContext.Request.ODataProperties().TotalCount;
if (countValue.HasValue)
{
feed.Count = countValue.Value;
}
}
}
else
{
// nested feed
ITruncatedCollection truncatedCollection = feedInstance as ITruncatedCollection;
if (truncatedCollection != null && truncatedCollection.IsTruncated)
{
feed.NextPageLink = GetNestedNextPageLink(writeContext, truncatedCollection.PageSize);
}
}
return feed;
}
private IEnumerable <ODataOperation> CreateODataOperations(IEnumerable <IEdmOperation> operations, FeedContext feedContext, ODataSerializerContext writeContext)
{
Contract.Assert(operations != null);
Contract.Assert(feedContext != null);
Contract.Assert(writeContext != null);
foreach (IEdmOperation operation in operations)
{
ODataOperation oDataOperation = CreateODataOperation(operation, feedContext, writeContext);
if (oDataOperation != null)
{
yield return(oDataOperation);
}
}
}
public void CanManuallyConfigureFeedActionLinkFactory()
{
// Arrange
Uri expectedUri = new Uri("http://localhost/service/Customers/Reward");
ODataModelBuilder builder = new ODataModelBuilder();
EntityTypeConfiguration<Customer> customer = builder.EntitySet<Customer>("Customers").EntityType;
customer.HasKey(c => c.CustomerId);
customer.Property(c => c.Name);
ActionConfiguration reward = customer.Collection.Action("Reward");
reward.HasFeedActionLink(ctx => expectedUri, followsConventions: false);
IEdmModel model = builder.GetEdmModel();
// Act
IEdmAction rewardAction = Assert.Single(model.SchemaElements.OfType<IEdmAction>()); // Guard
ActionLinkBuilder actionLinkBuilder = model.GetAnnotationValue<ActionLinkBuilder>(rewardAction);
FeedContext context = new FeedContext();
//Assert
Assert.Equal(expectedUri, reward.GetFeedActionLink()(context));
Assert.NotNull(actionLinkBuilder);
Assert.Equal(expectedUri, actionLinkBuilder.BuildActionLink(context));
}
public void GenerateActionLinkForFeed_GeneratesLinkWithoutCast_IfEntitySetTypeMatchesActionEntityType()
{
// Arrange
HttpRequestMessage request = GetODataRequest(_model.Model);
IEdmAction action = _model.Model.SchemaElements.OfType<IEdmAction>().First(a => a.Name == "UpgradeAll");
Assert.NotNull(action); // Guard
var context = new FeedContext
{
Request = request,
EntitySetBase = _model.Customers,
Url = request.GetUrlHelper(),
};
// Act
Uri link = context.GenerateActionLink(action);
Assert.Equal("http://localhost/Customers/NS.UpgradeAll", link.AbsoluteUri);
}
public PostsRepository(FeedContext context) : base(context)
{
}
public PackageGroupsModel(FeedContext db)
{
_db = db;
}
/// <summary>
/// Create the <see cref="ODataFeed"/> to be written for the given feed instance.
/// </summary>
/// <param name="feedInstance">The instance representing the feed being written.</param>
/// <param name="feedType">The EDM type of the feed being written.</param>
/// <param name="writeContext">The serializer context.</param>
/// <returns>The created <see cref="ODataFeed"/> object.</returns>
public virtual ODataFeed CreateODataFeed(IEnumerable feedInstance, IEdmCollectionTypeReference feedType,
ODataSerializerContext writeContext)
{
ODataFeed feed = new ODataFeed();
if (writeContext.NavigationSource != null)
{
FeedContext feedContext = new FeedContext
{
Request = writeContext.Request,
RequestContext = writeContext.RequestContext,
EntitySetBase = writeContext.NavigationSource as IEdmEntitySetBase,
Url = writeContext.Url,
FeedInstance = feedInstance
};
IEdmEntityType entityType = GetEntityType(feedType).Definition as IEdmEntityType;
var operations = writeContext.Model.GetAvailableOperationsBoundToCollection(entityType);
var odataOperations = CreateODataOperations(operations, feedContext, writeContext);
foreach (var odataOperation in odataOperations)
{
ODataAction action = odataOperation as ODataAction;
if (action != null)
{
feed.AddAction(action);
}
else
{
feed.AddFunction((ODataFunction)odataOperation);
}
}
}
if (writeContext.ExpandedEntity == null)
{
// If we have more OData format specific information apply it now, only if we are the root feed.
PageResult odataFeedAnnotations = feedInstance as PageResult;
if (odataFeedAnnotations != null)
{
feed.Count = odataFeedAnnotations.Count;
feed.NextPageLink = odataFeedAnnotations.NextPageLink;
}
else if (writeContext.Request != null)
{
feed.NextPageLink = writeContext.Request.ODataProperties().NextLink;
long? countValue = writeContext.Request.ODataProperties().TotalCount;
if (countValue.HasValue)
{
feed.Count = countValue.Value;
}
}
}
else
{
// nested feed
ITruncatedCollection truncatedCollection = feedInstance as ITruncatedCollection;
if (truncatedCollection != null && truncatedCollection.IsTruncated)
{
feed.NextPageLink = GetNestedNextPageLink(writeContext, truncatedCollection.PageSize);
}
ICountOptionCollection countOptionCollection = feedInstance as ICountOptionCollection;
if (countOptionCollection != null && countOptionCollection.TotalCount != null)
{
feed.Count = countOptionCollection.TotalCount;
}
}
return feed;
}
public HomeController(HomeContext context, FeedContext contextFeed)
{
_context = context;
_contextFeed = contextFeed;
}
private IEnumerable<ODataOperation> CreateODataOperations(IEnumerable<IEdmOperation> operations, FeedContext feedContext, ODataSerializerContext writeContext)
{
Contract.Assert(operations != null);
Contract.Assert(feedContext != null);
Contract.Assert(writeContext != null);
foreach (IEdmOperation operation in operations)
{
ODataOperation oDataOperation = CreateODataOperation(operation, feedContext, writeContext);
if (oDataOperation != null)
{
yield return oDataOperation;
}
}
}
public RssController(FeedContext context)
{
_context = context;
}
private void WriteFeed(object graph, ODataWriter writer, ODataSerializerContext writeContext)
{
IEnumerable enumerable = graph as IEnumerable; // Data to serialize
if (enumerable != null)
{
ODataFeed feed = new ODataFeed();
if (writeContext.EntitySet != null)
{
IEntitySetLinkBuilder linkBuilder = SerializerProvider.EdmModel.GetEntitySetLinkBuilder(writeContext.EntitySet);
FeedContext feedContext = new FeedContext
{
EntitySet = writeContext.EntitySet,
UrlHelper = writeContext.UrlHelper,
PathHandler = writeContext.PathHandler,
FeedInstance = graph
};
Uri feedSelfLink = linkBuilder.BuildFeedSelfLink(feedContext);
if (feedSelfLink != null)
{
feed.SetAnnotation(new AtomFeedMetadata() { SelfLink = new AtomLinkMetadata() { Relation = SelfLinkRelation, Href = feedSelfLink } });
}
}
// TODO: Bug 467590: remove the hardcoded feed id. Get support for it from the model builder ?
feed.Id = FeedNamespace + _edmCollectionType.FullName();
// If we have more OData format specific information apply it now.
ODataResult odataFeedAnnotations = graph as ODataResult;
if (odataFeedAnnotations != null)
{
feed.Count = odataFeedAnnotations.Count;
feed.NextPageLink = odataFeedAnnotations.NextPageLink;
}
else
{
object nextPageLinkPropertyValue;
HttpRequestMessage request = writeContext.Request;
if (request != null && request.Properties.TryGetValue(ODataQueryOptions.NextPageLinkPropertyKey, out nextPageLinkPropertyValue))
{
Uri nextPageLink = nextPageLinkPropertyValue as Uri;
if (nextPageLink != null)
{
feed.NextPageLink = nextPageLink;
}
}
}
writer.WriteStart(feed);
foreach (object entry in enumerable)
{
if (entry == null)
{
throw Error.NotSupported(SRResources.NullElementInCollection);
}
ODataSerializer entrySerializer = SerializerProvider.GetODataPayloadSerializer(entry.GetType());
if (entrySerializer == null)
{
throw Error.NotSupported(SRResources.TypeCannotBeSerialized, entry.GetType(), typeof(ODataMediaTypeFormatter).Name);
}
Contract.Assert(entrySerializer.ODataPayloadKind == ODataPayloadKind.Entry);
entrySerializer.WriteObjectInline(entry, writer, writeContext);
}
writer.WriteEnd();
}
}
public async Task ExecuteAsync(FeedContext context)
{
var model = new ListFeedQueryViewModel();
if (!context.Updater.TryUpdateModelAsync(model).GetAwaiter().GetResult() || model.ContentItemId == null)
{
return;
}
var contentItem = _contentManager.GetAsync(model.ContentItemId).GetAwaiter().GetResult();
if (contentItem == null)
{
return;
}
var contentItemMetadata = _contentManager.PopulateAspect <ContentItemMetadata>(contentItem);
var bodyAspect = _contentManager.PopulateAspect <BodyAspect>(contentItem);
var routes = contentItemMetadata.DisplayRouteValues;
if (context.Format == "rss")
{
var link = new XElement("link");
context.Response.Element.SetElementValue("title", contentItemMetadata.DisplayText);
context.Response.Element.Add(link);
if (bodyAspect.Body != null)
{
context.Response.Element.SetElementValue("description", bodyAspect.Body.ToString());
}
context.Response.Contextualize(contextualize =>
{
var request = contextualize.Url.ActionContext.HttpContext.Request;
var url = contextualize.Url.Action(routes["action"].ToString(), routes["controller"].ToString(), routes, request.Scheme);
link.Add(url);
});
}
else
{
context.Builder.AddProperty(context, null, "title", contentItemMetadata.DisplayText);
if (bodyAspect.Body != null)
{
context.Builder.AddProperty(context, null, "description", bodyAspect.Body.ToString());
}
context.Response.Contextualize(contextualize =>
{
var request = contextualize.Url.ActionContext.HttpContext.Request;
var url = contextualize.Url.Action(routes["action"].ToString(), routes["controller"].ToString(), routes, request.Scheme);
context.Builder.AddProperty(context, null, "link", url);
});
}
int itemsCount = contentItem.Content.ListPart?.FeedItemsCount ?? DefaultItemsCount;
IEnumerable <ContentItem> items;
items = itemsCount == 0
? Enumerable.Empty <ContentItem>()
: await _session.Query <ContentItem>()
.With <ContainedPartIndex>(x => x.ListContentItemId == contentItem.ContentItemId)
.With <ContentItemIndex>(x => x.Published)
.OrderByDescending(x => x.CreatedUtc)
.Take(itemsCount)
.ListAsync();
foreach (var item in items)
{
context.Builder.AddItem(context, item);
}
}
private void WriteFeed(object graph, ODataWriter writer, ODataSerializerContext writeContext)
{
IEnumerable enumerable = graph as IEnumerable; // Data to serialize
if (enumerable != null)
{
ODataFeed feed = new ODataFeed();
if (writeContext.EntitySet != null)
{
IEntitySetLinkBuilder linkBuilder = SerializerProvider.EdmModel.GetEntitySetLinkBuilder(writeContext.EntitySet);
FeedContext feedContext = new FeedContext
{
EntitySet = writeContext.EntitySet,
UrlHelper = writeContext.UrlHelper,
PathHandler = writeContext.PathHandler,
FeedInstance = graph
};
Uri feedSelfLink = linkBuilder.BuildFeedSelfLink(feedContext);
if (feedSelfLink != null)
{
feed.SetAnnotation(new AtomFeedMetadata()
{
SelfLink = new AtomLinkMetadata()
{
Relation = SelfLinkRelation, Href = feedSelfLink
}
});
}
}
// TODO: Bug 467590: remove the hardcoded feed id. Get support for it from the model builder ?
feed.Id = FeedNamespace + _edmCollectionType.FullName();
// If we have more OData format specific information apply it now.
ODataResult odataFeedAnnotations = graph as ODataResult;
if (odataFeedAnnotations != null)
{
feed.Count = odataFeedAnnotations.Count;
feed.NextPageLink = odataFeedAnnotations.NextPageLink;
}
else
{
object nextPageLinkPropertyValue;
HttpRequestMessage request = writeContext.Request;
if (request != null && request.Properties.TryGetValue(ODataQueryOptions.NextPageLinkPropertyKey, out nextPageLinkPropertyValue))
{
Uri nextPageLink = nextPageLinkPropertyValue as Uri;
if (nextPageLink != null)
{
feed.NextPageLink = nextPageLink;
}
}
}
writer.WriteStart(feed);
foreach (object entry in enumerable)
{
if (entry == null)
{
throw Error.NotSupported(SRResources.NullElementInCollection);
}
ODataSerializer entrySerializer = SerializerProvider.GetODataPayloadSerializer(entry.GetType());
if (entrySerializer == null)
{
throw Error.NotSupported(SRResources.TypeCannotBeSerialized, entry.GetType(), typeof(ODataMediaTypeFormatter).Name);
}
Contract.Assert(entrySerializer.ODataPayloadKind == ODataPayloadKind.Entry);
entrySerializer.WriteObjectInline(entry, writer, writeContext);
}
writer.WriteEnd();
}
}
/// <summary>
/// Create the <see cref="ODataFeed"/> to be written for the given feed instance.
/// </summary>
/// <param name="feedInstance">The instance representing the feed being written.</param>
/// <param name="writeContext">The serializer context.</param>
/// <returns>The created <see cref="ODataFeed"/> object.</returns>
public virtual ODataFeed CreateODataFeed(IEnumerable feedInstance, ODataSerializerContext writeContext)
{
ODataFeed feed = new ODataFeed();
if (writeContext.EntitySet != null)
{
IEdmModel model = writeContext.Model;
EntitySetLinkBuilderAnnotation linkBuilder = model.GetEntitySetLinkBuilder(writeContext.EntitySet);
FeedContext feedContext = new FeedContext
{
Request = writeContext.Request,
EntitySet = writeContext.EntitySet,
Url = writeContext.Url,
FeedInstance = feedInstance
};
Uri feedSelfLink = linkBuilder.BuildFeedSelfLink(feedContext);
if (feedSelfLink != null)
{
feed.SetAnnotation(new AtomFeedMetadata() { SelfLink = new AtomLinkMetadata() { Relation = "self", Href = feedSelfLink } });
}
}
// TODO: Bug 467590: remove the hardcoded feed id. Get support for it from the model builder ?
feed.Id = "http://schemas.datacontract.org/2004/07/" + EntityCollectionType.FullName();
// If we have more OData format specific information apply it now, only if we are the root feed.
if (!writeContext.IsNested)
{
PageResult odataFeedAnnotations = feedInstance as PageResult;
if (odataFeedAnnotations != null)
{
feed.Count = odataFeedAnnotations.Count;
feed.NextPageLink = odataFeedAnnotations.NextPageLink;
}
else if (writeContext.Request != null)
{
feed.NextPageLink = writeContext.Request.GetNextPageLink();
long? inlineCount = writeContext.Request.GetInlineCount();
if (inlineCount.HasValue)
{
feed.Count = inlineCount.Value;
}
}
}
return feed;
}
public UsersModel(FeedContext dbContext)
{
_dbContext = dbContext;
}
private void WriteFeed(object graph, ODataWriter writer, ODataSerializerContext writeContext)
{
IEnumerable enumerable = graph as IEnumerable; // Data to serialize
if (enumerable != null)
{
ODataFeed feed = new ODataFeed();
if (writeContext.EntitySet != null)
{
IEdmModel model = writeContext.Model;
EntitySetLinkBuilderAnnotation linkBuilder = model.GetEntitySetLinkBuilder(writeContext.EntitySet);
FeedContext feedContext = new FeedContext
{
Request = writeContext.Request,
EntitySet = writeContext.EntitySet,
Url = writeContext.Url,
FeedInstance = graph
};
Uri feedSelfLink = linkBuilder.BuildFeedSelfLink(feedContext);
if (feedSelfLink != null)
{
feed.SetAnnotation(new AtomFeedMetadata() { SelfLink = new AtomLinkMetadata() { Relation = "self", Href = feedSelfLink } });
}
}
// TODO: Bug 467590: remove the hardcoded feed id. Get support for it from the model builder ?
feed.Id = "http://schemas.datacontract.org/2004/07/" + _edmCollectionType.FullName();
// Compute and save the NextPageLink for JSON Light streaming support.
Uri nextPageLink = null;
// If we have more OData format specific information apply it now.
PageResult odataFeedAnnotations = graph as PageResult;
if (odataFeedAnnotations != null)
{
feed.Count = odataFeedAnnotations.Count;
nextPageLink = odataFeedAnnotations.NextPageLink;
}
else
{
nextPageLink = writeContext.NextPageLink;
long? inlineCount = writeContext.InlineCount;
if (inlineCount.HasValue)
{
feed.Count = inlineCount.Value;
}
}
writer.WriteStart(feed);
foreach (object entry in enumerable)
{
if (entry == null)
{
throw Error.NotSupported(SRResources.NullElementInCollection);
}
ODataSerializer entrySerializer = SerializerProvider.GetODataPayloadSerializer(writeContext.Model, entry.GetType());
if (entrySerializer == null)
{
throw Error.NotSupported(SRResources.TypeCannotBeSerialized, entry.GetType(), typeof(ODataMediaTypeFormatter).Name);
}
Contract.Assert(entrySerializer.ODataPayloadKind == ODataPayloadKind.Entry);
entrySerializer.WriteObjectInline(entry, writer, writeContext);
}
// Subtle and suprising behavior: If the NextPageLink property is set before calling WriteStart(feed),
// the next page link will be written early in a manner not compatible with streaming=true. Instead, if
// the next page link is not set when calling WriteStart(feed) but is instead set later on that feed
// object before calling WriteEnd(), the next page link will be written at the end, as required for
// streaming=true support.
if (nextPageLink != null)
{
feed.NextPageLink = nextPageLink;
}
writer.WriteEnd();
}
}
public async Task PopulateAsync(FeedContext context)
{
foreach (var feedItem in context.Response.Items.OfType <FeedItem <ContentItem> >())
{
var contentItem = feedItem.Item;
var contentItemMetadata = await _contentManager.PopulateAspectAsync <ContentItemMetadata>(contentItem);
var bodyAspect = await _contentManager.PopulateAspectAsync <BodyAspect>(contentItem);
var routes = contentItemMetadata.DisplayRouteValues;
// author is intentionally left empty as it could result in unwanted spam
// add to known formats
if (context.Format == "rss")
{
var link = new XElement("link");
var guid = new XElement("guid", new XAttribute("isPermaLink", "true"));
context.Response.Contextualize(contextualize =>
{
var request = contextualize.Url.ActionContext.HttpContext.Request;
var url = contextualize.Url.Action(routes["action"].ToString(), routes["controller"].ToString(), routes, request.Scheme);
link.Add(url);
guid.Add(url);
});
feedItem.Element.SetElementValue("title", contentItem.DisplayText);
feedItem.Element.Add(link);
feedItem.Element.SetElementValue("description", bodyAspect.Body?.ToString());
if (contentItem.PublishedUtc != null)
{
// RFC833
// The "R" or "r" standard format specifier represents a custom date and time format string that is defined by
// the DateTimeFormatInfo.RFC1123Pattern property. The pattern reflects a defined standard, and the property
// is read-only. Therefore, it is always the same, regardless of the culture used or the format provider supplied.
// The custom format string is "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'". When this standard format specifier is used,
// the formatting or parsing operation always uses the invariant culture.
feedItem.Element.SetElementValue("pubDate", contentItem.PublishedUtc.Value.ToString("r"));
}
feedItem.Element.Add(guid);
}
else
{
context.Response.Contextualize(contextualize =>
{
var request = contextualize.Url.ActionContext.HttpContext.Request;
var url = contextualize.Url.Action(routes["action"].ToString(), routes["controller"].ToString(), routes, request.Scheme);
context.Builder.AddProperty(context, feedItem, "link", url);
});
context.Builder.AddProperty(context, feedItem, "title", contentItem.DisplayText);
context.Builder.AddProperty(context, feedItem, "description", bodyAspect.Body.ToString());
if (contentItem.PublishedUtc != null)
{
context.Builder.AddProperty(context, feedItem, "published-date", contentItem.PublishedUtc.Value.ToString("r"));
}
}
}
}
public void Convention_GeneratesUri_ForActionBoundToCollectionOfEntity()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Customer>("Customers");
var action = builder.EntityType<Customer>().Collection.Action("MyAction").Returns<int>();
action.Parameter<string>("param");
IEdmModel model = builder.GetEdmModel();
// Act
HttpConfiguration configuration = new HttpConfiguration();
configuration.MapODataServiceRoute("odata", "odata", model);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost:123");
request.SetConfiguration(configuration);
request.ODataProperties().RouteName = "odata";
IEdmEntitySet customers = model.EntityContainer.FindEntitySet("Customers");
var entityContext = new FeedContext { EntitySetBase = customers, Request = request, Url = request.GetUrlHelper() };
// Assert
var edmAction = model.SchemaElements.OfType<IEdmAction>().First(f => f.Name == "MyAction");
Assert.NotNull(edmAction);
ActionLinkBuilder actionLinkBuilder = model.GetActionLinkBuilder(edmAction);
Uri link = actionLinkBuilder.BuildActionLink(entityContext);
Assert.Equal("http://localhost:123/odata/Customers/Default.MyAction", link.AbsoluteUri);
}
/// <summary>
/// Builds the function link for the given feed.
/// </summary>
/// <param name="context">An instance context wrapping the feed instance.</param>
/// <returns>The generated function link.</returns>
public virtual Uri BuildFunctionLink(FeedContext context)
{
return(BuildLink(context));
}
public void All()
{
var context = new FeedContext();
IUserRepository userRep = new UserRepository(context);
}
public CreateNewFeedUserProfileHandler(FeedContext feedContext)
{
_feedContext = feedContext;
}
public void Execute(FeedContext context)
{
var termParthId = context.ValueProvider.GetValue("term");
if (termParthId == null)
{
return;
}
var limitValue = context.ValueProvider.GetValue("limit");
var limit = 20;
if (limitValue != null)
{
limit = (int)limitValue.ConvertTo(typeof(int));
}
var containerId = (int)termParthId.ConvertTo(typeof(int));
var container = _contentManager.Get <TermPart>(containerId);
if (container == null)
{
return;
}
var inspector = new ItemInspector(container, _contentManager.GetItemMetadata(container));
if (context.Format == "rss")
{
var link = new XElement("link");
context.Response.Element.SetElementValue("title", inspector.Title);
context.Response.Element.Add(link);
context.Response.Element.SetElementValue("description", inspector.Description);
context.Response.Contextualize(requestContext => {
var urlHelper = new UrlHelper(requestContext);
var uriBuilder = new UriBuilder(urlHelper.MakeAbsolute("/"))
{
Path = urlHelper.RouteUrl(inspector.Link)
};
link.Add(uriBuilder.Uri.OriginalString);
});
}
else
{
context.Builder.AddProperty(context, null, "title", inspector.Title);
context.Builder.AddProperty(context, null, "description", inspector.Description);
context.Response.Contextualize(requestContext => {
var urlHelper = new UrlHelper(requestContext);
context.Builder.AddProperty(context, null, "link", urlHelper.RouteUrl(inspector.Link));
});
}
var items = _taxonomyService.GetContentItems(container, 0, limit);
foreach (var item in items)
{
// call item.ContentItem to force a cast to ContentItem, and
// thus use CorePartsFeedItemBuilder
context.Builder.AddItem(context, item.ContentItem);
}
}
public void Execute(FeedContext context)
{
var tagIdValue = context.ValueProvider.GetValue("tag");
if (tagIdValue == null)
{
return;
}
var limitValue = context.ValueProvider.GetValue("limit");
var limit = 20;
if (limitValue != null)
{
Int32.TryParse(Convert.ToString(limitValue), out limit);
}
limit = Math.Min(limit, 100);
var tagName = (string)tagIdValue.ConvertTo(typeof(string));
var tag = _tagService.GetTagByName(tagName);
if (tag == null)
{
return;
}
var displayRouteValues = new RouteValueDictionary {
{ "area", "Tomelt.Tags" },
{ "controller", "Home" },
{ "action", "Search" },
{ "tagName", tag.TagName }
};
if (context.Format == "rss")
{
var link = new XElement("link");
context.Response.Element.SetElementValue("title", tag.TagName);
context.Response.Element.Add(link);
context.Response.Element.SetElementValue("description", T("Content tagged with {0}", tag.TagName).ToString());
context.Response.Contextualize(requestContext => {
var urlHelper = new UrlHelper(requestContext);
var uriBuilder = new UriBuilder(urlHelper.MakeAbsolute("/"))
{
Path = urlHelper.RouteUrl(displayRouteValues)
};
link.Add(uriBuilder.Uri.OriginalString);
});
}
else
{
context.Builder.AddProperty(context, null, "title", tag.TagName);
context.Builder.AddProperty(context, null, "description", T("Content tagged with {0}", tag.TagName).ToString());
context.Response.Contextualize(requestContext => {
var urlHelper = new UrlHelper(requestContext);
context.Builder.AddProperty(context, null, "link", urlHelper.MakeAbsolute(urlHelper.RouteUrl(displayRouteValues)));
});
}
var items = _tagService.GetTaggedContentItems(tag.Id, 0, limit);
foreach (var item in items)
{
context.Builder.AddItem(context, item.ContentItem);
}
}
/// <summary>
/// Builds the procedure link for the given feed.
/// </summary>
/// <param name="context">An feed context wrapping the feed instance.</param>
/// <returns>The generated link.</returns>
public virtual Uri BuildLink(FeedContext context)
{
if (_feedLinkFactory == null)
{
return null;
}
return _feedLinkFactory(context);
}
public FeedRepository(FeedContext context) : base(context)
{
}
public SubscriptionRepository(FeedContext context) : base(context)
{
}
public void Execute(FeedContext context)
{
var containerIdValue = context.ValueProvider.GetValue("containerid");
if (containerIdValue == null)
{
return;
}
var limitValue = context.ValueProvider.GetValue("limit");
var limit = 20;
if (limitValue != null)
{
Int32.TryParse(Convert.ToString(limitValue), out limit);
}
limit = Math.Min(limit, 100);
var containerId = (int)containerIdValue.ConvertTo(typeof(int));
var container = _contentManager.Get(containerId);
if (container == null)
{
return;
}
var inspector = new ItemInspector(container, _contentManager.GetItemMetadata(container), _htmlFilters);
if (context.Format == "rss")
{
var link = new XElement("link");
context.Response.Element.SetElementValue("title", inspector.Title);
context.Response.Element.Add(link);
context.Response.Element.SetElementValue("description", inspector.Description);
context.Response.Contextualize(requestContext => {
var urlHelper = new UrlHelper(requestContext);
var uriBuilder = new UriBuilder(urlHelper.MakeAbsolute("/"))
{
Path = urlHelper.RouteUrl(inspector.Link)
};
link.Add(uriBuilder.Uri.OriginalString);
});
}
else
{
context.Builder.AddProperty(context, null, "title", inspector.Title);
context.Builder.AddProperty(context, null, "description", inspector.Description);
context.Response.Contextualize(requestContext => {
var urlHelper = new UrlHelper(requestContext);
context.Builder.AddProperty(context, null, "link", urlHelper.MakeAbsolute(urlHelper.RouteUrl(inspector.Link)));
});
}
var items = _contentManager.Query()
.Where <CommonPartRecord>(x => x.Container == container.Record)
.OrderByDescending(x => x.CreatedUtc)
.Slice(0, limit);
foreach (var item in items)
{
context.Builder.AddItem(context, item);
}
}
/// <summary>
/// Builds the function link for the given feed.
/// </summary>
/// <param name="context">An instance context wrapping the feed instance.</param>
/// <returns>The generated function link.</returns>
public virtual Uri BuildFunctionLink(FeedContext context)
{
return BuildLink(context);
}
