Example #1
0
 public MemberService()
 {
     _memberService = AppHelpers.UmbServices().MemberService;
     _memberGroupService = AppHelpers.UmbServices().MemberGroupService;
     _membershipHelper = AppHelpers.UmbMemberHelper();
     _memberTypeService = AppHelpers.UmbServices().MemberTypeService;
     _dataTypeService = AppHelpers.UmbServices().DataTypeService;
 }
Example #2
0
    public void PostSaveMember_SaveNew_WhenMemberEmailAlreadyExists_ExpectFailResponse(
        [Frozen] IMemberManager umbracoMembersUserManager,
        IMemberService memberService,
        IMemberTypeService memberTypeService,
        IMemberGroupService memberGroupService,
        IDataTypeService dataTypeService,
        IBackOfficeSecurityAccessor backOfficeSecurityAccessor,
        IBackOfficeSecurity backOfficeSecurity,
        IPasswordChanger <MemberIdentityUser> passwordChanger,
        IOptions <GlobalSettings> globalSettings,
        IUser user)
    {
        // arrange
        var member = SetupMemberTestData(out var fakeMemberData, out _, ContentSaveAction.SaveNew);

        Mock.Get(umbracoMembersUserManager)
        .Setup(x => x.CreateAsync(It.IsAny <MemberIdentityUser>()))
        .ReturnsAsync(() => IdentityResult.Success);
        Mock.Get(memberTypeService).Setup(x => x.GetDefault()).Returns("fakeAlias");
        Mock.Get(backOfficeSecurityAccessor).Setup(x => x.BackOfficeSecurity).Returns(backOfficeSecurity);
        Mock.Get(umbracoMembersUserManager)
        .Setup(x => x.ValidatePasswordAsync(It.IsAny <string>()))
        .ReturnsAsync(() => IdentityResult.Success);
        Mock.Get(umbracoMembersUserManager)
        .Setup(x => x.AddToRolesAsync(It.IsAny <MemberIdentityUser>(), It.IsAny <IEnumerable <string> >()))
        .ReturnsAsync(() => IdentityResult.Success);

        Mock.Get(memberService).SetupSequence(
            x => x.GetByEmail(It.IsAny <string>()))
        .Returns(() => member);

        var sut = CreateSut(
            memberService,
            memberTypeService,
            memberGroupService,
            umbracoMembersUserManager,
            dataTypeService,
            backOfficeSecurityAccessor,
            passwordChanger,
            globalSettings);

        // act
        var result     = sut.PostSave(fakeMemberData).Result;
        var validation = result.Result as ValidationErrorResult;

        // assert
        Assert.IsNotNull(result.Result);
        Assert.IsNull(result.Value);
        Assert.AreEqual(StatusCodes.Status400BadRequest, validation?.StatusCode);
    }
Example #3
0
    public async Task PostSaveMember_SaveNew_CustomField_WhenAllIsSetupCorrectly_ExpectSuccessResponse(
        [Frozen] IMemberManager umbracoMembersUserManager,
        IMemberService memberService,
        IMemberTypeService memberTypeService,
        IMemberGroupService memberGroupService,
        IDataTypeService dataTypeService,
        IBackOfficeSecurityAccessor backOfficeSecurityAccessor,
        IBackOfficeSecurity backOfficeSecurity,
        IPasswordChanger <MemberIdentityUser> passwordChanger,
        IOptions <GlobalSettings> globalSettings,
        IUser user)
    {
        // arrange
        var member = SetupMemberTestData(out var fakeMemberData, out var memberDisplay, ContentSaveAction.SaveNew);

        Mock.Get(umbracoMembersUserManager)
        .Setup(x => x.CreateAsync(It.IsAny <MemberIdentityUser>(), It.IsAny <string>()))
        .ReturnsAsync(() => IdentityResult.Success);
        Mock.Get(umbracoMembersUserManager)
        .Setup(x => x.ValidatePasswordAsync(It.IsAny <string>()))
        .ReturnsAsync(() => IdentityResult.Success);
        Mock.Get(umbracoMembersUserManager)
        .Setup(x => x.GetRolesAsync(It.IsAny <MemberIdentityUser>()))
        .ReturnsAsync(() => Array.Empty <string>());
        Mock.Get(memberTypeService).Setup(x => x.GetDefault()).Returns("fakeAlias");
        Mock.Get(backOfficeSecurityAccessor).Setup(x => x.BackOfficeSecurity).Returns(backOfficeSecurity);
        Mock.Get(memberService).SetupSequence(
            x => x.GetByEmail(It.IsAny <string>()))
        .Returns(() => null)
        .Returns(() => member);
        Mock.Get(memberService).Setup(x => x.GetByUsername(It.IsAny <string>())).Returns(() => member);

        var sut = CreateSut(
            memberService,
            memberTypeService,
            memberGroupService,
            umbracoMembersUserManager,
            dataTypeService,
            backOfficeSecurityAccessor,
            passwordChanger,
            globalSettings);

        // act
        var result = await sut.PostSave(fakeMemberData);

        // assert
        Assert.IsNull(result.Result);
        Assert.IsNotNull(result.Value);
        AssertMemberDisplayPropertiesAreEqual(memberDisplay, result.Value);
    }
        public async Task PostSaveMember_SaveExisting_WhenAllIsSetupCorrectly_ExpectSuccessResponse(
            [Frozen] IMemberManager umbracoMembersUserManager,
            IMemberService memberService,
            IMemberTypeService memberTypeService,
            IMemberGroupService memberGroupService,
            IDataTypeService dataTypeService,
            IBackOfficeSecurityAccessor backOfficeSecurityAccessor,
            IBackOfficeSecurity backOfficeSecurity,
            IPasswordChanger <MemberIdentityUser> passwordChanger,
            IOptions <GlobalSettings> globalSettings,
            IUser user)
        {
            // arrange
            Member member = SetupMemberTestData(out MemberSave fakeMemberData, out MemberDisplay memberDisplay, ContentSaveAction.Save);
            var    membersIdentityUser = new MemberIdentityUser(123);

            Mock.Get(umbracoMembersUserManager)
            .Setup(x => x.FindByIdAsync(It.IsAny <string>()))
            .ReturnsAsync(() => membersIdentityUser);
            Mock.Get(umbracoMembersUserManager)
            .Setup(x => x.ValidatePasswordAsync(It.IsAny <string>()))
            .ReturnsAsync(() => IdentityResult.Success);

            Mock.Get(umbracoMembersUserManager)
            .Setup(x => x.UpdateAsync(It.IsAny <MemberIdentityUser>()))
            .ReturnsAsync(() => IdentityResult.Success);
            Mock.Get(memberTypeService).Setup(x => x.GetDefault()).Returns("fakeAlias");
            Mock.Get(globalSettings);

            SetupUserAccess(backOfficeSecurityAccessor, backOfficeSecurity, user);
            SetupPasswordSuccess(umbracoMembersUserManager, passwordChanger);

            Mock.Get(memberService).Setup(x => x.GetByUsername(It.IsAny <string>())).Returns(() => member);
            Mock.Get(memberService).Setup(x => x.GetById(It.IsAny <int>())).Returns(() => member);
            Mock.Get(memberService).SetupSequence(
                x => x.GetByEmail(It.IsAny <string>()))
            .Returns(() => null)
            .Returns(() => member);


            MemberController sut = CreateSut(memberService, memberTypeService, memberGroupService, umbracoMembersUserManager, dataTypeService, backOfficeSecurityAccessor, passwordChanger, globalSettings, user);

            // act
            ActionResult <MemberDisplay> result = await sut.PostSave(fakeMemberData);

            // assert
            Assert.IsNull(result.Result);
            Assert.IsNotNull(result.Value);
            AssertMemberDisplayPropertiesAreEqual(memberDisplay, result.Value);
        }
        public MemberExtendedService(IScopeProvider provider, ILogger logger, IEventMessagesFactory eventMessagesFactory,
                                     IMemberGroupService memberGroupService, IMediaFileSystem mediaFileSystem,
                                     IMemberRepository memberRepository, IMemberTypeRepository memberTypeRepository,
                                     IMemberGroupRepository memberGroupRepository, IAuditRepository auditRepository,
                                     IExamineManager examineManager)
            : base(provider, logger, eventMessagesFactory, memberGroupService, mediaFileSystem,
                   memberRepository, memberTypeRepository, memberGroupRepository, auditRepository)
        {
            this.logger = new Logging <MemberExtendedService>(logger);
#endif
            this.memberGroupService = memberGroupService;
            this.memberRepository   = memberRepository;
            this.examineManager     = examineManager;
        }
 static void MemberGroupService_Saved(IMemberGroupService sender, Core.Events.SaveEventArgs <Core.Models.IMemberGroup> e)
 {
     foreach (var grp in e.SavedEntities)
     {
         //check if the name has changed
         if (grp.AdditionalData.ContainsKey("previousName") &&
             grp.AdditionalData["previousName"] != null &&
             grp.AdditionalData["previousName"].ToString().IsNullOrWhiteSpace() == false &&
             grp.AdditionalData["previousName"].ToString() != grp.Name)
         {
             Current.Services.PublicAccessService.RenameMemberGroupRoleRules(grp.AdditionalData["previousName"].ToString(), grp.Name);
         }
     }
 }
 public MemberTabsAndPropertiesMapper(ICultureDictionary cultureDictionary,
                                      IBackOfficeSecurityAccessor backofficeSecurityAccessor,
                                      ILocalizedTextService localizedTextService,
                                      IMemberTypeService memberTypeService,
                                      IMemberService memberService,
                                      IMemberGroupService memberGroupService,
                                      IOptions <MemberPasswordConfigurationSettings> memberPasswordConfiguration,
                                      IContentTypeBaseServiceProvider contentTypeBaseServiceProvider,
                                      PropertyEditorCollection propertyEditorCollection)
     : base(cultureDictionary, localizedTextService, contentTypeBaseServiceProvider)
 {
     _backofficeSecurityAccessor = backofficeSecurityAccessor ?? throw new ArgumentNullException(nameof(backofficeSecurityAccessor));
     _localizedTextService       = localizedTextService ?? throw new ArgumentNullException(nameof(localizedTextService));
     _memberTypeService          = memberTypeService ?? throw new ArgumentNullException(nameof(memberTypeService));
     _memberService               = memberService ?? throw new ArgumentNullException(nameof(memberService));
     _memberGroupService          = memberGroupService ?? throw new ArgumentNullException(nameof(memberGroupService));
     _memberPasswordConfiguration = memberPasswordConfiguration.Value;
     _propertyEditorCollection    = propertyEditorCollection;
 }
Example #8
0
        public UmbracoMembersUserStore(
            ILogger logger,
            IMemberService memberService,
            IMemberTypeService memberTypeService,
            IMemberGroupService memberGroupService,
            IdentityEnabledMembersMembershipProvider membershipProvider,
            IExternalLoginStore externalLoginStore)
        {
            _logger             = logger ?? throw new ArgumentNullException(nameof(logger));
            _memberService      = memberService ?? throw new ArgumentNullException("memberService");
            _memberTypeService  = memberTypeService;
            _memberGroupService = memberGroupService ?? throw new ArgumentNullException(nameof(memberGroupService));
            _membershipProvider = membershipProvider ?? throw new ArgumentNullException("membershipProvider");
            _externalLoginStore = externalLoginStore ?? throw new ArgumentNullException("externalLoginStore");

            if (_membershipProvider.PasswordFormat != MembershipPasswordFormat.Hashed)
            {
                throw new InvalidOperationException("Cannot use ASP.Net Identity with UmbracoMembersUserStore when the password format is not Hashed");
            }
        }
Example #9
0
    public void PostSaveMember_WhenModelStateIsNotValid_ExpectFailureResponse(
        [Frozen] IMemberManager umbracoMembersUserManager,
        IMemberService memberService,
        IMemberTypeService memberTypeService,
        IMemberGroupService memberGroupService,
        IDataTypeService dataTypeService,
        IBackOfficeSecurityAccessor backOfficeSecurityAccessor,
        IPasswordChanger <MemberIdentityUser> passwordChanger,
        IOptions <GlobalSettings> globalSettings,
        IUser user)
    {
        // arrange
        SetupMemberTestData(out var fakeMemberData, out _, ContentSaveAction.SaveNew);
        var sut = CreateSut(
            memberService,
            memberTypeService,
            memberGroupService,
            umbracoMembersUserManager,
            dataTypeService,
            backOfficeSecurityAccessor,
            passwordChanger,
            globalSettings);

        sut.ModelState.AddModelError("key", "Invalid model state");

        Mock.Get(umbracoMembersUserManager)
        .Setup(x => x.CreateAsync(It.IsAny <MemberIdentityUser>(), It.IsAny <string>()))
        .ReturnsAsync(() => IdentityResult.Success);
        Mock.Get(umbracoMembersUserManager)
        .Setup(x => x.ValidatePasswordAsync(It.IsAny <string>()))
        .ReturnsAsync(() => IdentityResult.Success);

        // act
        var result     = sut.PostSave(fakeMemberData).Result;
        var validation = result.Result as ValidationErrorResult;

        // assert
        Assert.IsNotNull(result.Result);
        Assert.IsNull(result.Value);
        Assert.AreEqual(StatusCodes.Status400BadRequest, validation?.StatusCode);
    }
Example #10
0
        /// <summary>
        /// Default method to create a user manager
        /// </summary>
        /// <param name="options"></param>
        /// <param name="logger"></param>
        /// <param name="scopeProvider"></param>
        /// <param name="memberService"></param>
        /// <param name="memberTypeService"></param>
        /// <param name="memberGroupService"></param>
        /// <param name="membershipProvider"></param>
        /// <returns></returns>
        public static UmbracoMembersUserManager <TUser> Create(
            IdentityFactoryOptions <UmbracoMembersUserManager <TUser> > options,
            ILogger logger,
            IScopeProvider scopeProvider,
            IMemberService memberService,
            IMemberTypeService memberTypeService,
            IMemberGroupService memberGroupService,
            IdentityEnabledMembersMembershipProvider membershipProvider = null)
        {
            //we'll grab some settings from the membership provider
            var provider = membershipProvider ?? Membership.Providers["UmbracoMembershipProvider"] as IdentityEnabledMembersMembershipProvider;

            if (provider == null)
            {
                throw new InvalidOperationException("In order to use " + typeof(UmbracoMembersUserManager <>) + " the Umbraco members membership provider must be of type " + typeof(IdentityEnabledMembersMembershipProvider));
            }

            var externalLoginStore = new ExternalLoginStore(scopeProvider);

            return(Create(options, new UmbracoMembersUserStore <TUser>(logger, memberService, memberTypeService, memberGroupService, provider, externalLoginStore), membershipProvider));
        }
Example #11
0
 public PermissionsController(
     IMemberGroupService memberGroupService,
     IPermissionResourceTypeProvider resourceTypeProvider,
     IPermissionActionTypeProvider actionTypeProvider,
     IIntranetMemberService <IntranetMember> intranetMemberService,
     IIntranetMemberGroupProvider intranetMemberGroupProvider,
     IPermissionsService permissionsService,
     IIntranetMemberGroupService intranetMemberGroupService,
     IApplicationSettings applicationSettings,
     ILogger logger)
 {
     _memberGroupService          = memberGroupService;
     _resourceTypeProvider        = resourceTypeProvider;
     _actionTypeProvider          = actionTypeProvider;
     _intranetMemberService       = intranetMemberService;
     _intranetMemberGroupProvider = intranetMemberGroupProvider;
     _permissionsService          = permissionsService;
     _intranetMemberGroupService  = intranetMemberGroupService;
     _applicationSettings         = applicationSettings;
     _logger = logger;
 }
 public ExtendedMemberController(
     ICultureDictionary cultureDictionary,
     ILoggerFactory loggerFactory,
     IShortStringHelper shortStringHelper,
     IEventMessagesFactory eventMessages,
     ILocalizedTextService localizedTextService,
     PropertyEditorCollection propertyEditors,
     IUmbracoMapper umbracoMapper,
     IMemberService memberService,
     IMemberTypeService memberTypeService,
     IMemberManager memberManager,
     IDataTypeService dataTypeService,
     IBackOfficeSecurityAccessor backOfficeSecurityAccessor,
     IJsonSerializer jsonSerializer,
     IPasswordChanger <MemberIdentityUser> passwordChanger,
     IScopeProvider scopeProvider,
     IMemberExtendedService memberExtendedService,
     IMemberGroupService memberGroupService,
     IConfiguration configuration) :
     base(cultureDictionary, loggerFactory, shortStringHelper, eventMessages, localizedTextService,
          propertyEditors, umbracoMapper, memberService, memberTypeService,
          memberManager, dataTypeService, backOfficeSecurityAccessor, jsonSerializer, passwordChanger, scopeProvider)
Example #13
0
 public MemberGroupPickerConverter(IMemberGroupService memberGroupService)
 {
     _memberGroupService = memberGroupService;
 }
Example #14
0
 public DefaultMemberGroupPickerPropertyValueConverter()
 {
     _memberGroupService = UmbracoContextHelper.GetUmbracoContext().Application.Services.MemberGroupService;
 }
 public DoMemberGroupApiController(ILogger <DoMemberGroupApiController> logger, IMemberGroupService service)
     : base(logger, service)
 {
     _service = service;
 }
Example #16
0
 public KeepOutComponent(IUmbracoContextFactory factory, ILogger logger, IMemberGroupService memberGroupService)
 {
     _factory            = factory;
     _logger             = logger;
     _memberGroupService = memberGroupService;
 }
Example #17
0
 public UmbracoMembersRoleStore(
     IMemberGroupService memberGroupService)
 {
     _memberGroupService = memberGroupService;
 }
 public UmbracoMemberGroupDataListSource(IMemberGroupService memberGroupService)
 {
     _memberGroupService = memberGroupService;
 }
 public MemberGroupHelper(IRouteGenerator routeGenerator, IMemberService memberService, IMemberGroupService memberGroupService, RoleProvider roleProvider)
 {
     _routeGenerator     = routeGenerator ?? throw new ArgumentNullException(nameof(routeGenerator));
     _memberService      = memberService ?? throw new ArgumentNullException(nameof(memberService));
     _memberGroupService = memberGroupService ?? throw new ArgumentNullException(nameof(memberGroupService));
     _roleProvider       = roleProvider ?? throw new ArgumentNullException(nameof(roleProvider));
 }
Example #20
0
 public MemberController()
 {
     groupService = new GroupService();
     mgrService   = new MemberGroupService();
 }
        //private const string genericIdentityErrorCode = "IdentityErrorUserStore";

        public MemberRoleStore(IMemberGroupService memberGroupService, IdentityErrorDescriber errorDescriber)
        {
            _memberGroupService = memberGroupService ?? throw new ArgumentNullException(nameof(memberGroupService));
            ErrorDescriber      = errorDescriber ?? throw new ArgumentNullException(nameof(errorDescriber));
        }
 //private
 public MemberExtendedService(IScopeUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IEventMessagesFactory eventMessagesFactory, IMemberGroupService memberGroupService, IDataTypeService dataTypeService)
     : base(provider, repositoryFactory, logger, eventMessagesFactory, memberGroupService, dataTypeService)
 {
     UowProvider = provider;
 }
Example #23
0
 public InviteService()
 {
     userService = new UserService();
     msgService  = new MessageService();
     mgrService  = new MemberGroupService();
 }
Example #24
0
        /// <summary>
        /// Create member controller to test
        /// </summary>
        /// <param name="memberService">Member service</param>
        /// <param name="memberTypeService">Member type service</param>
        /// <param name="memberGroupService">Member group service</param>
        /// <param name="membersUserManager">Members user manager</param>
        /// <param name="dataTypeService">Data type service</param>
        /// <param name="backOfficeSecurityAccessor">Back office security accessor</param>
        /// <param name="mockPasswordChanger">Password changer class</param>
        /// <returns>A member controller for the tests</returns>
        private MemberController CreateSut(
            IMemberService memberService,
            IMemberTypeService memberTypeService,
            IMemberGroupService memberGroupService,
            IUmbracoUserManager <MemberIdentityUser> membersUserManager,
            IDataTypeService dataTypeService,
            IBackOfficeSecurityAccessor backOfficeSecurityAccessor,
            IPasswordChanger <MemberIdentityUser> passwordChanger,
            IOptions <GlobalSettings> globalSettings,
            IUser user)
        {
            var httpContextAccessor = new HttpContextAccessor();

            var mockShortStringHelper          = new MockShortStringHelper();
            var textService                    = new Mock <ILocalizedTextService>();
            var contentTypeBaseServiceProvider = new Mock <IContentTypeBaseServiceProvider>();

            contentTypeBaseServiceProvider.Setup(x => x.GetContentTypeOf(It.IsAny <IContentBase>())).Returns(new ContentType(mockShortStringHelper, 123));
            var contentAppFactories              = new Mock <List <IContentAppFactory> >();
            var mockContentAppFactoryCollection  = new Mock <ILogger <ContentAppFactoryCollection> >();
            var hybridBackOfficeSecurityAccessor = new BackOfficeSecurityAccessor(httpContextAccessor);
            var contentAppFactoryCollection      = new ContentAppFactoryCollection(
                () => contentAppFactories.Object,
                mockContentAppFactoryCollection.Object,
                hybridBackOfficeSecurityAccessor);
            var mockUserService = new Mock <IUserService>();
            var commonMapper    = new CommonMapper(
                mockUserService.Object,
                contentTypeBaseServiceProvider.Object,
                contentAppFactoryCollection,
                textService.Object);
            var mockCultureDictionary = new Mock <ICultureDictionary>();

            var mockPasswordConfig = new Mock <IOptions <MemberPasswordConfigurationSettings> >();

            mockPasswordConfig.Setup(x => x.Value).Returns(() => new MemberPasswordConfigurationSettings());
            IDataEditor dataEditor = Mock.Of <IDataEditor>(
                x => x.Type == EditorType.PropertyValue &&
                x.Alias == Constants.PropertyEditors.Aliases.Label);

            Mock.Get(dataEditor).Setup(x => x.GetValueEditor()).Returns(new TextOnlyValueEditor(new DataEditorAttribute(Constants.PropertyEditors.Aliases.TextBox, "Test Textbox", "textbox"), textService.Object, Mock.Of <IShortStringHelper>(), Mock.Of <IJsonSerializer>(), Mock.Of <IIOHelper>()));

            var propertyEditorCollection = new PropertyEditorCollection(new DataEditorCollection(() => new[] { dataEditor }));

            IMapDefinition memberMapDefinition = new MemberMapDefinition(
                commonMapper,
                new CommonTreeNodeMapper(Mock.Of <LinkGenerator>()),
                new MemberTabsAndPropertiesMapper(
                    mockCultureDictionary.Object,
                    backOfficeSecurityAccessor,
                    textService.Object,
                    memberTypeService,
                    memberService,
                    memberGroupService,
                    mockPasswordConfig.Object,
                    contentTypeBaseServiceProvider.Object,
                    propertyEditorCollection));

            var map = new MapDefinitionCollection(() => new List <IMapDefinition>()
            {
                new global::Umbraco.Cms.Core.Models.Mapping.MemberMapDefinition(),
                memberMapDefinition,
                new ContentTypeMapDefinition(
                    commonMapper,
                    propertyEditorCollection,
                    dataTypeService,
                    new Mock <IFileService>().Object,
                    new Mock <IContentTypeService>().Object,
                    new Mock <IMediaTypeService>().Object,
                    memberTypeService,
                    new Mock <ILoggerFactory>().Object,
                    mockShortStringHelper,
                    globalSettings,
                    new Mock <IHostingEnvironment>().Object)
            });
            var scopeProvider = Mock.Of <IScopeProvider>(x => x.CreateScope(
                                                             It.IsAny <IsolationLevel>(),
                                                             It.IsAny <RepositoryCacheMode>(),
                                                             It.IsAny <IEventDispatcher>(),
                                                             It.IsAny <IScopedNotificationPublisher>(),
                                                             It.IsAny <bool?>(),
                                                             It.IsAny <bool>(),
                                                             It.IsAny <bool>()) == Mock.Of <IScope>());

            _mapper = new UmbracoMapper(map, scopeProvider);

            return(new MemberController(
                       new DefaultCultureDictionary(
                           new Mock <ILocalizationService>().Object,
                           NoAppCache.Instance),
                       new LoggerFactory(),
                       mockShortStringHelper,
                       new DefaultEventMessagesFactory(
                           new Mock <IEventMessagesAccessor>().Object),
                       textService.Object,
                       propertyEditorCollection,
                       _mapper,
                       memberService,
                       memberTypeService,
                       (IMemberManager)membersUserManager,
                       dataTypeService,
                       backOfficeSecurityAccessor,
                       new ConfigurationEditorJsonSerializer(),
                       passwordChanger,
                       scopeProvider
                       ));
        }
Example #25
0
        public JoinController() {
            groupService = new GroupService();
            mgrService = new MemberGroupService();

            HidePermission( typeof( wojilu.Web.Controller.SecurityController ) );
        }
Example #26
0
 public GroupService()
 {
     appService  = new GroupAppService();
     menuService = new GroupMenuService();
     mgrService  = new MemberGroupService();
 }
 public MemberExtendedService(IScopeProvider provider, ILoggerFactory loggerFactory, IEventMessagesFactory eventMessagesFactory, IMemberGroupService memberGroupService,
                              IMemberRepository memberRepository, IMemberTypeRepository memberTypeRepository, IMemberGroupRepository memberGroupRepository, IAuditRepository auditRepository,
                              IExamineManager examineManager)
     : base(provider, loggerFactory, eventMessagesFactory, memberGroupService, memberRepository, memberTypeRepository, memberGroupRepository, auditRepository)
 {
     this.logger = new Logging <MemberExtendedService>(loggerFactory.CreateLogger <MemberExtendedService>());
 public void ProcessMemberGroupSaved(IMemberGroupService sender, SaveEventArgs <IMemberGroup> args)
 {
     _intranetMemberGroupService.ClearCache();
 }
Example #29
0
 /// <summary>
 /// public ctor - will generally just be used for unit testing all items are optional and if not specified, the defaults will be used
 /// </summary>
 /// <param name="contentService"></param>
 /// <param name="mediaService"></param>
 /// <param name="contentTypeService"></param>
 /// <param name="dataTypeService"></param>
 /// <param name="fileService"></param>
 /// <param name="localizationService"></param>
 /// <param name="packagingService"></param>
 /// <param name="entityService"></param>
 /// <param name="relationService"></param>
 /// <param name="memberGroupService"></param>
 /// <param name="memberTypeService"></param>
 /// <param name="memberService"></param>
 /// <param name="userService"></param>
 /// <param name="sectionService"></param>
 /// <param name="treeService"></param>
 /// <param name="tagService"></param>
 /// <param name="notificationService"></param>
 /// <param name="localizedTextService"></param>
 /// <param name="auditService"></param>
 /// <param name="domainService"></param>
 /// <param name="taskService"></param>
 /// <param name="macroService"></param>
 /// <param name="publicAccessService"></param>
 /// <param name="externalLoginService"></param>
 /// <param name="migrationEntryService"></param>
 public ServiceContext(
     IContentService contentService         = null,
     IMediaService mediaService             = null,
     IContentTypeService contentTypeService = null,
     IDataTypeService dataTypeService       = null,
     IFileService fileService = null,
     ILocalizationService localizationService = null,
     IPackagingService packagingService       = null,
     IEntityService entityService             = null,
     IRelationService relationService         = null,
     IMemberGroupService memberGroupService   = null,
     IMemberTypeService memberTypeService     = null,
     IMemberService memberService             = null,
     IUserService userService            = null,
     ISectionService sectionService      = null,
     IApplicationTreeService treeService = null,
     ITagService tagService = null,
     INotificationService notificationService   = null,
     ILocalizedTextService localizedTextService = null,
     IAuditService auditService                   = null,
     IDomainService domainService                 = null,
     ITaskService taskService                     = null,
     IMacroService macroService                   = null,
     IPublicAccessService publicAccessService     = null,
     IExternalLoginService externalLoginService   = null,
     IMigrationEntryService migrationEntryService = null)
 {
     if (migrationEntryService != null)
     {
         _migrationEntryService = new Lazy <IMigrationEntryService>(() => migrationEntryService);
     }
     if (externalLoginService != null)
     {
         _externalLoginService = new Lazy <IExternalLoginService>(() => externalLoginService);
     }
     if (auditService != null)
     {
         _auditService = new Lazy <IAuditService>(() => auditService);
     }
     if (localizedTextService != null)
     {
         _localizedTextService = new Lazy <ILocalizedTextService>(() => localizedTextService);
     }
     if (tagService != null)
     {
         _tagService = new Lazy <ITagService>(() => tagService);
     }
     if (contentService != null)
     {
         _contentService = new Lazy <IContentService>(() => contentService);
     }
     if (mediaService != null)
     {
         _mediaService = new Lazy <IMediaService>(() => mediaService);
     }
     if (contentTypeService != null)
     {
         _contentTypeService = new Lazy <IContentTypeService>(() => contentTypeService);
     }
     if (dataTypeService != null)
     {
         _dataTypeService = new Lazy <IDataTypeService>(() => dataTypeService);
     }
     if (fileService != null)
     {
         _fileService = new Lazy <IFileService>(() => fileService);
     }
     if (localizationService != null)
     {
         _localizationService = new Lazy <ILocalizationService>(() => localizationService);
     }
     if (packagingService != null)
     {
         _packagingService = new Lazy <IPackagingService>(() => packagingService);
     }
     if (entityService != null)
     {
         _entityService = new Lazy <IEntityService>(() => entityService);
     }
     if (relationService != null)
     {
         _relationService = new Lazy <IRelationService>(() => relationService);
     }
     if (sectionService != null)
     {
         _sectionService = new Lazy <ISectionService>(() => sectionService);
     }
     if (memberGroupService != null)
     {
         _memberGroupService = new Lazy <IMemberGroupService>(() => memberGroupService);
     }
     if (memberTypeService != null)
     {
         _memberTypeService = new Lazy <IMemberTypeService>(() => memberTypeService);
     }
     if (treeService != null)
     {
         _treeService = new Lazy <IApplicationTreeService>(() => treeService);
     }
     if (memberService != null)
     {
         _memberService = new Lazy <IMemberService>(() => memberService);
     }
     if (userService != null)
     {
         _userService = new Lazy <IUserService>(() => userService);
     }
     if (notificationService != null)
     {
         _notificationService = new Lazy <INotificationService>(() => notificationService);
     }
     if (domainService != null)
     {
         _domainService = new Lazy <IDomainService>(() => domainService);
     }
     if (taskService != null)
     {
         _taskService = new Lazy <ITaskService>(() => taskService);
     }
     if (macroService != null)
     {
         _macroService = new Lazy <IMacroService>(() => macroService);
     }
     if (publicAccessService != null)
     {
         _publicAccessService = new Lazy <IPublicAccessService>(() => publicAccessService);
     }
 }
Example #30
0
        public async Task PostSaveMember_SaveExistingMember_WithNoRoles_Add1Role_ExpectSuccessResponse(
            [Frozen] IMemberManager umbracoMembersUserManager,
            IMemberService memberService,
            IMemberTypeService memberTypeService,
            IMemberGroupService memberGroupService,
            IDataTypeService dataTypeService,
            IBackOfficeSecurityAccessor backOfficeSecurityAccessor,
            IBackOfficeSecurity backOfficeSecurity,
            IPasswordChanger <MemberIdentityUser> passwordChanger,
            IOptions <GlobalSettings> globalSettings,
            IUser user)
        {
            // arrange
            var     roleName = "anyrole";
            IMember member   = SetupMemberTestData(out MemberSave fakeMemberData, out MemberDisplay memberDisplay, ContentSaveAction.Save);

            fakeMemberData.Groups = new List <string>()
            {
                roleName
            };
            var membersIdentityUser = new MemberIdentityUser(123);

            Mock.Get(umbracoMembersUserManager)
            .Setup(x => x.FindByIdAsync(It.IsAny <string>()))
            .ReturnsAsync(() => membersIdentityUser);
            Mock.Get(umbracoMembersUserManager)
            .Setup(x => x.ValidatePasswordAsync(It.IsAny <string>()))
            .ReturnsAsync(() => IdentityResult.Success);
            Mock.Get(umbracoMembersUserManager)
            .Setup(x => x.UpdateAsync(It.IsAny <MemberIdentityUser>()))
            .ReturnsAsync(() => IdentityResult.Success);
            Mock.Get(umbracoMembersUserManager)
            .Setup(x => x.AddToRolesAsync(It.IsAny <MemberIdentityUser>(), It.IsAny <IEnumerable <string> >()))
            .ReturnsAsync(() => IdentityResult.Success);
            Mock.Get(memberTypeService).Setup(x => x.GetDefault()).Returns("fakeAlias");
            Mock.Get(backOfficeSecurityAccessor).Setup(x => x.BackOfficeSecurity).Returns(backOfficeSecurity);
            Mock.Get(memberService).Setup(x => x.GetByUsername(It.IsAny <string>())).Returns(() => member);
            Mock.Get(memberService).Setup(x => x.GetById(It.IsAny <int>())).Returns(() => member);

            SetupUserAccess(backOfficeSecurityAccessor, backOfficeSecurity, user);
            SetupPasswordSuccess(umbracoMembersUserManager, passwordChanger);

            Mock.Get(memberService).SetupSequence(
                x => x.GetByEmail(It.IsAny <string>()))
            .Returns(() => null)
            .Returns(() => member);
            MemberController sut = CreateSut(memberService, memberTypeService, memberGroupService, umbracoMembersUserManager, dataTypeService, backOfficeSecurityAccessor, passwordChanger, globalSettings, user);

            // act
            ActionResult <MemberDisplay> result = await sut.PostSave(fakeMemberData);

            // assert
            Assert.IsNull(result.Result);
            Assert.IsNotNull(result.Value);
            Mock.Get(umbracoMembersUserManager)
            .Verify(u => u.GetRolesAsync(membersIdentityUser));
            Mock.Get(umbracoMembersUserManager)
            .Verify(u => u.AddToRolesAsync(membersIdentityUser, new[] { roleName }));
            Mock.Get(memberService)
            .Verify(m => m.Save(It.IsAny <Member>()));
            AssertMemberDisplayPropertiesAreEqual(memberDisplay, result.Value);
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="MemberGroupController"/> class.
 /// </summary>
 /// <param name="memberGroupService">The member group service.</param>
 public MemberGroupController(IMemberGroupService memberGroupService)
 {
     MemberGroupService = memberGroupService;
 }
        public MemberController() {
            groupService = new GroupService();
            mgrService = new MemberGroupService();

        }
 public UmbracoMemberGroupInitializerService(IMemberGroupService memberGroupService)
 => _memberGroupService = memberGroupService