private void btnActualizar_Click(object sender, EventArgs e)
{
if (Actualizar != null)
{
Actualizar.Invoke(txtDatos.Text);
}
}
protected void Button1_Click(object sender, EventArgs e)
{
string codigoUsuario = null;
codigoUsuario = Session["CODUSUA"] as string;
string nombre = txtNombre.Text;
string apellido = txtApellido.Text;
string email = txtEmail.Text;
string numeroTelefonico = txtTelefono.Text;
int cargo = Convert.ToInt32(Cargo.SelectedValue.ToString());
int tipUsuario = Convert.ToInt32(TipoUsuario.SelectedValue.ToString());
if (email.Contains(".com") == false)
{
lblError.Text = "Verifique su correo por favor";
}
else
{
Actualizar update = new Actualizar();
update.actualizarDatos(codigoUsuario, nombre, apellido, email, numeroTelefonico, cargo, tipUsuario);
txtNombre.Visible = false;
txtApellido.Visible = false;
txtEmail.Visible = false;
txtTelefono.Visible = false;
Cargo.Visible = false;
TipoUsuario.Visible = false;
Button1.Visible = false;
AD.Visible = false;
lblError.Text = "";
lblRespuesta1.Text = "Datos Actualizados";
}
}
public async virtual Task <ActualizarResponse <TEntidad> > ActualizarAsync(Actualizar <TEntidad> modelo, IRequest peticion)
{
var autoinfoAlActualizar = new EntidadAutoinfo <TEntidad>();
PreprocesarAlActualizar(modelo, autoinfoAlActualizar, peticion);
return(await repositorio.ActualizarAsync(modelo, autoinfoAlActualizar));
}
static void Main(string[] args)
{
var insertar = new Insertar();
var actualizar = new Actualizar();
//insertar.InsertarEstudiante();
//insertar.InsertaListaEstuadiante();
//actualizar.ActualizarEstudianteConectado();
actualizar.ActualizarEstudianteDesconectado();
}
protected override void PreprocesarAlActualizar(Actualizar <PlantillaEncuesta> modelo, EntidadAutoinfo <PlantillaEncuesta> autoinfoAlActualizar, IRequest peticion)
{
var entidad = modelo as PlantillaEncuestaActualizar;
var getAlmacenada = GetEntityById(modelo.Id);
entidad.Inactiva.SiEsNullEntonces(() => entidad.Inactiva = getAlmacenada().Inactiva);
entidad.Aprobada.SiEsNullEntonces(() => entidad.Aprobada = getAlmacenada().Aprobada);
entidad.Descripcion.SiEstaVacia_O_NullEntonces(() => entidad.Descripcion = getAlmacenada().Descripcion);
entidad.Nombre.SiEstaVacia_O_NullEntonces(() => entidad.Nombre = getAlmacenada().Nombre);
base.PreprocesarAlActualizar(modelo, autoinfoAlActualizar, peticion);
}
public async Task <ActualizarResponse <TEntidad> > ActualizarAsync(Actualizar <TEntidad> modelo, EntidadAutoinfo <TEntidad> autoinfoAlActualizar)
{
var entidad = CrearEntidadConDatosDelModelo(modelo);
PreprocesarAlActualizar(entidad, autoinfoAlActualizar);
var onlyfields = ObtenerCamposPorActualizar(autoinfoAlActualizar, modelo.GetType());
await repositorio.ActualizarAsync(entidad, onlyfields);
entidad = await repositorio.ConsultarPorIdAsync <TEntidad>(entidad.Id);
return(new ActualizarResponse <TEntidad> {
Data = entidad
});
}
/*****************************************************************************************************************************************************
* Descripcion: Cuando se activa este evento se ejecutan multiples procedimientos para guaradar en la base de datos.
*****************************************************************************************************************************************************/
private void BtnCrearUsuario_Click(object sender, EventArgs e)
{
claseControlUsuario.Direccion = txtDireccionConfiUsuario.Text;
claseControlUsuario.Nombre = txtNombreConfiUsuario.Text;
claseControlUsuario.Cedula = txtCedulaConfiUsuario.Text;
claseControlUsuario.Tlf = txtTlfConfiUsuario.Text;
claseControlUsuario.IdPerfil = Convert.ToInt32(cmbPerfiles.SelectedValue);
claseControlUsuario.PassNew = ClaseComunes.ObtenerHash(txtContraseña.Text);
claseControlUsuario.Apellido = txtApellidoConfiUsuario.Text;
claseControlUsuario.UserNew = txtUsuario.Text;
claseControlUsuario.Correo = txtCorreoConfiUsuario.Text;
claseControlUsuario.Estatus = Convert.ToBoolean(chbEstatusConfiUsuario.Checked);
if (!entidad.ValidarCampos())
{
return;
}
if (entidad.VerificarExitenciaUsuario())
{
ClaseComunes.MsjShow("La cedula ya se encuentra registrada en el sistema.", 1, 3);
return;
}
if (entidad.GuardarUsuario())
{
ClaseComunes.MsjShow("El Registro se Guardo Exitosamente", 1, 5);
if (Text == "Nuevo")
{
LimpiarConfiUsuario();
claseControlUsuario.IdUsuario = 0;
}
else
{
pnlCreacionUsr.Visible = false;
claseControlUsuario.setDgrw(ref dgrvUsuarios, "USP_ConsultaUsuario");
}
Actualizar?.Invoke(sender, e);
}
}
protected override void PreprocesarAlActualizar(Actualizar <Gam> modelo, EntidadAutoinfo <Gam> autoinfoAlActualizar, IRequest peticion)
{
var gamActualizar = modelo as GamActualizar;
var alamcenada = GetEntityById(modelo.Id);
gamActualizar.EncargadoId.SiEsCero_O_NullEntonces(() => {
gamActualizar.EncargadoId = alamcenada().EncargadoId;
});
gamActualizar.MunicipioId.SiEsCero_O_NullEntonces(() => {
gamActualizar.MunicipioId = alamcenada().MunicipioId;
});
gamActualizar.Nombre.SiEstaVacia_O_NullEntonces(() => {
gamActualizar.Nombre = alamcenada().Nombre;
});
base.PreprocesarAlActualizar(gamActualizar, autoinfoAlActualizar, peticion);
}
protected void btnChangePassword_Click(object sender, EventArgs e)
{
lblError.Text = "";
bool error = false;
string anteriorPassword = null;
string nuevaPassword = null;
string codigoUsuario = null;
codigoUsuario = Session["CODUSUA"] as string;
anteriorPassword = txtBeforePassword.Text;
nuevaPassword = txtAfterPassword.Text;
AutenticarLogin valida = new AutenticarLogin();
error = valida.AutenticarUsuario(codigoUsuario, anteriorPassword);
if (error == true)
{
if (anteriorPassword == nuevaPassword)
{
lblError.Text = "La contraseña actual es igual a la que quiere cambiar";
}
else
{
Actualizar update = new Actualizar();
update.actualizarPassword(codigoUsuario, nuevaPassword);
txtAfterPassword.Visible = false;
txtAfterPasswordConfirm.Visible = false;
txtBeforePassword.Visible = false;
btnChangePassword.Visible = false;
AC.Visible = false;
lblCambios.Text = "Password Actualizada";
}
}
else
{
lblError.Text = "Su Password es incorrecta";
}
}
public async Task <ActualizarResponse <TEntidad> > ActualizarAsync(Actualizar <TEntidad> modelo)
{
return(await ActualizarAsync(modelo, new EntidadAutoinfo <TEntidad>()));
}
public virtual ActualizarResponse <TEntidad> Actualizar(Actualizar <TEntidad> modelo,
EntidadAutoinfo <TEntidad> autoinfoAlActualizar)
{
return(ActualizarAsync(modelo, autoinfoAlActualizar).Result);
}
public virtual ActualizarResponse <TEntidad> Actualizar(Actualizar <TEntidad> modelo)
{
return(ActualizarAsync(modelo, new EntidadAutoinfo <TEntidad>()).Result);
}
protected virtual void PreprocesarAlActualizar(Actualizar <TEntidad> modelo,
EntidadAutoinfo <TEntidad> autoinfoAlActualizar, IRequest peticion)
{
}
public virtual ActualizarResponse <TEntidad> Actualizar(Actualizar <TEntidad> modelo, IRequest peticion)
{
return(ActualizarAsync(modelo, peticion).Result);
}
private string DescripcionDetallaDelContenedor(DataGridView dgv)
{
string Mensaje = "";
if (dgv.Rows.Count > 0)
{
List <DataGridViewRow> rows = (from item in dgv.Rows.Cast <DataGridViewRow>()
let Actualizar = Convert.ToBoolean(item.Cells["Actualizar"].Value ?? false)
let idProductoSustitutos = Convert.ToInt32(item.Cells["idProductoSustitutos"].Value)
where Actualizar.Equals(true) && idProductoSustitutos == 0
select item).ToList <DataGridViewRow>();
if (rows.Count > 0)
{
Mensaje += string.Format(" Se va a agregar: {1} Registros {0}", Environment.NewLine, rows.Count);
}
List <DataGridViewRow> rows1 = (from item in dgv.Rows.Cast <DataGridViewRow>()
let Actualizar = Convert.ToBoolean(item.Cells["Actualizar"].Value ?? false)
let idProductoSustitutos = Convert.ToInt32(item.Cells["idProductoSustitutos"].Value)
where Actualizar.Equals(true) && idProductoSustitutos > 0
select item).ToList <DataGridViewRow>();
if (rows1.Count > 0)
{
Mensaje += string.Format(" Se va a actualizar: {1} Registros {0}", Environment.NewLine, rows1.Count);
}
List <DataGridViewRow> rows2 = (from item in dgv.Rows.Cast <DataGridViewRow>()
let Eliminar = Convert.ToBoolean(item.Cells["Eliminar"].Value ?? false)
where Eliminar.Equals(true)
select item).ToList <DataGridViewRow>();
if (rows2.Count > 0)
{
Mensaje += string.Format(" Se va a Eliminar: {1} Registros {0}", Environment.NewLine, rows2.Count);
}
}
else
{
Mensaje = "";
}
if (string.IsNullOrEmpty(Mensaje) == false || Mensaje.Trim().Length > 0)
{
Mensaje = string.Format("Información de los contenedores: {0}", Mensaje);
}
return(Mensaje);
}
public static Response <TReturn> AplicarPatch <TReturn, TValue>(Obtener <TValue> fnObtener, Actualizar <TReturn, TValue> fnActualizar, int id, TValue patch)
{
Response <TReturn> resp = new Response <TReturn>();
try
{
var origValue = fnObtener(id).Datos;
ConcurrentDictionary <Type, PropertyInfo[]> TypePropertiesCache = new ConcurrentDictionary <Type, PropertyInfo[]>();
PropertyInfo[] properties = TypePropertiesCache.GetOrAdd(patch.GetType(), (type) => type.GetProperties(BindingFlags.Instance | BindingFlags.Public));
foreach (PropertyInfo prop in properties)
{
PropertyInfo orjProp = origValue.GetType().GetProperty(prop.Name);
object value = prop.GetValue(patch);
if (value != null)
{
orjProp.SetValue(origValue, value);
}
}
resp = fnActualizar(origValue);
//resp.Estatus = Estatus.Exito;
}
catch (Exception ex)
{
resp.Mensaje = "No se puede aplicar el parche";
resp.MensajeTecnico = ex.Message;
}
return(resp);
}
