Entities

README.md

@@ -57,12 +57,11 @@ We tested the library against following backends:
 
 #### Location encoding type
 
-If you want to run this library against a backend only supporting `'application/vnd.geo+json'` encoding for Location entities, you can
-specify it in your service declaration:
+If you want to run this library against a backend only supporting `'application/vnd.geo+json'` encoding for FeatureOfInterest/Location entities, you can specify it in your service declaration:
 
 ```typescript
 const service = new SensorThingsService(
     'https://example.org',
-    { locationEncodingType: 'application/vnd.geo+json' }
+    { encodingType: 'application/vnd.geo+json' }
 );
 ```

jest.config.js

@@ -1,4 +1,5 @@
 module.exports = {
   preset: 'ts-jest',
   testEnvironment: 'node',
+  collectCoverageFrom: ['src/**/*.ts','!test/**']
 };

package.json

@@ -14,6 +14,7 @@
     "lint": "eslint src/ --ext .js,.jsx,.ts,.tsx",
     "lint:fix": "eslint src/ --ext .js,.jsx,.ts,.tsx --fix",
     "test": "jest",
+    "test:coverage": "npx jest --coverage",
     "test:integration": "npx ts-node test/integration.ts",
     "clean": "rm -rf dist build package",
     "ts-node": "ts-node",
@@ -47,7 +48,8 @@
   },
   "dependencies": {
     "@turf/helpers": "^6.5.0",
-    "axios": "^0.22.0"
+    "axios": "^0.22.0",
+    "iso-datestring-validator": "^2.2.0"
   },
   "size-limit": [
     {

src/dao/DatastreamDao.ts

@@ -0,0 +1,26 @@
+import {BaseDao} from "./BaseDao";
+import {Datastream} from "../model/Datastream";
+import {UnitOfMeasurement} from "../model/utils/UnitOfMeasurement";
+import {ObservationType} from "../model/utils/ObservationType";
+import {Polygon} from "@turf/helpers";
+
+export class DatastreamDao extends BaseDao<Datastream> {
+    buildEntity(data: Record<string, unknown>): Datastream {
+        return new Datastream(
+            this._service,
+            data.name as string,
+            data.description as string,
+            data.unitOfMeasurement as UnitOfMeasurement,
+            data.observationType as ObservationType,
+            data.observedArea as Polygon,
+            data.phenomenonTime as string,
+            data.resultTime as string
+        );
+    }
+    get entityPathname(): string {
+        return "Datastreams";
+    }
+    get entityPublicAttributes(): string[] {
+        return ['name', 'description', 'unitOfMeasurement', 'observationType', 'observedArea', 'phenomenonTime', 'resultTime'];
+    }
+}

src/dao/FeatureOfInterestDao.ts

@@ -0,0 +1,20 @@
+import { Feature } from "@turf/helpers";
+import { FeatureOfInterest } from "../model/FeatureOfInterest";
+import { BaseDao } from "./BaseDao";
+
+export class FeatureOfInterestDao extends BaseDao<FeatureOfInterest> {
+    get entityPathname(): string {
+        return 'FeaturesOfInterest';
+    }
+    get entityPublicAttributes(): string[] {
+        return ['name', 'description', 'encodingType', 'feature'];
+    }
+    buildEntity(data: Record<string, unknown>): FeatureOfInterest {
+        return new FeatureOfInterest(
+            this._service,
+            data.name as string,
+            data.description as string,
+            data.feature as Feature
+        )
+    }
+}

src/dao/ObservationDao.ts

@@ -0,0 +1,22 @@
+import { Observation } from "../model/Observation";
+import { BaseDao } from "./BaseDao";
+
+export class ObservationDao extends BaseDao<Observation> {
+    get entityPathname(): string {
+        return 'Observations';
+    }
+    get entityPublicAttributes(): string[] {
+        return ['phenomenonTime', 'result', 'resultTime', 'resultQuality', 'validTime', 'parameters'];
+    }
+    buildEntity(data: Record<string, unknown>): Observation {
+        return new Observation(
+            this._service,
+            data.phenomenonTime as string,
+            data.result as unknown,
+            data.resultTime as string,
+            data.resultQuality as unknown,
+            data.validTime as string,
+            data.parameters as Record<string, unknown>
+        );
+    }
+}

src/dao/ObservedPropertyDao.ts

@@ -0,0 +1,19 @@
+import {BaseDao} from "./BaseDao";
+import {ObservedProperty} from "../model/ObservedProperty";
+
+export class ObservedPropertyDao extends BaseDao<ObservedProperty> {
+    buildEntity(data: Record<string, unknown>): ObservedProperty {
+        return new ObservedProperty(
+            this._service,
+            data.name as string,
+            data.definition as string,
+            data.description as string
+        );
+    }
+    get entityPathname(): string {
+        return "ObservedProperties";
+    }
+    get entityPublicAttributes(): string[] {
+        return ['name', 'description', 'definition'];
+    }
+}

src/dao/SensorDao.ts

@@ -0,0 +1,20 @@
+import { Sensor } from "../model/Sensor";
+import { BaseDao } from "./BaseDao";
+
+export class SensorDao extends BaseDao<Sensor> {
+    get entityPathname(): string {
+        return 'Sensors';
+    }
+    get entityPublicAttributes(): string[] {
+        return ['name', 'description', 'encodingType', 'metadata'];
+    }
+    buildEntity(data: Record<string, unknown>): Sensor {
+        return new Sensor(
+            this._service,
+            data.name as string,
+            data.description as string,
+            data.encodingType as string,
+            data.metadata as string
+        );
+    }
+}

src/model/Datastream.ts

@@ -0,0 +1,121 @@
+import {Entity} from "./Entity";
+import {BaseDao} from "../dao/BaseDao";
+import {Polygon} from "@turf/helpers";
+import {SensorThingsService} from "../service/SensorThingsService";
+import {ObservationType} from "./utils/ObservationType";
+import {UnitOfMeasurement} from "./utils/UnitOfMeasurement";
+import {DatastreamDao} from "../dao/DatastreamDao";
+import {DatastreamThingsList} from "./list/DatastreamThingsList";
+import {DatastreamObservedPropertiesList} from "./list/DatastreamObservedPropertiesList";
+import { TimeChecker } from "./utils/TimeChecker";
+import {DatastreamObservationsList} from "./list/DatastreamObservationsList";
+import {DatastreamSensorsList} from "./list/DatastreamSensorsList";
+
+/**
+ * A Datastream groups a collection of Observations measuring the same ObservedProperty and produced by the same Sensor.
+ *
+ * http://docs.opengeospatial.org/is/15-078r6/15-078r6.html#28
+ */
+export class Datastream extends Entity<Datastream> {
+    /**
+     * A property provides a label for Datastream entity, commonly a descriptive name.
+     */
+    public name: string;
+
+    /**
+     * The description of the Datastream entity.
+     */
+    public description: string;
+
+    /**
+     * A JSON Object containing three key-value pairs. The name property presents the full name of the unitOfMeasurement;
+     * the symbol property shows the textual form of the unit symbol; and the definition contains the URI defining the
+     * unitOfMeasurement.
+     * The values of these properties SHOULD follow the Unified Code for Unit of Measure (UCUM).
+     */
+    public unitOfMeasurement: UnitOfMeasurement;
+
+    /**
+     * The type of Observation (with unique result type), which is used by the service to encode observations.
+     */
+    public observationType: ObservationType;
+
+    /**
+     * The spatial bounding box of the spatial extent of all FeaturesOfInterest that belong to the Observations
+     * associated with this Datastream.
+     */
+    public observedArea: Polygon | undefined;
+
+    /**
+     * The temporal interval of the phenomenon times of all observations belonging to this Datastream.
+     */
+    public phenomenonTime: string | undefined;
+
+    /**
+     * The temporal interval of the result times of all observations belonging to this Datastream.
+     */
+    public resultTime: string | undefined;
+
+
+    /**
+     * A Thing has zero-to-many Datastreams. A Datastream entity SHALL only link to a Thing as a collection of Observations.
+     */
+    public things: DatastreamThingsList;
+
+    /**
+     * The Observations in a Datastream are performed by one-and-only-one Sensor. One Sensor MAY produce zero-to-many
+     * Observations in different Datastreams.
+     */
+    public sensors: DatastreamSensorsList;
+
+    /**
+     * The Observations of a Datastream SHALL observe the same ObservedProperty. The Observations of different Datastreams
+     * MAY observe the same ObservedProperty.
+     */
+    public observedProperties: DatastreamObservedPropertiesList;
+
+    /**
+     * A Datastream has zero-to-many Observations. One Observation SHALL occur in one-and-only-one Datastream.
+     */
+    public observations: DatastreamObservationsList;
+
+    constructor(
+        service: SensorThingsService, name: string, description: string,
+        unitOfMeasurement: UnitOfMeasurement | null,
+        observationType: ObservationType,
+        observedArea: Polygon | undefined = undefined,
+        phenomenonTime: string | undefined = undefined,
+        resultTime: string | undefined = undefined
+    ) {
+        super(service);
+        this.name = name;
+        this.description = description;
+
+        this.unitOfMeasurement = unitOfMeasurement ?? {
+            name: null,
+            symbol: null,
+            definition: null
+        };
+        if (![0, 3].includes(Object.values(this.unitOfMeasurement).filter(v => v === null).length))
+            throw new RangeError('unitOfMeasurement must have all of its properties either defined or null.');
+
+        this.observationType = observationType;
+        this.observedArea = observedArea;
+        this.things = new DatastreamThingsList(this, this._service);
+        this.sensors = new DatastreamSensorsList(this, this._service);
+        this.observedProperties = new DatastreamObservedPropertiesList(this, this._service);
+        this.observations = new DatastreamObservationsList(this, this._service);
+
+        const checker = new TimeChecker();
+        if (phenomenonTime !== undefined && !checker.checkTimeRange(phenomenonTime))
+            throw new RangeError(`"${phenomenonTime}" is not a valid phenomenonTime value.`);
+        this.phenomenonTime = phenomenonTime;
+        if (resultTime !== undefined && !checker.checkTimeRange(resultTime))
+            throw new RangeError(`"${resultTime}" is not a valid resultTime value.`);
+        this.resultTime = resultTime;
+    }
+
+    get dao(): BaseDao<Datastream> {
+        return new DatastreamDao(this._service);
+    }
+}

src/model/FeatureOfInterest.ts

@@ -0,0 +1,63 @@
+import { Feature } from "@turf/helpers";
+import { SensorThingsService } from "..";
+import { BaseDao } from "../dao/BaseDao";
+import { FeatureOfInterestDao } from "../dao/FeatureOfInterestDao";
+import { Entity } from "./Entity";
+import { FeatureOfInterestObservationsList } from "./list/FeatureOfInterestObservationsList";
+
+/**
+ * An Observation results in a value being assigned to a phenomenon. The phenomenon is a property of a feature, 
+ * the latter being the FeatureOfInterest of the Observation [OGC and ISO 19156:2011]. 
+ * 
+ * In the context of the Internet of Things, many Observations’ FeatureOfInterest can be the Location of the Thing. 
+ * For example, the FeatureOfInterest of a wifi-connect thermostat can be the Location of the thermostat (i.e., the 
+ * living room where the thermostat is located in). In the case of remote sensing, the FeatureOfInterest can be the 
+ * geographical area or volume that is being sensed.
+ * 
+ * http://docs.opengeospatial.org/is/15-078r6/15-078r6.html#32
+ */
+export class FeatureOfInterest extends Entity<FeatureOfInterest> {
+    /**
+     * A property provides a label for FeatureOfInterest entity, commonly a descriptive name.
+     */
+    public name: string;
+
+    /**
+     * The description about the FeatureOfInterest.
+     */
+    public description: string;
+
+    /**
+     * The encoding type of the feature property.
+     */
+    public readonly encodingType: string;
+
+    /**
+     * The detailed description of the feature.
+     */
+    public feature: Feature;
+
+
+    /**
+     * An Observation observes on one-and-only-one FeatureOfInterest. One FeatureOfInterest could be observed by zero-to-many Observations.
+     */
+    public observations: FeatureOfInterestObservationsList;
+
+    constructor(
+        service: SensorThingsService, 
+        name: string, 
+        description: string, 
+        feature: Feature
+    ) {
+        super(service);
+        this.name = name;
+        this.description = description;
+        this.encodingType = this._service.compatibility.encodingType;
+        this.feature = feature;
+        this.observations = new FeatureOfInterestObservationsList(this, this._service);
+    }
+
+    get dao(): BaseDao<FeatureOfInterest> {
+        return new FeatureOfInterestDao(this._service);
+    }
+}

src/model/HistoricalLocation.ts

@@ -4,20 +4,36 @@ import { SensorThingsService } from "../service/SensorThingsService";
 import { Entity } from "./Entity";
 import { HistoricalLocationLocationsList } from "./list/HistoricalLocationLocationsList";
 import { HistoricalLocationThingsList } from "./list/HistoricalLocationThingsList";
+import { TimeChecker } from "./utils/TimeChecker";
 
+/**
+ * A Thing’s HistoricalLocation entity set provides the times of the current (i.e., last known) and previous locations of the Thing.
+ * 
+ * https://docs.opengeospatial.org/is/15-078r6/15-078r6.html#27
+ */
 export class HistoricalLocation extends Entity<HistoricalLocation> {
+    /**
+     * The time when the Thing is known at the Location.
+     */
     public time: string;
 
+
+    /**
+     * A HistoricalLocation has one-and-only-one Thing. One Thing MAY have zero-to-many HistoricalLocations.
+     */
     public things: HistoricalLocationThingsList;
+
+    /**
+     * A Location can have zero-to-many HistoricalLocations. One HistoricalLocation SHALL have one or many Locations.
+     */
     public locations: HistoricalLocationLocationsList;
 
     constructor(service: SensorThingsService, time: string) {
         super(service);
-        try {
-            this.time = new Date(time).toISOString();
-        } catch (err) {
+        if (!new TimeChecker().checkISODate(time))
             throw new RangeError(`"${time}" is not a valid time value.`);
-        }
+        this.time = time;
+
         this.things = new HistoricalLocationThingsList(this, this._service);
         this.locations = new HistoricalLocationLocationsList(this, this._service);
     }