1 /* 2 // Copyright (c) 2018 Intel Corporation 3 // 4 // Licensed under the Apache License, Version 2.0 (the "License"); 5 // you may not use this file except in compliance with the License. 6 // You may obtain a copy of the License at 7 // 8 // http://www.apache.org/licenses/LICENSE-2.0 9 // 10 // Unless required by applicable law or agreed to in writing, software 11 // distributed under the License is distributed on an "AS IS" BASIS, 12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 // See the License for the specific language governing permissions and 14 // limitations under the License. 15 */ 16 #include "error_messages.hpp" 17 18 #include "http_response.hpp" 19 #include "logging.hpp" 20 #include "registries.hpp" 21 #include "registries/base_message_registry.hpp" 22 23 #include <boost/beast/http/field.hpp> 24 #include <boost/beast/http/status.hpp> 25 #include <nlohmann/json.hpp> 26 27 #include <array> 28 #include <cstddef> 29 #include <source_location> 30 #include <span> 31 #include <string> 32 #include <utility> 33 34 // IWYU pragma: no_include <stddef.h> 35 36 namespace redfish 37 { 38 39 namespace messages 40 { 41 42 static void addMessageToErrorJson(nlohmann::json& target, 43 const nlohmann::json& message) 44 { 45 auto& error = target["error"]; 46 47 // If this is the first error message, fill in the information from the 48 // first error message to the top level struct 49 if (!error.is_object()) 50 { 51 auto messageIdIterator = message.find("MessageId"); 52 if (messageIdIterator == message.end()) 53 { 54 BMCWEB_LOG_CRITICAL( 55 "Attempt to add error message without MessageId"); 56 return; 57 } 58 59 auto messageFieldIterator = message.find("Message"); 60 if (messageFieldIterator == message.end()) 61 { 62 BMCWEB_LOG_CRITICAL("Attempt to add error message without Message"); 63 return; 64 } 65 error["code"] = *messageIdIterator; 66 error["message"] = *messageFieldIterator; 67 } 68 else 69 { 70 // More than 1 error occurred, so the message has to be generic 71 error["code"] = std::string(messageVersionPrefix) + "GeneralError"; 72 error["message"] = "A general error has occurred. See Resolution for " 73 "information on how to resolve the error."; 74 } 75 76 // This check could technically be done in the default construction 77 // branch above, but because we need the pointer to the extended info field 78 // anyway, it's more efficient to do it here. 79 auto& extendedInfo = error[messages::messageAnnotation]; 80 if (!extendedInfo.is_array()) 81 { 82 extendedInfo = nlohmann::json::array(); 83 } 84 85 extendedInfo.push_back(message); 86 } 87 88 void moveErrorsToErrorJson(nlohmann::json& target, nlohmann::json& source) 89 { 90 if (!source.is_object()) 91 { 92 return; 93 } 94 auto errorIt = source.find("error"); 95 if (errorIt == source.end()) 96 { 97 // caller puts error message in root 98 messages::addMessageToErrorJson(target, source); 99 source.clear(); 100 return; 101 } 102 auto extendedInfoIt = errorIt->find(messages::messageAnnotation); 103 if (extendedInfoIt == errorIt->end()) 104 { 105 return; 106 } 107 const nlohmann::json::array_t* extendedInfo = 108 (*extendedInfoIt).get_ptr<const nlohmann::json::array_t*>(); 109 if (extendedInfo == nullptr) 110 { 111 source.erase(errorIt); 112 return; 113 } 114 for (const nlohmann::json& message : *extendedInfo) 115 { 116 addMessageToErrorJson(target, message); 117 } 118 source.erase(errorIt); 119 } 120 121 static void addMessageToJsonRoot(nlohmann::json& target, 122 const nlohmann::json& message) 123 { 124 if (!target[messages::messageAnnotation].is_array()) 125 { 126 // Force object to be an array 127 target[messages::messageAnnotation] = nlohmann::json::array(); 128 } 129 130 target[messages::messageAnnotation].push_back(message); 131 } 132 133 static void addMessageToJson(nlohmann::json& target, 134 const nlohmann::json& message, 135 std::string_view fieldPath) 136 { 137 std::string extendedInfo(fieldPath); 138 extendedInfo += messages::messageAnnotation; 139 140 nlohmann::json& field = target[extendedInfo]; 141 if (!field.is_array()) 142 { 143 // Force object to be an array 144 field = nlohmann::json::array(); 145 } 146 147 // Object exists and it is an array so we can just push in the message 148 field.push_back(message); 149 } 150 151 static nlohmann::json getLog(redfish::registries::base::Index name, 152 std::span<const std::string_view> args) 153 { 154 size_t index = static_cast<size_t>(name); 155 if (index >= redfish::registries::base::registry.size()) 156 { 157 return {}; 158 } 159 return getLogFromRegistry(redfish::registries::base::header, 160 redfish::registries::base::registry, index, args); 161 } 162 163 /** 164 * @internal 165 * @brief Formats ResourceInUse message into JSON 166 * 167 * See header file for more information 168 * @endinternal 169 */ 170 nlohmann::json resourceInUse() 171 { 172 return getLog(redfish::registries::base::Index::resourceInUse, {}); 173 } 174 175 void resourceInUse(crow::Response& res) 176 { 177 res.result(boost::beast::http::status::service_unavailable); 178 addMessageToErrorJson(res.jsonValue, resourceInUse()); 179 } 180 181 /** 182 * @internal 183 * @brief Formats MalformedJSON message into JSON 184 * 185 * See header file for more information 186 * @endinternal 187 */ 188 nlohmann::json malformedJSON() 189 { 190 return getLog(redfish::registries::base::Index::malformedJSON, {}); 191 } 192 193 void malformedJSON(crow::Response& res) 194 { 195 res.result(boost::beast::http::status::bad_request); 196 addMessageToErrorJson(res.jsonValue, malformedJSON()); 197 } 198 199 /** 200 * @internal 201 * @brief Formats ResourceMissingAtURI message into JSON 202 * 203 * See header file for more information 204 * @endinternal 205 */ 206 nlohmann::json resourceMissingAtURI(boost::urls::url_view arg1) 207 { 208 std::array<std::string_view, 1> args{arg1.buffer()}; 209 return getLog(redfish::registries::base::Index::resourceMissingAtURI, args); 210 } 211 212 void resourceMissingAtURI(crow::Response& res, boost::urls::url_view arg1) 213 { 214 res.result(boost::beast::http::status::bad_request); 215 addMessageToErrorJson(res.jsonValue, resourceMissingAtURI(arg1)); 216 } 217 218 /** 219 * @internal 220 * @brief Formats ActionParameterValueFormatError message into JSON 221 * 222 * See header file for more information 223 * @endinternal 224 */ 225 nlohmann::json actionParameterValueFormatError(const nlohmann::json& arg1, 226 std::string_view arg2, 227 std::string_view arg3) 228 { 229 std::string arg1Str = arg1.dump(2, ' ', true, 230 nlohmann::json::error_handler_t::replace); 231 return getLog( 232 redfish::registries::base::Index::actionParameterValueFormatError, 233 std::to_array<std::string_view>({arg1Str, arg2, arg3})); 234 } 235 236 void actionParameterValueFormatError(crow::Response& res, 237 const nlohmann::json& arg1, 238 std::string_view arg2, 239 std::string_view arg3) 240 { 241 res.result(boost::beast::http::status::bad_request); 242 addMessageToErrorJson(res.jsonValue, 243 actionParameterValueFormatError(arg1, arg2, arg3)); 244 } 245 246 /** 247 * @internal 248 * @brief Formats ActionParameterValueNotInList message into JSON 249 * 250 * See header file for more information 251 * @endinternal 252 */ 253 nlohmann::json actionParameterValueNotInList(std::string_view arg1, 254 std::string_view arg2, 255 std::string_view arg3) 256 { 257 return getLog( 258 redfish::registries::base::Index::actionParameterValueNotInList, 259 std::to_array({arg1, arg2, arg3})); 260 } 261 262 void actionParameterValueNotInList(crow::Response& res, std::string_view arg1, 263 std::string_view arg2, std::string_view arg3) 264 { 265 res.result(boost::beast::http::status::bad_request); 266 addMessageToErrorJson(res.jsonValue, 267 actionParameterValueNotInList(arg1, arg2, arg3)); 268 } 269 270 /** 271 * @internal 272 * @brief Formats InternalError message into JSON 273 * 274 * See header file for more information 275 * @endinternal 276 */ 277 nlohmann::json internalError() 278 { 279 return getLog(redfish::registries::base::Index::internalError, {}); 280 } 281 282 void internalError(crow::Response& res, const std::source_location location) 283 { 284 BMCWEB_LOG_CRITICAL("Internal Error {}({}:{}) `{}`: ", location.file_name(), 285 location.line(), location.column(), 286 location.function_name()); 287 res.result(boost::beast::http::status::internal_server_error); 288 addMessageToErrorJson(res.jsonValue, internalError()); 289 } 290 291 /** 292 * @internal 293 * @brief Formats UnrecognizedRequestBody message into JSON 294 * 295 * See header file for more information 296 * @endinternal 297 */ 298 nlohmann::json unrecognizedRequestBody() 299 { 300 return getLog(redfish::registries::base::Index::unrecognizedRequestBody, 301 {}); 302 } 303 304 void unrecognizedRequestBody(crow::Response& res) 305 { 306 res.result(boost::beast::http::status::bad_request); 307 addMessageToErrorJson(res.jsonValue, unrecognizedRequestBody()); 308 } 309 310 /** 311 * @internal 312 * @brief Formats ResourceAtUriUnauthorized message into JSON 313 * 314 * See header file for more information 315 * @endinternal 316 */ 317 nlohmann::json resourceAtUriUnauthorized(boost::urls::url_view arg1, 318 std::string_view arg2) 319 { 320 return getLog(redfish::registries::base::Index::resourceAtUriUnauthorized, 321 std::to_array<std::string_view>({arg1.buffer(), arg2})); 322 } 323 324 void resourceAtUriUnauthorized(crow::Response& res, boost::urls::url_view arg1, 325 std::string_view arg2) 326 { 327 res.result(boost::beast::http::status::unauthorized); 328 addMessageToErrorJson(res.jsonValue, resourceAtUriUnauthorized(arg1, arg2)); 329 } 330 331 /** 332 * @internal 333 * @brief Formats ActionParameterUnknown message into JSON 334 * 335 * See header file for more information 336 * @endinternal 337 */ 338 nlohmann::json actionParameterUnknown(std::string_view arg1, 339 std::string_view arg2) 340 { 341 return getLog(redfish::registries::base::Index::actionParameterUnknown, 342 std::to_array({arg1, arg2})); 343 } 344 345 void actionParameterUnknown(crow::Response& res, std::string_view arg1, 346 std::string_view arg2) 347 { 348 res.result(boost::beast::http::status::bad_request); 349 addMessageToErrorJson(res.jsonValue, actionParameterUnknown(arg1, arg2)); 350 } 351 352 /** 353 * @internal 354 * @brief Formats ResourceCannotBeDeleted message into JSON 355 * 356 * See header file for more information 357 * @endinternal 358 */ 359 nlohmann::json resourceCannotBeDeleted() 360 { 361 return getLog(redfish::registries::base::Index::resourceCannotBeDeleted, 362 {}); 363 } 364 365 void resourceCannotBeDeleted(crow::Response& res) 366 { 367 res.result(boost::beast::http::status::method_not_allowed); 368 addMessageToErrorJson(res.jsonValue, resourceCannotBeDeleted()); 369 } 370 371 /** 372 * @internal 373 * @brief Formats PropertyDuplicate message into JSON 374 * 375 * See header file for more information 376 * @endinternal 377 */ 378 nlohmann::json propertyDuplicate(std::string_view arg1) 379 { 380 return getLog(redfish::registries::base::Index::propertyDuplicate, 381 std::to_array({arg1})); 382 } 383 384 void propertyDuplicate(crow::Response& res, std::string_view arg1) 385 { 386 res.result(boost::beast::http::status::bad_request); 387 addMessageToJson(res.jsonValue, propertyDuplicate(arg1), arg1); 388 } 389 390 /** 391 * @internal 392 * @brief Formats ServiceTemporarilyUnavailable message into JSON 393 * 394 * See header file for more information 395 * @endinternal 396 */ 397 nlohmann::json serviceTemporarilyUnavailable(std::string_view arg1) 398 { 399 return getLog( 400 redfish::registries::base::Index::serviceTemporarilyUnavailable, 401 std::to_array({arg1})); 402 } 403 404 void serviceTemporarilyUnavailable(crow::Response& res, std::string_view arg1) 405 { 406 res.addHeader(boost::beast::http::field::retry_after, arg1); 407 res.result(boost::beast::http::status::service_unavailable); 408 addMessageToErrorJson(res.jsonValue, serviceTemporarilyUnavailable(arg1)); 409 } 410 411 /** 412 * @internal 413 * @brief Formats ResourceAlreadyExists message into JSON 414 * 415 * See header file for more information 416 * @endinternal 417 */ 418 nlohmann::json resourceAlreadyExists(std::string_view arg1, 419 std::string_view arg2, 420 std::string_view arg3) 421 { 422 return getLog(redfish::registries::base::Index::resourceAlreadyExists, 423 std::to_array({arg1, arg2, arg3})); 424 } 425 426 void resourceAlreadyExists(crow::Response& res, std::string_view arg1, 427 std::string_view arg2, std::string_view arg3) 428 { 429 res.result(boost::beast::http::status::bad_request); 430 addMessageToJson(res.jsonValue, resourceAlreadyExists(arg1, arg2, arg3), 431 arg2); 432 } 433 434 /** 435 * @internal 436 * @brief Formats AccountForSessionNoLongerExists message into JSON 437 * 438 * See header file for more information 439 * @endinternal 440 */ 441 nlohmann::json accountForSessionNoLongerExists() 442 { 443 return getLog( 444 redfish::registries::base::Index::accountForSessionNoLongerExists, {}); 445 } 446 447 void accountForSessionNoLongerExists(crow::Response& res) 448 { 449 res.result(boost::beast::http::status::forbidden); 450 addMessageToErrorJson(res.jsonValue, accountForSessionNoLongerExists()); 451 } 452 453 /** 454 * @internal 455 * @brief Formats CreateFailedMissingReqProperties message into JSON 456 * 457 * See header file for more information 458 * @endinternal 459 */ 460 nlohmann::json createFailedMissingReqProperties(std::string_view arg1) 461 { 462 return getLog( 463 redfish::registries::base::Index::createFailedMissingReqProperties, 464 std::to_array({arg1})); 465 } 466 467 void createFailedMissingReqProperties(crow::Response& res, 468 std::string_view arg1) 469 { 470 res.result(boost::beast::http::status::bad_request); 471 addMessageToJson(res.jsonValue, createFailedMissingReqProperties(arg1), 472 arg1); 473 } 474 475 /** 476 * @internal 477 * @brief Formats PropertyValueFormatError message into JSON for the specified 478 * property 479 * 480 * See header file for more information 481 * @endinternal 482 */ 483 nlohmann::json propertyValueFormatError(const nlohmann::json& arg1, 484 std::string_view arg2) 485 { 486 std::string arg1Str = arg1.dump(2, ' ', true, 487 nlohmann::json::error_handler_t::replace); 488 return getLog(redfish::registries::base::Index::propertyValueFormatError, 489 std::to_array<std::string_view>({arg1Str, arg2})); 490 } 491 492 void propertyValueFormatError(crow::Response& res, const nlohmann::json& arg1, 493 std::string_view arg2) 494 { 495 res.result(boost::beast::http::status::bad_request); 496 addMessageToJson(res.jsonValue, propertyValueFormatError(arg1, arg2), arg2); 497 } 498 499 /** 500 * @internal 501 * @brief Formats PropertyValueNotInList message into JSON for the specified 502 * property 503 * 504 * See header file for more information 505 * @endinternal 506 */ 507 508 nlohmann::json propertyValueNotInList(const nlohmann::json& arg1, 509 std::string_view arg2) 510 { 511 std::string arg1Str = arg1.dump(-1, ' ', true, 512 nlohmann::json::error_handler_t::replace); 513 return getLog(redfish::registries::base::Index::propertyValueNotInList, 514 std::to_array<std::string_view>({arg1Str, arg2})); 515 } 516 517 void propertyValueNotInList(crow::Response& res, const nlohmann::json& arg1, 518 std::string_view arg2) 519 { 520 res.result(boost::beast::http::status::bad_request); 521 addMessageToJson(res.jsonValue, propertyValueNotInList(arg1, arg2), arg2); 522 } 523 524 /** 525 * @internal 526 * @brief Formats PropertyValueOutOfRange message into JSON 527 * 528 * See header file for more information 529 * @endinternal 530 */ 531 nlohmann::json propertyValueOutOfRange(const nlohmann::json& arg1, 532 std::string_view arg2) 533 { 534 std::string arg1Str = arg1.dump(2, ' ', true, 535 nlohmann::json::error_handler_t::replace); 536 return getLog(redfish::registries::base::Index::propertyValueOutOfRange, 537 std::to_array<std::string_view>({arg1Str, arg2})); 538 } 539 540 void propertyValueOutOfRange(crow::Response& res, const nlohmann::json& arg1, 541 std::string_view arg2) 542 { 543 res.result(boost::beast::http::status::bad_request); 544 addMessageToErrorJson(res.jsonValue, propertyValueOutOfRange(arg1, arg2)); 545 } 546 547 /** 548 * @internal 549 * @brief Formats ResourceAtUriInUnknownFormat message into JSON 550 * 551 * See header file for more information 552 * @endinternal 553 */ 554 nlohmann::json resourceAtUriInUnknownFormat(boost::urls::url_view arg1) 555 { 556 return getLog( 557 redfish::registries::base::Index::resourceAtUriInUnknownFormat, 558 std::to_array<std::string_view>({arg1.buffer()})); 559 } 560 561 void resourceAtUriInUnknownFormat(crow::Response& res, 562 boost::urls::url_view arg1) 563 { 564 res.result(boost::beast::http::status::bad_request); 565 addMessageToErrorJson(res.jsonValue, resourceAtUriInUnknownFormat(arg1)); 566 } 567 568 /** 569 * @internal 570 * @brief Formats ServiceDisabled message into JSON 571 * 572 * See header file for more information 573 * @endinternal 574 */ 575 nlohmann::json serviceDisabled(std::string_view arg1) 576 { 577 return getLog(redfish::registries::base::Index::serviceDisabled, 578 std::to_array({arg1})); 579 } 580 581 void serviceDisabled(crow::Response& res, std::string_view arg1) 582 { 583 res.result(boost::beast::http::status::service_unavailable); 584 addMessageToErrorJson(res.jsonValue, serviceDisabled(arg1)); 585 } 586 587 /** 588 * @internal 589 * @brief Formats ServiceInUnknownState message into JSON 590 * 591 * See header file for more information 592 * @endinternal 593 */ 594 nlohmann::json serviceInUnknownState() 595 { 596 return getLog(redfish::registries::base::Index::serviceInUnknownState, {}); 597 } 598 599 void serviceInUnknownState(crow::Response& res) 600 { 601 res.result(boost::beast::http::status::service_unavailable); 602 addMessageToErrorJson(res.jsonValue, serviceInUnknownState()); 603 } 604 605 /** 606 * @internal 607 * @brief Formats EventSubscriptionLimitExceeded message into JSON 608 * 609 * See header file for more information 610 * @endinternal 611 */ 612 nlohmann::json eventSubscriptionLimitExceeded() 613 { 614 return getLog( 615 redfish::registries::base::Index::eventSubscriptionLimitExceeded, {}); 616 } 617 618 void eventSubscriptionLimitExceeded(crow::Response& res) 619 { 620 res.result(boost::beast::http::status::service_unavailable); 621 addMessageToErrorJson(res.jsonValue, eventSubscriptionLimitExceeded()); 622 } 623 624 /** 625 * @internal 626 * @brief Formats ActionParameterMissing message into JSON 627 * 628 * See header file for more information 629 * @endinternal 630 */ 631 nlohmann::json actionParameterMissing(std::string_view arg1, 632 std::string_view arg2) 633 { 634 return getLog(redfish::registries::base::Index::actionParameterMissing, 635 std::to_array({arg1, arg2})); 636 } 637 638 void actionParameterMissing(crow::Response& res, std::string_view arg1, 639 std::string_view arg2) 640 { 641 res.result(boost::beast::http::status::bad_request); 642 addMessageToErrorJson(res.jsonValue, actionParameterMissing(arg1, arg2)); 643 } 644 645 /** 646 * @internal 647 * @brief Formats StringValueTooLong message into JSON 648 * 649 * See header file for more information 650 * @endinternal 651 */ 652 nlohmann::json stringValueTooLong(std::string_view arg1, int arg2) 653 { 654 std::string arg2String = std::to_string(arg2); 655 return getLog(redfish::registries::base::Index::stringValueTooLong, 656 std::to_array({arg1, std::string_view(arg2String)})); 657 } 658 659 void stringValueTooLong(crow::Response& res, std::string_view arg1, int arg2) 660 { 661 res.result(boost::beast::http::status::bad_request); 662 addMessageToErrorJson(res.jsonValue, stringValueTooLong(arg1, arg2)); 663 } 664 665 /** 666 * @internal 667 * @brief Formats SessionTerminated message into JSON 668 * 669 * See header file for more information 670 * @endinternal 671 */ 672 nlohmann::json sessionTerminated() 673 { 674 return getLog(redfish::registries::base::Index::sessionTerminated, {}); 675 } 676 677 void sessionTerminated(crow::Response& res) 678 { 679 res.result(boost::beast::http::status::ok); 680 addMessageToJsonRoot(res.jsonValue, sessionTerminated()); 681 } 682 683 /** 684 * @internal 685 * @brief Formats SubscriptionTerminated message into JSON 686 * 687 * See header file for more information 688 * @endinternal 689 */ 690 nlohmann::json subscriptionTerminated() 691 { 692 return getLog(redfish::registries::base::Index::subscriptionTerminated, {}); 693 } 694 695 void subscriptionTerminated(crow::Response& res) 696 { 697 res.result(boost::beast::http::status::ok); 698 addMessageToJsonRoot(res.jsonValue, subscriptionTerminated()); 699 } 700 701 /** 702 * @internal 703 * @brief Formats ResourceTypeIncompatible message into JSON 704 * 705 * See header file for more information 706 * @endinternal 707 */ 708 nlohmann::json resourceTypeIncompatible(std::string_view arg1, 709 std::string_view arg2) 710 { 711 return getLog(redfish::registries::base::Index::resourceTypeIncompatible, 712 std::to_array({arg1, arg2})); 713 } 714 715 void resourceTypeIncompatible(crow::Response& res, std::string_view arg1, 716 std::string_view arg2) 717 { 718 res.result(boost::beast::http::status::bad_request); 719 addMessageToErrorJson(res.jsonValue, resourceTypeIncompatible(arg1, arg2)); 720 } 721 722 /** 723 * @internal 724 * @brief Formats ResetRequired message into JSON 725 * 726 * See header file for more information 727 * @endinternal 728 */ 729 nlohmann::json resetRequired(boost::urls::url_view arg1, std::string_view arg2) 730 { 731 return getLog(redfish::registries::base::Index::resetRequired, 732 std::to_array<std::string_view>({arg1.buffer(), arg2})); 733 } 734 735 void resetRequired(crow::Response& res, boost::urls::url_view arg1, 736 std::string_view arg2) 737 { 738 res.result(boost::beast::http::status::bad_request); 739 addMessageToErrorJson(res.jsonValue, resetRequired(arg1, arg2)); 740 } 741 742 /** 743 * @internal 744 * @brief Formats ChassisPowerStateOnRequired message into JSON 745 * 746 * See header file for more information 747 * @endinternal 748 */ 749 nlohmann::json chassisPowerStateOnRequired(std::string_view arg1) 750 { 751 return getLog(redfish::registries::base::Index::resetRequired, 752 std::to_array({arg1})); 753 } 754 755 void chassisPowerStateOnRequired(crow::Response& res, std::string_view arg1) 756 { 757 res.result(boost::beast::http::status::bad_request); 758 addMessageToErrorJson(res.jsonValue, chassisPowerStateOnRequired(arg1)); 759 } 760 761 /** 762 * @internal 763 * @brief Formats ChassisPowerStateOffRequired message into JSON 764 * 765 * See header file for more information 766 * @endinternal 767 */ 768 nlohmann::json chassisPowerStateOffRequired(std::string_view arg1) 769 { 770 return getLog( 771 redfish::registries::base::Index::chassisPowerStateOffRequired, 772 std::to_array({arg1})); 773 } 774 775 void chassisPowerStateOffRequired(crow::Response& res, std::string_view arg1) 776 { 777 res.result(boost::beast::http::status::bad_request); 778 addMessageToErrorJson(res.jsonValue, chassisPowerStateOffRequired(arg1)); 779 } 780 781 /** 782 * @internal 783 * @brief Formats PropertyValueConflict message into JSON 784 * 785 * See header file for more information 786 * @endinternal 787 */ 788 nlohmann::json propertyValueConflict(std::string_view arg1, 789 std::string_view arg2) 790 { 791 return getLog(redfish::registries::base::Index::propertyValueConflict, 792 std::to_array({arg1, arg2})); 793 } 794 795 void propertyValueConflict(crow::Response& res, std::string_view arg1, 796 std::string_view arg2) 797 { 798 res.result(boost::beast::http::status::bad_request); 799 addMessageToErrorJson(res.jsonValue, propertyValueConflict(arg1, arg2)); 800 } 801 802 /** 803 * @internal 804 * @brief Formats PropertyValueResourceConflict message into JSON 805 * 806 * See header file for more information 807 * @endinternal 808 */ 809 nlohmann::json propertyValueResourceConflict(std::string_view arg1, 810 const nlohmann::json& arg2, 811 boost::urls::url_view arg3) 812 { 813 std::string arg2Str = arg2.dump(2, ' ', true, 814 nlohmann::json::error_handler_t::replace); 815 816 return getLog( 817 redfish::registries::base::Index::propertyValueResourceConflict, 818 std::to_array<std::string_view>({arg1, arg2Str, arg3.buffer()})); 819 } 820 821 void propertyValueResourceConflict(crow::Response& res, std::string_view arg1, 822 const nlohmann::json& arg2, 823 boost::urls::url_view arg3) 824 { 825 res.result(boost::beast::http::status::conflict); 826 addMessageToErrorJson(res.jsonValue, 827 propertyValueResourceConflict(arg1, arg2, arg3)); 828 } 829 830 /** 831 * @internal 832 * @brief Formats PropertyValueExternalConflict message into JSON 833 * 834 * See header file for more information 835 * @endinternal 836 */ 837 nlohmann::json propertyValueExternalConflict(std::string_view arg1, 838 const nlohmann::json& arg2) 839 { 840 std::string arg2Str = arg2.dump(2, ' ', true, 841 nlohmann::json::error_handler_t::replace); 842 843 return getLog( 844 redfish::registries::base::Index::propertyValueExternalConflict, 845 std::to_array<std::string_view>({arg1, arg2Str})); 846 } 847 848 void propertyValueExternalConflict(crow::Response& res, std::string_view arg1, 849 const nlohmann::json& arg2) 850 { 851 res.result(boost::beast::http::status::conflict); 852 addMessageToErrorJson(res.jsonValue, 853 propertyValueExternalConflict(arg1, arg2)); 854 } 855 856 /** 857 * @internal 858 * @brief Formats PropertyValueIncorrect message into JSON 859 * 860 * See header file for more information 861 * @endinternal 862 */ 863 nlohmann::json propertyValueIncorrect(const nlohmann::json& arg1, 864 std::string_view arg2) 865 { 866 std::string arg1Str = arg1.dump(2, ' ', true, 867 nlohmann::json::error_handler_t::replace); 868 return getLog(redfish::registries::base::Index::propertyValueIncorrect, 869 std::to_array<std::string_view>({arg1Str, arg2})); 870 } 871 872 void propertyValueIncorrect(crow::Response& res, const nlohmann::json& arg1, 873 std::string_view arg2) 874 { 875 res.result(boost::beast::http::status::bad_request); 876 addMessageToErrorJson(res.jsonValue, propertyValueIncorrect(arg1, arg2)); 877 } 878 879 /** 880 * @internal 881 * @brief Formats ResourceCreationConflict message into JSON 882 * 883 * See header file for more information 884 * @endinternal 885 */ 886 nlohmann::json resourceCreationConflict(boost::urls::url_view arg1) 887 { 888 return getLog(redfish::registries::base::Index::resourceCreationConflict, 889 std::to_array<std::string_view>({arg1.buffer()})); 890 } 891 892 void resourceCreationConflict(crow::Response& res, boost::urls::url_view arg1) 893 { 894 res.result(boost::beast::http::status::bad_request); 895 addMessageToErrorJson(res.jsonValue, resourceCreationConflict(arg1)); 896 } 897 898 /** 899 * @internal 900 * @brief Formats MaximumErrorsExceeded message into JSON 901 * 902 * See header file for more information 903 * @endinternal 904 */ 905 nlohmann::json maximumErrorsExceeded() 906 { 907 return getLog(redfish::registries::base::Index::maximumErrorsExceeded, {}); 908 } 909 910 void maximumErrorsExceeded(crow::Response& res) 911 { 912 res.result(boost::beast::http::status::internal_server_error); 913 addMessageToErrorJson(res.jsonValue, maximumErrorsExceeded()); 914 } 915 916 /** 917 * @internal 918 * @brief Formats PreconditionFailed message into JSON 919 * 920 * See header file for more information 921 * @endinternal 922 */ 923 nlohmann::json preconditionFailed() 924 { 925 return getLog(redfish::registries::base::Index::preconditionFailed, {}); 926 } 927 928 void preconditionFailed(crow::Response& res) 929 { 930 res.result(boost::beast::http::status::precondition_failed); 931 addMessageToErrorJson(res.jsonValue, preconditionFailed()); 932 } 933 934 /** 935 * @internal 936 * @brief Formats PreconditionRequired message into JSON 937 * 938 * See header file for more information 939 * @endinternal 940 */ 941 nlohmann::json preconditionRequired() 942 { 943 return getLog(redfish::registries::base::Index::preconditionRequired, {}); 944 } 945 946 void preconditionRequired(crow::Response& res) 947 { 948 res.result(boost::beast::http::status::bad_request); 949 addMessageToErrorJson(res.jsonValue, preconditionRequired()); 950 } 951 952 /** 953 * @internal 954 * @brief Formats OperationFailed message into JSON 955 * 956 * See header file for more information 957 * @endinternal 958 */ 959 nlohmann::json operationFailed() 960 { 961 return getLog(redfish::registries::base::Index::operationFailed, {}); 962 } 963 964 void operationFailed(crow::Response& res) 965 { 966 res.result(boost::beast::http::status::bad_gateway); 967 addMessageToErrorJson(res.jsonValue, operationFailed()); 968 } 969 970 /** 971 * @internal 972 * @brief Formats OperationTimeout message into JSON 973 * 974 * See header file for more information 975 * @endinternal 976 */ 977 nlohmann::json operationTimeout() 978 { 979 return getLog(redfish::registries::base::Index::operationTimeout, {}); 980 } 981 982 void operationTimeout(crow::Response& res) 983 { 984 res.result(boost::beast::http::status::internal_server_error); 985 addMessageToErrorJson(res.jsonValue, operationTimeout()); 986 } 987 988 /** 989 * @internal 990 * @brief Formats PropertyValueTypeError message into JSON for the specified 991 * property 992 * 993 * See header file for more information 994 * @endinternal 995 */ 996 nlohmann::json propertyValueTypeError(const nlohmann::json& arg1, 997 std::string_view arg2) 998 { 999 std::string arg1Str = arg1.dump(2, ' ', true, 1000 nlohmann::json::error_handler_t::replace); 1001 return getLog(redfish::registries::base::Index::propertyValueTypeError, 1002 std::to_array<std::string_view>({arg1Str, arg2})); 1003 } 1004 1005 void propertyValueTypeError(crow::Response& res, const nlohmann::json& arg1, 1006 std::string_view arg2) 1007 { 1008 res.result(boost::beast::http::status::bad_request); 1009 addMessageToJson(res.jsonValue, propertyValueTypeError(arg1, arg2), arg2); 1010 } 1011 1012 /** 1013 * @internal 1014 * @brief Formats ResourceNotFound message into JSONd 1015 * 1016 * See header file for more information 1017 * @endinternal 1018 */ 1019 nlohmann::json resourceNotFound(std::string_view arg1, std::string_view arg2) 1020 { 1021 return getLog(redfish::registries::base::Index::resourceNotFound, 1022 std::to_array({arg1, arg2})); 1023 } 1024 1025 void resourceNotFound(crow::Response& res, std::string_view arg1, 1026 std::string_view arg2) 1027 { 1028 res.result(boost::beast::http::status::not_found); 1029 addMessageToErrorJson(res.jsonValue, resourceNotFound(arg1, arg2)); 1030 } 1031 1032 /** 1033 * @internal 1034 * @brief Formats CouldNotEstablishConnection message into JSON 1035 * 1036 * See header file for more information 1037 * @endinternal 1038 */ 1039 nlohmann::json couldNotEstablishConnection(boost::urls::url_view arg1) 1040 { 1041 return getLog(redfish::registries::base::Index::couldNotEstablishConnection, 1042 std::to_array<std::string_view>({arg1.buffer()})); 1043 } 1044 1045 void couldNotEstablishConnection(crow::Response& res, 1046 boost::urls::url_view arg1) 1047 { 1048 res.result(boost::beast::http::status::not_found); 1049 addMessageToErrorJson(res.jsonValue, couldNotEstablishConnection(arg1)); 1050 } 1051 1052 /** 1053 * @internal 1054 * @brief Formats PropertyNotWritable message into JSON for the specified 1055 * property 1056 * 1057 * See header file for more information 1058 * @endinternal 1059 */ 1060 nlohmann::json propertyNotWritable(std::string_view arg1) 1061 { 1062 return getLog(redfish::registries::base::Index::propertyNotWritable, 1063 std::to_array({arg1})); 1064 } 1065 1066 void propertyNotWritable(crow::Response& res, std::string_view arg1) 1067 { 1068 res.result(boost::beast::http::status::forbidden); 1069 addMessageToJson(res.jsonValue, propertyNotWritable(arg1), arg1); 1070 } 1071 1072 /** 1073 * @internal 1074 * @brief Formats QueryParameterValueTypeError message into JSON 1075 * 1076 * See header file for more information 1077 * @endinternal 1078 */ 1079 nlohmann::json queryParameterValueTypeError(const nlohmann::json& arg1, 1080 std::string_view arg2) 1081 { 1082 std::string arg1Str = arg1.dump(2, ' ', true, 1083 nlohmann::json::error_handler_t::replace); 1084 return getLog( 1085 redfish::registries::base::Index::queryParameterValueTypeError, 1086 std::to_array<std::string_view>({arg1Str, arg2})); 1087 } 1088 1089 void queryParameterValueTypeError(crow::Response& res, 1090 const nlohmann::json& arg1, 1091 std::string_view arg2) 1092 { 1093 res.result(boost::beast::http::status::bad_request); 1094 addMessageToErrorJson(res.jsonValue, 1095 queryParameterValueTypeError(arg1, arg2)); 1096 } 1097 1098 /** 1099 * @internal 1100 * @brief Formats ServiceShuttingDown message into JSON 1101 * 1102 * See header file for more information 1103 * @endinternal 1104 */ 1105 nlohmann::json serviceShuttingDown() 1106 { 1107 return getLog(redfish::registries::base::Index::serviceShuttingDown, {}); 1108 } 1109 1110 void serviceShuttingDown(crow::Response& res) 1111 { 1112 res.result(boost::beast::http::status::service_unavailable); 1113 addMessageToErrorJson(res.jsonValue, serviceShuttingDown()); 1114 } 1115 1116 /** 1117 * @internal 1118 * @brief Formats ActionParameterDuplicate message into JSON 1119 * 1120 * See header file for more information 1121 * @endinternal 1122 */ 1123 nlohmann::json actionParameterDuplicate(std::string_view arg1, 1124 std::string_view arg2) 1125 { 1126 return getLog(redfish::registries::base::Index::actionParameterDuplicate, 1127 std::to_array({arg1, arg2})); 1128 } 1129 1130 void actionParameterDuplicate(crow::Response& res, std::string_view arg1, 1131 std::string_view arg2) 1132 { 1133 res.result(boost::beast::http::status::bad_request); 1134 addMessageToErrorJson(res.jsonValue, actionParameterDuplicate(arg1, arg2)); 1135 } 1136 1137 /** 1138 * @internal 1139 * @brief Formats ActionParameterNotSupported message into JSON 1140 * 1141 * See header file for more information 1142 * @endinternal 1143 */ 1144 nlohmann::json actionParameterNotSupported(std::string_view arg1, 1145 std::string_view arg2) 1146 { 1147 return getLog(redfish::registries::base::Index::actionParameterNotSupported, 1148 std::to_array({arg1, arg2})); 1149 } 1150 1151 void actionParameterNotSupported(crow::Response& res, std::string_view arg1, 1152 std::string_view arg2) 1153 { 1154 res.result(boost::beast::http::status::bad_request); 1155 addMessageToErrorJson(res.jsonValue, 1156 actionParameterNotSupported(arg1, arg2)); 1157 } 1158 1159 /** 1160 * @internal 1161 * @brief Formats SourceDoesNotSupportProtocol message into JSON 1162 * 1163 * See header file for more information 1164 * @endinternal 1165 */ 1166 nlohmann::json sourceDoesNotSupportProtocol(boost::urls::url_view arg1, 1167 std::string_view arg2) 1168 { 1169 return getLog( 1170 redfish::registries::base::Index::sourceDoesNotSupportProtocol, 1171 std::to_array<std::string_view>({arg1.buffer(), arg2})); 1172 } 1173 1174 void sourceDoesNotSupportProtocol(crow::Response& res, 1175 boost::urls::url_view arg1, 1176 std::string_view arg2) 1177 { 1178 res.result(boost::beast::http::status::bad_request); 1179 addMessageToErrorJson(res.jsonValue, 1180 sourceDoesNotSupportProtocol(arg1, arg2)); 1181 } 1182 1183 /** 1184 * @internal 1185 * @brief Formats StrictAccountTypes message into JSON 1186 * 1187 * See header file for more information 1188 * @endinternal 1189 */ 1190 nlohmann::json strictAccountTypes(std::string_view arg1) 1191 { 1192 return getLog(redfish::registries::base::Index::strictAccountTypes, 1193 std::to_array({arg1})); 1194 } 1195 1196 void strictAccountTypes(crow::Response& res, std::string_view arg1) 1197 { 1198 res.result(boost::beast::http::status::bad_request); 1199 addMessageToErrorJson(res.jsonValue, strictAccountTypes(arg1)); 1200 } 1201 1202 /** 1203 * @internal 1204 * @brief Formats AccountRemoved message into JSON 1205 * 1206 * See header file for more information 1207 * @endinternal 1208 */ 1209 nlohmann::json accountRemoved() 1210 { 1211 return getLog(redfish::registries::base::Index::accountRemoved, {}); 1212 } 1213 1214 void accountRemoved(crow::Response& res) 1215 { 1216 res.result(boost::beast::http::status::ok); 1217 addMessageToJsonRoot(res.jsonValue, accountRemoved()); 1218 } 1219 1220 /** 1221 * @internal 1222 * @brief Formats AccessDenied message into JSON 1223 * 1224 * See header file for more information 1225 * @endinternal 1226 */ 1227 nlohmann::json accessDenied(boost::urls::url_view arg1) 1228 { 1229 return getLog(redfish::registries::base::Index::accessDenied, 1230 std::to_array<std::string_view>({arg1.buffer()})); 1231 } 1232 1233 void accessDenied(crow::Response& res, boost::urls::url_view arg1) 1234 { 1235 res.result(boost::beast::http::status::forbidden); 1236 addMessageToErrorJson(res.jsonValue, accessDenied(arg1)); 1237 } 1238 1239 /** 1240 * @internal 1241 * @brief Formats QueryNotSupported message into JSON 1242 * 1243 * See header file for more information 1244 * @endinternal 1245 */ 1246 nlohmann::json queryNotSupported() 1247 { 1248 return getLog(redfish::registries::base::Index::queryNotSupported, {}); 1249 } 1250 1251 void queryNotSupported(crow::Response& res) 1252 { 1253 res.result(boost::beast::http::status::bad_request); 1254 addMessageToErrorJson(res.jsonValue, queryNotSupported()); 1255 } 1256 1257 /** 1258 * @internal 1259 * @brief Formats CreateLimitReachedForResource message into JSON 1260 * 1261 * See header file for more information 1262 * @endinternal 1263 */ 1264 nlohmann::json createLimitReachedForResource() 1265 { 1266 return getLog( 1267 redfish::registries::base::Index::createLimitReachedForResource, {}); 1268 } 1269 1270 void createLimitReachedForResource(crow::Response& res) 1271 { 1272 res.result(boost::beast::http::status::bad_request); 1273 addMessageToErrorJson(res.jsonValue, createLimitReachedForResource()); 1274 } 1275 1276 /** 1277 * @internal 1278 * @brief Formats GeneralError message into JSON 1279 * 1280 * See header file for more information 1281 * @endinternal 1282 */ 1283 nlohmann::json generalError() 1284 { 1285 return getLog(redfish::registries::base::Index::generalError, {}); 1286 } 1287 1288 void generalError(crow::Response& res) 1289 { 1290 res.result(boost::beast::http::status::internal_server_error); 1291 addMessageToErrorJson(res.jsonValue, generalError()); 1292 } 1293 1294 /** 1295 * @internal 1296 * @brief Formats Success message into JSON 1297 * 1298 * See header file for more information 1299 * @endinternal 1300 */ 1301 nlohmann::json success() 1302 { 1303 return getLog(redfish::registries::base::Index::success, {}); 1304 } 1305 1306 void success(crow::Response& res) 1307 { 1308 // don't set res.result here because success is the default and any 1309 // error should overwrite the default 1310 addMessageToJsonRoot(res.jsonValue, success()); 1311 } 1312 1313 /** 1314 * @internal 1315 * @brief Formats Created message into JSON 1316 * 1317 * See header file for more information 1318 * @endinternal 1319 */ 1320 nlohmann::json created() 1321 { 1322 return getLog(redfish::registries::base::Index::created, {}); 1323 } 1324 1325 void created(crow::Response& res) 1326 { 1327 res.result(boost::beast::http::status::created); 1328 addMessageToJsonRoot(res.jsonValue, created()); 1329 } 1330 1331 /** 1332 * @internal 1333 * @brief Formats NoOperation message into JSON 1334 * 1335 * See header file for more information 1336 * @endinternal 1337 */ 1338 nlohmann::json noOperation() 1339 { 1340 return getLog(redfish::registries::base::Index::noOperation, {}); 1341 } 1342 1343 void noOperation(crow::Response& res) 1344 { 1345 res.result(boost::beast::http::status::bad_request); 1346 addMessageToErrorJson(res.jsonValue, noOperation()); 1347 } 1348 1349 /** 1350 * @internal 1351 * @brief Formats PropertyUnknown message into JSON for the specified 1352 * property 1353 * 1354 * See header file for more information 1355 * @endinternal 1356 */ 1357 nlohmann::json propertyUnknown(std::string_view arg1) 1358 { 1359 return getLog(redfish::registries::base::Index::propertyUnknown, 1360 std::to_array({arg1})); 1361 } 1362 1363 void propertyUnknown(crow::Response& res, std::string_view arg1) 1364 { 1365 res.result(boost::beast::http::status::bad_request); 1366 addMessageToErrorJson(res.jsonValue, propertyUnknown(arg1)); 1367 } 1368 1369 /** 1370 * @internal 1371 * @brief Formats NoValidSession message into JSON 1372 * 1373 * See header file for more information 1374 * @endinternal 1375 */ 1376 nlohmann::json noValidSession() 1377 { 1378 return getLog(redfish::registries::base::Index::noValidSession, {}); 1379 } 1380 1381 void noValidSession(crow::Response& res) 1382 { 1383 res.result(boost::beast::http::status::forbidden); 1384 addMessageToErrorJson(res.jsonValue, noValidSession()); 1385 } 1386 1387 /** 1388 * @internal 1389 * @brief Formats InvalidObject message into JSON 1390 * 1391 * See header file for more information 1392 * @endinternal 1393 */ 1394 nlohmann::json invalidObject(boost::urls::url_view arg1) 1395 { 1396 return getLog(redfish::registries::base::Index::invalidObject, 1397 std::to_array<std::string_view>({arg1.buffer()})); 1398 } 1399 1400 void invalidObject(crow::Response& res, boost::urls::url_view arg1) 1401 { 1402 res.result(boost::beast::http::status::bad_request); 1403 addMessageToErrorJson(res.jsonValue, invalidObject(arg1)); 1404 } 1405 1406 /** 1407 * @internal 1408 * @brief Formats ResourceInStandby message into JSON 1409 * 1410 * See header file for more information 1411 * @endinternal 1412 */ 1413 nlohmann::json resourceInStandby() 1414 { 1415 return getLog(redfish::registries::base::Index::resourceInStandby, {}); 1416 } 1417 1418 void resourceInStandby(crow::Response& res) 1419 { 1420 res.result(boost::beast::http::status::service_unavailable); 1421 addMessageToErrorJson(res.jsonValue, resourceInStandby()); 1422 } 1423 1424 /** 1425 * @internal 1426 * @brief Formats ActionParameterValueTypeError message into JSON 1427 * 1428 * See header file for more information 1429 * @endinternal 1430 */ 1431 nlohmann::json actionParameterValueTypeError(const nlohmann::json& arg1, 1432 std::string_view arg2, 1433 std::string_view arg3) 1434 { 1435 std::string arg1Str = arg1.dump(2, ' ', true, 1436 nlohmann::json::error_handler_t::replace); 1437 return getLog( 1438 redfish::registries::base::Index::actionParameterValueTypeError, 1439 std::to_array<std::string_view>({arg1Str, arg2, arg3})); 1440 } 1441 1442 void actionParameterValueTypeError(crow::Response& res, 1443 const nlohmann::json& arg1, 1444 std::string_view arg2, std::string_view arg3) 1445 { 1446 res.result(boost::beast::http::status::bad_request); 1447 addMessageToErrorJson(res.jsonValue, 1448 actionParameterValueTypeError(arg1, arg2, arg3)); 1449 } 1450 1451 /** 1452 * @internal 1453 * @brief Formats SessionLimitExceeded message into JSON 1454 * 1455 * See header file for more information 1456 * @endinternal 1457 */ 1458 nlohmann::json sessionLimitExceeded() 1459 { 1460 return getLog(redfish::registries::base::Index::sessionLimitExceeded, {}); 1461 } 1462 1463 void sessionLimitExceeded(crow::Response& res) 1464 { 1465 res.result(boost::beast::http::status::service_unavailable); 1466 addMessageToErrorJson(res.jsonValue, sessionLimitExceeded()); 1467 } 1468 1469 /** 1470 * @internal 1471 * @brief Formats ActionNotSupported message into JSON 1472 * 1473 * See header file for more information 1474 * @endinternal 1475 */ 1476 nlohmann::json actionNotSupported(std::string_view arg1) 1477 { 1478 return getLog(redfish::registries::base::Index::actionNotSupported, 1479 std::to_array({arg1})); 1480 } 1481 1482 void actionNotSupported(crow::Response& res, std::string_view arg1) 1483 { 1484 res.result(boost::beast::http::status::bad_request); 1485 addMessageToErrorJson(res.jsonValue, actionNotSupported(arg1)); 1486 } 1487 1488 /** 1489 * @internal 1490 * @brief Formats InvalidIndex message into JSON 1491 * 1492 * See header file for more information 1493 * @endinternal 1494 */ 1495 nlohmann::json invalidIndex(int64_t arg1) 1496 { 1497 std::string arg1Str = std::to_string(arg1); 1498 return getLog(redfish::registries::base::Index::invalidIndex, 1499 std::to_array<std::string_view>({arg1Str})); 1500 } 1501 1502 void invalidIndex(crow::Response& res, int64_t arg1) 1503 { 1504 res.result(boost::beast::http::status::bad_request); 1505 addMessageToErrorJson(res.jsonValue, invalidIndex(arg1)); 1506 } 1507 1508 /** 1509 * @internal 1510 * @brief Formats EmptyJSON message into JSON 1511 * 1512 * See header file for more information 1513 * @endinternal 1514 */ 1515 nlohmann::json emptyJSON() 1516 { 1517 return getLog(redfish::registries::base::Index::emptyJSON, {}); 1518 } 1519 1520 void emptyJSON(crow::Response& res) 1521 { 1522 res.result(boost::beast::http::status::bad_request); 1523 addMessageToErrorJson(res.jsonValue, emptyJSON()); 1524 } 1525 1526 /** 1527 * @internal 1528 * @brief Formats QueryNotSupportedOnResource message into JSON 1529 * 1530 * See header file for more information 1531 * @endinternal 1532 */ 1533 nlohmann::json queryNotSupportedOnResource() 1534 { 1535 return getLog(redfish::registries::base::Index::queryNotSupportedOnResource, 1536 {}); 1537 } 1538 1539 void queryNotSupportedOnResource(crow::Response& res) 1540 { 1541 res.result(boost::beast::http::status::bad_request); 1542 addMessageToErrorJson(res.jsonValue, queryNotSupportedOnResource()); 1543 } 1544 1545 /** 1546 * @internal 1547 * @brief Formats QueryNotSupportedOnOperation message into JSON 1548 * 1549 * See header file for more information 1550 * @endinternal 1551 */ 1552 nlohmann::json queryNotSupportedOnOperation() 1553 { 1554 return getLog( 1555 redfish::registries::base::Index::queryNotSupportedOnOperation, {}); 1556 } 1557 1558 void queryNotSupportedOnOperation(crow::Response& res) 1559 { 1560 res.result(boost::beast::http::status::bad_request); 1561 addMessageToErrorJson(res.jsonValue, queryNotSupportedOnOperation()); 1562 } 1563 1564 /** 1565 * @internal 1566 * @brief Formats QueryCombinationInvalid message into JSON 1567 * 1568 * See header file for more information 1569 * @endinternal 1570 */ 1571 nlohmann::json queryCombinationInvalid() 1572 { 1573 return getLog(redfish::registries::base::Index::queryCombinationInvalid, 1574 {}); 1575 } 1576 1577 void queryCombinationInvalid(crow::Response& res) 1578 { 1579 res.result(boost::beast::http::status::bad_request); 1580 addMessageToErrorJson(res.jsonValue, queryCombinationInvalid()); 1581 } 1582 1583 /** 1584 * @internal 1585 * @brief Formats InsufficientPrivilege message into JSON 1586 * 1587 * See header file for more information 1588 * @endinternal 1589 */ 1590 nlohmann::json insufficientPrivilege() 1591 { 1592 return getLog(redfish::registries::base::Index::insufficientPrivilege, {}); 1593 } 1594 1595 void insufficientPrivilege(crow::Response& res) 1596 { 1597 res.result(boost::beast::http::status::forbidden); 1598 addMessageToErrorJson(res.jsonValue, insufficientPrivilege()); 1599 } 1600 1601 /** 1602 * @internal 1603 * @brief Formats PropertyValueModified message into JSON 1604 * 1605 * See header file for more information 1606 * @endinternal 1607 */ 1608 nlohmann::json propertyValueModified(std::string_view arg1, 1609 const nlohmann::json& arg2) 1610 { 1611 std::string arg2Str = arg2.dump(2, ' ', true, 1612 nlohmann::json::error_handler_t::replace); 1613 return getLog(redfish::registries::base::Index::propertyValueModified, 1614 std::to_array<std::string_view>({arg1, arg2Str})); 1615 } 1616 1617 void propertyValueModified(crow::Response& res, std::string_view arg1, 1618 const nlohmann::json& arg2) 1619 { 1620 res.result(boost::beast::http::status::ok); 1621 addMessageToJson(res.jsonValue, propertyValueModified(arg1, arg2), arg1); 1622 } 1623 1624 /** 1625 * @internal 1626 * @brief Formats AccountNotModified message into JSON 1627 * 1628 * See header file for more information 1629 * @endinternal 1630 */ 1631 nlohmann::json accountNotModified() 1632 { 1633 return getLog(redfish::registries::base::Index::accountNotModified, {}); 1634 } 1635 1636 void accountNotModified(crow::Response& res) 1637 { 1638 res.result(boost::beast::http::status::bad_request); 1639 addMessageToErrorJson(res.jsonValue, accountNotModified()); 1640 } 1641 1642 /** 1643 * @internal 1644 * @brief Formats QueryParameterValueFormatError message into JSON 1645 * 1646 * See header file for more information 1647 * @endinternal 1648 */ 1649 nlohmann::json queryParameterValueFormatError(const nlohmann::json& arg1, 1650 std::string_view arg2) 1651 { 1652 std::string arg1Str = arg1.dump(2, ' ', true, 1653 nlohmann::json::error_handler_t::replace); 1654 return getLog( 1655 redfish::registries::base::Index::queryParameterValueFormatError, 1656 std::to_array<std::string_view>({arg1Str, arg2})); 1657 } 1658 1659 void queryParameterValueFormatError(crow::Response& res, 1660 const nlohmann::json& arg1, 1661 std::string_view arg2) 1662 { 1663 res.result(boost::beast::http::status::bad_request); 1664 addMessageToErrorJson(res.jsonValue, 1665 queryParameterValueFormatError(arg1, arg2)); 1666 } 1667 1668 /** 1669 * @internal 1670 * @brief Formats PropertyMissing message into JSON for the specified 1671 * property 1672 * 1673 * See header file for more information 1674 * @endinternal 1675 */ 1676 nlohmann::json propertyMissing(std::string_view arg1) 1677 { 1678 return getLog(redfish::registries::base::Index::propertyMissing, 1679 std::to_array({arg1})); 1680 } 1681 1682 void propertyMissing(crow::Response& res, std::string_view arg1) 1683 { 1684 res.result(boost::beast::http::status::bad_request); 1685 addMessageToJson(res.jsonValue, propertyMissing(arg1), arg1); 1686 } 1687 1688 /** 1689 * @internal 1690 * @brief Formats ResourceExhaustion message into JSON 1691 * 1692 * See header file for more information 1693 * @endinternal 1694 */ 1695 nlohmann::json resourceExhaustion(std::string_view arg1) 1696 { 1697 return getLog(redfish::registries::base::Index::resourceExhaustion, 1698 std::to_array({arg1})); 1699 } 1700 1701 void resourceExhaustion(crow::Response& res, std::string_view arg1) 1702 { 1703 res.result(boost::beast::http::status::service_unavailable); 1704 addMessageToErrorJson(res.jsonValue, resourceExhaustion(arg1)); 1705 } 1706 1707 /** 1708 * @internal 1709 * @brief Formats AccountModified message into JSON 1710 * 1711 * See header file for more information 1712 * @endinternal 1713 */ 1714 nlohmann::json accountModified() 1715 { 1716 return getLog(redfish::registries::base::Index::accountModified, {}); 1717 } 1718 1719 void accountModified(crow::Response& res) 1720 { 1721 res.result(boost::beast::http::status::ok); 1722 addMessageToErrorJson(res.jsonValue, accountModified()); 1723 } 1724 1725 /** 1726 * @internal 1727 * @brief Formats QueryParameterOutOfRange message into JSON 1728 * 1729 * See header file for more information 1730 * @endinternal 1731 */ 1732 nlohmann::json queryParameterOutOfRange(std::string_view arg1, 1733 std::string_view arg2, 1734 std::string_view arg3) 1735 { 1736 return getLog(redfish::registries::base::Index::queryParameterOutOfRange, 1737 std::to_array({arg1, arg2, arg3})); 1738 } 1739 1740 void queryParameterOutOfRange(crow::Response& res, std::string_view arg1, 1741 std::string_view arg2, std::string_view arg3) 1742 { 1743 res.result(boost::beast::http::status::bad_request); 1744 addMessageToErrorJson(res.jsonValue, 1745 queryParameterOutOfRange(arg1, arg2, arg3)); 1746 } 1747 1748 nlohmann::json passwordChangeRequired(boost::urls::url_view arg1) 1749 { 1750 return getLog(redfish::registries::base::Index::passwordChangeRequired, 1751 std::to_array<std::string_view>({arg1.buffer()})); 1752 } 1753 1754 /** 1755 * @internal 1756 * @brief Formats PasswordChangeRequired message into JSON 1757 * 1758 * See header file for more information 1759 * @endinternal 1760 */ 1761 void passwordChangeRequired(crow::Response& res, boost::urls::url_view arg1) 1762 { 1763 messages::addMessageToJsonRoot(res.jsonValue, passwordChangeRequired(arg1)); 1764 } 1765 1766 /** 1767 * @internal 1768 * @brief Formats InsufficientStorage message into JSON 1769 * 1770 * See header file for more information 1771 * @endinternal 1772 */ 1773 nlohmann::json insufficientStorage() 1774 { 1775 return getLog(redfish::registries::base::Index::insufficientStorage, {}); 1776 } 1777 1778 void insufficientStorage(crow::Response& res) 1779 { 1780 res.result(boost::beast::http::status::insufficient_storage); 1781 addMessageToErrorJson(res.jsonValue, insufficientStorage()); 1782 } 1783 1784 /** 1785 * @internal 1786 * @brief Formats OperationNotAllowed message into JSON 1787 * 1788 * See header file for more information 1789 * @endinternal 1790 */ 1791 nlohmann::json operationNotAllowed() 1792 { 1793 return getLog(redfish::registries::base::Index::operationNotAllowed, {}); 1794 } 1795 1796 void operationNotAllowed(crow::Response& res) 1797 { 1798 res.result(boost::beast::http::status::method_not_allowed); 1799 addMessageToErrorJson(res.jsonValue, operationNotAllowed()); 1800 } 1801 1802 /** 1803 * @internal 1804 * @brief Formats ArraySizeTooLong message into JSON 1805 * 1806 * See header file for more information 1807 * @endinternal 1808 */ 1809 nlohmann::json arraySizeTooLong(std::string_view property, uint64_t length) 1810 { 1811 std::string valStr = std::to_string(length); 1812 return getLog(redfish::registries::base::Index::arraySizeTooLong, 1813 std::to_array<std::string_view>({property, valStr})); 1814 } 1815 1816 void arraySizeTooLong(crow::Response& res, std::string_view property, 1817 uint64_t length) 1818 { 1819 res.result(boost::beast::http::status::bad_request); 1820 addMessageToErrorJson(res.jsonValue, arraySizeTooLong(property, length)); 1821 } 1822 1823 void invalidUpload(crow::Response& res, std::string_view arg1, 1824 std::string_view arg2) 1825 { 1826 res.result(boost::beast::http::status::bad_request); 1827 addMessageToErrorJson(res.jsonValue, invalidUpload(arg1, arg2)); 1828 } 1829 1830 /** 1831 * @internal 1832 * @brief Formats Invalid File message into JSON 1833 * 1834 * See header file for more information 1835 * @endinternal 1836 */ 1837 nlohmann::json invalidUpload(std::string_view arg1, std::string_view arg2) 1838 { 1839 std::string msg = "Invalid file uploaded to "; 1840 msg += arg1; 1841 msg += ": "; 1842 msg += arg2; 1843 msg += "."; 1844 1845 nlohmann::json::object_t ret; 1846 ret["@odata.type"] = "/redfish/v1/$metadata#Message.v1_1_1.Message"; 1847 ret["MessageId"] = "OpenBMC.0.2.InvalidUpload"; 1848 ret["Message"] = std::move(msg); 1849 nlohmann::json::array_t args; 1850 args.emplace_back(arg1); 1851 args.emplace_back(arg2); 1852 ret["MessageArgs"] = std::move(args); 1853 ret["MessageSeverity"] = "Warning"; 1854 ret["Resolution"] = "None."; 1855 return ret; 1856 } 1857 1858 } // namespace messages 1859 1860 } // namespace redfish 1861