/// <summary>
/// Metodo que almacena a un PerfilUsuario
/// </summary>
/// <param name="myPerfilUsuario">Objeto de tipo PerfilUsuario que se va almacenar</param>
/// <returns>retorna 1 si la transaccion se realizo con exito de lo contrario retorna 0</returns>
public static int Save(PerfilUsuario myPerfilUsuario)
{
int result = 0;
using (SqlConnection myConnection = new SqlConnection(AppConfiguration.ConnectionString))
{
SqlCommand myCommand = new SqlCommand("spPerfilUsuarioUpsert", myConnection);
myCommand.CommandType = CommandType.StoredProcedure;
myCommand.Parameters.AddWithValue("@Perf_Id", -1);
myCommand.Parameters.AddWithValue("@Usu_Login", myPerfilUsuario.Usu_login);
myCommand.Parameters.AddWithValue("@Concept_Id", myPerfilUsuario.ConceptId);
myCommand.Parameters.AddWithValue("@Wrud", myPerfilUsuario.Wrud);
DbParameter returnValue;
returnValue = myCommand.CreateParameter();
returnValue.Direction = ParameterDirection.ReturnValue;
myCommand.Parameters.Add(returnValue);
myConnection.Open();
myCommand.ExecuteNonQuery();
result = Convert.ToInt32(returnValue.Value);
myConnection.Close();
}
return(result);
}
public override void Nuevo()
{
try
{
Cursor.Current = Cursors.WaitCursor;
base.Nuevo();
using (var frm = new frmMntPerfilUsuario(PerfilUsuario.NewPerfilUsuario()))
if (frm.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
Buscar();
}
}
catch (DataPortalException ex)
{
XtraMessageBox.Show(ex.BusinessException.Message,
"Nuevo",
MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
}
catch (Exception ex)
{
XtraMessageBox.Show(ex.Message,
"Nuevo",
MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
}
finally
{
Cursor.Current = Cursors.Default;
}
}
public JsonResult RecuperarContrasena(string email)
{
Entidades.PerfilUsuario usuario = new PerfilUsuario();
List <Entidades.Usuario> ListUsuario = new List <Entidades.Usuario>();
Negocio.Usuario.Usuario Usuario = new Negocio.Usuario.Usuario();
List <Parametro> ListParametro = new List <Parametro>();
Parametro parametro = new Parametro();
ResultadoUsuario resultadoUsuario = new Models.Usuario.ResultadoUsuario();
const string key = "idaeconomia";
try
{
parametro = new Parametro();
parametro.Nombre = "Correo";
parametro.Valor = email;
ListParametro.Add(parametro);
usuario = Usuario.RecuperarContrasena(ListParametro);
string resultadoCorreo = Negocio.Correo.EnvioCorreo.Recuperacion(usuario.Correo);
}
catch (Exception ex)
{
}
return(Json(email, JsonRequestBehavior.AllowGet));
}
public PerfilUsuario ListarPorId(long id)
{
var retorno = new List <PerfilUsuario>();
var commandText = PerfilUsuarioSQL.ListarPorId;
var parametros = new Dictionary <string, object>
{
{ "id", id }
};
var linhas = contexto.ExecutaComandoComRetorno(commandText, parametros);
foreach (var row in linhas)
{
var tempPerfilUsuario = new PerfilUsuario
{
id = row["id"].ToLong(),
nomePerfil = row["nomePerfil"],
descricao = row["descricao"]
};
retorno.Add(tempPerfilUsuario);
}
return(retorno.FirstOrDefault());
}
public async Task <IActionResult> Create(string nome_vendedor, [Bind("Id,IdTipoUsuario,UserId")] PerfilUsuario perfilUsuario)
{
if (ModelState.IsValid)
{
//Verificar se perfil Usuario já existe
if (PerfilUsuarioExistsTipo(perfilUsuario.IdTipoUsuario, perfilUsuario.UserId))
{
TempData["MSG_E"] = Mensagem.MSG_E010;
return(RedirectToAction(nameof(Create)));
}
_context.Add(perfilUsuario);
//inserir na tabela Vendedor
if (nome_vendedor != null && nome_vendedor != "" && _context.TipoUsuario.Any(v => v.Id == perfilUsuario.IdTipoUsuario && (v.NomeTipoUsuario == "Vendedor" || v.NomeTipoUsuario == "vendedor")))
{
var email = _context.Users.FirstOrDefault(u => u.Id == perfilUsuario.UserId).Email;
var vendedor = new Vendedor()
{
Nome = nome_vendedor, Email = email, UserId = perfilUsuario.UserId
};
_context.Vendedor.Add(vendedor);
}
await _context.SaveChangesAsync();
TempData["MSG_S"] = Mensagem.MSG_S001;
return(RedirectToAction(nameof(Index)));
}
ViewData["UserId"] = new SelectList(_context.Users, "Id", "Email", perfilUsuario.UserId);
ViewData["IdTipoUsuario"] = new SelectList(_context.TipoUsuario, "Id", "NomeTipoUsuario", perfilUsuario.IdTipoUsuario);
return(View(perfilUsuario));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,IdTipoUsuario,UserId")] PerfilUsuario perfilUsuario)
{
if (id != perfilUsuario.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(perfilUsuario);
await _context.SaveChangesAsync();
TempData["MSG_S"] = Mensagem.MSG_S001;
}
catch (DbUpdateConcurrencyException)
{
if (!PerfilUsuarioExists(perfilUsuario.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["UserId"] = new SelectList(_context.Users, "Id", "Email", perfilUsuario.UserId);
ViewData["IdTipoUsuario"] = new SelectList(_context.TipoUsuario, "Id", "NomeTipoUsuario", perfilUsuario.IdTipoUsuario);
return(View(perfilUsuario));
}
private void EjecutarBusqueda()
{
var listaUsuarios = AccesoDatos.DevolverNombresUsuario();
var esta = false;
foreach (string elem in listaUsuarios)
{
if (txtBuscar.Text == elem)
{
esta = true;
}
}
if (txtBuscar.Text == "")
{
//Si intentas buscar con el campo vacio no haces nada
}
else if (esta) //Si el nombre de usuario suministrado por el txtbox existe en la base de datos, procedes
{
listaImagenes = AccesoDatos.DevolverImagenes(txtBuscar.Text);
var perfilUsuario = new PerfilUsuario(txtBuscar.Text, this, listaImagenes);
perfilUsuario.Show();
}
}
public frmPerfilUsuarioCadastrar(frmListaPerfil pai, PerfilUsuario perfil, int tipoTela)
{
InitializeComponent();
frmPai = pai;
TipoTela = tipoTela;
Perfil = perfil;
if (TipoTela == 1)
{
modoConsultar();
carregarPerfilTela();
}
else if (TipoTela == 2)
{
carregarPerfilTela();
}
List <IconButton> listBtn = new List <IconButton>();
listBtn.Add(btnSalvar);
listBtn.Add(btnVoltar);
DefaultLayout defaultLayout = new DefaultLayout();
defaultLayout.FormDefaultFilha(this, listBtn);
}
// CONSULTAR Progresso Usuario: PerfilUsuario(CLASSE)
public PerfilUsuario ConsultarProgressoUsuario(string CodProgresso)
{
try
{
PerfilUsuario perfilUsuario = new PerfilUsuario();
acessoBDSql.LimparParametros();
acessoBDSql.AdicionarParametros("@Cod_progresso", CodProgresso);
DataTable dataTableProgresso = acessoBDSql.ExecutaConsulta(System.Data.CommandType.StoredProcedure, "ProgressoConsultar");
foreach (DataRow linha in dataTableProgresso.Rows)
{
PerfilUsuario perfilUsuarioConsulta = new PerfilUsuario();
perfilUsuarioConsulta.Cod_Progresso = Convert.ToInt32(linha["Cod_Progresso"]);
perfilUsuarioConsulta.cod_teste = Convert.ToInt32(linha["Cod_teste"]);
perfilUsuarioConsulta.licao_usuario = Convert.ToInt32(linha["Licao_Usuario"]);
perfilUsuarioConsulta.modulo_usuario = Convert.ToInt32(linha["Modulo_Usuario"]);
perfilUsuarioConsulta.progresso_usuario = Convert.ToInt32(linha["Progre_usuario"]);
perfilUsuario.Equals(perfilUsuario);
}
return(perfilUsuario);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public Usuario(int idUsuario, PerfilUsuario perfil, string login, string senha)
{
IdUsuario = idUsuario;
Perfil = perfil;
Login = login;
Senha = senha;
AddNotifications(new Contract()
.Requires()
.IsNotNullOrWhiteSpace(Login, nameof(Login), "O campo Login é obrigatório"));
AddNotifications(new Contract()
.Requires()
.IsNotNullOrWhiteSpace(Senha, nameof(Senha), "O campo Senha é obrigatório"));
AddNotifications(new Contract()
.Requires()
.IsLowerOrEqualsThan(0, IdUsuario, nameof(IdUsuario), "O campo IdUsuario é inválido"));
if (Perfil == PerfilUsuario.Cliente)
{
AddNotifications(new Contract()
.Requires()
.HasLen(Login, 11, nameof(Login), "O campo é Login inválido: O campo CPF deve conter 11 dígitos")
.IsDigit(Login, nameof(Login), "O campo é Login inválido: O campo CPF deve conter apenas números"));
}
}
private void nuevoPerfilToolStripMenuItem_Click(object sender, EventArgs e)
{
try
{
Cursor.Current = Cursors.WaitCursor;
using (var frm = new frmMntPerfilUsuario(PerfilUsuario.NewPerfilUsuario()))
if (frm.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
CargarPerfiles(tvwAplicaciones.SelectedNode.Name);
}
}
catch (DataPortalException ex)
{
XtraMessageBox.Show(ex.BusinessException.Message,
"Nuevo Perfil de Usuario",
MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
}
catch (Exception ex)
{
XtraMessageBox.Show(ex.Message,
"Nuevo Perfil de Usuario",
MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
}
finally
{
Cursor.Current = Cursors.Default;
}
}
public PerfilUsuario GetPerfilAccesoPerfil(string siglaUsuario, int nroBizFlow, int idEstadoBisFlow)
{
PerfilUsuario perUsuario = new PerfilUsuario();
var estadoFormulario = 0;
var areaAsocBizFlow = this.persistenceAccesoPerfil.GetAreaAsociadaNroBizFlow(idEstadoBisFlow);
UsuarioDto usuario = this.persistenceAccesoPerfil.GetUsuario(siglaUsuario);
var areaPorUsuario = usuario.ID_AREA;
if (areaPorUsuario < areaAsocBizFlow)
{
estadoFormulario = (int)ServiciosParametrica.Ocupado;
}
else if (areaPorUsuario == areaAsocBizFlow)
{
var existePoliza = this.persistenceAccesoPerfil.GetExistePoliza(nroBizFlow);
if (existePoliza == 0)
{
estadoFormulario = (int)ServiciosParametrica.Disponible;
}
else
{
estadoFormulario = this.persistenceAccesoPerfil.GetEstadoFomulario(nroBizFlow);
}
}
if (estadoFormulario > 0)
{
perUsuario.PermisoPestana = this.persistenceAccesoPerfil.GetPermisoFormulario(estadoFormulario, siglaUsuario);
perUsuario.siglaUsuario = usuario.SIGLA_USUARIO;
perUsuario.NombreUsuario = usuario.NOMBRE;
perUsuario.NroBizflow = nroBizFlow;
}
return(perUsuario);
}
public async void PerfilUsuarioControllerIntegrationTest_ConsigoPostEDelete()
{
var perfilUsuario = new PerfilUsuario
{
Id = Guid.NewGuid(),
IdPerfil = Guid.NewGuid(),
IdUsuario = Guid.NewGuid(),
Ativo = true,
DataInclusao = new DateTime(2016, 1, 30)
};
using (var client = _server.CreateClient().AcceptJson())
{
var postResponse = await client.PostAsJsonAsync("/api/v1/PerfilUsuario", perfilUsuario);
var created = await postResponse.Content.ReadAsJsonAsync <PerfilUsuario>();
var deleteResponse = await client.DeleteAsync("/api/v1/PerfilUsuario/" + created.Id);
var getAllResponse = await client.GetAsync("/api/v1/PerfilUsuario/");
var all = await getAllResponse.Content.ReadAsJsonAsync <List <PerfilUsuario> >();
postResponse.IsSuccessStatusCode.Should().BeTrue();
deleteResponse.IsSuccessStatusCode.Should().BeTrue();
getAllResponse.IsSuccessStatusCode.Should().BeTrue();
perfilUsuario.DataInclusao.Should().Be(created.DataInclusao);
created.Id.Should().NotBe(Guid.Empty);
all.Select(x => x.Id).Should().NotContain(perfilUsuario.Id);
}
}
public async Task <IActionResult> Edit(int id, [Bind("IdPerfil,NomePerfil,ÍdTipoUsuario")] PerfilUsuario perfilUsuario)
{
if (id != perfilUsuario.IdPerfil)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(perfilUsuario);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PerfilUsuarioExists(perfilUsuario.IdPerfil))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["ÍdTipoUsuario"] = new SelectList(_context.Set <TipoUsuario>(), "IdTipoUsuario", "IdTipoUsuario", perfilUsuario.ÍdTipoUsuario);
return(View(perfilUsuario));
}
private async Task <bool> ListImport(IFormFile file)
{
List <PerfilUsuario> listImportar = new List <PerfilUsuario>();
if (file.FileName.EndsWith(".csv"))
{
PerfilUsuario perfilUsuario = new PerfilUsuario();
string[] rows;
using (var sreader = new StreamReader(file.OpenReadStream()))
{
string[] headers = sreader.ReadLine().Split(';'); //Title
while (!sreader.EndOfStream) //get all the content in rows
{
rows = sreader.ReadLine().Split(';');
//perfilUsuario.Code = rows[0];
perfilUsuario.Description = rows[1];
listImportar.Add(perfilUsuario);
perfilUsuario = new PerfilUsuario();
}
}
}
//await _perfilUsuarioService.Import(listImportar);
return(true);
}
public PerfilUsuarioColecao ComboBoxConsultar(bool ativo)
{
try
{
PerfilUsuarioColecao perfilUsuarioColecao = new PerfilUsuarioColecao();
sQLServer.LimparParametros();
sQLServer.AdicionarParametros("PFU_Ativo", ativo);
DataTable dataTablePerfilUsuario = sQLServer.ExecutarConsulta(CommandType.StoredProcedure, "PERFIL_USUARIO_CONSULTAR");
foreach (DataRow linha in dataTablePerfilUsuario.Rows)
{
PerfilUsuario perfilUsuario = new PerfilUsuario();
perfilUsuario.IdPerfilUsuario = Convert.ToInt32(linha["PFU_Tid"]);
perfilUsuario.NomePerfilUsuario = Convert.ToString(linha["PFU_Nome"]);
perfilUsuarioColecao.Add(perfilUsuario);
}
return(perfilUsuarioColecao);
}
catch (Exception ex)
{
throw new Exception("Não foi possível consultar os perfis de usuários. Detalhes:" + ex.Message);
}
}
public ActionResult Login(PerfilUsuario objUser)
{
if (ModelState.IsValid)
{
using (restauranteEntities db = new restauranteEntities())
{
var obj = db.PerfilUsuario.Where(a => a.Usuario.Equals(objUser.Usuario) && a.Password.Equals(objUser.Password)).FirstOrDefault();
if (obj != null)
{
obj.IsActive = true;
db.SaveChanges();
Session["Email"] = obj.Email.ToString();
Session["IdUsuario"] = obj.IdUsuario.ToString();
Session["Usuario"] = obj.Usuario.ToString();
Session["isActive"] = obj.IsActive;
FormsAuthentication.SetAuthCookie(Session["Usuario"].ToString(), true);
return(RedirectToAction("Mesa"));
}
else
{
ModelState.AddModelError("LoginFail", "Error, datos incorrectos");
return(View());
}
}
}
return(View(objUser));
}
public override void Editar()
{
base.Editar();
try
{
Cursor.Current = Cursors.WaitCursor;
//Comprobamos que al menos un registro hay sido seleccionado
CargaDatosActuales();
using (var frm = new frmMntPerfilUsuario(PerfilUsuario.GetPerfilUsuario(_PerfilUsuario.ID)))
{
if (frm.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
Buscar();
}
}
}
catch (DataPortalException ex)
{
XtraMessageBox.Show(ex.BusinessException.Message,
"Ver/Editar",
MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
}
catch (Exception ex)
{
XtraMessageBox.Show(ex.Message,
"Ver/Editar",
MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
}
finally
{
Cursor.Current = Cursors.Default;
}
}
public IList <PerfilUsuario> listarPerfiles()
{
AccesoDatos conexion = new AccesoDatos();
IList <PerfilUsuario> lista = new List <PerfilUsuario>();
PerfilUsuario aux;
try
{
//le paso el select a mi objeto conexion (de mi clase custom)
conexion.setearConsulta("select IDPERFILUSUARIO, nombre From PERFILESUSUARIOS");
//ejecuto la lectura
conexion.leerConsulta();
//leo lector que quedó dentro de mi objeto.
while (conexion.Lector.Read())
{
//por cada lectura creo un aux cone el constructor de Marca
aux = new PerfilUsuario();
aux.Id = conexion.Lector.GetInt32(0);
aux.Nombre = conexion.Lector.GetString(1);
//lo agrego a la lista.
lista.Add(aux);
}
return(lista);
}
catch (Exception ex)
{
throw ex;
}
finally
{
conexion.cerrarConexion();
conexion = null;
}
}
public override void Eliminar()
{
base.Eliminar();
try
{
Cursor.Current = Cursors.WaitCursor;
CargaDatosActuales();
if (XtraMessageBox.Show("Desea eliminar el registro?", Text, MessageBoxButtons.YesNo, MessageBoxIcon.Question) == System.Windows.Forms.DialogResult.No)
{
return;
}
PerfilUsuario.DeletePerfilUsuario(_PerfilUsuario.ID);
Buscar();
}
catch (DataPortalException ex)
{
XtraMessageBox.Show(ex.BusinessException.Message,
"Eliminar",
MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
}
catch (Exception ex)
{
XtraMessageBox.Show(ex.Message,
"Eliminar",
MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
}
finally
{
Cursor.Current = Cursors.Default;
}
}
public async Task <IActionResult> Edit(int id, [Bind("PerfilusuarioId,PrimerNombre,SegundoNombre,PrimerApellido,SegundoApellido,FechaNacimiento,LugarNacimiento,Genero,EstadoCivil,CorreoPrimario,CorreoSecundario,TipoIdentificacion,NumeroIdentificacion,Celular,TelefonoPrimario,TelefonoSecundario,Contrasena")] PerfilUsuario perfilUsuario)
{
if (id != perfilUsuario.PerfilusuarioId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(perfilUsuario);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PerfilUsuarioExists(perfilUsuario.PerfilusuarioId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(perfilUsuario));
}
public async Task <ActionResult> LogOn(LogOnViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
model.LanguageSelectList = GetLanguageSelectList();
model.CurrentLanguage = CultureManager.GetCulture(Thread.CurrentThread).Name;
return(View(model));
}
DateTime loginAttempUtc = DateTime.UtcNow;
var result = await SignInManager.PasswordSignInAsync(model.UserName, model.Password, false, shouldLockout : true).ConfigureAwait(false);
switch (result)
{
case SignInStatus.Success:
ApplicationUser applicationUser = await UserManager.FindByNameAsync(model.UserName).ConfigureAwait(false);
PerfilUsuario perfilUsuario = _uow.PerfilUsuarioRepository.GetByUserId(applicationUser.Id);
if (perfilUsuario.Ativo)
{
if (_uow.EmpresaRepository.RetornarEmpresaPrincipal(applicationUser.Id) > 0)
{
await CreateApplicationSession(model.UserName).ConfigureAwait(false);
return(RedirectToLocal(returnUrl));
}
else
{
model.ErrorMessage = Res.UserEmpresaError;
}
}
else
{
model.ErrorMessage = "O usuário informado não está ativo no sistema.";
}
break;
case SignInStatus.LockedOut:
model.ErrorMessage = await GetLogOnLockoutMessageAsync(loginAttempUtc, model.UserName).ConfigureAwait(false);
break;
case SignInStatus.RequiresVerification:
model.ErrorMessage = Res.SignInRequiresVerificationMessage;
break;
case SignInStatus.Failure:
default:
model.ErrorMessage = Res.InvalidUserMessage;
break;
}
model.LanguageSelectList = GetLanguageSelectList();
model.CurrentLanguage = CultureManager.GetCulture(Thread.CurrentThread).Name;
model.Password = string.Empty;
return(View(model));
}
/// <summary>
/// Obtiene un listado de usuarios para determinado perfil
/// </summary>
/// <param name="perfil">Perfil de los usuarios a obtener</param>
/// <returns>Listado de usuarios con ese perfil</returns>
public IEnumerable <Usuario> Obtener(PerfilUsuario perfil)
{
Datos.UsuariosDAL dalUsuarios = dal.ObtenerUsuariosDAL();
IEnumerable <Datos.Usuario> usuariosDAL = dalUsuarios.ObtenerPorPerfil(perfil.ToString());
return(Obtener(usuariosDAL));
}
public List <PerfilUsuario> ConsultarNome(PerfilUsuario perfilUsuario)
{
try
{
//Criar uma nova coleção de clientes
List <PerfilUsuario> perfilColecao = new List <PerfilUsuario>();
acessoDados.LimparParametros();
acessoDados.AdicionarParametros("@Descricao", perfilUsuario.Descricao);
//Retornará uma DataTable
DataTable dataTable = acessoDados.ExecutarConsulta(CommandType.Text, "SELECT * FROM PerfilUsuario " +
"WHERE Descricao LIKE '%'+@Descricao+'%'");
//Percorrer o DataTable e transformar em coleção de cliente
//Cada linha do DataTable é um cliente
foreach (DataRow linha in dataTable.Rows)
{
//Criar cliente vazio
//Colocar os dados da linha
//Adicionar na coleção
PerfilUsuario perfilAdd = new PerfilUsuario();
perfilAdd.IdPerfilUsuario = Convert.ToInt32(linha["IdPerfilUsuario"]);
perfilAdd.Descricao = Convert.ToString(linha["Descricao"]);
perfilAdd.Ativo = Convert.ToChar(linha["Ativo"]);
perfilColecao.Add(perfilAdd);
}
return(perfilColecao);
}
catch (Exception exception)
{
throw new Exception("Não foi possivel consultar o cliente por nome. Detalhes: " + exception.Message);
}
}
private void ApplyAuthorizationRules()
{
bbiAplicaciones.Enabled = Aplicacion.CanGet();
bbiEmpresas.Enabled = Empresa.CanGet();
bbiUsuarios.Enabled = Usuario.CanGet();
bbiPerfiles.Enabled = PerfilUsuario.CanGet();
}
// CONSULTAR TESTE
public PerfilUsuario ConsultarTeste(string teste)
{
try
{
PerfilUsuario ConsultaTeste = new PerfilUsuario();
acessoBDSql.LimparParametros();
acessoBDSql.AdicionarParametros("@Cod_Teste", teste);
DataTable dataTableTeste = acessoBDSql.ExecutaConsulta(System.Data.CommandType.StoredProcedure, "TesteConsultar");
foreach (DataRow linha in dataTableTeste.Rows)
{
PerfilUsuario testeUsuario = new PerfilUsuario();
testeUsuario.cod_teste = Convert.ToInt32(linha["Cod_Teste"]);
testeUsuario.resultado = Convert.ToInt32(linha["Resultado"]);
ConsultaTeste.Equals(testeUsuario);
}
return(ConsultaTeste);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task<IHttpActionResult> ValidarUsuario(ValidarUsuarioRequisicao requisicao)
{
if (!ModelState.IsValid)
{
return ApiBadRequest(ModelState);
}
ApplicationUser usuarioAplicacao = await UserManager.FindByNameAsync(requisicao.Codigo);
if (usuarioAplicacao == null)
{
return ApiNotFound("Usuário não cadastrado.");
}
PerfilUsuario usuarioPerfil = _unitOfWork.PerfilUsuarioRepository.GetByUserId(usuarioAplicacao.Id);
if (usuarioPerfil == null)
{
return ApiNotFound("Usuário não cadastrado.");
}
if (usuarioPerfil.Ativo == false)
{
return ApiForbidden("Usuário inativo.");
}
if (usuarioPerfil.UsuarioEmpresas.Count == 0)
{
return ApiForbidden("Usuário sem empresa.");
}
return ApiOk();
}
// INSERIR teste cod_teste/ resultado
public string TesteInserir(PerfilUsuario teste) // no paratense é a tabela do usuario ou a classe do obj_trans
{
try
{
//Limpeza dos parâmetros
acessoBDSql.LimparParametros();
//Adicionar parâmetros
acessoBDSql.AdicionarParametros("@Resultado", teste.resultado);
//Acesso ao método do Stored Procedure
//ManipularDados?
string resultado = acessoBDSql.ManipulaDados(CommandType.StoredProcedure, "TesteInserir").ToString();
return(resultado);
}
catch (Exception ex)
{
return(ex.Message);
}
}
public ActionResult Create(Usuario usuario)
{
try
{
if (ModelState.IsValid)
{
_db.Usuarios.AddObject(usuario);
_db.SaveChanges();
var usuarioDominio = _domainUserRepository.FindUser(usuario.NombreUsuario);
var perfil = new PerfilUsuario()
{
Apellidos = usuarioDominio.LastName,
Email = usuarioDominio.Email,
Nombre = usuarioDominio.FirstName,
Telefono = "",
Id = usuario.Id
};
_db.PerfilesUsuario.AddObject(perfil);
_db.SaveChanges();
_auditorRepository.GuardarRegistro(TipoTransaccion.Crear, perfil.Id, perfil.GetType());
Utilidades.ColocarMensaje("El usuario se ha guardado exitosamente.");
return(RedirectToAction("EditarPerfilUsuario/" + perfil.Id));
}
ViewBag.Id = new SelectList(_db.PerfilesUsuario, "Id", "Nombre", usuario.Id);
ViewBag.IdRol = _db.Roles.ToDictionary(x => x.Id.ToString(), x => x.Nombre);
return(View(usuario));
}
catch (Exception ex)
{
ViewBag.Id = new SelectList(_db.PerfilesUsuario, "Id", "Nombre");
ViewBag.IdRol = _db.Roles.ToDictionary(x => x.Id.ToString(), x => x.Nombre);
Utilidades.ColocarMensaje(ex.Message, ErrorType.Error, Request);
return(View(usuario));
}
}
// INSERIR Progresso
public string ProgressoInserir(PerfilUsuario progresso) // no paratense é a tabela do usuario ou a classe do obj_trans
{
try
{
//Limpeza dos parâmetros
acessoBDSql.LimparParametros();
//Adicionar parâmetros
// acessoBDSql.AdicionarParametros("@Cod_progresso", progresso.Cod_Progresso);
// acessoBDSql.AdicionarParametros("@Cod_teste", progresso.cod_teste);
acessoBDSql.AdicionarParametros("@licao_usuario", progresso.licao_usuario);
acessoBDSql.AdicionarParametros("@Modulo_usuario", progresso.modulo_usuario);
acessoBDSql.AdicionarParametros("@progre_usuario", progresso.progresso_usuario);
//Acesso ao método do Stored Procedure
//ManipularDados?
string progresso_usuario = acessoBDSql.ManipulaDados(CommandType.StoredProcedure, "ProgressoInserir").ToString();
return(progresso_usuario);
}
catch (Exception ex)
{
return(ex.Message);
}
}
private void SetPerfil(PerfilUsuario perfil)
{
if (perfil == PerfilUsuario.Operador)
OperadorRB.Checked = true;
if (perfil == PerfilUsuario.Administrador)
AdmRB.Checked = true;
}
public override void Grabar()
{
perfilUsuarioBindingSource.RaiseListChangedEvents = false;
perfilUsuarioBindingSource.EndEdit();
try
{
Cursor.Current = Cursors.WaitCursor;
aplicacionTextEdit.Focus();
m_PerfilUsuario = m_PerfilUsuario.Save();
XtraMessageBox.Show(
"Registro grabado correctamente!",
Text,
MessageBoxButtons.OK,
MessageBoxIcon.Information);
base.Grabar();
}
catch (ValidationException)
{
XtraMessageBox.Show(m_PerfilUsuario.BrokenRulesCollection.ToString(),
"Grabar",
MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
}
catch (DataPortalException ex)
{
XtraMessageBox.Show(ex.BusinessException.Message,
"Grabar",
MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
}
catch (Exception ex)
{
XtraMessageBox.Show(ex.Message,
"Grabar",
MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
}
finally
{
Cursor.Current = Cursors.Default;
}
perfilUsuarioBindingSource.RaiseListChangedEvents = true;
}
public frmMntPerfilUsuario(PerfilUsuario _perfilUsuario)
{
InitializeComponent();
m_PerfilUsuario = _perfilUsuario;
perfilUsuarioBindingSource.DataSource = _perfilUsuario;
if (!m_PerfilUsuario.IsNew)
{
aplicacionBindingSource.DataSource = AplicacionCommand.Execute(m_PerfilUsuario.Aplicacion);
aplicacionBindingSource.ResetBindings(false);
}
Shown += (sender, obj) =>
{
gdvRoles.BestFitColumns();
};
Cursor.Current = Cursors.Default;
}
