public IActionResult Edit(EventoViewModel eventoViewModel)
{
if (ValidarAutoridadeEvento(eventoViewModel))
{
return(RedirectToAction("MeusEventos", _eventoAppService.ObterEventosPorOrganizador(OrganizadroId)));
}
if (!ModelState.IsValid)
{
return(View(eventoViewModel));
}
eventoViewModel.OrganizadorId = OrganizadroId;
_eventoAppService.Atualizar(eventoViewModel);
ViewBag.RetornoPost = OperacaoValida() ? "sucess,Evento atualizado com sucesso!" : "error,Evento não atualizado, verifique as mensagens!";
if (_eventoAppService.ObterPorId(eventoViewModel.Id).Online)
{
eventoViewModel.Endereco = null;
}
else
{
eventoViewModel = _eventoAppService.ObterPorId(eventoViewModel.Id);
}
return(View(eventoViewModel));
}
public IActionResult Painel()
{
var Adicionais = adicionalRepository.ObterTodos();
var numPessoas = numPessoasRepository.ObterTodos();
var emailCliente = ObterUsuarioSession();
EventoViewModel pvm = new EventoViewModel();
pvm.Adicionais = adicionalRepository.ObterTodos();
pvm.NumeroPessoas = numPessoasRepository.ObterTodos();
pvm.Espaços = espaçoRepository.ObterTodos();
pvm.Eventos = eventoRepository.ObterTodosPorCliente(emailCliente);
if (!string.IsNullOrEmpty(emailCliente))
{
pvm.Usuario = userRepository.ObterPor(emailCliente);
}
var nomeUsuario = ObterUsuarioNomeSession();
if (!string.IsNullOrEmpty(nomeUsuario))
{
pvm.NomeUsuario = nomeUsuario;
}
pvm.NomeView = "Painel";
pvm.UsuarioEmail = emailCliente;
pvm.UsuarioNome = nomeUsuario;
return(View(pvm));
}
public IActionResult Index()
{
var espaço = espaçoRepository.ObterTodos();
var emailCliente = ObterUsuarioSession();
EventoViewModel pvm = new EventoViewModel();
pvm.Espaços = espaçoRepository.ObterTodos();
pvm.Adicionais = adicionalRepository.ObterTodos();
pvm.Eventos = eventoRepository.ObterTodosPorCliente(emailCliente);
if (!string.IsNullOrEmpty(emailCliente))
{
pvm.Cliente = clienteRepository.ObterPor(emailCliente);
}
var UsuarioNome = ObterUsuarioNomeSession();
if (!string.IsNullOrEmpty(UsuarioNome))
{
pvm.NomeCliente = UsuarioNome;
}
pvm.NomeView = "Evento";
pvm.UsuarioEmail = emailCliente;
pvm.UsuarioNome = UsuarioNome;
return(View(pvm));
}
public async Task <bool> ValidaHoraInicial(EventoViewModel evento, DateTime horaInicial, Guid profissionalId)
{
var query = await Db.Eventos.FirstOrDefaultAsync(
e => e.start == horaInicial && e.ProfissionalId == profissionalId && e.ID != evento.ID);
return(query != null);
}
public async Task <IActionResult> Put(EventoViewModel evento)
{
try
{
var eventoEncontrado = await _service.ObterEventoPorId(evento.Id, true);
if (eventoEncontrado == null)
{
return(NotFound());
}
if (evento.Lotes != null)
{
await AtualizarLotes(evento, eventoEncontrado.Evento);
}
if (evento.RedesSociais != null)
{
await AtualizarRedesSociais(evento, eventoEncontrado.Evento);
}
var response = await _service.EditarEvento(evento);
return(GetResponse(response));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, GetCustomMessageError500("editar evento")));
}
}
public IHttpActionResult PostEventoViewModel(EventoViewModel eventoViewModel)
{
var usuario = db.Users.SingleOrDefault(u => u.UserName == HttpContext.Current.User.Identity.Name);
if (usuario == null)
{
return(BadRequest("Nenhum Usuario Logado"));
}
if (usuario.Organizador == false)
{
return(BadRequest("É Necessário ser um Organizador para criar um Evento"));
}
// eventoViewModel.Id_usuario_organizador = usuario.Id;
eventoViewModel.Id_organizador = usuario.Id;//Mapper.Map<UsuarioViewModel> (usuario);
;
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_eventoAppService.Criar(eventoViewModel);
return(CreatedAtRoute("DefaultApi", new { id = eventoViewModel.Id }, eventoViewModel));
}
public EventoViewModel Atualizar(EventoViewModel eventoViewModel)
{
var eventoDTO = _eventoRepository.BuscarPorId(eventoViewModel.Id);
var evento = Mapper.Map(eventoViewModel, eventoDTO);
return(Mapper.Map <EventoViewModel>(evento));
}
public IActionResult Edit([Bind("Id,Nome,DescricaoCurta,DescricaoLonga,DataInicio,DateFinal,Gratuito,Valor,Online,NomeEmpresa,CategoriaId,OrganizadorId")] EventoViewModel eventoViewModel)
{
if (!ModelState.IsValid)
{
return(View(eventoViewModel));
}
if (ValidarAutoridadeEvento(eventoViewModel))
{
return(RedirectToAction("MeusEventos", _eventoAppService.ObterEventoPorOrganizador(OrganizadorId)));
}
eventoViewModel.OrganizadorId = OrganizadorId; //Não camada de DOMAIN é validado se este organizador é realmente o dono do EVENTO
_eventoAppService.Atualizar(eventoViewModel);
ViewBag.RetornoPost = OperacaoValida() ? "success,Evento atualizado com sucesso." : "error,Evento não pode ser atualizado. Verifique as mensagens.";
var eventoAtualizado = _eventoAppService.ObterPorId(eventoViewModel.Id);
if (eventoAtualizado.Online)
{
eventoViewModel.Endereco = null;
}
else
{
eventoViewModel = eventoAtualizado;
}
return(View(eventoViewModel));
}
public async Task <ActionResult> Editar(int?id)
{
if ((id == null) || (id == 0))
{
return(View(new EventoViewModel()
{
Vitrine = true
}));
}
try
{
Evento ev = await _appSvc.GetByIdAsync(id.Value);
EventoViewModel evvm = Mapper.Map <EventoViewModel>(ev);
if (evvm != null)
{
return(View(evvm));
}
else
{
MensagemParaUsuarioViewModel.MensagemErro("Esse registro não pôde ser encontrado. ", TempData, ModelState);
}
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro("Esse registro não pôde ser visualizado. " + err.Message, TempData, ModelState);
}
return(View(new EventoViewModel()));
}
public EventoViewModel Update(EventoViewModel entity)
{
var evento = mapper.Map <Evento>(entity);
eventoRepositorio.Update(evento);
return(mapper.Map <EventoViewModel>(evento));
}
public ActionResult EventSave()
{
try
{
//ESto es una puta prueba que no me quiere funcionar sabra el putas poir que
HttpRequest request = HttpContext.ApplicationInstance.Context.Request;
int empresarioId = JsonConvert.DeserializeObject <int>(request["Empresario"]);
EventoViewModel evento = JsonConvert.DeserializeObject <EventoViewModel>(request["EventData"]);
VenueViewModel venue = JsonConvert.DeserializeObject <VenueViewModel>(request["VenueData"]);
List <LocalidadViewModel> stages = JsonConvert.DeserializeObject <List <LocalidadViewModel> >(request["StagesData"]);
List <FuncionesEventoViewModel> functions = JsonConvert.DeserializeObject <List <FuncionesEventoViewModel> >(request["FunctionsData"]);
List <EtapasViewModel> steps = JsonConvert.DeserializeObject <List <EtapasViewModel> >(request["StepsData"]);
string mapa = request["__Mapa"].ToString();
string ticket = request["__TicketData"].ToString();
string htmlDescription = request["__EventDescription"].ToString();
evento.Empresario_id = empresarioId;
evento.Venue = venue;
evento.Localidades = stages;
evento.Funciones = functions;
evento.Etapas = steps;
ServicioEvento eventoStorage = new ServicioEvento();
eventoStorage.SaveComplete(evento, ticket, htmlDescription, mapa);
return(Json(new { status = HttpStatusCode.OK, message = "Evento almacenado correctamente" }, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
return(Json(new { status = HttpStatusCode.InternalServerError, message = ex.Message }, JsonRequestBehavior.AllowGet));
}
}
public async Task EventosController_RegistrarNovoEvento_RetornarComSucesso()
{
//Arrange
var login = await UserUtils.RealizarLoginOrganizador(Environment.Client);
var evento = new EventoViewModel
{
Nome = "DevXperience",
DescricaoCurta = "Um evento de teste",
DescricaoLonga = "Um evento de Tecnologia para testes",
CategoriaId = new Guid("42083bb8-d2b4-4677-8127-0afb1925fa37"),
DataInicio = DateTime.Now.AddDays(10),
DataFim = DateTime.Now.AddDays(13),
Gratuito = false,
Valor = 500,
NomeEmpresa = "DevX",
Online = true,
Endereco = new EnderecoViewModel(),
OrganizadorId = new Guid(login.user.id)
};
//act
var response = await Environment.Server
.CreateRequest("api/v1/eventos")
.AddHeader("Authorization", "Bearer " + login.access_token)
.And(request => request.Content = new StringContent(JsonConvert.SerializeObject(evento), Encoding.UTF8, "application/json"))
.PostAsync();
var eventoResult = JsonConvert.DeserializeObject <EventoJsonDTO>(await response.Content.ReadAsStringAsync());
// Assert
response.EnsureSuccessStatusCode();
Assert.IsType <EventoDTO>(eventoResult.data);
}
public async Task <IActionResult> Edit(long id, long?vbEmpresa = null)
{
try
{
ViewBag.EmpresaId = vbEmpresa;
ViewBag.EventoDuplicado = false;
ViewBag.EstablecimientoNoDisponible = false;
var evento = (EventoDto)await _eventoServicio.Obtener(id);
var model = new EventoViewModel()
{
Id = evento.Id,
EstaEliminado = evento.EliminadoStr,
Cupo = evento.Cupo,
CupoDisponible = evento.CupoDisponible,
Nombre = evento.Nombre,
Descripcion = evento.Descripcion,
Fecha = evento.Fecha,
EmpresaId = evento.EmpresaId,
EstablecimientoId = evento.EstablecimientoId,
Empresas = await _helperEmpresa.PoblarCombo(),
Establecimientos = await _helperEstablecimiento.PoblarCombo()
};
return(View(model));
}
catch (Exception)
{
return(RedirectToAction(nameof(Index), new { empresaId = vbEmpresa }));
}
}
public async Task <IActionResult> Put([FromBody] EventoViewModel eventoViewModel)
{
var reuniao = _mapper.Map <Evento>(eventoViewModel);
_eventoRepository.UpDate(reuniao);
_eventoRepository.SaveChanges();
return(Ok());
}
public void Atualizar(EventoViewModel eventoViewModel)
{
//TODO Validar se o organizador é dono do evento.
var atualizarEventoCommand = _mapper.Map <AtualizarEventoCommand>(eventoViewModel);
_bus.SendCommand(atualizarEventoCommand);
}
public async Task<EventoResponse> ExcluirEvento(EventoViewModel evento)
{
var command = _mapper.Map<ExcluirEventoCommand>(evento);
var commandResponse = await _mediator.Send(command);
Response.Success = commandResponse.Success;
Response.InnerResponse.Messages = commandResponse.Messages;
return Response;
}
//
// GET: /Evento/Details/5
public ActionResult Alta()
{
var viewModel = new EventoViewModel();
var delitoService = new TipoDelitoService();
viewModel.TiposDelitos = delitoService.GetAll();
return(View(viewModel));
}
public bool PossuiAgendamentoSalvar(EventoViewModel evento, DateTime fim, DateTime start)
{
//var diminuiMinuto = new TimeSpan(0,1,0);
//fim = fim.Subtract(diminuiMinuto);
var profissionalId = Guid.Parse(evento.ProfissionalId);
var possuiAgendamento = Db.Eventos.FirstOrDefault(e => e.start == start && e.ProfissionalId == profissionalId);
return(possuiAgendamento != null);
}
public ActionResult NuevoEvento()
{
EventoViewModel model = new EventoViewModel
{
};
return(View(model));
}
public string AlterarEvento(EventoViewModel evento)
{
try
{
if (ValidaDadosDeEntrada(evento) != "")
{
return(JsonConvert.SerializeObject(new { code = 400, message = ValidaDadosDeEntrada(evento) }));
}
else
{
bool podeAdicionar = true;
Evento ev = new Evento();
evento.Latitude = evento.Latitude.Replace(".", ",");
evento.Longitude = evento.Longitude.Replace(".", ",");
evento.Ativo = false;
evento.Aprovado = null;
var eventoService = Mapper.Map <EventoViewModel, Evento>(evento);
var retornoConsultaEvento = VerificaSeEventoJaExiste(eventoService);
foreach (var v in retornoConsultaEvento)
{
if (v.EventoId != eventoService.EventoId)
{
if (
podeAdicionar &&
(eventoService.DataHoraInicio <= v.DataHoraInicio && eventoService.DataHoraFim <= v.DataHoraInicio) ||
(eventoService.DataHoraInicio >= v.DataHoraFim && eventoService.DataHoraFim >= v.DataHoraFim)
)
{
podeAdicionar = true;
}
else
{
ev = v;
podeAdicionar = false;
}
}
}
if (podeAdicionar)
{
_eventoService.Update(eventoService);
return(JsonConvert.SerializeObject(new { code = 200, message = "Evento alterado com sucesso. Aguarde a aprovação." }));
}
else
{
return(JsonConvert.SerializeObject(new { code = 400, message = "Desculpe, mas já existe um evento cadastrado neste local para este horário.", retornoEvento = ev }));
}
}
}
catch
{
return(JsonConvert.SerializeObject(new { code = 400, message = "Erro ao alterar. Por favor, tente novamente." }));
}
}
public void Atualizar(EventoViewModel eventoViewModel)
{
var evento = _mapper.Map <Evento>(eventoViewModel);
if (evento.EhValido())
{
_eventoRepository.Atualizar(evento);
_eventoRepository.SaveChanges();
}
}
public IActionResult Put([FromBody] EventoViewModel eventoVielModel)
{
if (!ModelState.IsValid)
{
NotificarErroModelInvalida();
return(Response());
}
_eventoAppService.Atualizar(eventoVielModel);
return(Response(eventoVielModel));
}
public IActionResult Delete(Guid id)
{
var eventoViewModel = new EventoViewModel {
Id = id
};
var eventoCommand = _mapper.Map <ExcluirEventoCommand>(eventoViewModel);
_mediator.EnviarComando(eventoCommand);
return(Response(eventoCommand));
}
public void Destroy(EventoViewModel obj)
{
var entity = entities.Eventos.FirstOrDefault(c => c.Id == obj.Id);
if (entity != null)
{
entities.Delete(entity);
entities.SaveChanges();
}
}
public IActionResult Index()
{
EventoViewModel pvm = new EventoViewModel();
pvm.Eventos = eventoRepository.ObterTodos();
pvm.NomeView = "Home";
pvm.UsuarioEmail = ObterUsuarioSession();
pvm.UsuarioNome = ObterUsuarioNomeSession();
return(View(pvm));
}
public ActionResult Create(EventoViewModel viewModel)
{
if (ModelState.IsValid)
{
var eventoCrear = new Evento(viewModel, db);
new Repositorio <Evento>(db).Crear(eventoCrear);
return(RedirectToAction("Index"));
}
return(View(viewModel));
}
public IActionResult Edit(EventoViewModel eventoViewModel)
{
if (ModelState.IsValid)
{
return(View(eventoViewModel));
}
_eventoAppService.Atualizar(eventoViewModel);
return(View(eventoViewModel));
}
public IActionResult Create(EventoViewModel eventoViewModel)
{
if (!ModelState.IsValid)
{
return(View(eventoViewModel));
}
_eventoAppService.Registrar(eventoViewModel);
return(View(eventoViewModel));
}
private void Inicializar()
{
// Instanciar a viewmodel
vm = new EventoViewModel();
// Vincular a vm com a página
BindingContext = vm;
// Definir a fonte de dados da lista
lvEvento.ItemsSource = vm.Lista;
}
public IActionResult AtualizarEndereco(Guid?id)
{
if (id == null)
{
return(NotFound());
}
EventoViewModel eventoViewModel = _eventoAppService.ObterPorId(id.Value);
return(PartialView("_AtualizarEndereco", eventoViewModel));
}
