/// <summary> /// Returns the TooltipContents after proxying through the task system to allow developers to modify the output /// </summary> /// <param name="ds"></param> /// <param name="sender"></param> /// <param name="entity"> </param> /// <param name="htmlContent"></param> /// <param name="width"></param> /// <param name="height"></param> /// <returns></returns> public static TooltipContents CreateTooltipContentsViaTask(this INodeSelectorDataSource ds, object sender, TypedEntity entity, string htmlContent, int width = -1, int height = -1) { var args = new NodeSelectorTooltipEventArgs(entity, htmlContent) { Height = height, Width = width }; //launch task to modify the contents ds.FrameworkContext.TaskManager .ExecuteInContext( NodeSelectorTaskTriggers.GetTooltipContents, sender, new TaskEventArgs(ds.FrameworkContext, args)); return new TooltipContents(args.HtmlContents) { Height = args.Height, Width = args.Width }; }
public static TypedEntity MapTypedEntity(XElement xElement) { Mandate.ParameterNotNull(xElement, "xElement"); var attribs = new HashSet<TypedAttribute>(); var ordinal = 0; foreach (var childElement in xElement.Elements().Where(x => !x.HasAttributes)) { var typedAttribute = new TypedAttribute(new AttributeDefinition() { Alias = childElement.Name.LocalName, Name = childElement.Name.LocalName, Ordinal = ordinal, Id = HiveId.Empty }, childElement.Value) { Id = HiveId.Empty }; attribs.Add(typedAttribute); ordinal++; } var nodeId = (int)xElement.Attribute("id"); var returnValue = new TypedEntity { // TODO: Replace provider id with injected value inside UoWFactory Id = new HiveId("content", "r-xmlstore-01", new HiveIdValue(nodeId)) }; returnValue.Attributes.Reset(attribs); return returnValue; }
public void GetIdPath_Returns_In_Correct_Order_For_Entities() { //mock hive IReadonlyEntityRepositoryGroup<IContentStore> readonlyEntitySession; IReadonlySchemaRepositoryGroup<IContentStore> readonlySchemaSession; IEntityRepositoryGroup<IContentStore> entityRepository; ISchemaRepositoryGroup<IContentStore> schemaSession; var hive = MockHiveManager.GetManager().MockContentStore(out readonlyEntitySession, out readonlySchemaSession, out entityRepository, out schemaSession); var entity = new TypedEntity {Id = new HiveId(100)}; entityRepository.Get<TypedEntity>(Arg.Any<bool>(), Arg.Any<HiveId[]>()).Returns(new[] {entity}); entityRepository.GetAncestorRelations(new HiveId(100), FixedRelationTypes.DefaultRelationType) .Returns(new[] { new Relation(FixedRelationTypes.DefaultRelationType, new TypedEntity{Id = new HiveId(99)}, entity), new Relation(FixedRelationTypes.DefaultRelationType, new TypedEntity{Id = new HiveId(98)}, new TypedEntity{Id = new HiveId(99)}), new Relation(FixedRelationTypes.DefaultRelationType, new TypedEntity{Id = new HiveId(97)}, new TypedEntity{Id = new HiveId(98)}), }); using (var uow = hive.OpenWriter<IContentStore>()) { var path = uow.Repositories.GetEntityPath<TypedEntity>(new HiveId(100), FixedRelationTypes.DefaultRelationType); Assert.AreEqual(new HiveId(97), path.ElementAt(0)); Assert.AreEqual(new HiveId(98), path.ElementAt(1)); Assert.AreEqual(new HiveId(99), path.ElementAt(2)); Assert.AreEqual(new HiveId(100), path.ElementAt(3)); } }
public CompositeTypedEntity(TypedEntity entity) { Attributes.Clear(); entity.Attributes.ForEach(x => Attributes.Add(x)); RelationProxies.LazyLoadDelegate = entity.RelationProxies.LazyLoadDelegate; }
protected TypedEntity AddChildNode(TypedEntity parent, TypedEntity child, int sortOrder = 0) { using (var uow = this.HiveManager.OpenWriter<IContentStore>()) { parent.RelationProxies.EnlistChild(child, FixedRelationTypes.DefaultRelationType, sortOrder); uow.Repositories.AddOrUpdate(parent); uow.Repositories.AddOrUpdate(child); uow.Complete(); } return child; }
private TypedEntity CreateTypedEntity() { var entity = new TypedEntity { EntitySchema = new EntitySchema("schema", "Schema") { SchemaType = "Content", Id = new HiveId(Guid.NewGuid()) }, Id = new HiveId(Guid.NewGuid()), UtcCreated = DateTimeOffset.UtcNow, UtcModified = DateTimeOffset.UtcNow, UtcStatusChanged = DateTimeOffset.UtcNow }; SetupTypedEntity(entity); return entity; }
private void SetupTypedEntity(TypedEntity entity) { entity.EntitySchema.AttributeGroups.Add(new AttributeGroup("tab1", "Tab 1", 0)); entity.EntitySchema.AttributeGroups.Add(new AttributeGroup("tab2", "Tab 2", 1)); entity.EntitySchema.AttributeGroups.Add(new AttributeGroup("tab3", "Tab 3", 2)); entity.EntitySchema.AttributeDefinitions.Add(new AttributeDefinition("property1", "Property 1") { Description = "property1", AttributeGroup = entity.EntitySchema.AttributeGroups.ElementAt(0), AttributeType = _stringAttType }); entity.EntitySchema.AttributeDefinitions.Add(new AttributeDefinition("property2", "Property 2") { Description = "property2", AttributeGroup = entity.EntitySchema.AttributeGroups.ElementAt(1), AttributeType = _stringAttType }); entity.EntitySchema.AttributeDefinitions.Add(new AttributeDefinition("property3", "Property 3") { Description = "property3", AttributeGroup = entity.EntitySchema.AttributeGroups.ElementAt(2), AttributeType = _stringAttType }); entity.Attributes.Add(new TypedAttribute(entity.EntitySchema.AttributeDefinitions.ElementAt(0), "Value 1")); entity.Attributes.Add(new TypedAttribute(entity.EntitySchema.AttributeDefinitions.ElementAt(1), "Value 2")); entity.Attributes.Add(new TypedAttribute(entity.EntitySchema.AttributeDefinitions.ElementAt(2), "Value 3")); }
/// <summary> /// Gets the URL of the file in the upload field with the given property alias on the given TypedEntity at the specific size /// </summary> /// <param name="entity">The entity.</param> /// <param name="propertyAlias">The property alias.</param> /// <param name="size">The size (must be a prevalue on the upload property editor).</param> /// <returns></returns> public string GetMediaUrl(TypedEntity entity, string propertyAlias, int size) { return _urlHelper.GetMediaUrl(entity, propertyAlias, size); }
/// <summary> /// Gets the URL of the file in the first upload field found on the given TypedEntity at the specific size /// </summary> /// <param name="entity">The entity.</param> /// <param name="size">The size (must be a prevalue on the upload property editor).</param> /// <returns></returns> public string GetMediaUrl(TypedEntity entity, int size) { return _urlHelper.GetMediaUrl(entity, size); }
/// <summary> /// Gets the URL of the file in the first upload field found on the given TypedEntity /// </summary> /// <param name="entity">The entity.</param> /// <returns></returns> public string GetMediaUrl(TypedEntity entity) { return _urlHelper.GetMediaUrl(entity); }
public NodeSelectorTooltipEventArgs(TypedEntity entity, string htmlContents) { Entity = entity; HtmlContents = htmlContents; }
private static void ChangeValue(TypedAttribute nodeNameAttr, IQueryable<TypedEntity> parentQuery, TypedEntity item, string potentialValue, string valueKey, string existsSuffixCheck, string defaultSuffix, string dupeFormat) { var iterationCount = 0; var itExists = false; var originalValue = potentialValue; var valueCheck = potentialValue; do { iterationCount++; itExists = parentQuery.Any(x => x.InnerAttribute<string>(NodeNameAttributeDefinition.AliasValue, valueKey) == valueCheck && x.Id != item.Id); if (itExists) { // Don't concatenate (1) (2) etc. just use the original value plus a count valueCheck = originalValue + string.Format(dupeFormat, iterationCount); } } while (itExists); if (iterationCount > 1) { nodeNameAttr.Values[valueKey] = valueCheck; } //var exists = parentQuery // .Any(x => x.InnerAttribute<string>(NodeNameAttributeDefinition.AliasValue, valueKey) == potentialValue && x.Id != item.Id); //if (exists) //{ // // Get the count of items matching potentialValue + "(" // var dupeName = potentialValue + existsSuffixCheck; // var items = parentQuery // .Where( // x => // x.InnerAttribute<string>(NodeNameAttributeDefinition.AliasValue, valueKey).StartsWith(dupeName) && // x.Id != item.Id) // .ToList(); // var itemsDebug = items.Select(x => new // { // x.Id, // x.Attributes, // ValueKey = x.InnerAttribute<string>(NodeNameAttributeDefinition.AliasValue, valueKey) // }).ToArray(); // var count = items.Count; // if (count == 0) // { // potentialValue = potentialValue + defaultSuffix; // } // else // { // var newCount = (count + 1); // var format = string.Format(dupeFormat, newCount); // potentialValue = potentialValue + format; // } //} //nodeNameAttr.Values[valueKey] = potentialValue; }
/// <summary> /// Creates a new RedirectToUmbracoResult /// </summary> /// <param name="pageEntity"></param> public RedirectToUmbracoPageResult(TypedEntity pageEntity) : this(pageEntity, DependencyResolver.Current.GetService<IRoutableRequestContext>()) { }
/// <summary> /// Redirects to the Umbraco page with the given id /// </summary> /// <param name="pageEntity"></param> /// <returns></returns> protected RedirectToUmbracoPageResult RedirectToUmbracoPage(TypedEntity pageEntity) { return new RedirectToUmbracoPageResult(pageEntity, RoutableRequestContext); }
public EntityRouteResult(TypedEntity entity, EntityRouteStatus status) { Status = status; RoutableEntity = entity; }
protected virtual string GetTreeNodeAlias(TypedEntity x) { var toReturn = string.Empty; var nodeName = x.Attributes.FirstOrDefault(y => y.AttributeDefinition.Alias == NodeNameAttributeDefinition.AliasValue); if (nodeName != null) toReturn = nodeName.GetValueAsString("Name"); if (string.IsNullOrEmpty(toReturn)) { if (x.EntitySchema != null) { toReturn = "[Unnamed {0}]".InvariantFormat(string.IsNullOrEmpty(x.EntitySchema.Name) ? x.EntitySchema.Alias : (string)x.EntitySchema.Name); } else { toReturn = "[Unnamed, untyped]"; } } return toReturn; }
protected virtual TreeNode ConvertEntityToTreeNode(TypedEntity entity, HiveId parentId, FormCollection queryStrings, IReadonlyGroupUnit<IContentStore> uow) { var treeNode = CreateTreeNode(entity.Id, queryStrings, GetTreeNodeAlias(entity), GetEditorUrl(entity.Id, queryStrings), uow.Repositories.GetChildRelations(entity.Id, FixedRelationTypes.DefaultRelationType).Any()); var icon = entity.EntitySchema.GetXmlConfigProperty("icon"); if (!string.IsNullOrEmpty(icon)) { if (icon.Contains(".")) { //need to get the path //TODO: Load this in from the right hive provider --Aaron treeNode.Icon = Url.Content( BackOfficeRequestContext.Application.Settings.UmbracoFolders. DocTypeIconFolder + "/" + icon); } else { treeNode.Icon = icon; } } //TODO: This is going to make a few calls to the db for each node, is there a better way? var snapshot = uow.Repositories.Revisions.GetLatestSnapshot<TypedEntity>(entity.Id); if (!snapshot.IsPublished()) treeNode.Style.DimNode(); else if (snapshot.IsPublishPending()) treeNode.Style.HighlightNode(); else { if (BackOfficeRequestContext.Application.Security.PublicAccess.IsProtected(entity.Id)) { treeNode.Style.SecureNode(); } } //now, check if we're in the recycle bin, if so we need to filter the nodes based on the user's start node //and where the nodes originated from. if (parentId == RecycleBinId) { //TODO: Hopefully there's a better way of looking all this up as this will make quite a few queries as well... var recycledRelation = uow.Repositories.GetParentRelations(entity, FixedRelationTypes.RecycledRelationType); var allowed = true; foreach (var r in recycledRelation) { //get the path of the original parent var path = uow.Repositories.GetEntityPath(r.SourceId, FixedRelationTypes.DefaultRelationType).ToList(); //append the current node to the path to create the full original path path.Add(r.DestinationId); //BUG: This currently will always be false because NH is not returning the correct Ids for 'system' ids. // so we've commented out the return null below until fixed //now we can determine if this node can be viewed if (!path.Contains(RootNodeId, new HiveIdComparer(true))) { allowed = false; } } //if (!allowed) // return null; } //TODO: Check if node has been secured AddQueryStringsToAdditionalData(treeNode, queryStrings); return treeNode; }
public abstract HiveId StartNodeId(IBackOfficeRequestContext requestContext, TypedEntity currentNode, TypedEntity rootNode);
/// <summary> /// Gets the URL for the given entity. /// </summary> /// <param name="entity">The entity.</param> /// <returns></returns> public string GetUrl(TypedEntity entity) { return _requestContext.RoutingEngine.GetUrl(entity.Id); }
private void AssertFoundEntityByUrl(TypedEntity domainRoot, Uri fullUrlIncludingDomain) { var entityByUrl = GetEngine(new Uri("http://hello.com")).FindEntityByUrl(fullUrlIncludingDomain, null); Assert.NotNull(entityByUrl); Assert.That(entityByUrl.Status, Is.EqualTo(EntityRouteStatus.SuccessWithoutHostname)); Assert.NotNull(entityByUrl.RoutableEntity); Assert.AreEqual(domainRoot.Id, entityByUrl.RoutableEntity.Id); }
public static TypedEntity CreateTypedEntity(EntitySchema schema, TypedAttribute[] attribs, bool assignId = false) { var entity = new TypedEntity { EntitySchema = schema }; entity.Attributes.Reset(attribs); if (assignId) entity.Id = new HiveId(Guid.NewGuid()); return entity; }
public void Initialize() { //Seup permissions _permissions = new Permission[] { new SavePermission(), new PublishPermission(), new HostnamesPermission(), new CopyPermission(), new MovePermission(), new BackOfficeAccessPermission() } .Select(x => new Lazy<Permission, PermissionMetadata>(() => x, new PermissionMetadata(new Dictionary<string, object> { {"Id", x.Id}, {"Name", x.Name}, {"Type", x.Type} }))); //Setup user groups _userGroups = new List<UserGroup> { new UserGroup { Id = new HiveId("9DB63B97-4C8F-489C-98C7-017DC6AD869A"), Name = "Administrator" }, new UserGroup { Id = new HiveId("F61E4B62-513B-4858-91BF-D873401AD3CA"), Name = "Editor" }, new UserGroup { Id = new HiveId("8B65EF91-D49B-43A3-AFD9-6A47D5341B7D"), Name = "Writter" } }; // Setup user id _userId = new HiveId("857BD0F6-49DC-4378-84C1-6CD8AE14301D"); //Setup content nodes _systemRootNode = new TypedEntity { Id = FixedHiveIds.SystemRoot }; _childContentNode = new TypedEntity { Id = new HiveId("00E55027-402F-41CF-9052-B8D8F3DBCD76") }; //Setup relations var systemRootPermissionRelations = new List<RelationById> { new RelationById( _userGroups.First().Id, _systemRootNode.Id, FixedRelationTypes.PermissionRelationType, 0, new RelationMetaDatum(FixedPermissionIds.BackOfficeAccess, PermissionStatus.Allow.ToString()), new RelationMetaDatum(FixedPermissionIds.Copy, PermissionStatus.Allow.ToString()), new RelationMetaDatum(FixedPermissionIds.Save, PermissionStatus.Allow.ToString()), new RelationMetaDatum(FixedPermissionIds.Publish, PermissionStatus.Deny.ToString()), new RelationMetaDatum(FixedPermissionIds.Hostnames, PermissionStatus.Inherit.ToString()), new RelationMetaDatum(FixedPermissionIds.Move, PermissionStatus.Inherit.ToString()) ), new RelationById( _userGroups.Last().Id, _systemRootNode.Id, FixedRelationTypes.PermissionRelationType, 0, new RelationMetaDatum(FixedPermissionIds.Copy, PermissionStatus.Allow.ToString()), new RelationMetaDatum(FixedPermissionIds.Save, PermissionStatus.Deny.ToString()), new RelationMetaDatum(FixedPermissionIds.Publish, PermissionStatus.Allow.ToString()), new RelationMetaDatum(FixedPermissionIds.Hostnames, PermissionStatus.Allow.ToString()), new RelationMetaDatum(FixedPermissionIds.Move, PermissionStatus.Inherit.ToString()) ) }; var childContentNodePermissionRelations = new List<RelationById> { new RelationById( _userGroups.Skip(1).First().Id, _childContentNode.Id, FixedRelationTypes.PermissionRelationType, 0, new RelationMetaDatum(FixedPermissionIds.BackOfficeAccess, PermissionStatus.Deny.ToString()), // Back office access is not an entity action so this should get ignored new RelationMetaDatum(FixedPermissionIds.Copy, PermissionStatus.Allow.ToString()), new RelationMetaDatum(FixedPermissionIds.Save, PermissionStatus.Deny.ToString()), new RelationMetaDatum(FixedPermissionIds.Publish, PermissionStatus.Allow.ToString()), new RelationMetaDatum(FixedPermissionIds.Hostnames, PermissionStatus.Allow.ToString()), new RelationMetaDatum(FixedPermissionIds.Move, PermissionStatus.Inherit.ToString()) ) }; var childContentNodeAncestorRelations = new List<RelationById> { new RelationById( _systemRootNode.Id, _childContentNode.Id, FixedRelationTypes.DefaultRelationType, 0) }; var userGroupRelations = new List<RelationById> { new RelationById( _userGroups.First().Id, _userId, FixedRelationTypes.UserGroupRelationType, 0), new RelationById( _userGroups.Skip(1).First().Id, _userId, FixedRelationTypes.UserGroupRelationType, 0), new RelationById( _userGroups.Last().Id, _userId, FixedRelationTypes.UserGroupRelationType, 0) }; _membershipService = Substitute.For<IMembershipService<User>>(); _membershipService.GetById(_userId, true).Returns(new User { Id = _userId, Username = "******", Groups = _userGroups.Select(x => x.Id).ToArray() }); //Setup hive _hive = MockHiveManager.GetManager() .MockContentStore(out _readonlyContentStoreSession, out _readonlyContentStoreSchemaSession, out _contentStoreRepository, out _contentStoreSchemaRepository) .MockSecurityStore(out _readonlySecurityStoreSession, out _readonlySecurityStoreSchemaSession, out _securityStoreRepository, out _securityStoreSchemaRepository); //Setup content store _readonlyContentStoreSession.Exists<TypedEntity>(HiveId.Empty).ReturnsForAnyArgs(true); _readonlySecurityStoreSession .Get<UserGroup>(true, Arg.Any<HiveId[]>()) .Returns(MockHiveManager.MockReturnForGet<UserGroup>()); _readonlyContentStoreSession .Get<UserGroup>(true, Arg.Any<HiveId[]>()) .Returns(MockHiveManager.MockReturnForGet<UserGroup>()); _securityStoreRepository .Get<UserGroup>(true, Arg.Any<HiveId[]>()) .Returns(MockHiveManager.MockReturnForGet<UserGroup>()); _contentStoreRepository .Get<UserGroup>(true, Arg.Any<HiveId[]>()) .Returns(MockHiveManager.MockReturnForGet<UserGroup>()); //Setup security store _readonlySecurityStoreSession.GetParentRelations(_systemRootNode.Id, FixedRelationTypes.PermissionRelationType).Returns(systemRootPermissionRelations); _readonlySecurityStoreSession.GetParentRelations(_childContentNode.Id, FixedRelationTypes.PermissionRelationType).Returns(childContentNodePermissionRelations); _readonlySecurityStoreSession.GetAncestorRelations(_childContentNode.Id, FixedRelationTypes.DefaultRelationType).Returns(childContentNodeAncestorRelations); _readonlySecurityStoreSession.GetParentRelations(_userId, FixedRelationTypes.UserGroupRelationType).Returns(userGroupRelations); _readonlySecurityStoreSession.Query<UserGroup>().Returns(x => Enumerable.Repeat(new UserGroup() { Name = "Administrator" }, 1).AsQueryable()); }
public abstract bool IsMatch(IBackOfficeRequestContext requestContext, TypedEntity entity);
/// <summary> /// Gets the URL of the file in the upload field with the given property alias on the given TypedEntity at the specific size /// </summary> /// <param name="url">The URL.</param> /// <param name="entity">The entity.</param> /// <param name="propertyAlias">The property alias.</param> /// <param name="size">The size (must be a prevalue on the upload property editor).</param> /// <returns></returns> public static string GetMediaUrl(this UrlHelper url, TypedEntity entity, string propertyAlias, int size) { //TODO: There is a lot of duplication between this and the MediaProxyController (with slight differences). Need to find a way to reuse code. var appContext = DependencyResolver.Current.GetService<IUmbracoApplicationContext>(); using (var securityUow = appContext.Hive.OpenReader<ISecurityStore>()) { // Check to see if anonymous view is allowed var anonymousViewAllowed = !appContext.Security.PublicAccess.IsProtected(entity.Id); // Get upload property var prop = propertyAlias.IsNullOrWhiteSpace() ? entity.Attributes.SingleOrDefault(x => x.AttributeDefinition.AttributeType.RenderTypeProvider.InvariantEquals(CorePluginConstants.FileUploadPropertyEditorId)) : entity.Attributes.SingleOrDefault(x => x.AttributeDefinition.Alias == propertyAlias); if (prop == null || !prop.Values.ContainsKey("MediaId")) return null; // Couldn't find property so return null var mediaId = prop.Values["MediaId"].ToString(); var fileId = new HiveId(prop.Values["Value"].ToString()); // Get the file using (var fileUow = appContext.Hive.OpenReader<IFileStore>(fileId.ToUri())) { var file = fileUow.Repositories.Get<File>(fileId); if (file == null) return null; // Couldn't find file so return null // Fetch the thumbnail if (size > 0) { var relation = fileUow.Repositories.GetLazyChildRelations(fileId, FixedRelationTypes.ThumbnailRelationType) .SingleOrDefault(x => x.MetaData.Single(y => y.Key == "size").Value == size.ToString()); file = (relation != null && relation.Destination != null) ? (File)relation.Destination : null; } if (file == null) return null; // Couldn't find file so return null if (anonymousViewAllowed && !file.PublicUrl.StartsWith("~/App_Data/")) // Don't proxy { return url.Content(file.PublicUrl); } else // Proxy { //NOTE: THIS IS TEMPORARY CODE UNTIL MEMBER PERMISSIONS IS DONE //if (anonymousViewAllowed) //{ // // If they are anonymous, but media happens to be in app_data folder proxy // return url.Action("Proxy", "MediaProxy", new { area = "", propertyAlias = prop.AttributeDefinition.Alias, mediaId, size, fileName = file.Name }); //} //return null; // Check permissions //var authAttr = new UmbracoAuthorizeAttribute {AllowAnonymous = true, Permissions = new [] { FixedPermissionIds.View }}; //var authorized = authAttr.IsAuthorized(url.RequestContext.HttpContext, entity.Id); //if (!authorized) // return null; // Not authorized so return null var member = appContext.Security.Members.GetCurrent(); if (member == null || !appContext.Security.PublicAccess.GetPublicAccessStatus(member.Id, entity.Id).CanAccess) { // Member can't access, but check to see if logged in identiy is a User, if so, just allow access var wrapper = new HttpContextWrapper(HttpContext.Current); var ticket = wrapper.GetUmbracoAuthTicket(); if (ticket == null || ticket.Expired) { return null; } } return url.Action("Proxy", "MediaProxy", new { area = "", propertyAlias = prop.AttributeDefinition.Alias, mediaId, size, fileName = file.Name }); } } } }
/// <summary> /// Creates a new RedirectToUmbracoResult /// </summary> /// <param name="pageEntity"></param> /// <param name="routableRequestContext"></param> public RedirectToUmbracoPageResult(TypedEntity pageEntity, IRoutableRequestContext routableRequestContext) { _pageEntity = pageEntity; _pageId = pageEntity.Id; _routableRequestContext = routableRequestContext; }
public UrlResolutionResult[] GetAllUrlsForEntity(TypedEntity entity) { return new UrlResolutionResult[0]; }
private TypedEntity SetupTestStructure( out TypedEntity multiGrandChild, out TypedEntity firstChild, out TypedEntity firstGrandChild, out TypedEntity secondChild) { var domainRoot = CreateNewEntity(); firstChild = CreateNewEntity(); secondChild = CreateNewEntity(); firstGrandChild = CreateNewEntity(); multiGrandChild = CreateNewEntity(); using (var writer = GetHive().Create<IContentStore>()) { domainRoot.Attributes[NodeNameAttributeDefinition.AliasValue].Values["UrlName"] = "homepage"; firstChild.Attributes[NodeNameAttributeDefinition.AliasValue].Values["UrlName"] = "first-child"; firstGrandChild.Attributes[NodeNameAttributeDefinition.AliasValue].Values["UrlName"] = "first-grandchild"; multiGrandChild.Attributes[NodeNameAttributeDefinition.AliasValue].Values["UrlName"] = "multi-grandchild"; secondChild.Attributes[NodeNameAttributeDefinition.AliasValue].Values["UrlName"] = "second-child"; writer.Repositories.AddOrUpdate(domainRoot); writer.Repositories.AddOrUpdate(firstChild); writer.Repositories.AddOrUpdate(firstGrandChild); writer.Repositories.AddOrUpdate(multiGrandChild); writer.Repositories.AddOrUpdate(secondChild); writer.Repositories.AddRelation( FixedHiveIds.ContentVirtualRoot, domainRoot.Id, FixedRelationTypes.DefaultRelationType, 0); writer.Repositories.AddRelation(domainRoot, firstChild, FixedRelationTypes.DefaultRelationType, 0); writer.Repositories.AddRelation(firstChild, firstGrandChild, FixedRelationTypes.DefaultRelationType, 0); writer.Repositories.AddRelation(firstChild, multiGrandChild, FixedRelationTypes.DefaultRelationType, 0); writer.Repositories.AddRelation(secondChild, multiGrandChild, FixedRelationTypes.DefaultRelationType, 0); writer.Repositories.AddRelation(domainRoot, secondChild, FixedRelationTypes.DefaultRelationType, 0); var hostname = new Hostname { Name = "hello.com" }; writer.Repositories.AddOrUpdate(hostname); writer.Repositories.AddRelation(domainRoot.Id, hostname.Id, FixedRelationTypes.HostnameRelationType, 0); writer.Complete(); } return domainRoot; }
private void AddDuplicateEntityTestData(TypedEntity existingEntity) { using (var uow = this.Setup.ProviderSetup.UnitFactory.Create()) { // Save another item so that we should have two matching for the same attribute value existingEntity.Id = HiveId.Empty; // Add another attribute to this "clone" that should correctly then match a Single query for testing var existingDef = existingEntity.EntitySchema.AttributeDefinitions[0]; var newDef = HiveModelCreationHelper.CreateAttributeDefinition( "uniqueAliasForQuerying", "", "", existingDef.AttributeType, existingDef.AttributeGroup, true); existingEntity.EntitySchema.AttributeDefinitions.Add(newDef); existingEntity.Attributes.Add(new TypedAttribute(newDef, "my-new-value")); uow.EntityRepository.AddOrUpdate(existingEntity); uow.Complete(); } }
private void AddRevision(TypedEntity entity, RevisionStatusType revisionStatusType) { using (var uow = GroupUnitFactory.Create()) { // Make a new revision that is published var revision = new Revision<TypedEntity>(entity); revision.MetaData.StatusType = revisionStatusType; uow.Repositories.Revisions.AddOrUpdate(revision); uow.Complete(); } }
public UrlResolutionResult GetUrlForEntity(TypedEntity entity) { return new UrlResolutionResult("/this-is-a-test", UrlResolutionStatus.SuccessWithoutHostname); }