// INSERT
//------------------------------------------------------------------------------------------------------------
public int InsertUsuario(objUsuario usuario)
{
try
{
AcessoDados db = new AcessoDados();
//--- clear Params
db.LimparParametros();
//--- define Params
db.AdicionarParametros("@UsuarioApelido", usuario.UsuarioApelido);
db.AdicionarParametros("@UsuarioAcesso", usuario.UsuarioAcesso);
db.AdicionarParametros("@UsuarioSenha", usuario.UsuarioSenha);
db.AdicionarParametros("@Email", usuario.Email);
//--- convert null parameters
db.ConvertNullParams();
//--- create query
string query = db.CreateInsertSQL("tblUsuario");
//--- insert
return((int)db.ExecutarInsertAndGetID(query));
}
catch (Exception ex)
{
throw ex;
}
}
// FIND AND SELECT IN LIST PROVIDED DEFAULT ID
//------------------------------------------------------------------------------------------------------------
private void FindSelectDefautID(int?DefaultID)
{
if (DefaultID != null)
{
foreach (BetterListViewItem item in lstItens)
{
if (Convert.ToInt32(item.Text) == DefaultID)
{
item.Selected = true;
propEscolha = GetSelectedItem();
}
else
{
item.Selected = false;
}
}
}
else
{
if (lstItens.Items.Count > 0)
{
lstItens.Items[0].Selected = true;
}
}
}
public bool ConsultarUsuario(objUsuario Usuario)
{
MySql.Data.MySqlClient.MySqlConnection dbConn = new MySql.Data.MySqlClient.MySqlConnection("Persist Security Info=False;server=localhost;database=hotel_bd;uid=conexion;password=pruebas1.");
bool idnumber = false;
MySqlCommand cmd = dbConn.CreateCommand();
cmd.CommandText = "SELECT COUNT(*) resultado from usuario WHERE username = '******'";
try
{
dbConn.Open();
}
catch (Exception erro)
{
strMensajeError = erro.Message;
dbConn.Close();
}
try
{
MySqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
idnumber = reader.HasRows;
}
return(idnumber);
}
catch (Exception ex)
{
strMensajeError = ex.Message;
return(false);
}
}
public bool ConsultarUsuario(objUsuario Usuario)
{
if (this.OpenConnection())
{
MySqlCommand cmd = Conexion.CreateCommand();
bool idnumber = false;
cmd.CommandText = "SELECT * from usuario WHERE username = @usuario and password = @contra";
cmd.Parameters.AddWithValue("@usuario", Usuario.strUser);
cmd.Parameters.AddWithValue("@contra", Usuario.strPass);
try
{
MySqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
idnumber = reader.HasRows;
}
this.CloseConnection();
return(idnumber);
}
catch (Exception ex)
{
strMensajeError = ex.Message;
return(false);
}
}
else
{
strMensajeError = "Error al iniciar la conexion";
return(false);
}
}
// CONVERT ROW IN CLASS
//------------------------------------------------------------------------------------------------------------
public objUsuario ConvertRowInClass(DataRow row)
{
objUsuario usuario = new objUsuario((int)row["IDUsuario"])
{
};
usuario.UsuarioApelido = (string)row["UsuarioApelido"];
usuario.UsuarioAcesso = row["UsuarioAcesso"] == DBNull.Value ? (byte)0 : (byte)row["UsuarioAcesso"];
usuario.UsuarioAtivo = (bool)row["UsuarioAtivo"];
usuario.Email = row["Email"] == DBNull.Value ? string.Empty : (string)row["Email"];
return(usuario);
}
//=================================================================================================
// GET NEW LOGIN ACESSO
//=================================================================================================
public objUsuario GetAuthorization(
string UsuarioApelido,
string UsuarioSenha,
EnumAcessoTipo UsuarioAcesso = EnumAcessoTipo.Usuario_Local, // usuario_local = 4
string AuthDescription = "Acesso Login"
)
{
AcessoDados db = new AcessoDados();
db.LimparParametros();
db.AdicionarParametros("@UsuarioApelido", UsuarioApelido);
db.AdicionarParametros("@UsuarioSenha", UsuarioSenha);
db.AdicionarParametros("@UsuarioAcesso", UsuarioAcesso);
db.AdicionarParametros("@AuthDescription", AuthDescription);
db.AdicionarParametros("@AuthDate", DateTime.Now);
try
{
DataTable dt = db.ExecutarConsulta(CommandType.StoredProcedure, "uspUserGetAuthorization");
if (dt.Rows.Count == 0)
{
TentativasAcesso += 1;
throw new AppException("Não há Usuários no sistema, comunique com o administrador...");
}
DataRow row = dt.Rows[0];
if (row.ItemArray.Length == 1)
{
TentativasAcesso += 1;
throw new AppException(dt.Rows[0].ItemArray[0].ToString());
}
objUsuario UsuarioAtual = new objUsuario((int)row["IDUsuario"])
{
UsuarioAcesso = (byte)row["UsuarioAcesso"],
UsuarioApelido = (string)row["UsuarioApelido"]
};
return(UsuarioAtual);
}
catch (AppException ex)
{
throw ex;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// metodo para eliminar a un usuario
/// </summary>
/// <param name="id"></param>
private async void eliminarusuario(objUsuario id_usuario)
{
DialogService dialog = new DialogService();
MetroDialogSettings botones = new MetroDialogSettings();
Encriptacion encriptar = new Encriptacion();
botones.AffirmativeButtonText = StringResources.lblYes;
botones.NegativeButtonText = StringResources.lblNo;
if (id_usuario != null)
{
MessageDialogResult resultado = await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgDelUsuario, botones, MessageDialogStyle.AffirmativeAndNegative);
if (resultado == MessageDialogResult.Affirmative)
{
bool r = DataManagerControlDocumentos.ContarDocumentos(encriptar.encript(id_usuario.usuario));
if (SelectedItem != null)
{
// Se manda llamar método para eliminar el usuario de la tabla TBL_USER_DETAILS
DataManagerControlDocumentos.Delete_UserDetail(encriptar.encript(id_usuario.usuario));
if (r == true)
{
//si el usuario tiene documentos
await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgPrivilegiosUsuario);
Model.DataManager.DeletePrivilegiosUsuario(encriptar.encript(id_usuario.usuario));
Model.DataManager.DeLete_PerfilUsuario(encriptar.encript(id_usuario.usuario));
DataManagerControlDocumentos.DeleteRol_Usuario(encriptar.encript(id_usuario.usuario));
ConstructorVista();
}
else
{
//si el usuario no tiene documentos
Model.DataManager.DeletePrivilegiosUsuario(encriptar.encript(id_usuario.usuario));
Model.DataManager.DeLete_PerfilUsuario(encriptar.encript(id_usuario.usuario));
DataManagerControlDocumentos.DeleteRol_Usuario(encriptar.encript(id_usuario.usuario));
DataManagerControlDocumentos.DeleteUsuarios(id_usuario);
await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgDeleteUsuario);
ConstructorVista();
}
}
}
}
}
public frmUsuarioContaAcesso(objUsuario Usuario, Form formOrigem)
{
InitializeComponent();
_formOrigem = formOrigem;
_usuario = Usuario;
lblUsuarioApelido.Text = _usuario.UsuarioApelido;
//--- Add any initialization after the InitializeComponent() call.
ObterDados(this, new EventArgs());
//--- Handlers
HandlerKeyDownControl(this);
}
private void btnEscolher_Click(object sender, EventArgs e)
{
objUsuario item = GetSelectedItem();
//--- check selected item
if (item == null)
{
AbrirDialog("Favor selecionar um registro para Editar...",
"Selecionar Registro", DialogType.OK, DialogIcon.Information);
return;
}
//--- open edit form
propEscolha = item;
DialogResult = DialogResult.OK;
}
// OPEN PROCURA FORM
//------------------------------------------------------------------------------------------------------------
private void btnSetUser_Click(object sender, EventArgs e)
{
try
{
// --- Ampulheta ON
Cursor.Current = Cursors.WaitCursor;
frmUsuarioProcura frm = new frmUsuarioProcura(this, null, true);
frm.ShowDialog();
//--- check return
if (frm.DialogResult != DialogResult.OK)
{
return;
}
//--- check user
if (frm.propEscolha.IDUsuario == (int)Program.usuarioAtual.IDUsuario)
{
AbrirDialog("Não é possível enviar uma mensagem para o usuário:\n" +
$"{Program.usuarioAtual.UsuarioApelido}\n" +
$"porque este é o usuário atual.",
"Mensagem para Usuário",
DialogType.OK,
DialogIcon.Exclamation);
return;
}
// set user
_DestinoUser = frm.propEscolha;
txtUsuarioDestino.Text = frm.propEscolha.UsuarioApelido;
//--- select
txtUsuarioDestino.Focus();
txtUsuarioDestino.SelectAll();
}
catch (Exception ex)
{
AbrirDialog("Uma exceção ocorreu ao abrir o formulário de procura..." + "\n" +
ex.Message, "Exceção", DialogType.OK, DialogIcon.Exclamation);
}
finally
{
// --- Ampulheta OFF
Cursor.Current = Cursors.Default;
}
}
// EDITAR MENSAGEM
//------------------------------------------------------------------------------------------------------------
private void EditarMensagem()
{
if (dgvListagem.SelectedRows.Count == 0)
{
AbrirDialog("Selecione um registro para editar...", "Selecionar");
return;
}
//--- get selected message
objMensagem mensagem = (objMensagem)dgvListagem.SelectedRows[0].DataBoundItem;
//--- create destino user
var user = new objUsuario(mensagem.IDUsuarioDestino)
{
UsuarioApelido = mensagem.UsuarioDestino
};
//--- open form mensagem
var frmM = new frmMensagemEditar(mensagem, user, this);
frmM.ShowDialog();
if (frmM.DialogResult != DialogResult.OK)
{
return;
}
try
{
// --- Ampulheta ON
Cursor.Current = Cursors.WaitCursor;
//--- update
mBLL.UpdateMensagem(mensagem);
}
catch (Exception ex)
{
AbrirDialog("Uma exceção ocorreu ao Salvar Mensagem..." + "\n" +
ex.Message, "Exceção", DialogType.OK, DialogIcon.Exclamation);
}
finally
{
// --- Ampulheta OFF
Cursor.Current = Cursors.Default;
}
}
public frmMensagemEditar(objMensagem mensagem, objUsuario DestinoUser, Form formOrigem)
{
InitializeComponent();
_formOrigem = formOrigem;
_DestinoUser = DestinoUser;
_mensagem = mensagem;
bind.DataSource = _mensagem;
BindingCreator();
if (_mensagem.IDMensagem == null)
{
Sit = EnumFlagEstado.NovoRegistro;
}
else
{
Sit = EnumFlagEstado.RegistroSalvo;
if (mensagem.IDUsuarioOrigem != Program.usuarioAtual.IDUsuario)
{
txtUsuarioDestino.ReadOnly = true;
txtMensagem.ReadOnly = true;
btnSetConta.Enabled = false;
btnEnviar.Visible = false;
btnCancelar.Text = "&Fechar";
}
}
// CHECK IF IS RESPOSTA
if (_mensagem.IsResposta && mensagem.IDOrigem != null)
{
mBLL = new MensagemBLL();
lstAntigas = ObterAnteriores((int)mensagem.IDOrigem);
if (lstAntigas != null && lstAntigas.Count > 0)
{
PreencheControleAntigas();
}
}
// CHECK FORM SIZE
WithAnteriores();
// ADD HANDLERS
HandlerKeyDownControl(this);
}
private void btnAlterarAtivo_Click(object sender, EventArgs e)
{
// get selected user on list
objUsuario usuario = GetSelectedItem();
if (usuario == null)
{
return;
}
// check if is actual user
if (usuario.UsuarioAtivo && usuario.IDUsuario == Program.usuarioAtual.IDUsuario)
{
AbrirDialog("Você não pode desabilitar o usuário atual...",
"Desativar", DialogType.OK, DialogIcon.Exclamation);
return;
}
// change ATIVO value
usuario.UsuarioAtivo = !usuario.UsuarioAtivo;
// Save DB
try
{
// --- Ampulheta ON
Cursor.Current = Cursors.WaitCursor;
// update
uBLL.UpdateUsuario(usuario);
// redraw itens and button
lstUsuarios.RedrawItems();
lstUsuarios_SelectedIndexChanged(sender, null);
}
catch (Exception ex)
{
AbrirDialog("Uma exceção ocorreu ao Ativar/Desativar Usuário..." + "\n" +
ex.Message, "Exceção", DialogType.OK, DialogIcon.Exclamation);
}
finally
{
// --- Ampulheta OFF
Cursor.Current = Cursors.Default;
}
}
// UPDATE
//------------------------------------------------------------------------------------------------------------
public bool UpdateUsuario(objUsuario usuario)
{
try
{
AcessoDados db = new AcessoDados();
//--- create query
string query = "UPDATE tblUsuario SET " +
"UsuarioApelido = @UsuarioApelido, " +
"UsuarioAcesso = @UsuarioAcesso, " +
"UsuarioAtivo = @UsuarioAtivo, " +
"Email = @Email";
//--- clear Params
db.LimparParametros();
//--- define Params
db.AdicionarParametros("@IDUsuario", usuario.IDUsuario);
db.AdicionarParametros("@UsuarioApelido", usuario.UsuarioApelido);
db.AdicionarParametros("@UsuarioAcesso", usuario.UsuarioAcesso);
db.AdicionarParametros("@UsuarioAtivo", usuario.UsuarioAtivo);
db.AdicionarParametros("@Email", usuario.Email);
if (!string.IsNullOrEmpty(usuario.UsuarioSenha))
{
db.AdicionarParametros("@UsuarioSenha", usuario.UsuarioSenha);
query += ", UsuarioSenha = @UsuarioSenha";
}
query += " WHERE IDUsuario = @IDUsuario";
//--- convert null parameters
db.ConvertNullParams();
//--- update
db.ExecutarManipulacao(CommandType.Text, query);
return(true);
}
catch (Exception ex)
{
throw ex;
}
}
// CONFIRM PASSWORD OF USER
//------------------------------------------------------------------------------------------------------------
public bool ConfirmPassword(objUsuario User, string Password)
{
try
{
AcessoControlBLL acesso = new AcessoControlBLL();
objUsuario returnedUser = acesso.GetAuthorization(
User.UsuarioApelido,
Password,
(EnumAcessoTipo)User.UsuarioAcesso,
"Confirmar Password");
return(true);
}
catch (Exception ex)
{
throw ex;
}
}
// GET Movimentacao LIST BY IDCaixa
//------------------------------------------------------------------------------------------------------------
public List <objMovimentacao> GetMovimentacaoCaixaList(
objCaixa caixa,
objUsuario user,
object dbTran = null)
{
try
{
AcessoDados db = dbTran == null ? new AcessoDados() : (AcessoDados)dbTran;
//--- update MOVIMENTACAO
if (user.UsuarioAcesso == 1)
{
InsertCaixaMovs(caixa, db);
}
// add params
db.LimparParametros();
db.AdicionarParametros("@IDCaixa", caixa.IDCaixa);
string query = "SELECT * FROM qryMovimentacao WHERE IDCaixa = @IDCaixa";
query += " ORDER BY MovData";
List <objMovimentacao> listagem = new List <objMovimentacao>();
DataTable dt = db.ExecutarConsulta(CommandType.Text, query);
if (dt.Rows.Count == 0)
{
return(listagem);
}
foreach (DataRow row in dt.Rows)
{
listagem.Add(ConvertRowInClass(row, false));
}
return(listagem);
}
catch (Exception ex)
{
throw ex;
}
}
// ALTERA A IMAGEM DO BTN ALTERAR ATIVO
//------------------------------------------------------------------------------------------------------------
private void lstUsuarios_SelectedIndexChanged(object sender, EventArgs e)
{
objUsuario usuario = GetSelectedItem();
if (usuario == null)
{
btnAlterarAtivo.Enabled = false;
return;
}
btnAlterarAtivo.Enabled = true;
if (usuario.UsuarioAtivo)
{
btnAlterarAtivo.Text = "Desativar Usuário";
btnAlterarAtivo.Image = Properties.Resources.block_24;
}
else
{
btnAlterarAtivo.Text = "Ativar Usuário";
btnAlterarAtivo.Image = Properties.Resources.accept_24;
}
}
// GET DATA
//------------------------------------------------------------------------------------------------------------
private void ObterDados(bool WithAllUsers)
{
try
{
// --- Ampulheta ON
Cursor.Current = Cursors.WaitCursor;
//--- clear
listUser.Clear();
//--- get users
listUser.AddRange(new UsuarioBLL().GetListUsuario("", true));
//--- insert TODOS if necessary
if (WithAllUsers)
{
objUsuario Todos = new objUsuario(-1)
{
UsuarioApelido = "TODOS USUÁRIOS ATIVOS",
};
listUser.Add(Todos);
}
PreencheListagem();
}
catch (Exception ex)
{
AbrirDialog("Uma exceção ocorreu ao Obter os Dados da listagem..." + "\n" +
ex.Message, "Exceção", DialogType.OK, DialogIcon.Exclamation);
}
finally
{
// --- Ampulheta OFF
Cursor.Current = Cursors.Default;
}
}
/// <summary>
/// metodo para adjuntar una ruta
/// </summary>
private async void adjuntarruta()
{
DialogService dialog = new DialogService();
Microsoft.Win32.OpenFileDialog dlg = new Microsoft.Win32.OpenFileDialog();
//filtramos los tipos de archivos que se pueden adjuntar
dlg.Filter = "LOTUS Files (.nsf) | *.nsf";
Nullable <bool> result = dlg.ShowDialog();
objUsuario obj = new objUsuario();
if (result == true)
{
try
{
string ruta = (dlg.FileName);
//obtenemos la RUTA del archivo, solo nos interesa la ruta
string filename = dlg.FileName;
obj.extencion = System.IO.Path.GetExtension(filename);
obj.Pathnsf = dlg.FileName;
//volvemos a verificar que la extencion sea .nsf
if (obj.extencion == ".nsf")
{
patnsf = ruta;
}
else
{
await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgExtencionNSF);
}
}
catch (Exception)
{
throw;
}
}
}
public ModificarDatosUsuario(objUsuario SelectedItem)
{
//Asiganmos los valores para que se muestren
if (SelectedItem != null)
{
usuario = SelectedItem.usuario;
nombre = SelectedItem.nombre;
Contraseña = SelectedItem.password;
Apaterno = SelectedItem.APaterno;
Amaterno = SelectedItem.AMaterno;
correo = SelectedItem.Correo;
if (string.IsNullOrEmpty(SelectedItem.Pathnsf))
{
patnsf = "";
}
else
{
patnsf = SelectedItem.Pathnsf;
}
ListaTotdosRoles = DataManagerControlDocumentos.GetRol();
Encriptacion encriptar = new Encriptacion();
string user = encriptar.encript(SelectedItem.usuario);
ListaRol = DataManagerControlDocumentos.GetRol_Usuario(user);
//muestra los roles que el usuario tenga
foreach (var item in ListaTotdosRoles)
{
if (existe(item.id_rol, ListaRol))
{
item.selected = true;
}
}
}
}
private void btnUserPermissao_Click(object sender, EventArgs e)
{
objUsuario usuario = GetSelectedItem();
if (usuario == null)
{
btnAlterarAtivo.Enabled = false;
return;
}
else if (usuario.UsuarioAcesso == 1)
{
AbrirDialog("O acesso desse usuário já ilimitado...\n" +
"Não há necessidade de definir o acesso para um usuário ADMINISTRADOR.",
"Definir Acesso");
return;
}
try
{
// --- Ampulheta ON
Cursor.Current = Cursors.WaitCursor;
frmUsuarioContaAcesso frm = new frmUsuarioContaAcesso(usuario, this);
frm.ShowDialog();
}
catch (Exception ex)
{
AbrirDialog("Uma exceção ocorreu ao Abrir formulário de Permissão..." + "\n" +
ex.Message, "Exceção", DialogType.OK, DialogIcon.Exclamation);
}
finally
{
// --- Ampulheta OFF
Cursor.Current = Cursors.Default;
}
}
// SUB NEW
//------------------------------------------------------------------------------------------------------------
public frmUsuario(objUsuario obj, EnumFormUsuarioFuncao Funcao)
{
InitializeComponent();
_usuario = obj;
_funcao = Funcao;
bind.DataSource = _usuario;
BindingCreator();
_usuario.PropertyChanged += RegistroAlterado;
if (_usuario.IDUsuario == null)
{
Sit = EnumFlagEstado.NovoRegistro;
}
else
{
Sit = EnumFlagEstado.RegistroSalvo;
}
// ADD HANDLERS
HandlerKeyDownControl(this);
txtUsuarioNovo.Validating += (a, b) => PrimeiraLetraMaiuscula(txtUsuarioNovo);
}
/// <summary>
/// Metodo para guardar los cambios hechos a los datos del usuario
/// </summary>
private async void guardardatos()
{
DialogService dialog = new DialogService();
MetroDialogSettings botones = new MetroDialogSettings();
botones.AffirmativeButtonText = StringResources.lblYes;
botones.NegativeButtonText = StringResources.lblNo;
MessageDialogResult result = await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgConfirmacion, botones, MessageDialogStyle.AffirmativeAndNegative);
if (result == MessageDialogResult.Affirmative)
{
//si no se modifico el campo de contraseña pasaremos a guardar los demas datos
//pero si se modifico haremos las validaciones correspondientes
if (string.IsNullOrEmpty(_contraseña) || string.IsNullOrEmpty(_confirmarContraseña))
{
//declaramos el objeto para encriptar el usuario
Encriptacion encriptar = new Encriptacion();
//declaramos un objeto de tipo usuarios
objUsuario nuevosdatos = new objUsuario();
//pasamos los valores
nuevosdatos.usuario = encriptar.encript(_usuario);
nuevosdatos.nombre = _nombre;
nuevosdatos.password = Contraseña;
nuevosdatos.APaterno = _Apaterno;
nuevosdatos.AMaterno = _Amaterno;
nuevosdatos.Correo = _correo;
nuevosdatos.Pathnsf = _patnsf;
//datos por default
nuevosdatos.usql = "´©³¶´¦³";
nuevosdatos.psql = "´‰“sqrr";
//insertamos los cambios a la BD
int DatosUsuarios = DataManagerControlDocumentos.UpdateUsuario(nuevosdatos);
//obtenemos los roles que tiene un usuario
Usuario Dusuario = new Usuario();
Dusuario.NombreUsuario = nuevosdatos.usuario;
//borramos todos los roles que tenga un usuario
int borrar = DataManagerControlDocumentos.DeleteRol_Usuario(nuevosdatos.usuario);
//agregamos los roles
foreach (var item in ListaTotdosRoles)
{
if (item.selected == true)
{
Model.ControlDocumentos.Rol ObjRol = new Model.ControlDocumentos.Rol();
//asignamos los valores
ObjRol.id_rol = item.id_rol;
ObjRol.id_usuario = nuevosdatos.usuario;
//insertamos los cambios en la BD
int id_rolusuario = DataManagerControlDocumentos.SetRol_Usuario(ObjRol);
}
}
IList RolesUsuario = DataManager.GetRoles(Dusuario.NombreUsuario);
Dusuario.Roles = new List <Model.Rol>();
foreach (var item in RolesUsuario)
{
System.Type tipo = item.GetType();
Model.Rol rol = new Model.Rol();
rol.idRol = (int)tipo.GetProperty("ID_ROL").GetValue(item, null);
rol.NombreRol = (string)tipo.GetProperty("NOMBRE_ROL").GetValue(item, null);
//los agregamos a la propiedad de roles
Dusuario.Roles.Add(rol);
}
//eliminar todos los registros de perfil y privilegio.
DataManager.DeLete_PerfilUsuario(encriptar.encript(_usuario));
DataManager.DeletePrivilegiosUsuario(encriptar.encript(_usuario));
//si el usuario tiene rol de dueño de documento o administrador de CIT
if (Module.UsuarioIsRol(Dusuario.Roles, 2) || Module.UsuarioIsRol(Dusuario.Roles, 3))
{
Dusuario.PerfilCIT = true;
}
//si el usuario tiene rol de ingeniero
if (Module.UsuarioIsRol(Dusuario.Roles, 4) || Module.UsuarioIsRol(Dusuario.Roles, 5) || Module.UsuarioIsRol(Dusuario.Roles, 6) || Module.UsuarioIsRol(Dusuario.Roles, 7))
{
Dusuario.PerfilData = true;
Dusuario.PerfilQuotes = true;
Dusuario.PerfilRawMaterial = true;
Dusuario.PerfilStandarTime = true;
Dusuario.PerfilTooling = true;
Dusuario.PerfilUserProfile = true;
Dusuario.PerfilRGP = true;
}
//si el usuario tiene rol de administrador de sistema
if (Module.UsuarioIsRol(Dusuario.Roles, 1))
{
Dusuario.PerfilCIT = true;
Dusuario.PerfilData = true;
Dusuario.PerfilHelp = true;
Dusuario.PerfilQuotes = true;
Dusuario.PerfilRawMaterial = true;
Dusuario.PerfilStandarTime = true;
Dusuario.PerfilTooling = true;
Dusuario.PerfilUserProfile = true;
Dusuario.PerfilRGP = true;
}
//agregamos los perfiles y privilegios correspondientes
DataManager.Set_PerfilUsuario(Dusuario);
DataManager.Set_PrivilegiosUsuario(Dusuario);
await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgCambiosRealizados);
//obtenemos la ventana anterior
var window = Application.Current.Windows.OfType <MetroWindow>().LastOrDefault();
if (window != null)
{
//Cerramos la pantalla actual
window.Close();
}
}
else
{
//verificamos que la longitud de la contraseña sea mayor o igual que 6
if (_contraseña.Length >= 6)
{
//verificamos que los campos de contraseña y confirmar contraseña sean iguales
if (_contraseña.Equals(_confirmarContraseña))
{
//declaramos el objeto con el cual se encripta la contraseña
Encriptacion encriptar = new Encriptacion();
//declaramos un objeto de tipo usuarios
objUsuario nuevosdatos = new objUsuario();
//pasaremos los valores
nuevosdatos.usuario = encriptar.encript(_usuario);
nuevosdatos.nombre = _nombre;
nuevosdatos.APaterno = _Apaterno;
nuevosdatos.AMaterno = _Amaterno;
nuevosdatos.Correo = _correo;
nuevosdatos.password = encriptar.encript(_contraseña);
nuevosdatos.Pathnsf = _patnsf;
nuevosdatos.usql = "´©³¶´¦³";
nuevosdatos.psql = "´‰“sqrr";
//insertamos los datos a la BD
int datosusuario = DataManagerControlDocumentos.UpdateUsuario(nuevosdatos);
Usuario Dusuario = new Usuario();
Dusuario.NombreUsuario = nuevosdatos.usuario;
//borramos todos los roles que tenga un usuario
int borrar = DataManagerControlDocumentos.DeleteRol_Usuario(nuevosdatos.usuario);
foreach (var item in ListaTotdosRoles)
{
if (item.selected == true)
{
Model.ControlDocumentos.Rol ObjRol = new Model.ControlDocumentos.Rol();
ObjRol.id_rol = item.id_rol;
ObjRol.id_usuario = nuevosdatos.usuario;
//le agregamos el rol a cada usuario
int id_RolUsuario = DataManagerControlDocumentos.SetRol_Usuario(ObjRol);
}
}
//obtenemos los roles del usuario
IList RolesUsuario = DataManager.GetRoles(Dusuario.NombreUsuario);
Dusuario.Roles = new List <Model.Rol>();
foreach (var item in RolesUsuario)
{
System.Type tipo = item.GetType();
Model.Rol rol = new Model.Rol();
rol.idRol = (int)tipo.GetProperty("ID_ROL").GetValue(item, null);
rol.NombreRol = (string)tipo.GetProperty("NOMBRE_ROL").GetValue(item, null);
//los agregamos a la propiedad de roles
Dusuario.Roles.Add(rol);
}
//borramos el perfil y los privilegios que tenga el usuario
DataManager.DeLete_PerfilUsuario(encriptar.encript(_usuario));
DataManager.DeletePrivilegiosUsuario(encriptar.encript(_usuario));
//si el usuario tiene rol de dueño de documento o administrador de CIT
if (Module.UsuarioIsRol(Dusuario.Roles, 2) || Module.UsuarioIsRol(Dusuario.Roles, 3))
{
Dusuario.PerfilCIT = true;
}
//si el usuario tiene rol de ingeniero
if (Module.UsuarioIsRol(Dusuario.Roles, 4) || Module.UsuarioIsRol(Dusuario.Roles, 5) || Module.UsuarioIsRol(Dusuario.Roles, 6) || Module.UsuarioIsRol(Dusuario.Roles, 7))
{
Dusuario.PerfilData = true;
Dusuario.PerfilQuotes = true;
Dusuario.PerfilRawMaterial = true;
Dusuario.PerfilStandarTime = true;
Dusuario.PerfilTooling = true;
Dusuario.PerfilUserProfile = true;
Dusuario.PerfilRGP = true;
}
//si el usuario tiene rol de administrador
if (Module.UsuarioIsRol(Dusuario.Roles, 1))
{
Dusuario.PerfilCIT = true;
Dusuario.PerfilData = true;
Dusuario.PerfilHelp = true;
Dusuario.PerfilQuotes = true;
Dusuario.PerfilRawMaterial = true;
Dusuario.PerfilStandarTime = true;
Dusuario.PerfilTooling = true;
Dusuario.PerfilUserProfile = true;
Dusuario.PerfilRGP = true;
}
//asignamos los perfiles y los privilegios correspondientes
DataManager.Set_PerfilUsuario(Dusuario);
DataManager.Set_PrivilegiosUsuario(Dusuario);
await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgCambiosRealizados);
//obtenemos la ventana anterior
var window = Application.Current.Windows.OfType <MetroWindow>().LastOrDefault();
if (window != null)
{
//Cerramos la pantalla actual
window.Close();
}
}
else
{
await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgContraseñaDiferente);
}
}
else
{
await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgContraseñaCorta);
}
}
}
}
// BUTTON CLICK
//------------------------------------------------------------------------------------------------------------
private void btnOK_Click(object sender, EventArgs e)
{
if (!VerificaCampos())
{
return;
}
try
{
// --- Ampulheta ON
Cursor.Current = Cursors.WaitCursor;
objUsuario obj = db.GetAuthorization(txtApelido.Text, txtSenha.Text);
Program.usuarioAtual = obj;
Logado = true;
string AcessoTipo = Program.usuarioAtual.UsuarioAcessoDesc;
//--- Bem-vindo
AbrirDialog("Seja Bem-Vindo: " + txtApelido.Text.ToUpper() + "\n \n" +
"Acesso: " + AcessoTipo.ToUpper(), TituloIgreja,
DialogType.OK,
DialogIcon.Information);
DialogResult = DialogResult.Yes;
Close();
}
catch (AppException ex)
{
switch (db.TentativasAcesso)
{
case 1:
MessageBox.Show(ex.Message + "\n" +
"Tente novamente..." + "\n" +
"PRIMEIRA TENTATIVA, você pode tentar mais DUAS vezes",
"Senha e/ou Usuário Incorreto",
MessageBoxButtons.OK, MessageBoxIcon.Information);
txtApelido.Focus();
break;
case 2:
MessageBox.Show("Usuário ou Senha estão incorretas! \n" +
"Tente novamente...\n" +
"SEGUNDA TENTATIVA, você pode tentar mais UMA vezes",
"Senha e/ou Usuário Incorreto",
MessageBoxButtons.OK, MessageBoxIcon.Information);
txtApelido.Focus();
break;
case 3:
MessageBox.Show("Usuário ou Senha estão incorretas!\n" +
"TERCEIRA TENTATIVA, a aplicação será encerrada...",
"Erro de Senha e Usuário",
MessageBoxButtons.OK, MessageBoxIcon.Stop);
Logado = false;
Close();
return;
default:
break;
}
}
catch (Exception ex)
{
AbrirDialog("Uma exceção ocorreu ao Conectar o BD SQL... \n" +
"Verique a conexão com o servidor e tente novamente... \n" +
ex.Message, "Conexão Inválida",
DialogType.OK,
DialogIcon.Exclamation);
Logado = false;
Close();
return;
}
finally
{
// --- Ampulheta OFF
Cursor.Current = Cursors.Default;
}
}
// RESPONDER MENSAGEM SELECIONADA
//------------------------------------------------------------------------------------------------------------
private void ResponderMensagem()
{
if (dgvListagem.SelectedRows.Count == 0)
{
AbrirDialog("Selecione uma mensagem para Responder...", "Selecionar");
return;
}
//--- get selected message
objMensagem mensagem = (objMensagem)dgvListagem.SelectedRows[0].DataBoundItem;
//--- check if mensagem is RECEBIDA
if (!mensagem.Recebida)
{
AbrirDialog("Para responder uma mensagem, a mesma deve estar marcada como mensagem LIDA..." +
"Favor marcar essa mensagem com LIDA.",
"Responder Mensagem", DialogType.OK, DialogIcon.Exclamation);
return;
}
try
{
// --- Ampulheta ON
Cursor.Current = Cursors.WaitCursor;
//--- Define Destination User message
objUsuario userDestino = new objUsuario(mensagem.IDUsuarioOrigem)
{
UsuarioApelido = mensagem.UsuarioOrigem
};
//--- create new mensagem
var novaMensagem = new objMensagem()
{
IDMensagem = null,
IDUsuarioDestino = (int)userDestino.IDUsuario,
IDUsuarioOrigem = (int)Program.usuarioAtual.IDUsuario,
IsResposta = true,
IDOrigem = mensagem.IDMensagem,
Mensagem = "",
MensagemData = DateTime.Today,
MensagemOrigem = mensagem,
Recebida = false,
RecebidaData = null,
Suporte = false,
UsuarioOrigem = Program.usuarioAtual.UsuarioApelido,
UsuarioDestino = userDestino.UsuarioApelido
};
//--- open form mensagem
var frmM = new frmMensagemEditar(novaMensagem, userDestino, this);
frmM.ShowDialog();
if (frmM.DialogResult != DialogResult.OK)
{
return;
}
EnviarMensagem(novaMensagem);
}
catch (Exception ex)
{
AbrirDialog("Uma exceção ocorreu ao Enviar a Resposta da Mensagem..." + "\n" +
ex.Message, "Exceção", DialogType.OK, DialogIcon.Exclamation);
}
finally
{
// --- Ampulheta OFF
Cursor.Current = Cursors.Default;
}
}
// CHANGE USUARIO
//------------------------------------------------------------------------------------------------------------
private void AlterarUsuario(Control controle)
{
try
{
objUsuario usuario = null;
if (controle == btnAdicionar)
{
usuario = new objUsuario(null);
}
else
{
usuario = GetSelectedItem();
if (usuario == null)
{
return;
}
}
// --- Ampulheta ON
Cursor.Current = Cursors.WaitCursor;
frmUsuario.EnumFormUsuarioFuncao funcao = frmUsuario.EnumFormUsuarioFuncao.Alterar_Senha;
switch (controle.Name)
{
case "btnAdicionar":
funcao = frmUsuario.EnumFormUsuarioFuncao.Novo_Usuario;
break;
case "btnAlterarSenha":
funcao = frmUsuario.EnumFormUsuarioFuncao.Alterar_Senha;
break;
case "btnAlterarEmail":
funcao = frmUsuario.EnumFormUsuarioFuncao.Alterar_Email;
break;
case "btnAlterarAcesso":
funcao = frmUsuario.EnumFormUsuarioFuncao.Alterar_Acesso;
break;
case "lstUsuarios":
funcao = frmUsuario.EnumFormUsuarioFuncao.Alterar_Email;
break;
default:
break;
}
frmUsuario frm = new frmUsuario(usuario, funcao);
// hide forms
this.Visible = false;
_formOrigem.Visible = false;
lstUsuarios.SelectedIndexChanged -= lstUsuarios_SelectedIndexChanged;
// show Usuario Form
frm.ShowDialog();
// show forms
this.Visible = true;
_formOrigem.Visible = true;
// requery list
ObterDados();
// select old usuario in list
if (usuario != null && lstUsuarios.Items.Count > 0)
{
foreach (var item in lstUsuarios.Items)
{
if (Convert.ToInt32(item.Text) == usuario.IDUsuario)
{
item.Selected = true;
item.EnsureVisible();
}
else
{
item.Selected = false;
}
}
}
else
{
lstUsuarios.Items.ToList().ForEach(x => x.Selected = false); // unselect all items
lstUsuarios.Items.Last().Selected = true; // select last item
}
// restore Handler to list changed item
lstUsuarios.SelectedIndexChanged += lstUsuarios_SelectedIndexChanged;
}
catch (Exception ex)
{
AbrirDialog("Uma exceção ocorreu ao Abrir formulário de Alteração..." + "\n" +
ex.Message, "Exceção", DialogType.OK, DialogIcon.Exclamation);
}
finally
{
// --- Ampulheta OFF
Cursor.Current = Cursors.Default;
}
}
public async void guardarUsuario()
{
//Incializamos los servicios de dialog.
DialogService dialog = new DialogService();
//Declaramos un objeto de tipo MetroDialogSettings al cual le asignamos las propiedades que contendra el mensaje modal.
MetroDialogSettings setting = new MetroDialogSettings();
setting.AffirmativeButtonText = StringResources.lblYes;
setting.NegativeButtonText = StringResources.lblNo;
//Ejecutamos el método para mostrar el mensaje. El resultado lo asignamos a una variable local.
MessageDialogResult result = await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgConfirmacion, setting, MessageDialogStyle.AffirmativeAndNegative);
if (result == MessageDialogResult.Affirmative)
{
//Valida que los campos no estén vacíos.
if (Validar() & ValidarSelected())
{
// Asignamos el valor de la constraseña random
_contraseña = this.GenerarPasswordAleatoria();
if (_contraseña.Length >= 6)
{
//Declaramos un objeto con el cual se realiza la encriptación
Encriptacion encriptar = new Encriptacion();
//Declaramos un objeto de tipo usuarios
objUsuario objUsuario = new objUsuario();
//Asignamos los valores al objeto
objUsuario.usuario = encriptar.encript(_usuario);
objUsuario.nombre = _nombre;
objUsuario.APaterno = _aPaterno;
objUsuario.AMaterno = _aMaterno;
objUsuario.password = encriptar.encript(_contraseña);
objUsuario.Correo = Correo;
objUsuario.Pathnsf = "";
//datos por default
objUsuario.usql = "´©³¶´¦³";
objUsuario.psql = "´‰“sqrr";
//Valida que el nombre de usuario no se repita
string validate = DataManagerControlDocumentos.ValidateUsuario(objUsuario);
//si no se repite
if (validate == null)
{
// Nos aseguramos que sean iguales
_confirmarContraseña = _contraseña;
//si las contraseñas son iguales
if (_contraseña.Equals(_confirmarContraseña))
{
//ejecutamos el método para insertar un registro a la tabla
string usuario = DataManagerControlDocumentos.SetUsuario(objUsuario);
// Declaramos la ruta para asignarle una foto de usuario por default
string url_foto = @"\\MXAGSQLSRV01\documents__\ESPECIFICOS\img\defaultuser.jpg";
// Declaramos valor para el campo
bool is_available_email = true;
bool temporal_password = true;
// Ejecutamos el método para insertar los registros a la tabla TBL_USER_DETAILS
DataManagerControlDocumentos.Insert_UserDetail(objUsuario.usuario, url_foto, is_available_email, temporal_password);
Usuario _usuario = new Usuario();
_usuario.NombreUsuario = usuario;
//si el usuario es diferente de vacío
if (usuario != string.Empty)
{
//Recorremos la lista de roles
foreach (var item in _listaRol)
{
//si el rol fue seleccionado
if (item.selected == true)
{
Model.ControlDocumentos.Rol objRol = new Model.ControlDocumentos.Rol();
objRol.id_rol = item.id_rol;
objRol.id_usuario = usuario;
//Agregamos el rol de cada usuario
int id_rolUsuario = DataManagerControlDocumentos.SetRol_Usuario(objRol);
}
}
//Obtenemos los roles del usuario nuevo
IList Roles = DataManager.GetRoles(_usuario.NombreUsuario);
_usuario.Roles = new List <Model.Rol>();
foreach (var item in Roles)
{
System.Type tipo = item.GetType();
Model.Rol rol = new Model.Rol();
rol.idRol = (int)tipo.GetProperty("ID_ROL").GetValue(item, null);
rol.NombreRol = (string)tipo.GetProperty("NOMBRE_ROL").GetValue(item, null);
//los agregamos a la propiedad de roles
_usuario.Roles.Add(rol);
}
//si el usuario tiene rol de administrador de CIT o dueño de documento
if (Module.UsuarioIsRol(_usuario.Roles, 2) || Module.UsuarioIsRol(_usuario.Roles, 3))
{
//usuario es admin del cit o dueño del documento
_usuario.PerfilCIT = true;
}
//si el usuario tiene rol de ingeniero
if (Module.UsuarioIsRol(_usuario.Roles, 4) || Module.UsuarioIsRol(_usuario.Roles, 5) || Module.UsuarioIsRol(_usuario.Roles, 6) || Module.UsuarioIsRol(_usuario.Roles, 7))
{
//usuario tiene rol de ingeniero
_usuario.PerfilUserProfile = true;
_usuario.PerfilData = true;
_usuario.PerfilQuotes = true;
_usuario.PerfilRawMaterial = true;
_usuario.PerfilStandarTime = true;
_usuario.PerfilTooling = true;
_usuario.PerfilRGP = true;
}
//si el usuario tiene rol de administrador del sistema
if (Module.UsuarioIsRol(_usuario.Roles, 1))
{
//Es administrador
_usuario.PerfilCIT = true;
_usuario.PerfilData = true;
_usuario.PerfilHelp = true;
_usuario.PerfilQuotes = true;
_usuario.PerfilRawMaterial = true;
_usuario.PerfilStandarTime = true;
_usuario.PerfilTooling = true;
_usuario.PerfilUserProfile = true;
_usuario.PerfilRGP = true;
}
//agregamos los perfiles y privilegios correspondientes
DataManager.Set_PerfilUsuario(_usuario);
DataManager.Set_PrivilegiosUsuario(_usuario);
//se muestra un mensaje de cambios realizados.
await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgUsuarioAlta);
//Obtenemos la ventana actual.
var window = Application.Current.Windows.OfType <MetroWindow>().LastOrDefault();
//Verificamos que la pantalla sea diferente de nulo.
if (window != null)
{
//Cerramos la pantalla
window.Close();
}
// Declaramos el cuerpo y título del correo
string title = "Tu usuario ha sido creado";
string body = "";
// Declaramos lista vacía para el parámetro
ObservableCollection <Archivo> ListaVacia = new ObservableCollection <Archivo>();
// Declaramos el objeto
Usuario UserCreated = new Usuario();
// Obtenemos el nuevo usuario creado
UserCreated = DataManager.GetUsuario(objUsuario.usuario);
// Declaramos lista para guardar el nuevo usuario
List <objUsuario> ListaUserCreated = new List <objUsuario>();
objUsuario userCreado = new objUsuario();
// Igualamos valores
userCreado.Correo = UserCreated.Correo;
userCreado.nombre = UserCreated.Nombre;
userCreado.APaterno = UserCreated.ApellidoPaterno;
userCreado.AMaterno = UserCreated.ApellidoMaterno;
userCreado.Details = UserCreated.Details;
ListaUserCreated.Add(userCreado);
// Cargamos el cuerpo del correo
body = "<P> Le envío su usuario y contraseña:</P>";
body += "<P><STRONG> Usuario:</STRONG> " + encriptar.desencript(_usuario.NombreUsuario) + "</P>";
body += "<P><STRONG> Contraseña:</STRONG> " + _contraseña + "</P>";
body += "<P> Favor de respetar minúsculas y mayúsculas.</P>";
body += "<P> Para el acceso a la plataforma, favor de ingresar a la siguiente ruta:</P>";
body += "<P><STRONG> TodosP/R@aul/Deploy</STRONG></P>";
body += "<P> En dicha carpeta se encuentra un archivo llamado View.exe. Favor de ejecutarlo.</P>";
// Abrimos ventana para notificar
NotificarAViewModel vmNotificar = new NotificarAViewModel(User, body, ListaVacia, ListaUserCreated, title, "ALTA_USUARIO", 0);
WNotificarA ventanaCorreo = new WNotificarA();
ventanaCorreo.DataContext = vmNotificar;
ventanaCorreo.ShowDialog();
}
else
{
await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgUsuarioAltaError);
}
}
else
{
await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgContraseñaDiferente);
}
}
else
{
await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgUsuarioExistente);
}
}
else
{
await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgContraseñaCorta);
}
}
else
{
await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgFillFlields);
}
}
}
