private async void ActualizarEstadoPedidoHCG(string estado)
{
_mensaje = "Ha ocurrido un error mientras se actualizaba el estado.";
try
{
var estadoPrimeraMayus = char.ToUpper(estado[0]) + estado.Substring(1);
foreach (CellEntry celda in _celdas.Entries)
{
if (celda.Row != _pedido.FilaPlanillaCalculo)
{
continue;
}
if (celda.Column == 7 || celda.Column == 8)
{
celda.InputValue = celda.Column == 7 ? estadoPrimeraMayus : CuentaUsuario.ObtenerNombreUsuarioGoogle() ?? "-";
celda.Update();
}
}
}
catch (Exception)
{
// Si se quedó la pantalla abierta un largo tiempo y se venció el token, se cierra y refresca el token
var paginaAuntenticacion = new PaginaAuntenticacion(true);
Navigation.InsertPageBefore(paginaAuntenticacion, this);
await Navigation.PopAsync();
}
}
private void InicializarValoresGenerales()
{
_esGoogle = CuentaUsuario.ObtenerAccesoDatos() == "G";
Cabecera.Children.Add(App.Instancia.ObtenerImagen(TipoImagen.EncabezadoProductores));
SombraEncabezado.Source = ImageSource.FromResource(App.RutaImagenSombraEncabezado);
ConfigurarBotones();
var columnasParaVer = CuentaUsuario.ObtenerColumnasParaVer();
if (!string.IsNullOrEmpty(columnasParaVer))
{
_listaColumnasParaVer = columnasParaVer.Split(',');
}
var columnasInventario = CuentaUsuario.ObtenerColumnasInventario();
if (!string.IsNullOrEmpty(columnasInventario))
{
_listaColumnasInventario = columnasInventario.Split(',');
}
_indicadorActividad = new ActivityIndicator
{
VerticalOptions = LayoutOptions.CenterAndExpand,
IsEnabled = true,
BindingContext = this
};
_indicadorActividad.SetBinding(IsVisibleProperty, "IsBusy");
_indicadorActividad.SetBinding(ActivityIndicator.IsRunningProperty, "IsBusy");
}
private void btnEnviar_Click(object sender, EventArgs e)
{
if (txtCorreo.Text == "")
{
MessageBox.Show("Debe ingresar su correo electrónico.", "Advertencia", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
CuentaUsuario cu = cuentasUsuarioBl.obtenerCuentaUsuario(txtCorreo.Text);
if (cu == null)
{
MessageBox.Show("No existe dicho correo electrónico.", "Advertencia", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
if (cuentasUsuarioBl.recuperarContraseña(cu))
{
MessageBox.Show("El código de recuperación se ha enviado exitósamente.", "Recuperación", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
MessageBox.Show("Ha ocurrido un error durante el envío del correo." + System.Environment.NewLine + "Intentar más tarde", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
this.DialogResult = DialogResult.OK;
}
public async Task <ActionResult> RegisterPromotor(RegisterViewModel model)
{
CuentaUsuario cue = null;
cue = db.CuentaUsuario.Find(model.Email);
if (cue != null)
{
TempData["MessageErrorPromotor"] = "Ya existe una cuenta con ese correo";
return(RedirectToAction("Index", "Empleado"));
}
List <CuentaUsuario> lcu = db.CuentaUsuario.Where(c => c.tipoDoc == model.tipoDoc && c.codDoc == model.codDoc).ToList();
if (lcu == null || lcu.Count > 0)
{
TempData["MessageErrorPromotor"] = "Ya existe un cuenta registrada con ese DNI";
return(RedirectToAction("Index", "Empleado"));
}
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var currentUser = UserManager.FindByName(user.UserName);
UserManager.AddToRole(user.Id, "Promotor");
CuentaUsuario cuentausuario = new CuentaUsuario();
cuentausuario.correo = model.Email;
cuentausuario.apellido = model.apellido;
cuentausuario.codDoc = model.codDoc;
cuentausuario.codPerfil = 3;
//cuentausuario.contrasena = user.PasswordHash;
cuentausuario.direccion = model.direccion;
cuentausuario.estado = true;
cuentausuario.fechaNac = model.fechaNac;
cuentausuario.nombre = model.nombre;
cuentausuario.puntos = 0;
cuentausuario.sexo = model.sexo;
cuentausuario.telefono = model.telefono;
cuentausuario.telMovil = model.telMovil;
cuentausuario.tipoDoc = model.tipoDoc;
cuentausuario.usuario = model.Email;
db.CuentaUsuario.Add(cuentausuario);
db.SaveChanges();
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Index", "Empleado"));
//return View("~/Views/Home/Index.cshtml");
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(RedirectToAction("Index", "Empleado"));
}
private string obtenerMensajeRecuperacion(CuentaUsuario cu)
{
string mensaje = "Estimado/a " + cu.Persona.Nombre + ",\r\nSu contraseña es: " +
cu.Contrasena + "\r\n\r\nAtentamente,\r\n\r\nEl equipo de Excellia";
return(mensaje);
}
public int insertarCuentaUsuario(CuentaUsuario usuario)
{
MySqlConnection conn;
string cadena = DBManager.cadena;
try
{
conn = new MySqlConnection(cadena);
}
catch
{
return(-1);
}
conn.Open();
MySqlCommand cmd = new MySqlCommand();
cmd.Connection = conn;
string insert = "INSERT INTO CUENTA_USUARIO(NOMBRE_USUARIO, CONTRASENA, BLOQUEADO) VALUES ('" + usuario.NomUsuario + "', '" + usuario.Contrasena + "', " + usuario.Bloqueado + ");";
cmd.CommandText = insert;
cmd.ExecuteNonQuery();
int id = (int)cmd.LastInsertedId;
return(id);
}
public PaginaConexionBaseDeDatos()
{
InitializeComponent();
SombraEncabezado.Source = ImageSource.FromResource(App.RutaImagenSombraEncabezado);
CuentaUsuario.AlmacenarAccesoDatos("B");
Usuario.Text = CuentaUsuario.ObtenerUsuarioDeBaseDeDatos();
}
public int validarUsuario(ref CuentaUsuario usuario)
{
CuentaUsuarioDA cuentaUsuarioDA = new CuentaUsuarioDA();
BindingList <CuentaUsuario> cuentasUsuario = cuentaUsuarioDA.obtenerCuentasUsuario();
bool encontrado = false;
bool usuarioEncontrado = false;
foreach (CuentaUsuario usuarioBD in cuentasUsuario)
{
encontrado = ((usuario.NomUsuario == usuarioBD.NomUsuario) && (usuario.Contrasena == usuarioBD.Contrasena));
if (encontrado)
{
usuario = usuarioBD;
break;
}
if (!usuarioEncontrado)
{
usuarioEncontrado = (usuario.NomUsuario == usuarioBD.NomUsuario);
}
}
if (encontrado)
{
return(determinarTipoUsuario(usuario.Persona));
}
else if (usuarioEncontrado)
{
return(-1);
}
else
{
return(-2);
}
}
private void ConfigurarSelectorHojas()
{
_listaHojas = new Picker
{
IsVisible = false,
WidthRequest = App.AnchoRetratoDePantalla * .3,
HorizontalOptions = LayoutOptions.EndAndExpand,
VerticalOptions = LayoutOptions.Center
};
_listaHojas.IsVisible = true;
var nombreHojaActual = CuentaUsuario.ObtenerNombreHoja(_linkHojaConsulta);
var nombres = CuentaUsuario.ObtenerTodosLosNombresDeHojas();
var i = 0;
foreach (var nombre in nombres)
{
_listaHojas.Items.Add(nombre);
if (nombre == nombreHojaActual)
{
_listaHojas.SelectedIndex = i;
}
i += 1;
}
_listaHojas.SelectedIndexChanged += CargarHoja;
Cabecera.Children.Add(_listaHojas);
}
public frmCambiarContraseña(CuentaUsuario cu)
{
InitializeComponent();
this.cu = cu;
trabajadorBL = new TrabajadorBL();
txtContra.Validating += TxtContra_Validating;
}
private void ExtraerTokenAccesoDesdeUrl(string url)
{
if (url.Contains("access_token") && url.Contains("&expires_in="))
{
Content = null;
var at = url.Replace("http://localhost/#access_token=", "");
if (Device.OS == TargetPlatform.WinPhone || Device.OS == TargetPlatform.Windows) //VER
{
at = url.Replace("http://localhost/#access_token=", "");
}
if (!url.Contains("&noActualizarFecha"))
{
//Expira en 1 hora, por las dudas, lo actualizamos a los 55 minutos para evitar potencial desfasaje en el horario del servidor.
var fechaExpiracion = DateTime.Now.AddMinutes(55);
CuentaUsuario.AlmacenarFechaExpiracionToken(fechaExpiracion);
}
var tokenDeAcceso = at.Remove(at.IndexOf("&token_type="));
CuentaUsuario.AlmacenarTokenDeGoogle(tokenDeAcceso);
//Recuperar el nombre de usuario para el historial de movimientos
if (string.IsNullOrEmpty(CuentaUsuario.ObtenerNombreUsuarioGoogle()))
{
RecuperarNombreUsuarioGoogle(tokenDeAcceso);
}
//A partir de la procedencia determinar si irá hacia la página de grilla o hacia la de libros
DeterminarProcesoParaCargaDatos(tokenDeAcceso);
}
}
private string AlmacenarHojaConsulta(string tituloHoja, bool requerida)
{
var hojaConsulta = _listaHojas.FirstOrDefault(datosHoja => datosHoja.Title.Text == tituloHoja);
if (hojaConsulta == null)
{
return(requerida ? "Libro incorrecto, no tiene hoja " + tituloHoja + "." : "");
}
var linkHoja = hojaConsulta.Links.FindService(GDataSpreadsheetsNameTable.CellRel, null).HRef.ToString();
CuentaUsuario.AlmacenarLinkHojaConsulta(linkHoja);
CuentaUsuario.AlmacenarNombreDeHoja(linkHoja, tituloHoja);
AlmacenarColumnasVerEInventario(linkHoja);
if (tituloHoja.Equals("Productos App"))
{
// Link para pantalla PaginaGrilla
_linkHojaConsulta = linkHoja;
// 1 - Se valida si tenemos que habilitar la funcionalidad de Relación Insumo - Producto
// Ocurre si existe en el libro una hoja de nombre "Costos variables".
// 2 - Almacena las columnas de Producto - Se usarán en la pantalla Pedido (para almacenar movimientos de stock desde el detalle de pedido).
ValidarHabilitacionRelacionesInsumoProducto(_linkHojaConsulta);
AlmacenarColumnasProducto(_linkHojaConsulta);
}
return("");
}
private async Task ObtenerYConfigurarHojas(string linkLibro)
{
try
{
IsBusy = true;
await Task.Run(async() =>
{
if (CuentaUsuario.ValidarTokenDeGoogle())
{
_listaHojas = new ServiciosGoogle().ObtenerListaHojas(linkLibro, _servicio);
ConfigurarHojas();
}
else
{
//Si se quedó la pantalla abierta un largo tiempo y se venció el token, se cierra y refresca el token
var paginaAuntenticacion = new PaginaAuntenticacion(true);
Navigation.InsertPageBefore(paginaAuntenticacion, this);
await Navigation.PopAsync();
}
});
}
finally
{
IsBusy = false; //Remueve el Indicador de Actividad.
}
}
public PaginaAuntenticacion(bool conexionExistente = false)
{
InitializeComponent();
SombraEncabezado.Source = ImageSource.FromResource(App.RutaImagenSombraEncabezado);
CuentaUsuario.AlmacenarAccesoDatos("G");
// Si es verdadero debe llevarnos a la Grilla en lugar de avanzar hacia la página de selección de libros
_conexionExistente = conexionExistente;
var webView = new WebView
{
VerticalOptions = LayoutOptions.FillAndExpand
};
webView.Navigated += CuandoNavegaWebView;
if (!CuentaUsuario.ValidarTokenDeGoogle())
{
var solicitud =
"https://accounts.google.com/o/oauth2/auth?client_id=" + _clientId
+ "&scope=https://www.googleapis.com/auth/drive https://spreadsheets.google.com/feeds https://www.googleapis.com/auth/plus.login"
+ "&token_uri=https://accounts.google.com/o/oauth2/token"
+ "&response_type=token&redirect_uri=http://localhost";
webView.Source = solicitud;
}
else
{
webView.Source = "http://localhost/#access_token=" + CuentaUsuario.ObtenerTokenActualDeGoogle() +
"&token_type=&expires_in=&noActualizarFecha";
}
Contenedor.Children.Add(webView);
}
private void RegistrarInfoEmpleado()
{
Empleado empleado = new Empleado();
Direccion direccion = new Direccion();
string rol = puestosCB.SelectedItem.ToString();
try
{
InstanceContext context = new InstanceContext(this);
RegistrarCuentaUsuarioClient ServicioEmpleado = new RegistrarCuentaUsuarioClient(context);
AsignarInfoEmpleado(ref empleado);
AsignarDireccion(ref direccion);
if (EsAdministrativo())
{
CuentaUsuario cuenta = new CuentaUsuario();
AsignarCuentaUsuario(ref cuenta);
ServicioEmpleado.RegistrarCuentaUsuario(cuenta, empleado, direccion, rol);
}
else
{
ServicioEmpleado.RegistrarCuentaUsuario2(empleado, direccion, rol);
}
}
catch (Exception error)
{
FuncionesComunes.MostrarMensajeDeError(error.Message + " " + error.GetType());
}
}
private async void ObtenerDatosClientesDesdeHCG()
{
try
{
IsBusy = true;
await Task.Run(async() =>
{
if (CuentaUsuario.ValidarTokenDeGoogle())
{
var linkHojaClientes = CuentaUsuario.ObtenerLinkHojaClientes();
_clientes = ObtenerListado(linkHojaClientes);
var linkHojaProductos = CuentaUsuario.ObtenerLinkHojaPorNombre("Productos App");
_productos = ObtenerListado(linkHojaProductos);
ConstruirVista();
}
else
{
// Si se quedó la pantalla abierta un largo tiempo y se venció el token, se cierra y refresca el token.
var paginaAuntenticacion = new PaginaAuntenticacion(true);
Navigation.InsertPageBefore(paginaAuntenticacion, this);
await Navigation.PopAsync();
}
});
}
finally
{
// Remueve el Indicador de Actividad.
IsBusy = false;
}
}
private async Task TareaGuardarPedido(Picker comboCliente)
{
try
{
IsBusy = true;
await Task.Run(async() =>
{
if (CuentaUsuario.ValidarTokenDeGoogle())
{
GuardarPedidoHojaDeCalculoGoogle(comboCliente);
}
else
{
//Si se quedó la pantalla abierta un largo tiempo y se venció el token, se cierra y refresca el token
var paginaAuntenticacion = new PaginaAuntenticacion(true);
Navigation.InsertPageBefore(paginaAuntenticacion, this);
await Navigation.PopAsync();
}
});
}
finally
{
IsBusy = false; //Remueve el Indicador de Actividad.
}
}
private async void EnviarPagina(string linkHoja, string nombreHoja, bool desvinculaHoja)
{
//Si está desvinculando borra todas las configuraciones anteriores de la hoja seleccionada
if (desvinculaHoja)
{
CuentaUsuario.ReiniciarHoja(linkHoja);
CargarListaHojas();
}
else
{
ContentPage pagina;
//Si ya se usó esta hoja alguna vez y si el botón presionado NO es el de Desvincular, carga las columnas ya seleccionadas y envía a Grilla.
//Si no (alguna de las dos condiciones) envía a pantallas de selección de histórico y columnas.
if (CuentaUsuario.VerificarHojaUsadaRecuperarColumnas(linkHoja))
{
App.Instancia.LimpiarNavegadorLuegoIrPagina(new PaginaGrilla(linkHoja, _servicio));
}
else
{
if (CuentaUsuario.VerificarHojaUsada(linkHoja))
{
await DisplayAlert("Configuración incompleta",
"La hoja a la que intenta acceder tiene una configuración incompleta, por favor, desvincule la hoja y vuelva a configurarla.",
"Listo");
return;
}
if (CuentaUsuario.VerificarHojaUsadaPorNombre(nombreHoja))
{
await DisplayAlert("Hoja con el mismo nombre",
"Ya existe una hoja con el mismo nombre en uso, por favor, modifique el nombre de la hoja y vuelva a configurarla.",
"Listo");
return;
}
// Se almacena el link para recobrar los datos de stock de la hoja cuando ingrese nuevamente.
CuentaUsuario.AlmacenarLinkHojaConsulta(linkHoja);
CuentaUsuario.AlmacenarNombreDeHoja(linkHoja, nombreHoja);
// 1 - Se ha seleccionado una hoja principal (de nombre "Productos App"), se valida si tenemos que habilitar la funcionalidad de Relación Insumo - Producto
// Ocurre si existe en el libro una hoja de nombre "Costos variables".
// 2 - Almacena las columnas de Producto - Se usarán en la pantalla Pedido (para almacenar movimientos de stock desde el detalle de pedido).
if (nombreHoja == "Productos App")
{
ValidarHabilitacionRelacionesInsumoProducto(linkHoja);
AlmacnarColumnasProducto(linkHoja);
// HACER -- En la configuración directa, agregar nunto a las otras hojas. Hacer if anidados y recorrer la lista de hojas una sola vez.
AgregarHojaClientes();
AgregarHojaPedidos();
}
pagina = new ListaHojasHistoricoGoogle(_servicio, _listaHojas);
await Navigation.PushAsync(pagina, true);
}
}
}
public async Task <ActionResult> ChangePassword(ChangePasswordViewModel model)
{
var db = new inf245netsoft();
string correo = User.Identity.Name;
CuentaUsuario cliente = db.CuentaUsuario.Where(c => c.correo == correo).First();
if (cliente.contrasena == model.OldPassword)
{
if (cliente.contrasena != model.NewPassword)
{
if (model.NewPassword == model.ConfirmPassword)
{
var result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
cliente.contrasena = model.NewPassword;
db.SaveChanges();
TempData["tipo"] = "alert alert-success";
TempData["message"] = "Contraseña cambiada Exitosamente";
if (user != null)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
}
/*Aca deberia retornarte a MiCuenta de CuentaUsuario*/
return(RedirectToAction("MiCuenta", "CuentaUsuario"));
}
else
{
ModelState.AddModelError("NewPassword", "Las contraseñas deben tener 6 caracteres como mínimo y una combinación de caracteres especiales, letras, letras mayúsculas y números");
}
}
else
{
//cuando la contraseña nueva y la confirmacion no son iguales
ModelState.AddModelError("ConfirmPassword", "Las contraseñas no coinciden");
}
}
else
{
//contrseña actual igual a la contraseña nueva
ModelState.AddModelError("NewPassword", "Ingrese una contraseña diferente a la actual.");
/*var result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
* if (!result.Succeeded)
* {
* ModelState.AddModelError("NewPassword", "Las contraseñas deben tener 6 caracteres como mínimo y una combinación de caracteres especiales, letras, letras mayúsculas y números");
* }*/
}
}
else
{
//contreña actual diferente a la ingresa
ModelState.AddModelError("OldPassword", "Contraseña ingresada no es correcta");
}
return(View(model));
}
static public void Cargar(string nom, string ape, string pass, string r)
{
CuentaUsuario a = new CuentaUsuario();
a.SetUsuario(nom, ape, pass, r);
Console.WriteLine("Se introdujo el Objeto {0}\n{1}\n{2}\n{3}", a.Nombre, a.Apellido, a.NombreUsuario, a.Contraseña);
Lst_Usuarios.Add(a);
}
// GET: Admin/Home
public ActionResult Index()
{
CuentaUsuario cuentaUsuario = new CuentaUsuario();
ViewData["estadisticas"] = cuentaUsuario.getDashboardUser();
return(View());
}
public pedido(int _idPedido, estado _estadoPedido, CuentaUsuario _cuentaUsuario, DateTime _registroPedido, DateTime _entregaPedido)
{
this._idPedido = _idPedido;
this._estadoPedido = _estadoPedido;
this._cuentaUsuario = _cuentaUsuario;
this._registroPedido = _registroPedido;
this._entregaPedido = _entregaPedido;
}
private string obtenerMensajeBienvenidaSistema(CuentaUsuario usuario, string contrasena)
{
string mensaje = "Estimado/a " + usuario.Persona.Nombre + ",\r\nMediante la presente, le damos la bienvenida " +
"al sistema de Excellia. Adjunto, encontrará sus credenciales para poder ingresar al sistema:\r\n\r\n" +
"Usuario: " + usuario.NomUsuario + "\r\nContraseña: " + contrasena +
"\r\n\r\nAtentamente,\r\n\r\nEl equipo de Excellia";
return(mensaje);
}
private void Btn_cuenta_Click(object sender, RoutedEventArgs e)
{
CuentaUsuario cuentaUsuario = new CuentaUsuario();
cuentaUsuario.ventanaPadre = this;
GridPrincipal.Children.Clear();
GridPrincipal.Children.Add(cuentaUsuario);
}
private void IrSeleccionColumnas(object sender, EventArgs args)
{
//Si no configuro Puntos de venta lo saco de la memoria para que no muestre el campo en Productos.
CuentaUsuario.RemoverValorEnCuentaLocal("puntosVenta");
ContentPage pagina = new SeleccionColumnasParaVer(_servicio);
Navigation.PushAsync(pagina, true);
}
public PaginaConexionBaseDeDatos()
{
InitializeComponent();
Cabecera.Children.Add(App.Instancia.ObtenerImagen(TipoImagen.EncabezadoProyectos));
SombraEncabezado.Source = ImageSource.FromResource(App.RutaImagenSombraEncabezado);
ConfigurarBotones();
CuentaUsuario.AlmacenarAccesoDatos("B");
Usuario.Text = CuentaUsuario.ObtenerUsuarioDeBaseDeDatos();
}
private async void ObtenerDatosMovimientosDesdeHCG()
{
try
{
ContenedorMovimientos.Children.Add(_indicadorActividad);
IsBusy = true;
await Task.Run(async() => {
if (CuentaUsuario.ValidarTokenDeGoogle())
{
var linkHistoricosCeldas = CuentaUsuario.ObtenerLinkHojaHistoricosCeldas(CuentaUsuario.ObtenerLinkHojaConsulta());
_celdas = _servicioGoogle.ObtenerCeldasDeUnaHoja(linkHistoricosCeldas, _servicio);
}
else
{
//Si se quedó la pantalla abierta un largo tiempo y se venció el token, se cierra y refresca el token
var paginaAuntenticacion = new PaginaAuntenticacion(true);
Navigation.InsertPageBefore(paginaAuntenticacion, this);
await Navigation.PopAsync();
}
});
}
finally
{
IsBusy = false; //Remueve el Indicador de Actividad.
}
_nombresColumnas = new string[_celdas.ColCount.Count];
var movimientos = new List <string[]>();
var movimiento = new string[_celdas.ColCount.Count];
foreach (CellEntry celda in _celdas.Entries)
{
if (celda.Row != 1)
{
if (celda.Column == 1)
{
movimiento = new string[_celdas.ColCount.Count];
}
movimiento.SetValue(celda.Value, (int)celda.Column - 1);
if (celda.Column == _celdas.ColCount.Count)
{
movimientos.Add(movimiento);
}
}
else
{
_nombresColumnas.SetValue(celda.Value, (int)celda.Column - 1);
}
}
LlenarGrillaDeMovimientos(movimientos);
}
/// <summary>
///
/// </summary>
/// <param name="token"></param>
/// <returns></returns>
public CuentaUsuario IniciarSessionPorToken(string token, string codigoSistema)
{
CuentaUsuario resultado = this.ObtenerUsuarioPorToken(token);
if (resultado != null)
{
resultado = this.ObtenerPermisos(resultado, codigoSistema);
}
return(resultado);
}
public bool RegistrarUsuarioNuevo(string usuario, string contraseña)
{
CuentaUsuario nueva = new CuentaUsuario
{
Nombre = usuario,
Clave = contraseña
};
return(nueva.Crear());
}
public void DevuelveCuenta(CuentaUsuario cuenta)
{
Dispatcher.Invoke(() =>
{
CuentaUsuario = cuenta;
Principal ventana = new Principal(cuenta);
ventana.Show();
this.Close();
});
}
