public MensajeDto CrearMensaje(MensajeDto mensajeDto)
{
using (TransactionScope ts = new TransactionScope())
{
using (var ctx = new FacturaElectronicaEntities())
{
Mensaje mensaje = new Mensaje();
ToMensaje(mensajeDto, mensaje);
MensajeCliente mensajeCliente = null;
foreach (var clienteDto in mensajeDto.Clientes)
{
Cliente cliente = this.ObtenerCliente(ctx, clienteDto.Id);
mensajeCliente = new MensajeCliente()
{
Mensaje = mensaje,
Cliente = cliente,
Leido = false
};
mensaje.MensajeClientes.Add(mensajeCliente);
}
mensaje.FechaDeCarga = DateTime.Now;
ctx.Mensajes.AddObject(mensaje);
ctx.SaveChanges();
ts.Complete();
mensajeDto.Id = mensaje.Id;
}
return(mensajeDto);
}
}
public UsuarioDto CrearUsuario(UsuarioDto usuarioDto)
{
using (TransactionScope ts = new TransactionScope())
{
using (var ctx = new FacturaElectronicaEntities())
{
if (this.ObtenerUsuario(ctx, usuarioDto.NombreUsuario) != null)
{
throw new Exception("El usuario ya existe");
}
Usuario usuario = new Usuario();
ToUsuario(usuarioDto, usuario);
if (usuarioDto.Roles != null &&
usuarioDto.Roles.Count() > 0)
{
foreach (RolDto rolDto in usuarioDto.Roles)
{
Rol rol = this.ObtenerRol(ctx, rolDto.Id);
if (rol != null)
{
usuario.Roles.Add(rol);
}
}
}
ctx.Usuarios.AddObject(usuario);
ctx.SaveChanges();
ts.Complete();
usuarioDto.Id = usuario.Id;
}
return(usuarioDto);
}
}
public UsuarioDto EditarUsuario(UsuarioDto usuarioDto)
{
using (TransactionScope ts = new TransactionScope())
{
using (var ctx = new FacturaElectronicaEntities())
{
Usuario usuario = this.ObtenerUsuario(ctx, usuarioDto.Id);
string pass = usuario.Password;
ToUsuario(usuarioDto, usuario);
usuario.Password = pass;
if (usuarioDto.Roles != null &&
usuarioDto.Roles.Count() > 0)
{
usuario.Roles.Clear();
foreach (RolDto rolDto in usuarioDto.Roles)
{
Rol rol = this.ObtenerRol(ctx, rolDto.Id);
if (rol != null)
{
usuario.Roles.Add(rol);
}
}
}
ctx.SaveChanges();
ts.Complete();
}
return(usuarioDto);
}
}
public void AgregarVisualizacion(VisualizacionComprobanteDto dto)
{
using (var ctx = new FacturaElectronicaEntities())
{
ArchivoAsociado aa = ctx.ArchivoAsociadoes.Where(c => c.Id == dto.ArchivoAsociadoId).FirstOrDefault();
if (aa != null)
{
VisualizacionComprobante vc = new VisualizacionComprobante()
{
ArchivoAsociadoId = aa.Id,
Fecha = DateTime.Now,
DireccionIP = dto.Ip
};
if (aa.EstadoArchivoAsociado.Codigo == CodigosEstadoArchivoAsociado.NoVisualizado)
{
aa.EstadoArchivoAsociado = ctx.EstadoArchivoAsociadoes.Where(e => e.Codigo == CodigosEstadoArchivoAsociado.Visualizado).First();
if (aa.Comprobante.Cliente.CalculaVencimientoConVisualizacionDoc && !aa.FechaDeRecepcion.HasValue)
{
DateTime fechaDeRecepcion = DateTime.Now;
AsociarFechaDeRecepcion(ctx, dto.ArchivoAsociadoId, fechaDeRecepcion, dto.UsuarioIdAuditoria);
}
}
aa.VisualizacionComprobantes.Add(vc);
//if (!aa.FechaVencimiento.HasValue && aa.DiasVencimiento.HasValue)
//{
// aa.FechaVencimiento = DateTime.Now.AddDays(aa.DiasVencimiento.Value);
//}
ctx.SaveChanges();
}
}
}
public void MarcarComoLeido(long mensajeId, long clienteId)
{
using (var ctx = new FacturaElectronicaEntities())
{
MensajeCliente mensajeCliente = ctx.MensajeClientes.Where(mc => mc.MensajeId == mensajeId && mc.ClienteId == clienteId).Single();
mensajeCliente.Leido = true;
ctx.SaveChanges();
}
}
private static void GenerarLog(FacturaElectronicaEntities ctx, long corridaId, string mensaje)
{
CorridaSubidaArchivoLog log = new CorridaSubidaArchivoLog();
log.Mensaje = mensaje;
log.Fecha = DateTime.Now;
log.CorridaId = corridaId;
ctx.CorridaSubidaArchivoLogs.AddObject(log);
ctx.SaveChanges();
}
public void CrearComprobante(ComprobanteDto dto)
{
using (var ctx = new FacturaElectronicaEntities())
{
Comprobante cbte = new Comprobante();
ToComprobante(dto, cbte);
ctx.Comprobantes.AddObject(cbte);
ctx.SaveChanges();
}
}
public void Log(long corridaId, string mensaje, string detalle)
{
using (var ctx = new FacturaElectronicaEntities())
{
LogCorrida log = new LogCorrida();
log.CorridaId = corridaId;
log.Fecha = DateTime.Now;
log.Mensaje = mensaje;
log.Detalle = detalle;
ctx.LogCorridas.AddObject(log);
ctx.SaveChanges();
}
}
public CorridaAutorizacionDto CrearNuevaCorrida(string xmlPath)
{
using (var ctx = new FacturaElectronicaEntities())
{
CorridaAutorizacion corrida = new CorridaAutorizacion();
corrida.Fecha = DateTime.Now;
corrida.PathArchivo = xmlPath;
corrida.Procesada = null;
ctx.CorridaAutorizacions.AddObject(corrida);
ctx.SaveChanges();
return(ToCorridaDto(corrida, null, null, null));
}
}
public bool EliminarUsuario(long usuarioId)
{
int result = 0;
using (var ctx = new FacturaElectronicaEntities())
{
Usuario usuario = this.ObtenerUsuario(ctx, usuarioId);
usuario.Roles.Clear();
ctx.Usuarios.DeleteObject(usuario);
result = ctx.SaveChanges();
}
return(result > 0);
}
public bool CambiarPassword(long usuarioId, string passwordNueva)
{
using (var ctx = new FacturaElectronicaEntities())
{
Usuario usuario = this.ObtenerUsuario(ctx, usuarioId);
bool cambioPass = false;
if (usuario != null)
{
usuario.Password = SecurityHelper.CreatePasswordHash(passwordNueva, SecurityHelper.CreateSalt(30));
cambioPass = ctx.SaveChanges() > 0;
}
return(cambioPass);
}
}
public bool EliminarCliente(long clienteId)
{
int result = 0;
using (var ctx = new FacturaElectronicaEntities())
{
Cliente cliente = this.ObtenerCliente(ctx, clienteId);
if (cliente.Usuarios.Count > 0)
{
cliente.Usuarios.Clear();
}
ctx.Clientes.DeleteObject(cliente);
result = ctx.SaveChanges();
}
return(result > 0);
}
public void CambiarEstado(long archivoAsociadoId, string codigoEstado)
{
using (var ctx = new FacturaElectronicaEntities())
{
EstadoArchivoAsociado nuevoEstado = ctx.EstadoArchivoAsociadoes.Where(e => e.Codigo == codigoEstado).FirstOrDefault();
if (nuevoEstado != null)
{
ArchivoAsociado aa = ctx.ArchivoAsociadoes.Where(c => c.Id == archivoAsociadoId).FirstOrDefault();
if (aa != null)
{
aa.EstadoArchivoAsociado = nuevoEstado;
ctx.SaveChanges();
}
}
}
}
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);
}
}
public void AsociarFechaDeRecepcion(Dictionary <long, DateTime?> archivosAsociados, long userId)
{
using (TransactionScope ts = new TransactionScope())
{
using (var ctx = new FacturaElectronicaEntities())
{
foreach (var key in archivosAsociados.Keys)
{
AsociarFechaDeRecepcion(ctx, key, archivosAsociados[key], userId);
}
ctx.SaveChanges();
ts.Complete();
}
}
}
private static bool CambiaPassword(FacturaElectronicaEntities ctx, Usuario usuario, string passwordActual, string passwordNueva)
{
bool cambioPass = false;
if (usuario != null)
{
if (usuario.Password != HashPassword(usuario, passwordActual))
{
throw new Exception("La Contraseña Anterior ingresada es incorrecta.");
}
usuario.Password = SecurityHelper.CreatePasswordHash(passwordNueva, SecurityHelper.CreateSalt(30));
cambioPass = ctx.SaveChanges() > 0;
}
return(cambioPass);
}
/// <summary>
/// Indica si la corrida puede ejectuarse si es asi la marca en proceso
/// </summary>
/// <param name="corridaId"></param>
/// <returns></returns>
public bool MarcarCorridaEnProceso(long corridaId)
{
bool puedeEjecturar = false;
using (var ctx = new FacturaElectronicaEntities())
{
var corridaAutorizacion = ctx.CorridaAutorizacions.Where(c => c.Id == corridaId).SingleOrDefault();
if (corridaAutorizacion != null)
{
if (!corridaAutorizacion.Procesada.HasValue)
{
corridaAutorizacion.Procesada = false; // Significa que está en proceso
ctx.SaveChanges();
puedeEjecturar = true;
}
}
}
return(puedeEjecturar);
}
private void SendEmailToCustomer(object param)
{
EmailInThread emailInThread = (EmailInThread)param;
using (FacturaElectronicaEntities ctx = new FacturaElectronicaEntities(emailInThread.ConnectionString))
{
try
{
SendMail(emailInThread);
GenerarLog(ctx, emailInThread.CorridaId, string.Format("Email enviado a {0}", emailInThread.Email));
}
catch (Exception ex)
{
string exceptionMessage = GetExceptionMessage(ex);
string exceptionStack = GetExceptionStackTrace(ex);
GenerarLog(ctx, emailInThread.CorridaId, string.Format("Email enviado a {0} con error {1}", emailInThread.Email, exceptionMessage + exceptionStack));
}
ctx.SaveChanges();
}
}
public ClienteDto CrearCliente(ClienteDto clienteDto)
{
using (TransactionScope ts = new TransactionScope())
{
using (var ctx = new FacturaElectronicaEntities())
{
Cliente cliente = new Cliente();
if (cliente.CalculaVencimientoConVisualizacionDoc != clienteDto.CalculaVencimientoConVisualizacionDoc)
{
CrearAuditoria(clienteDto, cliente);
}
ToCliente(clienteDto, cliente);
ctx.Clientes.AddObject(cliente);
ctx.SaveChanges();
ts.Complete();
clienteDto.Id = cliente.Id;
}
return(clienteDto);
}
}
public bool EliminarMensaje(long mensajeId)
{
int result = 0;
using (var ctx = new FacturaElectronicaEntities())
{
Mensaje mensaje = this.ObtenerMensaje(ctx, mensajeId);
bool leido = false;
foreach (MensajeCliente mensajeCliente in mensaje.MensajeClientes)
{
if (mensajeCliente.Leido)
{
leido = true;
break;
}
}
if (!leido)
{
string path = mensaje.Path;
using (TransactionScope ts = new TransactionScope())
{
List <long> mensajeClienteIds = (from m in mensaje.MensajeClientes
select m.Id).ToList();
foreach (var id in mensajeClienteIds)
{
ctx.MensajeClientes.DeleteObject(mensaje.MensajeClientes.Where(mc => mc.Id == id).Single());
}
ctx.Mensajes.DeleteObject(mensaje);
result = ctx.SaveChanges();
ts.Complete();
}
if (result > 0 && !string.IsNullOrEmpty(path))
{
File.Delete(path);
}
}
}
return(result > 0);
}
public ClienteDto EditarCliente(ClienteDto clienteDto)
{
using (TransactionScope ts = new TransactionScope())
{
using (var ctx = new FacturaElectronicaEntities())
{
Cliente cliente = this.ObtenerCliente(ctx, clienteDto.Id);
// Se podrían analizar todos los campos
if (cliente.CalculaVencimientoConVisualizacionDoc != clienteDto.CalculaVencimientoConVisualizacionDoc)
{
CrearAuditoria(clienteDto, cliente);
}
ToCliente(clienteDto, cliente);
ctx.SaveChanges();
ts.Complete();
}
return(clienteDto);
}
}
public CorridaAutorizacionDto ProcesarCorridaWsFeX(CorridaAutorizacionDto corridaDto, FEXResponseAuthorize feXCAEResponse, ClsFEXRequest feXCAERequest)
{
using (var ctx = new FacturaElectronicaEntities())
{
CorridaAutorizacion corrida = ctx.CorridaAutorizacions.Where(c => c.Id == corridaDto.Id).First();
// Procesar Cabecera
DetalleCabecera cabecera = new DetalleCabecera();
ClsFEXOutAuthorize feCabResp = feXCAEResponse.FEXResultAuth;
if (feCabResp != null)
{
cabecera.CantReg = 1; // ByAd: revisar
cabecera.CUIT = feCabResp.Cuit;
cabecera.CbteTipo = feCabResp.Cbte_tipo;
cabecera.FchProceso = DateTime.Now; // ByAd: revisar
cabecera.Resultado = feCabResp.Resultado;
cabecera.PtoVta = feCabResp.Punto_vta;
corrida.DetalleCabeceras.Add(cabecera);
TipoComprobanteDto tipoCbteDto = cbteSvc.ObtenerTipoComprobantePorCodigoAfip(cabecera.CbteTipo);
int tipoCbteId;
if (tipoCbteDto != null)
{
tipoCbteId = tipoCbteDto.Id;
}
// Procesar Comprobantes
DetalleComprobante detalleCbte = null;
ObservacionComprobante observacionesCbte = null;
detalleCbte = new DetalleComprobante();
detalleCbte.Concepto = 1; // ByAd revisar: aca es prdoucto, servicios o ambos
detalleCbte.DocTipo = 80;
detalleCbte.DocNro = feCabResp.Cuit;
detalleCbte.CbteDesde = feCabResp.Cbte_nro;
detalleCbte.CbteHasta = feCabResp.Cbte_nro;
detalleCbte.CbteFch = DateTimeHelper.ConvertyyyyMMddToDate(feCabResp.Fch_cbte);
detalleCbte.Resultado = feCabResp.Resultado;
if (feCabResp.Resultado == ResultadoCbte.Aprobado)
{
detalleCbte.CAE = feCabResp.Cae;
detalleCbte.CAEFchVto = DateTimeHelper.ConvertyyyyMMddToDate(feCabResp.Fch_venc_Cae);
// Si fue aprobado agrego una entidad Comprobante
Comprobante comprobante = new Comprobante();
comprobante.CAE = detalleCbte.CAE;
comprobante.CAEFechaVencimiento = detalleCbte.CAEFchVto;
comprobante.CbteDesde = detalleCbte.CbteDesde;
comprobante.CbteHasta = detalleCbte.CbteHasta;
comprobante.CbteFecha = detalleCbte.CbteFch;
comprobante.PtoVta = cabecera.PtoVta;
comprobante.FechaDeCarga = DateTime.Now;
comprobante.TipoComprobante = ctx.TipoComprobantes.Where(tc => tc.CodigoAfip == cabecera.CbteTipo).FirstOrDefault();
if (detalleCbte.DocTipo == 80) // CUIT
{
ClienteDto clienteDto = clienteSvc.ObtenerClientePorCuit(detalleCbte.DocNro);
if (clienteDto != null)
{
comprobante.ClienteId = clienteDto.Id;
}
}
// #TODO: borrar
//EstadoComprobanteDto estadoDto = this.cbteSvc.ObtenerEstado(CodigoEstadoCbte.NoVisualizado);
//if (estadoDto != null)
//{
// comprobante.EstadoId = estadoDto.Id;
//}
detalleCbte.Comprobantes.Add(comprobante);
}
else
{
if (!String.IsNullOrEmpty(feCabResp.Motivos_Obs))
{
observacionesCbte = new ObservacionComprobante();
observacionesCbte.Code = 1; // ByAd: hardcodeado, ya que este tipo no recibe
observacionesCbte.Msg = feCabResp.Motivos_Obs;
detalleCbte.ObservacionComprobantes.Add(observacionesCbte);
}
}
corrida.DetalleComprobantes.Add(detalleCbte);
}
if (feXCAEResponse.FEXEvents != null && !String.IsNullOrEmpty(feXCAEResponse.FEXEvents.EventMsg))
{
// Procesar Eventos
DetalleEvento detalleEvento = null;
detalleEvento = new DetalleEvento();
detalleEvento.Code = feXCAEResponse.FEXEvents.EventCode;
detalleEvento.Msg = feXCAEResponse.FEXEvents.EventMsg;
corrida.DetalleEventos.Add(detalleEvento);
}
if (feXCAEResponse.FEXErr != null && !String.IsNullOrEmpty(feXCAEResponse.FEXErr.ErrMsg))
{
// Procesar Errores
DetalleError detalleError = null;
detalleError = new DetalleError();
detalleError.Code = feXCAEResponse.FEXErr.ErrCode;
detalleError.Msg = feXCAEResponse.FEXErr.ErrMsg;
corrida.DetalleErrores.Add(detalleError);
}
corrida.Procesada = true;
ctx.SaveChanges();
return(ToCorridaDto(corrida, ctx.TipoDocumentoes.ToList(), ctx.TipoComprobantes.ToList(), ctx.TipoConceptoes.ToList()));
}
}
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);
}
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);
}
public CorridaAutorizacionDto ProcesarCorrida(CorridaAutorizacionDto corridaDto, FECAEResponse feCAEResponse)
{
using (var ctx = new FacturaElectronicaEntities())
{
CorridaAutorizacion corrida = ctx.CorridaAutorizacions.Where(c => c.Id == corridaDto.Id).First();
// Procesar Cabecera
DetalleCabecera cabecera = new DetalleCabecera();
FECabResponse feCabResp = feCAEResponse.FeCabResp;
cabecera.CantReg = feCabResp.CantReg;
cabecera.CUIT = feCabResp.Cuit;
cabecera.CbteTipo = feCabResp.CbteTipo;
cabecera.FchProceso = DateTimeHelper.ConvertyyyyMMddhhmmssToDate(feCabResp.FchProceso);
cabecera.Resultado = feCabResp.Resultado;
cabecera.PtoVta = feCabResp.PtoVta;
corrida.DetalleCabeceras.Add(cabecera);
TipoComprobanteDto tipoCbteDto = cbteSvc.ObtenerTipoComprobantePorCodigoAfip(cabecera.CbteTipo);
int tipoCbteId;
if (tipoCbteDto != null)
{
tipoCbteId = tipoCbteDto.Id;
}
if (feCAEResponse.FeDetResp != null && feCAEResponse.FeDetResp.Count() > 0)
{
// Procesar Comprobantes
DetalleComprobante detalleCbte = null;
ObservacionComprobante observacionesCbte = null;
foreach (FECAEDetResponse cbte in feCAEResponse.FeDetResp)
{
detalleCbte = new DetalleComprobante();
detalleCbte.Concepto = cbte.Concepto;
detalleCbte.DocTipo = cbte.DocTipo;
detalleCbte.DocNro = cbte.DocNro;
detalleCbte.CbteDesde = cbte.CbteDesde;
detalleCbte.CbteHasta = cbte.CbteHasta;
detalleCbte.CbteFch = DateTimeHelper.ConvertyyyyMMddToDate(cbte.CbteFch);
detalleCbte.Resultado = cbte.Resultado;
if (cbte.Resultado == ResultadoCbte.Aprobado)
{
detalleCbte.CAE = cbte.CAE;
detalleCbte.CAEFchVto = DateTimeHelper.ConvertyyyyMMddToDate(cbte.CAEFchVto);
// Si fue aprobado agrego una entidad Comprobante
Comprobante comprobante = new Comprobante();
comprobante.CAE = detalleCbte.CAE;
comprobante.CAEFechaVencimiento = detalleCbte.CAEFchVto;
comprobante.CbteDesde = detalleCbte.CbteDesde;
comprobante.CbteHasta = detalleCbte.CbteHasta;
comprobante.CbteFecha = detalleCbte.CbteFch;
comprobante.PtoVta = cabecera.PtoVta;
comprobante.FechaDeCarga = DateTime.Now;
comprobante.TipoComprobante = ctx.TipoComprobantes.Where(tc => tc.CodigoAfip == cabecera.CbteTipo).FirstOrDefault();
if (detalleCbte.DocTipo == 80) // CUIT
{
ClienteDto clienteDto = clienteSvc.ObtenerClientePorCuit(detalleCbte.DocNro);
if (clienteDto != null)
{
comprobante.ClienteId = clienteDto.Id;
}
}
// #TODO: borrar
//EstadoComprobanteDto estadoDto = this.cbteSvc.ObtenerEstado(CodigoEstadoCbte.NoVisualizado);
//if (estadoDto != null)
//{
// comprobante.EstadoId = estadoDto.Id;
//}
detalleCbte.Comprobantes.Add(comprobante);
}
else
{
if (cbte.Observaciones != null && cbte.Observaciones.Count() > 0)
{
foreach (Obs obs in cbte.Observaciones)
{
observacionesCbte = new ObservacionComprobante();
observacionesCbte.Code = obs.Code;
observacionesCbte.Msg = obs.Msg;
detalleCbte.ObservacionComprobantes.Add(observacionesCbte);
}
}
}
corrida.DetalleComprobantes.Add(detalleCbte);
}
}
if (feCAEResponse.Events != null && feCAEResponse.Events.Count() > 0)
{
// Procesar Eventos
DetalleEvento detalleEvento = null;
foreach (Evt evento in feCAEResponse.Events)
{
detalleEvento = new DetalleEvento();
detalleEvento.Code = evento.Code;
detalleEvento.Msg = evento.Msg;
corrida.DetalleEventos.Add(detalleEvento);
}
}
if (feCAEResponse.Errors != null && feCAEResponse.Errors.Count() > 0)
{
// Procesar Errores
DetalleError detalleError = null;
foreach (Err error in feCAEResponse.Errors)
{
detalleError = new DetalleError();
detalleError.Code = error.Code;
detalleError.Msg = error.Msg;
corrida.DetalleErrores.Add(detalleError);
}
}
corrida.Procesada = true;
ctx.SaveChanges();
return(ToCorridaDto(corrida, ctx.TipoDocumentoes.ToList(), ctx.TipoComprobantes.ToList(), ctx.TipoConceptoes.ToList()));
}
}