@aceplus/smartace-api 2.12.0 → 2.13.0-alpha.2

package/README.md

@@ -19,12 +19,16 @@ To use the SmartAce Api in node you will need the following dependencies
 
 ```
 
+Frontend: [https://saas.tkf-aceplus.com/](https://saas.tkf-aceplus.com/)
+Auth: auth.tkf-aceplus.com
+Asset Platform: saas.tkf-aceplus.com
+
 ## Auth
 
 Authentication happens on the auth cluster which is located on the following URL
 
 ```typescript
-var AuthAddress = "https://backend-auth.smart-ace.com";
+var AuthAddress = "https://auth.tkf-aceplus.com";
 ```
 
 ### Login
@@ -38,29 +42,29 @@ 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 });
-        }
-      },
-    });
-  });
+	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
@@ -81,29 +85,29 @@ 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 });
-        }
-      },
-    });
-  });
+	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");
@@ -116,36 +120,36 @@ auth = await refresh(auth.accessToken, auth.refreshToken);
 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";
+var OperatorAddress = "https://saas.tkf-aceplus.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
+	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 });
-        }
-      },
-    });
-  });
+	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 });
+				}
+			},
+		});
+	});
 }
 ```
 
@@ -155,18 +159,18 @@ 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));
-  });
+	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);
@@ -183,29 +187,29 @@ 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));
-  });
+	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));
-  });
+	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);
@@ -218,20 +222,20 @@ console.log(cabinet2.toObject());
 
 ```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));
-  });
+	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);
 
@@ -242,23 +246,23 @@ console.log(events.toObject());
 
 ```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));
-  });
+	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);
 
@@ -273,36 +277,36 @@ Here you have option for how long the opening is valid and if it is a single use
 
 ```typescript
 function Open(accessToken: string, cabinetId: number): Promise<CabinetProto.OpenRequest> {
-  return new Promise(async (resolve, reject) => {
-    const request = new CabinetProto.OpenRequest.CreateRequest();
+	return new Promise(async (resolve, reject) => {
+		const request = new CabinetProto.OpenRequest.CreateRequest();
 
-    request.setCabinetId(cabinetId);
+		request.setCabinetId(cabinetId);
 
-    function DateToTimestamp(date: Date): Timestamp {
-      let ts = new Timestamp();
-      let seconds = Math.round(date.getTime() / 1000);
-      ts.setSeconds(seconds);
-      return ts;
-    }
+		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 now = new Date(Date.now());
+		request.setRequestTime(DateToTimestamp(now));
 
-    var expirationDate = new Date(Date.now());
-    expirationDate.setTime(expirationDate.getTime() + 60 * 60 * 1000);
+		var expirationDate = new Date(Date.now());
+		expirationDate.setTime(expirationDate.getTime() + 60 * 60 * 1000);
 
-    request.setValidUntil(DateToTimestamp(expirationDate));
+		request.setValidUntil(DateToTimestamp(expirationDate));
 
-    request.setType(CabinetProto.OpenRequest.OpenRequestType.ADMIN_OPENING);
+		request.setType(CabinetProto.OpenRequest.OpenRequestType.ADMIN_OPENING);
 
-    request.setDeactivateafteropening(true);
+		request.setDeactivateafteropening(true);
 
-    BaseOperatorRequest(accessToken, CabinetGRPC.CreateOpenRequest, request)
-      .then((res) => {
-        resolve(res as CabinetProto.OpenRequest);
-      })
-      .catch((err) => reject(err));
-  });
+		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/meta.client_pb.d.ts

@@ -0,0 +1,168 @@
+// package: Meta
+// file: meta.client.proto
+
+import * as jspb from "google-protobuf";
+import * as google_protobuf_empty_pb from "google-protobuf/google/protobuf/empty_pb";
+import * as platform_pagination_pb from "./platform.pagination_pb";
+import * as platform_client_pb from "./platform.client_pb";
+import * as google_api_annotations_pb from "./google/api/annotations_pb";
+import * as google_protobuf_wrappers_pb from "google-protobuf/google/protobuf/wrappers_pb";
+
+export class ClientContactProto extends jspb.Message {
+  getEmail(): string;
+  setEmail(value: string): void;
+
+  getPhone(): string;
+  setPhone(value: string): void;
+
+  getFirstName(): string;
+  setFirstName(value: string): void;
+
+  getLastName(): string;
+  setLastName(value: string): void;
+
+  getFunction(): string;
+  setFunction(value: string): void;
+
+  hasIsmale(): boolean;
+  clearIsmale(): void;
+  getIsmale(): google_protobuf_wrappers_pb.BoolValue | undefined;
+  setIsmale(value?: google_protobuf_wrappers_pb.BoolValue): void;
+
+  getLanguage(): string;
+  setLanguage(value: string): void;
+
+  getPriority(): number;
+  setPriority(value: number): void;
+
+  getId(): number;
+  setId(value: number): void;
+
+  getClientId(): number;
+  setClientId(value: number): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ClientContactProto.AsObject;
+  static toObject(includeInstance: boolean, msg: ClientContactProto): ClientContactProto.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ClientContactProto, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ClientContactProto;
+  static deserializeBinaryFromReader(message: ClientContactProto, reader: jspb.BinaryReader): ClientContactProto;
+}
+
+export namespace ClientContactProto {
+  export type AsObject = {
+    email: string,
+    phone: string,
+    firstName: string,
+    lastName: string,
+    pb_function: string,
+    ismale?: google_protobuf_wrappers_pb.BoolValue.AsObject,
+    language: string,
+    priority: number,
+    id: number,
+    clientId: number,
+  }
+
+  export class EditRequest extends jspb.Message {
+    getContactId(): number;
+    setContactId(value: number): void;
+
+    hasContact(): boolean;
+    clearContact(): void;
+    getContact(): ClientContactProto | undefined;
+    setContact(value?: ClientContactProto): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): EditRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: EditRequest): EditRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: EditRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): EditRequest;
+    static deserializeBinaryFromReader(message: EditRequest, reader: jspb.BinaryReader): EditRequest;
+  }
+
+  export namespace EditRequest {
+    export type AsObject = {
+      contactId: number,
+      contact?: ClientContactProto.AsObject,
+    }
+  }
+
+  export class AddRequest extends jspb.Message {
+    getClientId(): number;
+    setClientId(value: number): void;
+
+    hasContact(): boolean;
+    clearContact(): void;
+    getContact(): ClientContactProto | undefined;
+    setContact(value?: ClientContactProto): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): AddRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: AddRequest): AddRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: AddRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): AddRequest;
+    static deserializeBinaryFromReader(message: AddRequest, reader: jspb.BinaryReader): AddRequest;
+  }
+
+  export namespace AddRequest {
+    export type AsObject = {
+      clientId: number,
+      contact?: ClientContactProto.AsObject,
+    }
+  }
+
+  export class RemoveRequest extends jspb.Message {
+    getContactId(): number;
+    setContactId(value: number): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): RemoveRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: RemoveRequest): RemoveRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: RemoveRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): RemoveRequest;
+    static deserializeBinaryFromReader(message: RemoveRequest, reader: jspb.BinaryReader): RemoveRequest;
+  }
+
+  export namespace RemoveRequest {
+    export type AsObject = {
+      contactId: number,
+    }
+  }
+}
+
+export class ClientProtoMeta extends jspb.Message {
+  hasClient(): boolean;
+  clearClient(): void;
+  getClient(): platform_client_pb.ClientProto | undefined;
+  setClient(value?: platform_client_pb.ClientProto): void;
+
+  clearContactsList(): void;
+  getContactsList(): Array<ClientContactProto>;
+  setContactsList(value: Array<ClientContactProto>): void;
+  addContacts(value?: ClientContactProto, index?: number): ClientContactProto;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ClientProtoMeta.AsObject;
+  static toObject(includeInstance: boolean, msg: ClientProtoMeta): ClientProtoMeta.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ClientProtoMeta, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ClientProtoMeta;
+  static deserializeBinaryFromReader(message: ClientProtoMeta, reader: jspb.BinaryReader): ClientProtoMeta;
+}
+
+export namespace ClientProtoMeta {
+  export type AsObject = {
+    client?: platform_client_pb.ClientProto.AsObject,
+    contactsList: Array<ClientContactProto.AsObject>,
+  }
+}
+