Check for 'optional required' variables (only required when a component is available) and if they are not used while the whole ctrlr is not available..

Signed-off-by: Maaike Zijderveld, iolar <git.mail@iolar.nl>

Author: maaikez

include/ocpp/v201/ctrlr_component_variables.hpp

@@ -24,7 +24,7 @@ struct RequiredComponentVariable : ComponentVariable {
     ///
     RequiredComponentVariable(const Component component, const std::optional<Variable> variable,
                               const std::optional<CustomData> custom_data = std::nullopt,
-                              const std::set<OcppProtocolVersion> required_for = {OcppProtocolVersion::v201,
+                              const std::set<OcppProtocolVersion>& required_for = {OcppProtocolVersion::v201,
                                                                                   OcppProtocolVersion::v21}) :
         ComponentVariable(), required_for(required_for) {
         this->component = component;

include/ocpp/v201/functional_blocks/diagnostics.hpp

@@ -71,6 +71,7 @@ class Diagnostics : public DiagnosticsInterface {
 
     /// \brief Callback function that can be called to clear customer information based on the given arguments
     std::optional<ClearCustomerInformationCallback> clear_customer_information_callback;
+    const bool is_monitoring_available;
 
 private: // Functions
     /* OCPP message requests */
@@ -109,5 +110,9 @@ class Diagnostics : public DiagnosticsInterface {
     void clear_customer_information(const std::optional<CertificateHashDataType> customer_certificate,
                                     const std::optional<IdToken> id_token,
                                     const std::optional<CiString<64>> customer_identifier);
+
+    /// \brief Check if monitoring is available and if not, throw.
+    /// \param type Message type to include in MessageTypeNotImplementedException when thrown.
+    void throw_when_monitoring_not_available(const MessageType type);
 };
 } // namespace ocpp::v201

lib/ocpp/v201/charge_point.cpp

@@ -709,9 +709,14 @@ void ChargePoint::initialize(const std::map<int32_t, int32_t>& evse_connector_st
             *this->database_handler, this->callbacks.set_charging_profiles_callback);
     }
 
-    this->tariff_and_cost = std::make_unique<TariffAndCost>(
-        *this->message_dispatcher, *this->device_model, *this->evse_manager, *this->meter_values,
-        this->callbacks.set_display_message_callback, this->callbacks.set_running_cost_callback, this->io_service);
+    if (device_model->get_optional_value<bool>(ControllerComponentVariables::TariffCostCtrlrAvailableCost)
+            .value_or(false) ||
+        device_model->get_optional_value<bool>(ControllerComponentVariables::TariffCostCtrlrAvailableTariff)
+            .value_or(false)) {
+        this->tariff_and_cost = std::make_unique<TariffAndCost>(
+            *this->message_dispatcher, *this->device_model, *this->evse_manager, *this->meter_values,
+            this->callbacks.set_display_message_callback, this->callbacks.set_running_cost_callback, this->io_service);
+    }
 
     Component ocpp_comm_ctrlr = {"OCPPCommCtrlr"};
     Variable field_length = {"FieldLength"};
@@ -823,7 +828,12 @@ void ChargePoint::handle_message(const EnhancedMessage<v201::MessageType>& messa
             }
             break;
         case MessageType::CostUpdated:
-            this->tariff_and_cost->handle_message(message);
+            if (this->tariff_and_cost != nullptr) {
+                this->tariff_and_cost->handle_message(message);
+            } else {
+                send_not_implemented_error(message.uniqueId, message.messageTypeId);
+            }
+
             break;
         default:
             send_not_implemented_error(message.uniqueId, message.messageTypeId);
@@ -1690,7 +1700,10 @@ void ChargePoint::handle_transaction_event_response(const EnhancedMessage<v201::
         this->callbacks.transaction_event_response_callback.value()(original_msg, call_result.msg);
     }
 
-    this->tariff_and_cost->handle_cost_and_tariff(call_result.msg, original_msg, message.message[CALLRESULT_PAYLOAD]);
+    if (tariff_and_cost != nullptr) {
+        this->tariff_and_cost->handle_cost_and_tariff(call_result.msg, original_msg,
+                                                      message.message[CALLRESULT_PAYLOAD]);
+    }
 
     if (original_msg.eventType == TransactionEventEnum::Ended) {
         // nothing to do for TransactionEventEnum::Ended

lib/ocpp/v201/functional_blocks/authorization.cpp

@@ -483,7 +483,9 @@ void ocpp::v201::Authorization::cache_cleanup_handler() {
 void ocpp::v201::Authorization::handle_send_local_authorization_list_req(Call<SendLocalListRequest> call) {
     SendLocalListResponse response;
 
-    if (this->device_model.get_optional_value<bool>(ControllerComponentVariables::LocalAuthListCtrlrEnabled)
+    if (this->device_model.get_optional_value<bool>(ControllerComponentVariables::LocalAuthListCtrlrAvailable)
+            .value_or(false) &&
+        this->device_model.get_optional_value<bool>(ControllerComponentVariables::LocalAuthListCtrlrEnabled)
             .value_or(false)) {
         response.status = apply_local_authorization_list(call.msg);
     } else {
@@ -522,7 +524,9 @@ void ocpp::v201::Authorization::handle_send_local_authorization_list_req(Call<Se
 void ocpp::v201::Authorization::handle_get_local_authorization_list_version_req(Call<GetLocalListVersionRequest> call) {
     GetLocalListVersionResponse response;
 
-    if (this->device_model.get_optional_value<bool>(ControllerComponentVariables::LocalAuthListCtrlrEnabled)
+    if (this->device_model.get_optional_value<bool>(ControllerComponentVariables::LocalAuthListCtrlrAvailable)
+            .value_or(false) &&
+        this->device_model.get_optional_value<bool>(ControllerComponentVariables::LocalAuthListCtrlrEnabled)
             .value_or(false)) {
         try {
             response.versionNumber = this->database_handler.get_local_authorization_list_version();

lib/ocpp/v201/functional_blocks/diagnostics.cpp

@@ -39,7 +39,10 @@ Diagnostics::Diagnostics(MessageDispatcherInterface<MessageType>& message_dispat
         [this]() { return !this->connectivity_manager.is_websocket_connected(); }),
     get_log_request_callback(get_log_request_callback),
     get_customer_information_callback(get_customer_information_callback),
-    clear_customer_information_callback(clear_customer_information_callback) {
+    clear_customer_information_callback(clear_customer_information_callback),
+    is_monitoring_available(
+        this->device_model.get_optional_value<bool>(ControllerComponentVariables::MonitoringCtrlrAvailable)
+            .value_or(false)) {
 }
 
 void Diagnostics::handle_message(const ocpp::EnhancedMessage<MessageType>& message) {
@@ -52,18 +55,23 @@ void Diagnostics::handle_message(const ocpp::EnhancedMessage<MessageType>& messa
         this->handle_customer_information_req(json_message);
         break;
     case MessageType::SetMonitoringBase:
+        this->throw_when_monitoring_not_available(message.messageType);
         this->handle_set_monitoring_base_req(json_message);
         break;
     case MessageType::SetMonitoringLevel:
+        this->throw_when_monitoring_not_available(message.messageType);
         this->handle_set_monitoring_level_req(json_message);
         break;
     case MessageType::SetVariableMonitoring:
+        this->throw_when_monitoring_not_available(message.messageType);
         this->handle_set_variable_monitoring_req(message);
         break;
     case MessageType::GetMonitoringReport:
+        this->throw_when_monitoring_not_available(message.messageType);
         this->handle_get_monitoring_report_req(json_message);
         break;
     case MessageType::ClearVariableMonitoring:
+        this->throw_when_monitoring_not_available(message.messageType);
         this->handle_clear_variable_monitoring_req(json_message);
         break;
     default:
@@ -402,4 +410,10 @@ void Diagnostics::clear_customer_information(const std::optional<CertificateHash
     }
 }
 
+void Diagnostics::throw_when_monitoring_not_available(const MessageType type) {
+    if (!is_monitoring_available) {
+        throw MessageTypeNotImplementedException(type);
+    }
+}
+
 } // namespace ocpp::v201

lib/ocpp/v201/functional_blocks/display_message.cpp

@@ -101,7 +101,7 @@ void DisplayMessageBlock::handle_set_display_message(const Call<SetDisplayMessag
          this->evse_manager.get_transaction_evseid(call.msg.message.transactionId.value()) != std::nullopt);
 
     // Check if display messages are available.
-    if (!display_message_available.has_value() or !display_message_available.value()) {
+    if (!display_message_available.value_or(false)) {
         error = true;
         response.status = DisplayMessageStatusEnum::Rejected;
     }