public void ProcessOrder(IEnumerable <IItem> items)
{
foreach (IItem item in items)
{
IRule rule;
switch (item.ProductType)
{
case (int)ProductTypeEnum.Book:
rule = new ProductRule(item);
break;
case (int)ProductTypeEnum.Video:
rule = new ProductRule(item);
break;
case (int)ProductTypeEnum.Subscription:
rule = new MembershipRule(item);
break;
default:
rule = null;
break;
}
if (rule != null)
{
rule.CompleteRule();
}
}
}
public virtual int GetComprehensionScore(MembershipRule rule, Auth0User user)
{
if (user == null)
{
return(0);
}
var memberLink =
user.MemberAuth0Users
.SingleOrDefault(
m => m.Member.OrganisationId == rule.MembershipRuleSection.ShurahBasedOrganisationId);
var users = new List <Auth0User> {
user
};
if (memberLink != null)
{
users.AddRange(memberLink.Member.MemberAuth0Users.Select(m => m.Auth0User));
}
return(users.SelectMany(u => u.MembershipRuleComprehensionTestResults)
.Where(t => t.MembershipRuleComprehensionQuestion.MembershipRuleId == rule.Id)
.Where(t => t.CorrectlyAnswered)
.Where(t => t.AnsweredDateTimeUtc > rule.PublishedDateTimeUtc)
.GroupBy(x => x.MembershipRuleComprehensionQuestionId).Count());
//var correctAnswers=_dependencies.StorageService.SetOf<MembershipRuleComprehensionTestResult>()
// .Where(r => r.MembershipRuleComprehensionQuestion.MembershipRuleId == rule.Id
// && ids.Contains(r.Auuth0UserId)
// && r.CorrectlyAnswered
// && r.StartedDateTimeUtc>rule.PublishedDateTimeUtc)
// .GroupBy(x=>x.MembershipRuleComprehensionQuestionId).Count();
//return correctAnswers;
}
public void CreateDiscoveries()
{
Discovery discovery = new Discovery()
{
ID = string.Format("ds.{0}", releationShipTypeId),
Enabled = true,
Target = parentid,
Category = "Discovery",
ConfirmDelivery = false,
Remotable = true,
Priority = "Normal",
DataSource = new DataSource()
{
ID = "DS",
TypeID = "SC!Microsoft.SystemCenter.GroupPopulator",
RuleId = "$MPElement$",
GroupInstanceId = "$Target/Id$"
}
};
MembershipRule rule = new MembershipRule()
{
MonitoringClass = string.Format("$MPElement[Name=\"{0}\"]$", parentid),
RelationshipClass = string.Format("$MPElement[Name=\"{0}\"]$", releationShipTypeId)
};
discovery.DataSource.MembershipRules.Add(rule);
}
public void PropertiesAreCorrectlyBuiltForTheRule()
{
MethodToTest(() => service.BuildMembershipRuleResource(A <string> .Ignored,
A <Auth0User> .Ignored, A <MembershipRule> .Ignored, A <int> .Ignored, A <IEnumerable <MembershipRuleTermDefinition> > .Ignored));
var prefix = "1.2.3.";
var index = 7;
var rule = new MembershipRule
{
RuleStatement = "some statement",
Id = 67,
// Explanation = new MembershipRuleExplanation { ExplanationUrl = "someurl"},
MembershipRuleComprehensionQuestions = new List <MembershipRuleComprehensionQuestion>(),
PublishedDateTimeUtc = DateTime.UtcNow
};
var user = new Auth0User();
var fragments = new List <TextFragmentResource>();
var terms = new List <MembershipRuleTermDefinition>();
A.CallTo(() => service.ParseRuleStatement(rule.RuleStatement, terms)).Returns(fragments);
A.CallTo(() => service.GetComprehensionScore(rule, user)).Returns(15);
A.CallTo(() => dependencies.LinqService.EnumerableCount(
rule.MembershipRuleComprehensionQuestions)).Returns(20);
var result = service.BuildMembershipRuleResource(prefix, user, rule, index, terms);
Assert.AreEqual(prefix + (index + 1), result.Number);
Assert.AreEqual(rule.Id, result.Id);
Assert.AreSame(fragments, result.RuleFragments);
// Assert.AreEqual(rule.Explanation.ExplanationUrl,result.ExplanationUrl);
Assert.AreEqual(15, result.ComprehensionScore);
Assert.AreEqual(20, result.MaxComprehensionScore);
Assert.AreEqual(rule.PublishedDateTimeUtc.ToString("s"), result.PublishedUtcDateTimeText);
Assert.AreEqual(rule.RuleStatement, result.RuleStatement);
}
public IOrderProcess GetProductRuleInstance(ProductType productType)
{
IOrderProcess orderRule;
switch (productType)
{
case ProductType.PhysicalProduct:
orderRule = new PhysicalProductRule();
break;
case ProductType.Book:
orderRule = new BookRule();
break;
case ProductType.Membership:
orderRule = new MembershipRule();
break;
case ProductType.MembershipUpgrade:
orderRule = new MembershipUpgradeRule();
break;
case ProductType.Video:
orderRule = new VideoRule();
break;
default:
orderRule = new NewProductRule();
break;
}
return(orderRule);
}
public List <string> GetMemberPermissions(Auth0User user, MembershipRule rule)
{
if (rule == null)
{
return(new List <string>());
}
return(GetMemberPermissions(user, rule.MembershipRuleSection));
}
public void RuleShouldApplyIsTrueWhenPOContainsRule()
{
var ipoReader = new Mock <IPOReader>();
ipoReader.Setup(x => x.Request).Returns(new List <string> {
"membership request books"
});
var rule = new MembershipRule(MembershipType.Books);
var actual = rule.ShouldApply(ipoReader.Object);
Assert.True(actual);
}
public void Add_Membership_Rule()
{
Payment payment = new Payment();
payment.PaymentType = Enum_PaymentType.Membership;
payment.ProductName = "Golf Club Membership";
payment.IsBook = false;
IRule rule = new MembershipRule();
ruleManager.AddRule(rule);
rule = new E_MailRule();
ruleManager.AddRule(rule);
var ruleResult = ruleManager.ExecuteRules(payment);
bool isMembershipRuleApplied = ruleResult.Contains("Activate Membership");
Assert.IsTrue(isMembershipRuleApplied);
bool isActivationMailSent = ruleResult.Contains("Mail To Owner About Membership Activation");
Assert.IsTrue(isActivationMailSent);
}
public ResponseResource CreateRule(IPrincipal principal, CreateMembershipRuleRequest request)
{
var user = _dependencies.UserService.GetAuthenticatedUser(principal);
var ruleSection = _dependencies.MembershipRuleSectionService.GetMembershipRuleSection(request.MembershipRuleSectionId);
var permissions = _dependencies.OrganisationService.GetMemberPermissions(user, ruleSection);
if (!permissions.Contains(ShurahOrganisationPermission.EditMembershipRules.ToString()))
{
return(new ResponseResource {
HasError = true, Error = "Access Denied!"
});
}
var rule = new MembershipRule();
_dependencies.StorageService.SetOf <MembershipRule>().Add(rule);
rule.MembershipRuleSection = ruleSection;
rule.RuleStatement = request.Rule;
rule.MembershipRuleSectionId = ruleSection.Id;
rule.Sequence = ruleSection.MembershipRules.Count + 2;
rule.PublishedDateTimeUtc = DateTime.UtcNow;
_dependencies.StorageService.SaveChanges();
return(new ResponseResource());
}
public virtual MembershipRuleResource BuildMembershipRuleResource(string rulePrefix, Auth0User user, MembershipRule rule, int ruleIndex, IEnumerable <MembershipRuleTermDefinition> terms)
{
var resource = new MembershipRuleResource();
resource.Id = rule.Id;
resource.Number = rulePrefix + (ruleIndex + 1);
resource.RuleFragments = ParseRuleStatement(rule.RuleStatement, terms);
resource.ComprehensionScore = GetComprehensionScore(rule, user);
resource.MaxComprehensionScore =
_dependencies.LinqService.EnumerableCount(rule.MembershipRuleComprehensionQuestions);
resource.PublishedUtcDateTimeText = rule.PublishedDateTimeUtc.ToString("s");
resource.RuleStatement = rule.RuleStatement;
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);
}
public MembershipRuleTest()
{
mockMembership = new Mock <IMembership>();
_membershipRule = new MembershipRule();
}
