/// <summary>
/// Constructs an empty rule builder.
/// </summary>
public RuleBuilder()
{
var rootScope = new SymbolTable();
_dependencyBuilder = new DependencyGroupBuilder(rootScope);
_groupBuilder = new GroupBuilder(rootScope, GroupType.And);
_actionGroupBuilder = new ActionGroupBuilder(rootScope);
}
public async Task Success_when_member_has_administrator_permission() => await Run(async sut =>
{
var group = await GroupBuilder.For(sut).CreateGroup("group1")
.AsOwner()
.CreateRole("role1").AddPermission("Administrator").Build()
.CreateMember().AssignRole(1).Build()
.CreateMember().Build()
.CreateChannel("channel1").Build()
.Build()
.Build();
await sut.SendAsync(new AllowPermissionForMemberCommand(@group.Member(1).UserId, @group.GroupId, @group.Channel(1).ChannelId, @group.Member(2).UserId, "ReadMessages"));
var overrides = await sut.QueryAsync(
new GetChannelMemberPermissionOverridesQuery(@group.GroupId, @group.Channel(1).ChannelId, @group.Member(2).UserId)
);
overrides.Should().ContainEquivalentOf(
new PermissionOverrideDto
{
Type = OverrideTypeDto.Allow,
Permission = "ReadMessages"
}
);
});
public async Task Member_without_manage_roles_permission_but_with_allow_manage_roles_override_on_role_in_given_channel_can_change_all_permissions_in_channel() => await Run(async sut =>
{
var group = await GroupBuilder.For(sut).CreateGroup("group1")
.AsOwner()
.CreateRole("role1").Build()
.CreateMember().AssignRole(1).Build()
.CreateMember().Build()
.CreateChannel("channel1").AllowPermissionForMember(1, "ManageRoles").Build()
.Build()
.Build();
await sut.SendAsync(new AllowPermissionForMemberCommand(@group.Member(1).UserId, @group.GroupId, @group.Channel(1).ChannelId, @group.Member(2).UserId, "SendMessages"));
var overrides = await sut.QueryAsync(
new GetChannelMemberPermissionOverridesQuery(@group.GroupId, @group.Channel(1).ChannelId, @group.Member(2).UserId)
);
overrides.Should().ContainEquivalentOf(
new PermissionOverrideDto
{
Type = OverrideTypeDto.Allow,
Permission = "SendMessages"
}
);
});
public async Task Member_with_manage_roles_permission_can_add_new_role() => await Run(async sut =>
{
//arrange
var group = await GroupBuilder.For(sut).CreateGroup("group1")
.AsOwner()
.CreateRole("role1").AddPermission("ManageRoles").Build()
.CreateMember().AssignRole(1).Build()
.Build().Build();
var role2Id = Guid.NewGuid();
//act
await sut.SendAsync(new AddRoleCommand(group.Member(1).UserId, group.GroupId, role2Id, "role2"));
//assert
var roles = await sut.QueryAsync(new GetRolesQuery(group.OwnerId, group.GroupId));
roles.Should().SatisfyRespectively(
x =>
{
x.RoleId.Should().Be(group.Role(1).RoleId);
x.Priority.Should().Be(1);
x.Name.Should().Be("role1");
},
x =>
{
x.RoleId.Should().Be(role2Id);
x.Priority.Should().Be(0);
x.Name.Should().Be("role2");
},
x =>
{
x.RoleId.Should().NotBeEmpty();
x.Priority.Should().Be(-1);
x.Name.Should().Be("@everyone");
}
);
});
public async Task User_defined_role_cannot_be_moved_below_everyone_role() => await Run(async sut =>
{
var group = await GroupBuilder.For(sut).CreateGroup("group1")
.AsOwner()
.CreateRole("role1").Build().Build().Build();
await sut.SendAsync(new MoveDownRoleInHierarchyCommand(group.OwnerId, group.GroupId, group.Role(1).RoleId));
var roles = await sut.QueryAsync(new GetRolesQuery(group.OwnerId, group.GroupId));
roles.Should().SatisfyRespectively(
x =>
{
x.RoleId.Should().Be(group.Role(1).RoleId);
x.Priority.Should().Be(0);
x.Name.Should().Be("role1");
},
x =>
{
x.RoleId.Should().NotBeEmpty();
x.Priority.Should().Be(-1);
x.Name.Should().Be("@everyone");
}
);
});
override public void Execute()
{
inviteUsersToMyAccount();
displayAccountGroupsAndMembers();
Group emptyGroup = GroupBuilder.NewGroup(Guid.NewGuid().ToString())
.WithId(new GroupId(Guid.NewGuid().ToString()))
.WithEmail("*****@*****.**")
.WithoutIndividualMemberEmailing()
.Build();
createdEmptyGroup = ossClient.GroupService.CreateGroup(emptyGroup);
List <GroupMember> retrievedEmptyGroup = ossClient.GroupService.GetGroupMembers(createdEmptyGroup.Id);
GroupMember addMember = ossClient.GroupService.AddMember(createdEmptyGroup.Id,
GroupMemberBuilder.NewGroupMember(email1)
.AsMemberType(GroupMemberType.MANAGER)
.Build());
Group inviteMember = ossClient.GroupService.InviteMember(createdEmptyGroup.Id,
GroupMemberBuilder.NewGroupMember(email3)
.AsMemberType(GroupMemberType.MANAGER)
.Build());
Console.Out.WriteLine("GroupId: " + createdEmptyGroup.Id.Id);
retrievedEmptyGroup = ossClient.GroupService.GetGroupMembers(createdEmptyGroup.Id);
String groupName = Guid.NewGuid().ToString();
Group group1 = GroupBuilder.NewGroup(GROUP_NAME_PREFIX + groupName)
.WithId(new GroupId(Guid.NewGuid().ToString()))
.WithMember(GroupMemberBuilder.NewGroupMember(email1)
.AsMemberType(GroupMemberType.MANAGER))
.WithMember(GroupMemberBuilder.NewGroupMember(email3)
.AsMemberType(GroupMemberType.MANAGER))
.WithEmail(EMAIL)
.WithIndividualMemberEmailing()
.Build();
createdGroup1 = ossClient.GroupService.CreateGroup(group1);
Console.Out.WriteLine("GroupId #1: " + createdGroup1.Id.Id);
ossClient.GroupService.AddMember(createdGroup1.Id,
GroupMemberBuilder.NewGroupMember(email3)
.AsMemberType(GroupMemberType.MANAGER)
.Build());
ossClient.GroupService.AddMember(createdGroup1.Id,
GroupMemberBuilder.NewGroupMember(email4)
.AsMemberType(GroupMemberType.REGULAR)
.Build());
retrievedGroup1 = ossClient.GroupService.GetGroup(createdGroup1.Id);
// Retrieve by group name
retrievedGroupByName1 = ossClient.GroupService.GetMyGroups(createdGroup1.Name);
String groupName2 = Guid.NewGuid().ToString();
Group group2 = GroupBuilder.NewGroup(GROUP_NAME_PREFIX + groupName2)
.WithMember(GroupMemberBuilder.NewGroupMember(email2)
.AsMemberType(GroupMemberType.MANAGER))
.WithEmail(EMAIL)
.WithIndividualMemberEmailing()
.Build();
createdGroup2 = ossClient.GroupService.CreateGroup(group2);
retrievedGroup2 = ossClient.GroupService.GetGroup(createdGroup2.Id);
Console.Out.WriteLine("GroupId #2: " + createdGroup2.Id.Id);
String groupName3 = Guid.NewGuid().ToString();
Group group3 = GroupBuilder.NewGroup(GROUP_NAME_PREFIX + groupName3)
.WithMember(GroupMemberBuilder.NewGroupMember(email3)
.AsMemberType(GroupMemberType.MANAGER))
.WithEmail(EMAIL)
.WithIndividualMemberEmailing()
.Build();
createdGroup3 = ossClient.GroupService.CreateGroup(group3);
Console.Out.WriteLine("GroupId #3: " + createdGroup3.Id.Id);
retrievedGroup3 = ossClient.GroupService.GetGroup(createdGroup3.Id);
// Retrieve by group name
retrievedByNamePrefix = ossClient.GroupService.GetMyGroups(GROUP_NAME_PREFIX);
allGroupsBeforeDelete = ossClient.GroupService.GetMyGroups();
allGroupsAfterDelete = ossClient.GroupService.GetMyGroups();
Group updatedGroup = GroupBuilder.NewGroup(Guid.NewGuid().ToString())
.WithMember(GroupMemberBuilder.NewGroupMember(email2)
.AsMemberType(GroupMemberType.MANAGER))
.WithMember(GroupMemberBuilder.NewGroupMember(email3)
.AsMemberType(GroupMemberType.REGULAR))
.WithMember(GroupMemberBuilder.NewGroupMember(email4)
.AsMemberType(GroupMemberType.REGULAR))
.WithEmail(EMAIL)
.WithIndividualMemberEmailing()
.Build();
createdGroup3Updated = ossClient.GroupService.UpdateGroup(updatedGroup, createdGroup3.Id);
groupMemberEmailsAfterUpdate = ossClient.GroupService.GetGroupMemberEmails(createdGroup3Updated.Id);
DocumentPackage superDuperPackage = PackageBuilder.NewPackageNamed(PackageName)
.WithSigner(SignerBuilder.NewSignerFromGroup(createdGroup1.Id)
.CanChangeSigner()
.DeliverSignedDocumentsByEmail())
.WithDocument(DocumentBuilder.NewDocumentNamed("First Document")
.FromStream(fileStream1, DocumentType.PDF)
.WithSignature(SignatureBuilder.SignatureFor(createdGroup1.Id)
.OnPage(0)
.AtPosition(100, 100)))
.Build();
PackageId packageId = ossClient.CreatePackage(superDuperPackage);
ossClient.SendPackage(packageId);
ossClient.PackageService.NotifySigner(packageId, createdGroup1.Id);
DocumentPackage result = ossClient.GetPackage(packageId);
ossClient.GroupService.DeleteGroup(createdGroup1.Id);
ossClient.GroupService.DeleteGroup(createdGroup2.Id);
ossClient.GroupService.DeleteGroup(createdGroup3.Id);
}
public GroupBuilderChain(GroupBuilder rootGroupBuilder)
{
_groupBuilders.Push(rootGroupBuilder);
}
public LeftHandSideExpression(GroupBuilder builder, SymbolStack symbolStack)
{
_builder = builder;
_symbolStack = symbolStack;
}
public void ShouldOrderByZToAAsSpecified()
{
// Arrange
var groupCategory = new GroupCategory("name", "slug", "icon", "image");
var location = new MapPosition()
{
Lat = 5, Lon = -2
};
var contentfulGroupFirst = new ContentfulGroupBuilder().Slug("slug1").Build();
var contentfulGroupSecond = new ContentfulGroupBuilder().Slug("slug2").Build();
var contentfulGroupThird = new ContentfulGroupBuilder().Slug("slug3").Build();
var collection = new ContentfulCollection <ContentfulGroup>
{
Items = new List <ContentfulGroup> {
contentfulGroupFirst, contentfulGroupSecond, contentfulGroupThird
}
};
var groupfirst = new GroupBuilder().Name("aGroup").Slug("slug1").MapPosition(location).CategoriesReference(new List <GroupCategory>()
{
groupCategory
}).Build();
var groupsecond = new GroupBuilder().Name("bGroup").Slug("slug2").MapPosition(location).CategoriesReference(new List <GroupCategory>()
{
groupCategory
}).Build();
var groupthird = new GroupBuilder().Name("cGroup").Slug("slug3").MapPosition(location).CategoriesReference(new List <GroupCategory>()
{
groupCategory
}).Build();
var builder = new QueryBuilder <ContentfulGroup>().ContentTypeIs("group").Include(1).FieldEquals("fields.mapPosition[near]", Defaults.Groups.StockportLatitude + "," + Defaults.Groups.StockportLongitude + ",10").Build();
_client.Setup(o => o.GetEntries <ContentfulGroup>(It.Is <string>(q => q.Contains(builder)),
It.IsAny <CancellationToken>())).ReturnsAsync(collection);
var noLatLngBuilder = new QueryBuilder <ContentfulGroup>().ContentTypeIs("group").Include(1).Build();
_client.Setup(o => o.GetEntries <ContentfulGroup>(It.Is <string>(q => q.Contains(noLatLngBuilder)),
It.IsAny <CancellationToken>())).ReturnsAsync(collection);
_groupFactory.Setup(o => o.ToModel(contentfulGroupFirst)).Returns(groupfirst);
_groupFactory.Setup(o => o.ToModel(contentfulGroupSecond)).Returns(groupsecond);
_groupFactory.Setup(o => o.ToModel(contentfulGroupThird)).Returns(groupthird);
_cacheWrapper.Setup(o => o.GetFromCacheOrDirectlyAsync(It.Is <string>(s => s == "group-categories"), It.IsAny <Func <Task <List <GroupCategory> > > >(), It.Is <int>(s => s == 60))).ReturnsAsync(new List <GroupCategory>()
{
groupCategory
});
// Act
var response = AsyncTestHelper.Resolve(_repository.GetGroupResults(new GroupSearch
{
Category = string.Empty,
GetInvolved = string.Empty,
Latitude = 0.0d,
Location = string.Empty,
Longitude = 0.0d,
Order = "name z-a",
Organisation = string.Empty,
SubCategories = string.Empty,
Tag = string.Empty,
Tags = string.Empty
}, "slug"));
var filteredGroupResults = response.Get <GroupResults>();
// Assert
filteredGroupResults.Groups.First().Should().Be(groupthird);
filteredGroupResults.Groups[1].Should().Be(groupsecond);
filteredGroupResults.Groups[2].Should().Be(groupfirst);
}
public LeftHandSideExpression(RuleBuilder builder)
{
_builder = builder;
_groupBuilder = builder.LeftHandSide();
}
public QueryExpression(ParameterExpression symbol, GroupBuilder groupBuilder)
{
_symbol = symbol;
_groupBuilder = groupBuilder;
Builder = this;
}
internal ValueBuilder(GroupBuilder groupBuilder, string key)
{
Assert.IsFalse(bound, "Already bound this Key");
this.groupBuilder = groupBuilder;
this.key = key;
}
void OnEnable()
{
groupBuilder = target as GroupBuilder;
}
public GroupBuilder AddGroup(string text)
{
GroupBuilder group = new GroupBuilder(this, text);
_layout.AddRow(group.Root);
return group;
}
private void btn_TestDayData_Click(object sender, EventArgs e)
{
//string code = "600519";
////if(!dtp.RuntimeInfo.SecurityCodes.Contains(code))
////{
//// MessageBox.Show(string.Format("证券{0}不存在！",code));
//// return;
////}
int MaxThrdCnt = int.Parse(this.txt_maxThreadCnt.Text);
int GrpUnitCnt = int.Parse(this.txt_GrpUnitCnt.Text);
int ThrdInterVal = int.Parse(this.txt_ThrdInterval.Text);
CommMarketClass cmc = new CommMarketClass(dtp);
string strendT = this.txt_endT.Text;
string strbegT = this.txt_begT.Text;
if (useCodes == null)
{
useCodes = cmc.GetMarketsStocks("000001", strendT, 500, true, true, false);
}
string[] currCodes = new string[useCodes.Length];
try
{
Array.Copy(useCodes, 0, currCodes, 0, currCodes.Length);
List <string[]> codeGrps = GroupBuilder.ToGroup <string>(currCodes, currCodes.Length / dtp.ThreadUnitCnt);
begT = DateTime.Now;
DisplayCnt(currCodes.Length, codeGrps.Count, 0, 0, 0);
SecurityGrpReader <StockMongoData> sgr = new SecurityGrpReader <StockMongoData>();
sgr.CheckEvent = DisplayCnt;
MongoDataDictionary <StockMongoData> data = sgr.GetResult(codeGrps, (a) =>
{
SecurityReader sr = new SecurityReader(dtp.DataType, dtp.HistoryTable, a);
MongoDataDictionary <StockMongoData> res = sr.GetAllCodeDateSerialDataList <StockMongoData>(strbegT, strendT);
return(res);
}, dtp.MaxThreadCnt, 1);
DisplayCnt(currCodes.Length, codeGrps.Count, MaxThrdCnt, 0, data.Count);
begT = DateTime.Now;
List <MongoDataDictionary <StockMongoData> > datalist = GroupBuilder.ToGroup <StockMongoData>(data, currCodes.Length / dtp.ThreadUnitCnt);
sgr.CheckEvent = DisplayCnt;
data = sgr.GetResult(datalist, (a) =>
{
return(new SecurityReader(dtp.DataType).FQ(a, dtp.RuntimeInfo.XDXRList));
}, dtp.MaxThreadCnt, 1);
DisplayCnt(currCodes.Length, codeGrps.Count, MaxThrdCnt, 0, data.Count);
//// reader.GetAllCodeDateSerialDataList<StockMongoData>("2015-07-15", "2019-03-27");
////data = reader.Stock_FQ(data, dtp.RuntimeInfo.XDXRList);
////MongoReturnDataList<StockMongoData> fqdata = reader.Stock_FQ(code, data);
////////int n = 0;
////////StockMongoData testobj = null;
////////var test = fqdata.Where(a => (a.date == "2015-07-15"));
////////testobj = test.First();
////////MessageBox.Show(string.Format("{0},{1}", testobj.date, testobj.close));
////////n = fqdata.Count/2;
////////MessageBox.Show(string.Format("{0},{1}", fqdata[n].date, fqdata[n].close));
////////n = fqdata.Count-1;
////////MessageBox.Show(string.Format("{0},{1}", fqdata[n].date, fqdata[n].close));
////EMA ema1 = new EMA(fqdata.ToList(a => a.close).ToArray(),12);
////EMA ema2 = new EMA(fqdata.ToList(a => a.close).ToArray(), 26);
////Matrix e1 = ema1.GetResult();
////Matrix e2 = ema2.GetResult();
////int n = fqdata.Count - 1;
////MessageBox.Show(string.Format("12:{0:f2},26:{1:f2}",e1[n-1,0],e2[n-1,0]));
////MACD macd = new MACD(fqdata.ToList(a => a.close).ToArray());
////Matrix ret = macd.GetResult();
////int cnt = 10;
////for (int i = 0; i < cnt; i++)
////{
//// MessageBox.Show(string.Format("{0}:{4:f2}=>Diff:{1:f2};DEA:{2:f2};MACD:{3:f2}", fqdata[n - i].date, ret.Detail[n - i, 0], ret.Detail[n - i, 1], ret.Detail[n - i, 2],fqdata[n-i].close));
////}
}
catch (Exception ce)
{
MessageBox.Show(ce.Message);
}
}
override public void Execute()
{
Placeholder signer1Id = new Placeholder(Guid.NewGuid().ToString());
DocumentPackage superDuperPackage =
PackageBuilder.NewPackageNamed("SignerManipulationExample: " + DateTime.Now)
.DescribedAs("This is a package created using the e-SignLive SDK")
.WithSigner(SignerBuilder.NewSignerWithEmail(email1)
.WithFirstName("firstName1")
.WithLastName("lastName1")
.WithTitle("Title1")
)
.WithSigner(SignerBuilder.NewSignerWithEmail(email2)
.WithFirstName("firstName2")
.WithLastName("lastName2")
.WithTitle("Title2")
)
.Build();
packageId = eslClient.CreatePackage(superDuperPackage);
DocumentPackage createdPackage = eslClient.GetPackage(packageId);
string signerId = createdPackage.Signers[email1].Id;
string signer2Id = createdPackage.Signers[email2].Id;
// eslClient.SignerService.UpdateSigner( packageId, signerId, SignerBuilder.NewSignerWithEmail(email1)
// .WithFirstName("firstName1b")
// .WithLastName("lastName1b")
// .WithTitle("title1b") );
string addedSignerId = eslClient.PackageService.AddSigner(packageId,
SignerBuilder.NewSignerWithEmail(email3)
.WithFirstName("firstName3")
.WithLastName("lastName3")
.WithTitle("Title3")
.Lock()
.Build()
);
string placeHolderId = eslClient.PackageService.AddSigner(packageId,
SignerBuilder.NewSignerPlaceholder(new Placeholder("placeHolderRoleId"))
.Build()
);
Group avengers = eslClient.GroupService.CreateGroup(GroupBuilder.NewGroup(Guid.NewGuid().ToString()).WithEmail("*****@*****.**").Build());
string addedGroupSignerId = eslClient.PackageService.AddSigner(packageId,
SignerBuilder.NewSignerFromGroup(avengers.Id)
.Build());
eslClient.PackageService.RemoveSigner(packageId, placeHolderId);
eslClient.PackageService.RemoveSigner(packageId, signerId);
eslClient.PackageService.UpdateSigner(packageId, SignerBuilder.NewSignerWithEmail("*****@*****.**")
.WithCustomId(signer2Id)
.WithFirstName("updateFirstName1")
.WithLastName("updateLastName1")
.WithTitle("UpdatedTitle1")
.Build());
Signer retrievedSigner = eslClient.PackageService.GetSigner(packageId, addedSignerId);
//eslClient.SendPackage(packageId);
eslClient.PackageService.UnlockSigner(PackageId, addedSignerId);
}
public CollectPatternExpression(RuleBuilder builder, GroupBuilder groupBuilder, PatternBuilder patternBuilder)
: base(builder, groupBuilder)
{
_patternBuilder = patternBuilder;
}
public static FormViewModel CreateForm()
{
var htmlContent = new HtmlElementBuilder().SetName("HtmlContent").SetContent(
"<h2 style=\"text-align: center;\"><strong>Demo Form<br /></strong></h2>\r\n<p>Test HTML Content embedded in the demo form</p>\r\n<ul>\r\n<li>FirstName / LastName</li>\r\n<li>Years of experiance</li>\r\n<li>Accept Terms and Conditions</li>\r\n<li>Submit</li>\r\n</ul>")
.Build();
var firstNameText = new TextElementBuilder()
.SetName("First Name")
.SetLabel(ElementLabel.Left("First Name: "))
.SetDefaultValue("First Name")
.AddRules(
ValidationRule <ITextElementViewModel> .Create(new TextElement_MaximumLength_Validator(10))
.WithFailMessage("First Name must be less then 10 characters"),
ValidationRule <ITextElementViewModel> .Create(new TextElement_MinimunLength_Validator(2))
.WithFailMessage("First Name must be greater then 2 characters"))
.Build();
var lastNameText = new TextElementBuilder()
.SetName("Last Name")
.SetLabel(ElementLabel.Left("Last Name: "))
.SetDefaultValue("Last Name")
.AddRules(
ValidationRule <ITextElementViewModel> .Create(new TextElement_MaximumLength_Validator(10))
.WithFailMessage("Last Name must be less then 10 characters"),
ValidationRule <ITextElementViewModel> .Create(new TextElement_MinimunLength_Validator(2))
.WithFailMessage("Last Name must be greater then 2 characters"))
.Build();
var personalDetails = new LinearLayoutBuilder().SetName("personalDetails")
.AddChildren(firstNameText, lastNameText).SetOrientation(LayoutOrientation.Horizontal).Build();
var experienceSelection = new SelectElementBuilder().SetName("experienceSelection")
.SetLabel(ElementLabel.Left("How many years experience have you got?")).AddValues("0-1", "1-5", "5+")
.SetDefaultValue("Select a value").Build();
var termsAndConditions = new CheckElementBuilder().SetName("TermsAndConditions")
.SetLabel(ElementLabel.Left("Do you accept the terms and conditions?")).SetContent("Yes / No").AddRules(
ValidationRule <ICheckElementViewModel> .Create(new CheckElement_IsChecked_Validator())
.WithFailMessage("You must accept the terms and conditions")).Build();
var submitButton = new ButtonElementBuilder().SetName("Submit Button").SetContent("Submit")
.SetVerticalAlignment(VerticalAlignment.Bottom).Build();
var submitEventListenerAcceptsTerms = new EventListener("submit",
new ElementNameEventSpecification("Submit Button").And(
new TypeNameEventSpecification(nameof(ButtonElementClickedEvent))),
new ElementPropertyFormSpecification("TermsAndConditions", "IsChecked", "True"));
var submitEventListenerExperience = new EventListener("tooLittleExperiance",
new ElementNameEventSpecification("Submit Button").And(
new TypeNameEventSpecification(nameof(ButtonElementClickedEvent))),
new ElementPropertyFormSpecification("experienceSelection", "SelectedItem", "0-1"));
var rowGroup1 = new LinearLayoutBuilder().SetName("Data Entry Rows")
.AddChildren(htmlContent, personalDetails, experienceSelection, termsAndConditions).Build();
var rootGroup = new GroupBuilder().SetName("Test Group 1").SetTitle("Demo Form Title")
.AddChildren(rowGroup1, submitButton).Build();
var newForm = new FormBuilder().SetName("Demo Form").SetTitle("Demo Form Title").SetRoot(rootGroup)
.AddEventListeners(submitEventListenerAcceptsTerms, submitEventListenerExperience)
.Build();
return(new FormViewModel(newForm));
}
public PkConversa(PkUsuarioConversa usuario, List <ChatProfess> mensagensDoUsuario, int codigoDoCliente, GroupBuilder groupBuilder, bool deveOrdenar = true)
{
this.Codigo = usuario.Codigo;
this.Nome = usuario.Nome.GetPrimeiroEUltimoNome();
this.Foto = FotoTrata.ToBase64String(usuario.Foto);
this.Status = usuario.Status;
this.Tipo = usuario.Tipo;
if (this.Status == this.Tipo)
{
this.Status = TipoDeUsuarioDoChatTrata.TipoExtenso(this.Tipo);
}
this.CodigoDaEscola = codigoDoCliente;
this.GroupName = groupBuilder.BuildGroupName(codigoDoCliente, usuario.Tipo, usuario.Codigo);
this.Mensagens = mensagensDoUsuario
.Select(mensagem => new PkMensagem(mensagem, groupBuilder, codigoDoCliente))
.ToList();
if (deveOrdenar)
{
this.Mensagens = this.Mensagens
.OrderBy(x => x.DataDaMensagem)
.ToList();
}
this.SetDataDaUltimaMensagem();
}
/// <summary>
/// Gets a group for a given material
/// </summary>
/// <param name="material">Group material</param>
/// <returns>Returns an existing unretired group that matches the specified material, or a new group</returns>
public GroupBuilder GetGroup( GroupMaterial material )
{
foreach ( GroupBuilder group in m_Groups )
{
if ( group.Material == material )
{
return group;
}
}
GroupBuilder newGroup = new GroupBuilder( material );
m_Groups.Add( newGroup );
return newGroup;
}
public LeftHandSideExpression(RuleBuilder builder, GroupBuilder groupBuilder)
{
_builder = builder;
_groupBuilder = groupBuilder;
}
public void Fill(GroupBuilder builder)
{
builder.BuildIdClause("year", "{ '$year': '$StartDate' }");
builder.BuildIdClause("month", "{ '$month': '$StartDate' }");
builder.BuildIdClause("day", "{ '$dayOfMonth': '$StartDate' }");
}
public void ShouldReturnListOfGroupsWhereAdministratorMatchesEmailAddress()
{
// Arrange
var emailAddress = "*****@*****.**";
var contentfulGroupsReturned = new List <ContentfulGroup>();
var correctContentfulGroup = new ContentfulGroupBuilder().GroupAdministrators(new GroupAdministrators()
{
Items = new List <GroupAdministratorItems>()
{
new GroupAdministratorItems()
{
Email = emailAddress, Permission = "A"
}
}
}).Build();
contentfulGroupsReturned.Add(new ContentfulGroupBuilder().GroupAdministrators(new GroupAdministrators()
{
Items = new List <GroupAdministratorItems> {
new GroupAdministratorItems()
{
Email = "*****@*****.**", Permission = "E"
}
}
}).Build());
contentfulGroupsReturned.Add(correctContentfulGroup);
contentfulGroupsReturned.Add(new ContentfulGroupBuilder().GroupAdministrators(new GroupAdministrators()
{
Items = new List <GroupAdministratorItems> {
new GroupAdministratorItems()
{
Email = "*****@*****.**", Permission = "A"
}
}
}).Build());
contentfulGroupsReturned.Add(new ContentfulGroupBuilder().GroupAdministrators(new GroupAdministrators()
{
Items = new List <GroupAdministratorItems> {
new GroupAdministratorItems()
{
Email = "*****@*****.**", Permission = "A"
}
}
}).Build());
var collection = new ContentfulCollection <ContentfulGroup>();
collection.Items = contentfulGroupsReturned;
var groupReturned = new GroupBuilder().GroupAdministrators(new GroupAdministrators()
{
Items = new List <GroupAdministratorItems>()
{
new GroupAdministratorItems()
{
Email = emailAddress, Permission = "A"
}
}
}).Build();
var builder = new QueryBuilder <ContentfulGroup>().ContentTypeIs("group").FieldExists("fields.groupAdministrators")
.Include(1)
.Limit(ContentfulQueryValues.LIMIT_MAX);
_client.Setup(
o => o.GetEntries(It.Is <QueryBuilder <ContentfulGroup> >(q => q.Build() == builder.Build()),
It.IsAny <CancellationToken>())).ReturnsAsync(collection);
_groupFactory.Setup(o => o.ToModel(correctContentfulGroup)).Returns(groupReturned);
// Act
var response = AsyncTestHelper.Resolve(_repository.GetAdministratorsGroups(emailAddress));
var filteredGroups = response.Get <List <Group> >();
// Assert
filteredGroups.Count().Should().Be(1);
}
void OnEnable()
{
groupBuilder = target as GroupBuilder;
}
