@corvina/device-example 1.0.8

package/src/controllers/device/dto/datapoint.dto.ts

@@ -0,0 +1,7 @@
+import { DataPoint } from "@corvina/corvina-device-sdk";
+
+export class DataPointDTO implements DataPoint {
+    tagName: string; // tag name
+    value: any;
+    timestamp: number; // posix time
+}

package/src/controllers/device/dto/deviceconfig.dto.ts

@@ -0,0 +1,110 @@
+import { ApiProperty } from "@nestjs/swagger";
+import {
+    AlarmDesc,
+    MultiLangString,
+    NoiseSimulationProperties,
+    NoiseSimulationType,
+    NullableSimulationProperties,
+    NullableSimulationStateMachine,
+    SimulationDesc,
+    SimulationType,
+    PacketFormatEnum,
+    TagDesc,
+} from "@corvina/corvina-device-sdk";
+import { DeviceConfig } from "@corvina/corvina-device-sdk";
+
+export class NullableSimulationStateMachineDTO implements NullableSimulationStateMachine {
+    nullifying: boolean;
+    start: number;
+    duration: number;
+}
+
+export class NullableSimulationPropertiesDTO implements NullableSimulationProperties {
+    probability: number;
+    dt_min: number;
+    dt_max: number;
+    state?: NullableSimulationStateMachineDTO;
+}
+
+export class NoiseSimulationPropertiesDTO implements NoiseSimulationProperties {
+    type: NoiseSimulationType;
+    amplitude: number;
+}
+
+export class SimulationDescDTO implements SimulationDesc {
+    type: SimulationType;
+    noise: NoiseSimulationPropertiesDTO;
+    nullable: NullableSimulationPropertiesDTO;
+}
+
+export class TagDescDTO implements TagDesc {
+    name: string;
+    type: string;
+    simulation?: SimulationDescDTO;
+}
+
+export class MultiLangStringDTO implements MultiLangString {
+    [languageCode: string]: string;
+}
+
+export class AlarmDescDTO implements AlarmDesc {
+    name: string;
+    desc: MultiLangStringDTO;
+    source: string;
+    severity: number;
+    ack_required: boolean;
+    reset_required: boolean;
+    enabled: boolean;
+    simulation: SimulationDescDTO;
+}
+
+export class DeviceConfigDTO {
+    activationKey?: string;
+    pairingEndpoint?: string;
+    availableTagsFile?: string; // json array string
+    availableTags?: TagDescDTO[]; // json array string
+    simulateTags?: boolean;
+    availableAlarms?: AlarmDescDTO[]; // json array string
+    simulateAlarms?: boolean;
+    packetFormat?: PacketFormatEnum;
+
+    private arrayToMap(input: { name: string }[]): Map<string, any> {
+        const map = new Map<string, any>();
+        for (const item of input) {
+            map.set(item.name, item);
+        }
+        return map;
+    }
+
+    private mapToArray(input: Map<string, any>) {
+        const array = [];
+        input.forEach((value, key) => {
+            array.push({ name: key, value });
+        });
+        return array;
+    }
+
+    toDeviceConfig(): DeviceConfig {
+        return {
+            activationKey: this.activationKey,
+            pairingEndpoint: this.pairingEndpoint,
+            availableTagsFile: this.availableTagsFile,
+            availableTags: this.arrayToMap(this.availableTags),
+            simulateTags: this.simulateTags,
+            availableAlarms: this.arrayToMap(this.availableAlarms),
+            simulateAlarms: this.simulateAlarms,
+            packetFormat: this.packetFormat,
+        };
+    }
+
+    constructor(deviceConfig: DeviceConfig) {
+        this.activationKey = deviceConfig.activationKey;
+        this.pairingEndpoint = deviceConfig.pairingEndpoint;
+        this.availableTagsFile = deviceConfig.availableTagsFile;
+        this.availableTags = this.mapToArray(deviceConfig.availableTags);
+        this.simulateTags = deviceConfig.simulateTags;
+        this.availableAlarms = this.mapToArray(deviceConfig.availableAlarms);
+        this.simulateAlarms = deviceConfig.simulateAlarms;
+        this.packetFormat = deviceConfig.packetFormat;
+    }
+}

package/src/controllers/device/dto/licensedata.dto.ts

@@ -0,0 +1,9 @@
+import { LicenseData } from "@corvina/corvina-device-sdk";
+
+export class LicenseDataDTO implements LicenseData {
+    realm: string;
+    logicalId: string;
+    apiKey: string;
+    platformPairingApiUrl: string;
+    brokerUrls: string[];
+}

package/src/controllers/device/json.controller.ts

@@ -0,0 +1,111 @@
+import { Logger, Controller, Injectable, Post, Query, Inject, Body, Param } from "@nestjs/common";
+import { DeviceService } from "@corvina/corvina-device-sdk";
+import { DataPoint } from "@corvina/corvina-device-sdk";
+import { ApiBody, ApiOperation, ApiQuery, ApiTags } from "@nestjs/swagger";
+import { DataPointDTO } from "./dto/datapoint.dto";
+import axios from "axios";
+
+/** Handles requests from Nebbiolo FOG CEP */
+@ApiTags("device")
+@Controller("/device/json/")
+@Injectable()
+export class Json {
+    private readonly l = new Logger(Json.name);
+    @Inject() private readonly deviceService: DeviceService;
+
+    @ApiOperation({
+        summary: "Post a new JSON value",
+        callbacks: {
+            result: {
+                "{$request.query#/callback}": {
+                    post: {
+                        requestBody: {
+                            required: true,
+                            content: {
+                                "application/json": {
+                                    schema: {
+                                        type: "object",
+                                        properties: {
+                                            error: {
+                                                type: "object",
+                                                properties: {
+                                                    message: {
+                                                        type: "string",
+                                                    },
+                                                },
+                                            },
+                                            tagName: {
+                                                type: "string",
+                                            },
+                                            modelPath: {
+                                                type: "string",
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                        responses: {
+                            "200": { description: "The server acknowledged the request" },
+                        },
+                    },
+                },
+            },
+        },
+    })
+    @ApiQuery({
+        name: "tagName",
+        description:
+            "Prefix of device identifier (name) of data source. The actual tag names advertised to the cloud are automatically generated as this prefix plus each property JSON path. The prefix can be undefined, so that only JSON paths are used",
+        schema: { default: undefined, example: "temperature" },
+        required: false,
+    })
+    @ApiQuery({
+        name: "timestamp",
+        description: "Specify a timestamp (if omitted the request timestamp is used) ",
+        required: false,
+    })
+    @ApiQuery({
+        name: "callback",
+        description: "Specify an optional callback to be invoked when the message has been delivered",
+        schema: { type: "string", format: "uri", example: "http://localhost:30001" },
+        required: false,
+    })
+    @ApiQuery({
+        name: "qos",
+        description: "Specify an optional qos (by default is zeo)",
+        schema: { type: "number", minimum: 0, maximum: 2, default: 0, example: 1 },
+        required: false,
+    })
+    @ApiBody({
+        description:
+            "The json value to set. Each property in the json is assigned as full tag name advertised to the cloud as ```availableTags``` the corresponding json path prefixed by ```tagName```. For instance, if ```tagName=\"tag\"``` and value is ```{ a: {b : 1 } }``` the advertised list of available tags is  ```['tag.a.b']```. If ```tagName``` is undefined the advertised list of available tags is simply ```['a.b']```",
+        schema: { default: "{}", example: { Tag1: 1 } },
+    })
+    @Post()
+    async post(
+        @Query("tagName") tagName = undefined,
+        @Query("timestamp") timestamp = undefined,
+        @Query("qos") qos = undefined,
+        @Query("callback") postCallback = undefined,
+        @Body() v: any,
+    ): Promise<DataPointDTO[]> {
+        const t = timestamp || Date.now();
+        const dataPoints = new Array<DataPoint>();
+        const dp: DataPoint = {
+            tagName,
+            value: v,
+            timestamp: t,
+        };
+        dataPoints.push(dp);
+        await this.deviceService.post(dataPoints, {
+            qos: qos || 0,
+            cb: postCallback
+                ? (error, tagName, modelPath) => {
+                      axios.post(postCallback, { error: { message: error.message }, tagName, modelPath });
+                  }
+                : undefined,
+        });
+        return dataPoints;
+    }
+}

package/src/controllers/device/sine.controller.ts

@@ -0,0 +1,56 @@
+import { Logger, Controller, Injectable, Post, Query, Inject } from "@nestjs/common";
+import { DeviceService } from "@corvina/corvina-device-sdk";
+import { DataPoint } from "@corvina/corvina-device-sdk";
+import { ApiOperation, ApiQuery, ApiTags } from "@nestjs/swagger";
+import { DataPointDTO } from "./dto/datapoint.dto";
+
+/** Handles requests from Nebbiolo FOG CEP */
+@ApiTags("device")
+@Controller("/device/sine")
+@Injectable()
+export class Sine {
+    private readonly l = new Logger(Sine.name);
+    @Inject() private readonly deviceService: DeviceService;
+
+    @ApiOperation({
+        summary: "Post a new value sampled from a sine wave with the given parameters, using wall clock as time base",
+    })
+    @ApiQuery({
+        name: "tagName",
+        description: "device identifier (name) of data source",
+        schema: { default: "Tag" },
+        required: false,
+    })
+    @ApiQuery({
+        name: "period",
+        description: "period in ms of the sine wave",
+        required: false,
+        schema: { default: 1000 },
+    })
+    @ApiQuery({
+        name: "amplitude",
+        description: "amplitude of the sine wave",
+        required: false,
+        schema: { default: 1000 },
+    })
+    @ApiQuery({ name: "phase", description: "phase of the sine wave", required: false, schema: { default: 0 } })
+    @Post()
+    async post(
+        @Query("tagName") tagName = "Tag",
+        @Query("period") period = 1000,
+        @Query("amplitude") amplitude = 1000,
+        @Query("phase") phase = 0,
+    ): Promise<DataPointDTO[]> {
+        const t = Date.now();
+        const v = amplitude * Math.sin(phase + (Date.now() / period) * 2 * Math.PI);
+        const dataPoints = new Array<DataPoint>();
+        const dp: DataPoint = {
+            tagName,
+            value: v,
+            timestamp: t,
+        };
+        dataPoints.push(dp);
+        await this.deviceService.post(dataPoints);
+        return dataPoints;
+    }
+}

package/src/controllers/health.controller.ts

@@ -0,0 +1,14 @@
+import { Controller, Get } from "@nestjs/common";
+import { DeviceHealthIndicator } from "../services/device.health";
+import { HealthCheck, HealthCheckService } from "@nestjs/terminus";
+
+@Controller("health")
+export class HealthController {
+    constructor(private health: HealthCheckService, private deviceHealthIndicator: DeviceHealthIndicator) {}
+
+    @Get()
+    @HealthCheck()
+    check() {
+        return this.health.check([async () => this.deviceHealthIndicator.isHealthy("device")]);
+    }
+}

package/src/main.ts

@@ -0,0 +1,33 @@
+import { DeviceService, DeviceRunnerService } from "@corvina/corvina-device-sdk";
+import { NestFactory } from "@nestjs/core";
+import { DocumentBuilder, SwaggerModule } from "@nestjs/swagger";
+import axios from "axios";
+import { AppModule } from "./app.module";
+
+async function bootstrap() {
+    const app = await NestFactory.create(AppModule);
+
+    try {
+        const config = new DocumentBuilder()
+            .setTitle("Corvina NodeJS device API")
+            .setDescription("")
+            .setVersion("1.0")
+            .addTag("device")
+            .build();
+        const document = SwaggerModule.createDocument(app, config);
+        SwaggerModule.setup("swagger-ui", app, document);
+    } catch (e) {
+        console.error("Error caught: ", e);
+    }
+
+    await app.listen(3000);
+
+    app.get(DeviceRunnerService).run();
+    app.get(DeviceService).on("write", (event) => {
+        console.log("Write event received", event);
+        if (process.env["WRITE_CALLBACK"]) {
+            axios.post(process.env["WRITE_CALLBACK"], event);
+        }
+    });
+}
+bootstrap();

package/src/services/device.health.ts

@@ -0,0 +1,20 @@
+import { Injectable } from "@nestjs/common";
+import { HealthIndicatorResult, HealthIndicator, HealthCheckError } from "@nestjs/terminus";
+import { DeviceService } from "@corvina/corvina-device-sdk";
+
+@Injectable()
+export class DeviceHealthIndicator extends HealthIndicator {
+    constructor(private readonly deviceService: DeviceService) {
+        super();
+    }
+
+    async isHealthy(key: string): Promise<HealthIndicatorResult> {
+        const isHealthy = this.deviceService.status.ready == true;
+        const result = this.getStatus(key, isHealthy, this.deviceService.status);
+
+        if (this.deviceService.isReady) {
+            return result;
+        }
+        throw new HealthCheckError("Device not ready", result);
+    }
+}

package/tsconfig.app.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "declaration": false,
+    "outDir": "dist"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "test", "**/*spec.ts"]
+}