public async Task <Member> CreateMember(CreateMemberCommand command)
{
if (command == null)
{
throw new CustomBadRequestException(ExceptionMessage.NullCommand);
}
if (String.IsNullOrEmpty(command.PhoneNumber) && String.IsNullOrEmpty(command.Email))
{
throw new CustomBadRequestException(ExceptionMessage.MemberEmptyEmailAndPhone);
}
if (command.IdCard == null)
{
throw new CustomBadRequestException(ExceptionMessage.IdCardNull);
}
if (!String.IsNullOrEmpty(command.Email))
{
if (!IsEmailValid(command.Email))
{
throw new CustomBadRequestException(ExceptionMessage.BadEmailFormat);
}
}
var idCard = new IdentityCard
{
Firstname = command.IdCard.Firstname,
Lastname = command.IdCard.Lastname,
BirthDate = command.IdCard.BirthDate,
CardNumber = command.IdCard.CardNumber,
ExpirationDate = command.IdCard.ExpirationDate,
ValidityDate = command.IdCard.ValidityDate,
NationalRegisterNumber = command.IdCard.NationalRegisterNumber
};
ValidateIdCard(idCard);
var memberCard = MemberCard.GenerateMemberCard();
var member = new Member
{
Email = command.Email,
PhoneNumber = command.PhoneNumber,
IdentityCards = new List <IdentityCard>()
{
idCard
},
MemberCards = new List <MemberCard>()
{
memberCard
},
IsActive = true
};
_context.Members.Add(member);
await _context.SaveChangesAsync();
return(member);
}
public async Task Run([QueueTrigger("userregistered", Connection = "azurestorageconnectionstring")] string jsonEvent, ILogger log)
{
log.LogInformation($"C# Queue trigger function processed: {jsonEvent}");
var ev = JsonConvert.DeserializeObject <UserRegistered>(jsonEvent);
var command = new CreateMemberCommand(Guid.Parse(ev.Id), ev.Username);
await _betModule.ExecuteCommandAsync(command).ConfigureAwait(false);
}
public async Task Handle_return_true()
{
var fakeMemberCommand = new CreateMemberCommand()
{
Company = "测试成功", Password = "******", PhoneNumber = "1366" + DateTime.Now.ToString("yyyyMMddhh"), UserName = "******"
};
_memberRepositoryMock.Setup(p => p.UnitOfWork.SaveChangesAsync(default)).Returns(Task.FromResult(1));
public async Task <ActionResult <GetMemberViewModel> > CreateMember([FromBody] CreateMemberCommand command)
{
var member = await _memberService.CreateMember(command);
var memberViewModel = _mapper.Map <GetMemberViewModel>(member);
return(CreatedAtAction(nameof(GetById), new { memberId = memberViewModel.Id }, memberViewModel));
}
public async Task <IActionResult> CreateAsync([FromBody] CreateMemberCommand command,
CancellationToken cancellationToken)
{
var result = await _mediator.Send(command, cancellationToken);
return(result.Failures.Any()
? BadRequest(result.GenerateFailuresOutput()) as IActionResult
: CreatedAtRoute("get-member", new { id = result.Data.Id }, result.Data));
}
public async Task <BizResult <string> > Register(CreateMemberCommand dto)
{
var hash = configuration["Customization:PwdKey"];
dto.Password = EncryptUtil.AESEncrypt(dto.Password, hash);
await _mediator.Send(dto, HttpContext.RequestAborted);
return(new BizResult <string>("注册成功"));
}
public async Task CreateMember_EmptyEmailAndPhone_ThrowException()
{
InjectClassFor(InitializeContext());
var command = new CreateMemberCommand();
var exception = await Assert.ThrowsAsync <CustomBadRequestException>(() => ClassUnderTest.CreateMember(command));
Assert.Equal(ExceptionMessage.MemberEmptyEmailAndPhone, exception.Message);
}
public void CreateMember_CreateSuccesfully()
{
var factory = new Mock <IFactory>();
var result = new CreateMemberCommand(new List <string>()
{
"Member5"
}, database, factory.Object).Execute();
Assert.AreEqual("Created member: 'Member5'", result);
}
public async Task <IActionResult> Create(CreateMemberCommand command)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _memberService.CreateMemberCommandHandler(command);
return(Created($"/api/members/{result.Payload.Id}", result));
}
public void IsValid_ShouldBeFalse_WhenCreateMemberCommandIsNotValid()
{
var command = new CreateMemberCommand
{
Name = string.Empty,
Address = string.Empty
};
var validator = new CreateMemberCommandValidator();
var result = validator.Validate(command);
result.IsValid.ShouldBe(false);
}
public async Task CreateMember_EmptyIdCard_ThrowException()
{
InjectClassFor(InitializeContext());
var command = new CreateMemberCommand
{
Email = "*****@*****.**"
};
var exception = await Assert.ThrowsAsync <CustomBadRequestException>(() => ClassUnderTest.CreateMember(command));
Assert.Equal(ExceptionMessage.IdCardNull, exception.Message);
}
public async Task <CreateMemberCommandResult> CreateMemberCommandHandler(CreateMemberCommand command)
{
var member = _mapper.Map <Member>(command);
var persistedMember = await _memberRepository.CreateRecordAsync(member);
var vm = _mapper.Map <MemberVm>(persistedMember);
return(new CreateMemberCommandResult()
{
Payload = vm
});
}
public async Task ShouldNotCreateMemberIfMemberAlreadyCreated()
{
var memberId = Guid.Parse("01c1da98-b4b7-45dc-8352-c98ece06dab1");
var command = new CreateMemberCommand(memberId,
"toto");
var member = new Member(new(memberId), "toto", 10);
var memberRepository = new InMemoryMemberRepository(new() { member });
var handler = new CreateMemberCommandHandler(memberRepository);
var record = await Record.ExceptionAsync(() => handler.Handle(command, default));
Assert.IsType <MemberAlreadyExistsException>(record);
Assert.Single(memberRepository.GetMembers());
}
public MemberController()
{
DatabaseService database = new DatabaseService();
GetMembersListQuery membersListQuery = new GetMembersListQuery(database);
GetMemberDetailQuery memberDetailQuery = new GetMemberDetailQuery(database);
CreateMemberViewModelFactory factory = new CreateMemberViewModelFactory(new GetCategoriesListQuery(database));
CreateMemberCommand createMemberCommand = new CreateMemberCommand(database, new MemberFactory());
_membersListQuery = membersListQuery;
_memberDetailQuery = memberDetailQuery;
_factory = factory;
_createMemberCommand = createMemberCommand;
}
public static CreateMemberCommand ToCreateMemberCommand(this MemberVm model)
{
var command = new CreateMemberCommand()
{
FirstName = model.FirstName,
LastName = model.LastName,
Roles = model.Roles,
Avatar = model.Avatar,
Email = model.Email
};
return(command);
}
public static Faker <CreateMemberCommand> Valid()
{
return(new Faker <CreateMemberCommand>().CustomInstantiator(x =>
{
var command = new CreateMemberCommand {
Name = x.Person.UserName
};
const string routename = "get-member";
var urlHelper = UrlHelperMockBuilder.Create().SetupLink(routename).Build();
command.SetupForCreation(urlHelper, routename, x => new { x.Id });
return command;
}));
}
public IActionResult Post(CreateMemberCommand command)
{
var member = mapper.Map<Member>(command);
try
{
memberRepository.Add(member);
return StatusCode(201, new { Message = "Member successfully created." });
}
catch (Exception e)
{
return StatusCode(500, e.Message);
}
}
public async Task <(bool IsValid, IEnumerable <string> Errors)> Create(CreateMemberCommand createMemberCommand)
{
var validation = await CreateMemberCommandValidator.Instance.ValidateAsync(createMemberCommand);
if (!validation.IsValid)
{
return(validation.IsValid, validation.Errors.Select(x => x.ErrorMessage));
}
var member = new Member(createMemberCommand.Name);
await _memberService.Upsert(member);
return(true, null);
}
public void AddMembership(CreateMemberCommand request)
{
members.Add(new Membership
{
Mail = request.Mail,
PhoneNumber = request.PhoneNumber,
IdentityCard = new IdentityCard
{
Birthday = request.IdentityBirthday,
CardNumber = request.IdentityCardNumber,
FirstName = request.IdentityFirstName,
LastName = request.IdentityLastName,
NISS = request.NISS,
ValidityDate = request.IdentityValidityDate
}
});
}
public async Task ShouldCreateMember()
{
var memberId = Guid.Parse("01c1da98-b4b7-45dc-8352-c98ece06dab1");
var command = new CreateMemberCommand(memberId,
"toto");
var memberRepository = new InMemoryMemberRepository();
var handler = new CreateMemberCommandHandler(memberRepository);
await handler.Handle(command, default);
var member = await memberRepository.GetByIdAsync(new(Guid.Parse("01c1da98-b4b7-45dc-8352-c98ece06dab1")));
Assert.Equal(memberId, member.Id.Value);
Assert.Equal("toto", member.Name);
Assert.Equal(1000, member.Wallet);
Assert.Collection(member.DomainEvents, x =>
{
Assert.Equal(memberId, (x as MemberCreated).MemberId);
});
}
public async Task CreateMember_IdExpirationOlderThanToday_ThrowException()
{
InjectClassFor(InitializeContext());
var command = new CreateMemberCommand
{
PhoneNumber = "+32495414243",
IdCard = new CreateMemberCommand.IdentityCard
{
BirthDate = new DateTime(2000, 5, 30),
CardNumber = 100000012,
Firstname = "Test",
Lastname = "Jean",
NationalRegisterNumber = "456.51.51-456-78",
ExpirationDate = new DateTime(2016, 6, 11),
ValidityDate = new DateTime(2014, 6, 11)
}
};
var exception = await Assert.ThrowsAsync <CustomBadRequestException>(() => ClassUnderTest.CreateMember(command));
Assert.Equal(ExceptionMessage.IdCardExpired, exception.Message);
}
public async Task CreateMember_InvalidEmailFormat_ThrowException()
{
InjectClassFor(InitializeContext());
var command = new CreateMemberCommand
{
Email = "testemail.com",
IdCard = new CreateMemberCommand.IdentityCard
{
BirthDate = new DateTime(2000, 5, 30),
CardNumber = 100000012,
Firstname = "Test",
Lastname = "Jean",
NationalRegisterNumber = "456.51.51-456-78",
ExpirationDate = new DateTime(2021, 6, 11),
ValidityDate = new DateTime(2016, 6, 11)
}
};
var exception = await Assert.ThrowsAsync <CustomBadRequestException>(() => ClassUnderTest.CreateMember(command));
Assert.Equal(ExceptionMessage.BadEmailFormat, exception.Message);
}
public async Task CreateMember_ValidCommand_ReturnCreatedMember()
{
InjectClassFor(InitializeContext());
var command = new CreateMemberCommand
{
PhoneNumber = "+32495414243",
IdCard = new CreateMemberCommand.IdentityCard
{
BirthDate = new DateTime(2000, 5, 30),
CardNumber = 100000024,
Firstname = "Test",
Lastname = "Jean",
NationalRegisterNumber = "456.51.51-456-78",
ExpirationDate = new DateTime(2026, 6, 11),
ValidityDate = new DateTime(2016, 6, 11)
}
};
var member = await ClassUnderTest.CreateMember(command);
Assert.Equal("+32495414243", member.PhoneNumber);
Assert.Equal("456.51.51-456-78", member.IdentityCards.FirstOrDefault().NationalRegisterNumber);
Assert.NotNull(member.MemberCards.FirstOrDefault());
}
public void AddMembership(CreateMemberCommand request)
{
throw new NotImplementedException();
}
public async Task <CreateMemberCommandResult> Create(CreateMemberCommand command)
{
return(await _httpClient.PostJsonAsync <CreateMemberCommandResult>("members", command));
}
public async Task <IActionResult> CreateAsync([FromBody] CreateMemberCommand command, CancellationToken cancellationToken)
{
command.SetupForCreation(Url, "get-member", x => new { id = x.Id });
return(await _mediator.Send(command, cancellationToken));
}
public async Task <IHttpActionResult> Create([FromBody] CreateMemberCommand command)
{
var result = await _mediator.Send(command);
return(Created(Request.RequestUri, result));
}
public async Task <ApiResponse <Member> > Handle(CreateMemberCommand request, CancellationToken cancellationToken)
{
var createdMember = await _memberRepository.InsertAsync(new Member(request.Name), cancellationToken);
return(new ApiResponse <Member>(createdMember));
}
public async Task <ActionResult <int> > Post([FromBody] CreateMemberCommand command)
{
return(await _mediator.Send(command));
}
public async Task <IActionResult> CreateNewMember([FromBody] CreateMemberCommand command)
{
var result = await Mediator.Send(command);
return(Ok(result));
}
