コード例 #1
0
        public CorridaSubidaArchivoDto CrearNuevaCorrida()
        {
            using (var ctx = new FacturaElectronicaEntities())
            {
                CorridaSubidaArchivo corrida = new CorridaSubidaArchivo();
                corrida.FechaProceso = DateTime.Now;
                corrida.Procesada    = null;
                ctx.CorridaSubidaArchivoes.AddObject(corrida);
                ctx.SaveChanges();
                CorridaSubidaArchivoDto corridaDto = new CorridaSubidaArchivoDto();

                EntityMapper.Map(corrida, corridaDto);

                return(corridaDto);
            }
        }
コード例 #2
0
        private void ArmarArchivoAsociadoConContexto(FacturaElectronicaEntities ctx, CorridaSubidaArchivo dbCorrida, string filePath, string fileDestinationPathOk, string fileDestinationPathNoOk, EjecutarCorridaSubidaArchivo corrida)
        {
            string fileName = Path.GetFileName(filePath);

            StringBuilder mensajeError = new StringBuilder();
            string        errorStr     = string.Empty;

            bool procesarArchivo = true;
            long cuit            = 0;

            if (!Int64.TryParse(corrida.Cuit, out cuit))
            {
                errorStr = "No se pudo interpretar el CUIT " + corrida.Cuit;
                mensajeError.AppendLine(errorStr);
                GenerarLog(dbCorrida.Id, errorStr);
                procesarArchivo = false;
            }

            string          tipoComprobante    = corrida.TipoDeComprobanteCodigo;
            TipoComprobante tipoComprobanteObj = null;

            if (!String.IsNullOrEmpty(tipoComprobante))
            {
                tipoComprobanteObj = GetTipoComprobante(ctx).Where(t => t.Codigo == tipoComprobante).SingleOrDefault();
                if (tipoComprobanteObj == null)
                {
                    errorStr = "No se pudo interpretar el Tipo de Comprobante " + tipoComprobante;
                    mensajeError.AppendLine(errorStr);
                    GenerarLog(dbCorrida.Id, errorStr);
                    procesarArchivo = false;
                }
            }
            else
            {
                errorStr = "No se pudo interpretar el Tipo de Comprobante " + tipoComprobante;
                mensajeError.AppendLine(errorStr);
                GenerarLog(dbCorrida.Id, errorStr);
                procesarArchivo = false;
            }

            long nroComprobante = corrida.NroComprobante;

            long?ptovta = corrida.PuntoDeVenta;

            string periodoFactuStr        = corrida.PeriodoDeFacturacion;
            string periodoFactuAnioStr    = periodoFactuStr.Substring(0, 4);
            string periodoFactuMesStr     = periodoFactuStr.Substring(4, 2);
            int    periodoFacturacionAnio = 0;
            int    periodoFacturacionMes  = 0;

            if (!Int32.TryParse(periodoFactuAnioStr, out periodoFacturacionAnio) || !Int32.TryParse(periodoFactuMesStr, out periodoFacturacionMes))
            {
                errorStr = "No se pudo interpretar el Periodo de Facturacion " + periodoFactuStr;
                mensajeError.AppendLine(errorStr);
                GenerarLog(dbCorrida.Id, errorStr);
                procesarArchivo = false;
            }

            bool     tieneFechaVencimiento;
            DateTime fechaDeVencimiento = DateTime.MinValue;
            int      diasDeVencimiento  = 0;

            if (!corrida.FechaDeVencimiento.HasValue)
            {
                tieneFechaVencimiento = false;
                if (!corrida.DiasDeVencimiento.HasValue)
                {
                    errorStr = "No se pudo interpretar la fecha de vencimiento ";
                    mensajeError.AppendLine(errorStr);
                    GenerarLog(dbCorrida.Id, errorStr);
                    procesarArchivo = false;
                }
                else
                {
                    diasDeVencimiento = corrida.DiasDeVencimiento.Value;
                }
            }
            else
            {
                tieneFechaVencimiento = true;
                fechaDeVencimiento    = corrida.FechaDeVencimiento.Value.Date;
            }

            string  montoTotalStr = corrida.MontoTotal;
            decimal montoTotal;

            montoTotalStr = montoTotalStr.Replace(".", CultureInfo.CurrentCulture.NumberFormat.CurrencyDecimalSeparator);
            if (!Decimal.TryParse(montoTotalStr, out montoTotal))
            {
                errorStr = "No se pudo interpretar el MontoTotal " + montoTotalStr;
                mensajeError.AppendLine(errorStr);
                GenerarLog(dbCorrida.Id, errorStr);
                procesarArchivo = false;
            }

            string       tipoContratoStr = corrida.TipoContratoCodigo;
            TipoContrato tipoContrato    = null;

            if (!String.IsNullOrEmpty(tipoContratoStr))
            {
                tipoContrato = GetTipoContrato(ctx).Where(t => t.Codigo == tipoContratoStr).SingleOrDefault();

                if (tipoContrato == null)
                {
                    errorStr = "No se pudo interpretar el Tipo de Contrato " + tipoContratoStr;
                    mensajeError.AppendLine(errorStr);
                    GenerarLog(dbCorrida.Id, errorStr);
                    procesarArchivo = false;
                }
            }
            else
            {
                errorStr = "No se pudo interpretar el Tipo de Contrato " + tipoContratoStr;
                mensajeError.AppendLine(errorStr);
                GenerarLog(dbCorrida.Id, errorStr);
                procesarArchivo = false;
            }

            CorridaSubidaArchivoDetalle detalle = new CorridaSubidaArchivoDetalle();

            if (procesarArchivo)
            {
                // obtengo el cliente
                var dbCliente = ctx.Clientes.Where(c => c.CUIT == cuit).SingleOrDefault();
                if (dbCliente == null)
                {
                    errorStr = "No se encuentra el cliente " + cuit.ToString();
                    mensajeError.AppendLine(errorStr);
                    GenerarLog(dbCorrida.Id, errorStr);
                    detalle.ProcesadoOK = false;
                }
                else
                {
                    // Obtengo el comprobante al que hay que asociarle el archivo
                    var  dbComprobante = ctx.Comprobantes.Where(c => c.TipoComprobanteId == tipoComprobanteObj.Id && c.PtoVta == ptovta && c.CbteDesde <= nroComprobante && c.CbteHasta >= nroComprobante).FirstOrDefault();
                    bool comprobanteOK = false;
                    if (dbComprobante == null)
                    {
                        if (corrida.ForzarDatosCliente)
                        {
                            // Creo el comprobante
                            dbComprobante = new Comprobante();
                            ctx.Comprobantes.AddObject(dbComprobante);
                            dbComprobante.TipoComprobanteId = tipoComprobanteObj.Id;
                            dbComprobante.FechaDeCarga      = DateTime.Now;
                            dbComprobante.ClienteId         = dbCliente.Id;
                            dbComprobante.CAE = corrida.CAE;
                            dbComprobante.CAEFechaVencimiento = corrida.FechaVencimientoCAE.Value;
                            dbComprobante.CbteFecha           = corrida.FechaComprobante;
                            dbComprobante.CbteDesde           = corrida.NroComprobante;
                            dbComprobante.CbteHasta           = corrida.NroComprobante;
                            dbComprobante.PtoVta = corrida.PuntoDeVenta;
                            ctx.SaveChanges();
                            comprobanteOK = true;
                        }
                        else
                        {
                            // No se puede procesar
                            errorStr = string.Format("No se encuentra el comprobante asociado. Nro {0}, Tipo {1}, PtoVta: {2}", nroComprobante, tipoComprobanteObj.Descripcion, ptovta);
                            mensajeError.AppendLine(errorStr);
                            GenerarLog(dbCorrida.Id, errorStr);

                            // Lo copio a la carpeta de fallidos y registro el estado en el documento
                            //File.Move(filePath, fileDestinationPathNoOk);
                            detalle.ProcesadoOK = false;
                        }
                    }
                    else
                    {
                        comprobanteOK = true;
                    }

                    if (comprobanteOK)
                    {
                        bool clienteOk = true;
                        if (!dbComprobante.ClienteId.HasValue)
                        {
                            dbComprobante.ClienteId = dbCliente.Id;
                        }
                        else if (dbComprobante.ClienteId.Value != dbCliente.Id)
                        {
                            errorStr = string.Format("El cliente del comprobante CUIT {0} es distinto que el indicado en la factura CUIT {1}", dbComprobante.Cliente.CUIT, dbCliente.CUIT);
                            mensajeError.AppendLine(errorStr);
                            GenerarLog(dbCorrida.Id, errorStr);

                            // Lo copio a la carpeta de fallidos y registro el estado en el documento
                            //File.Move(filePath, fileDestinationPathNoOk);
                            detalle.ProcesadoOK = false;
                            clienteOk           = false;
                        }

                        if (clienteOk)
                        {
                            // Lo copio a la carpeta de ok y lo guardo en la base
                            string destPath = Path.Combine(fileDestinationPathOk, fileName);
                            detalle.ProcesadoOK = true;
                            File.Move(filePath, destPath);

                            // Puede ser que el archivo asociado ya exista y lo tengo que actualizar
                            ArchivoAsociado archivoAsociado;
                            archivoAsociado = ctx.ArchivoAsociadoes.Where(a => a.ComprobanteId == dbComprobante.Id && a.NombreArchivo == fileName).SingleOrDefault();
                            if (archivoAsociado != null &&
                                archivoAsociado.EstadoArchivoAsociado.Codigo == CodigosEstadoArchivoAsociado.Visualizado)
                            {
                                // No se puede procesar porque ya fue visualizado
                                errorStr = string.Format("No se puede reemplazar el archivo asociado del comprobante porque ya fue visualizado. (Nro {0}, Tipo {1}, PtoVta: {2})", nroComprobante, tipoComprobanteObj.Descripcion, ptovta);
                                mensajeError.AppendLine(errorStr);
                                GenerarLog(dbCorrida.Id, errorStr);
                            }
                            else
                            {
                                if (archivoAsociado == null)
                                {
                                    archivoAsociado = new ArchivoAsociado();
                                    dbComprobante.ArchivoAsociadoes.Add(archivoAsociado);
                                }

                                detalle.ArchivoAsociado        = archivoAsociado;
                                archivoAsociado.NombreArchivo  = fileName;
                                archivoAsociado.PathArchivo    = destPath;
                                archivoAsociado.NroComprobante = nroComprobante;
                                archivoAsociado.TipoContratoId = tipoContrato.Id;
                                if (tieneFechaVencimiento)
                                {
                                    archivoAsociado.FechaVencimiento = fechaDeVencimiento;
                                }
                                else
                                {
                                    archivoAsociado.DiasVencimiento = diasDeVencimiento;
                                }

                                archivoAsociado.FechaDeCarga    = DateTime.Now;
                                archivoAsociado.MesFacturacion  = periodoFacturacionMes;
                                archivoAsociado.AnioFacturacion = periodoFacturacionAnio;
                                archivoAsociado.EstadoId        = GetEstadoArchivoAsociado(ctx).Where(c => c.Codigo == CodigosEstadoArchivoAsociado.NoVisualizado).Select(e => e.Id).Single();
                                archivoAsociado.MontoTotal      = montoTotal;
                            }
                        }
                    }
                }
            }

            if (!detalle.ProcesadoOK)
            {
                // Lo copio a la carpeta de fallidos y registro el estado en el documento
                string destPath = Path.Combine(fileDestinationPathNoOk, fileName);
                File.Move(filePath, destPath);
            }

            detalle.NombreArchivo = fileName;
            detalle.Mensaje       = mensajeError.ToString();
            dbCorrida.CorridaSubidaArchivoDetalles.Add(detalle);
        }
コード例 #3
0
        public void EjecutarCorrida(EjecutarCorridaSubidaArchivo corrida)
        {
            long corridaId = corrida.CorridaId;

            List <string> files = corrida.FileNames;

            // Proceso los archivos en la corrida y marcos cuales están ok y cuales no
            using (var ctx = new FacturaElectronicaEntities())
            {
                CorridaSubidaArchivo dbCorrida = ctx.CorridaSubidaArchivoes.Where(c => c.Id == corridaId).SingleOrDefault();
                if (dbCorrida != null)
                {
                    try
                    {
                        // Armo los path destinos Ok y con errores
                        string fileDestinationPathOk = ConfigurationManager.AppSettings["PathDestinoArchivosFactura"];

                        fileDestinationPathOk = Path.Combine(fileDestinationPathOk, "ArchivosPDF");

                        fileDestinationPathOk = Path.Combine(fileDestinationPathOk, corridaId.ToString());
                        string sourceFilePath          = Path.Combine(fileDestinationPathOk, "AProcesar");
                        string fileDestinationPathNoOk = Path.Combine(fileDestinationPathOk, "ConErrores");;
                        fileDestinationPathOk = Path.Combine(fileDestinationPathOk, "OK");
                        if (!Directory.Exists(fileDestinationPathOk))
                        {
                            Directory.CreateDirectory(fileDestinationPathOk);
                        }

                        if (!Directory.Exists(fileDestinationPathNoOk))
                        {
                            Directory.CreateDirectory(fileDestinationPathNoOk);
                        }

                        // Una vez que tengo los paths, cargo los archivos
                        foreach (string filePathIterator in files)
                        {
                            try
                            {
                                string filePath = Path.Combine(sourceFilePath, filePathIterator);

                                string fileName = Path.GetFileName(filePath);
                                GenerarLog(dbCorrida.Id, string.Format("Procesando Archivo: {0}", fileName));

                                if (File.Exists(filePath))
                                {
                                    if (!corrida.ForzarDatosCliente)
                                    {
                                        ArmarArchivoAsociado(ctx, dbCorrida, filePath, fileDestinationPathOk, fileDestinationPathNoOk, corrida);
                                    }
                                    else
                                    {
                                        ArmarArchivoAsociadoConContexto(ctx, dbCorrida, filePath, fileDestinationPathOk, fileDestinationPathNoOk, corrida);
                                    }
                                }
                                else
                                {
                                    GenerarLog(dbCorrida.Id, string.Format("No Existe el Archivo: {0}", fileName));
                                }

                                GenerarLog(dbCorrida.Id, string.Format("Fin Procesamiento Archivo: {0}", fileName));
                            }
                            catch (Exception ex)
                            {
                                GenerarLog(dbCorrida.Id, ex.Message);
                            }
                        }

                        GenerarLog(dbCorrida.Id, FinCorridaStr);

                        dbCorrida.Procesada = true;
                        ctx.SaveChanges();
                    }
                    catch (Exception ex)
                    {
                        GenerarLog(dbCorrida.Id, ex.Message);
                    }
                }
            }

            // Al final, envío emails a los clientes informando que ya están listos X cantidad de facturas para
            // ser visualizadas
            SendMailToCustomers(corridaId);
        }