domo/domo-iot
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

update data model management. and write first tests.

Browse Source
This commit is contained in:
NADAL Jean-Baptiste
2019-12-26 18:29:16 +01:00
parent 429ec84ccf
commit 64fe3eb156
5 changed files with 468 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files

452
src/devices/devices_manager.c
View File

@@ -47,15 +47,24 @@
int load_outlets(devices_manager_t *dm, struct json_object *node);
struct json_object *save_outlets(devices_manager_t *dm);
int create_outlet(struct json_object *node);
int create_outlet(devices_manager_t *dm, struct json_object *node);
int remove_outlet(devices_manager_t *dm, uint16_t id);
int update_outlet(devices_manager_t *dm, uint16_t id, struct json_object *node);
int set_outlet_state(devices_manager_t *dm, uint16_t id, bool state);
int load_shutters(devices_manager_t *dm, struct json_object *node);
struct json_object *save_shutters(devices_manager_t *dm);
int create_shutter(devices_manager_t *dm, struct json_object *node);
int remove_shutter(devices_manager_t *dm, uint16_t id);
int update_shutter(devices_manager_t *dm, uint16_t id, struct json_object *node);
int set_shutter_state(devices_manager_t *dm, uint16_t id, bool state);
int load_sprinklers(devices_manager_t *dm, struct json_object *node);
struct json_object *save_sprinklers(devices_manager_t *dm);
int create_sprinkler(devices_manager_t *dm, struct json_object *node);
int remove_sprinkler(devices_manager_t *dm, uint16_t id);
int update_sprinkler(devices_manager_t *dm, uint16_t id, struct json_object *node);
int set_sprinkler_state(devices_manager_t *dm, uint16_t id, bool state);
/*----------------------------- PUBLIC FUNCTIONS ----------------------------*/
@@ -111,8 +120,8 @@ void devices_manager_free(devices_manager_t *devices_manager)
int devices_manager_load(devices_manager_t *dm, char *config_path)
{
struct json_object *the_root_node, *the_value_node;
DEBUG("Devices load...\n");
struct json_object *the_root_node, *the_value_node;
DEBUG("Devices load...\n");
if (config_path == NULL)
{
@@ -121,64 +130,64 @@ int devices_manager_load(devices_manager_t *dm, char *config_path)
}
dm->file_path = config_path;
the_root_node = json_object_from_file(dm->file_path);
if (the_root_node == NULL)
{
fprintf(stderr, "Failed to parse the Devices File (%s).\n", dm->file_path);
return -1;
}
the_root_node = json_object_from_file(dm->file_path);
if (the_root_node == NULL)
{
fprintf(stderr, "Failed to parse the Devices File (%s).\n", dm->file_path);
return -1;
}
if (json_object_object_get_ex(the_root_node, kOutletEntry, &the_value_node))
{
load_outlets(dm, the_value_node);
}
if (json_object_object_get_ex(the_root_node, kOutletEntry, &the_value_node))
{
load_outlets(dm, the_value_node);
}
if (json_object_object_get_ex(the_root_node, kShutterEntry, &the_value_node))
{
load_shutters(dm, the_value_node);
}
if (json_object_object_get_ex(the_root_node, kShutterEntry, &the_value_node))
{
load_shutters(dm, the_value_node);
}
if (json_object_object_get_ex(the_root_node, kSprinklerEntry, &the_value_node))
{
load_sprinklers(dm, the_value_node);
}
if (json_object_object_get_ex(the_root_node, kSprinklerEntry, &the_value_node))
{
load_sprinklers(dm, the_value_node);
}
/* Clean the json object. */
json_object_put(the_root_node);
/* Clean the json object. */
json_object_put(the_root_node);
return 0;
return 0;
}
/*--------------------------------------------------------------------------*/
int devices_manager_save(devices_manager_t *dm)
{
int result;
struct json_object *root_node;
int result;
struct json_object *root_node;
DEBUG("Devices save...\n");
root_node = json_object_new_object();
root_node = json_object_new_object();
// Outlets
json_object_object_add(root_node, kOutletEntry, save_outlets(dm));
// Shutters
// Outlets
json_object_object_add(root_node, kOutletEntry, save_outlets(dm));
// Shutters
json_object_object_add(root_node, kShutterEntry, save_shutters(dm));
// Sprinklers
json_object_object_add(root_node, kSprinklerEntry, save_sprinklers(dm));
// Sprinklers
json_object_object_add(root_node, kSprinklerEntry, save_sprinklers(dm));
result = json_object_to_file_ext(dm->file_path, root_node, JSON_C_TO_STRING_PRETTY);
result = json_object_to_file_ext(dm->file_path, root_node, JSON_C_TO_STRING_PRETTY);
/* Clean the json object. */
json_object_put(root_node);
/* Clean the json object. */
json_object_put(root_node);
return result;
return result;
}
/*--------------------------------------------------------------------------*/
char *devices_manager_get(devices_manager_t *dm, const char *capability)
{
#warning "TODO"
#warning "TODO"
return NULL;
}
@@ -186,7 +195,7 @@ char *devices_manager_get(devices_manager_t *dm, const char *capability)
char *devices_manager_get_by_id(devices_manager_t *dm, const char *capability, uint32_t id)
{
#warning "TODO"
#warning "TODO"
return NULL;
}
@@ -194,7 +203,7 @@ char *devices_manager_get_by_id(devices_manager_t *dm, const char *capability, u
int devices_manager_set(devices_manager_t *dm, const char *capability, struct json_object *node)
{
#warning "TODO"
#warning "TODO"
return 0;
}
@@ -202,36 +211,115 @@ int devices_manager_set(devices_manager_t *dm, const char *capability, struct js
int devices_manager_set_state(devices_manager_t *dm, const char *capability, int id, bool state)
{
#warning "TODO"
return 0;
int result = -1;
if (capability == kOutletEntry)
{
result = set_outlet_state(dm, id, state);
}
else if (capability == kShutterEntry)
{
result = set_shutter_state(dm, id, state);
}
else if (capability == kSprinklerEntry)
{
result = set_sprinkler_state(dm, id, state);
}
if (result == 0)
{
devices_manager_save(dm);
}
return result;
}
/*--------------------------------------------------------------------------*/
int devices_manager_create(devices_manager_t *dm, const char *a_capability, struct json_object *node)
int devices_manager_create(devices_manager_t *dm, const char *capability, struct json_object *node)
{
#warning "TODO"
return 0;
if (capability == kOutletEntry)
{
return create_outlet(dm, node);
}
else if (capability == kShutterEntry)
{
return create_shutter(dm, node);
}
else if (capability == kSprinklerEntry)
{
return create_sprinkler(dm, node);
}
return -1;
}
/*--------------------------------------------------------------------------*/
int devices_manager_update(devices_manager_t *dm, const char *a_capability, struct json_object *node)
int devices_manager_update(devices_manager_t *dm, const char *capability, struct json_object *node)
{
#warning "TODO"
return 0;
int32_t id = -1;
struct json_object *value_node;
// id
if (json_object_object_get_ex(node, k_entry_id, &value_node))
{
id = json_object_get_int(value_node);
}
// Sanity checks.
if (id == -1)
return -1;
if (capability == kOutletEntry)
{
return update_outlet(dm, id, node);
}
else if (capability == kShutterEntry)
{
return update_shutter(dm, id, node);
}
else if (capability == kSprinklerEntry)
{
return update_sprinkler(dm, id, node);
}
return -1;
}
/*--------------------------------------------------------------------------*/
int devices_manager_delete(devices_manager_t *dm, const char *a_capability, struct json_object *node)
int devices_manager_delete(devices_manager_t *dm, const char *capability, struct json_object *node)
{
#warning "TODO"
return 0;
int32_t id = -1;
struct json_object *value_node;
// id
if (json_object_object_get_ex(node, k_entry_id, &value_node))
{
id = json_object_get_int(value_node);
}
// Sanity checks.
if (id == -1)
return -1;
if (capability == kOutletEntry)
{
return remove_outlet(dm, id);
}
else if (capability == kShutterEntry)
{
return remove_shutter(dm, id);
}
else if (capability == kSprinklerEntry)
{
return remove_sprinkler(dm, id);
}
return -1;
}
/*! ----------------------------------------------------------------------------
* @fn load_outlets
*
@@ -239,39 +327,39 @@ int devices_manager_delete(devices_manager_t *dm, const char *a_capability, stru
*/
int load_outlets(devices_manager_t *dm, struct json_object *node)
{
DEBUG("devicesManager-load_outlets\n");
DEBUG("devicesManager-load_outlets\n");
/* Get Outlets */
if (json_object_get_type(node) == json_type_array)
{
int length;
struct json_object *outlet_node;
/* Get Outlets */
if (json_object_get_type(node) == json_type_array)
{
int length;
struct json_object *outlet_node;
length = json_object_array_length(node);
for (int i = 0; i < length; i++)
{
length = json_object_array_length(node);
for (int i = 0; i < length; i++)
{
outlet_dio_t *outlet = outlet_dio_new();
outlet_node = json_object_array_get_idx(node, i);
if (outlet_dio_from_json(outlet, outlet_node) == 0)
{
qlist_addlast(dm->outlets, outlet, sizeof(outlet_dio_t));
}
}
}
}
}
return 0;
return 0;
}
/*--------------------------------------------------------------------------*/
struct json_object *save_outlets(devices_manager_t *dm)
{
struct json_object *root_node;
outlet_dio_t *outlet;
struct json_object *root_node;
outlet_dio_t *outlet;
qlist_obj_t obj;
memset((void *) &obj, 0, sizeof(obj));
root_node = json_object_new_array();
memset((void *)&obj, 0, sizeof(obj));
root_node = json_object_new_array();
while (qlist_getnext(dm->outlets, &obj, true))
{
@@ -279,46 +367,88 @@ struct json_object *save_outlets(devices_manager_t *dm)
json_object_array_add(root_node, outlet_dio_to_json_object(outlet));
}
return root_node;
return root_node;
}
/*--------------------------------------------------------------------------*/
int create_outlet(devices_manager_t *dm, struct json_object *node)
{
outlet_dio_t *outlet = outlet_dio_new();
if (outlet_dio_from_json(outlet, node) != 0)
{
outlet_dio_free(outlet);
return -1;
}
device_set_id(outlet->device, ++dm->outlets_max_id);
qlist_addlast(dm->outlets, outlet, sizeof(outlet_dio_t));
return 0;
}
/*--------------------------------------------------------------------------*/
int remove_outlet(devices_manager_t *dm, uint16_t id)
{
#warning "TODO"
return 0;
}
/*--------------------------------------------------------------------------*/
int update_outlet(devices_manager_t *dm, uint16_t id, struct json_object *node)
{
#warning "TODO"
return 0;
}
/*--------------------------------------------------------------------------*/
int set_outlet_state(devices_manager_t *dm, uint16_t id, bool state)
{
#warning "TODO"
return 0;
}
/*--------------------------------------------------------------------------*/
int load_shutters(devices_manager_t *dm, struct json_object *node)
{
DEBUG("devicesManager-load_shutters\n");
DEBUG("devicesManager-load_shutters\n");
/* Get Shutters */
if (json_object_get_type(node) == json_type_array)
{
int length;
struct json_object *shutter_node;
/* Get Shutters */
if (json_object_get_type(node) == json_type_array)
{
int length;
struct json_object *shutter_node;
length = json_object_array_length(node);
for (int i = 0; i < length; i++)
{
length = json_object_array_length(node);
for (int i = 0; i < length; i++)
{
shutter_t *shutter = shutter_new();
shutter_node = json_object_array_get_idx(node, i);
if (shutter_from_json(shutter, shutter_node) == 0)
{
qlist_addlast(dm->shutters, shutter, sizeof(shutter_t));
}
}
}
}
}
return 0;
return 0;
}
/*--------------------------------------------------------------------------*/
struct json_object *save_shutters(devices_manager_t *dm)
{
struct json_object *root_node;
shutter_t *shutter;
struct json_object *root_node;
shutter_t *shutter;
qlist_obj_t obj;
memset((void *) &obj, 0, sizeof(obj));
root_node = json_object_new_array();
memset((void *)&obj, 0, sizeof(obj));
root_node = json_object_new_array();
while (qlist_getnext(dm->shutters, &obj, true))
{
@@ -326,14 +456,48 @@ struct json_object *save_shutters(devices_manager_t *dm)
json_object_array_add(root_node, shutter_to_json_object(shutter));
}
return root_node;
return root_node;
}
/*--------------------------------------------------------------------------*/
int create_shutter(devices_manager_t *dm, struct json_object *node)
{
#warning "TODO"
shutter_t *shutter = shutter_new();
if (shutter_from_json(shutter, node) != 0)
{
shutter_free(shutter);
return -1;
}
device_set_id(shutter->outlet_dio->device, ++dm->shutters_max_id);
qlist_addlast(dm->shutters, shutter, sizeof(shutter_t));
return 0;
}
/*--------------------------------------------------------------------------*/
int remove_shutter(devices_manager_t *dm, uint16_t id)
{
#warning "TODO"
return 0;
}
/*--------------------------------------------------------------------------*/
int update_shutter(devices_manager_t *dm, uint16_t id, struct json_object *node)
{
#warning "TODO"
return 0;
}
/*--------------------------------------------------------------------------*/
int set_shutter_state(devices_manager_t *dm, uint16_t id, bool state)
{
#warning "TODO"
return 0;
}
@@ -341,39 +505,39 @@ int create_shutter(devices_manager_t *dm, struct json_object *node)
int load_sprinklers(devices_manager_t *dm, struct json_object *node)
{
DEBUG("devicesManager-load_sprinkler\n");
DEBUG("devicesManager-load_sprinkler\n");
/* Get Shutters */
if (json_object_get_type(node) == json_type_array)
{
int length;
struct json_object *sprinkler_node;
/* Get Shutters */
if (json_object_get_type(node) == json_type_array)
{
int length;
struct json_object *sprinkler_node;
length = json_object_array_length(node);
for (int i = 0; i < length; i++)
{
length = json_object_array_length(node);
for (int i = 0; i < length; i++)
{
sprinkler_t *sprinkler = sprinkler_new();
sprinkler_node = json_object_array_get_idx(node, i);
if (sprinkler_from_json(sprinkler, sprinkler_node) == 0)
{
qlist_addlast(dm->sprinklers, sprinkler, sizeof(sprinkler_t));
}
}
}
}
}
return 0;
return 0;
}
/*--------------------------------------------------------------------------*/
struct json_object *save_sprinklers(devices_manager_t *dm)
{
struct json_object *root_node;
sprinkler_t *sprinkler;
struct json_object *root_node;
sprinkler_t *sprinkler;
qlist_obj_t obj;
memset((void *) &obj, 0, sizeof(obj));
root_node = json_object_new_array();
memset((void *)&obj, 0, sizeof(obj));
root_node = json_object_new_array();
while (qlist_getnext(dm->sprinklers, &obj, true))
{
@@ -381,13 +545,91 @@ struct json_object *save_sprinklers(devices_manager_t *dm)
json_object_array_add(root_node, sprinkler_to_json_object(sprinkler));
}
return root_node;
return root_node;
}
/*--------------------------------------------------------------------------*/
int create_sprinkler(devices_manager_t *dm, struct json_object *node)
{
#warning "TODO"
sprinkler_t *sprinkler = sprinkler_new();
if (sprinkler_from_json(sprinkler, node) != 0)
{
sprinkler_free(sprinkler);
return -1;
}
device_set_id(sprinkler->device, ++dm->sprinklers_max_id);
qlist_addlast(dm->sprinklers, sprinkler, sizeof(sprinkler_t));
return 0;
}
/*--------------------------------------------------------------------------*/
int remove_sprinkler(devices_manager_t *dm, uint16_t id)
{
qlist_obj_t obj;
sprinkler_t *sprinkler;
int position = 0;
memset((void *)&obj, 0, sizeof(obj));
while (qlist_getnext(dm->sprinklers, &obj, true))
{
sprinkler = obj.data;
if (sprinkler->device->id == id)
{
qlist_removeat(dm->sprinklers, position);
return 0;
}
position++;
}
return -1;
}
/*--------------------------------------------------------------------------*/
int update_sprinkler(devices_manager_t *dm, uint16_t id, struct json_object *node)
{
qlist_obj_t obj;
sprinkler_t *sprinkler;
memset((void *)&obj, 0, sizeof(obj));
while (qlist_getnext(dm->sprinklers, &obj, true))
{
sprinkler = obj.data;
if (sprinkler->device->id == id)
{
sprinkler_from_json(sprinkler, node);
return 0;
}
}
return -1;
}
/*--------------------------------------------------------------------------*/
int set_sprinkler_state(devices_manager_t *dm, uint16_t id, bool state)
{
qlist_obj_t obj;
sprinkler_t *sprinkler;
memset((void *)&obj, 0, sizeof(obj));
while (qlist_getnext(dm->sprinklers, &obj, true))
{
sprinkler = obj.data;
if (sprinkler->device->id == id)
{
sprinkler->device->state = state;
return 0;
}
}
return -1;
}