public async Task <MemberViewModel> CreateMember([FromBody] CreateMemberModel model)
{
Tk.AssertValidIds(model.GroupId, model.ContactId);
var userId = _httpContextAccessor.GetContactId();
model.CreatedBy = userId;
_logger.LogInformation($"create.groupMember Group: {model.GroupId} Contact: {model.ContactId}");
var toSave = _mapper.Map <Member>(model);
var data = await _repository.CreateAsync(toSave);
_logger.LogInformation($"created.groupMember ${data.Id}");
return(_mapper.Map <MemberViewModel>(data));
}
/// <summary>
/// Creates a new project with a given name and an given author.
/// The author is automatically added to the project.
/// </summary>
/// <param name="projectName">Name for new project</param>
/// <param name="author">Member that is requesting project be made</param>
/// <returns>A new project instance
/// or throws an exception if project was not created
/// or author failed to join the project.</returns>
public async Task <Project> CreateProjectAsync(string projectName, Member author)
{
var retrievedAuthor = await _memberRepository.ReadFromSnowflakeAsync(author.SnowflakeId);
// If author doesn't exist
if (retrievedAuthor == null)
{
// Create author member
if (await _memberRepository.CreateAsync(author))
{
author = await _memberRepository.ReadFromSnowflakeAsync(author.SnowflakeId); // Update author
}
else
{
throw new Exception($"Failed to create new member: {author}!");
}
}
else // Author exists
{
// Update local object for author
author = retrievedAuthor;
}
var newProject = new Project(projectName, author);
if (!await _projectRepository.CreateAsync(newProject))
{
throw new Exception($"Failed to create new project: {projectName}!");
}
// Retrieve project to add member to.
newProject = await _projectRepository.ReadAsync(newProject.Name);
await _projectRepository.AddMemberAsync(newProject, author);
// Retrieve project with added member.
newProject = await _projectRepository.ReadAsync(newProject.Name);
return(newProject);
}
public async Task <IActionResult> Create([Bind("Id,FirstName,LastName,Email,Username,Birthdate")] Member member)
{
if (member == null)
{
return(NotFound());
}
if (ModelState.IsValid)
{
var m = await _memberRepository.CreateAsync(member);
return(RedirectToAction("Index", new { id = m.Id }));
}
return(View());
}
public async Task <Member> CreateMemberAsync(MemberApiModel memberApi)
{
try
{
var validationResult = await _validator.ValidateAsync(memberApi);
if (!validationResult.Errors.Any(x => x.Severity == Severity.Error))
{
var existMemberWithEmail = await _memberRepository.GetByEmailAsync(memberApi.Email);
if (existMemberWithEmail != null)
{
throw new MemberDomainException($"Ya existe un usuario con el email: '{memberApi.Email}'", "ValidationErrors");
}
Guid id = Guid.NewGuid();
var member = Member.Create(id,
memberApi?.FirstName,
memberApi?.LastName,
memberApi.Email,
memberApi.Password,
memberApi.Country,
memberApi.PhoneNumber,
memberApi.PostCode);
//Se publican los eventos de dominio en caso por ejemplo, que se quiera notificar al usuario mediante correo o sms añadiremos, un manejador que haga el envío de la notificación
//si quisieramos que este fuese completamente asíncrono, en dicho manejador añadiriamos al bus de servicio o a la cola el envío de dicho mensaje y otro microservicio estaría a
//la escucha para realizar el envío
await _mediator?.DispatchDomainEventsAsync(member);
await _memberRepository.CreateAsync(member);
return(await _memberRepository.GetAsync(id));
}
else
{
throw new MemberDomainException(string.Join(";", validationResult.Errors), "ValidationErrors");
}
}
catch (Exception ex)
{
_logger.LogError($"Error al crear el usuario: {ex.Message}", ex);
throw;
}
}
