public async Task <ActionResult> Post(SpeakerDto speaker)
{
speaker.Id = _context.Identity.Id;
await _speakersService.CreateAsync(speaker);
return(CreatedAtAction(nameof(Get), new { id = speaker.Id }, null));
}
public async Task <ActionResult> Put(SpeakerDto speaker)
{
speaker.Id = _context.Identity.Id;
await _speakersService.UpdateAsync(speaker);
return(NoContent());
}
public async Task <ActionResult> UpdateAsync(Guid id, SpeakerDto dto)
{
dto.Id = id;
await _speakerService.UpdateAsync(dto);
return(NoContent());
}
public async Task LoadConferencesAsync(LoadRequest loadRequest)
{
this.AreConferencesLoading = true;
//_messenger.Publish (new ConferencesLoading (this));
List <Conference> conferences = await _databaseService.LoadConferencesAsync();
if (conferences == null || !conferences.Any() || loadRequest == LoadRequest.Refresh)
{
var user = await _databaseService.LoadCurrentUserAsync();
string userName = "";
if (user != null)
{
userName = user.UserName;
}
await _databaseService.DeleteAllConferencesAsync();
var conferenceDtos = await _conferenceService.LoadConferencesAsync(userName);
if (conferenceDtos != null)
{
foreach (var conferenceDto in conferenceDtos)
{
ConferenceDto dto = conferenceDto;
var conference = await TaskEx.Run(() => Mapper.Map <Conference>(dto));
await _databaseService.SaveConferenceAsync(conference);
foreach (var sessionDto in conferenceDto.Sessions)
{
SessionDto dto1 = sessionDto;
var session = await TaskEx.Run(() => Mapper.Map <Session>(dto1));
session.ConferenceId = conference.Id;
await _databaseService.SaveSessionAsync(session);
foreach (var speakerDto in sessionDto.Speakers)
{
SpeakerDto speakerDto1 = speakerDto;
var speaker = await TaskEx.Run(() => Mapper.Map <Speaker>(speakerDto1));
speaker.SessionId = session.Id;
await _databaseService.SaveSpeakerAsync(speaker);
}
}
}
}
conferences = await _databaseService.LoadConferencesAsync();
}
this.AreConferencesLoading = false;
//_messenger.Publish(new ConferencesLoaded(this));
this.Conferences = conferences;
}
public ActionResult <SpeakerDto> CreateSpeaker(SpeakerDto speakerDto)
{
var model = mapper.Map <Speaker>(speakerDto);
service.Add(model);
service.Save();
var speakerRead = mapper.Map <SpeakerDto>(model);
return(CreatedAtRoute(nameof(GetById), new { Id = speakerDto.ID }, speakerRead));
}
public async Task CreateAsync(SpeakerDto speaker)
{
var alreadyExists = await _repository.ExistsAsync(speaker.Id);
if (alreadyExists)
{
throw new SpeakerAlreadyExistsException(speaker.Id);
}
await _repository.AddAsync(speaker.AsEntity());
}
public async Task <IActionResult> OnGet(int id)
{
Speaker = await _apiClient.GetSpeakerAsync(id);
if (Speaker == null)
{
return(NotFound());
}
return(Page());
}
public async Task UpdateAsync(SpeakerDto speaker)
{
var exists = await _repository.ExistsAsync(speaker.Id);
if (!exists)
{
throw new SpeakerNotFoundException(speaker.Id);
}
await _repository.UpdateAsync(speaker.AsEntity());
}
public IActionResult Create(SpeakerDto model)
{
if (ModelState.IsValid)
{
Speaker newSpeaker = new Speaker();
newSpeaker = mapper.Map <Speaker>(model);
service.Add(newSpeaker);
service.Save();
return(RedirectToAction("List", "Speakers"));
}
return(View());
}
public async Task CreateAsync(SpeakerDto speaker)
{
var alreadyExists = await _repository.ExistsAsync(speaker.Id);
if (alreadyExists)
{
throw new SpeakerAlreadyExistsException(speaker.Id);
}
await _repository.AddAsync(speaker.AsEntity());
await _messageBroker.PublishAsync(new SpeakerCreated(speaker.Id, speaker.FullName));
}
public ActionResult UpdateSpeaker(int id, SpeakerDto speakerUpdateDto)
{
var model = service.GetSpeakerById(id);
if (model == null)
{
return(NotFound());
}
mapper.Map(speakerUpdateDto, model);
service.Update(model);
service.Save();
return(NoContent());
}
public IActionResult Edit(int?id)
{
SpeakerDto model = new SpeakerDto();
if (id.HasValue)
{
var existingSpeaker = service.GetSpeakerById(id.Value);
if (existingSpeaker != null)
{
model = mapper.Map <SpeakerDto>(existingSpeaker);
}
}
return(View(model));
}
public IActionResult Edit(SpeakerDto incomingModel)
{
if (incomingModel.Id > 0)
{
if (ModelState.IsValid)
{
var speakerInDb = new Speaker();
speakerInDb = mapper.Map <Speaker>(incomingModel);
service.Update(speakerInDb);
service.Save();
return(RedirectToAction("List", "Speakers"));
}
}
return(View(incomingModel));
}
public IActionResult Edit(SpeakerDto incomingModel)
{
if (incomingModel.ID > 0)
{
if (ModelState.IsValid)
{
//tranform dto to domain object
var speakerInDb = new Speaker();
speakerInDb = mapper.Map <Speaker>(incomingModel);
//call the service to update the speakerInDB
service.Update(speakerInDb);
//save the entity
service.Save();
return(RedirectToAction("List", "Speakers"));
}
}
return(View(incomingModel));
}
private async Task Login(MobileServiceAuthenticationProvider provider)
{
var user = await _authenticationService.Login(provider);
var userName = await GetIsOauthUserRegistered(user.UserId);
await _databaseService.SaveCurrentUserAsync(new User { UserName = userName });
await _databaseService.DeleteAllScheduledConferencesAsync();
var conferenceDtos = await _remoteConferenceService.LoadScheduledConferencesAsync(userName);
foreach (var conferenceDto in conferenceDtos)
{
var dto = conferenceDto;
dto.IsAddedToSchedule = true;
var conference = await TaskEx.Run(() => Mapper.Map <Conference> (dto));
await _databaseService.SaveConferenceAsync(conference);
foreach (var sessionDto in dto.Sessions)
{
SessionDto dto1 = sessionDto;
var session = await TaskEx.Run(() => Mapper.Map <Session>(dto1));
session.ConferenceId = conference.Id;
await _databaseService.SaveSessionAsync(session);
foreach (var speakerDto in sessionDto.Speakers)
{
SpeakerDto speakerDto1 = speakerDto;
var speaker = await TaskEx.Run(() => Mapper.Map <Speaker>(speakerDto1));
speaker.SessionId = session.Id;
await _databaseService.SaveSpeakerAsync(speaker);
}
}
}
ShowViewModel <ConferencesTabViewModel> ();
}
public async Task <ActionResult> AddAsync(SpeakerDto dto)
{
await _speakerService.CreateAsync(dto);
return(CreatedAtAction(nameof(Get), new { id = dto.Id }, null));
}
public async Task <ActionResult> Put(SpeakerDto speaker)
{
await _speakersService.UpdateAsync(speaker);
return(NoContent());
}
public static Speaker AsEntity(this SpeakerDto dto) => new()
public IActionResult Create()
{
var model = new SpeakerDto();
return(View(model));
}
