public Task <Unit> Handle(RegisterConferenceCommand message, CancellationToken cancellationToken)
{
var address = new Address(message.Address.Id, message.Address.Address1, message.Address.Address2, message.Address.Address3,
message.Address.Number, message.Address.Postcode, message.Address.City, message.Address.County, message.Address.ConferenceId.Value);
var conference = Conference.ConferenceFactory.NewConferenceComplety(message.Id, message.Name, message.ShortDescription,
message.LongDescription, message.StartDate, message.EndDate, message.Free, message.Value,
message.Online, message.CompanyName, _user.GetUserId(), address, message.CategoryId);
if (!IsConferenceValid(conference))
{
return(Task.FromResult(Unit.Value));
}
// TODO:
// Validate business
// Organizer can register conference?
_conferenceRepository.Add(conference);
if (Commit())
{
_mediator.PublishEvent(new ConferenceRegisteredEvent(conference.Id, conference.Name, conference.StartDate, conference.EndDate,
conference.Free, conference.Value, conference.Online, conference.CompanyName));
}
return(Task.FromResult(Unit.Value));
}
public async Task <IActionResult> Add(ConferenceDto conferenceDto)
{
if (ModelState.IsValid)
{
await _conferenceRepository.Add(conferenceDto);
}
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Add(ConferenceModel model)
{
if (ModelState.IsValid)
{
await repo.Add(model);
}
return(RedirectToAction("Index"));
}
public IActionResult Add(Conference conference)
{
if (ModelState.IsValid)
{
_conferenceRepository.Add(conference);
_conferenceRepository.Commit();
}
return(RedirectToAction("Index"));
}
public void Register(ConferenceViewModel conferenceViewModel)
{
_conferenceRepository.Add(new Conference
{
AuthorFirstName = conferenceViewModel.AuthorFirstName,
AuthorLastName = conferenceViewModel.AuthorLastName,
Email = conferenceViewModel.AuthorMail,
ArticleTitle = conferenceViewModel.ArticleTitle,
ArticleAbstract = conferenceViewModel.ArticleAbstract
});
}
public IActionResult Post([FromBody] ConferenceViewModel value)
{
if (ModelState.IsValid)
{
var newId = _conferenceRepository.Add(value.ToModel());
return(Ok(newId));
}
else
{
return(BadRequest());
}
}
public int Add(int userId, ConferenceDto conferenceDto)
{
if (CheckUserPermission(userId))
{
var conference = _mapper.Map <Conference>(conferenceDto);
//foreach (var admin in conferenceDto.Admins)//.GroupBy(s => s.Id).FirstOrDefault()
//{
// conference.AdminOfConferences.Add(new AdminOfConference() { UserId = admin.Id});
//}
return(_conferenceRepository.Add(conference));
}
throw new NotEnoughRightsException();
}
public async Task AddAsync(CreateConferenceDto dto)
{
var host = await _hostsRepository.GetAsync(dto.HostId);
if (host is null)
{
throw new HostNotFoundException(dto.HostId);
}
var conference = new Conference(dto.Name, dto.Location, dto.LogoUrl, dto.ParticipantsLimit, dto.From, dto.To, host);
_conferenceRepository.Add(conference);
await _conferenceRepository.UnitOfWork.SaveChangesAsync();
}
public IActionResult Create(ConferenceViewModel conferenceViewModel)
{
if (ModelState.IsValid)
{
_conferenceRepository.Add(new Conference
{
Name = conferenceViewModel.Name,
Description = conferenceViewModel.Description
});
return(RedirectToAction("Index", "Conference"));
}
return(View());
}
public void Add(ConferenceModel conference)
{
repo.Add(conference);
}
public ConferenceModel Add([FromBody] ConferenceModel conferenceModel)
{
return(conferenceRepository.Add(conferenceModel).Result);
}
public async Task <int> Add(ConferenceModel conference)
{
return(await _conferenceRepository.Add(conference));
}
