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

add test for devices_manager_get_by_id & devices_manager_update
All checks were successful
continuous-integration/drone/push Build is passing
Details

Browse Source
This commit is contained in:
NADAL Jean-Baptiste
2020-01-07 17:29:55 +01:00
parent 87751f24b7
commit b5405fbe81
18 changed files with 573 additions and 364 deletions
Download Patch File Download Diff File Expand all files Collapse all files

384
src/devices/devices_manager.c
View File

@@ -1,7 +1,7 @@
/*!
* devices_manager.c
*
* Copyright (c) 2015-2019, NADAL Jean-Baptiste. All rights reserved.
* Copyright (c) 2015-2020, NADAL Jean-Baptiste. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@@ -41,31 +41,11 @@
#include "shutter.h"
#include "sprinkler.h"
#include "devices_manager_internal.h"
#include "devices_manager.h"
/*----------------------------- LOCAL FUNCTIONS ----------------------------*/
int load_outlets(devices_manager_t *dm, struct json_object *node);
struct json_object *save_outlets(devices_manager_t *dm);
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 ----------------------------*/
/*--------------------------------------------------------------------------*/
@@ -94,21 +74,33 @@ void devices_manager_free(devices_manager_t *devices_manager)
{
qlist_obj_t obj;
int i;
memset((void *)&obj, 0, sizeof(obj));
if (devices_manager == NULL)
return;
if (devices_manager->outlets)
{
devices_manager->outlets->free(devices_manager->outlets);
i = 0;
while (qlist_getnext(devices_manager->outlets, &obj, true))
{
sprinkler_free(obj.data);
i++;
}
qlist_free(devices_manager->outlets);
}
if (devices_manager->shutters)
{
devices_manager->shutters->free(devices_manager->shutters);
i = 0;
while (qlist_getnext(devices_manager->shutters, &obj, true))
{
sprinkler_free(obj.data);
i++;
}
qlist_free(devices_manager->shutters);
}
if (devices_manager->sprinklers)
{
memset((void *)&obj, 0, sizeof(obj));
i = 0;
while (qlist_getnext(devices_manager->sprinklers, &obj, true))
{
@@ -206,8 +198,32 @@ 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"
return NULL;
const char *output = NULL;
if (capability == kOutletEntry)
{
}
else if (capability == kShutterEntry)
{
}
else if (capability == kSprinklerEntry)
{
sprinkler_t *sprinkler;
sprinkler = get_sprinkler_by_id(dm, id);
if (sprinkler != NULL)
{
json_object *output_node = sprinkler_to_json_object(sprinkler);
if (output_node != NULL)
{
output = strdup(json_object_to_json_string(output_node));
json_object_put(output_node);
}
}
}
return output;
}
/*--------------------------------------------------------------------------*/
@@ -331,317 +347,3 @@ int devices_manager_delete(devices_manager_t *dm, const char *capability, struct
return -1;
}
/*! ----------------------------------------------------------------------------
* @fn load_outlets
*
* @brief Load outlets Object From a Json Node.
*/
int load_outlets(devices_manager_t *dm, struct json_object *node)
{
DEBUG("devicesManager-load_outlets\n");
/* 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++)
{
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;
}
/*--------------------------------------------------------------------------*/
struct json_object *save_outlets(devices_manager_t *dm)
{
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();
while (qlist_getnext(dm->outlets, &obj, true))
{
outlet = obj.data;
json_object_array_add(root_node, outlet_dio_to_json_object(outlet));
}
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");
/* 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++)
{
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;
}
/*--------------------------------------------------------------------------*/
struct json_object *save_shutters(devices_manager_t *dm)
{
struct json_object *root_node;
shutter_t *shutter;
qlist_obj_t obj;
memset((void *)&obj, 0, sizeof(obj));
root_node = json_object_new_array();
while (qlist_getnext(dm->shutters, &obj, true))
{
shutter = obj.data;
json_object_array_add(root_node, shutter_to_json_object(shutter));
}
return root_node;
}
/*--------------------------------------------------------------------------*/
int create_shutter(devices_manager_t *dm, struct json_object *node)
{
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;
}
/*--------------------------------------------------------------------------*/
int load_sprinklers(devices_manager_t *dm, struct json_object *node)
{
DEBUG("devicesManager-load_sprinkler\n");
/* 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++)
{
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;
}
/*--------------------------------------------------------------------------*/
struct json_object *save_sprinklers(devices_manager_t *dm)
{
struct json_object *root_node;
sprinkler_t *sprinkler;
qlist_obj_t obj;
memset((void *)&obj, 0, sizeof(obj));
root_node = json_object_new_array();
while (qlist_getnext(dm->sprinklers, &obj, true))
{
sprinkler = obj.data;
json_object_array_add(root_node, sprinkler_to_json_object(sprinkler));
}
return root_node;
}
/*--------------------------------------------------------------------------*/
int create_sprinkler(devices_manager_t *dm, struct json_object *node)
{
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));
free(sprinkler); // duplicated by qlist
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;
}