/// <summary>
        /// Returns the user cache of the given user.  If the user does not exist in CAM it is added.  If
        /// the user is invalid according to cam no permissions are cached.
        /// </summary>
        /// <param name="user">The user to return cache for.</param>
        /// <returns>The user's cache.</returns>
        public async Task <UserCache> GetUserCacheAsync(IWebApiUser user)
        {
            Contract.Requires(user != null, "The user must not be null.");
            var userCache = cacheService.GetUserCache(user);

            logger.Info("User [{0}] is cached:  {1}.", user, userCache != null);
            if (userCache == null)
            {
                logger.Info("Caching user [{0}] information.", user);
                var camUser = await userService.GetUserByIdAsync(user.Id);

                var isValidUser = false;
                IEnumerable <IPermission> permissions = new List <IPermission>();
                if (camUser != null)
                {
                    isValidUser = await userService.IsUserValidAsync(user.Id);

                    if (isValidUser)
                    {
                        permissions = await GetUserPermissionsAsync(camUser.PrincipalId);
                    }
                }
                else
                {
                    camUser = new User();
                }
                userCache = new UserCache(user, camUser, isValidUser, permissions);
                cacheService.Add(userCache);
                return(userCache);
            }
            else
            {
                return(userCache);
            }
        }
Exemplo n.º 2
0
        public override async Task <IResult <TResponse> > Handle(TRequest request, CancellationToken cancellationToken)
        {
            var       code = GenerateKey(request);
            TResponse existing;

            if (request.CacheControl != CacheControl.NoCache)
            {
                existing = _cacheService.Get <TResponse>(code);

                if (existing != null)
                {
                    request.CompletedFromCache = true;
                    OnGotFromCache(existing, code);
                    return(Result.Success(existing));
                }
            }

            if (request.CacheControl == CacheControl.OnlyIfCached)
            {
                return(Result.Failure <TResponse>(ErrorCodes.NotFound));
            }

            var result = await HandleImpl(request, cancellationToken)
                         .ConfigureAwait(false);

            if (result.IsFailure)
            {
                return(result);
            }

            var regions = Enum.GetValues <CacheRegion>()
                          .Where(r => request.CacheRegion.HasFlag(r))
                          .Select(r => r.ToString())
                          .ToArray();

            _cacheService.Add(result.Value, code, regions);

            OnAddedToCache(result.Value, code, request.CacheRegion.ToString());

            return(result);
        }
Exemplo n.º 3
0
        public UserModule(IUserService userService, IErrorService error, IPasswordService passwordService, IUserCacheService userCacheService) : base("/user")
        {
            Post["/create"] = _ =>
            {
                if (Params.AreMissing("UserName", "Email"))
                {
                    return(error.MissingParameters(Response));
                }
                if (userService.GetUserByName(Params.UserName) != null)
                {
                    return(error.UserNameTaken(Response));
                }
                if (!Params.Email.IsEmail())
                {
                    return(error.InvalidParameters(Response));
                }
                var password = userService.CreateUser(Params.UserName, Params.Email);
                return((string.IsNullOrWhiteSpace(password)) ? error.InvalidParameters(Response) : Response.AsJson(new { Password = password }));
            };

            Post["/validate"] = _ =>
            {
                if (Params.AreMissing("UserName", "Password"))
                {
                    return(error.MissingParameters(Response));
                }
                var user = userService.GetUserByName(Params.UserName);
                if (user == null || !passwordService.IsPasswordValid(user, Params.Password))
                {
                    return(error.NoUserForCredentials(Response));
                }
                var key = userCacheService.Add(user);
                return((key == null) ? error.InvalidParameters(Response) : Response.AsJson(new { ThumbKey = key }));
            };

            Post["/get"] = _ =>
            {
                if (Params.AreMissing("ThumbKey"))
                {
                    return(error.MissingParameters(Response));
                }
                if (!Params.ThumbKey.IsGuid())
                {
                    return(error.InvalidParameters(Response));
                }
                var user = userCacheService.GetUser(Params.ThumbKey);
                return((user == null) ? error.NoUserForThumbkey(Response) : Response.AsJson(new { User = new { Id = user.Id, UserName = user.UserName, Email = user.Email } }));
            };

            Post["/validate/thumbkey"] = _ =>
            {
                if (Params.AreMissing("ThumbKey"))
                {
                    return(error.MissingParameters(Response));
                }
                if (!Params.ThumbKey.IsGuid())
                {
                    return(error.InvalidParameters(Response));
                }
                var isValid = userCacheService.Validate(Params.ThumbKey);
                return(!isValid?error.NoUserForThumbkey(Response) : HttpStatusCode.OK);
            };

            Post["/validate/name"] = _ =>
            {
                if (Params.AreMissing("UserName"))
                {
                    return(error.MissingParameters(Response));
                }
                var isValid = userService.GetUserByName(Params.UserName) == null;
                return(!isValid?error.UserNameTaken(Response) : HttpStatusCode.OK);
            };

            Post["/reset/password"] = _ =>
            {
                if (Params.AreMissing("UserName", "Password"))
                {
                    return(error.MissingParameters(Response));
                }
                var user = userService.GetUserByName(Params.UserName);
                if (user == null || !passwordService.IsPasswordValid(user, Params.Password))
                {
                    return(error.NoUserForCredentials(Response));
                }
                var password = userService.ResetPassword(user);
                return((password == null) ? error.InvalidParameters(Response) : Response.AsJson(new { Password = password }));
            };

            Post["/forgot-password/request"] = _ =>
            {
                if (Params.AreMissing("UserName", "Email"))
                {
                    return(error.MissingParameters(Response));
                }
                if (!Params.Email.IsEmail())
                {
                    return(error.InvalidParameters(Response));
                }
                var user = userService.GetUserByName(Params.UserName);
                if (user == null)
                {
                    return(error.NoUserForCredentials(Response));
                }
                if (user.Email != Params.Email)
                {
                    return(error.NoUserForEmail(Response));
                }
                var token = userService.ForgotPasswordRequest(user);
                return((token == null) ? error.InvalidParameters(Response) : Response.AsJson(new { Token = token }));
            };

            Post["/forgot-password/reset"] = _ =>
            {
                if (Params.AreMissing("UserName", "Token"))
                {
                    return(error.MissingParameters(Response));
                }
                if (!Params.Token.IsGuid())
                {
                    return(error.InvalidParameters(Response));
                }
                var user = userService.GetUserByName(Params.UserName);
                if (user == null || !passwordService.IsForgotPasswordTokenValid(user, Params.Token))
                {
                    return(error.InvalidForgotPasswordToken(Response));
                }
                var password = userService.ForgotPasswordReset(user);
                return((password == null) ? error.InvalidParameters(Response) : Response.AsJson(new { Password = password }));
            };

            Post["/logout"] = _ =>
            {
                if (Params.AreMissing("ThumbKey"))
                {
                    return(error.MissingParameters(Response));
                }
                if (!Params.ThumbKey.IsGuid())
                {
                    return(error.InvalidParameters(Response));
                }
                var success = userCacheService.Remove(Params.ThumbKey);
                return(!success?error.NoUserForThumbkey(Response) : HttpStatusCode.OK);
            };
        }
Exemplo n.º 4
0
        public UserModule(IUserService userService, IErrorService error, IPasswordService passwordService, IUserCacheService userCacheService)
            : base("/user")
        {
            Post["/create"] = _ =>
            {
                if (Params.AreMissing("UserName", "Email")) return error.MissingParameters(Response);
                if (userService.GetUserByName(Params.UserName)!=null) return error.UserNameTaken(Response);
                if (!Params.Email.IsEmail()) return error.InvalidParameters(Response);
                var password = userService.CreateUser(Params.UserName, Params.Email);
                return (string.IsNullOrWhiteSpace(password)) ? error.InvalidParameters(Response) : Response.AsJson(new { Password = password });
            };

            Post["/validate"] = _ =>
            {
                if (Params.AreMissing("UserName", "Password")) return error.MissingParameters(Response);
                var user = userService.GetUserByName(Params.UserName);
                if (user == null || !passwordService.IsPasswordValid(user, Params.Password)) return error.NoUserForCredentials(Response);
                var key = userCacheService.Add(user);
                return (key == null) ? error.InvalidParameters(Response) : Response.AsJson(new { ThumbKey = key });
            };

            Post["/get"] = _ =>
            {
                if (Params.AreMissing("ThumbKey")) return error.MissingParameters(Response);
                if (!Params.ThumbKey.IsGuid()) return error.InvalidParameters(Response);
                var user = userCacheService.GetUser(Params.ThumbKey);
                return (user == null) ? error.NoUserForThumbkey(Response) : Response.AsJson(new { User = new { Id = user.Id, UserName = user.UserName, Email = user.Email } });
            };

            Post["/validate/thumbkey"] = _ =>
            {
                if (Params.AreMissing("ThumbKey")) return error.MissingParameters(Response);
                if (!Params.ThumbKey.IsGuid()) return error.InvalidParameters(Response);
                var isValid = userCacheService.Validate(Params.ThumbKey);
                return !isValid ? error.NoUserForThumbkey(Response) : HttpStatusCode.OK;
            };

            Post["/validate/name"] = _ =>
            {
                if (Params.AreMissing("UserName")) return error.MissingParameters(Response);
                var isValid = userService.GetUserByName(Params.UserName)==null;
                return !isValid ? error.UserNameTaken(Response) : HttpStatusCode.OK;
            };

            Post["/reset/password"] = _ =>
            {
                if (Params.AreMissing("UserName", "Password")) return error.MissingParameters(Response);
                var user = userService.GetUserByName(Params.UserName);
                if (user == null || !passwordService.IsPasswordValid(user, Params.Password)) return error.NoUserForCredentials(Response);
                var password = userService.ResetPassword(user);
                return (password == null) ? error.InvalidParameters(Response) : Response.AsJson(new { Password = password });
            };

            Post["/forgot-password/request"] = _ =>
            {
                if (Params.AreMissing("UserName", "Email")) return error.MissingParameters(Response);
                if (!Params.Email.IsEmail()) return error.InvalidParameters(Response);
                var user = userService.GetUserByName(Params.UserName);
                if (user == null) return error.NoUserForCredentials(Response);
                if (user.Email != Params.Email) return error.NoUserForEmail(Response);
                var token = userService.ForgotPasswordRequest(user);
                return (token == null) ? error.InvalidParameters(Response) : Response.AsJson(new { Token = token });
            };

            Post["/forgot-password/reset"] = _ =>
            {
                if (Params.AreMissing("UserName", "Token")) return error.MissingParameters(Response);
                if (!Params.Token.IsGuid()) return error.InvalidParameters(Response);
                var user = userService.GetUserByName(Params.UserName);
                if (user == null || !passwordService.IsForgotPasswordTokenValid(user, Params.Token)) return error.InvalidForgotPasswordToken(Response);
                var password = userService.ForgotPasswordReset(user);
                return (password == null) ? error.InvalidParameters(Response) : Response.AsJson(new { Password = password });
            };

            Post["/logout"] = _ =>
            {
                if (Params.AreMissing("ThumbKey")) return error.MissingParameters(Response);
                if (!Params.ThumbKey.IsGuid()) return error.InvalidParameters(Response);
                var success = userCacheService.Remove(Params.ThumbKey);
                return !success ? error.NoUserForThumbkey(Response) : HttpStatusCode.OK;
            };
        }