/// <summary>
        /// Render the Group Admission block view.
        /// </summary>
        /// <param name="currentBlock">The current block instance.</param>
        /// <returns></returns>
        public override ActionResult Index(GroupAdmissionBlock currentBlock)
        {
            var currentPageLink = pageRouteHelper.PageLink;

            //Populate model to pass to block view
            var blockModel = new GroupAdmissionBlockViewModel(currentBlock, currentPageLink);

            //Retrieves moderation information for the model to display in the view
            try
            {
                var group = communityRepository.Get(currentBlock.GroupName);
                ValidateGroup(blockModel, group);
                PopulateMemberDetails(blockModel);
            }
            catch (SocialRepositoryException ex)
            {
                AddMessage(MessageKey, new MessageViewModel(ex.Message, ErrorMessage));
            }
            catch (GroupDoesNotExistException ex)
            {
                AddMessage(MessageKey, new MessageViewModel(ex.Message, ErrorMessage));
            }
            blockModel.Messages = RetrieveMessages(MessageKey);
            //Remove existing values from input fields
            ModelState.Clear();

            //Return block view
            return(PartialView("~/Views/Social/GroupAdmissionBlock/Index.cshtml", blockModel));
        }
        /// <summary>
        /// Populates the member related properties on the viewmodel
        /// </summary>
        /// <param name="blockModel">The view model for the GroupAdmissionBlock</param>
        private void PopulateMemberDetails(GroupAdmissionBlockViewModel blockModel)
        {
            var userId   = userRepository.GetUserId(this.User);
            var loggedIn = !String.IsNullOrWhiteSpace(userId);

            blockModel.UserIsLoggedIn = loggedIn;
            blockModel.MemberName     = loggedIn ? userRepository.CreateAuthenticatedUri(userId): "";
            blockModel.ModeratedUserAdmissionState = loggedIn ? moderationRepository.GetMembershipRequestState(blockModel.MemberName, blockModel.GroupId) : "";
        }
        public ActionResult Submit(GroupAdmissionBlockViewModel blockModel)
        {
            try
            {
                AddMember(blockModel);
            }
            catch (SocialRepositoryException ex)
            {
                AddMessage(MessageKey, new MessageViewModel(ex.Message, ErrorMessage));
            }

            return(Redirect(UrlResolver.Current.GetUrl(blockModel.CurrentPageLink)));
        }
 /// <summary>
 /// Validates that the group returned exists
 /// </summary>
 /// <param name="blockModel">The view model for the GroupAdmissionBlock</param>
 /// <param name="group">The group that was retrieved</param>
 private void ValidateGroup(GroupAdmissionBlockViewModel blockModel, Community group)
 {
     if (group != null)
     {
         var groupId = group.Id;
         blockModel.GroupName   = group.Name;
         blockModel.GroupId     = groupId.ToString();
         blockModel.IsModerated = moderationRepository.IsModerated(groupId);
     }
     else
     {
         var errorMessage = "The group configured for this block cannot be found. Please update the block to use an existing group.";
         AddMessage(MessageKey, new MessageViewModel(errorMessage, ErrorMessage));
     }
 }
        /// <summary>
        /// Determines how a member is added to a group.
        /// If the group is moderated a request for membership is added into the group moderation workflow.
        /// If the group is not moderated the member is  added to the underlying membership repository
        /// </summary>
        /// <param name="blockModel">The viewmodel for the GroupAdmission view</param>
        private void AddMember(GroupAdmissionBlockViewModel blockModel)
        {
            //Construct friendly names for messaging
            var userName = "";

            if (blockModel.UserIsLoggedIn)
            {
                var userId = userRepository.GetAuthenticatedId(blockModel.MemberName);
                userName = userRepository.GetUserName(userId);
            }
            else
            {
                userName = blockModel.MemberName;
                blockModel.MemberName = userRepository.CreateAnonymousUri(blockModel.MemberName);
            }

            if (ValidateMemberInputs(blockModel.MemberName, blockModel.MemberEmail))
            {
                try
                {
                    //Populated the CommunityMember and extension data
                    var member = new CommunityMember(blockModel.MemberName, blockModel.GroupId, blockModel.MemberEmail, blockModel.MemberCompany);
                    if (blockModel.IsModerated)
                    {
                        //Adds request for membership into moderation workflow
                        this.moderationRepository.AddAModeratedMember(member);
                    }
                    else
                    {
                        //Add the new member with extension data and persist the success message in temp data
                        memberRepository.Add(member);
                        var message = userName + " was added successfully to the group.";
                        AddMessage(MessageKey, new MessageViewModel(message, SuccessMessage));
                    }
                }
                catch (SocialRepositoryException ex)
                {
                    //Persist the exception message in temp data to be used in the error message
                    AddMessage(MessageKey, new MessageViewModel(ex.Message, ErrorMessage));
                }
            }
            else
            {
                //Persist the message in temp data to be used in the error message
                var message = "The member name, email and company cannot be empty.";
                AddMessage(MessageKey, new MessageViewModel(message, ErrorMessage));
            }
        }