The space Availability APIs

package.json

@@ -42,7 +42,7 @@
   },
   "dependencies": {
     "@protobuf-ts/plugin": "^2.6.0",
-    "@windingtree/stays-models": "^1.0.1",
+    "@windingtree/stays-models": "^2.0.0",
     "@windingtree/videre-sdk": "^0.5.0",
     "axios": "^0.27.2",
     "bcrypt": "^5.0.1",
@@ -85,6 +85,7 @@
     "@types/node": "^17.0.38",
     "@types/response-time": "^2.3.5",
     "@types/swagger-ui-express": "^4.1.3",
+    "@types/luxon": "^2.3.2",
     "@typescript-eslint/eslint-plugin": "^5.27.0",
     "@typescript-eslint/parser": "^5.27.0",
     "@windingtree/videre-contracts": "^0.2.0-alpha.1",

src/controllers/FacilityController.ts

@@ -0,0 +1,74 @@
+import type { NextFunction, Request, Response } from 'express';
+import type { AvailabilityDate } from '../services/DBService';
+import { DateTime } from 'luxon';
+import ApiError from '../exceptions/ApiError';
+import { SpaceAvailabilityRepository } from '../repositories/SpaceAvailabilityRepository';
+
+export class FacilityController {
+  // Returns availability of the space
+  getSpaceAvailability = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    try {
+      const { facilityId, spaceId, date } = req.params;
+
+      const repository = new SpaceAvailabilityRepository(facilityId, spaceId);
+      const numSpaces = await repository.getSpaceAvailabilityNumSpaces(
+        date as AvailabilityDate
+      );
+
+      return res.json({ numSpaces });
+    } catch (e) {
+      next(e);
+    }
+  };
+
+  // Adds availability of the space by date
+  createSpaceAvailability = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    try {
+      const { facilityId, spaceId, date } = req.params;
+      const { numSpaces } = req.body;
+
+      if (!DateTime.fromSQL(date).isValid) {
+        throw ApiError.BadRequest('Invalid availability date format');
+      }
+
+      const repository = new SpaceAvailabilityRepository(facilityId, spaceId);
+      await repository.createAvailabilityByDate(
+        date as AvailabilityDate,
+        Number(numSpaces)
+      );
+
+      return res.json({ success: true });
+    } catch (e) {
+      next(e);
+    }
+  };
+
+  // Adds/updates `default` availability of the space
+  createDefaultSpaceAvailability = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    try {
+      const { facilityId, spaceId } = req.params;
+      const { numSpaces } = req.body;
+
+      const repository = new SpaceAvailabilityRepository(facilityId, spaceId);
+      await repository.createDefaultAvailability(Number(numSpaces));
+
+      return res.json({ success: true });
+    } catch (e) {
+      next(e);
+    }
+  };
+}
+
+export default new FacilityController();

src/controllers/StorageController.ts

@@ -11,7 +11,7 @@ import walletService from '../services/WalletService';
 import { web3StorageKey, typedDataDomain } from '../config';
 import { walletAccountsIndexes } from '../types';
 import { Facility, Item, ItemType, Space } from '../proto/facility';
-import facilitiesService from '../services/FacilitiesService';
+import facilityService from '../services/FacilityService';
 import { FacilitySpaceLevelValues } from 'src/services/DBService';
 const { readFile } = promises;
 
@@ -67,7 +67,7 @@ export class StorageController {
       );
 
       // Extract ans save/update facility from metadata
-      await facilitiesService.setFacilityDbKeys(serviceProviderId, [
+      await facilityService.setFacilityDbKeys(serviceProviderId, [
         [
           'metadata',
           Facility.fromBinary(serviceProviderData.payload) as Facility
@@ -95,7 +95,7 @@ export class StorageController {
       // Add/update spaces to DB
       await Promise.all(
         Object.entries(spaces).map(([itemId, entries]) =>
-          facilitiesService.setItemDbKeys(
+          facilityService.setItemDbKeys(
             serviceProviderId,
             'spaces',
             itemId,
@@ -107,7 +107,7 @@ export class StorageController {
       // Add/update other items to DB
       await Promise.all(
         Object.entries(otherItems).map(([itemId, entries]) =>
-          facilitiesService.setItemDbKeys(
+          facilityService.setItemDbKeys(
             serviceProviderId,
             'otherItems',
             itemId,

src/repositories/FacilityRepository.ts

@@ -13,10 +13,9 @@ export class FacilityRepository {
 
   public async getFacilityIds(): Promise<string[]> {
     try {
-      return await this.db.get<string, string[]>(
-        'facilities',
-        { valueEncoding: 'json' }
-      );
+      return await this.db.get<string, string[]>('facilities', {
+        valueEncoding: 'json'
+      });
     } catch (e) {
       if (e.status !== 404) {
         throw e;
@@ -25,7 +24,10 @@ export class FacilityRepository {
     return [];
   }
 
-  public async createFacility(facilityId: string, facility: Facility): Promise<void> {
+  public async createFacility(
+    facilityId: string,
+    facility: Facility
+  ): Promise<void> {
     const facilitySublevel = this.dbService.getFacilitySublevelDB(facilityId);
 
     await facilitySublevel.put('metadata', facility);

src/repositories/SpaceAvailabilityRepository.ts

@@ -1,17 +1,32 @@
-import DBService, { DateType, FacilityItemValues, LevelDefaultTyping } from '../services/DBService';
+import DBService, {
+  AvailabilityDate,
+  AvailabilityItemKey,
+  FacilityItemValues,
+  LevelDefaultTyping
+} from '../services/DBService';
 import { AbstractLevel, AbstractSublevel } from 'abstract-level';
 import { Availability } from '../proto/lpms';
 
 export class SpaceAvailabilityRepository {
   private dbService: DBService;
-  private availableDB: AbstractSublevel<AbstractLevel<LevelDefaultTyping, string, FacilityItemValues>, LevelDefaultTyping, "default" | DateType, Availability>;
+  private availableDB: AbstractSublevel<
+    AbstractLevel<LevelDefaultTyping, string, FacilityItemValues>,
+    LevelDefaultTyping,
+    AvailabilityItemKey,
+    Availability
+  >;
 
-  constructor(facilityId, spaceId) {
+  constructor(facilityId: string, spaceId: string) {
     this.dbService = DBService.getInstance();
-    this.availableDB = this.dbService.getSpaceAvailabilityDB(facilityId, spaceId);
+    this.availableDB = this.dbService.getSpaceAvailabilityDB(
+      facilityId,
+      spaceId
+    );
   }
 
-  public async getSpaceAvailabilityNumSpaces(key): Promise<number> {
+  public async getSpaceAvailabilityNumSpaces(
+    key: AvailabilityItemKey
+  ): Promise<number> {
     try {
       const availability: Availability = await this.availableDB.get(key);
       return availability.numSpaces;
@@ -24,11 +39,22 @@ export class SpaceAvailabilityRepository {
     return 0;
   }
 
-  public async createAvailabilityByDate(key: DateType): Promise<void> {
+  public async createDefaultAvailability(numSpaces: number): Promise<void> {
+    const availability: Availability = {
+      numSpaces
+    };
+
+    await this.availableDB.put('default', availability);
+  }
+
+  public async createAvailabilityByDate(
+    key: AvailabilityDate,
+    numSpaces = 1
+  ): Promise<void> {
     const count = await this.getSpaceAvailabilityNumSpaces(key);
 
     const availability: Availability = {
-      numSpaces: count + 1
+      numSpaces: count + numSpaces
     };
 
     await this.availableDB.put(key, availability);