public ActionResult FeedPost(FeedPostModel model)
        {
            //check if user is logged in
            if (User.Identity.IsAuthenticated)
            {
                //check if the feed is okay
                if (String.IsNullOrEmpty(model.feedContent))
                {
                    return RedirectToCurrentUmbracoPage();
                }

                //get the username of the poster
                int userId = _memberService.GetByUsername(User.Identity.Name).Id;

                //create a new content
                var feed = _contentService.CreateContent(
                    "feed",
                    1084,
                    "feed", userId);
                //store the value
                feed.SetValue("feedContent", model.feedContent);
                //published it and save with the content service
                _contentService.SaveAndPublishWithStatus(feed);

                //create a relationship between the posting user and the feed, and save it
                var relationType = _relationService.GetRelationTypeByAlias("feedToUser");
                var nRelation = new Relation(feed.Id, userId, relationType);
                _relationService.Save(nRelation);
            }

            return RedirectToCurrentUmbracoPage();
        }
        public ActionResult CommentPost(CommentPostModel model)
        {
            if (User.Identity.IsAuthenticated)
            {
                if (String.IsNullOrEmpty(model.commentContent))
                {
                    return RedirectToCurrentUmbracoPage();
                }
                if (model.feedToCommentOn == 0)
                {
                    return RedirectToCurrentUmbracoPage();
                }

                int userId = _memberService.GetByUsername(User.Identity.Name).Id;

                //add content
                var commentToStore = _contentService.CreateContent(
                    "comment",
                    model.feedToCommentOn,
                    "comment", userId);

                commentToStore.SetValue("commentContent", model.commentContent);

                _contentService.SaveAndPublishWithStatus(commentToStore);

                //create the relation betwen the feed and the member
                var relationType = _relationService.GetRelationTypeByAlias("commentToMember");
                var nRelation = new Relation(commentToStore.Id, userId, relationType);
                _relationService.Save(nRelation);
            }

            return RedirectToCurrentUmbracoPage();
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Finds all published Content for this site and adds relations to Media
        /// </summary>
        private void AddMediaUsageForAllContent()
        {
            // RelationService
            IRelationService rs = ApplicationContext.Current.Services.RelationService;

            // RelationType
            IRelationType relationType = rs.GetRelationTypeByAlias(Constants.RelationTypeAlias);

            // Remove all existing relations
            if (rs.HasRelations(relationType))
            {
                rs.DeleteRelationsOfType(relationType);
            }

            // Relate Media in all Published Documents
            foreach (var contentNodeId in FindAllContent())
            {
                foreach (var mediaNodeId in FindMedia(contentNodeId))
                {
                    Relation relation = new Relation(mediaNodeId, contentNodeId, relationType);
                    rs.Save(relation);

                    LogHelper.Debug<MediaContentUsage>(String.Format("Saved relation: ParentId {0} ChildId {1}", relation.ParentId, relation.ChildId));
                }
            }
        }
        public static Relation MakeNew(int ParentId, int ChildId, RelationType RelType, string Comment)
        {
            var relation = new Umbraco.Core.Models.Relation(ParentId, ChildId, RelType.RelationTypeEntity)
            {
                Comment = Comment
            };

            ApplicationContext.Current.Services.RelationService.Save(relation);
            return(new Relation(relation));
        }
        public void Can_Perform_Add_On_RelationRepository()
        {
            // Arrange
            var provider = new PetaPocoUnitOfWorkProvider();
            var unitOfWork = provider.GetUnitOfWork();
            var repositoryType = new RelationTypeRepository(unitOfWork);
            var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType);

            // Act
            var relationType = repositoryType.Get(1);
            var relation = new Relation(1047, 1048, relationType);
            repository.AddOrUpdate(relation);
            unitOfWork.Commit();

            // Assert
            Assert.That(relation, Is.Not.Null);
            Assert.That(relation.HasIdentity, Is.True);
        }
        public void Can_Perform_Add_On_RelationRepository()
        {
            // Arrange
            var provider = new PetaPocoUnitOfWorkProvider();
            var unitOfWork = provider.GetUnitOfWork();
            RelationTypeRepository repositoryType;
            using (var repository = CreateRepository(unitOfWork, out repositoryType))
            {

                // Act
                var relationType = repositoryType.Get(1);
                var relation = new Relation(NodeDto.NodeIdSeed + 2, NodeDto.NodeIdSeed + 3, relationType);
                repository.AddOrUpdate(relation);
                unitOfWork.Commit();

                // Assert
                Assert.That(relation, Is.Not.Null);
                Assert.That(relation.HasIdentity, Is.True);
            }
        }
        public void CreateTestData()
        {
            var relateContent = new RelationType(new Guid(Constants.ObjectTypes.Document), new Guid("C66BA18E-EAF3-4CFF-8A22-41B16D66A972"), "relateContentOnCopy") { IsBidirectional = true, Name = "Relate Content on Copy" };
            var relateContentType = new RelationType(new Guid(Constants.ObjectTypes.DocumentType), new Guid("A2CB7800-F571-4787-9638-BC48539A0EFB"), "relateContentTypeOnCopy") { IsBidirectional = true, Name = "Relate ContentType on Copy" };

            var provider = new PetaPocoUnitOfWorkProvider();
            var unitOfWork = provider.GetUnitOfWork();
            var relationTypeRepository = new RelationTypeRepository(unitOfWork);
            var relationRepository = new RelationRepository(unitOfWork, NullCacheProvider.Current, relationTypeRepository);

            relationTypeRepository.AddOrUpdate(relateContent);
            relationTypeRepository.AddOrUpdate(relateContentType);
            unitOfWork.Commit();

            //Create and Save ContentType "umbTextpage" -> 1045
            ContentType contentType = MockedContentTypes.CreateSimpleContentType("umbTextpage", "Textpage");
            ServiceContext.ContentTypeService.Save(contentType);

            //Create and Save Content "Homepage" based on "umbTextpage" -> 1046
            Content textpage = MockedContent.CreateSimpleContent(contentType);
            ServiceContext.ContentService.Save(textpage, 0);

            //Create and Save Content "Text Page 1" based on "umbTextpage" -> 1047
            Content subpage = MockedContent.CreateSimpleContent(contentType, "Text Page 1", textpage.Id);
            ServiceContext.ContentService.Save(subpage, 0);

            //Create and Save Content "Text Page 1" based on "umbTextpage" -> 1048
            Content subpage2 = MockedContent.CreateSimpleContent(contentType, "Text Page 2", textpage.Id);
            ServiceContext.ContentService.Save(subpage2, 0);

            var relation = new Relation(textpage.Id, subpage.Id, relateContent) { Comment = string.Empty };
            var relation2 = new Relation(textpage.Id, subpage2.Id, relateContent) { Comment = string.Empty };
            relationRepository.AddOrUpdate(relation);
            relationRepository.AddOrUpdate(relation2);
            unitOfWork.Commit();
        }
Ejemplo n.º 8
0
        /// <summary>
        /// Copies an <see cref="IContent"/> object by creating a new Content object of the same type and copies all data from the current 
        /// to the new copy which is returned.
        /// </summary>
        /// <param name="content">The <see cref="IContent"/> to copy</param>
        /// <param name="parentId">Id of the Content's new Parent</param>
        /// <param name="relateToOriginal">Boolean indicating whether the copy should be related to the original</param>
        /// <param name="userId">Optional Id of the User copying the Content</param>
        /// <returns>The newly created <see cref="IContent"/> object</returns>
        public IContent Copy(IContent content, int parentId, bool relateToOriginal, int userId = 0)
        {
            using (new WriteLock(Locker))
            {
                var copy = ((Content)content).Clone();
                copy.ParentId = parentId;

                // A copy should never be set to published automatically even if the original was.
                copy.ChangePublishedState(PublishedState.Unpublished);

                if (Copying.IsRaisedEventCancelled(new CopyEventArgs<IContent>(content, copy, parentId), this))
                    return null;

                var uow = _uowProvider.GetUnitOfWork();
                using (var repository = _repositoryFactory.CreateContentRepository(uow))
                {
                    // Update the create author and last edit author
                    copy.CreatorId = userId;
                    copy.WriterId = userId;

                    repository.AddOrUpdate(copy);
                    uow.Commit();

                    //Special case for the Upload DataType
                    var uploadDataTypeId = new Guid(Constants.PropertyEditors.UploadField);
                    if (content.Properties.Any(x => x.PropertyType.DataTypeId == uploadDataTypeId))
                    {
                        bool isUpdated = false;
                        var fs = FileSystemProviderManager.Current.GetFileSystemProvider<MediaFileSystem>();

                        //Loop through properties to check if the content contains media that should be deleted
                        foreach (var property in content.Properties.Where(x => x.PropertyType.DataTypeId == uploadDataTypeId
                                                                               && string.IsNullOrEmpty(x.Value.ToString()) == false))
                        {
                            if (fs.FileExists(IOHelper.MapPath(property.Value.ToString())))
                            {
                                var currentPath = fs.GetRelativePath(property.Value.ToString());
                                var propertyId = copy.Properties.First(x => x.Alias == property.Alias).Id;
                                var newPath = fs.GetRelativePath(propertyId, System.IO.Path.GetFileName(currentPath));

                                fs.CopyFile(currentPath, newPath);
                                copy.SetValue(property.Alias, fs.GetUrl(newPath));

                                //Copy thumbnails
                                foreach (var thumbPath in fs.GetThumbnails(currentPath))
                                {
                                    var newThumbPath = fs.GetRelativePath(propertyId, System.IO.Path.GetFileName(thumbPath));
                                    fs.CopyFile(thumbPath, newThumbPath);
                                }
                                isUpdated = true;
                            }
                        }

                        if (isUpdated)
                        {
                            repository.AddOrUpdate(copy);
                            uow.Commit();
                        }
                    }

                    //Special case for the Tags DataType
                    var tagsDataTypeId = new Guid(Constants.PropertyEditors.Tags);
                    if (content.Properties.Any(x => x.PropertyType.DataTypeId == tagsDataTypeId))
                    {
                        var tags = uow.Database.Fetch<TagRelationshipDto>("WHERE nodeId = @Id", new { Id = content.Id });
                        foreach (var tag in tags)
                        {
                            uow.Database.Insert(new TagRelationshipDto { NodeId = copy.Id, TagId = tag.TagId });
                        }
                    }
                }

                //NOTE This 'Relation' part should eventually be delegated to a RelationService
                if (relateToOriginal)
                {
                    RelationType relationType = null;
                    using (var relationTypeRepository = _repositoryFactory.CreateRelationTypeRepository(uow))
                    {
                        relationType = relationTypeRepository.Get(1);
                    }

                    using (var relationRepository = _repositoryFactory.CreateRelationRepository(uow))
                    {
                        var relation = new Relation(content.Id, copy.Id, relationType);
                        relationRepository.AddOrUpdate(relation);
                        uow.Commit();
                    }

                    Audit.Add(AuditTypes.Copy,
                              string.Format("Copied content with Id: '{0}' related to original content with Id: '{1}'",
                                            copy.Id, content.Id), copy.WriterId, copy.Id);
                }

                //Look for children and copy those as well
                var children = GetChildren(content.Id);
                foreach (var child in children)
                {
                    Copy(child, copy.Id, relateToOriginal, userId);
                }

                Copied.RaiseEvent(new CopyEventArgs<IContent>(content, copy, false, parentId), this);

                Audit.Add(AuditTypes.Copy, "Copy Content performed by user", content.WriterId, content.Id);


                //TODO: Don't think we need this here because cache should be cleared by the event listeners
                // and the correct ICacheRefreshers!?
                RuntimeCacheProvider.Current.Clear();

                return copy;
            }
        }
Ejemplo n.º 9
0
 /// <summary>
 /// Deletes a <see cref="Relation"/>
 /// </summary>
 /// <param name="relation">Relation to Delete</param>
 public void Delete(Relation relation)
 {
     var uow = _uowProvider.GetUnitOfWork();
     using (var repository = _repositoryFactory.CreateRelationRepository(uow))
     {
         repository.Delete(relation);
         uow.Commit();
     }
 }
Ejemplo n.º 10
0
        /// <summary>
        /// Relates two objects that are based on the <see cref="IUmbracoEntity"/> interface.
        /// </summary>
        /// <param name="parent">Parent entity</param>
        /// <param name="child">Child entity</param>
        /// <param name="relationTypeAlias">Alias of the type of relation to create</param>
        /// <returns>The created <see cref="Relation"/></returns>
        public Relation Relate(IUmbracoEntity parent, IUmbracoEntity child, string relationTypeAlias)
        {
            var relationType = GetRelationTypeByAlias(relationTypeAlias);
            if(relationType == null || string.IsNullOrEmpty(relationType.Alias))
                throw new ArgumentNullException(string.Format("No RelationType with Alias '{0}' exists.", relationTypeAlias));

            var relation = new Relation(parent.Id, child.Id, relationType);
            var uow = _uowProvider.GetUnitOfWork();
            using (var repository = _repositoryFactory.CreateRelationRepository(uow))
            {
                repository.AddOrUpdate(relation);
                uow.Commit();

                return relation;
            }
        }
Ejemplo n.º 11
0
        /// <summary>
        /// Gets the Parent and Child objects from a Relation as a <see cref="Tuple"/>"/> with <see cref="IUmbracoEntity"/>.
        /// </summary>
        /// <param name="relation">Relation to retrieve parent and child object from</param>
        /// <param name="loadBaseType">Optional bool to load the complete object graph when set to <c>False</c></param>
        /// <returns>Returns a Tuple with Parent (item1) and Child (item2)</returns>
        public Tuple<IUmbracoEntity, IUmbracoEntity> GetEntitiesFromRelation(Relation relation, bool loadBaseType = false)
        {
            var childObjectType = UmbracoObjectTypesExtensions.GetUmbracoObjectType(relation.RelationType.ChildObjectType);
            var parentObjectType = UmbracoObjectTypesExtensions.GetUmbracoObjectType(relation.RelationType.ParentObjectType);

            var child = _entityService.Get(relation.ChildId, childObjectType, loadBaseType);
            var parent = _entityService.Get(relation.ParentId, parentObjectType, loadBaseType);

            return new Tuple<IUmbracoEntity, IUmbracoEntity>(parent, child);
        }
Ejemplo n.º 12
0
 /// <summary>
 /// Gets the Parent object from a Relation as an <see cref="IUmbracoEntity"/>
 /// </summary>
 /// <param name="relation">Relation to retrieve parent object from</param>
 /// <param name="loadBaseType">Optional bool to load the complete object graph when set to <c>False</c></param>
 /// <returns>An <see cref="IUmbracoEntity"/></returns>
 public IUmbracoEntity GetParentEntityFromRelation(Relation relation, bool loadBaseType = false)
 {
     var objectType = UmbracoObjectTypesExtensions.GetUmbracoObjectType(relation.RelationType.ParentObjectType);
     return _entityService.Get(relation.ParentId, objectType, loadBaseType);
 }
Ejemplo n.º 13
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="contextId">the id of the content, media or member item</param>
        /// <param name="propertyAlias">the property alias of the picker using relation mapping</param>
        /// <param name="relationTypeAlias">the alias of the relation type to use</param>
        /// <param name="relationsOnly"></param>
        /// <param name="pickedIds">the ids of all picked items that are to be related to the contextId</param>
        internal static void UpdateRelationMapping(int contextId, string propertyAlias, string relationTypeAlias, bool relationsOnly, int[] pickedIds)
        {
            IRelationType relationType = ApplicationContext.Current.Services.RelationService.GetRelationTypeByAlias(relationTypeAlias);

            if (relationType != null)
            {
                // get all relations of this type
                List<IRelation> relations = ApplicationContext.Current.Services.RelationService.GetAllRelationsByRelationType(relationType.Id).ToList();

                // construct object used to identify a relation (this is serialized into the relation comment field)
                RelationMappingComment relationMappingComment = new RelationMappingComment(contextId, propertyAlias);

                // filter down potential relations, by relation type direction
                if (relationType.IsBidirectional && relationsOnly)
                {
                    relations = relations.Where(x => x.ChildId == contextId || x.ParentId == contextId).ToList();
                    relations = relations.Where(x => new RelationMappingComment(x.Comment).DataTypeDefinitionId == relationMappingComment.DataTypeDefinitionId).ToList();
                }
                else
                {
                    relations = relations.Where(x => x.ChildId == contextId).ToList();
                    relations = relations.Where(x => new RelationMappingComment(x.Comment).PropertyTypeId == relationMappingComment.PropertyTypeId).ToList();

                    if (relationMappingComment.IsInArchetype())
                    {
                        relations = relations.Where(x => new RelationMappingComment(x.Comment).MatchesArchetypeProperty(relationMappingComment.PropertyAlias)).ToList();
                    }
                }

                // check current context is of the correct object type (as according to the relation type)
                if (ApplicationContext.Current.Services.EntityService.GetObjectType(contextId) == UmbracoObjectTypesExtensions.GetUmbracoObjectType(relationType.ChildObjectType))
                {
                    // for each picked item 
                    foreach (int pickedId in pickedIds)
                    {
                        // check picked item context if of the correct object type (as according to the relation type)
                        if (ApplicationContext.Current.Services.EntityService.GetObjectType(pickedId) == UmbracoObjectTypesExtensions.GetUmbracoObjectType(relationType.ParentObjectType))
                        {
                            // if relation doesn't already exist (new picked item)
                            if (!relations.Exists(x => x.ParentId == pickedId))
                            {
                                // create relation
                                Relation relation = new Relation(pickedId, contextId, relationType);
                                relation.Comment = relationMappingComment.GetComment();
                                ApplicationContext.Current.Services.RelationService.Save(relation);
                            }

                            // housekeeping - remove 'the' relation from the list being processed (there should be only one)
                            relations.RemoveAll(x => x.ChildId == contextId && x.ParentId == pickedId && x.RelationTypeId == relationType.Id);
                        }
                    }
                }

                // delete relations for any items left on the list being processed
                if (relations.Any())
                {
                    foreach (IRelation relation in relations)
                    {
                        ApplicationContext.Current.Services.RelationService.Delete(relation);
                    }
                }
            }
        }
Ejemplo n.º 14
0
        /// <summary>
        /// Store the profilepicture has media and createa a relationship between the user and the picture
        /// </summary>
        /// <param name="userName">UserName of the user to store the profile picture to</param>
        /// <param name="file">HttpPostedFileBase of the profile picture</param>
        public void StoreProfilePicure(string userName, HttpPostedFileBase file)
        {
            //lets store the media
            var memberToStore = _memberService.GetByUsername(userName);

            //create the media item
            var profileImageMediaToSTore = _mediaService.CreateMedia(memberToStore.Name, 1132, "Image");

            //save it to create a medi aId
            _mediaService.Save(profileImageMediaToSTore);

            //let umbraco take care of the file
            profileImageMediaToSTore.SetValue("umbracoFile", file);

            //save the whole thing
            _mediaService.Save(profileImageMediaToSTore);

            //meow we need to create the relation between the member and his profile picture
            var relationType = _relationService.GetRelationTypeByAlias("memberToProfileImage");
            var nRelation = new Relation(memberToStore.Id, profileImageMediaToSTore.Id, relationType);
            _relationService.Save(nRelation);
        }
Ejemplo n.º 15
0
 public ActionResult OptIn(int id)
 {
     try
     {
         var rs = Services.RelationService;
         //rs.Relate(Member.GetCurrentMember(), , "UMF_EmailNotification");
         var relation = new Relation(Member.GetCurrentMember().Id, id, rs.GetRelationTypeByAlias("UMF_EmailNotification"));
         rs.Save(relation);
         return RedirectToCurrentUmbracoPage();
     }
     catch { return RedirectToCurrentUmbracoPage(); }
 }
Ejemplo n.º 16
0
        /// <summary>
        /// Adds relation between Content and Media when Content is published
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ContentService_Published(IPublishingStrategy sender, PublishEventArgs<IContent> e)
        {
            // RelationService
            IRelationService rs = ApplicationContext.Current.Services.RelationService;

            // ContentService
            IContentService cs = ApplicationContext.Current.Services.ContentService;

            // RelationType
            IRelationType relationType = rs.GetRelationTypeByAlias(Constants.RelationTypeAlias);

            // Published Documents
            foreach (var contentNode in e.PublishedEntities)
            {
                // Content is child, query by child and RelationType
                var relations = rs.GetByChild(cs.GetById(contentNode.Id), Constants.RelationTypeAlias);

                // Remove current relations
                if (relations.Count() > 0)
                {
                    LogHelper.Info<MediaContentUsage>(String.Format("Removing all Media relations for published Content with id '{0}'", contentNode.Id));

                    foreach (var relation in relations)
                    {
                        rs.Delete(relation);

                        LogHelper.Debug<MediaContentUsage>(String.Format("Deleted relation: ParentId {0} ChildId {1}", relation.ParentId, relation.ChildId));
                    }
                }

                // Relate found Media to this Content
                foreach (var mediaNodeId in FindMedia(contentNode.Id))
                {
                    Relation relation = new Relation(mediaNodeId, contentNode.Id, relationType);
                    rs.Save(relation);

                    LogHelper.Debug<MediaContentUsage>(String.Format("Saved relation: ParentId {0} ChildId {1}", relation.ParentId, relation.ChildId));
                }
            }
        }
Ejemplo n.º 17
0
        /// <summary>
        /// Relates two objects that are based on the <see cref="IUmbracoEntity"/> interface.
        /// </summary>
        /// <param name="parent">Parent entity</param>
        /// <param name="child">Child entity</param>
        /// <param name="relationType">The type of relation to create</param>
        /// <returns>The created <see cref="Relation"/></returns>
        public Relation Relate(IUmbracoEntity parent, IUmbracoEntity child, RelationType relationType)
        {
            //Ensure that the RelationType has an indentity before using it to relate two entities
            if(relationType.HasIdentity == false)
                Save(relationType);

            var relation = new Relation(parent.Id, child.Id, relationType);
            var uow = _uowProvider.GetUnitOfWork();
            using (var repository = _repositoryFactory.CreateRelationRepository(uow))
            {
                repository.AddOrUpdate(relation);
                uow.Commit();

                return relation;
            }
        }