public static FacturaDTO GenerarFactura(CfdiV33.Comprobante comprobante, string tipo)
{
FacturaDTO factura = new FacturaDTO();
try
{
factura = new FacturaDTO()
{
tipo = tipo,
rfcEmisor = comprobante.Emisor.Rfc,
rfcReceptor = comprobante.Receptor.Rfc,
fechaDocto = comprobante.Fecha,
fechaTimbrado = comprobante.Complemento.Any[0].Attributes[1].Value,
noFactura = comprobante.Folio,
UUID = comprobante.Complemento.Any[0].Attributes[2].Value,
importeFactura = comprobante.Total,
moneda = comprobante.Moneda.ToString(),
tipoCambio = comprobante.TipoCambio.ToString()
};
}
catch (Exception ex)
{
LogErrores.Write("Ocurrio un error al Generar la factura con la V3.3 con el folio: " + comprobante.Folio, ex);
}
return(factura);
}
// Modificar una factura
public Respuesta UpdateFactura(FacturaDTO facturaDTO)
{
using (Contexto db = new Contexto())
{
var facturaUpdate = db.Facturas.Find(facturaDTO.FacturasId);
if (facturaUpdate != null)
{
//facturaUpdate.NumeroFactura = facturaDTO.NumeroFactura;
facturaUpdate.ClienteId = facturaDTO.ClienteId;
facturaUpdate.Fecha = facturaDTO.Fecha;
//facturaUpdate.FacturasId = facturaDTO.FacturasId;
Respuesta respuesta = new Respuesta();
respuesta.Mensaje = "Modificado correctamente";
respuesta.Error = false;
respuesta.FilasAfectadas = db.SaveChanges();
return(respuesta);
}
else
{
Respuesta respuesta = new Respuesta();
respuesta.Mensaje = "No se encontro";
respuesta.Error = false;
respuesta.FilasAfectadas = db.SaveChanges();
return(respuesta);
}
}
}
public async Task <IActionResult> UpdateInvoice(FacturaDTO facturaDTO)
{
if (ModelState.IsValid)
{
try
{
Factura invoiceFromDb = await _repository.GetInvoiceById(facturaDTO.IdFactura);
if (invoiceFromDb == null)
{
return(BadRequest());
}
// IdLocatie is a composite primary key and cannot be modified
// In order to modify the IdLocatie we have to remove the primary key from it
//invoiceFromDb.IdLocatie = facturaDTO.IdLocatie;
invoiceFromDb.NumarFactura = facturaDTO.NumarFactura;
invoiceFromDb.DataFactura = facturaDTO.DataFactura;
invoiceFromDb.NumeClient = facturaDTO.NumeClient;
await _repository.EditInvoice(invoiceFromDb);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.Message.Split('.')[0]));
}
}
return(BadRequest("Invalid Invoice."));
}
// Eliminar una factura
public Respuesta DeleteFactura(FacturaDTO facturaDTO)
{
using (Contexto db = new Contexto())
{
var facturaDelete = db.Facturas.Find(facturaDTO.FacturasId);
if (facturaDelete != null)
{
db.ItemFacturas.RemoveRange(db.ItemFacturas.Where(item => item.FacturaId == facturaDelete.FacturasId));
db.Facturas.Remove(facturaDelete);
db.SaveChanges();
Respuesta respuesta = new Respuesta();
respuesta.Mensaje = "Se ha eliminado la factura con sus items";
respuesta.Error = false;
respuesta.FilasAfectadas = db.SaveChanges();
return(respuesta);
}
else
{
Respuesta respuesta = new Respuesta();
respuesta.Mensaje = "No encontro el registro";
respuesta.Error = false;
respuesta.FilasAfectadas = db.SaveChanges();
return(respuesta);
}
}
}
public async Task <Factura> CreateFactura(FacturaDTO factura)
{
Producto producto = await productoRepository.GetProducto(factura.ProductoId);
if (producto == null)
{
return(null);
}
Preventa preventa = await preventaRepository.GetPreventa(factura.PreventaId);
if (preventa == null)
{
return(null);
}
Factura nuevaFactura = new Factura
{
Preventa = preventa,
Producto = producto,
FacturaFecha = DateTime.UtcNow,
Cantidad = factura.CantidadProducto,
Total = producto.ValorUnitario * factura.CantidadProducto
};
return(await facturaRepository.CreateFactura(nuevaFactura));
}
public void AgregarFactura(FacturaDTO miFactura)
{
/*Creamos el principio de la factura con los datos que podemos agregar*/
Factura nuevaFactura = new Factura()
{
fecha = miFactura.Fecha,
numeroCliente = miFactura.NumeroCliente,
total = miFactura.Total,
nickUsuario = miFactura.NickUsuario
};
using (BaseSistema miBase = new BaseSistema())
{
miBase.Factura.Add(nuevaFactura);
miBase.SaveChanges();
foreach (var item in miFactura.ListaDetalle)
{
/*Creamos detalle por detalle y lo vamos agregando*/
DetallesFactura nuevoDetalle = new DetallesFactura()
{
cantidad = item.Cantidad,
idProducto = item.IdProducto,
subTotal = item.SubTotal,
/*El id de la factura es el mismo y se genero automatico cuando agregue la factura*/
factura = nuevaFactura.numeroFactura
};
miBase.DetallesFactura.Add(nuevoDetalle);
}
/*Guardamos los cambios*/
miBase.SaveChanges();
}
}
public async Task <IActionResult> UpdateAsync(FacturaDTO model)
{
Response <string> response = new Response <string>();
try
{
if (model == null)
{
return(BadRequest());
}
response = await _FacturaApplication.UpdateAsync(model);
if (response.IsSuccess)
{
return(Ok(response));
}
else
{
return(BadRequest(response));
}
}
catch (Exception ex)
{
response.Data = null;
response.IsSuccess = false;
response.Message = ex.Message;
return(BadRequest(response));
}
}
public async Task <Response <string> > UpdateAsync(FacturaDTO model)
{
var response = new Response <string>();
try
{
var resp = _mapper.Map <Factura>(model);
response.Data = await _FacturasDomain.UpdateAsync(resp);
if (response.Data == "success")
{
response.IsSuccess = true;
response.Message = "Se ha actualizado la Factura exitosamente.";
}
else
{
response.IsSuccess = false;
response.Message = "Ha ocurrido un error inesperado, por favor intente nuevamente";
}
}
catch (Exception ex)
{
response.IsSuccess = false;
response.Message = ex.Message;
}
return(response);
}
/*IMPRIMIR FACTURA*/
public ActionResult Pdf(int numeroFactura)
{
//Buscamos la factura en la base:
FacturaDTO miFactura = logicaFactura.BuscarFactura(Convert.ToInt32(numeroFactura));
//Retornamos el pdf de la vista ImprimirFactura con los datos de mifactura
return(new Rotativa.ActionAsPdf("ImprimirFactura", miFactura));
}
// Guardar una factura
public Respuesta Insertar(FacturaDTO factura)
{
using (db = new Contexto())
{
using (var transaction = db.Database.BeginTransaction())
{
try
{
// preparar al item de factura para guardar
Facturas f = new Facturas();
f.Fecha = factura.Fecha;
f.NumeroFactura = factura.NumeroFactura;
f.ClienteId = factura.ClienteId;
// var response = db.SaveChanges();
foreach (ItemFacturaDTO item in factura.ItemFacturas)
{
ItemFactura itemFactura = new ItemFactura();
itemFactura.Descripcion = item.Descripcion;
itemFactura.Valor = item.Valor;
itemFactura.Cantidad = item.Cantidad;
itemFactura.Iva = item.Iva;
//itemFactura.FacturaId = f.FacturasId;
//itemFactura.Factura = f;
f.ItemFacturas.Add(itemFactura);
}
db.Facturas.Add(f);
// preparar la respuesta
respuesta.FilasAfectadas = db.SaveChanges();
respuesta.Mensaje = "Se realizó la operación satisfactoriamente";
respuesta.Error = false;
transaction.Commit();
}
catch (System.Data.Entity.Validation.DbEntityValidationException ex)
{
respuesta.Mensaje = ex.Message;
respuesta.FilasAfectadas = 0;
respuesta.Error = true;
}
catch (Exception ex)
{
respuesta.Mensaje = ex.Message;
respuesta.FilasAfectadas = 0;
respuesta.Error = true;
}
return(respuesta);
}
}
}
public ActionResult ImprimirFactura(FacturaDTO miFactura)
{
//Buscamos la factura en la base:
FacturaDTO unaFactura = logicaFactura.BuscarFactura(miFactura.numeroFactura);
//Convertimos la FacturaDTO a Facturamodel con el metodo en HerramientasM
//Este metodo tambien agregara la descripcion del producto y el nombre del cliente (info importante a la hora de listar)
FacturaModel unaFacturaModel = HerramientasM.ConvertirAFacturaModel(unaFactura);
//Retornamos la vista parcial:
return(View("_ImprimirFactura", unaFacturaModel));
}
public List <FacturaDTO> FacturasUsuario(string usuario)
{
//creamos la lista resultante
List <FacturaDTO> resultado = new List <FacturaDTO>();
using (BaseSistema miBase = new BaseSistema())
{
//Obtenemos la lista de facturas y el detalle al mismo tiempo
foreach (Factura f in miBase.Factura)
{
//Verificamos que el usuario sea el que nos pasan
if (f.nickUsuario.Trim().ToLower() == usuario.Trim().ToLower())
{
//Creamos la facturaDTO y le asignamos los valores de la Factura de la base
FacturaDTO miFactura = new FacturaDTO()
{
numeroFactura = f.numeroFactura,
NumeroCliente = f.numeroCliente,
Fecha = f.fecha,
NickUsuario = f.nickUsuario,
Total = f.total,
ListaDetalle = new List <DetalleFacturaDTO>()
};
//Ahora que tenemos una factura creada le agregamos su detalle, buscando en la lista de detalles
foreach (DetallesFactura d in miBase.DetallesFactura)
{
//Buscamos los detalles que correspondan a la factura actual
if (miFactura.numeroFactura == d.factura)
{
//Creamos un nuevo detalle con los datos que corresponden
DetalleFacturaDTO unDetalle = new DetalleFacturaDTO()
{
Cantidad = d.cantidad,
IdFactura = d.factura,
IdProducto = d.idProducto,
SubTotal = d.subTotal
};
//Agregamos el detalle a la factura:
miFactura.ListaDetalle.Add(unDetalle);
}
}
//Agregamos (luego de ya haber agregado los datos y los detalles) la factura a la lista resultado
resultado.Add(miFactura);
}
}
}
//retornamos la lista resultado que contiene la lista de facturas de la base de datos
return(resultado);
}
public FacturaDTO BuscarFactura(int numeroFactura)
{
//Creamos el resultado como null, luego si encontramos una factura le asignamos su valor
FacturaDTO resultado = null;
using (BaseSistema miBase = new BaseSistema())
{
//Obtenemos la lista de facturas y el detalle al mismo tiempo
foreach (Factura f in miBase.Factura)
{
//Buscamos la factura con el mismo id
if (f.numeroFactura == numeroFactura)
{
resultado = new FacturaDTO()
{
numeroFactura = f.numeroFactura,
NumeroCliente = f.numeroCliente,
Fecha = f.fecha,
NickUsuario = f.nickUsuario,
Total = f.total,
ListaDetalle = new List <DetalleFacturaDTO>()
};
//Ahora que tenemos una factura creada le agregamos su detalle, buscando en la lista de detalles
foreach (DetallesFactura d in miBase.DetallesFactura)
{
//Buscamos los detalles que correspondan a la factura actual
if (resultado.numeroFactura == d.factura)
{
//Creamos un nuevo detalle con los datos que corresponden
DetalleFacturaDTO unDetalle = new DetalleFacturaDTO()
{
Cantidad = d.cantidad,
IdFactura = d.factura,
IdProducto = d.idProducto,
SubTotal = d.subTotal
};
//Agregamos el detalle a la factura:
resultado.ListaDetalle.Add(unDetalle);
}
}
//Retornamos la faltura terminando el ciclo, porque ya no necesitamos buscar mas
return(resultado);
}
}
//En caso de no encontrar ninguna se retornara null porque asi definimos resultado al principio:
return(resultado);
}
}
public IHttpActionResult Create(FacturaDTO facturaDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var factura = Mapper.Map <FacturaDTO, Factura>(facturaDTO);
_UnityOfWork.Facturas.Add(factura);
_UnityOfWork.SaveChanges();
facturaDTO.FacturaId = factura.FacturaId;
return(Created(new Uri(Request.RequestUri + "/" + factura.FacturaId), facturaDTO));
}
public IHttpActionResult Create(FacturaDTO comprobanteDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var comprobante = Mapper.Map <FacturaDTO, Comprobante>(comprobanteDTO);
_UnityOfWork.Comprobantes.Add(comprobante);
_UnityOfWork.SaveChanges();
comprobanteDTO.ComprobanteId = comprobante.ComprobanteId;
return(Created(new Uri(Request.RequestUri + "/" + comprobante.ComprobanteId), comprobanteDTO));
}
public async Task <ResponseModel> CreateFactura(FacturaApiModel factura)
{
ResponseModel response;
try
{
FacturaDTO facturaCreate = mapper.Map <FacturaDTO>(factura);
Factura facturaResult = await facturaService.CreateFactura(facturaCreate);
if (facturaResult == null)
{
FacturaReponseModel facturaResponse = new FacturaReponseModel
{
ProcesoVenta = "Fallido"
};
response = new ResponseModel
{
HttpResponse = (int)HttpStatusCode.BadRequest,
Response = facturaResponse
};
}
else
{
FacturaReponseModel facturaResponse = mapper.Map <FacturaReponseModel>(facturaResult);
facturaResponse.ProcesoVenta = "Exitoso";
response = new ResponseModel
{
HttpResponse = (int)HttpStatusCode.Created,
Response = facturaResponse
};
}
}
catch (Exception ex)
{
logger.LogError(ex.Message);
response = new ResponseModel
{
HttpResponse = (int)HttpStatusCode.InternalServerError,
ErrorResponse = "Ha ocurrido un error, consulte con el administrador"
};
}
return(response);
}
public async Task <IActionResult> AddInvoice(FacturaDTO facturaDTO)
{
if (ModelState.IsValid)
{
try
{
Factura newInvoice = _mapper.Map <FacturaDTO, Factura>(facturaDTO);
await _repository.AddInvoice(newInvoice);
return(Ok(newInvoice));
}
catch (Exception e)
{
return(BadRequest(e.Message.Split('.')[0]));
}
}
return(BadRequest("Invalid Invoice."));
}
public int UpdateFactura(FacturaDTO factura)
{
try
{
using (var context = new DataModelDB())
{
var std = context.Facturas.Where(fac => fac.Id.Equals(factura.Id)).FirstOrDefault();
std.ClienteId = factura.ClienteId;
std.ValorTotal = factura.ValorTotal;
std.Estado = factura.Estado;
context.SaveChanges();
}
return(1);
}
catch (Exception ex)
{
return(0);
}
}
public IHttpActionResult Update(int id, FacturaDTO comprobanteDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var comprobanteInPersistence = _UnityOfWork.Comprobantes.Get(id);
if (comprobanteInPersistence == null)
{
return(NotFound());
}
Mapper.Map <FacturaDTO, Comprobante>(comprobanteDTO, comprobanteInPersistence);
_UnityOfWork.SaveChanges();
return(Ok(comprobanteDTO));
}
public IHttpActionResult Update(int id, FacturaDTO facturaDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var facturaInPersistence = _UnityOfWork.Facturas.Get(id);
if (facturaInPersistence == null)
{
return(NotFound());
}
Mapper.Map <FacturaDTO, Factura>(facturaDTO, facturaInPersistence);
_UnityOfWork.SaveChanges();
return(Ok(facturaDTO));
}
public ActionResult MostrarFactura(string numeroFactura)
{
//Anticipamos un posible error en la base de datos
try
{
//Buscamos la factura en la base:
FacturaDTO miFactura = logicaFactura.BuscarFactura(Convert.ToInt32(numeroFactura));
//Convertimos la factura a FacturaModel y ademas le agregamos el nombre de cliente y la descripcion del producto
FacturaModel unaFacturaModel = HerramientasM.ConvertirAFacturaModel(miFactura);
//Retornamos la vista parcial:
return(View("_MostrarFactura", unaFacturaModel));
}
catch (Exception unError)
{
//Podriamos guardar el error
//Devolvemos la vista de error
return(PartialView("_Error"));
}
}
/*
* Estas herramientas seran funciones que controlen datos que la logica no puede controlar
* Por ejemplo, sessiones, devuelve modelos, Convierte de DTO a MODEL, etc...
*/
/* ******************************************************
* SECCION HERRAMIENTAS DE FACTURA
* ******************************************************/
public static FacturaModel ConvertirAFacturaModel(FacturaDTO miFactura)
{
//Cargamos nombre y marca del producto y el nombre del cliente
FacturaModel unaFacturaModel = new FacturaModel()
{
Fecha = miFactura.Fecha,
NickUsuario = miFactura.NickUsuario,
Total = miFactura.Total,
NumeroCliente = miFactura.NumeroCliente,
NumeroFactura = miFactura.numeroFactura,
NombreCliente = NombreCliente(miFactura.NumeroCliente),
ListaDetalle = new List <DetalleFacturaModel>()
};
//Creamos la lista de detalles vacia
List <DetalleFacturaModel> lista = new List <DetalleFacturaModel>();
//Convertimos cada detalle DTO en detalle model agregandole Marca y nombreCliente para que se vea bien en la vista detalles
foreach (DetalleFacturaDTO f in miFactura.ListaDetalle)
{
//Creamos el detalle model
DetalleFacturaModel unDetalle = new DetalleFacturaModel()
{
Cantidad = f.Cantidad,
IdProducto = f.IdProducto,
SubTotal = f.SubTotal,
//Cargamos nombre y marca para que se muestre en la factura
NombreMarca = NombreMarcaProducto(f.IdProducto)
};
//Agregamos el detalle a la lista de detalles
lista.Add(unDetalle);
}
//Agregamos la lista a la factura
unaFacturaModel.ListaDetalle = lista;
//Retornamos la Factura
return(unaFacturaModel);
}
public void Edit(FacturaDTO Editedclass)
{
var x = Editedclass;
try
{
using (var db = new Data())
{
var pac = (from p in db.Facturas where p.Facturanro == Editedclass.Facturanro select p).FirstOrDefault();
if (pac != null)
{
pac.Caja = x.Caja;
pac.Descuento = x.Descuento;
pac.Equipo = x.Equipo;
pac.Facturanro = x.Facturanro;
pac.Mesa = x.Mesa;
pac.Montoneto = x.Montoneto;
pac.Montoiva = x.Montoiva;
pac.Nota = x.Nota;
pac.Serial = x.Serial;
pac.Sirve = x.Sirve;
pac.Tasa = x.Tasa;
pac.Total = x.Total;
pac.Userid = x.Userid;
pac.ClienteID = x.ClienteID;
pac.Moneda = x.Moneda;
pac.Cierrex = x.Cierrex;
pac.Cierrez = x.Cierrez;
pac.Fecha = x.Fecha;
db.SaveChanges();
}
}
}
catch (DbEntityValidationException e)
{ }
}
public int InsertFactura(FacturaDTO factura)
{
try
{
using (var context = new DataModelDB())
{
context.Facturas.Add(new Factura
{
Id = factura.Id,
ClienteId = factura.ClienteId,
FechaVenta = DateTime.Now,
ValorTotal = factura.ValorTotal,
Estado = true
});
context.SaveChanges();
}
return(1);
}
catch (Exception ex)
{
return(0);
}
}
public void Insert(FacturaDTO NewClase)
{
var x = NewClase;
var pac = new Factura();
pac.Caja = x.Caja;
pac.Descuento = x.Descuento;
pac.Equipo = x.Equipo;
pac.Facturanro = x.Facturanro;
pac.Montoiva = x.Montoiva;
pac.Mesa = x.Mesa;
pac.Montoneto = x.Montoneto;
pac.Nota = x.Nota;
pac.Serial = x.Serial;
pac.Sirve = x.Sirve;
pac.Tasa = x.Tasa;
pac.Total = x.Total;
pac.Userid = x.Userid;
pac.ClienteID = x.ClienteID;
pac.Moneda = x.Moneda;
pac.Anulada = x.Anulada;
pac.Exento = 0;
pac.Fecha = Convert.ToDateTime(DateTime.Now);
pac.Cierrex = x.Cierrex;
pac.Cierrez = x.Cierrez;
pac.Id = 0;
using (var db = new Data())
{
db.Facturas.Add(pac);
db.Entry(pac).State = System.Data.Entity.EntityState.Added;
db.SaveChanges();
}
}
public Respuesta DeleteFactura(FacturaDTO facturaDTO)
{
FacturaBLL factura = new FacturaBLL();
return(factura.DeleteFactura(facturaDTO));
}
/// <summary>
/// POST: /api/Factura
/// </summary>
/// <param name="factura"></param>
public void Post([FromBody] FacturaDTO factura)
{
new FacturaBL().InsertFactura(factura);
}
/// <summary>
/// PUT: /api/Factura
/// </summary>
/// <param name="id"></param>
/// <param name="factura"></param>
public void Put([FromBody] FacturaDTO factura)
{
new FacturaBL().UpdateFactura(factura);
}
public ActionResult GuardarFactura(FacturaModel unaFactura)
{
//Controlamos que el usuario este logueado
if (Session["Logueado"] != null)
{
if (ModelState.IsValid)
{
//Nos anticipamos a un posible error en servidor
try
{
//Guardamos el usuario actual para agregarlo a la factura
UsuarioModel usuarioActual = (UsuarioModel)Session["Logueado"];
//Creamos una facturaDTO la cual pasaremos a la base para que se guarde
FacturaDTO miFactura = new FacturaDTO()
{
Fecha = DateTime.Now,
NickUsuario = usuarioActual.Usuario,
NumeroCliente = unaFactura.NumeroCliente,
Total = CalcularGasto(unaFactura.ListaDetalle)
};
//Convertimos la lista del tipo List<DetalleFacturaModel> al tipo List<DetalleFacturaDTO> creando una nueva lista y agregandola a nuestra factura
//Inicializamos la lista:
miFactura.ListaDetalle = new List <DetalleFacturaDTO>();
//Vamos agregando uno a uno los detalles
foreach (DetalleFacturaModel item in unaFactura.ListaDetalle)
{
//Creamos el DetalleFacturaDTO
DetalleFacturaDTO nuevoDetalle = new DetalleFacturaDTO()
{
IdProducto = item.IdProducto,
Cantidad = item.Cantidad,
SubTotal = item.SubTotal
//Omitimos id de factura porque se agrega en Capa de Datos
};
//Agregamos el detalle a la lista
miFactura.ListaDetalle.Add(nuevoDetalle);
}
//Ahora que ya tenemos la factura lista la enviamos a guardar en la base de datos
logicaFactura.AgregarFactura(miFactura);
//Si todo salio bien redirigimos a crear factura para que pueda agregar mas
return(RedirectToAction("CrearFactura", "Factura"));
}
catch (Exception unError)
{
//Podemos guardar el error en la base de datos
//Redirigimos a la vista de error
return(View("Error"));
}
}
else//Si el modelo no es valido
{
//Redirigimos a crear factura
return(RedirectToAction("CrearFactura", "Factura"));
}
}
else//Si el usuario no esta logueado
{
//Si el usuario no esta logueado redirigimos a el login
return(RedirectToAction("Login", "Ingreso"));
}
}
/*Registramos la factura que nos llega como parametro*/
public void AgregarFactura(FacturaDTO miFactura)
{
repositorioFactura.AgregarFactura(miFactura);
}
