Add API request states features

server/api/controllers/device.controller.js

@@ -106,6 +106,83 @@ module.exports = function DeviceController(gladys) {
     res.json(states);
   }
 
+  /**
+   * @api {get} /api/v1/device_feature/:device_feature_selector/states getDeviceFeaturesStates
+   * @apiName getDeviceFeatureStates
+   * @apiGroup Device
+   * @apiParam {string} from - Start date in UTC format "yyyy-mm-ddThh:mm:ss:sssZ"
+   * or "yyyy-mm-dd hh:mm:ss:sss" (GMT time).
+   * @apiParam {string} [to="now"] - End date in UTC format "yyyy-mm-ddThh:mm:ss:sssZ"
+   * or "yyyy-mm-dd hh:mm:ss:sss" (GMT time).
+   * @apiParam {number} [take] - Number of elements to return.
+   * @apiParam {number} [skip=0] - Number of elements to skip.
+   * @apiParam {number} [attributes] - Possible values (separated by a comma ',' if several): 'id',
+   * 'device_feature_id', 'value', 'created_at' and 'updated_at'. Leave empty to have all the columns.
+   * @apiParamExample {json} Request-Example with take and skip:
+   * {
+   *   "from": "2022-04-06T07:00:00.000Z",
+   *   "to": "2022-04-06T21:59:59.999Z",
+   *   "take": 3,
+   *   "skip": 5
+   * }
+   * @apiSuccessExample {json} Success-Response with take and skip:
+   * [
+   * 	{
+   * 		id: 'e1f30d6e-7891-4484-9aa7-2e094b53ed6c',
+   * 		device_feature_id: '83c31637-8cb3-4085-b518-dbe2f89b7d0c',
+   * 		value: 13,
+   * 		created_at: '2022-04-06 09:05:09.127 +00:00',
+   * 		updated_at: '2022-04-06 09:05:09.127 +00:00'
+   * 	},
+   * 	{
+   * 		id: '77bb6449-cdd0-4163-9f38-95102e1cbafa',
+   * 		device_feature_id: '83c31637-8cb3-4085-b518-dbe2f89b7d0c',
+   * 		value: 16,
+   * 		created_at: '2022-04-06 09:06:09.146 +00:00',
+   * 		updated_at: '2022-04-06 09:06:09.146 +00:00'
+   * 	},
+   * 	{
+   * 		id: '61a87d2a-93e7-4c6c-bd0e-a337803c236c',
+   * 		device_feature_id: '83c31637-8cb3-4085-b518-dbe2f89b7d0c',
+   * 		value: 108,
+   * 		created_at: '2022-04-06 09:07:09.137 +00:00',
+   * 		updated_at: '2022-04-06 09:07:09.137 +00:00'
+   * 	}
+   * ]
+   * @apiParamExample {json} Request-Example with attributes:
+   * {
+   *   'from': "2022-04-06 10:00:00.000",
+   *   'to': "2022-04-09 23:59:00.000",
+   *   'attributes': "created_at,value,id"
+   * }
+   * @apiSuccessExample {json} Success-Response with attributes definitions:
+   * [
+   * 	{
+   * 		created_at: '2022-04-06 10:00:09.225 +00:00',
+   * 		value: 139,
+   * 		id: '30c43c01-0718-40cd-84e0-b975894bd5af'
+   * 	},
+   * 	{
+   * 		created_at: '2022-04-06 10:01:09.219 +00:00',
+   * 		value: 140,
+   * 		id: 'd1674409-6baf-4658-abf0-070cbc5cbeef',
+   * 	},
+   * 	{
+   * 		created_at: '2022-04-06 10:02:09.166 +00:00',
+   * 		value: 141,
+   * 		id: '53129293-0b7c-4ced-be7d-7809fa558c96'
+   * 	},
+   * 	{
+   * 		...
+   * 	},
+   * 	... 3878 more items
+   * ]
+   */
+  async function getDeviceFeaturesStates(req, res) {
+    const states = await gladys.device.getDeviceFeaturesStates(req.params.device_feature_selector, req.query);
+    res.json(states);
+  }
+
   return Object.freeze({
     create: asyncMiddleware(create),
     get: asyncMiddleware(get),
@@ -115,5 +192,6 @@ module.exports = function DeviceController(gladys) {
     setValue: asyncMiddleware(setValue),
     setValueFeature: asyncMiddleware(setValueFeature),
     getDeviceFeaturesAggregated: asyncMiddleware(getDeviceFeaturesAggregated),
+    getDeviceFeaturesStates: asyncMiddleware(getDeviceFeaturesStates),
   });
 };

server/api/routes.js

@@ -223,6 +223,10 @@ function getRoutes(gladys) {
       authenticated: true,
       controller: deviceController.getDeviceFeaturesAggregated,
     },
+    'get /api/v1/device_feature/:device_feature_selector/states': {
+      authenticated: true,
+      controller: deviceController.getDeviceFeaturesStates,
+    },
     // house
     'post /api/v1/house': {
       authenticated: true,

server/lib/device/device.getDeviceFeaturesStates.js

@@ -0,0 +1,69 @@
+const { Op } = require('sequelize');
+const db = require('../../models');
+const { NotFoundError } = require('../../utils/coreErrors');
+const { Error400 } = require('../../utils/httpErrors');
+
+const DEFAULT_OPTIONS = {
+  skip: 0,
+  order_dir: 'ASC',
+  order_by: 'created_at',
+};
+
+/**
+ * @description Get all features states aggregates.
+ * @param {string} selector - Device selector.
+ * @param {object} options - Options of the query.
+ * @param {string} options.from - Start date in UTC format "yyyy-mm-ddThh:mm:ss:sssZ"
+ * or "yyyy-mm-dd hh:mm:ss:sss" (GMT time).
+ * @param {string} [options.to] - End date in UTC format "yyyy-mm-ddThh:mm:ss:sssZ"
+ * or "yyyy-mm-dd hh:mm:ss:sss" (GMT time).
+ * @param {number} [options.take] - Number of elements to return.
+ * @param {number} [options.skip] - Number of elements to skip.
+ * @param {string} [options.attributes] - Possible values (separated by a comma ',' if several): 'id',
+ * 'device_feature_id', 'value', 'created_at' and 'updated_at'. Leave empty to have all the columns.
+ * @returns {Promise<Array>} - Resolve with an array of data.
+ * @example
+ * device.getDeviceFeaturesStates('test-device', {from: '2022-03-31T00:00:00.000Z', to: '2022-03-31T23:59:59.999Z',
+ * take: 100, skip: 10, attributes: 'id,value,created_at'});
+ */
+async function getDeviceFeaturesStates(selector, options) {
+  const deviceFeature = this.stateManager.get('deviceFeature', selector);
+  if (deviceFeature === null) {
+    throw new NotFoundError('DeviceFeature not found');
+  }
+  if (options.from === undefined) {
+    throw new Error400('Start date missing');
+  }
+  const fromDate = new Date(options.from);
+  // Default end date is now
+  const toDate = options.to ? new Date(options.to) : new Date();
+
+  const optionsWithDefault = { ...DEFAULT_OPTIONS, ...options };
+
+  const queryParams = {
+    raw: true,
+    where: {
+      device_feature_id: deviceFeature.id,
+      created_at: {
+        [Op.gte]: fromDate,
+        [Op.lte]: toDate,
+      },
+    },
+    offset: optionsWithDefault.skip,
+    order: [[optionsWithDefault.order_by, optionsWithDefault.order_dir]],
+  };
+
+  // take is not a default
+  if (optionsWithDefault.take !== undefined) {
+    queryParams.limit = optionsWithDefault.take;
+  }
+
+  if (optionsWithDefault.attributes !== undefined) {
+    queryParams.attributes = optionsWithDefault.attributes.split(',');
+  }
+  return db.DeviceFeatureState.findAll(queryParams);
+}
+
+module.exports = {
+  getDeviceFeaturesStates,
+};

server/lib/device/index.js

@@ -20,6 +20,7 @@ const { getBySelector } = require('./device.getBySelector');
 const { getDeviceFeaturesAggregates } = require('./device.getDeviceFeaturesAggregates');
 const { getDeviceFeaturesAggregatesMulti } = require('./device.getDeviceFeaturesAggregatesMulti');
 const { onHourlyDeviceAggregateEvent } = require('./device.onHourlyDeviceAggregateEvent');
+const { getDeviceFeaturesStates } = require('./device.getDeviceFeaturesStates');
 const { purgeStates } = require('./device.purgeStates');
 const { purgeStatesByFeatureId } = require('./device.purgeStatesByFeatureId');
 const { poll } = require('./device.poll');
@@ -94,6 +95,7 @@ DeviceManager.prototype.getBySelector = getBySelector;
 DeviceManager.prototype.getDeviceFeaturesAggregates = getDeviceFeaturesAggregates;
 DeviceManager.prototype.getDeviceFeaturesAggregatesMulti = getDeviceFeaturesAggregatesMulti;
 DeviceManager.prototype.onHourlyDeviceAggregateEvent = onHourlyDeviceAggregateEvent;
+DeviceManager.prototype.getDeviceFeaturesStates = getDeviceFeaturesStates;
 DeviceManager.prototype.purgeStates = purgeStates;
 DeviceManager.prototype.purgeStatesByFeatureId = purgeStatesByFeatureId;
 DeviceManager.prototype.poll = poll;

server/test/controllers/device/device.controller.test.js

@@ -109,6 +109,34 @@ describe('GET /api/v1/device_feature/aggregated_states', () => {
   });
 });
 
+describe('GET /api/v1/device_feature/:device_feature_selector/states', () => {
+  beforeEach(async function BeforeEach() {
+    this.timeout(1000);
+    await insertStates(1);
+  });
+  it('should get device feature states by selector', async () => {
+    const now = new Date();
+    const dateState = `${now.getUTCFullYear()}-${`0${now.getUTCMonth() + 1}`.slice(-2)}-${`0${now.getUTCDate()}`.slice(
+      -2,
+    )}`;
+
+    await authenticatedRequest
+      .get('/api/v1/device_feature/test-device-feature/states')
+      .query({
+        from: new Date(`${dateState}T00:00:00.000Z`),
+        to: new Date(`${dateState}T23:59:59.999Z`),
+      })
+      .expect('Content-Type', /json/)
+      .expect(200)
+      .then((res) => {
+        expect(res.body).to.have.lengthOf(2000);
+        expect(res.body).to.be.an('array');
+        expect(res.body[0]).to.be.an('object');
+        expect(Object.keys(res.body[0])).to.have.lengthOf(5);
+      });
+  });
+});
+
 describe('DELETE /api/v1/device/:device_selector', () => {
   it('should delete device', async () => {
     await authenticatedRequest

server/test/lib/device/device.getDeviceFeaturesStates.test.js

@@ -0,0 +1,91 @@
+const EventEmitter = require('events');
+const { expect, assert } = require('chai');
+const uuid = require('uuid');
+const { fake } = require('sinon');
+const db = require('../../../models');
+const Device = require('../../../lib/device');
+const Job = require('../../../lib/job');
+
+const event = new EventEmitter();
+const job = new Job(event);
+
+const now = new Date('2000-06-15T03:59:00.000Z');
+const insertStates = async () => {
+  const queryInterface = db.sequelize.getQueryInterface();
+  const deviceFeatureStateToInsert = [];
+  const statesToInsert = 3 * 60;
+  for (let i = 0; i < statesToInsert; i += 1) {
+    const startAt = new Date(now.getTime() - 3 * 60 * 60 * 1000);
+    const date = new Date(startAt.getTime() + ((3 * 60 * 60 * 1000) / statesToInsert) * i);
+    deviceFeatureStateToInsert.push({
+      id: uuid.v4(),
+      device_feature_id: 'ca91dfdf-55b2-4cf8-a58b-99c0fbf6f5e4',
+      value: i,
+      created_at: date,
+      updated_at: date,
+    });
+  }
+  await queryInterface.bulkInsert('t_device_feature_state', deviceFeatureStateToInsert);
+};
+
+describe('Device.getDeviceFeaturesStates', function Describe() {
+  this.timeout(5000);
+
+  afterEach(async () => {
+    const queryInterface = db.sequelize.getQueryInterface();
+    await queryInterface.bulkDelete('t_device_feature_state');
+  });
+  it('should return states between 01:10 and 02:09 with a target between 2000-06-15 00:10 and now using take and skip , only created_at and values', async () => {
+    await insertStates();
+    const variable = {
+      getValue: fake.resolves(null),
+    };
+    const stateManager = {
+      get: fake.returns({
+        id: 'ca91dfdf-55b2-4cf8-a58b-99c0fbf6f5e4',
+        name: 'my-feature',
+      }),
+    };
+    const dateState = '2000-06-15';
+    const device = new Device(event, {}, stateManager, {}, {}, variable, job);
+    const states = await device.getDeviceFeaturesStates('test-device-feature', {
+      from: new Date(`${dateState}T00:00:00.000Z`).toISOString(),
+      attributes: 'created_at,value',
+      take: 60,
+      skip: 10,
+    });
+    expect(states).to.have.lengthOf(60);
+    expect(Object.keys(states[0])).to.have.lengthOf(2);
+    expect(states[0]).to.have.property('value');
+    expect(states[0]).to.not.have.own.property('updated_at');
+  });
+  it('should return error, device feature doesnt exist', async () => {
+    const variable = {
+      getValue: fake.resolves(null),
+    };
+    const stateManager = {
+      get: fake.returns(null),
+    };
+    const dateState = '2000-06-15';
+    const device = new Device(event, {}, stateManager, {}, {}, variable, job);
+    const promise = device.getDeviceFeaturesStates('test-device-feature', {
+      from: new Date(`${dateState}T00:00:00.000Z`).toISOString(),
+      to: new Date(`${dateState}T10:00:00.000Z`).toISOString(),
+    });
+    return assert.isRejected(promise, 'DeviceFeature not found');
+  });
+  it('should return error, start date missing', async () => {
+    const variable = {
+      getValue: fake.resolves(null),
+    };
+    const stateManager = {
+      get: fake.returns({
+        id: 'ca91dfdf-55b2-4cf8-a58b-99c0fbf6f5e4',
+        name: 'my-feature',
+      }),
+    };
+    const device = new Device(event, {}, stateManager, {}, {}, variable, job);
+    const promise = device.getDeviceFeaturesStates('this-device-does-not-exist', {});
+    return assert.isRejected(promise, 'Start date missing');
+  });
+});