public virtual List <string> GetMemberPermissions(Auth0User user, MembershipRuleSection section)
{
if (section == null)
{
return(new List <string>());
}
return(GetMemberPermissions(user, section.ShurahBasedOrganisation));
}
public virtual bool HasNoRootSection(MembershipRuleSection droppedSection)
{
var sectionIds = new List <int>();
sectionIds.Add(droppedSection.Id);
while (droppedSection.ParentMembershipRuleSection != null)
{
if (sectionIds.Contains(droppedSection.ParentMembershipRuleSection.ParentMembershipRuleSectionId))
{
return(true);
}
sectionIds.Add(droppedSection.ParentMembershipRuleSection.ParentMembershipRuleSectionId);
droppedSection = droppedSection.ParentMembershipRuleSection.ParentMembershipRuleSection;
}
return(false);
}
public void BuildsResourcesPerSection()
{
MethodToTest(() => service.BuildMembershipRuleSectionResources(A <string> .Ignored,
A <IEnumerable <MembershipRuleSection> > .Ignored,
A <IEnumerable <MembershipRuleTermDefinition> > .Ignored, A <Auth0User> .Ignored));
var sectionPrefix = "pre";
var user = new Auth0User();
var org = new ShurahBasedOrganisation
{
MembershipRuleSections = new List <MembershipRuleSection>(),
Terms = new List <MembershipRuleTermDefinition>()
};
var exampleIndex = 3;
var exampleSection = new MembershipRuleSection();
var exampleMembershipRuleSectionResource = new MembershipRuleSectionResource();
A.CallTo(() => service.BuildMembershipRuleSectionResource(sectionPrefix, exampleSection, user, exampleIndex, org.Terms))
.Returns(exampleMembershipRuleSectionResource);
var orderedSections = A.Fake <IOrderedEnumerable <MembershipRuleSection> >();
A.CallTo(() => dependencies.LinqService.OrderBy(org.MembershipRuleSections,
A <Func <MembershipRuleSection, int> > .That.Matches(x =>
x.Invoke(new MembershipRuleSection {
Sequence = 4
}) == 4
))).Returns(orderedSections);
var resources = new List <MembershipRuleSectionResource>();
A.CallTo(() => dependencies.LinqService.SelectIndexedEnumerable(orderedSections,
A <Func <MembershipRuleSection, int, MembershipRuleSectionResource> > .That.Matches(x =>
x.Invoke(exampleSection, exampleIndex) == exampleMembershipRuleSectionResource
))).Returns(resources);
var resourcesList = new List <MembershipRuleSectionResource>();
A.CallTo(() => dependencies.LinqService.EnumerableToList(resources)).Returns(resourcesList);
var result = service.BuildMembershipRuleSectionResources(sectionPrefix, org.MembershipRuleSections, org.Terms, user);
Assert.AreSame(resourcesList, result);
}
public virtual ResponseResource CreateRuleSection(IPrincipal principal, CreateMembershipRuleSectionRequest request)
{
var user = _dependencies.UserService.GetAuthenticatedUser(principal);
var organisation = _dependencies.OrganisationService.GetOrganisation(request.OrganisationId);
var permissions = _dependencies.OrganisationService.GetMemberPermissions(user, organisation);
if (!permissions.Contains(ShurahOrganisationPermission.EditMembershipRules.ToString()))
{
return(new ResponseResource {
HasError = true, Error = "Access Denied!"
});
}
if (organisation.MembershipRuleSections.Any(s => s.UniqueInOrganisationName == request.UniqueUrlSlug))
{
return(new ResponseResource {
HasError = true, Error = "Url id not unique!"
});
}
var ruleSection = new MembershipRuleSection();
_dependencies.StorageService.SetOf <MembershipRuleSection>().Add(ruleSection);
if (request.ParentSectionId.HasValue)
{
var parentSection =
organisation.MembershipRuleSections.FirstOrDefault(x => x.Id == request.ParentSectionId);
if (parentSection != null)
{
ruleSection.ParentMembershipRuleSection = new MembershipRuleSectionRelationship
{
ParentMembershipRuleSectionId = parentSection.Id,
};
}
}
ruleSection.ShurahBasedOrganisationId = organisation.Id;
ruleSection.UniqueInOrganisationName = request.UniqueUrlSlug;
ruleSection.PublishedDateTimeUtc = DateTime.UtcNow;
ruleSection.Title = request.Title;
_dependencies.StorageService.SaveChanges();
return(new ResponseResource());
}
public virtual MembershipRuleSectionResource BuildMembershipRuleSectionResource(string sectionPrefix,
MembershipRuleSection ruleSection, Auth0User user, int sectionIndex, IEnumerable <MembershipRuleTermDefinition> terms)
{
var resource = new MembershipRuleSectionResource();
resource.Title = ruleSection.Title;
resource.Id = ruleSection.Id;
resource.OrganisationId = ruleSection.ShurahBasedOrganisationId;
resource.SectionNumber = sectionPrefix + (sectionIndex + 1);
resource.UniqueName = ruleSection.UniqueInOrganisationName;
var orderedRules = _dependencies.LinqService.OrderBy(ruleSection.MembershipRules, r => r.Sequence);
var prefix = sectionPrefix + (sectionIndex + 1).ToString() + ".";
resource.Rules =
_dependencies.LinqService.EnumerableToList(
_dependencies.LinqService.SelectIndexedEnumerable(orderedRules,
(r, i) => BuildMembershipRuleResource(prefix, user, r, i, terms)));
resource.SubSections = BuildMembershipRuleSectionResources(
prefix,
_dependencies.LinqService.SelectEnumerable(ruleSection.ChildMembershipRuleSections,
x => x.MembershipRuleSection), terms, user);
return(resource);
}
public void AddsRulesWithTermsAndSubsections()
{
MethodToTest(() => service.BuildMembershipRuleSectionResource(A <string> .Ignored, A <MembershipRuleSection> .Ignored,
A <Auth0User> .Ignored, A <int> .Ignored, A <List <MembershipRuleTermDefinition> > .Ignored));
var sectionPrefix = "pre";
var sectionIndex = 3;
var section = new MembershipRuleSection
{
MembershipRules = new List <MembershipRule>(),
ChildMembershipRuleSections = new List <MembershipRuleSectionRelationship>()
};
var user = new Auth0User();
var terms = new List <MembershipRuleTermDefinition>();
var orderedRules = A.Fake <IOrderedEnumerable <MembershipRule> >();
A.CallTo(() => dependencies.LinqService.OrderBy(section.MembershipRules,
A <Func <MembershipRule, int> > .That.Matches(x =>
x.Invoke(new MembershipRule {
Sequence = 34
}) == 34
))).Returns(orderedRules);
var exampleRule = new MembershipRule();
var exampleRuleIndex = 4;
var rulePrefix = sectionPrefix + (sectionIndex + 1) + ".";
var exampleMembershipRuleResource = new MembershipRuleResource();
A.CallTo(() => service.BuildMembershipRuleResource(rulePrefix, user, exampleRule, exampleRuleIndex, terms))
.Returns(exampleMembershipRuleResource);
var ruleResources = new List <MembershipRuleResource>();
A.CallTo(() => dependencies.LinqService.SelectIndexedEnumerable(orderedRules,
A <Func <MembershipRule, int, MembershipRuleResource> > .That.Matches(x =>
x.Invoke(exampleRule, exampleRuleIndex) == exampleMembershipRuleResource
))).Returns(ruleResources);
var ruleResourcesList = new List <MembershipRuleResource>();
A.CallTo(() => dependencies.LinqService.EnumerableToList(ruleResources)).Returns(ruleResourcesList);
var childRuleSections = new List <MembershipRuleSection>();
var exampleRuleSectionRelationship = new MembershipRuleSectionRelationship
{
MembershipRuleSection = new MembershipRuleSection()
};
A.CallTo(() => dependencies.LinqService.SelectEnumerable(section.ChildMembershipRuleSections,
A <Func <MembershipRuleSectionRelationship, MembershipRuleSection> > .That.Matches(x =>
x.Invoke(exampleRuleSectionRelationship) ==
exampleRuleSectionRelationship.MembershipRuleSection
))).Returns(childRuleSections);
var childResourceSections = new List <MembershipRuleSectionResource>();
A.CallTo(() => service.BuildMembershipRuleSectionResources(
rulePrefix, childRuleSections, terms, user))
.Returns(childResourceSections);
var result = service.BuildMembershipRuleSectionResource(sectionPrefix, section, user, sectionIndex, terms);
Assert.AreSame(ruleResourcesList, result.Rules);
Assert.AreSame(childResourceSections, result.SubSections);
}
