public async Task <ActionResult> AddMember(string user_uid, int?flag)
{
return(await RunActionAsync(async() =>
{
if (!ValidateHelper.IsPlumpString(user_uid) || flag == null)
{
return GetJsonRes("参数错误");
}
if (!MemberRoleHelper.IsValid(flag.Value))
{
return GetJsonRes("权限值错误");
}
var org_uid = this.GetSelectedOrgUID();
var map = new OrganizationMemberEntity()
{
OrgUID = org_uid,
UserUID = user_uid,
Flag = flag.Value,
MemberApproved = (int)YesOrNoEnum.是,
OrgApproved = (int)YesOrNoEnum.是,
};
var res = await this._orgService.AddMember(map);
if (res.error)
{
return GetJsonRes(res.msg);
}
return GetJsonRes(string.Empty);
}));
}
public async Task AddOrganization_Success(
Organization organization,
OrganizationMemberEntity memb,
Mock <IMapper <OrganizationMemberEntity, OrganizationMember> > orgMemberDomainMapper
)
{
// Arrange
var mapMember = new Mock <IMapper <OrganizationMember, OrganizationMemberEntity> >();
mapMember.Setup(x => x.Map(It.IsAny <OrganizationMember>())).Returns(mapMember.Object);
mapMember.Setup(x => x.ToOutFormat()).Returns(memb);
var mapDomain = new OrganizationDomainMapper(orgMemberDomainMapper.Object);
var entityMapper = new OrganizationEntityMapper(mapMember.Object);
var db = new InMemoryDb <OrganizationDbContext>();
var context = new OrganizationDbContext(db.GetOptions());
var repo = new ReadWriteOrganizationRepository(context, entityMapper, mapDomain, mapMember.Object);
// Act
await repo.AddOrganization(organization);
var actual = await context.Organizations.FindAsync(organization.Id.Id);
// Assert
actual.Id.Should().Be(organization.Id.Id);
organization.Address.Should().BeEquivalentTo(actual, options => options.ExcludingMissingMembers());
}
public virtual async Task <_ <OrganizationMemberEntity> > AddMember(OrganizationMemberEntity model)
{
var res = new _ <OrganizationMemberEntity>();
if (await this._orgMemberRepo.GetCountAsync(x => x.OrgUID == model.OrgUID) >= 500)
{
res.SetErrorMsg("成员数达到上限");
return(res);
}
await this._orgMemberRepo.DeleteWhereAsync(x => x.UserUID == model.UserUID && x.OrgUID == model.OrgUID);
return(await this._orgMemberRepo.AddEntity_(model, "org-member"));
}
public void OrganizationMemberDomainMapper_Entity_ReturnsDomain(OrganizationMemberEntity organizationEntity)
{
//Arrange
IMapper <OrganizationMemberEntity, OrganizationMember> sut = new OrganizationMemberDomainMapper();
//Act
var actual = sut.Map(organizationEntity).ToOutFormat();
//Assert
actual.OrganizationId.Id.Should().Be(organizationEntity.OrganizationId);
actual.Email.ActualEmail.Should().Be(organizationEntity.Email);
actual.UserName.Should().Be(organizationEntity.UserName);
actual.Permission.Should().Be(organizationEntity.Permission);
}
public async Task <ActionResult> Save(string data)
{
return(await RunActionAsync(async() =>
{
var model = this.JsonToEntity_ <OrganizationEntity>(data);
var loginuser = await this.GetLoginUserAsync();
model.UserUID = loginuser.UserID;
if (ValidateHelper.IsPlumpString(model.UID))
{
var res = await this._orgService.UpdateOrg(model);
if (res.error)
{
return GetJsonRes(res.msg);
}
var map = new OrganizationMemberEntity()
{
OrgUID = res.data.UID,
UserUID = res.data.OwnerUID,
Flag = (int)MemberRoleEnum.管理员,
MemberApproved = (int)YesOrNoEnum.是,
OrgApproved = (int)YesOrNoEnum.是,
IsOwner = (int)YesOrNoEnum.是
};
await this._orgService.AddMember(map);
}
else
{
var res = await this._orgService.AddOrg(model);
if (res.error)
{
return GetJsonRes(res.msg);
}
var map = new OrganizationMemberEntity()
{
OrgUID = res.data.UID,
UserUID = res.data.OwnerUID,
Flag = (int)MemberRoleEnum.管理员,
MemberApproved = (int)YesOrNoEnum.是,
OrgApproved = (int)YesOrNoEnum.是,
};
await this._orgService.AddMember(map);
}
return GetJsonRes(string.Empty);
}));
}
public async Task <ActionResult> Save(string data)
{
return(await RunActionAsync(async() =>
{
var model = data?.JsonToEntity <OrganizationEntity>(throwIfException: false);
if (model == null)
{
return GetJsonRes("参数错误");
}
if (ValidateHelper.IsPlumpString(model.UID))
{
var res = await this._orgService.UpdateOrg(model);
if (res.error)
{
return GetJsonRes(res.msg);
}
var map = new OrganizationMemberEntity()
{
OrgUID = res.data.UID,
UserUID = res.data.OwnerUID,
Flag = (int)MemberRoleEnum.超级管理员,
MemberApproved = (int)YesOrNoEnum.是,
OrgApproved = (int)YesOrNoEnum.是,
};
await this._orgService.AddMember(map);
}
else
{
var res = await this._orgService.AddOrg(model);
if (res.error)
{
return GetJsonRes(res.msg);
}
var map = new OrganizationMemberEntity()
{
OrgUID = res.data.UID,
UserUID = res.data.OwnerUID,
Flag = (int)MemberRoleEnum.超级管理员,
MemberApproved = (int)YesOrNoEnum.是,
OrgApproved = (int)YesOrNoEnum.是,
};
await this._orgService.AddMember(map);
}
return GetJsonRes(string.Empty);
}));
}
public void OrganizationEntityMapper_DomainWithoutMembers_ReturnsEntity(Organization organization, OrganizationMemberEntity orgMemberEntity)
{
//Arrange
var memberMapper = new Mock <IMapper <OrganizationMember, OrganizationMemberEntity> >();
memberMapper.Setup(x => x.Map(It.IsAny <OrganizationMember>())).Returns(memberMapper.Object);
memberMapper.Setup(x => x.ToOutFormat()).Returns(orgMemberEntity);
var sut = new OrganizationEntityMapper(memberMapper.Object);
//Act
var actual = sut.Map(organization).ToOutFormat();
//Assert
actual.Members.Should().HaveCount(0);
memberMapper.Verify(x => x.Map(It.IsAny <OrganizationMember>()), Times.Never);
}
public void OrganizationEntityMapper_Domain_ReturnsEntity(Organization organization, OrganizationMemberEntity orgMemberEntity)
{
//Arrange
var memberMapper = new Mock <IMapper <OrganizationMember, OrganizationMemberEntity> >();
memberMapper.Setup(x => x.Map(It.IsAny <OrganizationMember>())).Returns(memberMapper.Object);
memberMapper.Setup(x => x.ToOutFormat()).Returns(orgMemberEntity);
var sut = new OrganizationEntityMapper(memberMapper.Object);
//Act
var actual = sut.Map(organization).ToOutFormat();
//Assert
actual.Id.Should().Be(organization.Id.Id);
actual.Name.Should().Be(organization.Name.Name);
organization.Address.Should().BeEquivalentTo(actual, options => options.ExcludingMissingMembers());
organization.VatNumber.Should().BeEquivalentTo(actual, options => options.ExcludingMissingMembers());
actual.Website.Should().Be(organization.Website);
actual.ChangeDate.Should().Be(organization.ChangeDate);
actual.ChangedBy.Should().Be(organization.ChangedBy);
}
public virtual async Task <_ <OrganizationMemberEntity> > AddMember(OrganizationMemberEntity model)
{
await this._orgMemberRepo.DeleteWhereAsync(x => x.UserUID == model.UserUID && x.OrgUID == model.OrgUID);
return(await this._orgMemberRepo.AddEntity_(model, "org-member"));
}
public async Task GetUserOrganizationByEmail_ReturnsDomainList(List <OrganizationEntity> organizations, OrganizationMemberEntity memberEntity, Organization organization)
{
var orgMembers = new List <OrganizationMemberEntity>();
// Arrange
organizations.ForEach(x =>
orgMembers.Add(
new OrganizationMemberEntity
{
OrganizationId = x.Id,
Organization = x,
Email = memberEntity.Email,
Permission = memberEntity.Permission,
UserName = memberEntity.UserName
}));
var mapDomain = new Mock <IMapper <OrganizationEntity, Organization> >();
mapDomain.Setup(x => x.Map(It.IsAny <OrganizationEntity>())).Returns(mapDomain.Object);
mapDomain.Setup(x => x.ToOutFormat()).Returns(organization);
var mapMemberDomain = new Mock <IMapper <OrganizationMemberEntity, OrganizationMember> >();
mapMemberDomain.Setup(x => x.Map(It.IsAny <OrganizationMemberEntity>())).Returns(mapMemberDomain.Object);
var db = new InMemoryDb <OrganizationDbContext>();
var context = new OrganizationDbContext(db.GetOptions());
var repo = new ReadOnlyOrganizationMemberRepository(context, mapMemberDomain.Object, mapDomain.Object);
context.OrganizationMembers.AddRange(orgMembers);
context.SaveChanges();
// Act
var hest = await repo.GetUserOrganizationsByEmail(memberEntity.Email);
// Arrange
hest.Should().HaveCount(3);
}
