/// <summary>
/// ELIMINAR SP
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void BTN_ELIMINA_Click(object sender, EventArgs e)
{
try
{
//===========================================================
// DECLARACION DE VARIABLES
//===========================================================
SMetodos Servicio = new SMetodos();
//===========================================================
// PARAMETROS
//===========================================================
iSP_DELETE_GRUPO_X_LOGIN ParametrosInput = new iSP_DELETE_GRUPO_X_LOGIN();
ParametrosInput.ID_GRUPO = Convert.ToInt32(TXT_ID_ELIMINA_1.Text);
ParametrosInput.NRO_USUARIO = Convert.ToInt32(TXT_ID_ELIMINA_2.Text);
//===========================================================
// LLAMADA A SERVICIO
//===========================================================
oSP_RETURN_STATUS ObjetoRest = Servicio.SP_DELETE_GRUPO_X_LOGIN(ParametrosInput);
if (ObjetoRest.RETURN_VALUE == 0)
{
MensajeLOGEdit("A", "ELIMINACION DE LOGIN NO FUE REALIZADA", "MSG_INFO_ELIMINA", "MSG_ALERTA_ELIMINA");
return;
}
if (ObjetoRest.RETURN_VALUE == 1)
{
MensajeLOGEdit("I", "ELIMINACION DE LOGIN FUE REALIZADA CORRECTAMANTE", "MSG_INFO_ELIMINA", "MSG_ALERTA_ELIMINA");
LEER_USUARIO(Convert.ToInt32(TXT_ID_ELIMINA_1.Text));
return;
}
}
catch (EServiceRestFulException srv)
{
MensajeLOGEdit("A", srv.Message, "MSG_INFO_ELIMINA", "MSG_ALERTA_ELIMINA");
}
catch (System.Exception ex)
{
MensajeLOGEdit("A", UThrowError.MensajeThrow(ex), "MSG_INFO_ELIMINA", "MSG_ALERTA_ELIMINA");
}
}
/// <summary>
/// ACTUALIZA EL CAMPO DE LA GRILLA MULTICHECKED
/// </summary>
/// <param name="Input"></param>
/// <returns></returns>
public oSP_RETURN_STATUS SP_UPDATE_FORMULARIO_X_OBJETO_MULTICHECKED(iSP_UPDATE_FORMULARIO_X_OBJETO_MULTICHECKED Input)
{
oSP_RETURN_STATUS ObjetoRest = new oSP_RETURN_STATUS();
try
{
//===========================================================
// SERVICIO REST
//===========================================================
using (SRestFul Servicio = new SRestFul())
{
//=======================================================
// LLAMADA DEL SERVICIO
//=======================================================
int ESTADO = Servicio.Solicitar <oSP_RETURN_STATUS>("SP_UPDATE_FORMULARIO_X_OBJETO_MULTICHECKED", SISTEMA, Input, new object());
//=======================================================
// EVALUACIÓN DE CABEZERA
//=======================================================
if (ESTADO == 1)
{
ObjetoRest = (oSP_RETURN_STATUS)Servicio.ObjetoRest;
}
else
{
ErroresException Error = (ErroresException)Servicio.ObjetoRest;
throw new EServiceRestFulException(UThrowError.MensajeThrow(Error));
}
}
return(ObjetoRest);
}
catch
{
throw;
}
}
/// <summary>
/// LECTURA DE METODO REST
/// </summary>
/// <param name="Input"></param>
/// <returns></returns>
public oSP_RETURN_STATUS SP_CREATE_FIFO_INTERFAZ_DIS_X_PROCESO(iSP_CREATE_FIFO_INTERFAZ_DIS_X_PROCESO Input)
{
oSP_RETURN_STATUS ObjetoRest = new oSP_RETURN_STATUS();
try
{
//===========================================================
// SERVICIO
//===========================================================
using (SRestFul Servicio = new SRestFul(C_URL))
{
//===========================================================
// LLAMADA DEL SERVICIO
//===========================================================
int ESTADO = Servicio.SolicitarWCFPost <oSP_RETURN_STATUS>("SP_CREATE_FIFO_INTERFAZ_DIS_X_PROCESO", SISTEMA, Input, new object());
if (ESTADO == 1)
{
ObjetoRest = (oSP_RETURN_STATUS)Servicio.ObjetoRest;
}
else
{
ErroresException Error = (ErroresException)Servicio.ObjetoRest;
throw new EServiceRestFulException(UThrowError.MensajeThrow(Error, C_RUTA_XSLT));
}
}
return(ObjetoRest);
}
catch
{
throw;
}
}
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>
/// LEVANTA MODAL PARA CREAR NUEVO GRUPO DE CARGA
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void BTN_GRUPO_CARGA_Click(object sender, EventArgs e)
{
try
{
//===========================================================
// DECLARACION DE VARIABLES
//===========================================================
SMetodos Servicio = new SMetodos();
int ID_CLUSTER = 0;
string DESCRIPCION = "";
string LLAVE_EXPLOTACION = "";
string LLAVE_NOTIFICACION = "";
string LLAVE_VERIFICACION = "";
//===========================================================
// VALIDACION DE SELECCION DE CAMPANA
//===========================================================
if (DDL_SELECT_CLUSTER.Items.Count > 0)
{
ID_CLUSTER = Convert.ToInt32(DDL_SELECT_CLUSTER.SelectedValue);
}
else
{
MensajeLOGEdit("A", "DEBES SELECCIONAR UNA CLUSTER", "MSG_INFO_GRUPO_CARGA", "MSG_ALERTA_GRUPO_CARGA");
return;
}
//===========================================================
// VALIDACION DE DESCRIPCION
//===========================================================
if (!string.IsNullOrWhiteSpace(TXT_DESCRIPCION.Text))
{
DESCRIPCION = TXT_DESCRIPCION.Text;
}
else
{
MensajeLOGEdit("A", "DEBES INGRESAR UNA DESCRIPCION", "MSG_INFO_GRUPO_CARGA", "MSG_ALERTA_GRUPO_CARGA");
return;
}
//===========================================================
// VALIDACION DE LLAVE DE LISTA PARA EXPLOTACION
//===========================================================
if (!string.IsNullOrWhiteSpace(TXT_LLAVE_EXPLOTACION.Text))
{
LLAVE_EXPLOTACION = TXT_LLAVE_EXPLOTACION.Text;
}
else
{
MensajeLOGEdit("A", "DEBES INGRESAR UNA LLAVE PARA LA LISTA DE EXPLOTACIÓN", "MSG_INFO_GRUPO_CARGA", "MSG_ALERTA_GRUPO_CARGA");
return;
}
//===========================================================
// VALIDACION DE LLAVE DE LISTA PARA NOTIFICACION
//===========================================================
if (!string.IsNullOrWhiteSpace(TXT_LLAVE_NOTIFICACION.Text))
{
LLAVE_NOTIFICACION = TXT_LLAVE_NOTIFICACION.Text;
}
else
{
MensajeLOGEdit("A", "DEBES INGRESAR UNA LLAVE PARA LA LISTA DE NOTIFICACIÓN", "MSG_INFO_GRUPO_CARGA", "MSG_ALERTA_GRUPO_CARGA");
return;
}
//===========================================================
// VALIDACION DE LLAVE DE LISTA PARA VERIFICACION
//===========================================================
if (!string.IsNullOrWhiteSpace(TXT_LLAVE_VERIFICACION.Text))
{
LLAVE_VERIFICACION = TXT_LLAVE_VERIFICACION.Text;
}
else
{
MensajeLOGEdit("A", "DEBES INGRESAR UNA LLAVE PARA LA LISTA DE VERIFICACIÓN", "MSG_INFO_GRUPO_CARGA", "MSG_ALERTA_GRUPO_CARGA");
return;
}
if (Convert.ToInt32(TXT_ID_GRUPO_CARGA_MODAL.Text) == 0)
{
//=======================================================
// CONSTRUCCION DE OBJETO
//=======================================================
iSP_CREATE_GRUPO_CARGA ParametrosInput = new iSP_CREATE_GRUPO_CARGA();
ParametrosInput.ID_CLUSTER = ID_CLUSTER;
ParametrosInput.DESCRIPCION = DESCRIPCION;
ParametrosInput.LLAVE_LISTA_EXPLOTADOR = LLAVE_EXPLOTACION;
ParametrosInput.LLAVE_LISTA_NOTIFICACION = LLAVE_NOTIFICACION;
ParametrosInput.LLAVE_LISTA_VERIFICACION = LLAVE_VERIFICACION;
//=======================================================
// LLAMADA A SERVICIO
//=======================================================
oSP_CREATE_GRUPO_CARGA GRUPO_CARGA = Servicio.SP_CREATE_GRUPO_CARGA(ParametrosInput);
if (GRUPO_CARGA.ID_GRUPO_CARGA == -1)
{
MensajeLOGEdit("A", "EL GRUPO DE CARGA YA SE ENCUENTRA EN EL SISTEMA", "MSG_INFO_GRUPO_CARGA", "MSG_ALERTA_GRUPO_CARGA");
return;
}
if (GRUPO_CARGA.ID_GRUPO_CARGA == 0)
{
MensajeLOGEdit("A", "EL GRUPO DE CARGA NO FUE INGRESADO", "MSG_INFO_GRUPO_CARGA", "MSG_ALERTA_GRUPO_CARGA");
return;
}
if (GRUPO_CARGA.ID_GRUPO_CARGA > 0)
{
MensajeLOGEdit("I", "EL GRUPO DE CARGA FUE INGRESADO CORRECTAMENTE", "MSG_INFO_GRUPO_CARGA", "MSG_ALERTA_GRUPO_CARGA");
LEER_GRUPO_CARGA(ID_CLUSTER);
LEER_DETALLE_GRUPO_CARGA(GRUPO_CARGA.ID_GRUPO_CARGA);
return;
}
}
if (Convert.ToInt32(TXT_ID_GRUPO_CARGA_MODAL.Text) > 0)
{
int ID_GRUPO_CARGA = Convert.ToInt32(TXT_ID_GRUPO_CARGA_MODAL.Text);
//=======================================================
// CONSTRUCCION DE OBJETO
//=======================================================
iSP_UPDATE_GRUPO_CARGA ParametrosInput = new iSP_UPDATE_GRUPO_CARGA();
ParametrosInput.ID_GRUPO_CARGA = ID_GRUPO_CARGA;
ParametrosInput.ID_CLUSTER = ID_CLUSTER;
ParametrosInput.DESCRIPCION = DESCRIPCION;
ParametrosInput.LLAVE_LISTA_EXPLOTADOR = LLAVE_EXPLOTACION;
ParametrosInput.LLAVE_LISTA_NOTIFICACION = LLAVE_NOTIFICACION;
ParametrosInput.LLAVE_LISTA_VERIFICACION = LLAVE_VERIFICACION;
//=======================================================
// LLAMADA A SERVICIO
//=======================================================
oSP_RETURN_STATUS ESTADO = Servicio.SP_UPDATE_GRUPO_CARGA(ParametrosInput);
if (ESTADO.RETURN_VALUE == -1)
{
MensajeLOGEdit("A", "EL GRUPO DE CARGA YA SE ENCUENTRA EN EL SISTEMA", "MSG_INFO_GRUPO_CARGA", "MSG_ALERTA_GRUPO_CARGA");
return;
}
if (ESTADO.RETURN_VALUE == 0)
{
MensajeLOGEdit("A", "EL GRUPO DE CARGA NO FUE INGRESADO", "MSG_INFO_GRUPO_CARGA", "MSG_ALERTA_GRUPO_CARGA");
return;
}
if (ESTADO.RETURN_VALUE == 1)
{
MensajeLOGEdit("I", "EL GRUPO DE CARGA FUE ACTUALIZADO CORRECTAMENTE", "MSG_INFO_GRUPO_CARGA", "MSG_ALERTA_GRUPO_CARGA");
LEER_GRUPO_CARGA(ID_CLUSTER);
LEER_DETALLE_GRUPO_CARGA(ID_GRUPO_CARGA);
return;
}
}
}
catch (EServiceRestFulException srv)
{
MensajeLOG(srv.Message, "ERRORES DE SERVICIO");
}
catch (System.Exception ex)
{
MensajeLOGEdit("A", UThrowError.MensajeThrow(ex), "MSG_INFO_GRUPO_CARGA", "MSG_ALERTA_GRUPO_CARGA");
//MensajeLOG(UThrowError.MensajeThrow(ex), "ERRORES DE APLICACIÓN");
}
}
/// <summary>
/// ELIMINA FILTRO DE ASIGNACION
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void BTN_ELIMINA_OBJETO_X_INTERFAZ_Click(object sender, EventArgs e)
{
try
{
//=====================================================================
// DECLARACION DE VARIABLES
//=====================================================================
SMetodos Servicio = new SMetodos();
int ID_OBJETO_X_INTERFAZ = 0;
int ID_INTERFAZ = 0;
//===========================================================
// VALIDACION DE SELECCION DE INTERFAZ
//===========================================================
if (Convert.ToInt32(DDL_INTERFAZ.SelectedValue) == 0)
{
MensajeLOGEdit("A", "DEBES SELECCIONAR UNA INTERFAZ", "MSG_INFO_ELIMINA_OBJETO_X_INTERFAZ", "MSG_ALERTA_ELIMINA_OBJETO_X_INTERFAZ");
return;
}
else
{
ID_INTERFAZ = Convert.ToInt32(DDL_INTERFAZ.SelectedValue);
}
//===========================================================
// VALIDACION DE CONVERSION
//===========================================================
try
{
ID_OBJETO_X_INTERFAZ = Convert.ToInt32(TXT_ID_ELIMINA_OBJETO_X_INTERFAZ.Text);
}
catch
{
MensajeLOGEdit("A", "EL OBJETO NO ES VALIDO", "MSG_INFO_ELIMINA_OBJETO_X_INTERFAZ", "MSG_ALERTA_ELIMINA_OBJETO_X_INTERFAZ");
return;
}
//=====================================================================
// CREACION DE OBJETO
//=====================================================================
iSP_DELETE_OBJETO_INTERFAZ parametrosInput = new iSP_DELETE_OBJETO_INTERFAZ();
parametrosInput.ID_OBJETO_X_INTERFAZ = ID_OBJETO_X_INTERFAZ;
//=====================================================================
// LLAMADA A SERVICIO
//=====================================================================
oSP_RETURN_STATUS ESTADO = Servicio.SP_DELETE_OBJETO_INTERFAZ(parametrosInput);
if (ESTADO.RETURN_VALUE == 0)
{
MensajeLOGEdit("A", "EL OBJETO NO FUE ELIMINADO", "MSG_INFO_ELIMINA_OBJETO_X_INTERFAZ", "MSG_ALERTA_ELIMINA_OBJETO_X_INTERFAZ");
return;
}
if (ESTADO.RETURN_VALUE == 1)
{
MensajeLOGEdit("I", "EL OBJETO FUE ELIMINADO CORRECTAMENTE", "MSG_INFO_ELIMINA_OBJETO_X_INTERFAZ", "MSG_ALERTA_ELIMINA_OBJETO_X_INTERFAZ");
LEER_OBJETOS_X_INTERFAZ(ID_INTERFAZ);
CARGAR_GRILLA_OBJETO_X_INTERFAZ();
return;
}
}
catch (EServiceRestFulException svr)
{
MensajeLOGEdit("A", svr.Message, "MSG_INFO_ELIMINA_OBJETO_X_INTERFAZ", "MSG_ALERTA_ELIMINA_OBJETO_X_INTERFAZ");
}
catch (System.Exception ex)
{
MensajeLOGEdit("A", UThrowError.MensajeThrow(ex), "MSG_INFO_ELIMINA_OBJETO_X_INTERFAZ", "MSG_ALERTA_ELIMINA_OBJETO_X_INTERFAZ");
}
}
/// <summary>
/// CREA UN NUEVA ASIGNACION DE OBJETOS
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void BTN_OBJETO_X_INTERFAZ_Click(object sender, EventArgs e)
{
try
{
//===========================================================
// DECLARACION DE VARIABLES
//===========================================================
SMetodos Servicio = new SMetodos();
int ID_INTERFAZ = 0;
int ID_OBJETO = 0;
string VALOR = "";
//===========================================================
// VALIDACION DE SELECCION DE PAIS
//===========================================================
if (Convert.ToInt32(DDL_INTERFAZ.SelectedValue) == 0)
{
MensajeLOGEdit("A", "DEBES SELECCIONAR UNA INTERFAZ", "MSG_INFO_OBJETO_X_INTERFAZ", "MSG_ALERTA_OBJETO_X_INTERFAZ");
return;
}
else
{
ID_INTERFAZ = Convert.ToInt32(DDL_INTERFAZ.SelectedValue);
}
//===========================================================
// VALIDACION DE SELECCION DE OBJETOS
//===========================================================
if (Convert.ToInt32(DDL_OBJETOS.SelectedValue) == 0)
{
MensajeLOGEdit("A", "DEBES SELECCIONAR UN OBJETO", "MSG_INFO_OBJETO_X_INTERFAZ", "MSG_ALERTA_OBJETO_X_INTERFAZ");
return;
}
else
{
ID_OBJETO = Convert.ToInt32(DDL_OBJETOS.SelectedValue);
}
//===========================================================
// VALIDACION DE INGRESO DE DE VALOR
//===========================================================
if (string.IsNullOrWhiteSpace(TXT_VALOR.Text))
{
MensajeLOGEdit("A", "DEBES INGRESAR UN VALOR PARA EL OBJETO", "MSG_INFO_OBJETO_X_INTERFAZ", "MSG_ALERTA_OBJETO_X_INTERFAZ");
return;
}
else
{
VALOR = TXT_VALOR.Text;
}
//===========================================================
// INGRESAR ASIGNACION DE OBJETOS
//===========================================================
if (Convert.ToInt32(TXT_ID_OBJETO.Text) == 0)
{
//===========================================================
// CONSTRUCCION DE OBJETO
//===========================================================
iSP_CREATE_OBJETO_X_INTERFAZ parametrosInput = new iSP_CREATE_OBJETO_X_INTERFAZ();
parametrosInput.ID_INTERFAZ = ID_INTERFAZ;
parametrosInput.ID_OBJETO = ID_OBJETO;
parametrosInput.VALOR = VALOR;
//===========================================================
// LLAMADA A SERVICIO
//===========================================================
oSP_RETURN_STATUS ESTADO = Servicio.SP_CREATE_OBJETO_X_INTERFAZ(parametrosInput);
//===========================================================
// RESPUESTA
//===========================================================
if (ESTADO.RETURN_VALUE == -1)
{
MensajeLOGEdit("A", "EL OBJETO YA EXISTE", "MSG_INFO_OBJETO_X_INTERFAZ", "MSG_ALERTA_OBJETO_X_INTERFAZ");
return;
}
if (ESTADO.RETURN_VALUE == 0)
{
MensajeLOGEdit("A", "EL OBJETO NO FUE INGRESADO", "MSG_INFO_OBJETO_X_INTERFAZ", "MSG_ALERTA_OBJETO_X_INTERFAZ");
return;
}
if (ESTADO.RETURN_VALUE == 1)
{
MensajeLOGEdit("I", "EL OBJETO FUE INGRESADO CORRECTAMENTE", "MSG_INFO_OBJETO_X_INTERFAZ", "MSG_ALERTA_OBJETO_X_INTERFAZ");
LEER_OBJETOS_X_INTERFAZ(ID_INTERFAZ);
CARGAR_GRILLA_OBJETO_X_INTERFAZ();
return;
}
}
if (Convert.ToInt32(TXT_ID_OBJETO.Text) > 0)
{
//===========================================================
// CONSTRUCCION DE OBJETO
//===========================================================
iSP_UPDATE_OBJETO_X_INTERFAZ parametrosInput = new iSP_UPDATE_OBJETO_X_INTERFAZ();
parametrosInput.ID_OBJETO_X_INTERFAZ = Convert.ToInt32(TXT_ID_OBJETO.Text);
parametrosInput.ID_OBJETO = ID_OBJETO;
parametrosInput.VALOR = VALOR;
//===========================================================
// LLAMADA A SERVICIO
//===========================================================
oSP_RETURN_STATUS ESTADO = Servicio.SP_UPDATE_OBJETO_X_INTERFAZ(parametrosInput);
//===========================================================
// RESPUESTA
//===========================================================
if (ESTADO.RETURN_VALUE == -1)
{
MensajeLOGEdit("A", "EL OBJETO YA EXISTE", "MSG_INFO_OBJETO_X_INTERFAZ", "MSG_ALERTA_OBJETO_X_INTERFAZ");
return;
}
if (ESTADO.RETURN_VALUE == 0)
{
MensajeLOGEdit("A", "EL OBJETO NO FUE ACTUALIZADO", "MSG_INFO_OBJETO_X_INTERFAZ", "MSG_ALERTA_OBJETO_X_INTERFAZ");
return;
}
if (ESTADO.RETURN_VALUE == 1)
{
MensajeLOGEdit("I", "EL OBJETO FUE ACTUALIZADO CORRECTAMENTE", "MSG_INFO_OBJETO_X_INTERFAZ", "MSG_ALERTA_OBJETO_X_INTERFAZ");
LEER_OBJETOS_X_INTERFAZ(ID_INTERFAZ);
CARGAR_GRILLA_OBJETO_X_INTERFAZ();
return;
}
}
}
catch (EServiceRestFulException svr)
{
MensajeLOGEdit("A", svr.Message, "MSG_INFO_OBJETO_X_INTERFAZ", "MSG_ALERTA_OBJETO_X_INTERFAZ");
}
catch (System.Exception ex)
{
MensajeLOGEdit("A", UThrowError.MensajeThrow(ex), "MSG_INFO_OBJETO_X_INTERFAZ", "MSG_ALERTA_OBJETO_X_INTERFAZ");
}
}
/// <summary>
/// ACTUALIZAR O INGRESAR INFORMACION DE GRUPOS
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void BTN_EditGrilla_Click(object sender, EventArgs e)
{
try
{
//===========================================================
// DECLARACION DE VARIABLES
//===========================================================
string LOGIN = "";
int ID_GRUPO = 0;
SMetodos Servicio = new SMetodos();
//===========================================================
// VALIDACION DE OBSERVACION
//===========================================================
if (string.IsNullOrEmpty(TXT_LOGIN.Text))
{
throw new Exception("DEBE INGRESAR UN LOGIN");
}
//===========================================================
// ASIGNACION
//===========================================================
LOGIN = TXT_LOGIN.Text;
//===========================================================
// VALIDACION DE OBSERVACION
//===========================================================
if (string.IsNullOrEmpty(TXT_ID.Text))
{
throw new Exception("NO EXISTE ID VALIDO PARA CREAR Y TAMPOCO ACTUALIZAR");
}
//===========================================================
// ID ASIGNADO
//===========================================================
try
{
ID_GRUPO = Convert.ToInt32(TXT_ID.Text);
}
catch
{
throw new Exception("ID ENVIADO NO ES UN NUMERO VALIDO");
}
//===========================================================
// CONSTRUCCION DE OBJETO
//===========================================================
iSP_VALIDA_EXISTE_USUARIO ParametrosInputValida = new iSP_VALIDA_EXISTE_USUARIO();
ParametrosInputValida.LOGIN = LOGIN;
//===========================================================
// LLAMADA ASERVICIO
//===========================================================
List <oSP_VALIDA_EXISTE_USUARIO> LST_LOGIN = Servicio.SP_VALIDA_EXISTE_USUARIO(ParametrosInputValida);
//===========================================================
// VALIDACION DE LISTA
//===========================================================
if (LST_LOGIN == null || LST_LOGIN.Count <= 0)
{
MensajeLOGEdit("A", "EL LOGIN NO ES VALIDO", "MSG_GRUPO_INFO", "MSG_GRUPO_Alerta");
return;
}
//===========================================================
// INGRESAR
//===========================================================
iSP_CREATE_GRUPO_X_LOGIN ParametrosInput = new iSP_CREATE_GRUPO_X_LOGIN();
ParametrosInput.ID_GRUPO = ID_GRUPO;
ParametrosInput.NRO_USUARIO = LST_LOGIN.First().ID_USUARIO;
ParametrosInput.NOMBRE = LST_LOGIN.First().NOMBRE;
//===========================================================
// LLAMADA A SERVICIO
//===========================================================
oSP_RETURN_STATUS ESTADO = Servicio.SP_CREATE_GRUPO_X_LOGIN(ParametrosInput);
if (ESTADO.RETURN_VALUE == 1)
{
MensajeLOGEdit("I", "LOGIN FUE INGRESADO CORRECTAMANTE", "MSG_GRUPO_INFO", "MSG_GRUPO_Alerta");
LEER_USUARIO(ID_GRUPO);
return;
}
if (ESTADO.RETURN_VALUE == 0)
{
MensajeLOGEdit("A", "LOGIN NO FUE ACTUALIZADO", "MSG_GRUPO_INFO", "MSG_GRUPO_Alerta");
return;
}
if (ESTADO.RETURN_VALUE == -1)
{
MensajeLOGEdit("A", "LOGIN YA ESTA INGRESADO", "MSG_GRUPO_INFO", "MSG_GRUPO_Alerta");
return;
}
}
catch (EServiceRestFulException srv)
{
MensajeLOGEdit("A", srv.Message, "MSG_GRUPO_INFO", "MSG_GRUPO_Alerta");
}
catch (System.Exception ex)
{
MensajeLOGEdit("A", UThrowError.MensajeThrow(ex), "MSG_GRUPO_INFO", "MSG_GRUPO_Alerta");
}
}
/// <summary>
/// ACTUALIZAR
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void BTN_EditGrilla_Click(object sender, EventArgs e)
{
try
{
//===========================================================
// DECLARACION DE VARIABLES
//===========================================================
int ID_CLUSTER = 0;
int ID_PAIS = 0;
string CODIGO = "";
string DESCRIPCION = "";
bool ESTADO_CLUSTER = false;
SMetodos Servicio = new SMetodos();
//===========================================================
// VALIDACION DE OBSERVACION
//===========================================================
if (string.IsNullOrEmpty(TXT_ID.Text))
{
throw new Exception("NO EXISTE ID VALIDO PARA CREAR Y TAMPOCO ACTUALIZAR");
}
else
{
try
{
ID_CLUSTER = Convert.ToInt32(TXT_ID.Text);
}
catch
{
throw new Exception("ID ESPECIFICADO NO ES UN NUMERO VALIDO");
}
}
//===========================================================
// CODIGO
//===========================================================
if (ID_CLUSTER > 0)
{
if (CHK_OPCION.Checked == true)
{
if (string.IsNullOrEmpty(TXT_CODIGO.Text))
{
throw new Exception("NO EXISTE CODIGO VALIDO PARA CREAR Y TAMPOCO ACTUALIZAR");
}
else
{
CODIGO = TXT_CODIGO.Text;
}
}
}
else
{
if (string.IsNullOrEmpty(TXT_CODIGO.Text))
{
throw new Exception("NO EXISTE CODIGO VALIDO PARA CREAR Y TAMPOCO ACTUALIZAR");
}
else
{
CODIGO = TXT_CODIGO.Text;
}
}
//===========================================================
// VALIDACION DE OBSERVACION
//===========================================================
if (string.IsNullOrEmpty(TXT_DESCRIPCION.Text))
{
throw new Exception("DEBE INGRESAR UNA DESCRIPCION");
}
else
{
DESCRIPCION = TXT_DESCRIPCION.Text;
}
//===========================================================
// ESTADO
//===========================================================
ESTADO_CLUSTER = CHK_ESTADO.Checked;
//===========================================================
// PAIS
//===========================================================
if (DDL_PAIS.Items.Count > 0)
{
ID_PAIS = Convert.ToInt32(DDL_PAIS.SelectedValue);
}
else
{
throw new Exception("NO EXISTEN PAIS EN LISTA");
}
//===========================================================
// VER SI ACTUALIZAMOS O INGRESAMOS
//===========================================================
if (ID_CLUSTER == 0)
{
iSP_CREATE_CLUSTER ParametrosInput = new iSP_CREATE_CLUSTER();
ParametrosInput.ID_PAIS = ID_PAIS;
ParametrosInput.CODIGO = CODIGO;
ParametrosInput.DESCRIPCION = DESCRIPCION;
ParametrosInput.ESTADO = ESTADO_CLUSTER;
//=======================================================
// LLAMADA A SERVICIO
//=======================================================
oSP_RETURN_STATUS ESTADO = Servicio.SP_CREATE_CLUSTER(ParametrosInput);
if (ESTADO.RETURN_VALUE == 1)
{
MensajeLOGEdit("I", "CLUSTER FUE CREADO CORRECTAMANTE", "MSG_CLUSTER_INFO", "MSG_CLUSTER_ALERTA");
LEER_CLUSTER();
return;
}
if (ESTADO.RETURN_VALUE == -1)
{
MensajeLOGEdit("A", "CÓDIGO DE CLUSTER YA EXISTE EN SISTEMA", "MSG_CLUSTER_INFO", "MSG_CLUSTER_ALERTA");
return;
}
if (ESTADO.RETURN_VALUE == 0)
{
MensajeLOGEdit("A", "CLUSTER NO FUE ACTUALIZADO", "MSG_CLUSTER_INFO", "MSG_CLUSTER_ALERTA");
return;
}
}
else
{
iSP_UPDATE_CLUSTER ParametrosInput = new iSP_UPDATE_CLUSTER();
ParametrosInput.ID_CLUSTER = ID_CLUSTER;
ParametrosInput.ID_PAIS = ID_PAIS;
ParametrosInput.CODIGO = CODIGO;
ParametrosInput.DESCRIPCION = DESCRIPCION;
ParametrosInput.ESTADO = ESTADO_CLUSTER;
ParametrosInput.OPCION = CHK_OPCION.Checked;
//=======================================================
// LLAMADA A SERVICIO
//=======================================================
oSP_RETURN_STATUS ESTADO = Servicio.SP_UPDATE_CLUSTER(ParametrosInput);
if (ESTADO.RETURN_VALUE == 1)
{
MensajeLOGEdit("I", "CLUSTER FUE ACTUALIZADO CORRECTAMANTE", "MSG_CLUSTER_INFO", "MSG_CLUSTER_ALERTA");
LEER_CLUSTER();
return;
}
if (ESTADO.RETURN_VALUE == -1)
{
MensajeLOGEdit("A", "YA EXISTE CLÚSTER CON ESE CÓDIGO", "MSG_CLUSTER_INFO", "MSG_CLUSTER_ALERTA");
LEER_CLUSTER();
return;
}
if (ESTADO.RETURN_VALUE == 0)
{
MensajeLOGEdit("A", "CLUSTER NO FUE ACTUALIZADO", "MSG_CLUSTER_INFO", "MSG_CLUSTER_ALERTA");
return;
}
}
}
catch (EServiceRestFulException srv)
{
MensajeLOGEdit("A", srv.Message, "MSG_CLUSTER_INFO", "MSG_CLUSTER_ALERTA");
}
catch (System.Exception ex)
{
MensajeLOGEdit("A", UThrowError.MensajeThrow(ex), "MSG_CLUSTER_INFO", "MSG_CLUSTER_ALERTA");
}
}
/// <summary>
/// ACTUALIZAR O INGRESAR INFORMACION DE GRUPOS
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void BTN_EditGrilla_Click(object sender, EventArgs e)
{
try
{
//===========================================================
// DECLARACION DE VARIABLES
//===========================================================
string DESCRIPCION = "";
bool ESTADO_GRUPO = false;
int ID_GRUPO = 0;
SMetodos Servicio = new SMetodos();
oSP_RETURN_STATUS ObjetoRest = new oSP_RETURN_STATUS();
//===========================================================
// VALIDACION DE OBSERVACION
//===========================================================
if (string.IsNullOrEmpty(TXT_DESCRIPCION.Text))
{
throw new Exception("DEBE INGRESAR UNA OBSERVACION");
}
//===========================================================
// ASIGNACION
//===========================================================
ESTADO_GRUPO = CHK_ESTADO.Checked;
DESCRIPCION = TXT_DESCRIPCION.Text;
//===========================================================
// VALIDACION DE OBSERVACION
//===========================================================
if (string.IsNullOrEmpty(TXT_ID.Text))
{
throw new Exception("NO EXISTE ID VALIDO PARA CREAR Y TAMPOCO ACTUALIZAR");
}
//===========================================================
// ID ASIGNADO
//===========================================================
try
{
ID_GRUPO = Convert.ToInt32(TXT_ID.Text);
}
catch
{
throw new Exception("ID ENVIADO NO ES UN NUMERO VALIDO");
}
//===========================================================
// VER SI ACTUALIZAMOS O INGRESAMOS
//===========================================================
if (ID_GRUPO == 0)
{
iSP_CREATE_GRUPO ParametrosInput = new iSP_CREATE_GRUPO();
ParametrosInput.ID_GRUPO = ID_GRUPO;
ParametrosInput.DESCRIPCION = DESCRIPCION;
//=======================================================
// LLAMADA A SERVICIO
//=======================================================
oSP_RETURN_STATUS ESTADO = Servicio.SP_CREATE_GRUPO(ParametrosInput);
if (ESTADO.RETURN_VALUE == -1)
{
MensajeLOGEdit("A", "GRUPO FUE INGRESADO CORRECTAMANTE", "MSG_GRUPO_INFO", "MSG_GRUPO_Alerta");
LEER_GRUPO();
return;
}
if (ESTADO.RETURN_VALUE == 0)
{
MensajeLOGEdit("A", "GRUPO NO FUE ACTUALIZADO", "MSG_GRUPO_INFO", "MSG_GRUPO_Alerta");
return;
}
}
else
{
iSP_UPDATE_GRUPO ParametrosInput = new iSP_UPDATE_GRUPO();
ParametrosInput.ID_GRUPO = ID_GRUPO;
ParametrosInput.DESCRIPCION = DESCRIPCION;
ParametrosInput.ESTADO = ESTADO_GRUPO;
//=======================================================
// LLAMADA A SERVICIO
//=======================================================
oSP_RETURN_STATUS ESTADO = Servicio.SP_UPDATE_GRUPO(ParametrosInput);
if (ESTADO.RETURN_VALUE == 1)
{
MensajeLOGEdit("A", "GRUPO FUE ACTUALIZADO CORRECTAMANTE", "MSG_GRUPO_INFO", "MSG_GRUPO_Alerta");
LEER_GRUPO();
return;
}
if (ESTADO.RETURN_VALUE == -1)
{
MensajeLOGEdit("A", "ERROR AL ACTUALIZAR, DESCRIPCIÓN YA EXISTE EN SISTEMA", "MSG_GRUPO_INFO", "MSG_GRUPO_Alerta");
return;
}
if (ESTADO.RETURN_VALUE == 0)
{
MensajeLOGEdit("A", "GRUPO NO FUE ACTUALIZADO", "MSG_GRUPO_INFO", "MSG_GRUPO_Alerta");
return;
}
}
}
catch (EServiceRestFulException srv)
{
MensajeLOGEdit("A", srv.Message, "MSG_GRUPO_INFO", "MSG_GRUPO_Alerta");
}
catch (System.Exception ex)
{
MensajeLOGEdit("A", UThrowError.MensajeThrow(ex), "MSG_GRUPO_INFO", "MSG_GRUPO_Alerta");
}
}
/// <summary>
/// GRILLA DE USUARIOS
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void GRDCluster_RowCommand(object sender, GridViewCommandEventArgs e)
{
try
{
//===========================================================
// DECLARACION DE VARIABLES
//===========================================================
SMetodos Servicio = new SMetodos();
//===========================================================
// ID
//===========================================================
int ID = Convert.ToInt32(e.CommandArgument);
if (ID == 0)
{
return;
}
//===========================================================
// ASIGNACION
//===========================================================
if (e.CommandName == "ASIGNAR")
{
int ID_CLUSTER = ID;
int ID_GRUPO = V_Global().ListaCluster.Where(p => p.ID_CLUSTER == ID_CLUSTER).Select(p => p.ID_GRUPO).FirstOrDefault();
bool ENCONTRADO = V_Global().ListaCluster.Where(p => p.ID_CLUSTER == ID_CLUSTER).Select(p => p.ENCONTRADO).FirstOrDefault();
if (ENCONTRADO == false)
{
iSP_CREATE_GRUPO_X_CLUSTER ParametrosInput = new iSP_CREATE_GRUPO_X_CLUSTER();
ParametrosInput.ID_GRUPO = ID_GRUPO;
ParametrosInput.ID_CLUSTER = ID_CLUSTER;
//=======================================================
// LLAMADA A SERVICIO
//=======================================================
oSP_RETURN_STATUS ESTADO = Servicio.SP_CREATE_GRUPO_X_CLUSTER(ParametrosInput);
if (ESTADO.RETURN_VALUE == -1)
{
MensajeLOG("CLUSER YA ESTA ASIGNADO", "ASIGNACIÓN DE USUARIOS");
}
if (ESTADO.RETURN_VALUE == 0)
{
MensajeLOG("CLUSER NO FUE ACTUALIZADO", "ASIGNACIÓN DE USUARIOS");
}
}
else
{
//=======================================================
// PARAMETROS DE ENTRADA
//=======================================================
iSP_DELETE_GRUPO_X_CLUSTER ParametrosInput = new iSP_DELETE_GRUPO_X_CLUSTER();
ParametrosInput.ID_GRUPO = ID_GRUPO;
ParametrosInput.ID_CLUSTER = ID_CLUSTER;
//=======================================================
// LLAMADA A SERVICIO
//=======================================================
oSP_RETURN_STATUS ESTADO = Servicio.SP_DELETE_GRUPO_X_CLUSTER(ParametrosInput);
if (ESTADO.RETURN_VALUE == 0)
{
MensajeLOG("CLUSER NO FUE ACTUALIZADO", "ASIGNACIÓN DE USUARIOS");
}
}
//=======================================================
// REFRESCAR GRILLA
//=======================================================
LEER_CLUSTER(ID_GRUPO);
}
}
catch (EServiceRestFulException srv)
{
MensajeLOG(srv.Message, "ERRORES DE SERVICIO");
}
catch (System.Exception ex)
{
MensajeLOG(UThrowError.MensajeThrow(ex), "ERRORES DE APLICACIÓN");
}
}
/// <summary>
/// CREAR O ACTUALIZAR UN NUEVO OBJETO
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void BTN_OBJETO_Click(object sender, EventArgs e)
{
try
{
//===========================================================
// DECLARACION DE VARIABLES
//===========================================================
SMetodos Servicio = new SMetodos();
int ID_CLUSTER = 0;
string DESCRIPCION = "";
string CODIGO = "";
bool OBLIGATORIO = false;
//===========================================================
// VALIDACION DE SELECCION DE CLUSTER
//===========================================================
if (DDL_SELECT_CLUSTER.Items.Count > 0)
{
ID_CLUSTER = Convert.ToInt32(DDL_SELECT_CLUSTER.SelectedValue);
}
else
{
MensajeLOGEdit("A", "DEBES SELECCIONAR UN CLUSTER", "MSG_INFO_OBJETO", "MSG_ALERTA_OBJETO");
return;
}
//===========================================================
// VALIDACION DE DESCRIPCION
//===========================================================
if (!string.IsNullOrWhiteSpace(TXT_DESCRIPCION.Text))
{
DESCRIPCION = TXT_DESCRIPCION.Text;
}
else
{
MensajeLOGEdit("A", "DEBES INGRESAR UNA DESCRIPCION", "MSG_INFO_OBJETO", "MSG_ALERTA_OBJETO");
return;
}
//===========================================================
// VALIDACION DE DESCRIPCION
//===========================================================
if (!string.IsNullOrWhiteSpace(TXT_CODIGO.Text))
{
CODIGO = TXT_CODIGO.Text;
}
else
{
MensajeLOGEdit("A", "DEBES INGRESAR UN CODIGO", "MSG_INFO_OBJETO", "MSG_ALERTA_OBJETO");
return;
}
OBLIGATORIO = CHK_OBLIGATORIO.Checked;
if (Convert.ToInt32(TXT_ID_OBJETO.Text) == 0)
{
//=======================================================
// CONSTRUCCION DE OBJETO
//=======================================================
iSP_CREATE_OBJETO ParametrosInput = new iSP_CREATE_OBJETO();
ParametrosInput.ID_CLUSTER = ID_CLUSTER;
ParametrosInput.DESCRIPCION = DESCRIPCION;
ParametrosInput.OBLIGATORIO = OBLIGATORIO;
ParametrosInput.CODIGO = CODIGO;
//=======================================================
// LLAMADA A SERVICIO
//=======================================================
oSP_RETURN_STATUS ESTADO = Servicio.SP_CREATE_OBJETO(ParametrosInput);
if (ESTADO.RETURN_VALUE == -1)
{
MensajeLOGEdit("A", "EL OBJETO YA SE ENCUENTRA EN EL SISTEMA", "MSG_INFO_OBJETO", "MSG_ALERTA_OBJETO");
return;
}
if (ESTADO.RETURN_VALUE == 0)
{
MensajeLOGEdit("A", "EL OBJETO NO FUE INGRESADO", "MSG_INFO_OBJETO", "MSG_ALERTA_OBJETO");
return;
}
if (ESTADO.RETURN_VALUE == 1)
{
MensajeLOGEdit("I", "EL OBJETO FUE INGRESADO CORRECTAMENTE", "MSG_INFO_OBJETO", "MSG_ALERTA_OBJETO");
LEER_OBJETO(ID_CLUSTER);
CARGAR_GRILLA_OBJETO();
return;
}
}
if (Convert.ToInt32(TXT_ID_OBJETO.Text) > 0)
{
//=======================================================
// CONSTRUCCION DE OBJETO
//=======================================================
iSP_UPDATE_OBJETO ParametrosInput = new iSP_UPDATE_OBJETO();
ParametrosInput.ID_OBJETO = Convert.ToInt32(TXT_ID_OBJETO.Text);
ParametrosInput.DESCRIPCION = DESCRIPCION;
ParametrosInput.OBLIGATORIO = OBLIGATORIO;
ParametrosInput.CODIGO = CODIGO;
//=======================================================
// LLAMADA A SERVICIO
//=======================================================
oSP_RETURN_STATUS ESTADO = Servicio.SP_UPDATE_OBJETO(ParametrosInput);
if (ESTADO.RETURN_VALUE == -1)
{
MensajeLOGEdit("A", "EL OBJETO YA SE ENCUENTRA EN EL SISTEMA", "MSG_INFO_OBJETO", "MSG_ALERTA_OBJETO");
return;
}
if (ESTADO.RETURN_VALUE == 0)
{
MensajeLOGEdit("A", "EL OBJETO NO FUE INGRESADO", "MSG_INFO_OBJETO", "MSG_ALERTA_OBJETO");
return;
}
if (ESTADO.RETURN_VALUE == 1)
{
MensajeLOGEdit("I", "EL OBJETO FUE ACTUALIZADO CORRECTAMENTE", "MSG_INFO_OBJETO", "MSG_ALERTA_OBJETO");
LEER_OBJETO(ID_CLUSTER);
CARGAR_GRILLA_OBJETO();
return;
}
}
}
catch (EServiceRestFulException srv)
{
MensajeLOGEdit("A", srv.Message, "MSG_INFO_OBJETO", "MSG_ALERTA_OBJETO");
}
catch (System.Exception ex)
{
MensajeLOGEdit("A", UThrowError.MensajeThrow(ex), "MSG_INFO_OBJETO", "MSG_ALERTA_OBJETO");
}
}
/// <summary>
/// LOGIN DE USUARIO
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void BTN_Login_Click(object sender, EventArgs e)
{
try
{
//===========================================================
// ACCESO AL SERVICIO
//===========================================================
SMetodos Servicio = new SMetodos();
//===========================================================
// VALIDACION DE CONTROLES ==
//===========================================================
if (string.IsNullOrEmpty(TXT_LOGIN.Text) == true)
{
MensajeLOG("NO HA INGRESADO LOGIN A VALIDAR", "VALIDACIÓN DE LOGIN");
return;
}
if (string.IsNullOrEmpty(TXT_PASSWORD.Text) == true)
{
MensajeLOG("NO HA PASSWORD A VALIDAR", "VALIDACIÓN DE LOGIN");
return;
}
//===========================================================
// ASIGNACION DE VALORES DE CREACION DE CUENTA ==
//===========================================================
string LOGIN = TXT_LOGIN.Text;
string PASSWORD = TXT_PASSWORD.Text;
//===========================================================
// ASIGNACION DE VALORES DE CREACION DE CUENTA ==
//===========================================================
iSP_VALIDATE_USUARIO ParametrosInput = new iSP_VALIDATE_USUARIO();
ParametrosInput.LOGIN = LOGIN;
ParametrosInput.PASSWORD = PASSWORD;
//===========================================================
// LLAMADA DEL SERVICIO
//===========================================================
oSP_RETURN_STATUS ObjetoRest = Servicio.SP_VALIDATE_USUARIO(ParametrosInput);
//===========================================================
// RESPUESTA SERVICIO
//===========================================================
if (ObjetoRest.RETURN_VALUE == -4)
{
MensajeLOG("INSTITUCIÓN NO EXISTE EN SISTEMA", "ERROR LOGIN");
return;
}
if (ObjetoRest.RETURN_VALUE == -3)
{
MensajeLOG("INSTITUCIÓN NO ESTA VIGENTE EN SISTEMA", "ERROR LOGIN");
return;
}
if (ObjetoRest.RETURN_VALUE == -2)
{
MensajeLOG("USUARIO NO EXISTE EN SISTEMA", "ERROR LOGIN");
return;
}
if (ObjetoRest.RETURN_VALUE == -1)
{
MensajeLOG("USUARIO ENVIADO NO ESTA VINCULADO A INSTITUCIÓN", "ERROR LOGIN");
return;
}
if (ObjetoRest.RETURN_VALUE == 0)
{
MensajeLOG("PASSWORD NO COINCIDE", "ERROR LOGIN");
return;
}
if (ObjetoRest.RETURN_VALUE == 1)
{
HttpCookie cookie = new HttpCookie(Globales.Cookie);
Response.Cookies.Remove(Globales.Cookie);
cookie.Values.Add("LOGIN", UCryptorEngine.Encriptar(LOGIN));
cookie.Values.Add("PASSWORD", UCryptorEngine.Encriptar(PASSWORD));
if (RememberMe.Checked == true)
{
cookie.Values.Add("Checked", "1");
cookie.Expires = DateTime.Now.AddDays(365);
}
else
{
cookie.Values.Add("Checked", "0");
cookie.Expires = DateTime.Now.AddDays(-1D);
}
Response.Cookies.Add(cookie);
UsuariosSession(LOGIN);
FormsAuthentication.RedirectFromLoginPage(LOGIN, false);
}
}
catch (EServiceRestFulException srv)
{
MensajeLOG(srv.Message, "ERRORES DE SERVICIO");
}
catch (System.Exception ex)
{
MensajeLOG(UThrowError.MensajeThrow(ex), "ERRORES DE APLICACIÓN");
}
}
/// <summary>
/// CAMBIAR PASSWORD EN SISTEMA
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void BTN_GUARDAR_PASSWORD_Click(object sender, EventArgs e)
{
try
{
//===========================================================
// DECLARACION DE VARIABLES
//===========================================================
string PASSWORD_NUEVA = "";
string PASSWORD_CONFIRMAR = "";
SMetodos Servicio = new SMetodos();
//===========================================================
// ASIGNA VALORES DE CAJA
//===========================================================
PASSWORD_NUEVA = TXT_PASSWORD_NUEVA.Text;
PASSWORD_CONFIRMAR = TXT_PASSWORD_CONFIRMAR.Text;
//===========================================================
// SI LOS VALORES SON DIDFERENTES
//===========================================================
if (PASSWORD_NUEVA != PASSWORD_CONFIRMAR)
{
MensajeLOG("LA NUEVA CONTRASEÑA Y LA CONFIRMACIÓN NO COINCIDEN", "FALLA ACTUALIZACION CLAVE");
return;
}
//===========================================================
// PARAMETROS DE ENTRADA
//===========================================================
iSP_UPDATE_PASSWORD ParametrosInput = new iSP_UPDATE_PASSWORD();
ParametrosInput.ID_USUARIO = Globales.DATOS_COOK().ID_USUARIO;
ParametrosInput.PASSWORD_ACTUAL = this.TXT_PASSWORD_ACTUAL.Text;
ParametrosInput.PASSWORD_NUEVA = this.TXT_PASSWORD_NUEVA.Text;
//===========================================================
// LLAMADA DEL SERVICIO
//===========================================================
oSP_RETURN_STATUS ObjetoRest = Servicio.SP_UPDATE_PASSWORD(ParametrosInput);
if (ObjetoRest.RETURN_VALUE == -1)
{
MensajeLOG("LA CLAVE ACTUAL NO CONCUERDA CON ESTE USUARIO", "FALLA ACTUALIZACION CLAVE");
}
if (ObjetoRest.RETURN_VALUE == 0)
{
MensajeLOG("FALLÓ LA ACTUALIZACION DE LA CLAVE EN BASE DE DATOS", "FALLA ACTUALIZACION CLAVE");
}
if (ObjetoRest.RETURN_VALUE == 1)
{
MensajeLOG("LA CLAVE FUE ACTUALIZADA EXITOSAMENTE", "CAMBIO DE CLAVE");
}
}
catch (EServiceRestFulException srv)
{
MensajeLOG(srv.Message, "ERRORES DE SERVICIO");
}
catch (System.Exception ex)
{
MensajeLOG(UThrowError.MensajeThrow(ex), "ERRORES DE APLICACIÓN");
}
}
