@aceplus/smartace-api 2.7.0-alpha.1 → 2.8.0-alpha.1

package/README.md

@@ -0,0 +1,309 @@
+# Guide
+
+To use the SmartAce Api in node you will need the following dependencies
+
+```typescript
+  "script": {
+    "dev": "npx tsx index.ts"
+  },
+  "dependencies": {
+    "@improbable-eng/grpc-web": "^0.15.0",
+    "@improbable-eng/grpc-web-node-http-transport": "^0.15.0",
+    "google-protobuf": "^3.21.2"
+  },
+  "devDependencies": {
+    "@types/google-protobuf": "^3.15.6",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.19.2"
+  }
+
+```
+
+## Auth
+
+Authentication happens on the auth cluster which is located on the following URL
+
+```typescript
+var AuthAddress = "https://backend-auth.smart-ace.com";
+```
+
+### Login
+
+To authenticate login with valid credentials
+
+```typescript
+import { grpc } from "@improbable-eng/grpc-web";
+import { NodeHttpTransport } from "@improbable-eng/grpc-web-node-http-transport";
+import { AuthnProto } from "@aceplus/smartace-api/auth.authn_pb";
+import { AuthnGRPC } from "@aceplus/smartace-api/auth.authn_pb_service";
+
+function login(username: string, password: string): Promise<AuthnProto.AsObject> {
+  return new Promise(async (resolve, reject) => {
+    let request = new AuthnProto.LoginRequest();
+
+    request.setUsername(username);
+    request.setPassword(password);
+
+    grpc.invoke(AuthnGRPC.Login, {
+      request,
+      transport: NodeHttpTransport(),
+      host: AuthAddress,
+      onMessage: (res) => {
+        resolve(res.toObject() as AuthnProto.AsObject);
+      },
+      onEnd: (code, message) => {
+        if (code === 0) {
+          console.log("Ok");
+        } else {
+          console.log({ code, message });
+          reject({ code, message });
+        }
+      },
+    });
+  });
+}
+
+var auth = await login("test@email.com", "password"); // fill in your credentials here
+
+console.log(auth.accessToken);
+```
+
+### Refresh
+
+Logging in gives you a accessToken that is valid for a certain amount of time. (1 hour by default)
+
+To keep the session open, use the refresh token
+
+```typescript
+import { grpc } from "@improbable-eng/grpc-web";
+import { NodeHttpTransport } from "@improbable-eng/grpc-web-node-http-transport";
+import { AuthnProto } from "@aceplus/smartace-api/auth.authn_pb";
+import { AuthnGRPC } from "@aceplus/smartace-api/auth.authn_pb_service";
+
+function refresh(accessToken: string, refreshToken: string): Promise<AuthnProto.AsObject> {
+  return new Promise(async (resolve, reject) => {
+    let request = new AuthnProto.RefreshRequest();
+
+    request.setAccessToken(accessToken);
+    request.setRefreshToken(refreshToken);
+
+    grpc.invoke(AuthnGRPC.Refresh, {
+      request,
+      transport: NodeHttpTransport(),
+      host: AuthAddress,
+      onMessage: (res) => {
+        resolve(res.toObject() as AuthnProto.AsObject);
+      },
+      onEnd: (code, message) => {
+        if (code === 0) {
+          console.log("Ok");
+        } else {
+          console.log({ code, message });
+          reject({ code, message });
+        }
+      },
+    });
+  });
+}
+
+var auth = await login("test@email.com", "password");
+
+auth = await refresh(auth.accessToken, auth.refreshToken);
+```
+
+## Spic
+
+To access the spic data, we need to access the operator cluster on the following URL
+
+```typescript
+var OperatorAddress = "https://backend-dev.smart-ace.com";
+
+// grpc call helper function
+function BaseOperatorRequest<TRequest extends grpc.ProtobufMessage, TResponse extends grpc.ProtobufMessage, TMethod extends grpc.MethodDefinition<TRequest, TResponse>>(
+  accessToken: string,
+  method: TMethod,
+  request: TRequest
+): Promise<TResponse> {
+  return new Promise(async (resolve, reject) => {
+    // set accesssToken in header for authorization
+    const metadata = new grpc.Metadata();
+    metadata.set("authorization", "Bearer " + accessToken);
+
+    grpc.invoke(method, {
+      metadata,
+      request,
+      host: OperatorAddress,
+      transport: NodeHttpTransport(), // required for Node
+      onMessage: (res) => {
+        resolve(res as TResponse);
+      },
+      onEnd: (code, message) => {
+        if (code === 0) {
+          console.log("Ok");
+        } else {
+          reject({ code, message });
+        }
+      },
+    });
+  });
+}
+```
+
+### Search Cabinets
+
+Searching cabinets with pagination
+
+```typescript
+function searchCabinets(accessToken: string, name: string, count: number, page: number): Promise<CabinetProto.SearchReply> {
+  return new Promise(async (resolve, reject) => {
+    const request = new CabinetProto.SearchRequest();
+    name && name.length >= 3 && request.setName(name);
+    request.setCount(count);
+    request.setPage(page);
+
+    BaseOperatorRequest(accessToken, CabinetGRPC.Search, request)
+      .then((res) => {
+        resolve(res as CabinetProto.SearchReply);
+      })
+      .catch((err) => reject(err));
+  });
+}
+
+var cabinets = await searchCabinets(auth.accessToken, "", 10, 0);
+
+console.log(cabinets.toObject());
+let firstCabinet = cabinets.getCabinetsList()[0];
+
+console.log(firstCabinet?.toObject());
+```
+
+### Retrieve cabinet
+
+Or retrieve cabinet by id or Uid
+
+```typescript
+function retrieveCabinetById(accessToken: string, id: number): Promise<CabinetWithLocation> {
+  return new Promise(async (resolve, reject) => {
+    const request = new CabinetProto.RetrieveRequest();
+    request.setId(id);
+
+    BaseOperatorRequest(accessToken, CabinetGRPC.Retrieve, request)
+      .then((res) => {
+        resolve(res as CabinetWithLocation);
+      })
+      .catch((err) => reject(err));
+  });
+}
+
+function retrieveCabinetByUid(accessToken: string, uid: string): Promise<CabinetWithLocation> {
+  return new Promise(async (resolve, reject) => {
+    const request = new CabinetProto.RetrieveRequest();
+    request.setUid(uid);
+
+    BaseOperatorRequest(accessToken, CabinetGRPC.Retrieve, request)
+      .then((res) => {
+        resolve(res as CabinetWithLocation);
+      })
+      .catch((err) => reject(err));
+  });
+}
+
+let cabinet1 = await retrieveCabinetById(auth.accessToken, 1);
+let cabinet2 = await retrieveCabinetByUid(auth.accessToken, "5424346F37680424");
+
+console.log(cabinet2.toObject());
+```
+
+### Retrieve events
+
+```typescript
+function retrieveEvents(accessToken: string, cabinetId: number, count: number, page: number, descendingOrder: boolean): Promise<CabinetProto.Event.SearchReply> {
+  return new Promise(async (resolve, reject) => {
+    const request = new CabinetProto.Event.SearchRequest();
+
+    request.setCabinetId(cabinetId);
+    request.setCount(count);
+    request.setPage(page);
+    request.setDescorder(descendingOrder);
+
+    BaseOperatorRequest(accessToken, CabinetGRPC.SearchEvents, request)
+      .then((res) => {
+        resolve(res as CabinetProto.Event.SearchReply);
+      })
+      .catch((err) => reject(err));
+  });
+}
+let events = await retrieveEvents(auth.accessToken, cabinet2.getCabinet()!.getId(), 10, 0, false);
+
+console.log(events.toObject());
+```
+
+### Retrieve states
+
+```typescript
+function retrieveStates(accessToken: string, uid: string, count: number, page: number, descendingOrder: boolean): Promise<CabinetProto.State.SearchReply> {
+  return new Promise(async (resolve, reject) => {
+    const request = new CabinetProto.State.SearchRequest();
+
+    request.setUid(uid);
+    request.setCount(count);
+    request.setPage(page);
+    request.setDescorder(descendingOrder);
+
+    request.setBatteryTo(4000);
+    request.setTemperatureTo(100);
+
+    BaseOperatorRequest(accessToken, CabinetGRPC.SearchStates, request)
+      .then((res) => {
+        resolve(res as CabinetProto.State.SearchReply);
+      })
+      .catch((err) => reject(err));
+  });
+}
+let states = await retrieveStates(auth.accessToken, cabinet2.getCabinet()!.getUid(), 10, 0, false);
+
+console.log(states.toObject());
+```
+
+### Opening a cabinet
+
+To open a cabinet you must create a openrequest.
+
+Here you have option for how long the opening is valid and if it is a single use or can be used multiple times withing the period
+
+```typescript
+function Open(accessToken: string, cabinetId: number): Promise<CabinetProto.OpenRequest> {
+  return new Promise(async (resolve, reject) => {
+    const request = new CabinetProto.OpenRequest.CreateRequest();
+
+    request.setCabinetId(cabinetId);
+
+    function DateToTimestamp(date: Date): Timestamp {
+      let ts = new Timestamp();
+      let seconds = Math.round(date.getTime() / 1000);
+      ts.setSeconds(seconds);
+      return ts;
+    }
+
+    var now = new Date(Date.now());
+    request.setRequestTime(DateToTimestamp(now));
+
+    var expirationDate = new Date(Date.now());
+    expirationDate.setTime(expirationDate.getTime() + 60 * 60 * 1000);
+
+    request.setValidUntil(DateToTimestamp(expirationDate));
+
+    request.setType(CabinetProto.OpenRequest.OpenRequestType.ADMIN_OPENING);
+
+    request.setDeactivateafteropening(true);
+
+    BaseOperatorRequest(accessToken, CabinetGRPC.CreateOpenRequest, request)
+      .then((res) => {
+        resolve(res as CabinetProto.OpenRequest);
+      })
+      .catch((err) => reject(err));
+  });
+}
+
+let openRequest = await Open(auth.accessToken, cabinet2.getCabinet()!.getId()).catch((err) => console.log(err));
+```

package/auth.account_pb.d.ts

@@ -29,6 +29,9 @@ export class AccountProto extends jspb.Message {
   getCompany(): string;
   setCompany(value: string): void;
 
+  getActive(): string;
+  setActive(value: string): void;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): AccountProto.AsObject;
   static toObject(includeInstance: boolean, msg: AccountProto): AccountProto.AsObject;
@@ -48,6 +51,7 @@ export namespace AccountProto {
     lastName: string,
     locale: string,
     company: string,
+    active: string,
   }
 
   export class CreateAdminRequest extends jspb.Message {
@@ -552,6 +556,94 @@ export namespace AccountProto {
     }
   }
 
+  export class RetrieveAccountActivationStatusesRequest extends jspb.Message {
+    clearIdsList(): void;
+    getIdsList(): Array<number>;
+    setIdsList(value: Array<number>): void;
+    addIds(value: number, index?: number): number;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): RetrieveAccountActivationStatusesRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: RetrieveAccountActivationStatusesRequest): RetrieveAccountActivationStatusesRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: RetrieveAccountActivationStatusesRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): RetrieveAccountActivationStatusesRequest;
+    static deserializeBinaryFromReader(message: RetrieveAccountActivationStatusesRequest, reader: jspb.BinaryReader): RetrieveAccountActivationStatusesRequest;
+  }
+
+  export namespace RetrieveAccountActivationStatusesRequest {
+    export type AsObject = {
+      idsList: Array<number>,
+    }
+  }
+
+  export class AccountsActivationStatuses extends jspb.Message {
+    getId(): number;
+    setId(value: number): void;
+
+    getStatus(): AccountProto.ActivationStatusesMap[keyof AccountProto.ActivationStatusesMap];
+    setStatus(value: AccountProto.ActivationStatusesMap[keyof AccountProto.ActivationStatusesMap]): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): AccountsActivationStatuses.AsObject;
+    static toObject(includeInstance: boolean, msg: AccountsActivationStatuses): AccountsActivationStatuses.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: AccountsActivationStatuses, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): AccountsActivationStatuses;
+    static deserializeBinaryFromReader(message: AccountsActivationStatuses, reader: jspb.BinaryReader): AccountsActivationStatuses;
+  }
+
+  export namespace AccountsActivationStatuses {
+    export type AsObject = {
+      id: number,
+      status: AccountProto.ActivationStatusesMap[keyof AccountProto.ActivationStatusesMap],
+    }
+  }
+
+  export class RetrieveAccountActivationStatusesReply extends jspb.Message {
+    clearActivationStatusesList(): void;
+    getActivationStatusesList(): Array<AccountProto.AccountsActivationStatuses>;
+    setActivationStatusesList(value: Array<AccountProto.AccountsActivationStatuses>): void;
+    addActivationStatuses(value?: AccountProto.AccountsActivationStatuses, index?: number): AccountProto.AccountsActivationStatuses;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): RetrieveAccountActivationStatusesReply.AsObject;
+    static toObject(includeInstance: boolean, msg: RetrieveAccountActivationStatusesReply): RetrieveAccountActivationStatusesReply.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: RetrieveAccountActivationStatusesReply, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): RetrieveAccountActivationStatusesReply;
+    static deserializeBinaryFromReader(message: RetrieveAccountActivationStatusesReply, reader: jspb.BinaryReader): RetrieveAccountActivationStatusesReply;
+  }
+
+  export namespace RetrieveAccountActivationStatusesReply {
+    export type AsObject = {
+      activationStatusesList: Array<AccountProto.AccountsActivationStatuses.AsObject>,
+    }
+  }
+
+  export class ResendInvitationRequest extends jspb.Message {
+    getId(): number;
+    setId(value: number): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ResendInvitationRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: ResendInvitationRequest): ResendInvitationRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ResendInvitationRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ResendInvitationRequest;
+    static deserializeBinaryFromReader(message: ResendInvitationRequest, reader: jspb.BinaryReader): ResendInvitationRequest;
+  }
+
+  export namespace ResendInvitationRequest {
+    export type AsObject = {
+      id: number,
+    }
+  }
+
   export interface RolesMap {
     SYSTEM_ADMIN: 0;
     ADMIN: 1;
@@ -563,5 +655,13 @@ export namespace AccountProto {
   }
 
   export const Roles: RolesMap;
+
+  export interface ActivationStatusesMap {
+    ACTIVATED: 0;
+    PENDING: 1;
+    EXPIRED: 2;
+  }
+
+  export const ActivationStatuses: ActivationStatusesMap;
 }