/**
         * Set user exclude until.
         */
        private static void SetUserExcludeUntil(User user, SetUserLimitsRequest setUserLimitsRequest)
        {
            Debug.Tested();
            Debug.AssertValid(user);
            Debug.AssertValid(setUserLimitsRequest);

            if (setUserLimitsRequest.excludeUntil != null)
            {
                // Exclude until time is being changed
                Debug.Tested();
                DateTime excludeUntil = (DateTime)APIHelper.DateTimeFromAPIDateTimeString(setUserLimitsRequest.excludeUntil);
                if (user.ExcludeUntil == null)
                {
                    // Exclude until time not set yet
                    Debug.Tested();
                    user.ExcludeUntil = excludeUntil;
                }
                else if (user.ExcludeUntil <= excludeUntil)
                {
                    // Exclude until time set and is being increased (or staying the same)
                    Debug.Tested();
                    user.ExcludeUntil        = excludeUntil;
                    user.NewExcludeUntil     = null;
                    user.NewExcludeUntilTime = null;
                }
                else
                {
                    // Exclude until time set and is being reduced
                    Debug.Tested();
                    user.NewExcludeUntil     = excludeUntil;
                    user.NewExcludeUntilTime = DateTime.Now.AddDays(7);
                }
            }
            else
            {
                // Exclude until time is not being changed
                Debug.Tested();
            }
        }
        /**
         * Set user max time logged in.
         */
        private static void SetUserMaxTimeLoggedIn(User user, SetUserLimitsRequest setUserLimitsRequest)
        {
            Debug.Tested();
            Debug.AssertValid(user);
            Debug.AssertValid(setUserLimitsRequest);

            if (setUserLimitsRequest.maxTimeLoggedIn != null)
            {
                // Max time logged in is being changed
                Debug.Tested();
                if (user.MaxTimeLoggedIn == null)
                {
                    // Max time logged in not set yet
                    Debug.Tested();
                    user.MaxTimeLoggedIn = setUserLimitsRequest.maxTimeLoggedIn;
                }
                else if (setUserLimitsRequest.maxTimeLoggedIn <= user.MaxTimeLoggedIn)
                {
                    // Max time logged in set and is being reduced (or staying the same)
                    Debug.Tested();
                    user.MaxTimeLoggedIn        = setUserLimitsRequest.maxTimeLoggedIn;
                    user.NewMaxTimeLoggedIn     = null;
                    user.NewMaxTimeLoggedInTime = null;
                }
                else
                {
                    // Max time logged in set and is being increased
                    Debug.Tested();
                    user.NewMaxTimeLoggedIn     = setUserLimitsRequest.maxTimeLoggedIn;
                    user.NewMaxTimeLoggedInTime = DateTime.Now.AddDays(7);
                }
            }
            else
            {
                // Max time logged in is not being changed
                Debug.Tested();
            }
        }
        /**
         * Set user max daily spending amount.
         */
        private static void SetUserMaxDailySpendingAmount(User user, SetUserLimitsRequest setUserLimitsRequest)
        {
            Debug.Tested();
            Debug.AssertValid(user);
            Debug.AssertValid(setUserLimitsRequest);

            if (setUserLimitsRequest.maxDailySpendingAmount != null)
            {
                // Max daily spending amount is being changed
                Debug.Tested();
                if (user.MaxDailySpendingAmount == null)
                {
                    // Max daily spending amount not set yet
                    Debug.Tested();
                    user.MaxDailySpendingAmount = setUserLimitsRequest.maxDailySpendingAmount;
                }
                else if (setUserLimitsRequest.maxDailySpendingAmount <= user.MaxDailySpendingAmount)
                {
                    // Max daily spending amount set and is being reduced (or staying the same)
                    Debug.Tested();
                    user.MaxDailySpendingAmount        = setUserLimitsRequest.maxDailySpendingAmount;
                    user.NewMaxDailySpendingAmount     = null;
                    user.NewMaxDailySpendingAmountTime = null;
                }
                else
                {
                    // Max daily spending amount set and is being increased
                    Debug.Tested();
                    user.NewMaxDailySpendingAmount     = setUserLimitsRequest.maxDailySpendingAmount;
                    user.NewMaxDailySpendingAmountTime = DateTime.Now.AddDays(7);
                }
            }
            else
            {
                // Max daily spending amount is not being changed
                Debug.Tested();
            }
        }
        /**
         * Set user limits.
         */
        private async Task <APIGatewayProxyResponse> SetUserLimits(IDataStores dataStores,
                                                                   IDictionary <string, string> requestHeaders,
                                                                   JObject requestBody)
        {
            Debug.Untested();
            Debug.AssertValid(dataStores);
            Debug.AssertValid(requestHeaders);
            Debug.AssertValidOrNull(requestBody);

            try {
                // Log call
                LoggingHelper.LogMessage($"UserIdentityService::SetUserLimits()");

                // Get the NoSQL DB client
                AmazonDynamoDBClient dbClient = (AmazonDynamoDBClient)dataStores.GetNoSQLDataStore().GetDBClient();
                Debug.AssertValid(dbClient);

                // Check inputs
                SetUserLimitsRequest setUserLimitsRequest = UserIdentityService_SetUserLimits_LogicLayer.CheckValidSetUserLimitsRequest(requestBody);
                Debug.AssertValid(setUserLimitsRequest);

                // Check authenticated endpoint security
                string loggedInUserId = await APIHelper.CheckLoggedIn(dbClient, requestHeaders);

                Debug.AssertID(loggedInUserId);

                // Perform logic
                await UserIdentityService_SetUserLimits_LogicLayer.SetUserLimits(dbClient, loggedInUserId, setUserLimitsRequest);

                // Respond
                return(new APIGatewayProxyResponse {
                    StatusCode = APIHelper.STATUS_CODE_NO_CONTENT
                });
            } catch (Exception exception) {
                Debug.Tested();
                return(APIHelper.ResponseFromException(exception));
            }
        }
        /**
         * Set user limits.
         */
        public static async Task SetUserLimits(AmazonDynamoDBClient dbClient, string loggedInUserId, SetUserLimitsRequest setUserLimitsRequest)
        {
            Debug.Tested();
            Debug.AssertValid(dbClient);
            Debug.AssertID(loggedInUserId);
            Debug.AssertValid(setUserLimitsRequest);

            if ((setUserLimitsRequest.maxDailySpendingAmount != null) ||
                (setUserLimitsRequest.maxTimeLoggedIn != null) ||
                (setUserLimitsRequest.excludeUntil != null))
            {
                // At least one of the limits may be being changed
                Debug.Tested();

                // Load the user
                User user = await IdentityServiceLogicLayer.FindUserByID(dbClient, loggedInUserId);

                Debug.AssertValid(user);

                // Make changes
                SetUserMaxDailySpendingAmount(user, setUserLimitsRequest);
                SetUserMaxTimeLoggedIn(user, setUserLimitsRequest);
                SetUserExcludeUntil(user, setUserLimitsRequest);

                // Save the user
                await IdentityServiceDataLayer.SaveUser(dbClient, user);
            }
            else
            {
                Debug.Tested();
            }
        }