user_credential_helpers.hpp

Go to the documentation of this file.

/******************************************************************************
 * # License
 * <b>Copyright 2024 Silicon Laboratories Inc. www.silabs.com</b>
 ******************************************************************************
 * The licensor of this software is Silicon Laboratories Inc. Your use of this
 * software is governed by the terms of Silicon Labs Master Software License
 * Agreement (MSLA) available at
 * www.silabs.com/about-us/legal/master-software-license-agreement. This
 * software is distributed to you in Source Code format and is governed by the
 * sections of the MSLA applicable to Source Code.
 *
 *****************************************************************************/
 
#ifndef USER_CREDENTIAL_HELPERS_H
#define USER_CREDENTIAL_HELPERS_H
 
// Get attribute store names
#include "attribute_store_defined_attribute_types.h"
// User credential types
#include "zwave_command_class_user_credential_types.h"
 
// Unify Cpp
#include "attribute.hpp"
#include "user_credential_definitions.hpp"
 
namespace user_credential_helpers
{
 
using attribute_callback = std::function<void(attribute_store::attribute &)>;
 
// Data struct
 
// Represent a credential ID (slot, type, user unique ID)
struct credential_id_nodes {
  attribute_store::attribute slot_node;
  attribute_store::attribute type_node;
  attribute_store::attribute user_unique_id_node;
};
 
template<typename T> attribute_store::attribute
  create_or_update_desired_value(attribute_store::attribute base_node,
                                 attribute_store_type_t attribute_type,
                                 T value)
{
  auto node = base_node.child_by_type_and_value(attribute_type,
                                                value,
                                                DESIRED_ATTRIBUTE);
  if (!node.is_valid()) {
    node = base_node.emplace_node(attribute_type, value);
  } else {
    node.set_reported(value);
    node.clear_desired();
  }
 
  return node;
}
 
void set_operation_type(attribute_store::attribute base_node,
                        attribute_store_type_t operation_type_node_type,
                        user_credential_operation_type_t operation_type);
void set_user_operation_type(attribute_store_node_t user_node,
                             user_credential_operation_type_t operation_type);
 
void set_credential_operation_type(
  attribute_store_node_t slot_node,
  user_credential_operation_type_t operation_type);
 
void set_credential_learn_operation_type(
  attribute_store_node_t slot_node,
  user_credential_operation_type_t operation_type);
 
bool user_exists(attribute_store::attribute endpoint_node,
                 user_credential_user_unique_id_t user_id);
 
attribute_store::attribute
  get_user_unique_id_node(attribute_store::attribute endpoint_node,
                          user_credential_user_unique_id_t user_id,
                          attribute_store_node_value_state_t state);
 
attribute_store::attribute
  get_credential_type_node(attribute_store::attribute user_id_node,
                           user_credential_type_t cred_type,
                           attribute_store_node_value_state_t state);
 
attribute_store::attribute
  get_credential_slot_node(attribute_store::attribute cred_type_node,
                           user_credential_slot_t cred_slot,
                           attribute_store_node_value_state_t state);
void for_each_credential_type_nodes_for_user(
  attribute_store::attribute user_id_node,
  const attribute_callback &callback,
  user_credential_type_t credential_type = 0);
 
void for_each_credential_type_nodes(attribute_store::attribute endpoint_node,
                                    const attribute_callback &callback,
                                    user_credential_type_t credential_type = 0);
bool is_credential_available(attribute_store_node_t endpoint_node,
                             user_credential_type_t credential_type,
                             user_credential_slot_t credential_slot);
 
credential_id_nodes
  get_credential_identifier_nodes(attribute_store_node_t child_node);
 
template<typename T> struct identifier_state {
  T value;
  attribute_store_node_value_state_t state;
};
credential_id_nodes get_credential_identifier_nodes(
  const attribute_store::attribute &endpoint_node,
  identifier_state<user_credential_user_unique_id_t> user_id,
  identifier_state<user_credential_type_t> credential_type,
  identifier_state<user_credential_slot_t> credential_slot);
 
bool is_admin_code_empty(const std::vector<uint8_t>& admin_pin_code);
void set_empty_admin_code(attribute_store::attribute &admin_pin_code_node,
                          attribute_store_node_value_state_t state);
 
}  // namespace user_credential_helpers
 
#endif  // USER_CREDENTIAL_HELPERS_H