| /* |
| // Copyright (c) 2018 Intel Corporation |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| */ |
| #include "http_response.hpp" |
| |
| #include <boost/beast/http/status.hpp> |
| #include <error_messages.hpp> |
| #include <logging.hpp> |
| #include <nlohmann/json.hpp> |
| |
| namespace redfish |
| { |
| |
| namespace messages |
| { |
| |
| static void addMessageToErrorJson(nlohmann::json& target, |
| const nlohmann::json& message) |
| { |
| auto& error = target["error"]; |
| |
| // If this is the first error message, fill in the information from the |
| // first error message to the top level struct |
| if (!error.is_object()) |
| { |
| auto messageIdIterator = message.find("MessageId"); |
| if (messageIdIterator == message.end()) |
| { |
| BMCWEB_LOG_CRITICAL |
| << "Attempt to add error message without MessageId"; |
| return; |
| } |
| |
| auto messageFieldIterator = message.find("Message"); |
| if (messageFieldIterator == message.end()) |
| { |
| BMCWEB_LOG_CRITICAL |
| << "Attempt to add error message without Message"; |
| return; |
| } |
| error = {{"code", *messageIdIterator}, |
| {"message", *messageFieldIterator}}; |
| } |
| else |
| { |
| // More than 1 error occurred, so the message has to be generic |
| error["code"] = std::string(messageVersionPrefix) + "GeneralError"; |
| error["message"] = "A general error has occurred. See Resolution for " |
| "information on how to resolve the error."; |
| } |
| |
| // This check could technically be done in in the default construction |
| // branch above, but because we need the pointer to the extended info field |
| // anyway, it's more efficient to do it here. |
| auto& extendedInfo = error[messages::messageAnnotation]; |
| if (!extendedInfo.is_array()) |
| { |
| extendedInfo = nlohmann::json::array(); |
| } |
| |
| extendedInfo.push_back(message); |
| } |
| |
| static void addMessageToJsonRoot(nlohmann::json& target, |
| const nlohmann::json& message) |
| { |
| if (!target[messages::messageAnnotation].is_array()) |
| { |
| // Force object to be an array |
| target[messages::messageAnnotation] = nlohmann::json::array(); |
| } |
| |
| target[messages::messageAnnotation].push_back(message); |
| } |
| |
| static void addMessageToJson(nlohmann::json& target, |
| const nlohmann::json& message, |
| const std::string& fieldPath) |
| { |
| std::string extendedInfo(fieldPath + messages::messageAnnotation); |
| |
| if (!target[extendedInfo].is_array()) |
| { |
| // Force object to be an array |
| target[extendedInfo] = nlohmann::json::array(); |
| } |
| |
| // Object exists and it is an array so we can just push in the message |
| target[extendedInfo].push_back(message); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats ResourceInUse message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json resourceInUse(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.ResourceInUse"}, |
| {"Message", "The change to the requested resource failed because " |
| "the resource is in use or in transition."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", "Remove the condition and resubmit the request if " |
| "the operation failed."}}; |
| } |
| |
| void resourceInUse(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::service_unavailable); |
| addMessageToErrorJson(res.jsonValue, resourceInUse()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats MalformedJSON message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json malformedJSON(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.MalformedJSON"}, |
| {"Message", "The request body submitted was malformed JSON and " |
| "could not be parsed by the receiving service."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", "Ensure that the request body is valid JSON and " |
| "resubmit the request."}}; |
| } |
| |
| void malformedJSON(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, malformedJSON()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats ResourceMissingAtURI message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json resourceMissingAtURI(const std::string& arg1) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.ResourceMissingAtURI"}, |
| {"Message", "The resource at the URI " + arg1 + " was not found."}, |
| {"MessageArgs", {arg1}}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", "Place a valid resource at the URI or correct the " |
| "URI and resubmit the request."}}; |
| } |
| |
| void resourceMissingAtURI(crow::Response& res, const std::string& arg1) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, resourceMissingAtURI(arg1)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats ActionParameterValueFormatError message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json actionParameterValueFormatError(const std::string& arg1, |
| const std::string& arg2, |
| const std::string& arg3) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.ActionParameterValueFormatError"}, |
| {"Message", |
| "The value " + arg1 + " for the parameter " + arg2 + |
| " in the action " + arg3 + |
| " is of a different format than the parameter can accept."}, |
| {"MessageArgs", {arg1, arg2, arg3}}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", |
| "Correct the value for the parameter in the request body and " |
| "resubmit the request if the operation failed."}}; |
| } |
| |
| void actionParameterValueFormatError(crow::Response& res, |
| const std::string& arg1, |
| const std::string& arg2, |
| const std::string& arg3) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, |
| actionParameterValueFormatError(arg1, arg2, arg3)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats InternalError message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json internalError(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.InternalError"}, |
| {"Message", "The request failed due to an internal service error. " |
| "The service is still operational."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", "Resubmit the request. If the problem persists, " |
| "consider resetting the service."}}; |
| } |
| |
| void internalError(crow::Response& res, const bmcweb::source_location location) |
| { |
| BMCWEB_LOG_CRITICAL << "Internal Error " << location.file_name() << "(" |
| << location.line() << ":" << location.column() << ") `" |
| << location.function_name() << "`: "; |
| res.result(boost::beast::http::status::internal_server_error); |
| addMessageToErrorJson(res.jsonValue, internalError()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats UnrecognizedRequestBody message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json unrecognizedRequestBody(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.UnrecognizedRequestBody"}, |
| {"Message", "The service detected a malformed request body that it " |
| "was unable to interpret."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", "Correct the request body and resubmit the request " |
| "if it failed."}}; |
| } |
| |
| void unrecognizedRequestBody(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, unrecognizedRequestBody()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats ResourceAtUriUnauthorized message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json resourceAtUriUnauthorized(const std::string& arg1, |
| const std::string& arg2) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.ResourceAtUriUnauthorized"}, |
| {"Message", "While accessing the resource at " + arg1 + |
| ", the service received an authorization error " + |
| arg2 + "."}, |
| {"MessageArgs", {arg1, arg2}}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", "Ensure that the appropriate access is provided for " |
| "the service in order for it to access the URI."}}; |
| } |
| |
| void resourceAtUriUnauthorized(crow::Response& res, const std::string& arg1, |
| const std::string& arg2) |
| { |
| res.result(boost::beast::http::status::unauthorized); |
| addMessageToErrorJson(res.jsonValue, resourceAtUriUnauthorized(arg1, arg2)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats ActionParameterUnknown message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json actionParameterUnknown(const std::string& arg1, |
| const std::string& arg2) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.ActionParameterUnknown"}, |
| {"Message", "The action " + arg1 + |
| " was submitted with the invalid parameter " + arg2 + |
| "."}, |
| {"MessageArgs", {arg1, arg2}}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", "Correct the invalid parameter and resubmit the " |
| "request if the operation failed."}}; |
| } |
| |
| void actionParameterUnknown(crow::Response& res, const std::string& arg1, |
| const std::string& arg2) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, actionParameterUnknown(arg1, arg2)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats ResourceCannotBeDeleted message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json resourceCannotBeDeleted(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.ResourceCannotBeDeleted"}, |
| {"Message", "The delete request failed because the resource " |
| "requested cannot be deleted."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", "Do not attempt to delete a non-deletable resource."}}; |
| } |
| |
| void resourceCannotBeDeleted(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::forbidden); |
| addMessageToErrorJson(res.jsonValue, resourceCannotBeDeleted()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats PropertyDuplicate message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json propertyDuplicate(const std::string& arg1) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.PropertyDuplicate"}, |
| {"Message", "The property " + arg1 + " was duplicated in the request."}, |
| {"MessageArgs", {arg1}}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", |
| "Remove the duplicate property from the request body and resubmit " |
| "the request if the operation failed."}}; |
| } |
| |
| void propertyDuplicate(crow::Response& res, const std::string& arg1) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToJson(res.jsonValue, propertyDuplicate(arg1), arg1); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats ServiceTemporarilyUnavailable message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json serviceTemporarilyUnavailable(const std::string& arg1) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.ServiceTemporarilyUnavailable"}, |
| {"Message", "The service is temporarily unavailable. Retry in " + |
| arg1 + " seconds."}, |
| {"MessageArgs", {arg1}}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", "Wait for the indicated retry duration and retry " |
| "the operation."}}; |
| } |
| |
| void serviceTemporarilyUnavailable(crow::Response& res, const std::string& arg1) |
| { |
| res.addHeader("Retry-After", arg1); |
| res.result(boost::beast::http::status::service_unavailable); |
| addMessageToErrorJson(res.jsonValue, serviceTemporarilyUnavailable(arg1)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats ResourceAlreadyExists message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json resourceAlreadyExists(const std::string& arg1, |
| const std::string& arg2, |
| const std::string& arg3) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.ResourceAlreadyExists"}, |
| {"Message", "The requested resource of type " + arg1 + |
| " with the property " + arg2 + " with the value " + |
| arg3 + " already exists."}, |
| {"MessageArgs", {arg1, arg2, arg3}}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", "Do not repeat the create operation as the resource " |
| "has already been created."}}; |
| } |
| |
| void resourceAlreadyExists(crow::Response& res, const std::string& arg1, |
| const std::string& arg2, const std::string& arg3) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToJson(res.jsonValue, resourceAlreadyExists(arg1, arg2, arg3), |
| arg2); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats AccountForSessionNoLongerExists message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json accountForSessionNoLongerExists(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.AccountForSessionNoLongerExists"}, |
| {"Message", "The account for the current session has been removed, " |
| "thus the current session has been removed as well."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "OK"}, |
| {"Resolution", "Attempt to connect with a valid account."}}; |
| } |
| |
| void accountForSessionNoLongerExists(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::forbidden); |
| addMessageToErrorJson(res.jsonValue, accountForSessionNoLongerExists()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats CreateFailedMissingReqProperties message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json createFailedMissingReqProperties(const std::string& arg1) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.CreateFailedMissingReqProperties"}, |
| {"Message", |
| "The create operation failed because the required property " + arg1 + |
| " was missing from the request."}, |
| {"MessageArgs", {arg1}}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", |
| "Correct the body to include the required property with a valid " |
| "value and resubmit the request if the operation failed."}}; |
| } |
| |
| void createFailedMissingReqProperties(crow::Response& res, |
| const std::string& arg1) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToJson(res.jsonValue, createFailedMissingReqProperties(arg1), |
| arg1); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats PropertyValueFormatError message into JSON for the specified |
| * property |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json propertyValueFormatError(const std::string& arg1, |
| const std::string& arg2) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.PropertyValueFormatError"}, |
| {"Message", |
| "The value " + arg1 + " for the property " + arg2 + |
| " is of a different format than the property can accept."}, |
| {"MessageArgs", {arg1, arg2}}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", |
| "Correct the value for the property in the request body and " |
| "resubmit the request if the operation failed."}}; |
| } |
| |
| void propertyValueFormatError(crow::Response& res, const std::string& arg1, |
| const std::string& arg2) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToJson(res.jsonValue, propertyValueFormatError(arg1, arg2), arg2); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats PropertyValueNotInList message into JSON for the specified |
| * property |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json propertyValueNotInList(const std::string& arg1, |
| const std::string& arg2) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.PropertyValueNotInList"}, |
| {"Message", "The value " + arg1 + " for the property " + arg2 + |
| " is not in the list of acceptable values."}, |
| {"MessageArgs", {arg1, arg2}}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", "Choose a value from the enumeration list that " |
| "the implementation " |
| "can support and resubmit the request if the " |
| "operation failed."}}; |
| } |
| |
| void propertyValueNotInList(crow::Response& res, const std::string& arg1, |
| const std::string& arg2) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToJson(res.jsonValue, propertyValueNotInList(arg1, arg2), arg2); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats ResourceAtUriInUnknownFormat message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json resourceAtUriInUnknownFormat(const std::string& arg1) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.ResourceAtUriInUnknownFormat"}, |
| {"Message", "The resource at " + arg1 + |
| " is in a format not recognized by the service."}, |
| {"MessageArgs", {arg1}}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", "Place an image or resource or file that is " |
| "recognized by the service at the URI."}}; |
| } |
| |
| void resourceAtUriInUnknownFormat(crow::Response& res, const std::string& arg1) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, resourceAtUriInUnknownFormat(arg1)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats ServiceDisabled message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json serviceDisabled(const std::string& arg1) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.11.0.ServiceDisabled"}, |
| {"Message", "The operation failed because the service at " + arg1 + |
| " is disabled and cannot accept requests."}, |
| {"MessageArgs", {arg1}}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", "Enable the service and resubmit the request if the " |
| "operation failed."}}; |
| } |
| |
| void serviceDisabled(crow::Response& res, const std::string& arg1) |
| { |
| res.result(boost::beast::http::status::service_unavailable); |
| addMessageToErrorJson(res.jsonValue, serviceDisabled(arg1)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats ServiceInUnknownState message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json serviceInUnknownState(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.ServiceInUnknownState"}, |
| {"Message", |
| "The operation failed because the service is in an unknown state " |
| "and can no longer take incoming requests."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", "Restart the service and resubmit the request if " |
| "the operation failed."}}; |
| } |
| |
| void serviceInUnknownState(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::service_unavailable); |
| addMessageToErrorJson(res.jsonValue, serviceInUnknownState()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats EventSubscriptionLimitExceeded message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json eventSubscriptionLimitExceeded(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.EventSubscriptionLimitExceeded"}, |
| {"Message", |
| "The event subscription failed due to the number of simultaneous " |
| "subscriptions exceeding the limit of the implementation."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", |
| "Reduce the number of other subscriptions before trying to " |
| "establish the event subscription or increase the limit of " |
| "simultaneous subscriptions (if supported)."}}; |
| } |
| |
| void eventSubscriptionLimitExceeded(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::service_unavailable); |
| addMessageToErrorJson(res.jsonValue, eventSubscriptionLimitExceeded()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats ActionParameterMissing message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json actionParameterMissing(const std::string& arg1, |
| const std::string& arg2) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.ActionParameterMissing"}, |
| {"Message", "The action " + arg1 + " requires the parameter " + arg2 + |
| " to be present in the request body."}, |
| {"MessageArgs", {arg1, arg2}}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", |
| "Supply the action with the required parameter in the request " |
| "body when the request is resubmitted."}}; |
| } |
| |
| void actionParameterMissing(crow::Response& res, const std::string& arg1, |
| const std::string& arg2) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, actionParameterMissing(arg1, arg2)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats StringValueTooLong message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json stringValueTooLong(const std::string& arg1, int arg2) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.StringValueTooLong"}, |
| {"Message", "The string " + arg1 + " exceeds the length limit " + |
| std::to_string(arg2) + "."}, |
| {"MessageArgs", {arg1, std::to_string(arg2)}}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", |
| "Resubmit the request with an appropriate string length."}}; |
| } |
| |
| void stringValueTooLong(crow::Response& res, const std::string& arg1, int arg2) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, stringValueTooLong(arg1, arg2)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats SessionTerminated message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json sessionTerminated(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.SessionTerminated"}, |
| {"Message", "The session was successfully terminated."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "OK"}, |
| {"Resolution", "No resolution is required."}}; |
| } |
| |
| void sessionTerminated(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::ok); |
| addMessageToJsonRoot(res.jsonValue, sessionTerminated()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats SubscriptionTerminated message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json subscriptionTerminated(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.SubscriptionTerminated"}, |
| {"Message", "The event subscription has been terminated."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "OK"}, |
| {"Resolution", "No resolution is required."}}; |
| } |
| |
| void subscriptionTerminated(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::ok); |
| addMessageToJsonRoot(res.jsonValue, subscriptionTerminated()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats ResourceTypeIncompatible message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json resourceTypeIncompatible(const std::string& arg1, |
| const std::string& arg2) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.ResourceTypeIncompatible"}, |
| {"Message", "The @odata.type of the request body " + arg1 + |
| " is incompatible with the @odata.type of the " |
| "resource which is " + |
| arg2 + "."}, |
| {"MessageArgs", {arg1, arg2}}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", "Resubmit the request with a payload compatible " |
| "with the resource's schema."}}; |
| } |
| |
| void resourceTypeIncompatible(crow::Response& res, const std::string& arg1, |
| const std::string& arg2) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, resourceTypeIncompatible(arg1, arg2)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats ResetRequired message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json resetRequired(const std::string& arg1, const std::string& arg2) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.ResetRequired"}, |
| {"Message", "In order to complete the operation, a component reset is " |
| "required with the Reset action URI '" + |
| arg1 + "' and ResetType '" + arg2 + "'."}, |
| {"MessageArgs", {arg1, arg2}}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", |
| "Perform the required Reset action on the specified component."}}; |
| } |
| |
| void resetRequired(crow::Response& res, const std::string& arg1, |
| const std::string& arg2) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, resetRequired(arg1, arg2)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats ChassisPowerStateOnRequired message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json chassisPowerStateOnRequired(const std::string& arg1) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.ChassisPowerStateOnRequired"}, |
| {"Message", "The Chassis with Id '" + arg1 + |
| "' requires to be powered on to perform this request."}, |
| {"MessageArgs", {arg1}}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", |
| "Power on the specified Chassis and resubmit the request."}}; |
| } |
| |
| void chassisPowerStateOnRequired(crow::Response& res, const std::string& arg1) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, chassisPowerStateOnRequired(arg1)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats ChassisPowerStateOffRequired message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json chassisPowerStateOffRequired(const std::string& arg1) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.ChassisPowerStateOffRequired"}, |
| {"Message", |
| "The Chassis with Id '" + arg1 + |
| "' requires to be powered off to perform this request."}, |
| {"MessageArgs", {arg1}}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", |
| "Power off the specified Chassis and resubmit the request."}}; |
| } |
| |
| void chassisPowerStateOffRequired(crow::Response& res, const std::string& arg1) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, chassisPowerStateOffRequired(arg1)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats PropertyValueConflict message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json propertyValueConflict(const std::string& arg1, |
| const std::string& arg2) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.PropertyValueConflict"}, |
| {"Message", "The property '" + arg1 + |
| "' could not be written because its value would " |
| "conflict with the value of the '" + |
| arg2 + "' property."}, |
| {"MessageArgs", {arg1, arg2}}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", "No resolution is required."}}; |
| } |
| |
| void propertyValueConflict(crow::Response& res, const std::string& arg1, |
| const std::string& arg2) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, propertyValueConflict(arg1, arg2)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats PropertyValueIncorrect message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json propertyValueIncorrect(const std::string& arg1, |
| const std::string& arg2) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.PropertyValueIncorrect"}, |
| {"Message", "The property '" + arg1 + |
| "' with the requested value of '" + arg2 + |
| "' could not be written because the value does not " |
| "meet the constraints of the implementation."}, |
| {"MessageArgs", {arg1, arg2}}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", "No resolution is required."}}; |
| } |
| |
| void propertyValueIncorrect(crow::Response& res, const std::string& arg1, |
| const std::string& arg2) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, propertyValueIncorrect(arg1, arg2)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats ResourceCreationConflict message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json resourceCreationConflict(const std::string& arg1) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.ResourceCreationConflict"}, |
| {"Message", "The resource could not be created. The service has a " |
| "resource at URI '" + |
| arg1 + "' that conflicts with the creation request."}, |
| {"MessageArgs", {arg1}}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", "No resolution is required."}}; |
| } |
| |
| void resourceCreationConflict(crow::Response& res, const std::string& arg1) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, resourceCreationConflict(arg1)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats MaximumErrorsExceeded message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json maximumErrorsExceeded(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.MaximumErrorsExceeded"}, |
| {"Message", "Too many errors have occurred to report them all."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", |
| "Resolve other reported errors and retry the current operation."}}; |
| } |
| |
| void maximumErrorsExceeded(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::internal_server_error); |
| addMessageToErrorJson(res.jsonValue, maximumErrorsExceeded()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats PreconditionFailed message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json preconditionFailed(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.PreconditionFailed"}, |
| {"Message", "The ETag supplied did not match the ETag required to " |
| "change this resource."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", "Try the operation again using the appropriate ETag."}}; |
| } |
| |
| void preconditionFailed(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::precondition_failed); |
| addMessageToErrorJson(res.jsonValue, preconditionFailed()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats PreconditionRequired message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json preconditionRequired(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.PreconditionRequired"}, |
| {"Message", "A precondition header or annotation is required to change " |
| "this resource."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", "Try the operation again using an If-Match or " |
| "If-None-Match header and appropriate ETag."}}; |
| } |
| |
| void preconditionRequired(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, preconditionRequired()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats OperationFailed message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json operationFailed(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.OperationFailed"}, |
| {"Message", |
| "An error occurred internal to the service as part of the overall " |
| "request. Partial results may have been returned."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", "Resubmit the request. If the problem persists, " |
| "consider resetting the service or provider."}}; |
| } |
| |
| void operationFailed(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::internal_server_error); |
| addMessageToErrorJson(res.jsonValue, operationFailed()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats OperationTimeout message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json operationTimeout(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.OperationTimeout"}, |
| {"Message", "A timeout internal to the service occured as part of the " |
| "request. Partial results may have been returned."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", "Resubmit the request. If the problem persists, " |
| "consider resetting the service or provider."}}; |
| } |
| |
| void operationTimeout(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::internal_server_error); |
| addMessageToErrorJson(res.jsonValue, operationTimeout()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats PropertyValueTypeError message into JSON for the specified |
| * property |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json propertyValueTypeError(const std::string& arg1, |
| const std::string& arg2) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.PropertyValueTypeError"}, |
| {"Message", |
| "The value " + arg1 + " for the property " + arg2 + |
| " is of a different type than the property can accept."}, |
| {"MessageArgs", {arg1, arg2}}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", |
| "Correct the value for the property in the request body and " |
| "resubmit the request if the operation failed."}}; |
| } |
| |
| void propertyValueTypeError(crow::Response& res, const std::string& arg1, |
| const std::string& arg2) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToJson(res.jsonValue, propertyValueTypeError(arg1, arg2), arg2); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats ResourceNotFound message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json resourceNotFound(const std::string& arg1, |
| const std::string& arg2) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.ResourceNotFound"}, |
| {"Message", "The requested resource of type " + arg1 + " named " + |
| arg2 + " was not found."}, |
| {"MessageArgs", {arg1, arg2}}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", |
| "Provide a valid resource identifier and resubmit the request."}}; |
| } |
| |
| void resourceNotFound(crow::Response& res, const std::string& arg1, |
| const std::string& arg2) |
| { |
| res.result(boost::beast::http::status::not_found); |
| addMessageToErrorJson(res.jsonValue, resourceNotFound(arg1, arg2)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats CouldNotEstablishConnection message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json couldNotEstablishConnection(const std::string& arg1) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.CouldNotEstablishConnection"}, |
| {"Message", |
| "The service failed to establish a connection with the URI " + arg1 + |
| "."}, |
| {"MessageArgs", {arg1}}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", |
| "Ensure that the URI contains a valid and reachable node name, " |
| "protocol information and other URI components."}}; |
| } |
| |
| void couldNotEstablishConnection(crow::Response& res, const std::string& arg1) |
| { |
| res.result(boost::beast::http::status::not_found); |
| addMessageToErrorJson(res.jsonValue, couldNotEstablishConnection(arg1)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats PropertyNotWritable message into JSON for the specified |
| * property |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json propertyNotWritable(const std::string& arg1) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.PropertyNotWritable"}, |
| {"Message", "The property " + arg1 + |
| " is a read only property and cannot be " |
| "assigned a value."}, |
| {"MessageArgs", {arg1}}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", "Remove the property from the request body and " |
| "resubmit the request if the operation failed."}}; |
| } |
| |
| void propertyNotWritable(crow::Response& res, const std::string& arg1) |
| { |
| res.result(boost::beast::http::status::forbidden); |
| addMessageToJson(res.jsonValue, propertyNotWritable(arg1), arg1); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats QueryParameterValueTypeError message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json queryParameterValueTypeError(const std::string& arg1, |
| const std::string& arg2) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.QueryParameterValueTypeError"}, |
| {"Message", |
| "The value " + arg1 + " for the query parameter " + arg2 + |
| " is of a different type than the parameter can accept."}, |
| {"MessageArgs", {arg1, arg2}}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", |
| "Correct the value for the query parameter in the request and " |
| "resubmit the request if the operation failed."}}; |
| } |
| |
| void queryParameterValueTypeError(crow::Response& res, const std::string& arg1, |
| const std::string& arg2) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, |
| queryParameterValueTypeError(arg1, arg2)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats ServiceShuttingDown message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json serviceShuttingDown(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.ServiceShuttingDown"}, |
| {"Message", "The operation failed because the service is shutting " |
| "down and can no longer take incoming requests."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", "When the service becomes available, resubmit the " |
| "request if the operation failed."}}; |
| } |
| |
| void serviceShuttingDown(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::service_unavailable); |
| addMessageToErrorJson(res.jsonValue, serviceShuttingDown()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats ActionParameterDuplicate message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json actionParameterDuplicate(const std::string& arg1, |
| const std::string& arg2) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.ActionParameterDuplicate"}, |
| {"Message", |
| "The action " + arg1 + |
| " was submitted with more than one value for the parameter " + |
| arg2 + "."}, |
| {"MessageArgs", {arg1, arg2}}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", |
| "Resubmit the action with only one instance of the parameter in " |
| "the request body if the operation failed."}}; |
| } |
| |
| void actionParameterDuplicate(crow::Response& res, const std::string& arg1, |
| const std::string& arg2) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, actionParameterDuplicate(arg1, arg2)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats ActionParameterNotSupported message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json actionParameterNotSupported(const std::string& arg1, |
| const std::string& arg2) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.ActionParameterNotSupported"}, |
| {"Message", "The parameter " + arg1 + " for the action " + arg2 + |
| " is not supported on the target resource."}, |
| {"MessageArgs", {arg1, arg2}}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", "Remove the parameter supplied and resubmit the " |
| "request if the operation failed."}}; |
| } |
| |
| void actionParameterNotSupported(crow::Response& res, const std::string& arg1, |
| const std::string& arg2) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, |
| actionParameterNotSupported(arg1, arg2)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats SourceDoesNotSupportProtocol message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json sourceDoesNotSupportProtocol(const std::string& arg1, |
| const std::string& arg2) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.SourceDoesNotSupportProtocol"}, |
| {"Message", "The other end of the connection at " + arg1 + |
| " does not support the specified protocol " + arg2 + |
| "."}, |
| {"MessageArgs", {arg1, arg2}}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", "Change protocols or URIs. "}}; |
| } |
| |
| void sourceDoesNotSupportProtocol(crow::Response& res, const std::string& arg1, |
| const std::string& arg2) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, |
| sourceDoesNotSupportProtocol(arg1, arg2)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats AccountRemoved message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json accountRemoved(void) |
| { |
| return nlohmann::json{{"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.AccountRemoved"}, |
| {"Message", "The account was successfully removed."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "OK"}, |
| {"Resolution", "No resolution is required."}}; |
| } |
| |
| void accountRemoved(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::ok); |
| addMessageToJsonRoot(res.jsonValue, accountRemoved()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats AccessDenied message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json accessDenied(const std::string& arg1) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.AccessDenied"}, |
| {"Message", "While attempting to establish a connection to " + arg1 + |
| ", the service denied access."}, |
| {"MessageArgs", {arg1}}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", "Attempt to ensure that the URI is correct and that " |
| "the service has the appropriate credentials."}}; |
| } |
| |
| void accessDenied(crow::Response& res, const std::string& arg1) |
| { |
| res.result(boost::beast::http::status::forbidden); |
| addMessageToErrorJson(res.jsonValue, accessDenied(arg1)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats QueryNotSupported message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json queryNotSupported(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.QueryNotSupported"}, |
| {"Message", "Querying is not supported by the implementation."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", "Remove the query parameters and resubmit the " |
| "request if the operation failed."}}; |
| } |
| |
| void queryNotSupported(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, queryNotSupported()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats CreateLimitReachedForResource message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json createLimitReachedForResource(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.CreateLimitReachedForResource"}, |
| {"Message", "The create operation failed because the resource has " |
| "reached the limit of possible resources."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", |
| "Either delete resources and resubmit the request if the " |
| "operation failed or do not resubmit the request."}}; |
| } |
| |
| void createLimitReachedForResource(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, createLimitReachedForResource()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats GeneralError message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json generalError(void) |
| { |
| return nlohmann::json{{"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.GeneralError"}, |
| {"Message", |
| "A general error has occurred. See Resolution for " |
| "information on how to resolve the error."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", "None."}}; |
| } |
| |
| void generalError(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::internal_server_error); |
| addMessageToErrorJson(res.jsonValue, generalError()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats Success message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json success(void) |
| { |
| return nlohmann::json{{"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.Success"}, |
| {"Message", "Successfully Completed Request"}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "OK"}, |
| {"Resolution", "None"}}; |
| } |
| |
| void success(crow::Response& res) |
| { |
| // don't set res.result here because success is the default and any |
| // error should overwrite the default |
| addMessageToJsonRoot(res.jsonValue, success()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats Created message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json created(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.Created"}, |
| {"Message", "The resource has been created successfully"}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "OK"}, |
| {"Resolution", "None"}}; |
| } |
| |
| void created(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::created); |
| addMessageToJsonRoot(res.jsonValue, created()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats NoOperation message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json noOperation(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.NoOperation"}, |
| {"Message", "The request body submitted contain no data to act " |
| "upon and no changes to the resource took place."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", |
| "Add properties in the JSON object and resubmit the request."}}; |
| } |
| |
| void noOperation(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, noOperation()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats PropertyUnknown message into JSON for the specified |
| * property |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json propertyUnknown(const std::string& arg1) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.PropertyUnknown"}, |
| {"Message", "The property " + arg1 + |
| " is not in the list of valid properties for " |
| "the resource."}, |
| {"MessageArgs", {arg1}}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", "Remove the unknown property from the request " |
| "body and resubmit " |
| "the request if the operation failed."}}; |
| } |
| |
| void propertyUnknown(crow::Response& res, const std::string& arg1) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToJson(res.jsonValue, propertyUnknown(arg1), arg1); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats NoValidSession message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json noValidSession(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.NoValidSession"}, |
| {"Message", |
| "There is no valid session established with the implementation."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", |
| "Establish a session before attempting any operations."}}; |
| } |
| |
| void noValidSession(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::forbidden); |
| addMessageToErrorJson(res.jsonValue, noValidSession()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats InvalidObject message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json invalidObject(const std::string& arg1) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.InvalidObject"}, |
| {"Message", "The object at " + arg1 + " is invalid."}, |
| {"MessageArgs", {arg1}}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", |
| "Either the object is malformed or the URI is not correct. " |
| "Correct the condition and resubmit the request if it failed."}}; |
| } |
| |
| void invalidObject(crow::Response& res, const std::string& arg1) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, invalidObject(arg1)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats ResourceInStandby message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json resourceInStandby(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.ResourceInStandby"}, |
| {"Message", "The request could not be performed because the " |
| "resource is in standby."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", "Ensure that the resource is in the correct power " |
| "state and resubmit the request."}}; |
| } |
| |
| void resourceInStandby(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::service_unavailable); |
| addMessageToErrorJson(res.jsonValue, resourceInStandby()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats ActionParameterValueTypeError message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json actionParameterValueTypeError(const std::string& arg1, |
| const std::string& arg2, |
| const std::string& arg3) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.ActionParameterValueTypeError"}, |
| {"Message", |
| "The value " + arg1 + " for the parameter " + arg2 + |
| " in the action " + arg3 + |
| " is of a different type than the parameter can accept."}, |
| {"MessageArgs", {arg1, arg2, arg3}}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", |
| "Correct the value for the parameter in the request body and " |
| "resubmit the request if the operation failed."}}; |
| } |
| |
| void actionParameterValueTypeError(crow::Response& res, const std::string& arg1, |
| const std::string& arg2, |
| const std::string& arg3) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, |
| actionParameterValueTypeError(arg1, arg2, arg3)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats SessionLimitExceeded message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json sessionLimitExceeded(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.SessionLimitExceeded"}, |
| {"Message", "The session establishment failed due to the number of " |
| "simultaneous sessions exceeding the limit of the " |
| "implementation."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", "Reduce the number of other sessions before trying " |
| "to establish the session or increase the limit of " |
| "simultaneous sessions (if supported)."}}; |
| } |
| |
| void sessionLimitExceeded(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::service_unavailable); |
| addMessageToErrorJson(res.jsonValue, sessionLimitExceeded()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats ActionNotSupported message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json actionNotSupported(const std::string& arg1) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.ActionNotSupported"}, |
| {"Message", |
| "The action " + arg1 + " is not supported by the resource."}, |
| {"MessageArgs", {arg1}}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", |
| "The action supplied cannot be resubmitted to the implementation. " |
| " Perhaps the action was invalid, the wrong resource was the " |
| "target or the implementation documentation may be of " |
| "assistance."}}; |
| } |
| |
| void actionNotSupported(crow::Response& res, const std::string& arg1) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, actionNotSupported(arg1)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats InvalidIndex message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json invalidIndex(int64_t arg1) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.InvalidIndex"}, |
| {"Message", "The Index " + std::to_string(arg1) + |
| " is not a valid offset into the array."}, |
| {"MessageArgs", {std::to_string(arg1)}}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", "Verify the index value provided is within the " |
| "bounds of the array."}}; |
| } |
| |
| void invalidIndex(crow::Response& res, int64_t arg1) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, invalidIndex(arg1)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats EmptyJSON message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json emptyJSON(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.EmptyJSON"}, |
| {"Message", "The request body submitted contained an empty JSON " |
| "object and the service is unable to process it."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", |
| "Add properties in the JSON object and resubmit the request."}}; |
| } |
| |
| void emptyJSON(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, emptyJSON()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats QueryNotSupportedOnResource message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json queryNotSupportedOnResource(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.QueryNotSupportedOnResource"}, |
| {"Message", "Querying is not supported on the requested resource."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", "Remove the query parameters and resubmit the " |
| "request if the operation failed."}}; |
| } |
| |
| void queryNotSupportedOnResource(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::forbidden); |
| addMessageToErrorJson(res.jsonValue, queryNotSupportedOnResource()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats QueryNotSupportedOnOperation message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json queryNotSupportedOnOperation(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.QueryNotSupportedOnOperation"}, |
| {"Message", "Querying is not supported with the requested operation."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", "Remove the query parameters and resubmit the request " |
| "if the operation failed."}}; |
| } |
| |
| void queryNotSupportedOnOperation(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::forbidden); |
| addMessageToErrorJson(res.jsonValue, queryNotSupportedOnOperation()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats QueryCombinationInvalid message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json queryCombinationInvalid(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.QueryCombinationInvalid"}, |
| {"Message", "Two or more query parameters in the request cannot be " |
| "used together."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", "Remove one or more of the query parameters and " |
| "resubmit the request if the operation failed."}}; |
| } |
| |
| void queryCombinationInvalid(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, queryCombinationInvalid()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats InsufficientPrivilege message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json insufficientPrivilege(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.InsufficientPrivilege"}, |
| {"Message", "There are insufficient privileges for the account or " |
| "credentials associated with the current session to " |
| "perform the requested operation."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", |
| "Either abandon the operation or change the associated access " |
| "rights and resubmit the request if the operation failed."}}; |
| } |
| |
| void insufficientPrivilege(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::forbidden); |
| addMessageToErrorJson(res.jsonValue, insufficientPrivilege()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats PropertyValueModified message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json propertyValueModified(const std::string& arg1, |
| const std::string& arg2) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.PropertyValueModified"}, |
| {"Message", "The property " + arg1 + " was assigned the value " + arg2 + |
| " due to modification by the service."}, |
| {"MessageArgs", {arg1, arg2}}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", "No resolution is required."}}; |
| } |
| |
| void propertyValueModified(crow::Response& res, const std::string& arg1, |
| const std::string& arg2) |
| { |
| res.result(boost::beast::http::status::ok); |
| addMessageToJson(res.jsonValue, propertyValueModified(arg1, arg2), arg1); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats AccountNotModified message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json accountNotModified(void) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.AccountNotModified"}, |
| {"Message", "The account modification request failed."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", "The modification may have failed due to permission " |
| "issues or issues with the request body."}}; |
| } |
| |
| void accountNotModified(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, accountNotModified()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats QueryParameterValueFormatError message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json queryParameterValueFormatError(const std::string& arg1, |
| const std::string& arg2) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.QueryParameterValueFormatError"}, |
| {"Message", |
| "The value " + arg1 + " for the parameter " + arg2 + |
| " is of a different format than the parameter can accept."}, |
| {"MessageArgs", {arg1, arg2}}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", |
| "Correct the value for the query parameter in the request and " |
| "resubmit the request if the operation failed."}}; |
| } |
| |
| void queryParameterValueFormatError(crow::Response& res, |
| const std::string& arg1, |
| const std::string& arg2) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, |
| queryParameterValueFormatError(arg1, arg2)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats PropertyMissing message into JSON for the specified |
| * property |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json propertyMissing(const std::string& arg1) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.PropertyMissing"}, |
| {"Message", "The property " + arg1 + |
| " is a required property and must be included in " |
| "the request."}, |
| {"MessageArgs", {arg1}}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", |
| "Ensure that the property is in the request body and has a " |
| "valid " |
| "value and resubmit the request if the operation failed."}}; |
| } |
| |
| void propertyMissing(crow::Response& res, const std::string& arg1) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToJson(res.jsonValue, propertyMissing(arg1), arg1); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats ResourceExhaustion message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json resourceExhaustion(const std::string& arg1) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.ResourceExhaustion"}, |
| {"Message", "The resource " + arg1 + |
| " was unable to satisfy the request due to " |
| "unavailability of resources."}, |
| {"MessageArgs", {arg1}}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", "Ensure that the resources are available and " |
| "resubmit the request."}}; |
| } |
| |
| void resourceExhaustion(crow::Response& res, const std::string& arg1) |
| { |
| res.result(boost::beast::http::status::service_unavailable); |
| addMessageToErrorJson(res.jsonValue, resourceExhaustion(arg1)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats AccountModified message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json accountModified(void) |
| { |
| return nlohmann::json{{"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.AccountModified"}, |
| {"Message", "The account was successfully modified."}, |
| {"MessageArgs", nlohmann::json::array()}, |
| {"MessageSeverity", "OK"}, |
| {"Resolution", "No resolution is required."}}; |
| } |
| |
| void accountModified(crow::Response& res) |
| { |
| res.result(boost::beast::http::status::ok); |
| addMessageToErrorJson(res.jsonValue, accountModified()); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats QueryParameterOutOfRange message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json queryParameterOutOfRange(const std::string& arg1, |
| const std::string& arg2, |
| const std::string& arg3) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "#Message.v1_1_1.Message"}, |
| {"MessageId", "Base.1.8.1.QueryParameterOutOfRange"}, |
| {"Message", "The value " + arg1 + " for the query parameter " + arg2 + |
| " is out of range " + arg3 + "."}, |
| {"MessageArgs", {arg1, arg2, arg3}}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", |
| "Reduce the value for the query parameter to a value that is " |
| "within range, such as a start or count value that is within " |
| "bounds of the number of resources in a collection or a page that " |
| "is within the range of valid pages."}}; |
| } |
| |
| void queryParameterOutOfRange(crow::Response& res, const std::string& arg1, |
| const std::string& arg2, const std::string& arg3) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, |
| queryParameterOutOfRange(arg1, arg2, arg3)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats PasswordChangeRequired message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| void passwordChangeRequired(crow::Response& res, const std::string& arg1) |
| { |
| messages::addMessageToJsonRoot( |
| res.jsonValue, |
| nlohmann::json{ |
| {"@odata.type", "/redfish/v1/$metadata#Message.v1_5_0.Message"}, |
| {"MessageId", "Base.1.8.1.PasswordChangeRequired"}, |
| {"Message", "The password provided for this account must be " |
| "changed before access is granted. PATCH the " |
| "'Password' property for this account located at " |
| "the target URI '" + |
| arg1 + "' to complete this process."}, |
| {"MessageArgs", {arg1}}, |
| {"MessageSeverity", "Critical"}, |
| {"Resolution", "Change the password for this account using " |
| "a PATCH to the 'Password' property at the URI " |
| "provided."}}); |
| } |
| |
| void invalidUpload(crow::Response& res, const std::string& arg1, |
| const std::string& arg2) |
| { |
| res.result(boost::beast::http::status::bad_request); |
| addMessageToErrorJson(res.jsonValue, invalidUpload(arg1, arg2)); |
| } |
| |
| /** |
| * @internal |
| * @brief Formats Invalid File message into JSON |
| * |
| * See header file for more information |
| * @endinternal |
| */ |
| nlohmann::json invalidUpload(const std::string& arg1, const std::string& arg2) |
| { |
| return nlohmann::json{ |
| {"@odata.type", "/redfish/v1/$metadata#Message.v1_1_1.Message"}, |
| {"MessageId", "OpenBMC.0.2.InvalidUpload"}, |
| {"Message", "Invalid file uploaded to " + arg1 + ": " + arg2 + "."}, |
| {"MessageArgs", {arg1, arg2}}, |
| {"MessageSeverity", "Warning"}, |
| {"Resolution", "None."}}; |
| } |
| |
| } // namespace messages |
| |
| } // namespace redfish |
