453 lines
11 KiB
C
453 lines
11 KiB
C
/*!
|
|
* 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));
|
|
free(outlet); // duplicated by qlist
|
|
|
|
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));
|
|
free(shutter); // duplicated by qlist
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
int remove_shutter(devices_manager_t *dm, uint16_t id)
|
|
{
|
|
qlist_obj_t obj;
|
|
shutter_t *shutter;
|
|
int position = 0;
|
|
|
|
memset((void *)&obj, 0, sizeof(obj));
|
|
|
|
while (qlist_getnext(dm->shutters, &obj, true))
|
|
{
|
|
shutter = obj.data;
|
|
if (shutter->outlet_dio->device->id == id)
|
|
{
|
|
qlist_removeat(dm->shutters, position);
|
|
return 0;
|
|
}
|
|
position++;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
int update_shutter(devices_manager_t *dm, uint16_t id, struct json_object *node)
|
|
{
|
|
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_from_json(shutter, node);
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
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;
|
|
}
|