private string ValidateBadRequest(EventoRequest request)
{
if (String.IsNullOrEmpty(request.Nome))
{
return("Nome é um campo obrigatório");
}
if (String.IsNullOrEmpty(request.Descricao))
{
return("Descricao é um campo obrigatório");
}
if (request.Data == null)
{
return("Data é um campo obrigatório");
}
if (string.IsNullOrEmpty(request.Local))
{
return("É obrigatório informar Local");
}
if (request.TipoEventoId == 0)
{
return("É obrigatório informar o TipoEvento");
}
return(null);
}
public async Task <EventoResponse> AdicionarEvento(EventoRequest request)
{
var model = request.MapTo <Evento>(_mapper);
var responseModel = await _eventoService.Adicionar(model);
return(responseModel.MapTo <EventoResponse>(_mapper));
}
public async Task <IActionResult> Put([FromRoute] int EventoId, [FromBody] EventoRequest request)
{
var userId = User.GetUserId();
var validate = ValidateBadRequest(request);
if (!string.IsNullOrEmpty(validate))
{
return(BadRequest(new ErrorResponse(validate, EnumResponseCode.Generico)));
}
var operacao = await _operacaoService.Find(request.Id);
if (operacao != null)
{
var entity = await UpdateEvento(request, EventoId);
await UpdateParticipantes(request, entity);
await _eventoService.Update(entity);
}
await _unitOfWork.CompleteAsync();
return(NoContent());
}
public ActionResult <EventoResponse> PutEvento([FromBody] EventoRequest eventoRequest, string id)
{
Evento evento = _eventoRepository.GetEvento(id);
if (evento != null)
{
if (evento.Casa.UsuarioEmail != User.Identity.Name)
{
return(BadRequest("Só é possível editar um evento que você criou."));
}
var eventoUpdate = eventoRequest.ToEvento();
eventoUpdate.Id = id;
bool deu = _eventoRepository.Update(eventoUpdate);
if (deu)
{
var casaUri = Url.Action("GetCasa", "Casa", new{ id = eventoUpdate.CasaId });
var uriVendas = Url.Action("GetVendas", new{ id = eventoUpdate.Id });
return(eventoUpdate.ToEventoResponse(casaUri, uriVendas));
}
return(NotFound("Casa não existe."));
}
return(BadRequest("Evento não existe."));
}
public async Task <IActionResult> AddEvent([FromBody] EventoRequest request)
{
try
{
ValidationModel validationModel = new ValidationModel();
var retorno = await _reservasSrv.RegistroEvento(request);
if (retorno.berror)
{
validationModel.ValidationResults.Add(new ValidationResult("-1", new[] { retorno.msjError }));
return(new BadRequestObjectResult(validationModel));
}
else
{
return(Ok(new ApiOkResponse(retorno.uidRetorno)));
}
}
catch (CError ce)
{
throw ce;
}
catch (System.Exception ex)
{
throw ex;
}
}
public async Task <Guid> AdicionarAsync(EventoRequest request)
{
Evento evento = ConverterParaModel(request);
ValidaSeExisteEventoNaData(evento.Data);
await _repository.InsertAsync(evento);
return(evento.Id);
}
private async Task <Evento> UpdateEvento(EventoRequest request, int EventoId)
{
var entity = await _eventoService.FindUpdate(EventoId);
entity.Nome = request.Nome;
entity.Descricao = request.Descricao;
entity.Data = request.Data;
entity.Local = request.Local;
entity.TipoEvento = request.TipoEventoId;
return(entity);
}
private async Task CreateParticipantes(EventoRequest request, int EventoId)
{
foreach (var item in request.Participantes)
{
var EventoMotivoRejeito = new EventoParticipante()
{
EventoId = EventoId,
ParticipanteId = item.Id
};
await _EventoParticipanteService.Create(EventoMotivoRejeito);
}
}
private async Task UpdateParticipantes(EventoRequest request, Evento entity)
{
foreach (var item in request.Participantes)
{
var EventoParticipantes = new EventoParticipante()
{
EventoId = entity.Id,
ParticipanteId = item.Id
};
await _EventoParticipanteService.Create(EventoParticipantes);
}
}
/// <summary>
///
/// </summary>
/// <param name="dto"></param>
public async Task <RetornoProcedureDto> RegistroEvento(EventoRequest dto)
{
try {
DateTime dtinicio = DateTime.Parse(dto.start);
DateTime dtfin = DateTime.Parse(dto.end);
TimeSpan timeStrat = TimeSpan.Parse(dto.startTime);
TimeSpan timeEnd = TimeSpan.Parse(dto.endTime);
RetornoProcedureDto retorno = new RetornoProcedureDto();
if (string.IsNullOrEmpty(dto.uiReserva))
{
retorno = await _storeProcedure.XportsInstalacionesReservaInsert(new ReservaRepositoryDto()
{
// Titulo = dto.Titulo,
dt_inicio = new DateTime(dtinicio.Year, dtinicio.Month, dtinicio.Day, timeStrat.Hours, timeStrat.Minutes, 0),
dt_fin = new DateTime(dtfin.Year, dtfin.Month, dtfin.Day, timeEnd.Hours, timeEnd.Minutes, 0),
UID_Instalacion = Guid.Parse(dto.uidInstalacion.ToString()),
UID_Person_Reserva = dto.uidGroupUsers[0].uidPerson,
UID_TipoReserva = Guid.Parse(dto.uidTipoReserva.ToString()),
uidGropusUser = getCollectionSplitUser(dto.uidGroupUsers),
idPaymentPartsUsers = getCollectionSplitPaymentUser(dto.uidGroupUsers)
});
}
else
{
ReservaRepositoryDto _dtoUpdate = new ReservaRepositoryDto();
_dtoUpdate.UID_Reserva = Guid.Parse(dto.uiReserva);
// _dtoUpdate.Titulo = dto.Titulo;
_dtoUpdate.UID_TipoReserva = Guid.Parse(dto.uidTipoReserva);
_dtoUpdate.dt_inicio = new DateTime(dtinicio.Year, dtinicio.Month, dtinicio.Day, timeStrat.Hours, timeStrat.Minutes, 0);
_dtoUpdate.dt_fin = new DateTime(dtfin.Year, dtfin.Month, dtfin.Day, timeEnd.Hours, timeEnd.Minutes, 0);
_dtoUpdate.UID_Instalacion = Guid.Parse(dto.uidInstalacion.ToString());
_dtoUpdate.UID_Person_Reserva = dto.uidGroupUsers[0].uidPerson;
_dtoUpdate.uidGropusUser = getCollectionSplitUser(dto.uidGroupUsers);
_dtoUpdate.idPaymentPartsUsers = getCollectionSplitPaymentUser(dto.uidGroupUsers);
retorno = await _storeProcedure.XportsInstalacionesReservaUpdate(_dtoUpdate);
}
return(retorno);
}
catch (CError e)
{
throw _errorManager.AddError("RegistroEvento", "Maestros_RegistroEvento", e, MethodBase.GetCurrentMethod(), null);
}
catch (System.Exception ex)
{
throw _errorManager.AddError("Error Generico", "Maestros_RegistroEvento", ex, MethodBase.GetCurrentMethod(), null);
}
}
public ActionResult <EventoResponse> PostEvento([FromBody] EventoRequest eventoRequest)
{
if (ModelState.IsValid)
{
Evento evento = eventoRequest.ToEvento();
bool deu = _eventoRepository.Add(evento, User.Identity.Name);
if (deu)
{
var uriEvento = Url.Action("GetEvento", new{ id = evento.Id });
var uriCasa = Url.Action("GetCasa", "Casa", new{ id = evento.CasaId });
var uriVendas = Url.Action("GetVendas", new{ id = evento.Id });
return(Created(uriEvento, evento.ToEventoResponse(uriCasa, uriVendas)));
}
return(BadRequest("Você não criou esta casa."));
}
return(BadRequest("Requisição inválida."));
}
private async Task <Evento> CreateEvento(EventoRequest request, Operacao operacao)
{
int EventoId = await _eventoService.MaxByOperacao(operacao.Id) + 100;
var entity = new Evento()
{
Id = EventoId,
Nome = request.Nome,
Descricao = request.Descricao,
Data = request.Data,
Local = request.Local,
TipoEvento = request.TipoEventoId,
};
await _eventoService.Create(entity);
return(entity);
}
public async Task <IActionResult> Post([FromBody] EventoRequest request)
{
var validate = ValidateBadRequest(request);
if (!string.IsNullOrEmpty(validate))
{
return(BadRequest(new ErrorResponse(validate, EnumResponseCode.Generico)));
}
var operacao = await _operacaoService.Find(request.Id);
if (operacao != null)
{
var Evento = await CreateEvento(request, operacao);
await CreateParticipantes(request, Evento.Id);
}
await _unitOfWork.CompleteAsync();
return(NoContent());
}
/// <summary>
/// Converte EventoRequest para Evento
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private Evento ConverterParaModel(EventoRequest request)
{
return(new Evento(request.Descricao, request.Data, request.CustoComida, request.CustoBebida));
}
public async Task <IActionResult> Adicionar(EventoRequest request)
{
return(Ok(await appService.AdicionarAsync(request)));
}
