public async Task <IActionResult> CreateGeneric(EntradaViewModel vm, long empresaId)
{
try
{
ViewBag.EmpresaId = empresaId;
ViewBag.EventoId = vm.EventoId;
if (!ModelState.IsValid)
{
throw new Exception("Error de validacion no controlado");
}
var entradaDto = new EntradaDto()
{
EventoId = vm.EventoId,
ClienteId = null,
Precio = vm.Precio,
TipoEntradaId = vm.TipoEntradaId
};
await _entradaServicio.Insertar(entradaDto);
return(RedirectToAction("ListGeneric", new { eventoId = entradaDto.EventoId, empresaId }));
}
catch (Exception)
{
return(View(vm));
}
}
public async Task <ActionResult> Post([FromBody] EntradaDto dtoCreate)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var result = await _service.Post(dtoCreate);
if (result != null)
{
return(Ok(result));
}
else
{
return(BadRequest());
}
}
catch (ArgumentException e)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, e.Message));
}
}
public async Task RestarEntradas(int cantidadEntradas, long funcionId)
{
var entrada = await _entradaRepos.GetByFilter(predicate : x => x.Funcion.Id == funcionId, null, include : x => x.Include(x => x.Funcion), true);
var entradaDto = new EntradaDto();
var entradaEncontrada = entrada.First(x => x.Funcion.Id == funcionId);
entradaEncontrada.Cantidad -= cantidadEntradas;
await _entradaRepos.Update(entradaEncontrada);
}
public async Task Update(EntradaDto dto)
{
var entrada = await _entradaRepos.GetById(dto.Id);
if (entrada != null)
{
entrada = _mapper.Map <Dominio._4._1_Entidades.Entrada.Entrada>(dto);
await _entradaRepos.Update(entrada);
}
}
public async System.Threading.Tasks.Task <IHttpActionResult> PostEntradasAsync()
{
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
string root = HttpContext.Current.Server.MapPath("~/App_Data");
var provider = new MultipartFormDataStreamProvider(root);
try
{
// Read the form data.
await Request.Content.ReadAsMultipartAsync(provider);
// This illustrates how to get the file names.
int usuarioId = int.Parse(provider.FormData.Get("userId"));
List <char> cargasIdForm = provider.FormData.Get("cargasId").ToList();
List <int> cargasId = new List <int>();
foreach (var number in cargasIdForm)// char in cargasIdForm
{
int cargaId;
bool result = Int32.TryParse(number.ToString(), out cargaId);
if (result)
{
cargasId.Add(cargaId);
}
}
EntradaDto entradaDto = new EntradaDto();
var cargas = _entradasRepository.GetListOfCargasInEntrada(cargasId);
entradaDto.UsuarioId = usuarioId;
entradaDto.Cargas = cargas;
entradaDto.Turno = (DateTimeService.GetTimeNow() < new TimeSpan(12, 0, 0)) ? Turno.Matutino : Turno.Vespertino;
var entradaModel = entradaDto.ToModel();
_entradasRepository.Add(entradaModel);
entradaDto.Id = entradaModel.Id;
return(Created(
Url.Link("DefaultApi", new { controller = "Entradas", id = entradaDto.Id }),
entradaModel
));
}
catch (System.Exception e)
{
return(InternalServerError());
}
}
public async Task <EntradaDto> Put(EntradaDto objeto)
{
var model = _mapper.Map <EntradaModel>(objeto);
var entity = _mapper.Map <EntradaEntity>(model);
if (objeto.PoupancaId == null)
{
entity.PoupancaId = null;
}
var result = await _repository.UpdateAsync(entity);
return(_mapper.Map <EntradaDto>(result));
}
public async Task Update(EntradaDto dto)
{
using (var context = new DataContext())
{
var modificarEntradas = context.Entradas.FirstOrDefault(x => x.Id == dto.Id);
modificarEntradas.Nombre = dto.Nombre;
modificarEntradas.Precio = dto.Precio;
modificarEntradas.CantidadDisponible = dto.CantidadDisponible;
modificarEntradas.TipoEntrada = dto.TipoEntrada;
await _entradaRepositorio.Update(modificarEntradas);
}
}
public EntradaDto Insertar(EntradaDto dto)
{
var entrada = new Dominio.Entity.Entidades.Entrada()
{
Monto = dto.Monto,
FechaDesde = dto.FechaDesde,
FechaHasta = dto.FechaHasta,
Cantidad = dto.Cantidad,
EventoId = dto.EventoId,
};
_entradaRepositorio.Add(entrada);
Guardar();
dto.Id = entrada.Id;
return(dto);
}
public async Task <EntradaDto> Post(EntradaDto objeto)
{
var model = _mapper.Map <EntradaModel>(objeto);
var entity = _mapper.Map <EntradaEntity>(model);
if (objeto.PoupancaId == null)
{
entity.PoupancaId = null;
}
var result = await _repository.InsertAsync(entity);
if (result.IsFixa.Equals(true))
{
await SalvarFixos(result);
}
return(_mapper.Map <EntradaDto>(result));;
}
public IHttpActionResult Put(int id, EntradaDto entradaDto)
{
var entrada = _entradasRepository.Get(id);
List <Carga> cargas = null;
if (entradaDto.CargasId != null)
{
cargas = _entradasRepository.GetListOfCargasInEntrada(entradaDto.CargasId);
}
entradaDto.Cargas = cargas;
entrada.Cargas = (entradaDto.Cargas.Count <= 0) ? entrada.Cargas : cargas;
_entradasRepository.Update(entrada);
return(StatusCode(System.Net.HttpStatusCode.NoContent));
}
public IHttpActionResult Post(EntradaDto entradaDto)
{
var cargas = _entradasRepository.GetListOfCargasInEntrada(entradaDto.CargasId);
entradaDto.Cargas = cargas;
entradaDto.Turno = (DateTimeService.GetTimeNow() < new TimeSpan(12, 0, 0)) ? Turno.Matutino : Turno.Vespertino;
var entradaModel = entradaDto.ToModel();
_entradasRepository.Add(entradaModel);
entradaDto.Id = entradaModel.Id;
return(Created(
Url.Link("DefaultApi", new { controller = "Entradas", id = entradaDto.Id }),
entradaModel
));
}
public IHttpActionResult AlterarContingencia([FromBody] EntradaDto entrada)
{
using (var sessao = new GDATransaction())
{
try
{
sessao.BeginTransaction();
ConfigDAO.Instance.SetValue(Config.ConfigEnum.ContingenciaNFe, UserInfo.GetUserInfo.IdLoja, (int)entrada.TipoContingencia);
sessao.Commit();
return(this.Aceito("Modo de contingência alterado."));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao("Falha ao habilitar contingência.", ex));
}
}
}
public async Task <IHttpActionResult> Put(EntradaDto entradas)
{
if (category == null)
{
return(BadRequest(String.Format(Resources.RequestEmpty, _element)));
}
var principal = RequestContext.Principal as ClaimsPrincipal;
category.UserModificatorId = principal.Identity.GetUserId();
var res = this._servicio.Put(category).Result;
switch (res)
{
case -1:
return(BadRequest(String.Format(Resources.UpdateError, _element)));
default:
return(Ok(String.Format(Resources.UpdateOk, _element)));
}
}
public async Task <IHttpActionResult> Post(EntradaDto entradas)
{
if (category == null)
{
return(BadRequest(String.Format(Resources.RequestEmpty, _element)));
}
var principal = RequestContext.Principal as ClaimsPrincipal;
category.UserCreatorId = principal.Identity.GetUserId();
category.UserModificatorId = principal.Identity.GetUserId();
var res = this._servicio.Post(category).Result;
if (res > 0)
{
return(Ok(String.Format(Resources.SaveOk, _element)));
}
else
{
return(BadRequest(String.Format(Resources.SaveError, _element)));
}
}
public EntradaDto Modificar(EntradaDto dto)
{
var entrada = _entradaRepositorio.GetById(dto.Id);
if (entrada == null)
{
throw new Exception("No se encontro el registro solicitado.");
}
entrada.Monto = dto.Monto;
entrada.FechaDesde = dto.FechaDesde;
entrada.FechaHasta = dto.FechaHasta;
entrada.Cantidad = dto.Cantidad;
entrada.EventoId = dto.EventoId;
_entradaRepositorio.Update(entrada);
Guardar();
dto.Id = entrada.Id;
return(dto);
}
public EntradaDto ObtenerEntradaPoEventoId(long eventoId)
{
var entrada = _entradaRepositorio.GetByFilter(x => x.EventoId == eventoId);
if (entrada == null)
{
throw new Exception("No se encontro el registro solicitado.");
}
var entradaAux = entrada.FirstOrDefault(x => x.EventoId == eventoId);
var EntradaFinal = new EntradaDto
{
Id = entradaAux.Id,
Monto = entradaAux.Monto,
FechaDesde = entradaAux.FechaDesde,
FechaHasta = entradaAux.FechaHasta,
Cantidad = entradaAux.Cantidad,
EventoId = entradaAux.EventoId,
};
return(EntradaFinal);
}
public ActionResult Crear(EventoViewDto eventoViewDto, HttpPostedFileBase img)
{
if (img != null)
{
using (var reader = new BinaryReader(img.InputStream))
{
eventoViewDto.Imagen = reader.ReadBytes(img.ContentLength);
}
}
else
{
ViewBag.ErrorEvento = "Ingrese una Imagen para su evento.";
return(View());
}
ViewBag.ListaTipoEvento = _tipoEventoServicio.Get().ToList();
if (ModelState.IsValid)
{
try
{
if (!_eventoServicio.ValidarTitulo(eventoViewDto.Titulo))
{
if (!_eventoServicio.ValidarFecha(eventoViewDto.FechaEvento))
{
var evento = new EventoDto
{
Id = eventoViewDto.Id,
Titulo = eventoViewDto.Titulo,
Descripcion = eventoViewDto.Descripcion,
Mail = eventoViewDto.Mail,
Latitud = eventoViewDto.Latitud,
Longitud = eventoViewDto.Longitud,
TipoEventoId = eventoViewDto.TipoEventoId,
Orante = eventoViewDto.Orante,
Organizacion = eventoViewDto.Organizacion,
Domicilio = eventoViewDto.DomicilioCompleto,
Telefono = eventoViewDto.Telefono,
Imagen = eventoViewDto.Imagen
};
var EventoObj = _eventoServicio.Insertar(evento);
//*************************************************************//
var fecha = new FechaDto
{
FechaEvento = eventoViewDto.FechaEvento,
HoraInicio = eventoViewDto.HoraInicio,
HoraCierre = eventoViewDto.HoraFin
};
var FechaObj = _fechaServicio.Insertar(fecha);
//*************************************************************//
var fechaEvento = new FechaEventoDto
{
EventosId = EventoObj.Id,
FechaId = FechaObj.Id
};
_fechaEventoServicio.Insertar(fechaEvento);
//*************************************************************//
var entrada = new EntradaDto
{
Monto = eventoViewDto.Precio,
FechaDesde = DateTime.Now,
FechaHasta = DateTime.Now,
EventoId = EventoObj.Id,
Cantidad = 1
};
_entradaServicio.Insertar(entrada);
//*************************************************************//
var CreadorEvento = new CreadorEventoDto()
{
EventoId = EventoObj.Id,
UsuarioId = SessionActiva.UsuarioId,
Fecha = DateTime.Now
};
_creadorEventoServicio.Insertar(CreadorEvento);
//*************************************************************//
return(RedirectToAction("ViewEvento", new { id = EventoObj.Id }));
}
else
{
ViewBag.ErrorEvento = "Ingresa una fecha valida , anticipacion de 1 dia";
return(View());
}
}
else
{
ViewBag.ErrorEvento = "El Titulo del evento ya esta siendo utilizada.";
return(View());
}
}
catch (Exception e)
{
ViewBag.ErrorEvento = "Ocurrio un error inesperado en el sistema";
return(View());
}
}
else
{
return(View());
}
}
public async Task Insertar(EntradaDto dto)
{
var nuevaEntrada = _mapper.Map <Dominio.Entidades.Entrada>(dto);
await _entradaRepositorio.Create(nuevaEntrada);
}
public async Task <IActionResult> SeleccionarEntradas(PagoViewModel vm, long eventoId)
{
try
{
ViewBag.DatosInvalidos = false;
ViewBag.EntradaInsuficiente = false;
ViewBag.ClienteExistente = false;
ViewBag.EventoId = eventoId;
if (!ModelState.IsValid)
{
ViewBag.DatosInvalidos = true;
throw new Exception("Error de validacion no controlado.");
}
var evento = await _helperEvento.Obtener(eventoId);
if (evento.CupoDisponible < vm.Cantidad)
{
ViewBag.EntradaInsuficiente = true;
throw new Exception("Cantidad de entradas insuficiente.");
}
long clienteId = vm.Cliente.Id;
var clienteVm = vm.Cliente;
if (!User.Identity.IsAuthenticated)
{
var existe = await _helperCliente.ExisteCliente(vm.Cliente.Dni, vm.Cliente.Email);
if (existe)
{
ViewBag.ClienteExistente = true;
throw new Exception("Ya existe un cliente con los datos especificados.");
}
var clienteDto = new ClienteDto()
{
Apellido = vm.Cliente.Apellido,
Nombre = vm.Cliente.Nombre,
Dni = vm.Cliente.Dni,
Email = vm.Cliente.Email
};
clienteId = await _clienteServicio.InsertarDevuelveId(clienteDto);
clienteVm = await _helperCliente.Obtener(clienteId);
}
await _helperEvento.ActualizarCupoDisponible(evento.Id, vm.Cantidad);
// guardo la forma de pago
var formaPagoDto = new FormaPagoTarjetaDto()
{
Nombre = vm.FormaPago.Nombre,
NumeroTarjeta = vm.FormaPago.NumeroTarjeta,
AnioExp = vm.FormaPago.AnioExp,
MesExp = vm.FormaPago.MesExp,
CodigoSeguridad = vm.FormaPago.CodigoSeguridad,
CodigoPostal = vm.FormaPago.CodigoPostal,
DireccionFacturacion = vm.FormaPago.DireccionFacturacion
};
var formaPagoId = await _formaPagoTarjetaServicio.InsertarDevuelveId(formaPagoDto);
var formaPagoVm = await _helperFormaPagoTarjeta.Obtener(formaPagoId);
// guardo las entradas para el cliente (for int i=0; 1 < cantidad; i++)
var entradaVm = await _helperEntrada.ObtenerEntrada(vm.EntradaId);
long[] entradas = new long[vm.Cantidad];
for (int i = 0; i < vm.Cantidad; i++)
{
var entrada = new EntradaDto()
{
ClienteId = clienteId,
EventoId = entradaVm.EventoId,
Precio = entradaVm.Precio,
TipoEntradaId = entradaVm.TipoEntradaId
};
var entradaId = await _entradaServicio.InsertarDevuelveId(entrada);
entradas[i] = entradaId;
}
return(RedirectToAction("AltaFacturaRedirect", "FacturaPDF", new { clienteId = clienteVm.Id, formaPagoId = formaPagoVm.Id, entradaId = entradaVm.Id, cantidad = vm.Cantidad, entradas }));
}
catch (Exception)
{
vm.EntradasGenericas = await _helperEntrada.PoblarComboGeneric(eventoId);
return(View(vm));
}
}
public async Task Create(EntradaDto dto)
{
await _entradaRepos.Create(_mapper.Map <Dominio._4._1_Entidades.Entrada.Entrada>(dto));
}
