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

1
src/CMakeLists.txt
View File

@@ -26,6 +26,7 @@ file(
broker/nats_broker.c
devices/devices_manager.c
devices/devices_manager_internal.c
devices/device.c
devices/outlet_dio.c
devices/shutter.c

4
src/devices/device.c
View File

@@ -1,7 +1,7 @@
/*!
* device.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
@@ -89,7 +89,7 @@ int device_from_json(device_t *device, struct json_object *node)
{
int16_t id = -1;
struct json_object *value_node;
// id
if (json_object_object_get_ex(node, k_entry_id, &value_node))
{

2
src/devices/device.h
View File

@@ -1,7 +1,7 @@
/*!
* device.h
*
* 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

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;
}

2
src/devices/devices_manager.h
View File

@@ -1,7 +1,7 @@
/*!
* devices_manager.h
*
* 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

421
src/devices/devices_manager_internal.c Normal file
View File

@@ -0,0 +1,421 @@
/*!
* devices_manager_internal.c
*
* 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
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301 USA
*
* @Author: NADAL Jean-Baptiste
* @Date: 07/01/2020
*
*/
// This is an independent project of an individual developer. Dear PVS-Studio, please check it.
// PVS-Studio Static Code Analyzer for C, C++, C#, and Java: http://www.viva64.com
/*-------------------------------- INCLUDES ---------------------------------*/
#include <strings.h>
#include <string.h>
#include <json.h>
#include <json_util.h>
#include "macro.h"
#include "domo.h"
#include "outlet_dio.h"
#include "shutter.h"
#include "sprinkler.h"
#include "devices_manager_internal.h"
/*! ----------------------------------------------------------------------------
* @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;
}
/*--------------------------------------------------------------------------*/
outlet_dio_t *get_outlet_by_id(devices_manager_t *dm, uint16_t id)
{
qlist_obj_t obj;
outlet_dio_t *outlet;
memset((void *)&obj, 0, sizeof(obj));
while (qlist_getnext(dm->outlets, &obj, false))
{
outlet = obj.data;
if (outlet->device->id == id)
{
return outlet;
}
}
return NULL;
}
/*--------------------------------------------------------------------------*/
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;
}
/*--------------------------------------------------------------------------*/
shutter_t *get_shutter_by_id(devices_manager_t *dm, uint16_t id)
{
qlist_obj_t obj;
shutter_t *shutter;
memset((void *)&obj, 0, sizeof(obj));
while (qlist_getnext(dm->shutters, &obj, false))
{
shutter = obj.data;
if (shutter->outlet_dio->device->id == id)
{
return shutter;
}
}
return NULL;
}
/*--------------------------------------------------------------------------*/
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, false))
{
sprinkler = obj.data;
if (sprinkler->device->id == id)
{
return sprinkler_from_json(sprinkler, node);
}
}
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;
}
/*--------------------------------------------------------------------------*/
sprinkler_t *get_sprinkler_by_id(devices_manager_t *dm, uint16_t id)
{
qlist_obj_t obj;
sprinkler_t *sprinkler;
memset((void *)&obj, 0, sizeof(obj));
while (qlist_getnext(dm->sprinklers, &obj, false))
{
sprinkler = obj.data;
if (sprinkler->device->id == id)
{
return sprinkler;
}
}
return NULL;
}

67
src/devices/devices_manager_internal.h Normal file
View File

@@ -0,0 +1,67 @@
/*!
* devices_manager_internal.h
*
* 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
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301 USA
*
* @Author: NADAL Jean-Baptiste
* @Date: 07/01/2020
*
*/
#ifndef _DEVICES_MANAGER_INTERNAL_H
#define _DEVICES_MANAGER_INTERNAL_H
/*------------------------------- INCLUDES ----------------------------------*/
#include <stdint.h>
#include "devices_manager.h"
struct json_object;
/*--------------------------- PUBLIC FUNCTIONS -------------------------------*/
/*-------------------------------- OUTLETS -----------------------------------*/
extern int load_outlets(devices_manager_t *dm, struct json_object *node);
extern struct json_object *save_outlets(devices_manager_t *dm);
extern int create_outlet(devices_manager_t *dm, struct json_object *node);
extern int remove_outlet(devices_manager_t *dm, uint16_t id);
extern int update_outlet(devices_manager_t *dm, uint16_t id, struct json_object *node);
extern int set_outlet_state(devices_manager_t *dm, uint16_t id, bool state);
extern outlet_dio_t *get_outlet_by_id(devices_manager_t *dm, uint16_t id);
/*-------------------------------- SHUTTERS -----------------------------------*/
extern int load_shutters(devices_manager_t *dm, struct json_object *node);
extern struct json_object *save_shutters(devices_manager_t *dm);
extern int create_shutter(devices_manager_t *dm, struct json_object *node);
extern int remove_shutter(devices_manager_t *dm, uint16_t id);
extern int update_shutter(devices_manager_t *dm, uint16_t id, struct json_object *node);
extern int set_shutter_state(devices_manager_t *dm, uint16_t id, bool state);
extern shutter_t *get_shutter_by_id(devices_manager_t *dm, uint16_t id);
/*------------------------------- SPRINKLERS ----------------------------------*/
extern int load_sprinklers(devices_manager_t *dm, struct json_object *node);
extern struct json_object *save_sprinklers(devices_manager_t *dm);
extern int create_sprinkler(devices_manager_t *dm, struct json_object *node);
extern int remove_sprinkler(devices_manager_t *dm, uint16_t id);
extern int update_sprinkler(devices_manager_t *dm, uint16_t id, struct json_object *node);
extern int set_sprinkler_state(devices_manager_t *dm, uint16_t id, bool state);
extern sprinkler_t *get_sprinkler_by_id(devices_manager_t *dm, uint16_t id);
#endif /* _DEVICES_MANAGER_INTERNAL_H */

2
src/devices/outlet_dio.c
View File

@@ -1,7 +1,7 @@
/*!
* outlet_dio.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

2
src/devices/outlet_dio.h
View File

@@ -1,7 +1,7 @@
/*!
* outlet_dio.h
*
* 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

2
src/devices/shutter.c
View File

@@ -1,7 +1,7 @@
/*!
* shutter.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

2
src/devices/shutter.h
View File

@@ -1,7 +1,7 @@
/*!
* shutter.h
*
* 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

3
src/devices/sprinkler.c
View File

@@ -1,7 +1,7 @@
/*!
* sprinkler.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
@@ -75,7 +75,6 @@ void sprinkler_free(sprinkler_t *sprinkler)
int sprinkler_from_json(sprinkler_t *sprinkler, struct json_object *node)
{
int result;
struct json_object *value_node;
result = device_from_json(sprinkler->device, node);
if (result < 0)

2
src/devices/sprinkler.h
View File

@@ -1,7 +1,7 @@
/*!
* sprinkler.h
*
* 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

2
src/domo.h
View File

@@ -1,7 +1,7 @@
/*!
* domo.h
*
* 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

2
src/main.c
View File

@@ -1,7 +1,7 @@
/*!
* main.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

2
src/rest/rest_handler.c
View File

@@ -1,7 +1,7 @@
/*!
* rest_handler.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

2
src/rest/rest_handler.h
View File

@@ -1,7 +1,7 @@
/*!
* rest_handler.h
*
* 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

35
src/tests/test_device.c
View File

@@ -1,7 +1,7 @@
/*!
* rest_handler.c
* test_device.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
@@ -36,7 +36,8 @@
QUNIT_START("Test Data Model");
#define kDeviceTestNameFalse "{ \"id\": 1, \"name\": \"test_name\", \"state\": false }"
#define kDeviceTestNameTrue "{ \"id\": 1, \"name\": \"test_name\", \"state\": true }"
TEST("devices_manager create and free")
{
@@ -52,21 +53,39 @@ TEST("sprinkler - create set_state remove.")
struct json_object *root_node;
devices_manager_t *dm;
int ret;
char *sprinkler_serialized;
dm = devices_manager_new();
ASSERT_NOT_NULL(dm);
// Create a New Entry.
root_node = json_object_new_object();
json_object_object_add(root_node, k_entry_name, json_object_new_string("test_name"));
ret = devices_manager_create(dm, kSprinklerEntry, root_node);
ASSERT_EQUAL_INT(ret, 0);
// ret = set_sprinkler_state(dm, 1, true);
// ASSERT_EQUAL_INT(ret, 0);
/* Clean the json object. */
json_object_put(root_node);
ASSERT_EQUAL_INT(ret, 0);
// Check Objets.
sprinkler_serialized = devices_manager_get_by_id(dm, kSprinklerEntry, 1);
ASSERT_EQUAL_STR(sprinkler_serialized, kDeviceTestNameFalse);
free(sprinkler_serialized);
// Change the State.
root_node = json_object_new_object();
json_object_object_add(root_node, k_entry_state, json_object_new_boolean(true));
json_object_object_add(root_node, k_entry_id, json_object_new_int(1));
devices_manager_update(dm, kSprinklerEntry, root_node);
/* Clean the json object. */
json_object_put(root_node);
ASSERT_EQUAL_INT(ret, 0);
// Check Objets.
sprinkler_serialized = devices_manager_get_by_id(dm, kSprinklerEntry, 1);
ASSERT_EQUAL_STR(sprinkler_serialized, kDeviceTestNameTrue);
free(sprinkler_serialized);
// Free the Object.
devices_manager_free(dm);
}