public async Task <ActionResult> ConfirmRegistration(UsuariosDTO userToValidate)
        {
            Result <Object> result = new Result <Object>();

            try
            {
                AuthenticateServices service = new AuthenticateServices();

                WrapperSimpleTypesDTO emailExist = await service.VerificarSiEmailYaExiste(userToValidate);

                if (emailExist == null || emailExist.Existe)
                {
                    result.Success = false;
                    result.Message = "NOTI_EMAIL_REGISTERED";
                    return(Json(result, JsonRequestBehavior.AllowGet));
                }

                WrapperSimpleTypesDTO userExist = await service.VerificarSiUsuarioYaExiste(userToValidate);

                if (userExist == null || userExist.Existe)
                {
                    result.Success = false;
                    result.Message = "NOTI_USER_REGISTERED";
                    return(Json(result, JsonRequestBehavior.AllowGet));
                }

                return(Json(result, JsonRequestBehavior.AllowGet));
            }
            catch (Exception ex)
            {
                result.Success = false;
                result.Message = ex.Message;
                return(Json(result, JsonRequestBehavior.AllowGet));
            }
        }
Example #2
0
        public async Task <JsonResult> SaveAdvertiser(AnunciantesDTO advertiser)
        {
            Result <AnunciantesDTO> result = new Result <AnunciantesDTO>();

            try
            {
                AnunciantesServices advertiserService = new AnunciantesServices();
                advertiser.Personas.Usuarios     = UserLoggedIn();
                advertiser.Personas.TipoPerfil   = advertiser.Personas.Usuarios.TipoPerfil;
                advertiser.Personas.CodigoIdioma = advertiser.Personas.Usuarios.PersonaDelUsuario.CodigoIdioma;
                WrapperSimpleTypesDTO res = new WrapperSimpleTypesDTO();
                if (advertiser.Consecutivo != 0)
                {
                    PersonasServices personService = new PersonasServices();
                    res = await personService.ModificarPersona(advertiser.Personas);

                    if (res != null)
                    {
                        res = await advertiserService.ModificarInformacionAnunciante(advertiser);

                        result.obj = advertiser;
                    }
                }
                else
                {
                    advertiser.Anuncios = null;
                    advertiser.Personas.Usuarios.Personas          = null;
                    advertiser.Personas.Usuarios.PersonaDelUsuario = null;
                    res = await advertiserService.CrearAnunciante(advertiser);

                    if (res != null)
                    {
                        advertiser.Consecutivo            = (int)res.ConsecutivoCreado;
                        advertiser.CodigoPersona          = res.ConsecutivoPersonaCreado;
                        advertiser.Personas.CodigoUsuario = res.ConsecutivoUsuarioCreado;
                        result.obj = advertiser;
                        AuthenticateServices AuthenticateService = new AuthenticateServices();
                        var newUser = await AuthenticateService.VerificarUsuario(UserLoggedIn());

                        setUserLogin(newUser);
                    }
                }

                if (res == null)
                {
                    return(Json(Helper.returnErrorObj(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
                }

                return(Json(result, JsonRequestBehavior.AllowGet));
            }
            catch (Exception)
            {
                return(Json(Helper.returnErrorObj(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
            }
        }
        public async Task AuthenticateService_ListarTiposPerfiles_ShouldList()
        {
            AuthenticateServices authenticateService = new AuthenticateServices();

            List <TiposPerfilesDTO> listaTipoPerfiles = await authenticateService.ListarTiposPerfiles();

            Assert.IsNotNull(listaTipoPerfiles);
            Assert.IsTrue(listaTipoPerfiles.Count > 0);
            Assert.IsTrue(listaTipoPerfiles.TrueForAll(x => x.Planes.Count == 0));
            Assert.IsTrue(listaTipoPerfiles.TrueForAll(x => x.Usuarios.Count == 0));
        }
        public async Task AuthenticateService_VerificarUsuarios_ShouldPass()
        {
            AuthenticateServices authenticateService = new AuthenticateServices();

            UsuariosDTO usuarioParaVerificar = new UsuariosDTO
            {
                Usuario = "Sergio",
                Clave   = "Sergio"
            };

            UsuariosDTO usuarioVerificado = await authenticateService.VerificarUsuario(usuarioParaVerificar);

            Assert.IsNotNull(usuarioVerificado);
            Assert.AreNotEqual(usuarioVerificado.Consecutivo, 0);
        }
Example #5
0
        async Task BuscarInformacionParaLogin()
        {
            PersonasServices personaSer        = new PersonasServices();
            PersonasDTO      personaParaBuscar = new PersonasDTO
            {
                Consecutivo  = Convert.ToInt32(App.RecordedPerson),
                CodigoIdioma = Convert.ToInt32(App.RecordedIdiomPerson)
            };

            if (IsNotConnected)
            {
                return;
            }
            App.Persona = await personaSer.BuscarPersona(personaParaBuscar);

            if (App.Persona == null)
            {
                return;
            }

            AuthenticateServices authSer           = new AuthenticateServices();
            UsuariosDTO          usuarioParaBuscar = new UsuariosDTO
            {
                Usuario = App.RecordedUser,
                Clave   = App.RecordedPasswordUser
            };

            if (IsNotConnected)
            {
                return;
            }
            App.Usuario = await authSer.VerificarUsuario(usuarioParaBuscar);

            if (App.Usuario == null)
            {
                return;
            }

            if (!IsNotConnected)
            {
                await App.ConnectPersonToChatHub();
            }
        }
        // GET: Confirmation Of Registration
        public async Task <ActionResult> ConfirmationOfRegistration(int ID, int Language)
        {
            Result <WrapperSimpleTypesDTO> result = new Result <WrapperSimpleTypesDTO>();

            try
            {
                AuthenticateServices service = new AuthenticateServices();
                result.obj = await service.ActivarUsuario(new UsuariosDTO()
                {
                    Consecutivo = ID
                });

                return(View());
            }
            catch (Exception)
            {
                return(View());
            }
        }
        public async Task <JsonResult> Login(UsuariosDTO userToValidate)
        {
            Result <UsuariosDTO> result = new Result <UsuariosDTO>();

            try
            {
                AuthenticateServices service = new AuthenticateServices();
                result.obj = await service.VerificarUsuario(userToValidate);

                if (result.obj != null)
                {
                    WrapperSimpleTypesDTO isActive = await service.VerificarSiCuentaEstaActiva(userToValidate);

                    if (isActive.Existe)
                    {
                        setUserLogin(result.obj);
                        result.Path = pathByTypeProfile(result.obj.TipoPerfil);
                        /* If remember user and password save user in cookie encrypted */
                        if (userToValidate.EsRecordarClave)
                        {
                            saveUserInCookie(result.obj);
                        }
                    }
                    else
                    {
                        result.Success = false;
                        result.obj     = null;
                        result.Message = "NOTI_USER_BLOCK";
                    }
                }
                else
                {
                    return(Json(Helper.returnErrorWrongUser(), JsonRequestBehavior.AllowGet));
                }
                return(Json(result, JsonRequestBehavior.AllowGet));
            }
            catch (Exception)
            {
                return(Json(Helper.returnErrorWrongUser(), JsonRequestBehavior.AllowGet));
            }
        }
        public async Task <JsonResult> ChangeUser(UsuariosDTO user)
        {
            Result <WrapperSimpleTypesDTO> result = new Result <WrapperSimpleTypesDTO>();

            try
            {
                AuthenticateServices service = new AuthenticateServices();
                user.Consecutivo = UserLoggedIn().Consecutivo;
                result.obj       = await service.ModificarUsuario(user);

                if (result.obj == null)
                {
                    return(Json(Helper.returnErrorSaveObj(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
                }
                return(Json(Helper.returnSuccessObj(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
            }
            catch (Exception)
            {
                return(Json(Helper.returnErrorSaveObj(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
            }
        }
        public async Task <JsonResult> RecoverPassword(UsuariosDTO userToValidate)
        {
            Result <WrapperSimpleTypesDTO> result = new Result <WrapperSimpleTypesDTO>();

            try
            {
                AuthenticateServices service = new AuthenticateServices();

                result.obj = await service.RecuperarClave(userToValidate);

                if (result.obj == null || !result.obj.Exitoso)
                {
                    return(Json(Helper.returnSendMailError(), JsonRequestBehavior.AllowGet));
                }
                return(Json(Helper.returnSendMailSuccess(), JsonRequestBehavior.AllowGet));
            }
            catch (Exception)
            {
                return(Json(Helper.returnSendMailError(), JsonRequestBehavior.AllowGet));
            }
        }
        public async Task <ActionResult> ValidateIfUserExist(UsuariosDTO userToValidate)
        {
            Result <WrapperSimpleTypesDTO> result = new Result <WrapperSimpleTypesDTO>();

            try
            {
                AuthenticateServices service = new AuthenticateServices();

                result.obj = await service.VerificarSiUsuarioYaExiste(userToValidate);

                if (result.obj == null || result.obj.Existe)
                {
                    return(Json(Helper.returnErrorObj(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
                }

                return(Json(result, JsonRequestBehavior.AllowGet));
            }
            catch (Exception)
            {
                return(Json(Helper.returnErrorObj(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
            }
        }
        public async Task <ActionResult> GetProfileTypes()
        {
            Result <TiposPerfilesDTO> result = new Result <TiposPerfilesDTO>();

            try
            {
                AuthenticateServices service = new AuthenticateServices();

                result.list = await service.ListarTiposPerfiles();

                if (result.list != null)
                {
                    return(Json(result, JsonRequestBehavior.AllowGet));
                }

                return(Json(Helper.returnErrorList(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
            }
            catch (Exception)
            {
                return(Json(Helper.returnErrorList(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
            }
        }
        // GET: Authenticate
        public async Task <ActionResult> Index()
        {
            if (System.Web.HttpContext.Current.Request.Cookies[FormsAuthentication.FormsCookieName.ToString()] != null)
            {
                FormsAuthenticationTicket authTicket = FormsAuthentication.Decrypt(System.Web.HttpContext.Current.Request.Cookies[FormsAuthentication.FormsCookieName.ToString()].Value);
                AuthenticateServices      service    = new AuthenticateServices();
                var user = await service.VerificarUsuario(new UsuariosDTO()
                {
                    Usuario = authTicket.Name, Clave = authTicket.UserData
                });

                if (user == null)
                {
                    ClearSession();
                    return(RedirectToAction("Index", "Authenticate"));
                }
                setUserLogin(user);
                return(RedirectToAction("Index", "Home"));
            }
            ClearSession();
            return(View());
        }
Example #13
0
 public PersonaPageModel()
 {
     _personaServices        = new PersonasServices();
     _administracionServices = new AdministracionServices();
     _authenticateServices   = new AuthenticateServices();
 }
 public RecuperarClavePageModel()
 {
     _authService = new AuthenticateServices();
 }
        public async Task <JsonResult> CreateAgent(RepresentantesDTO agent)
        {
            Result <WrapperSimpleTypesDTO> result = new Result <WrapperSimpleTypesDTO>();

            try
            {
                string newEmail = agent.Personas.Usuarios.Email;
                agent.Personas.CodigoUsuario  = UserLoggedIn().Consecutivo;
                agent.Personas.Usuarios       = UserLoggedIn();
                agent.Personas.Usuarios.Email = newEmail;

                RepresentantesServices agentService   = new RepresentantesServices();
                PersonasServices       personService  = new PersonasServices();
                AuthenticateServices   usuarioService = new AuthenticateServices();
                if (agent.Consecutivo != 0)
                {
                    agent.CategoriasRepresentantes = null;
                    result.obj = await personService.ModificarPersona(agent.Personas); // Update person

                    if (result.obj != null)
                    {
                        result.obj = await agentService.ModificarInformacionRepresentante(agent); // Update agent
                    }
                    if (result.obj != null)
                    {
                        result.obj = await usuarioService.ModificarEmailUsuario(agent.Personas.Usuarios); // Update email user
                    }
                    if (result.obj != null)
                    {
                        UserLoggedIn().PersonaDelUsuario.IdiomaDeLaPersona = agent.Personas.IdiomaDeLaPersona;
                    }
                }
                else
                {
                    agent.CategoriasRepresentantes.ToList().ForEach(c => c.Categorias = null);
                    result.obj = await agentService.CrearRepresentante(agent); // Create a new agent

                    if (result.obj != null)
                    {
                        AuthenticateServices service        = new AuthenticateServices();
                        UsuariosDTO          userToValidate = UserLoggedIn();
                        userToValidate.Personas       = null;
                        userToValidate.TiposPerfiles  = null;
                        userToValidate.PlanesUsuarios = null;
                        var userAgent = await service.VerificarUsuario(userToValidate);

                        if (userAgent != null)
                        {
                            setUserLogin(userAgent);
                        }
                    }
                }

                if (result.obj == null)
                {
                    return(Json(Helper.returnErrorObj(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
                }

                result.Message = "La información se ha guardado con éxito";
                return(Json(result, JsonRequestBehavior.AllowGet));
            }
            catch (Exception)
            {
                return(Json(Helper.returnErrorSaveObj(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
            }
        }
 public ConfiguracionUsuarioPageModel()
 {
     _authService    = new AuthenticateServices();
     _personaService = new PersonasServices();
 }
Example #17
0
 private async void LoginButton_Click(object sender, RoutedEventArgs e)
 {
     Employee employee = await AuthenticateServices.Authentication("admin", "admin");
 }
 public InicioSesionPageModel()
 {
     _authService    = new AuthenticateServices();
     _planesServices = new PlanesServices();
 }