Support OCPP 2.1 variables (#988)

* Extended RequiredComponentVariable with additional property to specify for which ocpp version a variable is required. This is the base to continue implementing a device model integrity check inside libocpps DeviceModel class
* Aligned data ctrlr and sampled data ctrlr must always be available and the required variables are really always required. 
* 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: Piet Gömpel <pietgoempel@gmail.com>
Signed-off-by: Maaike Zijderveld, iolar <git.mail@iolar.nl>
Co-authored-by: Piet Gömpel <pietgoempel@gmail.com>

Author: maaikez

config/v201/component_config/custom/Connector_1_1.json

@@ -19,7 +19,8 @@
         }
       ],
       "description": "This variable reports current availability state for the Connector. Optional, because already reported in StatusNotification.",
-      "type": "string"
+      "type": "string",
+      "default": ""
     },
     "ConnectorAvailable": {
       "variable_name": "Available",

config/v201/component_config/custom/Connector_2_1.json

@@ -19,7 +19,8 @@
         }
       ],
       "description": "This variable reports current availability state for the Connector. Optional, because already reported in StatusNotification.",
-      "type": "string"
+      "type": "string",
+      "default": ""
     },
     "ConnectorAvailable": {
       "variable_name": "Available",

config/v201/device_model_migrations/3_down-variable_required.sql

@@ -0,0 +1,2 @@
+ALTER TABLE VARIABLE
+ADD REQUIRED INTEGER DEFAULT FALSE;

config/v201/device_model_migrations/3_up-variable_required.sql

@@ -0,0 +1,2 @@
+ALTER TABLE VARIABLE
+DROP COLUMN REQUIRED;

doc/v201/ocpp_201_device_model_initialization.md

@@ -1,4 +1,4 @@
-# OCPP 2.0.1: Device model initialization and inserting of config values
+# OCPP 2.0.1 and 2.1: Device model initialization and inserting of config values
 
 If there is no custom database used for the device model, and 'initialize_device_model' is set to true in the 
 constructor of ChargePoint, the device model will be created or updated when ChargePoint is created. This document will
@@ -43,3 +43,16 @@ addition of a new one.
 Note: OCPP requires EVSE and Connector numbering starting from 1 counting upwards.
 
 Note: There should be no duplicate components or variables in the component config files.
+
+
+## Required variables
+
+There are some required Variables, which can be found in the OCPP spec.  
+Some `Variables` are only required if the `Component` is `Available`, for example `Reservation` and `Smart Charging`. 
+There are  some Components that are always required because that is how libocpp works: `AlignedDataCtrlr` and 
+`SampledDataCtrlr`.  
+When libocpp is started and initialized, all required Variables will be checked and an DeviceModelError is thrown if 
+one of the required Variables is not there.
+
+This also implies, that if you write code that needs a required `Variable`, when trying to get that variable with 
+`DeviceModel::get_value(...)`, you should first check if the Component that Variable belongs to is `Available`.

include/ocpp/v201/ctrlr_component_variables.hpp

@@ -4,10 +4,63 @@
 #ifndef OCPP_V201_CTRLR_COMPONENT_VARIABLES
 #define OCPP_V201_CTRLR_COMPONENT_VARIABLES
 
+#include <set>
+
 #include <ocpp/v201/ocpp_types.hpp>
 
 namespace ocpp {
 namespace v201 {
+///
+/// \brief Required ComponentVariable.
+///
+struct RequiredComponentVariable : ComponentVariable {
+    /// \brief Constructor
+    RequiredComponentVariable() : required_for({OcppProtocolVersion::v201, OcppProtocolVersion::v21}){};
+
+    ///
+    /// \brief RequiredComponentVariable
+    /// \param component    Component
+    /// \param variable     Variable
+    /// \param custom_data  Custom data (default nullopt)
+    /// \param required_for Required for which version. Multiple versions can be given.
+    ///
+    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,
+                                                                                   OcppProtocolVersion::v21}) :
+        ComponentVariable(), required_for(required_for) {
+        this->component = component;
+        this->variable = variable;
+        this->customData = custom_data;
+    };
+
+    /// \brief For which ocpp protocol version(s) this component variable is required.
+    std::set<OcppProtocolVersion> required_for;
+};
+
+///
+/// \brief Required variables per component.
+///
+/// First value is the 'available' variable from the specific component. Second value is a set of required variables.
+/// This makes it possible to check only for the required variables if a component is available.
+///
+extern const std::vector<std::pair<ComponentVariable, std::vector<RequiredComponentVariable>>>
+    required_component_available_variables;
+
+///
+/// \brief Required variables that should always exist, regardless of any available or not available controller.
+///
+extern const std::vector<RequiredComponentVariable> required_variables;
+
+///
+/// \brief Required variables of an EVSE.
+///
+extern const std::vector<Variable> required_evse_variables;
+
+///
+/// \brief Required variables of a connector.
+///
+extern const std::vector<Variable> required_connector_variables;
 
 namespace ControllerComponents {
 extern const Component InternalCtrlr;

include/ocpp/v201/device_model.hpp

@@ -8,6 +8,7 @@
 
 #include <everest/logging.hpp>
 
+#include <ocpp/v201/ctrlr_component_variables.hpp>
 #include <ocpp/v201/device_model_storage_interface.hpp>
 
 namespace ocpp {
@@ -136,6 +137,36 @@ class DeviceModel {
                                    const ocpp::v201::Component& component_,
                                    const struct ocpp::v201::Variable& variable_);
 
+    ///
+    /// \brief Helper function to check if a variable has a value.
+    /// \param component_variable   Component variable to check.
+    /// \param attribute            Attribute to check.
+    ///
+    /// \throws DeviceModelError if variable has no value or value is an empty string.
+    ///
+    void check_variable_has_value(const ComponentVariable& component_variable,
+                                  const AttributeEnum attribute = AttributeEnum::Actual);
+
+    ///
+    /// \brief Helper function to check if a required variable has a value.
+    /// \param required_variable    Required component variable to check.
+    /// \param supported_versions   The current supported ocpp versions.
+    /// \throws DeviceModelError if variable has no value or value is an empty string.
+    ///
+    void check_required_variable(const RequiredComponentVariable& required_variable,
+                                 const std::vector<OcppProtocolVersion>& supported_versions);
+
+    ///
+    /// \brief Loop over all required variables to check if they have a value.
+    ///
+    /// This will check for all required variables from `ctrlr_component_variables.cpp` `required_variables`.
+    /// It will also check for specific required variables that belong to a specific controller. If a controller is not
+    /// available, the 'required' variables of that component are not required at this point.
+    ///
+    /// \throws DeviceModelError if one of the variables does not have a value or value is an empty string.
+    ///
+    void check_required_variables();
+
 public:
     /// \brief Constructor for the device model
     /// \param device_model_storage_interface pointer to a device model interface class

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

include/ocpp/v201/functional_blocks/remote_transaction_control.hpp

@@ -47,7 +47,7 @@ class RemoteTransactionControl : public RemoteTransactionControlInterface {
     RemoteTransactionControl(MessageDispatcherInterface<MessageType>& message_dispatcher, DeviceModel& device_model,
                              ConnectivityManagerInterface& connectivity_manager, EvseManagerInterface& evse_manager,
                              ComponentStateManagerInterface& component_state_manager, TransactionInterface& transaction,
-                             SmartChargingInterface& smart_charging, MeterValuesInterface& meter_values,
+                             SmartChargingInterface* smart_charging, MeterValuesInterface& meter_values,
                              AvailabilityInterface& availability, FirmwareUpdateInterface& firmware_update,
                              SecurityInterface& security, ReservationInterface* reservation,
                              ProvisioningInterface& provisioning, UnlockConnectorCallback unlock_connector_callback,
@@ -66,7 +66,7 @@ class RemoteTransactionControl : public RemoteTransactionControlInterface {
     ComponentStateManagerInterface& component_state_manager;
 
     TransactionInterface& transaction;
-    SmartChargingInterface& smart_charging;
+    SmartChargingInterface* smart_charging;
     MeterValuesInterface& meter_values;
     AvailabilityInterface& availability;
     FirmwareUpdateInterface& firmware_update;

include/ocpp/v201/functional_blocks/transaction.hpp

@@ -90,7 +90,7 @@ class TransactionBlock : public TransactionInterface {
                      ConnectivityManagerInterface& connectivity_manager, EvseManagerInterface& evse_manager,
                      MessageQueue<v201::MessageType>& message_queue, DatabaseHandlerInterface& database_handler,
                      AuthorizationInterface& authorization, AvailabilityInterface& availability,
-                     SmartChargingInterface& smart_charging, TariffAndCostInterface& tariff_and_cost,
+                     SmartChargingInterface* smart_charging, TariffAndCostInterface* tariff_and_cost,
                      StopTransactionCallback stop_transaction_callback, PauseChargingCallback pause_charging_callback,
                      std::optional<TransactionEventCallback> transaction_event_callback,
                      std::optional<TransactionEventResponseCallback> transaction_event_response_callback,
@@ -129,8 +129,8 @@ class TransactionBlock : public TransactionInterface {
     DatabaseHandlerInterface& database_handler;
     AuthorizationInterface& authorization;
     AvailabilityInterface& availability;
-    SmartChargingInterface& smart_charging;
-    TariffAndCostInterface& tariff_and_cost;
+    SmartChargingInterface* smart_charging;
+    TariffAndCostInterface* tariff_and_cost;
     StopTransactionCallback stop_transaction_callback;
     PauseChargingCallback pause_charging_callback;
     std::optional<TransactionEventCallback> transaction_event_callback;

include/ocpp/v201/init_device_model_db.hpp

@@ -43,15 +43,13 @@ namespace ocpp::v201 {
 /// \brief Class that holds a component.
 ///
 /// When the component is read from the database, the component id will be set.
-/// When the component is read from the component config file, the 'required' vector will be filled.
 ///
 struct ComponentKey {
     std::optional<uint64_t> db_id;       ///< \brief Component id in the database.
     std::string name;                    ///< \brief Component name.
     std::optional<std::string> instance; ///< \brief Component instance.
     std::optional<int32_t> evse_id;      ///< \brief Component evse id.
     std::optional<int32_t> connector_id; ///< \brief Component connector id.
-    std::vector<std::string> required;   ///< \brief List of required variables.
 
     ///
     /// \brief operator <, needed to add this class as key in a map.
@@ -85,8 +83,6 @@ struct DeviceModelVariable {
     VariableCharacteristics characteristics;
     /// \brief Variable attributes
     std::vector<DbVariableAttribute> attributes;
-    /// \brief True if variable is required
-    bool required;
     /// \brief Variable instance
     std::optional<std::string> instance;
     /// \brief Default value, if this is set in the component config json
@@ -221,11 +217,9 @@ class InitDeviceModelDb : public common::DatabaseHandlerCommon {
     ///
     /// \brief Get all component properties (variables) from the given (component) json.
     /// \param component_properties The json component properties
-    /// \param required_properties  The vector of required properties of this component.
     /// \return A vector with all Variables belonging to this component.
     ///
-    std::vector<DeviceModelVariable> get_all_component_properties(const json& component_properties,
-                                                                  std::vector<std::string> required_properties);
+    std::vector<DeviceModelVariable> get_all_component_properties(const json& component_properties);
 
     ///
     /// \brief Insert variable characteristics

include/ocpp/v201/ocpp_types.hpp

@@ -2235,11 +2235,9 @@ void to_json(json& j, const Firmware& k);
 /// \brief Conversion from a given json object \p j to a given Firmware \p k
 void from_json(const json& j, Firmware& k);
 
-// \brief Writes the string representation of the given Firmware \p k to the given output stream \p os
+/// \brief Writes the string representation of the given Firmware \p k to the given output stream \p os
 /// \returns an output stream with the Firmware written to
 std::ostream& operator<<(std::ostream& os, const Firmware& k);
-
-struct RequiredComponentVariable : ComponentVariable {};
 } // namespace v201
 } // namespace ocpp