public ActionResult Create(FacturaViewModel factura)
{
dynamic resposonse = new ExpandoObject();
try
{
var item = _facturaService.Create(factura);
if (item != null)
{
resposonse.data = item;
resposonse.errormensaje = "";
resposonse.error = false;
}
else
{
resposonse.data = null;
resposonse.errormensaje = "No Existe Registros";
resposonse.error = true;
}
}
catch (Exception ex)
{
resposonse.data = null;
resposonse.errormensaje = ex.Message;
resposonse.error = true;
}
object datos = (object)resposonse;
return(Ok(datos));
}
public JResult InsFactura(FacturaViewModel model)
{
try
{
FACT_FACTURA dbItem = new FACT_FACTURA
{
Id = model.Id,
ClienteId = model.ClienteId,
Fecha = model.Fecha, //utilidades.ObtenerFechaDesdeString(model.Fecha),
Total = model.Total,
Estregistro = 1,
};
db.FACT_FACTURA.Attach(dbItem);
db.Entry(dbItem).State = EntityState.Added;
db.SaveChanges();
model.Id = dbItem.Id;
model.Estregistro = 1;
jresult.Data = model;
#region Salida Generica OK
return(jresult.SetOk("Registro creado correctamente"));
#endregion
}
#region Salida generica para errores
catch (Exception ex)
{
return(jresult.SetError(ex, "Error registrando datos", this.GetType().Name));
}
#endregion
}
//[ValidateAntiForgeryToken]
public async Task <IActionResult> Edit(FacturaViewModel model)
{
if (ModelState.IsValid)
{
try
{
var factura = await _converterHelper.ToFacturaAsync(model);
_context.Update(factura);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FacturaExists(model.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(new JsonResult(true));
}
model.Puertos = _combosHelper.GetComboPorts();
return(View(model));
}
public async Task <IActionResult> Details(long id)
{
try
{
var dto = (FacturaDto)await _facturaServicio.Obtener(id);
var model = new FacturaViewModel()
{
Id = dto.Id,
ClienteId = dto.ClienteId,
EmpresaId = dto.EmpresaId,
FormaPagoId = dto.FormaPagoId,
EstaEliminado = dto.EliminadoStr,
Fecha = dto.Fecha,
Total = dto.Total,
TipoFactura = dto.TipoFactura,
FacturaDetalles = dto.FacturaDetalles.Select(d => new FacturaDetalleViewModel()
{
FacturaId = d.FacturaId,
EntradaId = d.EntradaId,
Cantidad = d.Cantidad,
SubTotal = d.SubTotal,
Entrada = _helperEntrada.ObtenerEntrada(d.EntradaId).Result
}),
Cliente = _helperCliente.ObtenerNombreCliente(dto.ClienteId).Result,
Empresa = _helperEmpresa.ObtenerEmpresa(dto.EmpresaId).Result,
FormaPago = _helperFormaPago.ObtenerFormaPago(dto.FormaPagoId).Result,
};
return(View(model));
}
catch (Exception)
{
return(RedirectToAction(nameof(Index)));
}
}
public async Task <IActionResult> EditInvoice(FacturaViewModel invoice)
{
if (ModelState.IsValid)
{
try
{
if (invoice.IdFactura == 0)
{
Factura invoiceForDb = _mapper.Map <FacturaViewModel, Factura>(invoice);
await _repository.AddInvoice(invoiceForDb);
return(RedirectToAction("AllInvoices", "Invoice"));
}
Factura invoiceFromDb = await _repository.GetInvoiceById(invoice.IdFactura);
if (invoiceFromDb == null)
{
return(RedirectToAction("EditInvoice"));
}
invoiceFromDb.IdLocatie = invoice.IdLocatie;
invoiceFromDb.NumarFactura = invoice.NumarFactura;
invoiceFromDb.DataFactura = invoice.DataFactura;
invoiceFromDb.NumeClient = invoice.NumeClient;
await _repository.EditInvoice(invoiceFromDb);
return(RedirectToAction("AllInvoices", "Invoice"));
}
catch (Exception ex)
{
return(View("Error", ex.Message.Split('.')[0]));
}
}
return(View("AddInvoice"));
}
public JResult UpdFactura(FacturaViewModel model)
{
try
{
var dbItem = db.FACT_FACTURA.Find(model.Id);
dbItem.Id = model.Id;
dbItem.ClienteId = model.ClienteId;
dbItem.Fecha = model.Fecha;
dbItem.Total = model.Total;
dbItem.Estregistro = model.Estregistro;
db.FACT_FACTURA.Attach(dbItem);
db.Entry(dbItem).State = EntityState.Modified;
db.SaveChanges();
#region Salida Generica OK
return(jresult.SetOk());
#endregion
}
#region Salida generica para errores
catch (Exception ex)
{
return(jresult.SetError(ex, "Error registrando datos", this.GetType().Name));
}
#endregion
}
public string Save(FacturaViewModel facture)
{
if (!ModelState.IsValid)
{
IEnumerable <ModelError> errores = ModelState.Values.SelectMany(v => v.Errors);
return(serializer.Serialize(new { success = false, errores = errores }));
}
factura factura = new factura()
{
cliente_id = facture.cliente.Value
};
foreach (var producto in facture.productos)
{
factura.productos_factura.Add(new productos_factura()
{
productos_id = producto.id.Value,
cantidad = producto.cantidad.Value,
valor_unitario = producto.valor.Value
});
}
access.facturas.Add(factura);
access.SaveChanges();
return(serializer.Serialize(new { success = true }));
}
public ActionResult Nuevo(FacturaViewModel model)
{
try
{
if (ModelState.IsValid)
{
var oFactura = new Factura()
{
Total = model.Total,
FechaCompra = model.FechaCompra
};
db.Facturas.Add(oFactura);
db.SaveChanges();
return(Redirect("~/Compras"));
}
return(View(model));
}
catch (Exception)
{
throw;
}
}
public async Task <ActionResult> DevolverPorCodigo(string numero)
{
try
{
var fac = await facturaServices.DevolverPorNumero(numero);
FacturaViewModel factura = new FacturaViewModel();
factura.NumeroFactura = fac.Codigo;
factura.CodCliente = fac.Cliente.Codigo;
var resultcli = await clienteServices.DevolverPorCodigo(fac.Cliente.Codigo);
ClienteViewModel cliente = new ClienteViewModel();
cliente.Codigo = resultcli.Codigo;
cliente.Identificacion = resultcli.Identificacion;
cliente.Tipo_Documento = resultcli.Tipo_Identificacion.Abreviatura;
cliente.NombreCompleto = resultcli.NombreCompleto;
cliente.Direccion = resultcli.Direccion;
cliente.Telefono = resultcli.Telefono;
cliente.FechaNac = resultcli.FechaNac.ToString("dd/MM/yyyy");
cliente.Correo = resultcli.Correo;
factura.Cliente = cliente;
factura.Fecha = fac.Fecha.ToString("dd/MM/yyyy");
factura.SubTotal = fac.SubTotal;
factura.TotalDescuento = fac.Descuento;
factura.TotalIva = fac.Iva;
factura.TotalGeneral = fac.Total;
List <DetalleViewModel> listaDetalle = new List <DetalleViewModel>();
foreach (var item in fac.Detalle)
{
DetalleViewModel detalle = new DetalleViewModel();
detalle.NumeroFactura = fac.Codigo;
detalle.CodigoProducto = item.Producto.Codigo;
ProductoViewModel Producto = new ProductoViewModel();
Producto.CodigoProducto = item.Producto.Codigo;
Producto.NombreProducto = item.Producto.Nombre;
Producto.Descripcion = item.Producto.Descripcion;
Producto.Precio = item.Lista_Precio.Precio;
detalle.Producto = Producto;
detalle.Cantidad = item.Cantidad;
detalle.Precio = item.Lista_Precio.Precio;
detalle.PorcentajeDescuento = item.Descuento;
detalle.PorcentajeIva = item.Iva;
listaDetalle.Add(detalle);
}
factura.Detalle = listaDetalle;
return(Ok(factura));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> AddFileAsync(FacturaViewModel model)
{
try
{
if (ModelState.IsValid)
{
var files = HttpContext.Request.Form.Files;
var path = Path.Combine(_environment.WebRootPath, @"uploads\" + model.InvoiceNumber);
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
if (files.Count > 0)
{
foreach (var file in files)
{
if (file.Length > 0)
{
if (System.IO.File.Exists(path + @"\" + file.FileName))
{
var adjunto1 = await _context.Adjuntos.FirstOrDefaultAsync(a => a.DocumentName.Trim() == file.FileName.Trim());
if (adjunto1 != null)
{
await DeleteFileAsync(adjunto1.Id);
}
}
//var completePath = Path.Combine(@path, file.FileName);
using (var fileStream = new FileStream(Path.Combine(path, file.FileName), FileMode.Create))
{
await file.CopyToAsync(fileStream);
}
var adjunto = new Adjunto
{
RegisterDate = DateTime.Now,
User = _userSession.UserName,
DocumentUrl = path,
DocumentName = file.FileName,
Factura = await _context.Facturas.FirstOrDefaultAsync(f => f.Id == model.Id)
};
_context.Adjuntos.Add(adjunto);
await _context.SaveChangesAsync();
}
}
}
return(new JsonResult(true));
}
}
catch (Exception)
{
return(RedirectToAction(nameof(Index)));
}
return(RedirectToAction($"Edit/{model.Id}"));
}
public FacturaViewModel ConvertENToModelUI(FacturaEN en)
{
FacturaViewModel fac = new FacturaViewModel();
fac.id = en.Id;
fac.Pedido = en.Pedido.Id;
fac.Importe = en.Importe;
fac.Direccion = en.Direccion;
fac.MetodoPago = en.MetodoPago;
return(fac);
}
// GET: Factura/Delete/5
public ActionResult Delete(int id)
{
FacturaViewModel fac = null;
SessionInitialize();
FacturaEN facEN = new FacturaCAD(session).ReadOIDDefault(id);
fac = new AssemblerFactura().ConvertENToModelUI(facEN);
SessionClose();
return(View(fac));
}
public string Conexion(FacturaViewModel facturaNueva)
{
//string cadenaConexion = "Data Source=DESKTOP-7ALT5DI/SQLSERVER_2016;Initial Catalog=Factura;Integrated Security=True";
using (SqlConnection conexionBD = new SqlConnection(cadenaConexion))
{
SqlTransaction transaccion = null;
try
{
conexionBD.Open();
transaccion = conexionBD.BeginTransaction("tran1");
string query = "insert into tbl_factura(idCliente, total, fecha) " +
"values (@idCliente, @total, @fecha);SELECT SCOPE_IDENTITY()";
SqlCommand comando = new SqlCommand(query, conexionBD, transaccion);
comando.Parameters.AddWithValue("@idCliente", facturaNueva.idCliente);
comando.Parameters.AddWithValue("@total", 0);
comando.Parameters.AddWithValue("@fecha", "2018-25");
//idFactura = 2
//insert into factura
//Nos devuelve el idCreado con el Scope_identity
object resultado = comando.ExecuteScalar();
int idFacturaCreada = Int32.Parse(resultado.ToString());
foreach (var det in facturaNueva.detalleFactura)
{
string insertarDetalle = "insert into tbl_DetalleFactura " +
"(idFactura, idProducto, cantidad) values (@idFactura, @idProducto, @cantidad)";
SqlCommand comandoDetalle = new SqlCommand(insertarDetalle, conexionBD, transaccion);
// comando.CommandText =
comandoDetalle.Parameters.AddWithValue("@idFactura", idFacturaCreada);
comandoDetalle.Parameters.AddWithValue("@idProducto", det.idProducto);
comandoDetalle.Parameters.AddWithValue("@cantidad", det.cantidad);
//insert into detalleFactura
comandoDetalle.ExecuteNonQuery();
}
transaccion.Commit();
return("OK");
}
catch (SqlException exception)
{
if (transaccion != null)
{
transaccion.Rollback();
}
return("Hubo un error de tipo SQL: " + exception.Message);
}
catch (Exception exception)
{
if (transaccion != null)
{
transaccion.Rollback();
}
return("Hubo un error general: " + exception.Message);
}
}
}
public IList <TbFdFacturaDetalle> ViewModelToDomainFD(FacturaViewModel viewModel)
{
var domain = new List <TbFdFacturaDetalle>();
foreach (var item in viewModel.FacturaDetalle)
{
domain.Add(ViewModelToDomainSingleFD(item, viewModel));
}
return(domain);
}
public ActionResult <FacturaViewModel> Get(string id)
{
var factura = _facturaService.Consultar(id);
if (factura == null)
{
return(NotFound());
}
var facturaViewModel = new FacturaViewModel(factura);
return(facturaViewModel);
}
public ActionResult <FacturaViewModel> getByProductoId(string id)
{
Factura response = facturaService.ConsultarByProductoId(id);
if (response == null)
{
return(NotFound());
}
FacturaViewModel facturaViewModel = new FacturaViewModel(response);
return(facturaViewModel);
}
public ActionResult <FacturaViewModel> Get(int identificacion)
{
var factura = _facturaService.BuscarxIdentificacion(identificacion);
if (factura == null)
{
return(NotFound());
}
var facturaViewModel = new FacturaViewModel(factura);
return(facturaViewModel);
}
public ActionResult Delete(FacturaViewModel factura)
{
try
{
FacturaCEN fac = new FacturaCEN();
fac.Destroy(factura.id);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public ActionResult Create(FacturaViewModel factura)
{
try
{
FacturaCEN fac = new FacturaCEN();
fac.New_(factura.Pedido, factura.Importe, factura.Direccion, factura.MetodoPago);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public ActionResult Edit(FacturaViewModel factura)
{
try
{
FacturaCEN fac = new FacturaCEN();
fac.Modify(factura.id, factura.Importe, factura.Direccion, factura.MetodoPago);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public ActionResult Create(FacturaViewModel facturaViewModel)
{
if (ModelState.IsValid)
{
db.FacturasModels.Add(facturaViewModel.factura);
db.SaveChanges();
}
facturaViewModel.articulos = db.ArticulosModels.ToList().Select(i => new SelectListItem()
{
Value = i.id.ToString(), Text = i.descripcion
}).ToList();
return(View(facturaViewModel));
}
public ActionResult Reporte(int?idPedido, int?idDetalle)
{
var orden = db.Pedido.Where(x => x.Estado == 3 && x.IdPedido == idPedido).ToList();
var detalle = db.DetallePedido.Where(d => d.IdPedido == idPedido).ToList();
//var fact = db.Factura.Where(x => x.IdDetalle == idDetalle).ToList();
FacturaViewModel cvm = new FacturaViewModel();
cvm.pedidos = orden;
cvm.detalle = detalle;
cvm.menus = db.Menus.ToList();
cvm.factura = db.Factura.ToList();
return(View(cvm));
}
public ActionResult Edit(int Id)
{
var oFactura = db.Facturas.Find(Id);
FacturaViewModel model = new FacturaViewModel()
{
Total = oFactura.Total,
FechaCompra = oFactura.FechaCompra,
Id = oFactura.Id
};
return(View(model));
}
public bool ValidacionUnique(FacturaViewModel model)
{
//var query = getQueriableBaseActive().Where(w => w.ClienteId == model.ClienteId && w.f && w.Estregistro == 1 );
/*if (model.Id != null)
* {
* query = query.Where(w => w.Id != model.Id);
* }
* var data = query.FirstOrDefault();
* if (data != null)
* {
* jresult.Errores.addError("General", "Ya existe un registro con datos similares");
* return false;
* }*/
return(true);
}
public async Task <IActionResult> Facturar()
{
PurchaseEntity model = new PurchaseEntity();
model.Date = DateTime.Now;
model.PurchaseItemDetails = new List <PurchaseItemDetailEntity>();
model.PurchaseServiceDetails = new List <PurchaseServiceDetailEntity>();
FacturaViewModel viewmodel = new FacturaViewModel();
viewmodel.Factura = model;
viewmodel.Articulo = await _context.Items.Where(x => x.Stock > 0).ToListAsync();
viewmodel.Servicios = await _context.Services.ToListAsync();
return(View(viewmodel));
}
public async Task <Factura> ToFacturaAsync(FacturaViewModel factura)
{
var Factura = new Factura
{
Id = factura.Id,
InvoiceNumber = factura.InvoiceNumber,
InvoiceDate = factura.InvoiceDate,
InvoiceSystem = factura.InvoiceSystem,
InvoiceUser = factura.InvoiceUser,
Details = factura.Details,
Client = await _dataContext.Clientes.FindAsync(factura.ClienteId),
Port = await _dataContext.Puertos.FindAsync(factura.PuertoId),
Remarks = factura.Remarks
};
return(Factura);
}
public void Ejecutar(FacturaViewModel oFacturaViewModel)
{
Modelo.Factura oFactura = new Modelo.Factura()
{
RUC = oFacturaViewModel.RUC,
RazonSocial = oFacturaViewModel.RazonSocial,
Fecha = oFacturaViewModel.Fecha,
Glosa = oFacturaViewModel.Glosa,
FechaVencimiento = oFacturaViewModel.FechaVencimiento,
SubTotal = oFacturaViewModel.SubTotal,
IGV = oFacturaViewModel.IGV,
Total = oFacturaViewModel.Total
};
oFacturaRepositorio.Facturas.Agregar(oFactura);
oFacturaRepositorio.Commit();
}
public ActionResult Create(FacturaViewModel facturaViewModel)
{
if (ModelState.IsValid)
{
facturaViewModel.detalle.facturaid = facturaViewModel.factura.id;
db.FacturaDetallesModels.Add(facturaViewModel.detalle);
db.SaveChanges();
}
facturaViewModel.articulos = db.ArticulosModels.ToList().Select(i => new SelectListItem()
{
Value = i.id.ToString(), Text = i.descripcion
}).ToList();
TempData.Add("recargar", "no");
TempData.Add("facturaViewModel", facturaViewModel);
return(RedirectToAction("Create", "Facturas"));
}
// GET: Facturas/Create
public ActionResult Create()
{
if (TempData.Count > 0 && TempData["recargar"].ToString() == "no")
{
TempData.Remove("recargar");
return(View(TempData["facturaViewModel"]));
}
FacturaViewModel facturaViewModel = new FacturaViewModel();
facturaViewModel.factura = new FacturasModels();
facturaViewModel.factura.fecha = DateTime.Now;
facturaViewModel.detalle = new FacturaDetallesModels();
facturaViewModel.articulos = db.ArticulosModels.ToList().Select(i => new SelectListItem()
{
Value = i.id.ToString(), Text = i.descripcion
}).ToList();
return(View(facturaViewModel));
}
public string Create(FacturaViewModel factura)
{
using (var context = _unitOfWork.Create())
{
//Esto deberia ser en una modulo diferente, sepuede utilizar AutoMapper u otros...
Factura factura1 = new Factura();
factura1.Codigo = factura.Codigo;
factura1.Serie = factura.Serie;
factura1.Fecha = factura.Fecha;
factura1.ClienteId = factura.ClienteId;
factura1.VendedorId = factura.VendedorId;
factura1.Moneda = factura.Moneda;
factura1.FacturaDetalle = factura.FacturaDetalle;
var result = context.Repositories.FacturaRepository.Create(factura1);
return(result);
}
}