public static ResAcc<FacturaElectronica> GenerarXml(FacturaElectronica oFactura)
{
// Se genera el xml con los datos de la factura
var ResProcs = FacturaXml.GenerarXmlDeObjeto(oFactura);
string sFacturaXml = ResProcs.Respuesta;
// Se transforma al Xml requerido por el Sat v3.2
ResProcs = FacturaXml.TransformarXml(sFacturaXml, Properties.Resources.Cfdi3_2);
if (ResProcs.Error)
return new ResAcc<FacturaElectronica>(false, ResProcs.Mensaje);
string sCfdiXml = ResProcs.Respuesta;
// Se valida el Xml generado
ResProcs = FacturaXml.ValidarXml(sCfdiXml, Properties.Resources.cfdv32);
if (ResProcs.Error)
return new ResAcc<FacturaElectronica>(false, ResProcs.Mensaje);
// Se genera la cadena original
ResProcs = FacturaXml.TransformarXml(sCfdiXml, Properties.Resources.cadenaoriginal_3_2);
if (ResProcs.Error)
return new ResAcc<FacturaElectronica>(false, ResProcs.Mensaje);
string sCadenaOriginal = System.Web.HttpUtility.HtmlDecode(ResProcs.Respuesta);
// Se genera la cadena del sello digital
var Seguridad = new FacturaSeguridad();
ResProcs = Seguridad.GenerarSelloDigital(oFactura.Configuracion.RutaArchivoKey, oFactura.Configuracion.ContraseniaArchivoKey, sCadenaOriginal);
if (ResProcs.Error)
return new ResAcc<FacturaElectronica>(false, ResProcs.Mensaje);
string sSelloDigital = ResProcs.Respuesta;
// Se agregan los nuevos datos al xml a generar
var oCertificado = Seguridad.DatosCertificado(oFactura.Configuracion.RutaCertificado);
XmlDocument oXml = new XmlDocument();
oXml.LoadXml(sCfdiXml);
oXml.DocumentElement.Attributes["noCertificado"].Value = oCertificado["NumeroDeSerie"];
oXml.DocumentElement.Attributes["certificado"].Value = oCertificado["ContenidoBase64"];
oXml.DocumentElement.Attributes["sello"].Value = sSelloDigital;
// Se guarda el xml con los cambios
var oTexto = new StringWriterMod(Encoding.UTF8);
var oEscXml = XmlWriter.Create(oTexto, FacturaXml.ConfigXml);
oXml.Save(oEscXml);
ResProcs.Exito = true;
ResProcs.Respuesta = oTexto.ToString();
oFactura.NumeroDeCertificado = oCertificado["NumeroDeSerie"];
oFactura.Certificado = oCertificado["ContenidoBase64"];
oFactura.Sello = sSelloDigital;
oFactura.XmlFactura = ResProcs.Respuesta;
return new ResAcc<FacturaElectronica>(true, oFactura);
}
public static ResAcc<int> GenerarNotaDeCreditoFiscal(List<ProductoVenta> oDetalle, int iClienteID, int iUsuarioID)
{
// Se crea la instancia de la clase de Facturación Electrónica
var oFacturaE = new FacturaElectronica();
var oConfig = TheosProc.Config.ValoresVarios("Facturacion.");
// Se llenan los valores de configuración y los datos del emisor
VentasLoc.FeLlenarDatosComunes(ref oFacturaE, oConfig);
// Se llenan los datos generales de la factura
DateTime dAhora = DateTime.Now;
// Se obtiene el nombre del vendedor
var oUsuario = Datos.GetEntity<Usuario>(q => q.UsuarioID == iUsuarioID && q.Estatus);
string sVendedores = oUsuario.NombrePersona;
oFacturaE.Adicionales = new Dictionary<string, string>();
oFacturaE.Adicionales.Add("Vendedor", sVendedores);
oFacturaE.Fecha = dAhora;
oFacturaE.FormaDePago = "Una sola exhibición";
oFacturaE.LugarDeExpedicion = string.Format("{0}, {1}", oConfig["Facturacion.Municipio"], oConfig["Facturacion.Estado"]);
oFacturaE.TipoDeComprobante = Enumerados.TiposDeComprobante.Egreso;
oFacturaE.TasaDeImpuesto = GlobalClass.ConfiguracionGlobal.IVA.ToString();
oFacturaE.MetodoDePago = CatFe.MetodosDePago.Otros;
// Se llenan los datos del receptor
var ResRec = VentasLoc.FeLlenarDatosReceptor(ref oFacturaE, iClienteID);
if (ResRec.Error)
return new ResAcc<int>(false, ResRec.Mensaje);
// Se agregan datos adicionales
oFacturaE.Adicionales.Add("FacturaOrigen", "");
// Se llenan los conceptos de la factura
decimal mSubtotal = 0, mIva = 0;
oFacturaE.Conceptos = new List<Concepto>();
foreach (var oDet in oDetalle)
{
oFacturaE.Conceptos.Add(new Concepto()
{
Identificador = oDet.NumeroDeParte,
Cantidad = oDet.Cantidad,
Unidad = oDet.UnidadDeMedida,
Descripcion = oDet.NombreDeParte,
ValorUnitario = oDet.PrecioUnitario,
Iva = oDet.Iva
});
mSubtotal += oDet.PrecioUnitario;
mIva += oDet.Iva;
}
// Se comienza a procesar la facturación electrónica
// Se envía la factura y se obtiene el Xml generado
var ResXml = VentasLoc.FeEnviarFactura(ref oFacturaE);
bool bFacturada = ResXml.Exito;
/* if (ResXml.Error)
return new ResAcc<int>(false, ResXml.Mensaje);
*/
string sCfdiTimbrado = ResXml.Respuesta;
// Se guarda la información
var oFolioFactura = VentasLoc.GenerarFolioDeFacturaDevolucion();
oFacturaE.Serie = oFolioFactura["Serie"];
oFacturaE.Folio = oFolioFactura["Folio"];
var oNota = new NotaDeCreditoFiscal()
{
Fecha = dAhora,
ClienteID = iClienteID,
SucursalID = GlobalClass.SucursalID,
FolioFiscal = (oFacturaE.Timbre == null ? "" : oFacturaE.Timbre.FolioFiscal),
Serie = oFacturaE.Serie,
Folio = oFacturaE.Folio,
Subtotal = mSubtotal,
Iva = mIva,
RealizoUsuarioID = iUsuarioID
};
Datos.Guardar<NotaDeCreditoFiscal>(oNota);
// Se guarda el detalle de la Nota de Crédito
foreach (var oReg in oDetalle)
{
int iVentaID = Util.Entero(oReg.NumeroDeParte);
if (iVentaID <= 0) continue;
Datos.Guardar<NotaDeCreditoFiscalDetalle>(new NotaDeCreditoFiscalDetalle()
{
NotaDeCreditoFiscalID = oNota.NotaDeCreditoFiscalID,
VentaID = iVentaID,
Descuento = oReg.PrecioUnitario,
IvaDescuento = oReg.Iva
});
}
// Se manda guardar la factura, en pdf y xml
if (bFacturada)
VentasLoc.FeGuardarArchivosFacturaDevolucion(ref oFacturaE, sCfdiTimbrado, (oFacturaE.Serie + oFacturaE.Folio));
// Se manda la nota de crédito generada, por correo
// VentasProc.EnviarFacturaDevolucionPorCorreo(oFacturaDevolucion.VentaFacturaDevolucionID);
// Se manda imprimir la factura
// ..
var oRes = new ResAcc<int>(bFacturada, oNota.NotaDeCreditoFiscalID);
if (!bFacturada)
oRes.Mensaje = ResXml.Mensaje;
return oRes;
}
public static ResAcc<int> GenerarFacturaGlobal(string sConceptoVentas, decimal mCostoTotal, decimal mTotalVentas
, string sConceptoCancelaciones, decimal mTotalCancelaciones, string sConceptoDevoluciones, decimal mTotalDevoluciones
, List<VentasPagosDetalleView> oFormasDePago)
{
// Se crea la instancia de la clase de Facturación Electrónica
var oFacturaE = new FacturaElectronica();
var oConfig = TheosProc.Config.ValoresVarios("Facturacion.");
// Se llenan los valores de configuración y los datos del emisor
VentasLoc.FeLlenarDatosComunes(ref oFacturaE, oConfig);
// Se llenan los datos generales de la factura
int iClienteID = Cat.Clientes.Mostrador;
DateTime dAhora = DateTime.Now;
oFacturaE.Fecha = dAhora;
oFacturaE.FormaDePago = "Una sola exhibición";
oFacturaE.LugarDeExpedicion = string.Format("{0}, {1}", oConfig["Facturacion.Municipio"], oConfig["Facturacion.Estado"]);
oFacturaE.TipoDeComprobante = Enumerados.TiposDeComprobante.Ingreso;
oFacturaE.TasaDeImpuesto = GlobalClass.ConfiguracionGlobal.IVA.ToString();
oFacturaE.MetodoDePago = VentasLoc.GenerarMetodoDePagoFactura(oFormasDePago);
// Se agraga la cadena del método de pago, como adicional
oFacturaE.Adicionales = new Dictionary<string, string>();
oFacturaE.Adicionales.Add("LeyendaDePago", VentasLoc.GenerarCadenaMetodoDePagoFactura(oFormasDePago));
// Se llenan los datos del receptor
var ResRec = VentasLoc.FeLlenarDatosReceptor(ref oFacturaE, iClienteID);
if (ResRec.Error)
return new ResAcc<int>(false, ResRec.Mensaje);
// Se calcula el Iva
decimal mVentasValor = UtilTheos.ObtenerPrecioSinIva(mTotalVentas);
decimal mVentasIva = UtilTheos.ObtenerIvaDePrecio(mTotalVentas);
decimal mCancelacionesValor = UtilTheos.ObtenerPrecioSinIva(mTotalCancelaciones);
decimal mCancelacionesIva = UtilTheos.ObtenerIvaDePrecio(mTotalCancelaciones);
decimal mDevolucionesValor = UtilTheos.ObtenerPrecioSinIva(mTotalDevoluciones);
decimal mDevolucionesIva = UtilTheos.ObtenerIvaDePrecio(mTotalDevoluciones);
// Se llenan los conceptos de la factura
const string sUnidad = "U";
oFacturaE.Conceptos = new List<Concepto>();
// Ventas
oFacturaE.Conceptos.Add(new Concepto()
{
Cantidad = 1,
Unidad = sUnidad,
Descripcion = sConceptoVentas,
ValorUnitario = mVentasValor,
Iva = mVentasIva
});
// Cancelaciones
oFacturaE.Conceptos.Add(new Concepto()
{
Cantidad = 1,
Unidad = sUnidad,
Descripcion = sConceptoCancelaciones,
ValorUnitario = (mCancelacionesValor * -1),
Iva = (mCancelacionesIva * -1)
});
// Devoluciones
oFacturaE.Conceptos.Add(new Concepto()
{
Cantidad = 1,
Unidad = sUnidad,
Descripcion = sConceptoDevoluciones,
ValorUnitario = (mDevolucionesValor * -1),
Iva = (mDevolucionesIva * -1)
});
// Se comienza a procesar la facturación electrónica
// Se envía la factura y se obtiene el Xml generado
var ResXml = VentasLoc.FeEnviarFactura(ref oFacturaE);
if (ResXml.Error)
return new ResAcc<int>(false, ResXml.Mensaje);
string sCfdiTimbrado = ResXml.Respuesta;
// Se guarda la información
var oFolioFactura = VentasLoc.GenerarFolioDeFactura();
oFacturaE.Serie = oFolioFactura["Serie"];
oFacturaE.Folio = oFolioFactura["Folio"];
var oVentaFactura = new VentaFactura()
{
Fecha = dAhora,
FolioFiscal = oFacturaE.Timbre.FolioFiscal,
Serie = oFacturaE.Serie,
Folio = oFacturaE.Folio,
ClienteID = iClienteID,
Costo = mCostoTotal,
Subtotal = (mVentasValor - mCancelacionesValor - mDevolucionesValor),
Iva = (mVentasIva - mCancelacionesIva - mDevolucionesIva)
};
var oVentaFacturaD = new List<VentaFacturaDetalle>();
// No se agrega ningún detalle, para que las ventas aquí facturadas no aparezcan como facturadas
// foreach (var oVenta in oVentas)
// oVentaFacturaD.Add(new VentaFacturaDetalle() { VentaID = oVenta.VentaID });
Guardar.Factura(oVentaFactura, oVentaFacturaD);
// Se manda guardar la factura, en pdf y xml
var oRep = VentasLoc.FeGuardarArchivosFactura(ref oFacturaE, sCfdiTimbrado, (oFacturaE.Serie + oFacturaE.Folio));
// Se manda imprimir la factura
// ..
return new ResAcc<int>(true, oVentaFactura.VentaFacturaID);
}
public static ResAcc<int> GenerarFacturaElectronica(List<int> VentasIDs, int iClienteID
, List<ProductoVenta> oListaVenta, List<VentasPagosDetalleView> oFormasDePago, string sObservacion, Dictionary<string, object> oAdicionales)
{
// Se crea la instancia de la clase de Facturación Electrónica
var oFacturaE = new FacturaElectronica();
var oConfig = TheosProc.Config.ValoresVarios("Facturacion.");
// Se llenan los valores de configuración y los datos del emisor
VentasLoc.FeLlenarDatosComunes(ref oFacturaE, oConfig);
// Se llenan los datos generales de la factura
DateTime dAhora = DateTime.Now;
// Se obtienen las ventas a facturar, y los vendedores
var oVentas = new List<VentasView>();
string sVendedores = "";
foreach (int iVentaID in VentasIDs)
{
var oVentaV = Datos.GetEntity<VentasView>(q => q.VentaID == iVentaID);
oVentas.Add(oVentaV);
sVendedores += (", " + oVentaV.Vendedor);
}
sVendedores = (sVendedores == "" ? "" : sVendedores.Substring(2));
oFacturaE.Adicionales = new Dictionary<string, string>();
oFacturaE.Adicionales.Add("Vendedor", sVendedores);
if (oVentas.Count > 0)
{
oFacturaE.Adicionales.Add("ACredito", oVentas[0].ACredito.ToString());
// Se llena el dato de la fecha de vencimiento, sólo de la primer venta
int iClienteVenID = oVentas[0].ClienteID;
var oCliente = Datos.GetEntity<Cliente>(q => q.ClienteID == iClienteVenID && q.Estatus);
oFacturaE.Adicionales.Add("Vencimiento", oVentas[0].Fecha.AddDays(oCliente.DiasDeCredito.Valor()).ToShortDateString());
// Leyenda de la venta
oFacturaE.Adicionales.Add("LeyendaDeVenta", VentasProc.ObtenerQuitarLeyenda(oVentas[0].VentaID));
// Si no hay leyenda, se verifica si hay observación (por tickets convertidos a factura), y si hay, se manda como leyenda
if (string.IsNullOrEmpty(oFacturaE.Adicionales["LeyendaDeVenta"]) && sObservacion != "")
oFacturaE.Adicionales["LeyendaDeVenta"] = sObservacion;
// Leyenda de vehículo, si aplica
if (oVentas[0].ClienteVehiculoID.HasValue)
oFacturaE.Adicionales.Add("LeyendaDeVehiculo", UtilDatos.LeyendaDeVehiculo(oVentas[0].ClienteVehiculoID.Value));
// Se agregan los adicionales, si hubiera
if (oAdicionales != null)
{
if (oAdicionales.ContainsKey("EfectivoRecibido"))
oFacturaE.Adicionales.Add("EfectivoRecibido", Util.Cadena(oAdicionales["EfectivoRecibido"]));
if (oAdicionales.ContainsKey("Cambio"))
oFacturaE.Adicionales.Add("Cambio", Util.Cadena(oAdicionales["Cambio"]));
}
}
// Se procesa la forma de pago con nueva modalidad del sat
string sFormaDePago = VentasLoc.GenerarMetodoDePagoFactura(oFormasDePago);
oFacturaE.MetodoDePago = sFormaDePago;
oFacturaE.CuentaPago = VentasLoc.ObtenerCuentaDePago(oFormasDePago);
// Se agraga la cadena del método de pago, como adicional
oFacturaE.Adicionales.Add("LeyendaDePago", VentasLoc.GenerarCadenaMetodoDePagoFactura(oFormasDePago));
oFacturaE.Fecha = dAhora;
oFacturaE.FormaDePago = "UNA SOLA EXHIBICIÓN";
oFacturaE.LugarDeExpedicion = string.Format("{0}, {1}", oConfig["Facturacion.Municipio"], oConfig["Facturacion.Estado"]);
oFacturaE.TipoDeComprobante = Enumerados.TiposDeComprobante.Ingreso;
oFacturaE.TasaDeImpuesto = GlobalClass.ConfiguracionGlobal.IVA.ToString();
// Se llenan los datos del receptor
var ResRec = VentasLoc.FeLlenarDatosReceptor(ref oFacturaE, iClienteID);
if (ResRec.Error)
return new ResAcc<int>(false, ResRec.Mensaje);
// Se llenan los conceptos de la factura
decimal mUnitarioTotal = 0, mIvaTotal = 0;
oFacturaE.Conceptos = new List<Concepto>();
if (oListaVenta == null)
{
List<VentasDetalleView> oVentaDetalle;
foreach (var oVentaCon in oVentas)
{
oVentaDetalle = Datos.GetListOf<VentasDetalleView>(q => q.VentaID == oVentaCon.VentaID);
foreach (var oConcepto in oVentaDetalle)
{
oFacturaE.Conceptos.Add(new Concepto()
{
Identificador = oConcepto.NumeroParte,
Cantidad = oConcepto.Cantidad,
Unidad = oConcepto.Medida,
Descripcion = oConcepto.NombreParte,
ValorUnitario = oConcepto.PrecioUnitario,
Iva = oConcepto.Iva
});
mUnitarioTotal += oConcepto.PrecioUnitario;
mIvaTotal += oConcepto.Iva;
}
}
}
else
{
foreach (var oConcepto in oListaVenta)
{
oFacturaE.Conceptos.Add(new Concepto()
{
Identificador = oConcepto.NumeroDeParte,
Cantidad = oConcepto.Cantidad,
Unidad = oConcepto.UnidadDeMedida,
Descripcion = oConcepto.NombreDeParte,
ValorUnitario = oConcepto.PrecioUnitario,
Iva = oConcepto.Iva
});
mUnitarioTotal += oConcepto.PrecioUnitario;
mIvaTotal += oConcepto.Iva;
}
}
// Se asigna el folio y la serie de la factura
var oFolioFactura = VentasLoc.GenerarFolioDeFactura();
oFacturaE.Serie = oFolioFactura["Serie"];
oFacturaE.Folio = oFolioFactura["Folio"];
// Se comienza a procesar la facturación electrónica
// Se envía la factura y se obtiene el Xml generado
var ResXml = VentasLoc.FeEnviarFactura(ref oFacturaE);
if (ResXml.Error)
{
// Se trata de regresar el folio de facturación apartado
VentasLoc.RegresarFolioDeFacrtura(oFacturaE.Folio);
return new ResAcc<int>(false, ResXml.Mensaje);
}
string sCfdiTimbrado = ResXml.Respuesta;
// Se guarda la información
var oVentaFactura = new VentaFactura()
{
Fecha = dAhora,
FolioFiscal = oFacturaE.Timbre.FolioFiscal,
Serie = oFacturaE.Serie,
Folio = oFacturaE.Folio,
ClienteID = iClienteID,
Observacion = sObservacion,
Subtotal = mUnitarioTotal,
Iva = mIvaTotal
};
var oVentaFacturaD = new List<VentaFacturaDetalle>();
foreach (var oVentaFac in oVentas)
{
var oFacturaDet = new VentaFacturaDetalle() { VentaID = oVentaFac.VentaID };
// Se revisa si es la primera factura para esta venta
if (!Datos.Exists<VentaFacturaDetalle>(c => c.VentaID == oVentaFac.VentaID && c.Estatus))
oFacturaDet.Primera = true;
oVentaFacturaD.Add(oFacturaDet);
}
Guardar.Factura(oVentaFactura, oVentaFacturaD);
// Se escribe el folio de factura en cada venta
string sSerieFolio = (oFacturaE.Serie + oFacturaE.Folio);
foreach (int iVentaID in VentasIDs)
{
var oVenta = Datos.GetEntity<Venta>(q => q.VentaID == iVentaID && q.Estatus);
oVenta.Facturada = true;
oVenta.Folio = sSerieFolio;
Datos.Guardar<Venta>(oVenta);
}
// Se manda guardar la factura, en pdf y xml. También se manda a salida
var oRep = VentasLoc.FeGuardarArchivosFactura(ref oFacturaE, sCfdiTimbrado, sSerieFolio);
// Se manda la factura por correo
VentasLoc.EnviarFacturaPorCorreo(oVentaFactura.VentaFacturaID);
return new ResAcc<int>(true, oVentaFactura.VentaFacturaID);
}
/*
public static ResAcc<int> GenerarFacturaDevolucion(int iDevolucionID, int iUsuarioID)
{
// Se crea la instancia de la clase de Facturación Electrónica
var oFacturaE = new FacturaElectronica();
var oConfig = Config.ValoresVarios("Facturacion.");
// Se llenan los valores de configuración y los datos del emisor
VentasProc.FeLlenarDatosComunes(ref oFacturaE, oConfig);
// Se llenan los datos generales de la factura
DateTime dAhora = DateTime.Now;
var oDev = General.GetEntity<VentasDevolucionesView>(q => q.VentaDevolucionID == iDevolucionID);
// Se obtiene el nombre del vendedor
var oUsuario = General.GetEntity<Usuario>(q => q.UsuarioID == iUsuarioID && q.Estatus);
string sVendedores = oUsuario.NombrePersona;
oFacturaE.Adicionales = new Dictionary<string, string>();
oFacturaE.Adicionales.Add("Vendedor", sVendedores);
oFacturaE.Fecha = dAhora;
oFacturaE.FormaDePago = "Una sola exhibición";
oFacturaE.LugarDeExpedicion = string.Format("{0}, {1}", oConfig["Facturacion.Municipio"], oConfig["Facturacion.Estado"]);
oFacturaE.TipoDeComprobante = Enumerados.TiposDeComprobante.Egreso;
oFacturaE.TasaDeImpuesto = GlobalClass.ConfiguracionGlobal.IVA.ToString();
oFacturaE.MetodoDePago = oDev.FormaDePago;
// Se llenan los datos del receptor
var oVenta = General.GetEntity<Venta>(q => q.VentaID == oDev.VentaID && q.Estatus);
int iClienteID = oVenta.ClienteID;
var ResRec = VentasProc.FeLlenarDatosReceptor(ref oFacturaE, iClienteID);
if (ResRec.Error)
return new ResAcc<int>(false, ResRec.Mensaje);
// Se llenan los conceptos de la factura
var oDevDetalle = General.GetListOf<VentasDevolucionesDetalleView>(q => q.VentaDevolucionID == oDev.VentaDevolucionID);
oFacturaE.Conceptos = new List<Concepto>();
foreach (var oDet in oDevDetalle)
{
oFacturaE.Conceptos.Add(new Concepto()
{
Identificador = oDet.NumeroParte,
Cantidad = oDet.Cantidad,
Unidad = oDet.NombreMedida,
Descripcion = oDet.NombreParte,
ValorUnitario = oDet.PrecioUnitario,
Iva = oDet.Iva
});
}
// Se comienza a procesar la facturación electrónica
// Se envía la factura y se obtiene el Xml generado
var ResXml = VentasProc.FeEnviarFactura(ref oFacturaE);
bool bFacturada = ResXml.Exito;
// if (ResXml.Error)
// return new ResAcc<int>(false, ResXml.Mensaje);
string sCfdiTimbrado = ResXml.Respuesta;
// Se guarda la información
var oVentaFactura = General.GetEntity<VentasFacturasDetalleView>(q => q.VentaID == oVenta.VentaID);
var oFolioFactura = VentasProc.GenerarFolioDeFacturaDevolucion();
oFacturaE.Serie = oFolioFactura["Serie"];
oFacturaE.Folio = oFolioFactura["Folio"];
var oFacturaDevolucion = new VentaFacturaDevolucion()
{
VentaFacturaID = oVentaFactura.VentaFacturaID,
Fecha = dAhora,
FolioFiscal = (oFacturaE.Timbre == null ? "" : oFacturaE.Timbre.FolioFiscal),
Serie = oFacturaE.Serie,
Folio = oFacturaE.Folio,
EsCancelacion = false,
Procesada = bFacturada,
FechaProcesada = (bFacturada ? ((DateTime?)dAhora) : null)
};
var oFacturaDevDet = new List<VentaFacturaDevolucionDetalle>();
oFacturaDevDet.Add(new VentaFacturaDevolucionDetalle() { VentaDevolucionID = iDevolucionID });
Guardar.FacturaDevolucion(oFacturaDevolucion, oFacturaDevDet);
//
oFacturaE.Adicionales.Add("FacturaOrigen", (oVentaFactura.Serie + oVentaFactura.Folio));
// Se manda guardar la factura, en pdf y xml
if (bFacturada)
VentasProc.FeGuardarArchivosFacturaDevolucion(ref oFacturaE, sCfdiTimbrado, (oFacturaE.Serie + oFacturaE.Folio));
// Se manda la nota de crédito generada, por correo
VentasProc.EnviarFacturaDevolucionPorCorreo(oFacturaDevolucion.VentaFacturaDevolucionID);
// Se manda imprimir la factura
// ..
return new ResAcc<int>(bFacturada, oFacturaDevolucion.VentaFacturaDevolucionID);
}
*/
public static ResAcc<int> GenerarFacturaDevolucion(List<VentasPagosDetalleView> oFormasDePago, int iVentaID, List<ProductoVenta> oDetalle, int iUsuarioID
, bool bEsDevolucion, int iId)
{
// Se crea la instancia de la clase de Facturación Electrónica
var oFacturaE = new FacturaElectronica();
var oConfig = TheosProc.Config.ValoresVarios("Facturacion.");
// Se llenan los valores de configuración y los datos del emisor
VentasLoc.FeLlenarDatosComunes(ref oFacturaE, oConfig);
// Se llenan los datos generales de la factura
DateTime dAhora = DateTime.Now;
// Se obtiene el nombre del vendedor
var oUsuario = Datos.GetEntity<Usuario>(q => q.UsuarioID == iUsuarioID && q.Estatus);
string sVendedores = oUsuario.NombrePersona;
oFacturaE.Adicionales = new Dictionary<string, string>();
oFacturaE.Adicionales.Add("Vendedor", sVendedores);
oFacturaE.Fecha = dAhora;
oFacturaE.FormaDePago = "Una sola exhibición";
oFacturaE.LugarDeExpedicion = string.Format("{0}, {1}", oConfig["Facturacion.Municipio"], oConfig["Facturacion.Estado"]);
oFacturaE.TipoDeComprobante = Enumerados.TiposDeComprobante.Egreso;
oFacturaE.TasaDeImpuesto = GlobalClass.ConfiguracionGlobal.IVA.ToString();
oFacturaE.MetodoDePago = VentasLoc.GenerarMetodoDePagoFactura(oFormasDePago);
// Se agraga la cadena del método de pago, como adicional
oFacturaE.Adicionales.Add("LeyendaDePago", VentasLoc.GenerarCadenaMetodoDePagoFactura(oFormasDePago));
// Se llenan los datos del receptor
// var oVenta = General.GetEntity<Venta>(q => q.VentaID == iVentaID && q.Estatus);
var oVentaFactV = Datos.GetEntity<VentasFacturasDetalleAvanzadoView>(c => c.VentaID == iVentaID);
int iClienteID = oVentaFactV.ClienteID.Valor();
var ResRec = VentasLoc.FeLlenarDatosReceptor(ref oFacturaE, iClienteID);
if (ResRec.Error)
return new ResAcc<int>(false, ResRec.Mensaje);
// Se llenan los conceptos de la factura
decimal mUnitarioTotal = 0, mIvaTotal = 0;
oFacturaE.Conceptos = new List<Concepto>();
foreach (var oDet in oDetalle)
{
oFacturaE.Conceptos.Add(new Concepto()
{
Identificador = oDet.NumeroDeParte,
Cantidad = oDet.Cantidad,
Unidad = oDet.UnidadDeMedida,
Descripcion = oDet.NombreDeParte,
ValorUnitario = oDet.PrecioUnitario,
Iva = oDet.Iva
});
mUnitarioTotal += oDet.PrecioUnitario;
mIvaTotal += oDet.Iva;
}
// Se comienza a procesar la facturación electrónica
// Se envía la factura y se obtiene el Xml generado
var ResXml = VentasLoc.FeEnviarFactura(ref oFacturaE);
bool bFacturada = ResXml.Exito;
/* if (ResXml.Error)
return new ResAcc<int>(false, ResXml.Mensaje);
*/
string sCfdiTimbrado = ResXml.Respuesta;
// Se guarda la información
// var oVentaFactura = General.GetEntity<VentasFacturasDetalleAvanzadoView>(q => q.VentaID == iVentaID);
var oFolioFactura = VentasLoc.GenerarFolioDeFacturaDevolucion();
oFacturaE.Serie = oFolioFactura["Serie"];
oFacturaE.Folio = oFolioFactura["Folio"];
var oFacturaDevolucion = new VentaFacturaDevolucion()
{
VentaFacturaID = oVentaFactV.VentaFacturaID.Valor(),
Fecha = dAhora,
FolioFiscal = (oFacturaE.Timbre == null ? "" : oFacturaE.Timbre.FolioFiscal),
Serie = oFacturaE.Serie,
Folio = oFacturaE.Folio,
EsCancelacion = false,
Procesada = bFacturada,
FechaProcesada = (bFacturada ? ((DateTime?)dAhora) : null),
Subtotal = mUnitarioTotal,
Iva = mIvaTotal
};
var oFacturaDevDet = new List<VentaFacturaDevolucionDetalle>();
var oRegFacDevDet = new VentaFacturaDevolucionDetalle();
if (bEsDevolucion)
oRegFacDevDet.VentaDevolucionID = iId;
else
oRegFacDevDet.VentaGarantiaID = iId;
oFacturaDevDet.Add(oRegFacDevDet);
Guardar.FacturaDevolucion(oFacturaDevolucion, oFacturaDevDet);
// Quizá sea buena opción marcar (de alguna forma) el registro de VentaFacturaDetalle como cancelada, si es que fue una cancelación de la Venta
//
oFacturaE.Adicionales.Add("FacturaOrigen", (oVentaFactV.Serie + oVentaFactV.Folio));
// Se manda guardar la factura, en pdf y xml
if (bFacturada)
VentasLoc.FeGuardarArchivosFacturaDevolucion(ref oFacturaE, sCfdiTimbrado, (oFacturaE.Serie + oFacturaE.Folio));
// Se manda la nota de crédito generada, por correo
VentasLoc.EnviarFacturaDevolucionPorCorreo(oFacturaDevolucion.VentaFacturaDevolucionID);
// Se manda imprimir la factura
// ..
return new ResAcc<int>(bFacturada, oFacturaDevolucion.VentaFacturaDevolucionID);
}
private static ResAcc<bool> FeLlenarDatosReceptor(ref FacturaElectronica oFacturaE, int iClienteID)
{
var oClienteF = Datos.GetEntity<ClientesFacturacionView>(q => q.ClienteID == iClienteID);
if (oClienteF == null)
return new ResAcc<bool>(false, "El cliente seleccionado no tiene datos de facturación registrados. No se puede generar la factura.");
oFacturaE.Receptor = new Receptor()
{
RFC = oClienteF.Rfc,
Nombre = oClienteF.RazonSocial,
DomicilioFiscal = new Ubicacion()
{
Calle = oClienteF.Calle,
NumeroExterior = oClienteF.NumeroExterior,
NumeroInterior = oClienteF.NumeroInterior,
Referencia = oClienteF.Referencia,
Colonia = oClienteF.Colonia,
CodigoPostal = oClienteF.CodigoPostal,
Localidad = oClienteF.Localidad,
Municipio = oClienteF.Municipio,
Estado = oClienteF.Estado,
Pais = oClienteF.Pais
}
};
return new ResAcc<bool>(true);
}
private static void FeLlenarDatosComunes(ref FacturaElectronica oFacturaE, Dictionary<string, string> oConfig)
{
// Se llenan los valores de configuración
VentasLoc.FeLLenarConfiguracion(ref oFacturaE, oConfig);
// Se llenan los datos del Emisor
var oConfigMatriz = TheosProc.Config.ValoresVarios(Cat.Sucursales.Matriz, "Facturacion.");
oFacturaE.Emisor = new Emisor()
{
RFC = oConfig["Facturacion.Rfc"],
Nombre = oConfig["Facturacion.RazonSocial"],
DomicilioFiscal = new Ubicacion()
{
Calle = oConfigMatriz["Facturacion.Calle"],
NumeroExterior = oConfigMatriz["Facturacion.NumeroExterior"],
NumeroInterior = oConfigMatriz["Facturacion.NumeroInterior"],
Referencia = oConfigMatriz["Facturacion.Referencia"],
Colonia = oConfigMatriz["Facturacion.Colonia"],
CodigoPostal = oConfigMatriz["Facturacion.CodigoPostal"],
Localidad = oConfigMatriz["Facturacion.Localidad"],
Municipio = oConfigMatriz["Facturacion.Municipio"],
Estado = oConfigMatriz["Facturacion.Estado"],
Pais = oConfigMatriz["Facturacion.Pais"]
},
ExpedidoEn = new Ubicacion()
{
Calle = oConfig["Facturacion.Calle"],
NumeroExterior = oConfig["Facturacion.NumeroExterior"],
NumeroInterior = oConfig["Facturacion.NumeroInterior"],
Referencia = oConfig["Facturacion.Referencia"],
Colonia = oConfig["Facturacion.Colonia"],
CodigoPostal = oConfig["Facturacion.CodigoPostal"],
Localidad = oConfig["Facturacion.Localidad"],
Municipio = oConfig["Facturacion.Municipio"],
Estado = oConfig["Facturacion.Estado"],
Pais = oConfig["Facturacion.Pais"]
},
RegimenesFiscales = new List<string>(oConfig["Facturacion.RegimenesFiscales"].Split(','))
};
}
private static void FeLLenarConfiguracion(ref FacturaElectronica oFacturaE, Dictionary<string, string> oConfig)
{
oFacturaE.Configuracion = new FacturacionElectronica.Config()
{
RutaCertificado = oConfig["Facturacion.RutaCertificado"],
RutaArchivoKey = oConfig["Facturacion.RutaArchivoKey"],
ContraseniaArchivoKey = oConfig["Facturacion.ContraseniaArchivoKey"],
RutaArchivoPfx = oConfig["Facturacion.RutaArchivoPfx"],
ContraseniaArchivoPfx = oConfig["Facturacion.ContraseniaArchivoPfx"],
UsuarioPac = oConfig["Facturacion.UsuarioPac"],
ContraseniaPac = oConfig["Facturacion.ContraseniaPac"]
};
}
private static Report FeGuardarArchivosFacturaDevolucion(ref FacturaElectronica oFacturaE, string sCfdiTimbrado, string sSerieFolio)
{
// Se obtienen las rutas a utilizar
DateTime dAhora = DateTime.Now;
string sRutaPdf = TheosProc.Config.Valor("Facturacion.Devolucion.RutaPdf");
string sRutaXml = TheosProc.Config.Valor("Facturacion.Devolucion.RutaXml");
string sAnioMes = (@"\" + dAhora.Year.ToString() + @"\" + dAhora.Month.ToString() + @"\");
sRutaPdf += sAnioMes;
Directory.CreateDirectory(sRutaPdf);
sRutaXml += sAnioMes;
Directory.CreateDirectory(sRutaXml);
// Se guarda el xml
string sArchivoXml = (sRutaXml + sSerieFolio + ".xml");
File.WriteAllText(sArchivoXml, sCfdiTimbrado, Encoding.UTF8);
// Se manda la salida de la factura
string sArchivoPdf = (sRutaPdf + sSerieFolio + ".pdf");
var oRep = new Report();
oRep.Load(GlobalClass.ConfiguracionGlobal.pathReportes + "CfdiNotaDeCredito.frx");
var ObjetoCbb = new { Imagen = oFacturaE.GenerarCbb() };
oRep.RegisterData(new List<FacturaElectronica>() { oFacturaE }, "Factura");
oRep.RegisterData(new List<object>() { ObjetoCbb }, "Cbb");
oRep.SetParameterValue("Vendedor", oFacturaE.Adicionales["Vendedor"].ToUpper());
oRep.SetParameterValue("TotalConLetra", Util.ImporteALetra(oFacturaE.Total).ToUpper());
oRep.SetParameterValue("FacturaOrigen", oFacturaE.Adicionales["FacturaOrigen"]);
UtilLocal.EnviarReporteASalida("Reportes.VentaFacturaDevolucion.Salida", oRep);
// Se guarda el pdf
var oRepPdf = new FastReport.Export.Pdf.PDFExport() { ShowProgress = true };
oRep.Prepare();
oRep.Export(oRepPdf, sArchivoPdf);
return oRep;
}
private static ResAcc<string> FeEnviarFactura(ref FacturaElectronica oFacturaE)
{
// Se genera el Xml inicial, con el formato que pide el Sat
var ResXml = oFacturaE.GenerarFactura(true);
if (ResXml.Error)
return new ResAcc<string>(false, ResXml.Mensaje);
string sCfdi = ResXml.Respuesta;
// Se manda a timbrar el Xml con el proveedor Pac
ResXml = oFacturaE.TimbrarFactura(sCfdi, !GlobalClass.Produccion);
if (ResXml.Error)
return new ResAcc<string>(false, ResXml.Mensaje);
string sCfdiTimbrado = ResXml.Respuesta;
var Res = new ResAcc<string>(true);
Res.Respuesta = sCfdiTimbrado;
return Res;
}
public static ResAcc<bool> ValidarDatosParaFactura(List<int> VentasIDs, int iClienteID)
{
// Se crea la instancia de la clase de Facturación Electrónica
var oFacturaE = new FacturaElectronica();
var oConfig = TheosProc.Config.ValoresVarios("Facturacion.");
// Se llenan los valores de configuración y los datos del emisor
VentasLoc.FeLlenarDatosComunes(ref oFacturaE, oConfig);
// Se llenan los datos generales de la factura
DateTime dAhora = DateTime.Now;
// Se obtienen las ventas a facturar
var oVentas = new List<VentasView>();
foreach (int iVentaID in VentasIDs)
oVentas.Add(Datos.GetEntity<VentasView>(q => q.VentaID == iVentaID));
// Se llenan un dato "x" para simular el método de pago, pues no se tiene esa información todavía porque no se ha guardado la venta
oFacturaE.MetodoDePago = "Efectivo";
oFacturaE.Fecha = dAhora;
oFacturaE.FormaDePago = "Una sola exhibición";
oFacturaE.LugarDeExpedicion = string.Format("{0}, {1}", oConfig["Facturacion.Municipio"], oConfig["Facturacion.Estado"]);
oFacturaE.TipoDeComprobante = Enumerados.TiposDeComprobante.Ingreso;
oFacturaE.TasaDeImpuesto = GlobalClass.ConfiguracionGlobal.IVA.ToString();
// Se llenan los datos del receptor
var ResRec = VentasLoc.FeLlenarDatosReceptor(ref oFacturaE, iClienteID);
if (ResRec.Error)
return new ResAcc<bool>(false, ResRec.Mensaje);
// Se llenan los conceptos de la factura
oFacturaE.Conceptos = new List<Concepto>();
List<VentasDetalleView> oVentaDetalle;
foreach (var oVenta in oVentas)
{
oVentaDetalle = Datos.GetListOf<VentasDetalleView>(q => q.VentaID == oVenta.VentaID);
foreach (var oConcepto in oVentaDetalle)
{
oFacturaE.Conceptos.Add(new Concepto()
{
Identificador = oConcepto.ParteID.ToString(),
Cantidad = oConcepto.Cantidad,
Unidad = oConcepto.Medida,
Descripcion = oConcepto.NombreParte,
ValorUnitario = oConcepto.PrecioUnitario,
Iva = oConcepto.Iva
});
}
}
// Se genera el Xml inicial, con el formato que pide el Sat
var ResXml = oFacturaE.GenerarFactura(true);
if (ResXml.Error)
return new ResAcc<bool>(false, ResXml.Mensaje);
return new ResAcc<bool>(true, true);
}
public static ResAcc<bool> GenerarFacturaCancelacion(string sFolioFiscal, int iVentaFacturaDevolucionID)
{
// Se manda hacer la cancelación
var oFacturaE = new FacturaElectronica();
var oConfig = TheosProc.Config.ValoresVarios("Facturacion.");
VentasLoc.FeLLenarConfiguracion(ref oFacturaE, oConfig);
VentasLoc.FeLlenarDatosComunes(ref oFacturaE, oConfig);
var ResC = oFacturaE.CancelarFactura(sFolioFiscal, !GlobalClass.Produccion);
bool bFacturada = ResC.Exito;
// Se guardan datos del resultado de la cancelación ante Sat, si se canceló
if (bFacturada)
{
// Se obtiene el objeto de la cancelacion
var oFacturaDevolucion = Datos.GetEntity<VentaFacturaDevolucion>(q => q.VentaFacturaDevolucionID == iVentaFacturaDevolucionID);
oFacturaDevolucion.Ack = ResC.Respuesta.Izquierda(36);
oFacturaDevolucion.Procesada = true;
oFacturaDevolucion.FechaProcesada = DateTime.Now;
Datos.Guardar<VentaFacturaDevolucion>(oFacturaDevolucion);
// Se le cambia el estatus a la factura
var oFactura = Datos.GetEntity<VentaFactura>(q => q.VentaFacturaID == oFacturaDevolucion.VentaFacturaID && q.Estatus);
oFactura.EstatusGenericoID = Cat.EstatusGenericos.Cancelada;
Datos.Guardar<VentaFactura>(oFactura);
// Se manda la notificación por correo, si fue exitosa
VentasLoc.EnviarFacturaCancelacionPorCorreo(oFacturaDevolucion.VentaFacturaID);
}
return new ResAcc<bool>(bFacturada, ResC.Mensaje);
}
public static ResAcc <FacturaElectronica> GenerarXml(FacturaElectronica oFactura)
{
// Se genera el xml con los datos de la factura
var ResProcs = FacturaXml.GenerarXmlDeObjeto(oFactura);
string sFacturaXml = ResProcs.Respuesta;
// Se transforma al Xml requerido por el Sat v3.2
ResProcs = FacturaXml.TransformarXml(sFacturaXml, Properties.Resources.Cfdi3_2);
if (ResProcs.Error)
{
return(new ResAcc <FacturaElectronica>(false, ResProcs.Mensaje));
}
string sCfdiXml = ResProcs.Respuesta;
// Se valida el Xml generado
ResProcs = FacturaXml.ValidarXml(sCfdiXml, Properties.Resources.cfdv32);
if (ResProcs.Error)
{
return(new ResAcc <FacturaElectronica>(false, ResProcs.Mensaje));
}
// Se genera la cadena original
ResProcs = FacturaXml.TransformarXml(sCfdiXml, Properties.Resources.cadenaoriginal_3_2);
if (ResProcs.Error)
{
return(new ResAcc <FacturaElectronica>(false, ResProcs.Mensaje));
}
string sCadenaOriginal = System.Web.HttpUtility.HtmlDecode(ResProcs.Respuesta);
// Se genera la cadena del sello digital
var Seguridad = new FacturaSeguridad();
ResProcs = Seguridad.GenerarSelloDigital(oFactura.Configuracion.RutaArchivoKey, oFactura.Configuracion.ContraseniaArchivoKey, sCadenaOriginal);
if (ResProcs.Error)
{
return(new ResAcc <FacturaElectronica>(false, ResProcs.Mensaje));
}
string sSelloDigital = ResProcs.Respuesta;
// Se agregan los nuevos datos al xml a generar
var oCertificado = Seguridad.DatosCertificado(oFactura.Configuracion.RutaCertificado);
XmlDocument oXml = new XmlDocument();
oXml.LoadXml(sCfdiXml);
oXml.DocumentElement.Attributes["noCertificado"].Value = oCertificado["NumeroDeSerie"];
oXml.DocumentElement.Attributes["certificado"].Value = oCertificado["ContenidoBase64"];
oXml.DocumentElement.Attributes["sello"].Value = sSelloDigital;
// Se guarda el xml con los cambios
var oTexto = new StringWriterMod(Encoding.UTF8);
var oEscXml = XmlWriter.Create(oTexto, FacturaXml.ConfigXml);
oXml.Save(oEscXml);
ResProcs.Exito = true;
ResProcs.Respuesta = oTexto.ToString();
oFactura.NumeroDeCertificado = oCertificado["NumeroDeSerie"];
oFactura.Certificado = oCertificado["ContenidoBase64"];
oFactura.Sello = sSelloDigital;
oFactura.XmlFactura = ResProcs.Respuesta;
return(new ResAcc <FacturaElectronica>(true, oFactura));
}