public ActionResult Index(string criterio, string busqueda, int pagina = 1)
{
var cantidadRegistrosPorPagina = 10;
var modelo = new CompraViewModel();
if (busqueda != null)
{
var Shops = db.vista_Compra_listado.Where(x => x.nombre_proveedor.StartsWith(busqueda)).OrderByDescending(x => x.id_compra).
Skip((pagina - 1) * cantidadRegistrosPorPagina).
Take(cantidadRegistrosPorPagina).ToList();
var totalDeRegistros = db.vista_Compra_listado.Where(x => x.nombre_proveedor.StartsWith(busqueda)).Count();
modelo.Compras = Shops;
modelo.PaginaActual = pagina;
modelo.RegistrosPorPagina = cantidadRegistrosPorPagina;
modelo.TotalDeRegistros = totalDeRegistros;
modelo.ValoresQueryString = new RouteValueDictionary();
modelo.ValoresQueryString["busqueda"] = busqueda;
return(View(modelo));
}
else
{
var Shops = db.vista_Compra_listado.OrderByDescending(x => x.id_compra).
Skip((pagina - 1) * cantidadRegistrosPorPagina).
Take(cantidadRegistrosPorPagina).ToList();
var totalDeRegistros = db.vista_Compra_listado.Count();
modelo.Compras = Shops;
modelo.PaginaActual = pagina;
modelo.RegistrosPorPagina = cantidadRegistrosPorPagina;
modelo.TotalDeRegistros = totalDeRegistros;
modelo.ValoresQueryString = new RouteValueDictionary();
modelo.ValoresQueryString[""] = busqueda;
return(View(modelo));
}
}
public TelaNovaCompra()
{
InitializeComponent();
_compraViewModel = new CompraViewModel();
_caminhoPrograma = "C:\\temp";
this.DataContext = _compraViewModel;
}
public IActionResult Guardar(CompraViewModel compra)
{
using (var transaction = _dbContext.Database.BeginTransaction())
{
try
{
Comprar comprar = new Comprar {
UsuarioId = "x", Total = compra.Total
};
_dbContext.Add(comprar);
_dbContext.SaveChanges();
foreach (Producto item in compra.Productos)
{
ComprarProducto comprarProducto = new ComprarProducto
{
ProductoId = item.ProductoId,
ComprarId = comprar.CompraId
};
_dbContext.Add(comprarProducto);
}
_dbContext.SaveChanges();
transaction.Commit();
}
catch (Exception e)
{
transaction.Rollback();
}
}
return(RedirectToAction());
}
public async Task <CompraViewModel> GetById(int id, string usuario)
{
const string methodName = nameof(GetById);
string header = $"METHOD | {usuario} | {serviceName}: {methodName}";
try
{
logger.LogInformation((int)LogEventEnum.Events.GetItem,
$"{header} - {MessageLog.GettingList.Value}");
CompraViewModel result = await context.Compras
.Include(item => item.Revendedor).Include(item => item.Status)
.Where(item => item.Id.Equals(id)).Select(item => new CompraViewModel
{
Codigo = item.Codigo,
Valor = item.Valor,
Data = item.DataCompra,
PercentualCashback = item.PercentualCashback,
ValorCashback = item.ValorCashback,
Status = item.Status.Descricao,
CpfUsadoCompra = item.CpfRevendedor,
NomeRevendedor = item.Revendedor.Nome,
CpfRevendedor = item.Revendedor.Cpf
}).FirstOrDefaultAsync();
logger.LogInformation((int)LogEventEnum.Events.GetItem,
$"{header} - {MessageLog.Getted.Value} - ID: {id}");
return(result);
}
catch (Exception)
{
throw;
}
}
public async Task <ActionResult <CompraViewModel> > GetById(int id)
{
const string endpointName = nameof(GetById);
string header = $"GET | {UserTokenOptions.GetClaimTypesNameValue(User.Identity)} | {controllerName}: {endpointName}";
try
{
logger.LogInformation((int)LogEventEnum.Events.GetItem,
$"{header} - {MessageLog.Start.Value}");
CompraViewModel entity = await service.GetById(id, UserTokenOptions.GetClaimTypesNameValue(User.Identity));
if (entity is null)
{
logger.LogInformation((int)LogEventEnum.Events.GetItemNotFound,
$"{header} - {MessageError.NotFoundSingle.Value}");
return(NotFound(new { message = MessageError.NotFoundSingle.Value }));
}
logger.LogInformation((int)LogEventEnum.Events.GetItem,
$"{header} - {MessageLog.Stop.Value}");
return(Ok(entity));
}
catch (Exception ex)
{
logger.LogError((int)LogEventEnum.Events.GetItemError, ex,
$"{header} - {MessageLog.Error.Value} | Exception: {ex.Message}");
return(StatusCode(StatusCodes.Status500InternalServerError,
new { message = MessageError.InternalError.Value, error = ex.Message }));
}
}
public IActionResult Comprar(CompraViewModel model)
{
var encabezadoFactura = new EncabezadoFactura
{
DireccionCliente = model.Direccion,
NombreCliente = model.NombreCliente,
TotalCompra = model.Productos.Where(c => c.Comprar).Sum(c => c.Precio)
};
var detalleFacturas = model.Productos
.Where(c => c.Comprar)
.Select(c => new DetalleFactura
{
NombreProducto = c.Nombre,
CodigoFactura = encabezadoFactura.CodigoFactura,
PrecioProducto = c.Precio
}
);
_db.EncabezadoFacturas.Add(encabezadoFactura);
_db.DetalleFacturas.AddRange(detalleFacturas);
_db.SaveChanges();
return(RedirectToAction("Comprar"));
}
public ActionResult CambiarEstadoBorradorCompra(CompraViewModel viewModel)
{
try
{
var compraBD = service.GetCompraByDocumento(viewModel.NumeroDocumento, viewModel.TipoDocumento, viewModel.IdProveedor);
if (compraBD == null || compraBD.Id == viewModel.Id)
{
viewModel.Borrador = false;
var compra = map.Update(viewModel);
kardexMap.CreateKardexCD((int)compra.Id);
if (viewModel.EnCola)
{
haciendaMap.CreateCACompra(compra);
}
return(Json(new { success = true }));
}
else
{
return(Json(new { succes = false }));
}
}
catch (Exception ex)
{
AltivaLog.Log.Insertar(ex.ToString(), "Error");
return(BadRequest());
}
}
public ActionResult Cadastrar(CompraViewModel compra, string token)
{
if (Session["Login"].ToString() == "off")
{
return(Content("Efetue login e tente novamente. Você precisa estar logado para concluir sua compra"));
}
if (!ModelState.IsValid)
{
return(Content("Ops... ocorreu um erro ao concluir sua compra."));
}
compra.Usuario = new UsuarioViewModel {
Cpf = Session["Login"].ToString()
};
var response = _appCompra.InserirCompra(compra, token);
if (response.Status != HttpStatusCode.OK)
{
return(Content($"Os itens da compra não puderam ser registrados: {response.ContentAsString }"));
}
var user = _appUsuario.SelecionarUsuario(Session["Login"].ToString());
if (user.Status != HttpStatusCode.OK)
{
return(Content($"Erro ao atualizar seu saldo, {user.ContentAsString}"));
}
Session["saldoUsuario"] = $"{user.Content.SaldoUsuario:C}";
TempData["LimparCarrinho"] = true;
return(Content("Sua compra foi registrada com sucesso"));
}
public IHttpActionResult Post(CompraViewModel compraViewModel)
{
try
{
if (
compraViewModel != null &&
compraViewModel.Cliente != null && compraViewModel.Cliente.Ip != null &&
compraViewModel.DadosPagamento != null &&
compraViewModel.Endereco != null
)
{
compraViewModel.Cliente.Cpf = Comum.RemoveCaracteresEspeciais(compraViewModel.Cliente.Cpf).Trim();
compraViewModel.Cliente.Rg = Comum.RemoveCaracteresEspeciais(compraViewModel.Cliente.Rg).Trim();
compraViewModel.Cliente.Telefone = Comum.RemoveCaracteresEspeciais(compraViewModel.Cliente.Telefone).Trim();
var cliente = Mapper.Map <ClienteViewModel, Cliente>(compraViewModel.Cliente);
_clienteServico.Add(cliente);
compraViewModel.DadosPagamento.NumeroCartao = Comum.RemoveCaracteresEspeciais(compraViewModel.DadosPagamento.NumeroCartao).Trim();
compraViewModel.DadosPagamento.Cvv = Comum.RemoveCaracteresEspeciais(compraViewModel.DadosPagamento.Cvv).Trim();
compraViewModel.DadosPagamento.Validade = "31/" + compraViewModel.DadosPagamento.Validade;
var dadosPagamento = Mapper.Map <DadosPagamentoViewModel, DadosPagamento>(compraViewModel.DadosPagamento);
dadosPagamento.ClienteId = cliente.ClienteId;
_dadosPagamentoServico.Add(dadosPagamento);
compraViewModel.Endereco.ClienteId = cliente.ClienteId;
_enderecoServico.Add(compraViewModel.Endereco);
}
return(Ok("true"));
}
catch
{
return(BadRequest("false"));
}
}
public void AtualizarCompra(CompraViewModel compraViewModel)
{
var compra = _mapper.Map <Compra>(compraViewModel);
_compraRepository.Atualizar(compra);
_compraRepository.UnitOfWork.Commit();
}
public CompraViewModel Atualizar(CompraViewModel compraViewModel)
{
var compra = Mapper.Map <CompraViewModel, Compra>(compraViewModel);
BeginTransaction();
_compraService.Atualizar(compra);
Commit();
return(compraViewModel);
}
public ActionResult Create(CompraViewModel compraViewModel)
{
if (ModelState.IsValid)
{
compraViewModel = _compraAppService.Adicionar(compraViewModel);
return(RedirectToAction("Index"));
}
return(View(compraViewModel));
}
public ActionResult Edit(CompraViewModel compraViewModel)
{
if (ModelState.IsValid)
{
_compraAppService.Atualizar(compraViewModel);
return(RedirectToAction("Index"));
}
return(View(compraViewModel));
}
public JsonResult Compra_Final(ProductoViewModel producto)
{
IUserDAL userDAL = new UserDALImpl();
CompraViewModel lista = Session["Entradas"] as CompraViewModel;
User userViewModel = Session["Usuario_Compra"] as User;
Session["Orden_Comida"] = producto;
producto = Session["Orden_Comida"] as ProductoViewModel;
int id_sala = Convert.ToInt32(lista.sala);
Asiento asiento = new Asiento();
Reserva reserva = new Reserva();
User user_temp;
User user = new User()
{
nombre = userViewModel.nombre,
apellidos = userViewModel.apellidos,
Password = userViewModel.Password,
mail = userViewModel.mail,
UserName = userViewModel.nombre,
phone = userViewModel.phone,
card = userViewModel.card
};
using (UnidadDeTrabajo <User> unidad = new UnidadDeTrabajo <User>(new BDContext()))
{
unidad.genericDAL.Add(user);
unidad.Complete();
user_temp = userDAL.getUser(user.nombre);
reserva.id_cliente = user_temp.UserId;
}
foreach (var item in lista.numero_asiento)
{
asiento.id_sala = id_sala;
asiento.numero_asiento = item;
asiento.estado = 1;
using (UnidadDeTrabajo <Asiento> unidad = new UnidadDeTrabajo <Asiento>(new BDContext()))
{
asiento.id_asiento = unidad.genericDAL.GetAll().Count() + 1;
unidad.genericDAL.Add(asiento);
unidad.Complete();
reserva.id_asiento = unidad.genericDAL.GetAll().Count();
}
using (UnidadDeTrabajo <Reserva> unidad = new UnidadDeTrabajo <Reserva>(new BDContext()))
{
reserva.id_reserva = unidad.genericDAL.GetAll().Count() + 1;
unidad.genericDAL.Add(reserva);
unidad.Complete();
}
}
return(Json("Exito"));
}
public MntCompraForm(ObservableListSource <CompraViewModel> viewModelList)
{
InitializeComponent();
ViewModel = new CompraViewModel();
ViewModelList = viewModelList;
compraViewModelBindingSource.DataSource = ViewModel;
//
CargarCombos();
}
public IActionResult Detalles(int id)
{
CompraViewModel compra = new CompraViewModel
{
EncabezadoCompra = _unitOfWork.encabezadoCompra.Get(id),
DetallesCompra = _unitOfWork.detalleCompra.GetAll(filtro: c => c.IdEncabezadoCompra == id)
};
return(View(compra));
}
public void Create([Bind(Include = "Id,EnderecoId,PagamentoId,UsuarioId,ProdutosCarrinho")] CompraViewModel compra)
{
if (ModelState.IsValid)
{
new MapperConfiguration(map => { map.CreateMap <CompraViewModel, Compra>(); });
var model = Mapper.Map <CompraViewModel, Compra>(compra);
_app.Add(model);
db.SaveChanges();
}
}
// GET: Compra/Details/5
public ActionResult Details(int id)
{
CompraViewModel comp = null;
SessionInitialize();
CompraEN compEN = new CompraCAD(session).ReadOIDDefault(id);
comp = new CompraAssembler().ConvertEnToModelUI(compEN);
SessionClose();
return(View(comp));
}
public IActionResult Put([FromBody] CompraViewModel compraViewModel)
{
if (!ModelState.IsValid)
{
NotificarErroModelInvalida();
return(Response());
}
_compraAppService.Atualizar(compraViewModel);
return(Response(compraViewModel));
}
public ActionResult Compra(UserViewModel userViewModel)
{
CompraViewModel lista = Session["Entradas"] as CompraViewModel;
IUserDAL userDAL = new UserDALImpl();
User user_temp;
int id_sala = Convert.ToInt32(lista.sala);
Asiento asiento = new Asiento();
Reserva reserva = new Reserva();
User user = new User()
{
nombre = userViewModel.nombre,
apellidos = userViewModel.apellidos,
Password = userViewModel.Password,
mail = userViewModel.mail,
UserName = userViewModel.nombre,
phone = userViewModel.phone,
card = userViewModel.card
};
Session["Usuario_Compra"] = user;
using (UnidadDeTrabajo <User> unidad = new UnidadDeTrabajo <User>(new BDContext()))
{
unidad.genericDAL.Add(user);
unidad.Complete();
user_temp = userDAL.getUser(user.nombre);
reserva.id_cliente = user_temp.UserId;
}
foreach (var item in lista.numero_asiento)
{
asiento.id_sala = id_sala;
asiento.numero_asiento = item;
asiento.estado = 1;
using (UnidadDeTrabajo <Asiento> unidad = new UnidadDeTrabajo <Asiento>(new BDContext()))
{
asiento.id_asiento = unidad.genericDAL.GetAll().Count() + 1;
unidad.genericDAL.Add(asiento);
unidad.Complete();
reserva.id_asiento = unidad.genericDAL.GetAll().Count();
}
using (UnidadDeTrabajo <Reserva> unidad = new UnidadDeTrabajo <Reserva>(new BDContext()))
{
reserva.id_reserva = unidad.genericDAL.GetAll().Count() + 1;
unidad.genericDAL.Add(reserva);
unidad.Complete();
}
}
return(RedirectToAction("About", "Proyecciones"));
}
public Response <int> InserirCompra(CompraViewModel compra, string token)
{
using (var client = new HttpClient())
{
/* Aqui é definido o endereço da API, o verbo HTTP que será utilizado
* (nesse caso POST) e o tipo de retorno(nesse caso JSON), a linha de baixo
* define o tipo da resposta(nesse caso INT) e recebe o status dessa resposta
* (ok, bad request, internal server error, etc) */
AtualizaToken(token, client);
var response = client.PostAsync(_enderecoApi, compra, new JsonMediaTypeFormatter()).Result;
return(new Response <int>(response.Content.ReadAsStringAsync().Result, response.StatusCode));
}
}
public IActionResult Post([FromBody] CompraViewModel compraViewModel)
{
if (!ModelState.IsValid)
{
NotificarErroModelInvalida();
return(Response());
}
var compraCommand = _mapper.Map <RegistrarCompraCommand>(compraViewModel);
_bus.SendCommand(compraCommand);
return(Response(compraCommand));
}
public ActionResult Edit(CompraViewModel compView)
{
try
{
CompraCEN compCEN = new CompraCEN();
compCEN.Modify(compView.CompraId, compView.tipo_pago, compView.infoTarjeta, compView.fecha, compView.terminal, compView.comercio);
return(RedirectToAction("PorCompra", new { id = compView.CompraId }));
}
catch
{
return(View());
}
}
public JsonResult Entradas(CompraViewModel data)
{
Session["Entradas"] = data;
if (data != null)
{
return(Json("'Success':'true'" + data));
}
else
{
return(Json(String.Format("'Success':'false','Error':'Ha habido un error al mapear los datos.'")));
}
}
public ActionResult Create(CompraViewModel com)
{
try
{
CompraCEN comCEN = new CompraCEN();
comCEN.CreaCompra(com.compradorId, com.LibroId, com.tipo_pago, com.infoTarjeta, com.fecha, com.terminal, com.comercio);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public IActionResult Comprar()
{
var productos = _db.Productos.Select(c => new ProductoViewModel {
Nombre = c.Nombre,
Precio = c.Precio
}).ToList();
var model = new CompraViewModel
{
Productos = productos
};
return(View(model));
}
// GET: Compra/Delete/5
public ActionResult Delete(Guid?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
CompraViewModel compraViewModel = _compraAppService.ObterPorId(id.Value);
if (compraViewModel == null)
{
return(HttpNotFound());
}
return(View(compraViewModel));
}
public IActionResult Create(CompraViewModel compraViewModel)
{
if (!ModelState.IsValid)
{
return(View(compraViewModel));
}
compraViewModel.ClienteId = ClienteId;
_compraAppService.Registrar(compraViewModel);
ViewBag.RetornoPost = OperacaoValida() ? "success,Compra registrada com sucesso!" : "error,Compra não registrada! verifique as mensagens!";
return(View(compraViewModel));
}
public async Task <ActionResult <CompraViewModel> > Registrar([FromBody] CompraViewModel compraViewModel)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var compra = _mapper.Map <Compra>(compraViewModel);
compra.AdicionarProdutos(_mapper.Map <List <CompraProduto> >(compraViewModel.ProdutosCompra));
await _compraService.Registrar(compra);
return(CustomResponse(compraViewModel));
}
public ActionResult CrearGasto()
{
ViewData["usuario"] = userService.GetSingleUser(int.Parse(User.Claims.FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier)?.Value));
var tipoCambio = monedaService.GetAll();
var model = new CompraViewModel
{
TipoCambioDolar = tipoCambio.FirstOrDefault(m => m.Codigo == 2).ValorCompra,
TipoCambioEuro = tipoCambio.FirstOrDefault(m => m.Codigo == 3).ValorCompra,
Borrador = true
};
ViewData["monedas"] = tipoCambio;
ViewBag.tieneToma = false;
return(View("CrearEditarGasto", model));
}
