public async Task <RespuestaMO> ProcesarRespuestaAsync(CancellationToken cancelToken, String nombreArchivo, String tramaRespuesta)
{
RespuestaMO respuestaMO = new RespuestaMO();
try
{
using (_con = new SqlConnection(_conexion))
{
using (_cmd = new SqlCommand(Constante.SPS_HTH_PROCESAR_RESPUESTA, _con))
{
_cmd.CommandType = System.Data.CommandType.StoredProcedure;
SqlParameter par1 = _cmd.Parameters.Add(Constante.NOMBRE_ARCHIVO, System.Data.SqlDbType.NVarChar, Constante._100);
par1.Direction = System.Data.ParameterDirection.Input;
par1.Value = nombreArchivo;
SqlParameter par2 = _cmd.Parameters.Add(Constante.TRAMA_RESPUESTA, System.Data.SqlDbType.Xml);
par2.Direction = System.Data.ParameterDirection.Input;
par2.Value = tramaRespuesta;
_con.Open();
_reader = _cmd.ExecuteReader(System.Data.CommandBehavior.SingleRow);
if (_reader != null && _reader.HasRows)
{
if (_reader.Read())
{
respuestaMO.Codigo = _reader.IsDBNull(Constante._0) ? 0 : _reader.GetInt32(Constante._0);
respuestaMO.Mensaje = _reader.IsDBNull(Constante._1) ? String.Empty : _reader.GetString(Constante._1);
respuestaMO.IdSociedad = _reader.IsDBNull(Constante._2) ? String.Empty : _reader.GetString(Constante._2);
respuestaMO.IdSap = _reader.IsDBNull(Constante._3) ? String.Empty : _reader.GetString(Constante._3);
respuestaMO.Anio = _reader.IsDBNull(Constante._4) ? String.Empty : _reader.GetString(Constante._4);
respuestaMO.MomentoOrden = _reader.IsDBNull(Constante._5) ? String.Empty : _reader.GetString(Constante._5);
respuestaMO.IdEstadoOrden = _reader.IsDBNull(Constante._6) ? String.Empty : _reader.GetString(Constante._6);
respuestaMO.TipoOrden = _reader.IsDBNull(Constante._7) ? String.Empty : _reader.GetString(Constante._7);
respuestaMO.Usuario = _reader.IsDBNull(Constante._8) ? String.Empty : _reader.GetString(Constante._8);
}
}
_reader.Close();
_con.Close();
String mensaje = respuestaMO.Codigo == Constante.CODIGO_OK ? Constante.MENSAJE_PROCESAR_RESPUESTA_ASYNC_OK : Constante.MENSAJE_PROCESAR_RESPUESTA_ASYNC_NO_OK;
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_REPOSITORIO, Constante.CLASE_RESPUESTA_RE, Constante.METODO_PROCESAR_RESPUESTA_ASYNC, nombreArchivo, mensaje);
}
}
}
catch (Exception e)
{
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_ERROR, Constante.PROYECTO_REPOSITORIO, Constante.CLASE_RESPUESTA_RE, Constante.METODO_PROCESAR_RESPUESTA_ASYNC, nombreArchivo, Constante.MENSAJE_PROCESAR_RESPUESTA_ASYNC_NO_OK, e.Message);
throw e;
}
return(respuestaMO);
}
public async Task <RespuestaMO> Get(String idSociedad, String anio, String momentoOrden, String idEstadoOrden, String idSap, String usuario, String tipoOrden)
{
RespuestaMO respuestaMO = null;
try
{
respuestaMO = await _servicioNE.EnviarEstadoProcesoHostToHostAsync(new CancellationToken(false), idSociedad, anio, momentoOrden, idEstadoOrden, idSap, usuario, tipoOrden);
}
catch (Exception e)
{
respuestaMO.Respuesta = e.Message;
}
return(respuestaMO);
}
public async Task <RespuestaMO> EnviarEstadoProcesoHostToHostAsync(CancellationToken cancelToken, String idSociedad, String anio, String momentoOrden, String idEstadoOrden, String idSap, String usuario, String tipoOrden)
{
RespuestaMO respuestaMO = null;
try
{
respuestaMO = await _conexionSapNE.EnviarEstadoProcesoHostToHostAsync(cancelToken, idSociedad, anio, momentoOrden, idEstadoOrden, idSap, usuario, tipoOrden);
String mensaje = respuestaMO.IdRespuesta == Constante.TYPE_SUCCESS ? Constante.MENSAJE_ENVIAR_ESTADO_PROCESO_HOSTTOHOST_ASYNC_OK : Constante.MENSAJE_ENVIAR_ESTADO_PROCESO_HOSTTOHOST_ASYNC_NO_OK;
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_NEGOCIO, Constante.CLASE_SERVICIO_NE, Constante.METODO_ENVIAR_ESTADO_PROCESO_HOSTTOHOST_ASYNC, mensaje);
}
catch (Exception e)
{
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_ERROR, Constante.PROYECTO_NEGOCIO, Constante.CLASE_SERVICIO_NE, Constante.METODO_ENVIAR_ESTADO_PROCESO_HOSTTOHOST_ASYNC, Constante.MENSAJE_ENVIAR_ESTADO_PROCESO_HOSTTOHOST_ASYNC_NO_OK, e.Message);
throw e;
}
return(respuestaMO);
}
private RespuestaMO MapearEstructuraHaciaModeloAsync(IRfcStructure rfcStructureReturn)
{
RespuestaMO respuestaMO = respuestaMO = new RespuestaMO();
try
{
String tipo = rfcStructureReturn.GetString(Constante.TIPO) ?? String.Empty;
String mensaje = rfcStructureReturn.GetString(Constante.MENSAJE) ?? String.Empty;
if (tipo != String.Empty)
{
respuestaMO.IdRespuesta = tipo;
respuestaMO.Respuesta = mensaje;
}
}
catch (Exception e)
{
throw e;
}
return(respuestaMO);
}
private async void OnTimerRespuestaAsync(object sender)
{
RespuestaMO respuestaMO = null;
try
{
if (RespuestaNE.esProcesado)
{
RespuestaNE.esProcesado = false;
respuestaMO = await _respuestaNE.ProcesarRespuesta(_cancelToken);
await _bitacora.RegistrarEventoAsync(_cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_SERVICE, Constante.CLASE_SERVICE_HOST_TO_HOST, Constante.METODO_ON_TIMER_RESPUESTA_ASYNC, respuestaMO.NombreArchivo, respuestaMO.Mensaje);
await _bitacora.RegistrarEventoAsync(_cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_SERVICE, Constante.CLASE_SERVICE_HOST_TO_HOST, Constante.METODO_ON_TIMER_RESPUESTA_ASYNC, respuestaMO.NombreArchivo, Constante.ASTERIK);
}
}
catch (Exception e)
{
await _bitacora.RegistrarEventoAsync(_cancelToken, Constante.BITACORA_ERROR, Constante.PROYECTO_SERVICE, Constante.CLASE_SERVICE_HOST_TO_HOST, Constante.METODO_ON_TIMER_RESPUESTA_ASYNC, respuestaMO.NombreArchivo, Constante.MENSAJE_ON_TIMER_RESPUESTA_ASYNC_NO_OK, e.Message);
}
}
public async Task <RespuestaMO> EnviarEstadoProcesoHostToHostAsync(CancellationToken cancelToken, String idSociedad, String anio, String momentoOrden, String idEstadoOrden, String idSap, String usuario, String tipoOrden)
{
RespuestaMO respuestaMO = null;
try
{
DateTime?fecha = ConvertirCadenaHaciaFechaAsync(momentoOrden);
RfcDestinationManager.RegisterDestinationConfiguration(_conexionSap);
RfcConfigParameters rfcConfigParameters = GetParametersAsync();
RfcDestination rfcDestination = RfcDestinationManager.GetDestination(rfcConfigParameters[RfcConfigParameters.Name]);
RfcRepository rfcRepository = rfcDestination.Repository;
IRfcFunction rfcFunction = rfcRepository.CreateFunction(Constante.FUNCTION_YFIRFC_ACTSTS_H2H);
rfcFunction.SetValue(Constante.IP_BUKRS, idSociedad);
rfcFunction.SetValue(Constante.IP_GJAHR, anio);
rfcFunction.SetValue(Constante.IP_LAUFD, fecha);
rfcFunction.SetValue(Constante.IP_BSTAT, idEstadoOrden);
rfcFunction.SetValue(Constante.IP_REF1, idSap);
rfcFunction.SetValue(Constante.IP_USNAM, usuario);
rfcFunction.SetValue(Constante.IP_TIPO, tipoOrden);
rfcFunction.Invoke(rfcDestination);
IRfcStructure rfcStructureReturn = rfcFunction.GetStructure(Constante.EW_MENSG);
respuestaMO = MapearEstructuraHaciaModeloAsync(rfcStructureReturn);
String mensaje = respuestaMO.IdRespuesta == Constante.TYPE_SUCCESS ? Constante.MENSAJE_ENVIAR_ESTADO_PROCESO_HOSTTOHOST_ASYNC_OK : Constante.MENSAJE_ENVIAR_ESTADO_PROCESO_HOSTTOHOST_ASYNC_NO_OK;
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_NEGOCIO, Constante.CLASE_CONEXION_SAP_NE, Constante.METODO_ENVIAR_ESTADO_PROCESO_HOSTTOHOST_ASYNC, mensaje);
}
catch (Exception e)
{
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_ERROR, Constante.PROYECTO_NEGOCIO, Constante.CLASE_CONEXION_SAP_NE, Constante.METODO_ENVIAR_ESTADO_PROCESO_HOSTTOHOST_ASYNC, Constante.MENSAJE_ENVIAR_ESTADO_PROCESO_HOSTTOHOST_ASYNC_NO_OK, e.Message);
throw e;
}
finally
{
RfcDestinationManager.UnregisterDestinationConfiguration(_conexionSap);
}
return(respuestaMO);
}
public async Task <ObjetoRespuestaMO> EnviarRespuestaProcesoHaciaSapAsync(CancellationToken cancelToken, String idSociedad, String idSap, String anio, String momentoOrden, String tipoOrden)
{
ObjetoRespuestaMO objetoRespuestaMO = new ObjetoRespuestaMO();
RespuestaMO respuestaMO = null;
List <RespuestaDetalleMO> listaRespuestas = null;
try
{
using (_con = new SqlConnection(_conexionHostToHost))
{
using (_cmd = new SqlCommand(Constante.SPW_HTH_ENVIAR_RESPUESTA_PROCESO_HACIA_SAP, _con))
{
_cmd.CommandType = System.Data.CommandType.StoredProcedure;
SqlParameter par1 = _cmd.Parameters.Add(Constante.ID_SOCIEDAD, System.Data.SqlDbType.NChar, Constante._4);
par1.Direction = System.Data.ParameterDirection.Input;
par1.Value = idSociedad;
SqlParameter par2 = _cmd.Parameters.Add(Constante.ID_SAP, System.Data.SqlDbType.NVarChar, Constante._10);
par2.Direction = System.Data.ParameterDirection.Input;
par2.Value = idSap;
SqlParameter par3 = _cmd.Parameters.Add(Constante.ANIO, System.Data.SqlDbType.NChar, Constante._4);
par3.Direction = System.Data.ParameterDirection.Input;
par3.Value = anio;
SqlParameter par4 = _cmd.Parameters.Add(Constante.MOMENTO_ORDEN, System.Data.SqlDbType.NChar, Constante._8);
par4.Direction = System.Data.ParameterDirection.Input;
par4.Value = momentoOrden;
SqlParameter par5 = _cmd.Parameters.Add(Constante.TIPO_ORDEN, System.Data.SqlDbType.NChar, Constante._3);
par5.Direction = System.Data.ParameterDirection.Input;
par5.Value = tipoOrden;
await _con.OpenAsync(cancelToken);
_reader = await _cmd.ExecuteReaderAsync(System.Data.CommandBehavior.Default, cancelToken);
if (_reader != null && !_reader.HasRows)
{
objetoRespuestaMO.Codigo = Constante.CODIGO_OMISION;
objetoRespuestaMO.Mensaje = Constante.MENSAJE_SIN_RESULTADOS;
}
else if (_reader != null && _reader.HasRows)
{
listaRespuestas = new List <RespuestaDetalleMO>();
if (await _reader.ReadAsync(cancelToken))
{
respuestaMO = new RespuestaMO();
respuestaMO.IdEstadoOrden = await _reader.IsDBNullAsync(Constante._0, cancelToken) ? String.Empty : _reader.GetString(Constante._0);
respuestaMO.EstadoOrden = await _reader.IsDBNullAsync(Constante._1, cancelToken) ? String.Empty : _reader.GetString(Constante._1);
respuestaMO.Usuario = await _reader.IsDBNullAsync(Constante._2, cancelToken) ? String.Empty : _reader.GetString(Constante._2);
respuestaMO.Fecha = await _reader.IsDBNullAsync(Constante._3, cancelToken) ? String.Empty : _reader.GetString(Constante._3);
respuestaMO.Hora = await _reader.IsDBNullAsync(Constante._4, cancelToken) ? String.Empty : _reader.GetString(Constante._4);
}
await _reader.NextResultAsync(cancelToken);
while (await _reader.ReadAsync(cancelToken))
{
RespuestaDetalleMO respuestaDetalleMO = new RespuestaDetalleMO();
respuestaDetalleMO.Beneficiario = await _reader.IsDBNullAsync(Constante._0, cancelToken) ? String.Empty : _reader.GetString(Constante._0);
respuestaDetalleMO.Referencia1 = await _reader.IsDBNullAsync(Constante._1, cancelToken) ? String.Empty : _reader.GetString(Constante._1);
respuestaDetalleMO.Importe = await _reader.IsDBNullAsync(Constante._2, cancelToken) ? 0 : _reader.GetDecimal(Constante._2);
respuestaDetalleMO.IdRespuesta = await _reader.IsDBNullAsync(Constante._3, cancelToken) ? String.Empty : _reader.GetString(Constante._3);
respuestaDetalleMO.Respuesta = await _reader.IsDBNullAsync(Constante._4, cancelToken) ? String.Empty : _reader.GetString(Constante._4);
listaRespuestas.Add(respuestaDetalleMO);
}
objetoRespuestaMO.Codigo = Constante.CODIGO_OK;
}
_reader.Close();
_con.Close();
objetoRespuestaMO.Codigo = _reader != null ? objetoRespuestaMO.Codigo : Constante.CODIGO_NO_OK;
objetoRespuestaMO.Mensaje = _reader != null ? objetoRespuestaMO.Mensaje : Constante.MENSAJE_RECARGAR_PAGINA;
objetoRespuestaMO.RespuestaMO = respuestaMO;
objetoRespuestaMO.ListaRespuestas = listaRespuestas;
String mensaje = _reader != null ? Constante.MENSAJE_ENVIAR_RESPUESTA_PROCESO_HACIA_SAP_ASYNC_OK : Constante.MENSAJE_ENVIAR_RESPUESTA_PROCESO_HACIA_SAP_ASYNC_NO_OK;
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_REPOSITORIO, Constante.CLASE_SERVICIO_RE, Constante.METODO_ENVIAR_RESPUESTA_PROCESO_HACIA_SAP_ASYNC, mensaje);
}
}
}
catch (Exception e)
{
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_ERROR, Constante.PROYECTO_REPOSITORIO, Constante.CLASE_SERVICIO_RE, Constante.METODO_ENVIAR_RESPUESTA_PROCESO_HACIA_SAP_ASYNC, Constante.MENSAJE_ENVIAR_RESPUESTA_PROCESO_HACIA_SAP_ASYNC_NO_OK, e.Message);
throw e;
}
finally
{
if (_con != null && _con.State != System.Data.ConnectionState.Closed)
{
_con.Close();
}
}
return(objetoRespuestaMO);
}
public async Task <RespuestaMO> ProcesarRespuesta(CancellationToken cancelToken)
{
RespuestaMO respuestaMO = new RespuestaMO();
Int32 contador = 0;
Dictionary <String, String> listaNombreArchivos = null;
String arguments = String.Empty, error = String.Empty, message = String.Empty, nombreArchivo = String.Empty;
Boolean puedeContinuar = false;
try
{
String servidor = ConfigurationManager.AppSettings[Constante.SERVIDOR_SFTP_IP] ?? String.Empty;
Int32 puerto = ConfigurationManager.AppSettings[Constante.SERVIDOR_SFTP_PUERTO] == String.Empty ? 0 : Convert.ToInt32(ConfigurationManager.AppSettings[Constante.SERVIDOR_SFTP_PUERTO]);
String usuario = ConfigurationManager.AppSettings[Constante.SERVIDOR_SFTP_USUARIO] ?? String.Empty;
String clave = ConfigurationManager.AppSettings[Constante.SERVIDOR_SFTP_CLAVE] ?? String.Empty;
PasswordAuthenticationMethod authentication = new PasswordAuthenticationMethod(usuario, clave);
ConnectionInfo connection = new ConnectionInfo(servidor, puerto, usuario, authentication);
using (SftpClient sftpClient = new SftpClient(connection))
{
sftpClient.Connect();
Boolean isConnected = sftpClient.IsConnected;
if (isConnected)
{
IEnumerable <SftpFile> listaArchivos = sftpClient.ListDirectory(_carpetaRemota);
if (listaArchivos == null || !listaArchivos.Any())
{
String MENSAJE_CARPETA_ORIGEN_VACIA = String.Format("{0} | {1}", Constante.MENSAJE_CARPETA_ORIGEN_VACIA, _carpetaRemota);
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_NEGOCIO, Constante.CLASE_RESPUESTA_NE, Constante.METODO_PROCESAR_RESPUESTA_ASYNC, String.Empty, MENSAJE_CARPETA_ORIGEN_VACIA);
respuestaMO.Codigo = Constante.CODIGO_OK;
respuestaMO.Mensaje = MENSAJE_CARPETA_ORIGEN_VACIA;
}
else
{
puedeContinuar = true;
listaNombreArchivos = new Dictionary <String, String>();
foreach (SftpFile archivo in listaArchivos)
{
if (archivo.Name != Constante.SINGLE_DOT && archivo.Name != Constante.DOUBLE_DOT)
{
if (archivo.IsRegularFile)
{
respuestaMO.NombreArchivo = archivo.Name.Replace(Constante.EXTENSION_PGP, Constante.EXTENSION_TXT);
nombreArchivo = archivo.Name.Replace(Constante.EXTENSION_PGP, Constante.EXTENSION_TXT);
String rutaRemota = String.Format("{0}{1}", _carpetaRemota, archivo.Name);
String rutaArchivo = String.Format("{0}{1}", _carpetaDescargado, archivo.Name);
using (FileStream fileStream = File.Create(rutaArchivo))
{
sftpClient.DownloadFile(rutaRemota, fileStream);
}
Boolean esDescargado = File.Exists(rutaArchivo);
if (esDescargado)
{
sftpClient.DeleteFile(rutaRemota);
listaNombreArchivos.Add(nombreArchivo, rutaArchivo);
}
String mensaje = esDescargado == true ? Constante.MENSAJE_DESCARGAR_ARCHIVOS_ASYNC_OK : Constante.MENSAJE_DESCARGAR_ARCHIVOS_ASYNC_NO_OK;
mensaje = String.Format("{0} | {1}", mensaje, archivo.Name);
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_NEGOCIO, Constante.CLASE_RESPUESTA_NE, Constante.METODO_PROCESAR_RESPUESTA_ASYNC, nombreArchivo, mensaje);
}
contador++;
}
}
if (contador == Constante._2)
{
String MENSAJE_CARPETA_ORIGEN_VACIA = String.Format("{0} | {1}", Constante.MENSAJE_CARPETA_ORIGEN_VACIA, _carpetaRemota);
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_NEGOCIO, Constante.CLASE_RESPUESTA_NE, Constante.METODO_PROCESAR_RESPUESTA_ASYNC, String.Empty, MENSAJE_CARPETA_ORIGEN_VACIA);
respuestaMO.Codigo = Constante.CODIGO_OK;
respuestaMO.Mensaje = MENSAJE_CARPETA_ORIGEN_VACIA;
}
}
}
sftpClient.Disconnect();
sftpClient.Dispose();
}
if (puedeContinuar == false)
{
RespuestaNE.esProcesado = true;
}
else if (puedeContinuar == true && listaNombreArchivos != null && listaNombreArchivos.Count == 0)
{
RespuestaNE.esProcesado = true;
}
else if (puedeContinuar == true && listaNombreArchivos != null && listaNombreArchivos.Count > 0)
{
Boolean esConforme = false, esDesencriptado = false, esAlmacenado = false;
contador = 0;
String carpetaProcesado = _carpetaProcesado.Substring(Constante._0, _carpetaProcesado.LastIndexOf(Constante.BACK_SLASH));
foreach (var item in listaNombreArchivos)
{
respuestaMO.NombreArchivo = item.Key;
nombreArchivo = item.Key;
String rutaArchivo = item.Value;
String homeDirectory = string.Format("\"{0}\"", Constante.PGP_DIRECTORY);
arguments = String.Format("{0} {1} {2} {3} {4} {5} {6} {7} {8}", Constante.PGP_VERBOSE, Constante.PGP_HOME_DIRECTORY, homeDirectory, Constante.PGP_DECRYPT, rutaArchivo, Constante.PGP_PASSPHRASE_DEV, Constante.PGP_OUTPUT, carpetaProcesado, Constante.PGP_OVERWRITE);
Process process = new Process();
process.StartInfo.FileName = Constante.PGP_EXE;
process.StartInfo.Arguments = arguments;
process.StartInfo.UseShellExecute = false;
process.StartInfo.CreateNoWindow = true;
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardError = true;
process.Start();
message = process.StandardOutput.ReadToEnd();
error = process.StandardError.ReadToEnd();
process.WaitForExit(Timeout.Infinite);
rutaArchivo = String.Format("{0}{1}", _carpetaProcesado, nombreArchivo.Replace(Constante.EXTENSION_TXT, String.Empty));
if (File.Exists(rutaArchivo))
{
esDesencriptado = true;
String cadenaXml = await _util.ConvertirCadenaHaciaXml(cancelToken, rutaArchivo, nombreArchivo);
if (cadenaXml != String.Empty)
{
RespuestaMO respuestaMO2 = await _respuestaRE.ProcesarRespuestaAsync(cancelToken, nombreArchivo, cadenaXml);
if (respuestaMO2 != null && respuestaMO2.Codigo == Constante.CODIGO_OK)
{
String rutaRespaldo = String.Format("{0}{1}", _carpetaRespaldo, nombreArchivo);
if (File.Exists(rutaRespaldo))
{
File.Delete(rutaRespaldo);
}
File.Move(rutaArchivo, rutaRespaldo);
esAlmacenado = true;
esConforme = true;
await _conexionSapNE.EnviarEstadoProcesoHostToHostAsync(cancelToken, respuestaMO2.IdSociedad, respuestaMO2.Anio, respuestaMO2.MomentoOrden, respuestaMO2.IdEstadoOrden, respuestaMO2.IdSap, respuestaMO2.Usuario, respuestaMO2.TipoOrden, nombreArchivo);
}
String mensajeDesencriptado = esDesencriptado ? Constante.MENSAJE_DESENCRIPTAR_ARCHIVO_ASYNC_OK : Constante.MENSAJE_DESENCRIPTAR_ARCHIVO_ASYNC_NO_OK;
String mensajeAlmacenado = esAlmacenado ? Constante.MENSAJE_ALMACENAR_ARCHIVO_ASYNC_OK : Constante.MENSAJE_ALMACENAR_ARCHIVO_ASYNC_NO_OK;
String mensaje = esConforme ? String.Format("{0} {1}", Constante.MENSAJE_DESENCRIPTAR_ARCHIVO_ASYNC_OK, Constante.MENSAJE_ALMACENAR_ARCHIVO_ASYNC_OK) : String.Format("{0} | {1} | {2} | {3} | {4}", mensajeDesencriptado, mensajeAlmacenado, arguments, message, error);
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_NEGOCIO, Constante.CLASE_RESPUESTA_NE, Constante.METODO_PROCESAR_RESPUESTA_ASYNC, nombreArchivo, mensaje);
}
}
contador++;
}
if (contador == listaNombreArchivos.Count())
{
respuestaMO.Mensaje = String.Format("{0} | {1}", Constante.MENSAJE_PROCESAR_RESPUESTAS_ASYNC_OK, contador);
RespuestaNE.esProcesado = true;
}
}
}
catch (Exception e)
{
RespuestaNE.esProcesado = true;
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_ERROR, Constante.PROYECTO_NEGOCIO, Constante.CLASE_RESPUESTA_NE, Constante.METODO_PROCESAR_RESPUESTA_ASYNC, nombreArchivo, Constante.MENSAJE_PROCESAR_RESPUESTA_ASYNC_NO_OK, e.Message);
respuestaMO.Codigo = Constante.CODIGO_ERROR;
respuestaMO.Mensaje = e.Message;
}
return(respuestaMO);
}
public async Task <RespuestaMO> ProcesarTrama(CancellationToken cancelToken)
{
RespuestaMO respuestaMO = new RespuestaMO();
Int32 contador = 0;
String rutaOrigen = String.Empty, nombreArchivo = String.Empty;
try
{
String[] listaArchivosPendientes = Directory.GetFiles(_carpetaOrigen, Constante.PATRON_TXT, SearchOption.TopDirectoryOnly);
if (listaArchivosPendientes.Length == Constante._0)
{
String mensaje = String.Format("{0} | {1}", Constante.MENSAJE_CARPETA_ORIGEN_VACIA, _carpetaOrigen);
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_NEGOCIO, Constante.CLASE_TRAMA_NE, Constante.METODO_PROCESAR_TRAMA_ASYNC, String.Empty, mensaje);
respuestaMO.Codigo = Constante.CODIGO_OK;
respuestaMO.Mensaje = mensaje;
TramaNE.esProcesado = true;
}
else
{
foreach (String archivo in listaArchivosPendientes)
{
rutaOrigen = archivo;
String mensajeValidacion = _util.ValidarNombreArchivo(archivo, out nombreArchivo);
respuestaMO.NombreArchivo = nombreArchivo;
if (mensajeValidacion != String.Empty)
{
await _util.MoverArchivos(cancelToken, archivo, _carpetaIncorrecto, nombreArchivo);
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_NEGOCIO, Constante.CLASE_TRAMA_NE, Constante.METODO_PROCESAR_TRAMA_ASYNC, nombreArchivo, mensajeValidacion);
}
else
{
String nombreArchivoConExtension = archivo.Substring(archivo.LastIndexOf(Constante.BACK_SLASH) + 1);
String nombreArchivoSinExtension = nombreArchivoConExtension.Split(Constante.DOT)[Constante._0];
String parametros = nombreArchivoSinExtension.Substring(nombreArchivoSinExtension.IndexOf(Constante.AMPERSON) + 1);
nombreArchivoConExtension = String.Format("{0}{1}", nombreArchivoSinExtension.Split(Constante.AMPERSON)[Constante._0], Constante.EXTENSION_TXT);
TramaMO tramaMO = MapearCadenaHaciaModelo(nombreArchivoConExtension, archivo, parametros);
String cadenaXml = await _util.ConvertirCadenaHaciaXml(cancelToken, archivo, nombreArchivo);
if (cadenaXml != String.Empty)
{
RespuestaMO respuestaMO2 = await _tramaRE.ProcesarTramaAsync(cancelToken, tramaMO, cadenaXml, nombreArchivo);
Boolean esMovido = false;
if (respuestaMO2 != null && respuestaMO2.Codigo == Constante.CODIGO_OK)
{
esMovido = await _util.MoverArchivos(cancelToken, archivo, _carpetaCorrecto, nombreArchivo);
}
else
{
respuestaMO.Mensaje = respuestaMO2.Mensaje;
if (respuestaMO2.Codigo == Constante.CODIGO_ERROR)
{
await _util.MoverArchivos(cancelToken, archivo, _carpetaIncorrecto, nombreArchivo);
}
}
String mensaje = esMovido == true ? Constante.MENSAJE_PROCESAR_TRAMA_ASYNC_OK : Constante.MENSAJE_PROCESAR_TRAMA_ASYNC_NO_OK;
mensaje = String.Format("{0} | {1}", mensaje, respuestaMO2.Mensaje);
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_NEGOCIO, Constante.CLASE_TRAMA_NE, Constante.METODO_PROCESAR_TRAMA_ASYNC, nombreArchivo, mensaje);
}
}
contador++;
}
if (contador == listaArchivosPendientes.Length)
{
respuestaMO.Mensaje = String.Format("{0} | {1}", Constante.MENSAJE_PROCESAR_TRAMAS_ASYNC_OK, contador);
TramaNE.esProcesado = true;
}
}
}
catch (Exception e)
{
TramaNE.esProcesado = true;
await _util.MoverArchivos(cancelToken, rutaOrigen, _carpetaIncorrecto, nombreArchivo);
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_ERROR, Constante.PROYECTO_NEGOCIO, Constante.CLASE_TRAMA_NE, Constante.METODO_PROCESAR_TRAMA_ASYNC, nombreArchivo, Constante.MENSAJE_PROCESAR_TRAMA_ASYNC_NO_OK, e.Message);
respuestaMO.Codigo = Constante.CODIGO_ERROR;
respuestaMO.Mensaje = String.Format("{0} | {1}", nombreArchivo, e.Message);
}
return(respuestaMO);
}
public async Task <RespuestaMO> ProcesarTramaAsync(CancellationToken cancelToken, TramaMO tramaMO, String tramaDetalle, String nombreArchivo)
{
RespuestaMO respuestaMO = new RespuestaMO();
try
{
using (_con = new SqlConnection(_conexion))
{
using (_cmd = new SqlCommand(Constante.SPS_HTH_PROCESAR_TRAMA, _con))
{
_cmd.CommandType = System.Data.CommandType.StoredProcedure;
SqlParameter par1 = _cmd.Parameters.Add(Constante.ID_BANCO, System.Data.SqlDbType.NChar, Constante._5);
par1.Direction = System.Data.ParameterDirection.Input;
par1.Value = tramaMO.IdBanco;
SqlParameter par2 = _cmd.Parameters.Add(Constante.USUARIO, System.Data.SqlDbType.NVarChar, Constante._20);
par2.Direction = System.Data.ParameterDirection.Input;
par2.Value = tramaMO.Usuario;
SqlParameter par3 = _cmd.Parameters.Add(Constante.TIPO_ORDEN, System.Data.SqlDbType.NChar, Constante._3);
par3.Direction = System.Data.ParameterDirection.Input;
par3.Value = tramaMO.TipoOrden;
SqlParameter par4 = _cmd.Parameters.Add(Constante.ID_SOCIEDAD, System.Data.SqlDbType.NChar, Constante._4);
par4.Direction = System.Data.ParameterDirection.Input;
par4.Value = tramaMO.IdSociedad;
SqlParameter par5 = _cmd.Parameters.Add(Constante.ID_SAP, System.Data.SqlDbType.NVarChar, Constante._10);
par5.Direction = System.Data.ParameterDirection.Input;
par5.Value = tramaMO.IdSap;
SqlParameter par6 = _cmd.Parameters.Add(Constante.ANIO, System.Data.SqlDbType.NChar, Constante._4);
par6.Direction = System.Data.ParameterDirection.Input;
par6.Value = tramaMO.Anio;
SqlParameter par7 = _cmd.Parameters.Add(Constante.MOMENTO_ORDEN, System.Data.SqlDbType.NChar, Constante._8);
par7.Direction = System.Data.ParameterDirection.Input;
par7.Value = tramaMO.MomentoOrden;
SqlParameter par8 = _cmd.Parameters.Add(Constante.PROPIETARIO, System.Data.SqlDbType.NVarChar, Constante._20);
par8.Direction = System.Data.ParameterDirection.Input;
par8.Value = tramaMO.Propietario;
SqlParameter par9 = _cmd.Parameters.Add(Constante.NOMBRE_ARCHIVO, System.Data.SqlDbType.NVarChar, Constante._100);
par9.Direction = System.Data.ParameterDirection.Input;
par9.Value = tramaMO.NombreArchivo;
SqlParameter par10 = _cmd.Parameters.Add(Constante.RUTA_ARCHIVO, System.Data.SqlDbType.NVarChar, Constante._200);
par10.Direction = System.Data.ParameterDirection.Input;
par10.Value = tramaMO.RutaArchivo;
SqlParameter par11 = _cmd.Parameters.Add(Constante.PARAMETROS, System.Data.SqlDbType.NVarChar, Constante._100);
par11.Direction = System.Data.ParameterDirection.Input;
par11.Value = tramaMO.Parametros;
SqlParameter par12 = _cmd.Parameters.Add(Constante.TRAMA_DETALLE, System.Data.SqlDbType.Xml);
par12.Direction = System.Data.ParameterDirection.Input;
par12.Value = tramaDetalle;
_con.Open();
_reader = _cmd.ExecuteReader(System.Data.CommandBehavior.SingleRow);
if (_reader != null && _reader.HasRows)
{
if (_reader.Read())
{
respuestaMO.Codigo = _reader.IsDBNull(Constante._0) ? 0 : _reader.GetInt32(Constante._0);
respuestaMO.Mensaje = _reader.IsDBNull(Constante._1) ? String.Empty : _reader.GetString(Constante._1);
}
}
_reader.Close();
_con.Close();
String mensaje = respuestaMO.Codigo == Constante.CODIGO_OK ? Constante.MENSAJE_PROCESAR_TRAMA_ASYNC_OK : Constante.MENSAJE_PROCESAR_TRAMA_ASYNC_NO_OK;
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_REPOSITORIO, Constante.CLASE_TRAMA_RE, Constante.METODO_PROCESAR_TRAMA_ASYNC, nombreArchivo, mensaje);
}
}
}
catch (Exception e)
{
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_ERROR, Constante.PROYECTO_REPOSITORIO, Constante.CLASE_TRAMA_RE, Constante.METODO_PROCESAR_TRAMA_ASYNC, nombreArchivo, Constante.MENSAJE_PROCESAR_TRAMA_ASYNC_NO_OK, e.Message);
throw e;
}
return(respuestaMO);
}
