Hi Bjarne,

When using the MNTP to pick a company on a member, what are you using to create the relationship ?

Should nuPickers also create relation, when using MNTP like it does for the other pickers? https://github.com/uComponents/nuPickers/blob/0c8891cd94b6e073adc95cdf10d3203f6bce7881/source/nuPickers/Shared/RelationMapping/RelationMappingEvent.cs

In uComponents it did create the relation, when using MNTP as in the example mentioned before, where MNTP was in core.

/Bjarne

I have managed to solve it in this way similar to how nuPickers handle it with its different pickers. However when picking a company while create a member and hitting save, it seems it doesn't create the relation - first when I save the member again (after it has been created).

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Umbraco.Core;
using Umbraco.Core.Events;
using Umbraco.Core.Models;
using Umbraco.Core.Services;

namespace My.Library.Events
{
    /// <summary>
    /// server side event to update relations on change of any member
    /// </summary>
    public class RelationMappingEvent : ApplicationEventHandler
    {
        // inspired from nuPickers: https://github.com/uComponents/nuPickers/tree/master/source/nuPickers/Shared/RelationMapping

        protected override void ApplicationStarted(UmbracoApplicationBase umbracoApplication, ApplicationContext applicationContext)
        {
            MemberService.Saved += this.MemberService_Saved;

            // NOTE: all relations to an id are automatically deleted when emptying the recycle bin
        }

        private void MemberService_Saved(IMemberService sender, SaveEventArgs<IMember> e)
        {
            this.Saved((IService)sender, e.SavedEntities);
        }

        /// <summary>
        /// combined event for member 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="savedEntities"></param>
        private void Saved(IService sender, IEnumerable<IContentBase> savedEntities)
        {
            foreach (IContentBase savedEntity in savedEntities)
            {
                // for each property
                foreach (PropertyType propertyType in savedEntity.PropertyTypes.Where(p => p.Alias == "umbracoMemberCompany"))
                {
                    List<int> pickedIds = new List<int>();
                    int memberId = savedEntity.Id;
                    var mntpValues = savedEntity.GetValue(propertyType.Alias);
                    if(mntpValues != null)
                    {
                        pickedIds = mntpValues.ToString().Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries).Select(int.Parse).ToList();
                    }

                    UpdateCompanyRelations(memberId, "relateCompanyToMember", pickedIds);
                }
            }
        }

        private void SetCompanyRelation(int contentId, int memberId)
        {
            var rs = ApplicationContext.Current.Services.RelationService;
            var areRelated = rs.AreRelated(contentId, memberId, "relateCompanyToMember");

            if (!areRelated)
            {
                //create relation between document (company node) and member
                var relType = rs.GetRelationTypeByAlias("relateCompanyToMember");
                var r = new Relation(contentId, memberId, relType);
                r.Comment = string.Format("Relate document id {0} to member id {1} ", contentId, memberId);
                rs.Save(r);
            }
        }

        /// <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="pickedIds">the ids of all picked items that are to be related to the contextId</param>
        private void UpdateCompanyRelations(int contextId, string relationTypeAlias, List<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();

                // filter down potential relations, by relation type direction
                if (relationType.IsBidirectional)
                {
                    relations = relations.Where(x => x.ChildId == contextId || x.ParentId == contextId).ToList();
                }
                else
                {
                    relations = relations.Where(x => x.ChildId == contextId).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))
                        {
                            // create relation for each picked company
                            SetCompanyRelation(pickedId, contextId);
                        }
                    }
                }

                // delete any relations that not are in picked ids
                if (relations.Any())
                {
                    foreach (IRelation relation in relations)
                    {
                        if(pickedIds == null || !pickedIds.Contains(relation.ChildId))
                        {
                            ApplicationContext.Current.Services.RelationService.Delete(relation);
                        }
                    }
                }
            }
        }
    }
}

/Bjarne

Hi Bjarne,

Yes, you are correct. uComponents had a data-type which would 'watch' another picker and wire it up to relations, but this changed in nuPickers - now each picker can update relations directly. (Perhaps this change wasn't so sensible ? but it does avoid creating two data-types).

My guess on your current issue, could be that the relation isn't created on first save, as there isn't yet an id for the member being created ?

HTH, Hendy

I came across this page after looking for how to make use of the Relations mapping in v7 for Members, with similar use case in https://our.umbraco.org/projects/backoffice-extensions/media-content-usage/

I have created RelationShips from Content to Member and Member to Content.

Using MNTP by default, doesnt seem to capture the relations, like Bjarne pointed out (had to learn it the hard way...)

Apparently the tutorials/documentation on the net relates to pre v7 for successfull use cases.

For my use case, I'm trying to repliacete the usability of https://our.umbraco.org/projects/backoffice-extensions/media-content-usage/ but for Members instead of Media.

So when I visit a Member, I would like to see the list of Content Nodes (hyperlinks to content nodes).

Since data is already populated, and MNTP used, I cant change to NuPickers directly I think.

Is there a simpler way of using the code posted above, but adopt for Content with specific MemberType("Subscriber") ?

...like:

ContentNode -> MNTP member picker

and when a member page visited, i can see the links of content nodes

is working on a reply...