public void ProcessRequest(HttpContext context)
{
string FILA = context.Request["FILA"];
string FECHA_HORA = context.Request["FECHA_HORA"];
try
{
//=======================================================
// DECLARACION DE VARIABLES
//=======================================================
SMetodos Servicio = new SMetodos();
List <oSP_READ_INTERFAZ> ListaInterfaz = new List <oSP_READ_INTERFAZ>();
oSP_READ_INTERFAZ INTERFAZ = new oSP_READ_INTERFAZ();
string OPCION = context.Request["OPCION"];
//=======================================================
// VALIDACION DE DATOS
//=======================================================
string CODIGO_INTERFAZ = context.Request["CODIGO_INTERFAZ"];
int ID_GRUPO_CARGA;
int ID_INTERFAZ;
try
{
ID_INTERFAZ = Convert.ToInt32(context.Request["ID_INTERFAZ"]);
}
catch (Exception)
{
ID_INTERFAZ = 0;
}
try
{
ID_GRUPO_CARGA = Convert.ToInt32(context.Request["ID_GRUPO_CARGA"]);
}
catch (Exception)
{
ID_GRUPO_CARGA = 0;
}
if (string.IsNullOrEmpty(CODIGO_INTERFAZ))
{
throw new Exception("CODIGO DE INTERFAZ NO ENVIADO");
}
if (ID_INTERFAZ == 0)
{
throw new Exception("ID DE INTERFAZ NO ENVIADO");
}
iSP_READ_INTERFAZ ParametrosInputInterfaz = new iSP_READ_INTERFAZ();
ParametrosInputInterfaz.ID_INTERFAZ = ID_INTERFAZ;
ListaInterfaz = Servicio.SP_READ_INTERFAZ(ParametrosInputInterfaz);
if (ListaInterfaz == null && ListaInterfaz.Count <= 0)
{
throw new Exception("LA INTERFAZ CON EL ID " + ID_INTERFAZ + " NO EXISTE");
}
INTERFAZ = ListaInterfaz.First();
if (OPCION.Equals("I"))
{
//===========================================================
// DECLARACION DE VARIABLES
//===========================================================
string KEY_ZIP = "RUTA_7_ZIP";// @"C:\Program Files\7-Zip\7zG.exe";
string KEY_ZIP_POWER_SHELL = "RUTA_POWER_SHELL";
oSP_READ_RUTAS_CONFIGURACION_X_LLAVE RUTA_ZIP = RUTA_CONFIGURACION(KEY_ZIP);
oSP_READ_RUTAS_CONFIGURACION_X_LLAVE RUTA_POWER_SHELL = RUTA_CONFIGURACION(KEY_ZIP_POWER_SHELL);
if (ID_GRUPO_CARGA == 0)
{
throw new Exception("GRUPO DE CARGA NO ENVIADO");
}
string RUTA = context.Server.MapPath("~/archivoCarga/");
//=======================================================
// VERIFICAMOS QUE EXISTA LA CARPETA
//=======================================================
if (!Directory.Exists(RUTA))
{
Directory.CreateDirectory(RUTA);
}
//===========================================================
// LECTURA DE ARCHIVOS
//===========================================================
if (context.Request.Files.Count > 0)
{
//=======================================================
// RESCATAMOS EL ARCHIVO
//=======================================================
HttpPostedFile file = context.Request.Files[0];
//=======================================================
// VERIFICAMOS LA EXTENSION DEL ARCHIVO
//=======================================================
string EXTENSION = System.IO.Path.GetExtension(file.FileName);
if (!EXTENSION.ToLower().Equals(".txt") && !EXTENSION.ToLower().Equals(".csv"))
{
throw new Exception("DEBE SELECCIONAR UN ARCHIVO CON EXTENSION .txt o .csv");
}
//=======================================================
// SETEAMOS EL NUEVO NOMBRE DEL ARCHIVO
//=======================================================
string NOMBRE_ARCHIVO = Path.GetFileNameWithoutExtension(file.FileName);
//Entidad.CAMPO= Regex.Replace(Entidad.CAMPO, @"[^a-zA-Z0-9 ]+", "");
//Entidad.CAMPO = Entidad.CAMPO.Replace(" ", "_");
//transformación UNICODE
NOMBRE_ARCHIVO = NOMBRE_ARCHIVO.Normalize(NormalizationForm.FormD);
//coincide todo lo que no sean letras y números ascii o espacio
//y lo reemplazamos por una cadena vacía.
Regex reg = new Regex("[^a-zA-Z0-9 _]");
NOMBRE_ARCHIVO = reg.Replace(NOMBRE_ARCHIVO, "");
NOMBRE_ARCHIVO = NOMBRE_ARCHIVO.Replace(" ", "_");
NOMBRE_ARCHIVO = NOMBRE_ARCHIVO.ToUpper();
//=======================================================
// GUARDAMOS EL ARCHIVO
//=======================================================
string ORIGEN = RUTA + NOMBRE_ARCHIVO + EXTENSION;
file.SaveAs(ORIGEN);
//string RUTA_DIRECTORIO = CREA_DIRECTORIO(INTERFAZ);
string DESTINO = RUTA + NOMBRE_ARCHIVO + ".zip";
//=======================================================
// SE DESCOMPRIME EL PROYECTO Y SE ALMACENA
//=======================================================
try
{
ProcessStartInfo pro = new ProcessStartInfo();
pro.WindowStyle = ProcessWindowStyle.Hidden;
pro.FileName = '"' + RUTA_ZIP.RUTA + '"';
pro.Arguments = " a " + '"' + DESTINO + '"' + " " + '"' + ORIGEN + '"';
pro.UseShellExecute = false;
pro.RedirectStandardOutput = true;
pro.RedirectStandardError = true;
using (Process proc = new Process())
{
proc.StartInfo = pro;
proc.ErrorDataReceived += P_CaptureError;
proc.Start();
proc.WaitForExit();
}
}
catch
{
throw new Exception("PROBLEMAS AL COMPRIMIR EL ARCHIVO " + file.FileName);
}
//=======================================================================================
// DECLARACION DE VARIABLES
//=======================================================================================
oSP_READ_RUTAS_X_FTP_X_LLAVE RUTA_FTP = new oSP_READ_RUTAS_X_FTP_X_LLAVE();
oSP_READ_FTP_X_LLAVE FTP = new oSP_READ_FTP_X_LLAVE();
//=======================================================================================
// OBTENEMOS DATOS DEL FTP
//=======================================================================================
FTP = LEER_FTP();
//=======================================================================================
// OBTENEMOS DATOS DE LAS RUTAS
//=======================================================================================
RUTA_FTP = LEER_RUTA_FTP(FTP.ID_FTP);
bool ESTADO;
//=======================================================================================
// MANDAMOS EL ARCHIVO AL SFTP
//=======================================================================================
INPUT_FTP_JSON_ALO ObjetoInput_UP = new INPUT_FTP_JSON_ALO();
ObjetoInput_UP.R_FTP.KEY = FTP.KEY_SSH;
ObjetoInput_UP.R_FTP.SERVIDOR = FTP.SERVIDOR;
ObjetoInput_UP.R_FTP.USUARIO = FTP.USUARIO;
ObjetoInput_UP.R_FTP.PASSWORD = FTP.PASSWORD;
ObjetoInput_UP.R_FILE_FTP.FILE = NOMBRE_ARCHIVO + ".zip";
ObjetoInput_UP.R_FILE_FTP.RUTA = RUTA_FTP.RUTA;
ObjetoInput_UP.R_FILE_LOCAL.FILE = NOMBRE_ARCHIVO + ".zip";
ObjetoInput_UP.R_FILE_LOCAL.RUTA = RUTA;
using (UHttpFileServer HttpU = new UHttpFileServer())
{
HttpU.UploadFile(UConfiguracion.F_POST_UPLOAD_FILE, UConfiguracion.F_POST_UPLOAD_FTP, ObjetoInput_UP);
ESTADO = true;
}
if (ESTADO)
{
//=======================================================
// CONSTRUCCION DE OBJETO TABLA_CARGA
//=======================================================
iSP_CREATE_TABLA_CARGA ParametrosInputTablaCarga = new iSP_CREATE_TABLA_CARGA();
ParametrosInputTablaCarga.ID_INTERFAZ = ID_INTERFAZ;
ParametrosInputTablaCarga.COMPRESION = "ZIP";
ParametrosInputTablaCarga.FILENAME = NOMBRE_ARCHIVO + EXTENSION;
ParametrosInputTablaCarga.RUTA_FISICA = " ";
ParametrosInputTablaCarga.NOMBRE_TABLA = "FILE_" + CODIGO_INTERFAZ + "_" + FECHA_HORA + "_" + ID_INTERFAZ;
ParametrosInputTablaCarga.ID_EJECUCION = 0;
//=======================================================
// LLAMADA A SERVICIO
//=======================================================
oSP_CREATE_TABLA_CARGA TABLA_CARGA = Servicio.SP_CREATE_TABLA_CARGA(ParametrosInputTablaCarga);
if (TABLA_CARGA.ID_EJECUCION != 0 || TABLA_CARGA.ID_EJECUCION != -1)
{
//=======================================================
// CONSTRUCCION DE OBJETO DETALLE_GRUPO_CARGA
//=======================================================
iSP_CREATE_DETALLE_GRUPO_CARGA ParametrosInputGrupoCarga = new iSP_CREATE_DETALLE_GRUPO_CARGA();
ParametrosInputGrupoCarga.ID_EJECUCION = TABLA_CARGA.ID_EJECUCION;
ParametrosInputGrupoCarga.ID_GRUPO_CARGA = ID_GRUPO_CARGA;
//=======================================================
// LLAMADA A SERVICIO
//=======================================================
oSP_RETURN_STATUS ESTADO_DETALLE_GRUPO = Servicio.SP_CREATE_DETALLE_GRUPO_CARGA(ParametrosInputGrupoCarga);
if (ESTADO_DETALLE_GRUPO.RETURN_VALUE == 1)
{
//=======================================================
// CONSTRUCCION DE OBJETO ESTADO_INTERFAZ
//=======================================================
iSP_UPDATE_ESTADO_INTERFAZ ParametrosInputEstadoInterfaz = new iSP_UPDATE_ESTADO_INTERFAZ();
ParametrosInputEstadoInterfaz.ID_INTERFAZ = ID_INTERFAZ;
ParametrosInputEstadoInterfaz.ID_ESTADO_INTERFAZ = (int)T_ESTADO_INTERFAZ.COPIADA;
//=======================================================
// LLAMADA A SERVICIO
//=======================================================
oSP_RETURN_STATUS ESTADO_INTERFAZ = Servicio.SP_UPDATE_ESTADO_INTERFAZ(ParametrosInputEstadoInterfaz);
}
}
else
{
throw new Exception("NO SE A GENERADO EL PROCESO");
}
//===============================================================================
// ACTUALIZACION DE CANTIDAD DE REGISTROS
//===============================================================================
int CONTADOR = 0;
using (StreamReader sr = new StreamReader(ORIGEN, System.Text.Encoding.Default))
{
if (INTERFAZ.HEADER)
{
sr.ReadLine();
}
string line = String.Empty;
while ((line = sr.ReadLine()) != null)
{
CONTADOR++;
}
}
iSP_UPDATE_ROW_EJECUCION ParametrosInputRow = new iSP_UPDATE_ROW_EJECUCION();
ParametrosInputRow.ID_EJECUCION = TABLA_CARGA.ID_EJECUCION;
ParametrosInputRow.ROW_TOTAL = CONTADOR;
Servicio.SP_UPDATE_ROW_EJECUCION(ParametrosInputRow);
//===========================================================
// CONSTRUCCION DE OBJETO
//===========================================================
iSP_UPDATE_GRUPO_CARGA_ESTADO ParametrosInput = new iSP_UPDATE_GRUPO_CARGA_ESTADO();
ParametrosInput.ID_ESTADO_CARGA = (int)T_ESTADO_GRUPO_CARGA.SIN_ESTADO;
ParametrosInput.ID_GRUPO_CARGA = ID_GRUPO_CARGA;
ParametrosInput.MENSAJE = " ";
//===========================================================
// LLAMADA A SERVICIO
//===========================================================
Servicio.SP_UPDATE_GRUPO_CARGA_ESTADO(ParametrosInput);
//===========================================================
// ELIMINAMOS ARCHIVO EN LA RUTA TEMPORAL
//===========================================================
try
{
FileInfo INFO = new FileInfo(ORIGEN);
INFO.Delete();
}
catch
{
throw new Exception("NO EXISTE EL ARCHIVO EN LA RUTA TEMPORAL: " + ORIGEN);
}
//===========================================================
// ELIMINAMOS ARCHIVO EN LA RUTA TEMPORAL
//===========================================================
try
{
FileInfo INFO = new FileInfo(DESTINO);
INFO.Delete();
}
catch
{
throw new Exception("NO EXISTE EL ARCHIVO EN LA RUTA TEMPORAL: " + DESTINO);
}
}
else
{
throw new Exception("NO SE A GUARDADO EL ARCHIVO " + NOMBRE_ARCHIVO + " EN LA RUTA DE RESPALDO ");
}
context.Response.ContentType = "text/plain";
context.Response.Write("OK|" + FILA + "|" + "ARCHIVO SUBIDO EXITOSAMANTE.");
}
}
}
catch (Exception e)
{
context.Response.ContentType = "text/plain";
context.Response.Write("ERROR|" + FILA + "|" + e.Message);
}
}
/// <summary>
/// SUBIR ARCHIVO VIA FTP
/// </summary>
/// <param name="URL_1"></param>
/// <param name="URL_2"></param>
/// <param name="ObjetoInput"></param>
public void UploadFile(string URL_1, string URL_2, INPUT_FTP_JSON_ALO ObjetoInput)
{
try
{
//=============================================================
// DECLARACION DE VARIABLES
//=============================================================
string JsonReturn;
string Token = "";
//=============================================================
// VERIFICAR CARPETA
//=============================================================
if (Directory.Exists(ObjetoInput.R_FILE_LOCAL.RUTA) == false)
{
throw new Exception("RUTA DE CARPETA NO EXISTE");
}
//=============================================================
// COMBINAR RUTAS
//=============================================================
string[] paths = { ObjetoInput.R_FILE_LOCAL.RUTA, ObjetoInput.R_FILE_LOCAL.FILE };
string LocalFilename = Path.Combine(paths);
//=============================================================
// SE PREPARA OBJETO PARA SUBIR ARCHIVO
//=============================================================
using (WebClient Cliente = new WebClient())
{
Cliente.Proxy = null;
Cliente.Headers[HttpRequestHeader.AcceptEncoding] = "gzip";
byte[] ResponseArray = Cliente.UploadFile(URL_1, LocalFilename);
byte[] ReturnByte = Decompress(ResponseArray);
JsonReturn = System.Text.Encoding.ASCII.GetString(ReturnByte);
}
//=============================================================
// SE DEBE DESERIALIZAR RESULTADOS
//=============================================================
RETURN_JSON_APL Retorno = new RETURN_JSON_APL();
using (UObjetoJson ObjetoRetorno = new UObjetoJson())
{
Retorno = ObjetoRetorno.Deserialize <RETURN_JSON_APL>(JsonReturn);
}
//=============================================================
// COMPROBAR LA EJECUCION
//=============================================================
int ESTADO = Retorno.HEADER.ESTADO;
if (ESTADO == 1)
{
Mensaje Objeto = Retorno.RESULT_HTTP.DETALLES;
Token = Objeto.MSG;
}
else
{
throw new Exception(Retorno.ERRORES.Mensaje);
}
//=============================================================
// REEMPLAZAR OBJETO DE TOKEM
//=============================================================
FileInfo InfoFile = new FileInfo(LocalFilename);
string NombreFile = NameFile(LocalFilename);
ObjetoInput.R_FILE_LOCAL.FILE = InfoFile.Name.Replace(NombreFile, Token);
//=============================================================
// SI EXISTE TOKEN ENTONCES DEBEMOS INVOKAR EL SEGUNDO
// METODO CON LOS PARAMETROS
//=============================================================
string Json;
using (UObjetoJson ObjetoParametros = new UObjetoJson())
{
Json = ObjetoParametros.Serialize(ObjetoInput);
}
//=============================================================
// DATOS JSON EN URL
//=============================================================
Json = "json=" + Json;
//=============================================================
// DATOS JSON EN URL ==
//=============================================================
byte[] data = Encoding.ASCII.GetBytes(Json);
//=============================================================
// SERVICIO RESTFUL ==
//=============================================================
HttpWebRequest myRequest = (HttpWebRequest)WebRequest.Create(URL_2);
myRequest.Method = "POST";
myRequest.ContentType = "application/x-www-form-urlencoded";
myRequest.ContentLength = data.Length;
myRequest.Accept = "application/json";
myRequest.Headers.Add(HttpRequestHeader.AcceptEncoding, "gzip, deflate");
myRequest.AllowAutoRedirect = false;
myRequest.KeepAlive = false;
myRequest.ProtocolVersion = HttpVersion.Version11;
myRequest.Timeout = -1;
myRequest.ReadWriteTimeout = 10000;
myRequest.Proxy = null;
myRequest.ServicePoint.ConnectionLimit = 1000000;
//=============================================================
// PASAR POST
//=============================================================
using (var stream = myRequest.GetRequestStream())
{
stream.Write(data, 0, data.Length);
}
//=============================================================
// RESCATO VALORES ==
//=============================================================
JsonReturn = "";
using (var resp = (HttpWebResponse)myRequest.GetResponse())
{
using (Stream Str = resp.GetResponseStream())
{
Stream Compresion = Str;
if (resp.ContentEncoding.ToLower().Contains("gzip"))
{
Compresion = new GZipStream(Compresion, CompressionMode.Decompress);
}
else
{
if (resp.ContentEncoding.ToLower().Contains("deflate"))
{
Compresion = new DeflateStream(Compresion, CompressionMode.Decompress);
}
}
StreamReader rd = new StreamReader(Compresion);
JsonReturn = rd.ReadToEnd();
Str.Close();
}
resp.Close();
}
myRequest = null;
//=============================================================
// SE DEBE DESERIALIZAR RESULTADOS ==
//=============================================================
using (UObjetoJson ObjetoRetorno = new UObjetoJson())
{
Retorno = ObjetoRetorno.Deserialize <RETURN_JSON_APL>(JsonReturn);
}
ESTADO = Retorno.HEADER.ESTADO;
if (ESTADO == 1)
{
Mensaje Objeto = Retorno.RESULT_HTTP.DETALLES;
Console.WriteLine(Objeto.MSG);
}
else
{
throw new Exception(Retorno.ERRORES.Mensaje);
}
}
catch
{
throw;
}
}
/// <summary>
/// DESCARGAR ARCHIVO
/// </summary>
/// <param name="URL"></param>
/// <param name="ObjetoInput"></param>
/// <returns></returns>
public void DownloadFile(string URL, INPUT_FTP_JSON_ALO ObjetoInput)
{
try
{
//=============================================================
// DECLARACION DE VARIABLES
//=============================================================
string Json;
using (UObjetoJson ObjetoParametros = new UObjetoJson())
{
Json = ObjetoParametros.Serialize(ObjetoInput);
}
//=============================================================
// DATOS JSON EN URL
//=============================================================
Json = "json=" + Json;
byte[] data = Encoding.ASCII.GetBytes(Json);
//=============================================================
// VERIFICAR CARPETA
//=============================================================
if (Directory.Exists(ObjetoInput.R_FILE_LOCAL.RUTA) == false)
{
throw new Exception("RUTA DE CARPETA NO EXISTE");
}
//=============================================================
// COMBINAR RUTAS
//=============================================================
string[] paths = { ObjetoInput.R_FILE_LOCAL.RUTA, ObjetoInput.R_FILE_LOCAL.FILE };
string LocalFilename = Path.Combine(paths);
//=============================================================
// DECLARACION DE VARIABLES
//=============================================================
Stream LocalStream = null;
int BytesProcessed = 0;
//=============================================================
// SERVICIO RESTFUL
//=============================================================
HttpWebRequest myRequest = (HttpWebRequest)WebRequest.Create(URL);
myRequest.Method = "POST";
myRequest.ContentType = "application/x-www-form-urlencoded";
myRequest.ContentLength = data.Length;
myRequest.Accept = "application/json";
myRequest.AllowAutoRedirect = false;
myRequest.KeepAlive = false;
myRequest.ProtocolVersion = HttpVersion.Version11;
myRequest.Timeout = -1;
myRequest.ReadWriteTimeout = 10000;
myRequest.Proxy = null;
myRequest.ServicePoint.ConnectionLimit = 1000000;
//=============================================================
// PASAR POST
//=============================================================
using (var stream = myRequest.GetRequestStream())
{
stream.Write(data, 0, data.Length);
}
//=============================================================
// RESCATO VALORES ==
//=============================================================
using (HttpWebResponse resp = (HttpWebResponse)myRequest.GetResponse())
{
Stream RemoteStream = resp.GetResponseStream();
LocalStream = File.Create(LocalFilename);
byte[] buffer = new byte[1024];
int bytesRead;
do
{
bytesRead = RemoteStream.Read(buffer, 0, buffer.Length);
LocalStream.Write(buffer, 0, bytesRead);
BytesProcessed += bytesRead;
} while (bytesRead > 0);
LocalStream.Close();
RemoteStream.Close();
resp.Close();
}
myRequest = null;
}
catch
{
throw;
}
}
/// <summary>
/// ELIMINAR ARCHIVO FTP
/// </summary>
/// <param name="URL"></param>
/// <param name="ObjetoInput"></param>
public void DeleteFile(string URL, INPUT_FTP_JSON_ALO ObjetoInput)
{
try
{
//=============================================================
// DECLARACION DE VARIABLES
//=============================================================
string JsonReturn;
RETURN_JSON_APL Retorno = new RETURN_JSON_APL();
int ESTADO = 0;
//=============================================================
// SI EXISTE TOKEN ENTONCES DEBEMOS INVOKAR EL SEGUNDO
// METODO CON LOS PARAMETROS
//=============================================================
string Json;
using (UObjetoJson ObjetoParametros = new UObjetoJson())
{
Json = ObjetoParametros.Serialize(ObjetoInput);
}
//=============================================================
// DATOS JSON EN URL ==
//=============================================================
Json = "json=" + Json;
byte[] data = Encoding.ASCII.GetBytes(Json);
//=============================================================
// SERVICIO RESTFUL ==
//=============================================================
HttpWebRequest myRequest = (HttpWebRequest)WebRequest.Create(URL);
myRequest.Method = "POST";
myRequest.ContentType = "application/x-www-form-urlencoded";
myRequest.ContentLength = data.Length;
myRequest.Accept = "application/json";
myRequest.Headers.Add(HttpRequestHeader.AcceptEncoding, "gzip, deflate");
myRequest.AllowAutoRedirect = false;
myRequest.KeepAlive = false;
myRequest.ProtocolVersion = HttpVersion.Version11;
myRequest.Timeout = -1;
myRequest.ReadWriteTimeout = 10000;
myRequest.Proxy = null;
myRequest.ServicePoint.ConnectionLimit = 1000000;
//=============================================================
// PASAR POST
//=============================================================
using (var stream = myRequest.GetRequestStream())
{
stream.Write(data, 0, data.Length);
}
//=============================================================
// RESCATO VALORES ==
//=============================================================
JsonReturn = "";
using (var resp = (HttpWebResponse)myRequest.GetResponse())
{
using (Stream Str = resp.GetResponseStream())
{
Stream Compresion = Str;
if (resp.ContentEncoding.ToLower().Contains("gzip"))
{
Compresion = new GZipStream(Compresion, CompressionMode.Decompress);
}
else
{
if (resp.ContentEncoding.ToLower().Contains("deflate"))
{
Compresion = new DeflateStream(Compresion, CompressionMode.Decompress);
}
}
StreamReader rd = new StreamReader(Compresion);
JsonReturn = rd.ReadToEnd();
Str.Close();
}
resp.Close();
}
myRequest = null;
//=============================================================
// SE DEBE DESERIALIZAR RESULTADOS ==
//=============================================================
using (UObjetoJson ObjetoRetorno = new UObjetoJson())
{
Retorno = ObjetoRetorno.Deserialize <RETURN_JSON_APL>(JsonReturn);
}
ESTADO = Retorno.HEADER.ESTADO;
if (ESTADO == 1)
{
Mensaje Objeto = Retorno.RESULT_HTTP.DETALLES;
Console.WriteLine(Objeto.MSG);
}
else
{
throw new Exception(Retorno.ERRORES.Mensaje);
}
}
catch
{
throw;
}
}
