#ifndef THIRD_PARTY_GBMCWEB_REDFISH_CORE_LIB_TRUSTED_COMPONENT_H_
#define THIRD_PARTY_GBMCWEB_REDFISH_CORE_LIB_TRUSTED_COMPONENT_H_

/*
// Copyright (c) 2023 Google
/
// 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 <algorithm>
#include <array>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <tuple>
#include <utility>
#include <vector>

#include "boost/container/flat_map.hpp"  // NOLINT
#include "boost/system/error_code.hpp"  // NOLINT
#include "boost/url/format.hpp"  // NOLINT
#include "app.hpp"
#include "http_request.hpp"
#include "logging.hpp"
#include "utility.hpp"
#include "async_resp.hpp"
#include "dbus_utility.hpp"
#include "error_messages.hpp"
#include "query.hpp"
#include "registries/privilege_registry.hpp"
#include "chassis_utils.hpp"
#include "collection.hpp"
#include "dbus_utils.hpp"
#include "system_utils.hpp"
#include "component_integrity.hpp"
#include <nlohmann/json.hpp>
#include "managed_store.hpp"
#include "managed_store_types.hpp"
#include "sdbusplus/message/native_types.hpp"
#include "sdbusplus/unpack_properties.hpp"

#ifdef UNIT_TEST_BUILD
#include "test/g3/mock_managed_store.hpp"  // NOLINT
#endif

namespace redfish {
// Interfaces which imply a D-Bus object represents a TrustedComponent
constexpr std::array<std::string_view, 1> trustedComponentInterfaces = {
    "xyz.openbmc_project.Inventory.Item.TrustedComponent"};
constexpr char const* discreteAttachType =
    "xyz.openbmc_project.Inventory.Item.TrustedComponent.ComponentAttachType."
    "Discrete";
constexpr char const* integratedAttachType =
    "xyz.openbmc_project.Inventory.Item.TrustedComponent.ComponentAttachType."
    "Integrated";
constexpr char const* decoratorAssetIntf =
    "xyz.openbmc_project.Inventory.Decorator.Asset";
constexpr char const* uuidIntf = "xyz.openbmc_project.Common.UUID";
constexpr char const* trustedComponentIntf =
    "xyz.openbmc_project.Inventory.Item.TrustedComponent";

/**
 * Map a given vector of D-Bus object path to an array of Redfish
 * URI.
 *
 * @param[in]       property1       Redfish property name.
 * @param[in]       property2       Optional second Redfish property name.
 * @param[in]       nodeList        vector of path string.
 *
 * @return          entities        Array of Redfish URI in json.
 */
inline std::optional<nlohmann::json> mapObjectPathVector(
    const std::string& property1, const std::string& property2,
    const std::vector<std::string>& pathList) {
  nlohmann::json entities = nlohmann::json::array();

  for (const std::string& node : pathList) {
    sdbusplus::message::object_path path(node);
    std::string entityId = path.filename();
    if (entityId.empty()) {
      BMCWEB_LOG_ERROR << "Invalid object path:" << property1 << " "
                       << property2 << ":" << path.str;
      return std::nullopt;
    }

    nlohmann::json::object_t entity;
    if (property2.empty()) {
      entity["@odata.id"] =
          crow::utility::urlFromPieces("redfish", "v1", property1, entityId);
    } else {
      entity["@odata.id"] = crow::utility::urlFromPieces(
          "redfish", "v1", property1, property2, entityId);
    }
    entities.push_back(std::move(entity));
  }

  return {std::move(entities)};
}

/**
 * Find the D-Bus object representing the requested TrustedComponent, and call
 * the handler with the results. If matching object is not found, add 404 error
 * to response and don't call the handler.
 *
 * @param[in,out]   resp            Async HTTP response.
 * @param[in]       chassisId       Redfish Chassis Id.
 * @param[in]       componentId     Redfish TrustedComponent Id.
 * @param[in]       handler         Callback to continue processing request upon
 *                                  successfully finding object.
 */
template <typename Handler>
inline void getTrustedComponentObject(
    const std::shared_ptr<bmcweb::AsyncResp>& resp,
    const std::string& chassisId, const std::string& componentId,
    Handler&& handler) {
  BMCWEB_LOG_DEBUG << "Get available chassis trusted_component resources.";

  // GetSubTree on all interfaces which provide info about TrustedComponent
  constexpr std::array<std::string_view, 1> interfaces = {trustedComponentIntf};
  std::string trustedComponentsPath =
      sdbusplus::message::object_path("/xyz/openbmc_project/Chassis") /
      chassisId / "TrustedComponents";
  managedStore::ManagedObjectStoreContext context(resp);
  managedStore::GetManagedObjectStore()->getSubTree(
      trustedComponentsPath, 0, interfaces, context,
      [resp, chassisId, componentId, handler](
          const boost::system::error_code& ec,
          const dbus::utility::MapperGetSubTreeResponse& subtree) {
        if (ec) {
          BMCWEB_LOG_ERROR << "DBUS response error: " << ec;
          messages::internalError(resp->res);
          return;
        }

        for (const auto& [objectPath, serviceMap] : subtree) {
          // Ignore any objects which don't end with our desired component
          // name
          if (!objectPath.ends_with(componentId)) {
            continue;
          }

          bool found = false;
          for (const auto& [serviceName, interfaceList] : serviceMap) {
            if (std::find_first_of(interfaceList.begin(), interfaceList.end(),
                                   trustedComponentInterfaces.begin(),
                                   trustedComponentInterfaces.end()) !=
                interfaceList.end()) {
              found = true;
              break;
            }
          }

          if (!found) {
            continue;
          }

          // Found something, populate Name and Id before get Interface info
          resp->res.jsonValue["@odata.id"] = crow::utility::urlFromPieces(
              "redfish", "v1", "Chassis", chassisId, "TrustedComponents",
              componentId);
          resp->res.jsonValue["Name"] = componentId;
          resp->res.jsonValue["Id"] = componentId;

          handler(objectPath, serviceMap);
          return;
        }
        messages::resourceNotFound(resp->res, "TrustedComponent", componentId);
      });
}

inline void getTrustedComponentIntegratedIntoInfo(
    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
    const std::string& trustedComponentObjPath,
    const boost::system::error_code& ec,
    const dbus::utility::MapperEndPoints& integratedIntoObjPaths) {
  if (ec) {
    if (ec.value() != EBADR) {
      BMCWEB_LOG_ERROR << "DBUS response error " << ec;
      messages::internalError(asyncResp->res);
    }
    return;
  }

  if (integratedIntoObjPaths.empty()) {
    return;
  }

  managedStore::ManagedObjectStoreContext requestContext(asyncResp);
  for (const auto& objpath : integratedIntoObjPaths) {
    sdbusplus::message::object_path integratedIntoObjPath(objpath);
    const std::string objName = integratedIntoObjPath.filename();
    if (objName.empty()) {
      BMCWEB_LOG_WARNING << "Malformed integratedInto object path "
                         << integratedIntoObjPath.str << " for "
                         << trustedComponentObjPath;
      continue;
    }
    managedStore::GetManagedObjectStore()->getDbusObject(
        objpath, {}, requestContext,
        [asyncResp, integratedIntoObjPath, trustedComponentObjPath,
         requestContext,
         objName](const boost::system::error_code& ec2,
                  const dbus::utility::MapperGetObject& object) {
          if (ec2) {
            BMCWEB_LOG_ERROR << "DBUS response error";
            messages::internalError(asyncResp->res);
            return;
          }

          nlohmann::json::object_t integratedPath;

          // Link can be Chassis or Board, Processor, and NetworkAdapters
          // handle Chassis or Board case
          if (redfish::dbus_utils::findInterfacesInServiceMap(
                  object, redfish::chassis_utils::chassisInterfaces)) {
            integratedPath["@odata.id"] = crow::utility::urlFromPieces(
                "redfish", "v1", "Chassis", objName);
            asyncResp->res.jsonValue["Links"]["IntegratedInto"] =
                std::move(integratedPath);
            return;
          }

          // handle NetworkAdaptors: parent resource can only be Chassis.
          if (redfish::dbus_utils::findInterfacesInServiceMap(
                  object, networkAdapterInterfaces)) {
            const std::string parentObj =
                integratedIntoObjPath.parent_path().filename();
            if (parentObj.empty()) {
              BMCWEB_LOG_WARNING << "Malformed integratedInto object path "
                                 << integratedIntoObjPath.str << " for "
                                 << trustedComponentObjPath;
              return;
            }

            integratedPath["@odata.id"] = crow::utility::urlFromPieces(
                "redfish", "v1", "Chassis", parentObj, "NetworkAdapters",
                objName);
            asyncResp->res.jsonValue["Links"]["IntegratedInto"] =
                std::move(integratedPath);
            return;
          }

          if (redfish::dbus_utils::findInterfacesInServiceMap(
                  object, processorsInterfaces)) {
            std::string parentPath = integratedIntoObjPath.parent_path().str;
            std::string parentObj =
                integratedIntoObjPath.parent_path().filename();
            // e.g.,
            // /xyz/openbmc_project/inventory/system/board/BoardName/system1/chassis/motherboard/cpu0
            // filter out chassis|motherboard in object path.
            while (parentObj == "motherboard" || parentObj == "chassis") {
              sdbusplus::message::object_path tempObjPath(parentPath);
              parentPath = tempObjPath.parent_path().str;
              parentObj = tempObjPath.parent_path().filename();
            }
            if (parentObj.empty()) {
              BMCWEB_LOG_WARNING << "Malformed integratedInto object path "
                                 << integratedIntoObjPath.str << " for "
                                 << trustedComponentObjPath;
              return;
            }
            managedStore::GetManagedObjectStore()->getDbusObject(
                parentPath, {}, requestContext,
                [asyncResp, objName, parentObj](
                    const boost::system::error_code& ec2,
                    const dbus::utility::MapperGetObject& object) {
                  if (ec2) {
                    BMCWEB_LOG_ERROR << "DBUS response error";
                    messages::internalError(asyncResp->res);
                    return;
                  }

                  // handle Processor: parent resource has to be Systems as
                  // OpenBMC only search for Processor under Systems though
                  // Redfish SPEC allows Processors to be modeled under Chassis
                  // starting from DSP2046_2022.3.pdf.
                  nlohmann::json::object_t integratedProcessorPath;
                  std::string parentResourceType;
                  std::string parentResourceName;
                  if (redfish::dbus_utils::findInterfacesInServiceMap(
                          object, redfish::chassis_utils::chassisInterfaces)) {
                    parentResourceType = "Systems";
                    parentResourceName = "system";
                  } else if (redfish::dbus_utils::findInterfacesInServiceMap(
                                 object,
                                 redfish::system_utils::systemInterfaces)) {
                    parentResourceType = "Systems";
                    parentResourceName = parentObj;
                  } else {
                    BMCWEB_LOG_ERROR << "Parent resource type not "
                                        "supported for Processor resource";
                    messages::internalError(asyncResp->res);
                    return;
                  }

                  integratedProcessorPath["@odata.id"] =
                      crow::utility::urlFromPieces(
                          "redfish", "v1", parentResourceType,
                          parentResourceName, "Processors", objName);
                  asyncResp->res.jsonValue["Links"]["IntegratedInto"] =
                      std::move(integratedProcessorPath);
                  return;
                });

            return;
          }  // end of Processor interfaces handling

          // Unsupported resource type
          BMCWEB_LOG_ERROR << "Unsupported IntegratedInto resource for "
                           << integratedIntoObjPath.str;
          messages::internalError(asyncResp->res);
          return;
        });
  }
}

/**
 * @brief Fill out TrustedComponent interface related info by
 * requesting data from the given D-Bus object.
 *
 * @param[in,out]   aResp       Async HTTP response.
 * @param[in]       service     D-Bus service to query.
 * @param[in]       objPath     D-Bus object to query.
 */
inline void getTrustedComponentInterfaceData(
    const std::shared_ptr<bmcweb::AsyncResp>& aResp, const std::string& service,
    const std::string& objPath) {
  BMCWEB_LOG_DEBUG << "Get TrustedComponent Interface Data";
  managedStore::ManagedObjectStoreContext context(aResp);
  managedStore::GetManagedObjectStore()->getAllProperties(
      service, objPath, trustedComponentIntf, context,
      [objPath, aResp{aResp}, context](
          const boost::system::error_code& ec,
          const std::vector<std::pair<
              std::string, dbus::utility::DbusVariantType>>& properties) {
        if (ec) {
          BMCWEB_LOG_ERROR << "DBUS response error";
          messages::internalError(aResp->res);
          return;
        }

        const std::string* type = nullptr;
        const std::string* firmwareVersion = nullptr;

        const bool success = sdbusplus::unpackPropertiesNoThrow(
            dbus_utils::UnpackErrorPrinter(), properties, "FirmwareVersion",
            firmwareVersion, "TrustedComponentType", type);

        if (!success) {
          messages::internalError(aResp->res);
          return;
        }

        if ((firmwareVersion != nullptr) && !firmwareVersion->empty()) {
          aResp->res.jsonValue["FirmwareVersion"] = *firmwareVersion;
        }

        // For Root-of-Trust, it is safe to hardcode it as Embedded.
        aResp->res.jsonValue["Location"]["PartLocation"]["LocationType"] =
            "Embedded";

        // Get active software image info from associations.
        std::string activeSoftwarePath = objPath + "/actively_running";
        dbus_utils::getAssociationEndPoints(
            activeSoftwarePath, context,
            [aResp](
                const boost::system::error_code& e,
                const dbus::utility::MapperEndPoints& nodeActiveSoftwareList) {
              if (e) {
                if (e.value() != EBADR) {
                  messages::internalError(aResp->res);
                  return;
                }
                // No resource found.
                return;
              }

              // One TrustedComponent object should be associated with one
              // activeSoftwareImage object
              if (nodeActiveSoftwareList.size() != 1) {
                BMCWEB_LOG_ERROR
                    << "Unexpected ActiveSoftwareImage #objs (expecting 1): "
                    << nodeActiveSoftwareList.size();
                messages::internalError(aResp->res);
                return;
              }

              const std::string& softwareImageURI =
                  nodeActiveSoftwareList.at(0);
              sdbusplus::message::object_path activeSoftwareImage(
                  softwareImageURI);
              std::string softwareId = activeSoftwareImage.filename();

              nlohmann::json::object_t imagePath;

              if (softwareId.empty()) {
                BMCWEB_LOG_ERROR
                    << "TrustedComponent contains invalid activeSoftwareImage:"
                    << activeSoftwareImage.str;
                messages::internalError(aResp->res);
                return;
              }

              imagePath["@odata.id"] =
                  crow::utility::urlFromPieces("redfish", "v1", "UpdateService",
                                               "FirmwareInventory", softwareId);
              aResp->res.jsonValue["Links"]["ActiveSoftwareImage"] =
                  std::move(imagePath);
            });

        // Get ComponentIntegrity info from associations.
        std::string componentIntegrityPath = objPath + "/reported_by";
        dbus_utils::getAssociationEndPoints(
            componentIntegrityPath, context,
            [aResp](const boost::system::error_code& e,
                    const dbus::utility::MapperEndPoints&
                        nodeComponentIntegrityList) {
              if (e) {
                if (e.value() != EBADR) {
                  messages::internalError(aResp->res);
                  return;
                }
                // No resource found.
                return;
              }

              if (nodeComponentIntegrityList.empty()) {
                BMCWEB_LOG_DEBUG << "No ComponentIntegrity objects found!";
                return;
              }

              std::optional<nlohmann::json> components = mapObjectPathVector(
                  "ComponentIntegrity", "", nodeComponentIntegrityList);
              if (!components) {
                BMCWEB_LOG_ERROR << "ComponentIntegrity is invalid.";
                messages::internalError(aResp->res);
                return;
              }

              aResp->res.jsonValue["Links"]["ComponentIntegrity"] = *components;
            });

        // Get protected components info from associations.
        std::string protectedComponentPath = objPath + "/protecting";
        dbus_utils::getAssociationEndPoints(
            protectedComponentPath, context,
            std::bind_front(getProtectedComponentsInfo, aResp, objPath));

        // Get integratedInto info from associations.
        std::string integratedInto = objPath + "/integrated_into";
        dbus_utils::getAssociationEndPoints(
            integratedInto, context,
            std::bind_front(getTrustedComponentIntegratedIntoInfo, aResp,
                            objPath));

        // Get software images info from associations.
        std::string softwareImagesPath = objPath + "/runs";
        dbus_utils::getAssociationEndPoints(
            softwareImagesPath, context,
            [aResp](
                const boost::system::error_code& e,
                const dbus::utility::MapperEndPoints& nodeSoftwareImagesList) {
              if (e) {
                if (e.value() != EBADR) {
                  messages::internalError(aResp->res);
                  return;
                }
                // No resource found.
                return;
              }

              // One TrustedComponent object may be associated with one
              // or more SoftwareImage objects
              if (nodeSoftwareImagesList.empty()) {
                BMCWEB_LOG_DEBUG << "No software image objects found!";
                return;
              }

              std::optional<nlohmann::json> images = mapObjectPathVector(
                  "UpdateService", "FirmwareInventory", nodeSoftwareImagesList);
              if (!images) {
                BMCWEB_LOG_ERROR << "SoftwareImages is invalid.";
                messages::internalError(aResp->res);
                return;
              }
              aResp->res.jsonValue["Links"]["SoftwareImages"] = *images;
            });

        if ((type != nullptr) && !type->empty()) {
          if (*type == discreteAttachType) {
            aResp->res.jsonValue["TrustedComponentType"] = "Discrete";
          } else if (*type == integratedAttachType) {
            aResp->res.jsonValue["TrustedComponentType"] = "Integrated";
          } else {
            BMCWEB_LOG_ERROR << "Unrecognized ComponentAttachType!";
            messages::internalError(aResp->res);
            return;
          }
        } else {
          BMCWEB_LOG_ERROR << "No ComponentAttachType found!";
          messages::internalError(aResp->res);
          return;
        }
      });
}

/**
 * @brief Fill out Inventory.Decorator.Asset interface related info by
 * requesting data from the given D-Bus object.
 *
 * @param[in,out]   aResp       Async HTTP response.
 * @param[in]       service     D-Bus service to query.
 * @param[in]       objPath     D-Bus object to query.
 */
inline void getDecoratorAssetInterfaceData(
    const std::shared_ptr<bmcweb::AsyncResp>& aResp, const std::string& service,
    const std::string& objPath) {
  BMCWEB_LOG_DEBUG << "Get Decorator.Asset Interface Data";
  managedStore::ManagedObjectStoreContext context(aResp);
  managedStore::GetManagedObjectStore()->getAllProperties(
      service, objPath, decoratorAssetIntf, context,
      [objPath, aResp{aResp}, context](
          const boost::system::error_code& ec,
          const std::vector<std::pair<
              std::string, dbus::utility::DbusVariantType>>& properties) {
        if (ec) {
          BMCWEB_LOG_ERROR << "DBUS response error for DecoratorAssetIntf!";
          messages::internalError(aResp->res);
          return;
        }

        const std::string* manufacturer = nullptr;
        const std::string* serialNumber = nullptr;
        const std::string* sku = nullptr;
        const std::string* partNumber = nullptr;

        const bool success = sdbusplus::unpackPropertiesNoThrow(
            dbus_utils::UnpackErrorPrinter(), properties, "Manufacturer",
            manufacturer, "SerialNumber", serialNumber, "PartNumber",
            partNumber, "SKU", sku);

        if (!success) {
          BMCWEB_LOG_ERROR << "Unpacking Inventory.Decorator.Asset failed!";
          messages::internalError(aResp->res);
          return;
        }

        if ((manufacturer != nullptr) && !manufacturer->empty()) {
          aResp->res.jsonValue["Manufacturer"] = *manufacturer;
        }

        if ((serialNumber != nullptr) && !serialNumber->empty()) {
          aResp->res.jsonValue["SerialNumber"] = *serialNumber;
        }

        if ((sku != nullptr) && !sku->empty()) {
          aResp->res.jsonValue["SKU"] = *sku;
        }

        if ((partNumber != nullptr) && !partNumber->empty()) {
          aResp->res.jsonValue["PartNumber"] = *partNumber;
        }
      });
}

/**
 * @brief Fill out Common.UUID interface related info by
 * requesting data from the given D-Bus object.
 *
 * @param[in,out]   aResp       Async HTTP response.
 * @param[in]       service     D-Bus service to query.
 * @param[in]       objPath     D-Bus object to query.
 */
inline void getCommonUUIDInterfaceData(
    const std::shared_ptr<bmcweb::AsyncResp>& aResp, const std::string& service,
    const std::string& objPath) {
  BMCWEB_LOG_DEBUG << "Get Common.UUID Interface Data";
  managedStore::ManagedObjectStoreContext context(aResp);
  managedStore::GetManagedObjectStore()->getAllProperties(
      service, objPath, uuidIntf, context,
      [objPath, aResp{aResp}, context](
          const boost::system::error_code& ec,
          const std::vector<std::pair<
              std::string, dbus::utility::DbusVariantType>>& properties) {
        if (ec) {
          BMCWEB_LOG_DEBUG << "DBUS response error";
          messages::internalError(aResp->res);
          return;
        }

        const std::string* uuid = nullptr;

        const bool success = sdbusplus::unpackPropertiesNoThrow(
            dbus_utils::UnpackErrorPrinter(), properties, "UUID", uuid);

        if (!success) {
          messages::internalError(aResp->res);
          return;
        }

        if ((uuid != nullptr) && !uuid->empty()) {
          aResp->res.jsonValue["UUID"] = *uuid;
        }
      });
}

inline void getTrustedComponentData(
    const std::shared_ptr<bmcweb::AsyncResp>& aResp,
    const std::string& objectPath,
    const dbus::utility::MapperServiceMap& serviceMap) {
  for (const auto& [serviceName, interfaceList] : serviceMap) {
    for (const auto& interface : interfaceList) {
      if (interface == trustedComponentIntf) {
        getTrustedComponentInterfaceData(aResp, serviceName, objectPath);
      } else if (interface == decoratorAssetIntf) {
        getDecoratorAssetInterfaceData(aResp, serviceName, objectPath);
      } else if (interface == uuidIntf) {
        getCommonUUIDInterfaceData(aResp, serviceName, objectPath);
      }
    }
  }
}

inline void handleTrustedComponentGet(
    crow::App& app, const crow::Request& req,
    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
    const std::string& chassisId, const std::string& componentId) {
  if (!redfish::setUpRedfishRoute(app, req, asyncResp)) {
    return;
  }

  asyncResp->res.addHeader(boost::beast::http::field::link,
                           "</redfish/v1/JsonSchemas/TrustedComponent/"
                           "TrustedComponent.json>; rel=describedby");
  asyncResp->res.jsonValue["@odata.type"] =
      "#TrustedComponent.v1_0_0.TrustedComponent";

  getTrustedComponentObject(
      asyncResp, chassisId, componentId,
      std::bind_front(getTrustedComponentData, asyncResp));
}

inline void handleTrustedComponentCollectionGet(
    crow::App& app, const crow::Request& req,
    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
    const std::string& chassisId) {
  if (!redfish::setUpRedfishRoute(app, req, asyncResp)) {
    return;
  }

  boost::urls::url url = crow::utility::urlFromPieces(
      "redfish", "v1", "Chassis", chassisId, "TrustedComponents");

  asyncResp->res.jsonValue["@odata.type"] =
      "#TrustedComponentCollection.TrustedComponentCollection";
  asyncResp->res.jsonValue["@odata.id"] = url.buffer();
  asyncResp->res.jsonValue["Name"] = "Trusted Component Collection";
  asyncResp->res.jsonValue["Description"] = "Collection of Trusted Components";

  std::string trustedComponentsPath =
      sdbusplus::message::object_path("/xyz/openbmc_project/Chassis") /
      chassisId / "TrustedComponents";

  collection_util::getCollectionMembers(asyncResp, url,
                                        trustedComponentInterfaces,
                                        trustedComponentsPath.c_str());
}

inline void requestRoutesTrustedComponent(App& app) {
  BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/TrustedComponents/<str>/")
      .privileges(redfish::privileges::getTrustedComponent)
      .methods(boost::beast::http::verb::get)(
          std::bind_front(handleTrustedComponentGet, std::ref(app)));
}

inline void requestRoutesTrustedComponentCollection(App& app) {
  BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/TrustedComponents/")
      .privileges(redfish::privileges::getTrustedComponentCollection)
      .methods(boost::beast::http::verb::get)(
          std::bind_front(handleTrustedComponentCollectionGet, std::ref(app)));
}

}  // namespace redfish

#endif  // THIRD_PARTY_GBMCWEB_REDFISH_CORE_LIB_TRUSTED_COMPONENT_H_