@serptech/api 1.0.0

package/packages/serp-rest-api/src/serp-rest-api/api-facade/v1/notifications/index.ts

@@ -0,0 +1,40 @@
+import {
+  Liveness,
+  Sex,
+  Mood,
+  Result,
+  Paginatable,
+  Searchable,
+  id,
+} from "../../../../base/types";
+
+export interface NotificationInterface {
+  id?: id;
+  // read only
+  space_id?: id;
+  name?: string;
+  is_active?: boolean;
+  http_method?: number;
+  destination_url?: string;
+  results?: Array<Result>;
+  age_from?: number;
+  age_to?: number;
+  sex?: Array<Sex>;
+  moods?: Array<Mood>;
+  sources?: Array<string>;
+  persons_groups?: Array<id>;
+  liveness?: Array<Liveness>;
+}
+
+export interface NotificationsFiltersInterface extends Paginatable, Searchable {
+  spaces_ids?: Array<id>;
+}
+
+export interface NotificationsInterface {
+  getNotifications(filters: NotificationsFiltersInterface): Promise<null>;
+  getNotification(notificationId: id): Promise<NotificationInterface>;
+  createNotification(
+    notification: NotificationInterface
+  ): Promise<NotificationInterface>;
+  deleteNotification(notificationId: id): Promise<null>;
+}

package/packages/serp-rest-api/src/serp-rest-api/api-facade/v1/persons/index.ts

@@ -0,0 +1,60 @@
+import { Result, Sex, Mood } from "../../../../base/types";
+
+export interface PersonResponseIterface {
+  result: Result;
+  pid: string;
+  age: number;
+  sex: Sex;
+  mood: Mood;
+}
+
+export interface SearchPersonByImageParamsInterface {
+  image: File;
+  identify_asm?: boolean;
+}
+
+export interface CreatePersonParamsInterface {
+  image: File;
+  origin_id: number;
+  create_min_facesize?: number;
+  create_ha?: boolean;
+  create_junk?: boolean;
+  identify_asm?: boolean;
+}
+
+// export interface CreatePersonFromEntryParamsInterface {
+//   entryId: number;
+//   create_on_ha?: boolean;
+//   create_on_junk?: boolean;
+// }
+
+// export interface ReinitializePersonByEntryParamsInterface {
+//   entryId: id;
+// }
+
+export interface ReinitializePersonByImageParamsInterface {
+  pid: string;
+  image: File;
+  create_min_facesize?: number;
+  min_conf: number;
+  identify_asm?: boolean;
+}
+
+export interface PersonsInterface {
+  searchPersonByImage(
+    params: SearchPersonByImageParamsInterface
+  ): Promise<PersonResponseIterface>;
+  createPerson(
+    person: CreatePersonParamsInterface
+  ): Promise<PersonResponseIterface>;
+  // createPersonFromEntry(
+  //   person: CreatePersonFromEntryParamsInterface
+  // ): Promise<null>;
+  deletePerson(pid: string): Promise<null>;
+  // reinitializePersonByEntry(
+  //   params: ReinitializePersonByEntryParamsInterface
+  // ): Promise<null>;
+  reinitializePersonByImage(
+    params: ReinitializePersonByImageParamsInterface
+  ): Promise<null>;
+}

package/packages/serp-rest-api/src/serp-rest-api/api-facade/v1/persons-groups/index.ts

@@ -0,0 +1,54 @@
+import { Paginatable, Searchable, id } from "../../../../base/types";
+
+export interface GetPersonsGroupsFiltersInterface
+  extends Paginatable,
+    Searchable {
+  groups_ids?: Array<id>;
+  spaces_ids?: Array<id>;
+  person_ids_include?: Array<string>;
+  person_ids_exclude?: Array<string>;
+}
+
+export interface PersonsGroupInterface {
+  id?: id;
+  // read only
+  space_id?: id;
+  name?: string;
+  persons_count?: number;
+}
+
+export interface GetPersonsGroupPersonsFiltersInterface extends Paginatable {
+  groupId?: id;
+  person_ids?: Array<string>;
+}
+
+export interface AddPersonsToPersonsGroupsParamsInterface {
+  groupsIds?: Array<id>;
+  persons?: Array<string>;
+}
+
+export interface RemovePersonsFromPersonsGroupsParamsInterface {
+  groupsIds?: Array<id>;
+  persons?: Array<string>;
+}
+
+export interface PersonsGroupsInterface {
+  getPersonsGroups(params: GetPersonsGroupsFiltersInterface): Promise<null>;
+  getPersonsGroup(personsGroupId: id): Promise<PersonsGroupInterface>;
+  createPersonsGroup(
+    personsGroup: PersonsGroupInterface
+  ): Promise<PersonsGroupInterface>;
+  updatePersonsGroup(
+    personsGroup: PersonsGroupInterface
+  ): Promise<PersonsGroupInterface>;
+  deletePersonsGroup(personsGroupId: id): Promise<null>;
+  getPersonsGroupPersons(
+    filters: GetPersonsGroupPersonsFiltersInterface
+  ): Promise<null>;
+  addPersonsToPersonsGroups(
+    params: AddPersonsToPersonsGroupsParamsInterface
+  ): Promise<null>;
+  removePersonsFromPersonsGroups(
+    params: RemovePersonsFromPersonsGroupsParamsInterface
+  ): Promise<null>;
+}

package/packages/serp-rest-api/src/serp-rest-api/api-facade/v1/sources/index.ts

@@ -0,0 +1,46 @@
+import { Result, Paginatable, Searchable, id } from "../../../../base/types";
+
+export interface SourceInterface {
+  // General
+  id?: id;
+  // read only
+  space_id?: id;
+  name?: string;
+  license_id?: id;
+  license?: Record<string, unknown>;
+  identify_facesize_threshold?: number;
+  use_pps_timestamp?: boolean;
+
+  // Photo processing
+  manual_create_facesize_threshold?: number;
+  manual_create_on_ha?: boolean;
+  manual_create_on_junk?: boolean;
+  manual_identify_asm?: boolean;
+
+  // Processing a video stream
+  auto_create_persons?: boolean;
+  auto_create_facesize_threshold?: boolean;
+  auto_create_check_blur?: boolean;
+  auto_create_check_exposure?: boolean;
+  auto_create_on_ha?: boolean;
+  auto_create_on_junk?: boolean;
+  auto_check_face_angle?: boolean;
+  auto_check_angle_threshold?: number;
+  auto_check_liveness?: boolean;
+  auto_create_liveness_only?: boolean;
+  auto_identify_asm?: boolean;
+
+  // Saving images
+  store_images_for_results?: Array<Result>;
+}
+
+export interface SourcesFiltersInterface extends Paginatable, Searchable {
+  spaces_ids?: Array<id>;
+}
+
+export interface SourcesInterface {
+  getSources(filters: SourcesFiltersInterface): Promise<null>;
+  getSource(sourceId: id): Promise<SourceInterface>;
+  createSource(source: SourceInterface): Promise<SourceInterface>;
+  deleteSource(sourceId: id): Promise<null>;
+}

package/packages/serp-rest-api/src/serp-rest-api/api-facade/v1/spaces/index.ts

@@ -0,0 +1,27 @@
+import { Paginatable, Searchable, id } from "../../../../base/types";
+import { AuthApiInterface } from "../../../../base/auth-api";
+import { GetTokenInterface, TokenInterface } from "../tokens";
+
+export interface SpaceInterface {
+  id: id;
+  name: string;
+}
+
+export interface SpaceDataInterface {
+  name: string;
+}
+
+export interface GetSpacesParamsInterface extends Paginatable, Searchable {}
+
+export interface CreateSpaceTokenInterface extends GetTokenInterface {
+  id: id;
+}
+
+export interface SpacesInterface extends AuthApiInterface {
+  getSpaces(params: GetSpacesParamsInterface): Promise<Array<SpaceInterface>>;
+  getSpace(id: id): Promise<SpaceInterface>;
+  createSpace(data: SpaceDataInterface): Promise<SpaceInterface>;
+  updateSpace(data: SpaceInterface): Promise<SpaceInterface>;
+  deleteSpace(id: id): Promise<null>;
+  createToken(data: CreateSpaceTokenInterface): Promise<TokenInterface>;
+}

package/packages/serp-rest-api/src/serp-rest-api/api-facade/v1/stream-tokens/index.ts

@@ -0,0 +1,37 @@
+import { Paginatable, id } from "../../../../base/types";
+
+export interface StreamTokenInterface {
+  key: string;
+  id: id;
+  is_active: boolean;
+  created: string;
+  expires: string;
+}
+
+export interface GetStreamTokenInterface {
+  permanent?: boolean;
+}
+
+export interface GetStreamTokensParamsInterface
+  extends Paginatable,
+    GetStreamTokenInterface {}
+
+export interface UpdateStreamTokenParamsInterface {
+  id: id;
+  is_active: boolean;
+}
+
+export interface StreamTokensInterface {
+  getStreamTokens(
+    filters: GetStreamTokenInterface
+  ): Promise<Array<StreamTokenInterface>>;
+  getStreamToken(streamTokenId: id): Promise<StreamTokenInterface>;
+  createStreamToken(
+    streamToken: GetStreamTokenInterface
+  ): Promise<StreamTokenInterface>;
+  updateStreamToken(
+    params: UpdateStreamTokenParamsInterface
+  ): Promise<StreamTokenInterface>;
+  deleteStreamToken(streamTokenId: id): Promise<null>;
+  deleteStreamTokens(params: GetStreamTokenInterface): Promise<null>;
+}

package/packages/serp-rest-api/src/serp-rest-api/api-facade/v1/thresholds/index.ts

@@ -0,0 +1,17 @@
+import { id } from "../../../../base/types";
+
+export interface ThresholdsInterface {
+  // read only
+  space_id?: id;
+  exact?: number;
+  ha?: number;
+  junk?: number;
+}
+
+export interface ThresholdsClassInterface {
+  getThresholds(): Promise<ThresholdsInterface>;
+  updateThresholds(
+    Thresholds: ThresholdsInterface
+  ): Promise<ThresholdsInterface>;
+  resetThresholds(): Promise<ThresholdsInterface>;
+}

package/packages/serp-rest-api/src/serp-rest-api/api-facade/v1/tokens/index.ts

@@ -0,0 +1,32 @@
+import { Paginatable, id } from "../../../../base/types";
+import { AuthApiInterface } from "../../../../base/auth-api";
+
+export interface TokenInterface {
+  key: string;
+  id: id;
+  is_active: boolean;
+  created: string;
+  expires: string;
+}
+
+export interface GetTokenInterface {
+  permanent?: boolean;
+}
+
+export interface GetTokensParamsInterface
+  extends Paginatable,
+    GetTokenInterface {}
+
+export interface UpdateTokenParamsInterface {
+  id: id;
+  is_active: boolean;
+}
+
+export interface TokensInterface extends AuthApiInterface {
+  getTokens(params: GetTokensParamsInterface): Promise<Array<TokenInterface>>;
+  getToken(id: id): Promise<TokenInterface>;
+  createToken(params: GetTokenInterface): Promise<TokenInterface>;
+  updateToken(params: UpdateTokenParamsInterface): Promise<TokenInterface>;
+  deleteToken(id: id): Promise<void>;
+  deleteTokens(params: GetTokenInterface): Promise<void>;
+}

package/packages/serp-rest-api/src/serp-rest-api/api-facade/v1/utilities/index.ts

@@ -0,0 +1,82 @@
+import { Result, Sex, Mood } from "../../../../base/types";
+
+export interface ComparePhotosParamsInterface {
+  image1: File;
+  image2: File;
+  result?: Result;
+}
+
+export interface ComparePhotosResponseInterface {
+  similar: boolean;
+  result: Result;
+}
+
+export interface ComparePersonPhotoWithDocumentPhotoParamsInterface {
+  photo: File;
+  facesize?: number;
+  result?: Result;
+}
+
+export interface VerifyPersonPhotoWithDocumentPhotoParamsInterface {
+  photo_face: File;
+  photo_face_facesize?: number;
+
+  id_code: string;
+  photo_id: File;
+  photo_id_facesize?: number;
+
+  result?: Result;
+}
+
+export interface VerifyPersonPhotoWithDocumentPhotoResponseInterface
+  extends ComparePhotosResponseInterface {
+  extra?: {};
+  documents: [];
+}
+
+export interface CheckAsmParamsInterface {
+  image: File;
+}
+
+export interface CheckAsmResponseInterface {
+  age: number;
+  sex: Sex;
+  mood: Mood;
+}
+
+export interface FindOutCustomerParamsInterface {
+  source?: string;
+  offset?: number;
+}
+
+export interface FindOutCustomerResponseInterface {
+  pid: string;
+}
+
+export interface GetApiVersionResponseInterface {
+  version: string;
+}
+
+export interface UtilitiesInterface {
+  comparePhotos(
+    params: ComparePhotosParamsInterface
+  ): Promise<ComparePhotosResponseInterface>;
+
+  comparePersonPhotoWithDocumentPhoto(
+    params: ComparePersonPhotoWithDocumentPhotoParamsInterface
+  ): Promise<ComparePhotosResponseInterface>;
+
+  verifyPersonPhotoWithDocumentPhoto(
+    params: VerifyPersonPhotoWithDocumentPhotoParamsInterface
+  ): Promise<VerifyPersonPhotoWithDocumentPhotoResponseInterface>;
+
+  checkAsm(params: CheckAsmParamsInterface): Promise<CheckAsmResponseInterface>;
+
+  findOutCustomer(
+    params: FindOutCustomerParamsInterface
+  ): Promise<FindOutCustomerResponseInterface>;
+
+  getSupportedIdTypes(): Promise<null>;
+
+  getApiVersion(): Promise<GetApiVersionResponseInterface>;
+}

package/packages/serp-rest-api/src/serp-rest-api/features/auth/v1/index.ts

@@ -0,0 +1,58 @@
+import { AuthApi, AuthApiSettingsInterface } from "../../../../base/auth-api";
+import {
+  AuthInterface,
+  UserInterface,
+  LoginUserInterface,
+  ChangeUserPasswordInterface,
+} from "../../../api-facade/auth";
+
+class Auth extends AuthApi implements AuthInterface {
+  constructor(settings: AuthApiSettingsInterface) {
+    super(settings);
+    this.login = this.login.bind(this);
+    this.logout = this.logout.bind(this);
+    this.whoami = this.whoami.bind(this);
+    this.changePassword = this.changePassword.bind(this);
+  }
+
+  login(username: string, password: string): Promise<LoginUserInterface> {
+    const data = new FormData();
+    data.append("username", username);
+    data.append("password", password);
+
+    return this.httpClient
+      .post(this.authURL + "auth/token/", data)
+      .then((body: LoginUserInterface) => ({
+        token: {
+          id: body.token_meta.id,
+          key: body.access_token,
+          created: body.token_meta.created,
+          expires: body.token_meta.expires,
+          expires_in: body.expires_in,
+          is_active: body.token_meta.is_active,
+        },
+        user: {
+          username: body.user_meta.username,
+          created: body.user_meta.created,
+          space: {
+            id: body.user_meta.id,
+            name: "default",
+          },
+        },
+      }));
+  }
+
+  logout(tokenId: string): Promise<null> {
+    return this.httpClient.delete(this.authURL + `tokens/${tokenId}/`);
+  }
+
+  whoami(): Promise<UserInterface> {
+    return this.httpClient.get(this.authURL + "whoami/");
+  }
+
+  changePassword(data: ChangeUserPasswordInterface): Promise<null> {
+    return this.httpClient.post(this.authURL + "auth/password/change/", data);
+  }
+}
+
+export { Auth };

package/packages/serp-rest-api/src/serp-rest-api/features/entries/v1/index.ts

@@ -0,0 +1,70 @@
+import { Api, ApiSettingsInterface } from "../../../../base/api";
+import { id } from "../../../../base/types";
+
+import {
+  EntriesFiltersInterface,
+  EntriesInterface,
+  EntryInterface,
+  EntriesStatsInterface,
+} from "../../../api-facade/v1/entries";
+
+class Entries extends Api implements EntriesInterface {
+  constructor(settings: ApiSettingsInterface) {
+    super(settings);
+    this.getEntries = this.getEntries.bind(this);
+    this.getEntriesStatsByPersonId = this.getEntriesStatsByPersonId.bind(this);
+    this.deleteEntry = this.deleteEntry.bind(this);
+  }
+
+  static apiEndpoint = "entries/";
+
+  getEntries(
+    filters: EntriesFiltersInterface = {}
+  ): Promise<Array<EntryInterface>> {
+    const getFiltersData = ({
+      pid,
+      person_ids,
+      spaces_ids,
+      origin_ids,
+      conf,
+      liveness,
+      id_from,
+      date_from,
+      date_to,
+      limit,
+      offset,
+      sex,
+      mood,
+      age_from,
+      age_to,
+    }: EntriesFiltersInterface): {} => ({
+      pid,
+      person_ids,
+      spaces_ids,
+      origin_ids,
+      conf,
+      liveness,
+      id_from,
+      date_from,
+      date_to,
+      limit,
+      offset,
+      sex,
+      mood,
+      age_from,
+      age_to,
+    });
+
+    return this.httpClient.get(Entries.apiEndpoint, getFiltersData(filters));
+  }
+
+  getEntriesStatsByPersonId(pid: string): Promise<EntriesStatsInterface> {
+    return this.httpClient.get(`${Entries.apiEndpoint}stats/pid/${pid}/`);
+  }
+
+  deleteEntry(entryId: id): Promise<null> {
+    return this.httpClient.delete(`${Entries.apiEndpoint}${entryId}/`);
+  }
+}
+
+export { Entries };

package/packages/serp-rest-api/src/serp-rest-api/features/licenses/v1/index.ts

@@ -0,0 +1,82 @@
+import { AuthApi, AuthApiSettingsInterface } from "../../../../base/auth-api";
+import {
+  LicensesInterface,
+  LicenseInterface,
+  LicensesFiltersInterface,
+} from "../../../api-facade/v1/licenses";
+import { id } from "../../../../base/types";
+
+class Licenses extends AuthApi implements LicensesInterface {
+  constructor(settings: AuthApiSettingsInterface) {
+    super(settings);
+    this.getLicenses = this.getLicenses.bind(this);
+    this.getLicense = this.getLicense.bind(this);
+    this.createLicense = this.createLicense.bind(this);
+    this.updateLicense = this.updateLicense.bind(this);
+    this.deleteLicense = this.deleteLicense.bind(this);
+  }
+
+  static apiEndpoint = "licenses/sources/";
+
+  getLicenses(
+    filters: LicensesFiltersInterface = {}
+  ): Promise<LicenseInterface[]> {
+    const getFiltersData = ({
+      q,
+      limit,
+      offset,
+      date_from,
+      date_to,
+      is_bound,
+    }: LicensesFiltersInterface = {}): Record<string, unknown> => ({
+      q,
+      limit,
+      offset,
+      date_from,
+      date_to,
+      is_bound,
+    });
+
+    return this.httpClient.get(
+      this.authURL + Licenses.apiEndpoint,
+      getFiltersData(filters)
+    );
+  }
+
+  getLicense(licenseId: id): Promise<LicenseInterface> {
+    return this.httpClient.get(
+      this.authURL + `${Licenses.apiEndpoint}${licenseId}/`
+    );
+  }
+
+  createLicense({
+    name,
+    entry_storage_days,
+  }: LicenseInterface = {}): Promise<LicenseInterface> {
+    return this.httpClient.post(this.authURL + Licenses.apiEndpoint, {
+      name,
+      entry_storage_days,
+    });
+  }
+
+  updateLicense({
+    id,
+    name,
+    entry_storage_days,
+    is_active,
+  }: LicenseInterface = {}): Promise<LicenseInterface> {
+    return this.httpClient.put(this.authURL + `${Licenses.apiEndpoint}${id}/`, {
+      name,
+      entry_storage_days,
+      is_active,
+    });
+  }
+
+  deleteLicense(licenseId: id): Promise<null> {
+    return this.httpClient.delete(
+      this.authURL + `${Licenses.apiEndpoint}${licenseId}/`
+    );
+  }
+}
+
+export { Licenses };