@serptech/api 1.0.0

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

@@ -0,0 +1,100 @@
+import { Api, ApiSettingsInterface } from "../../../../base/api";
+import { id } from "../../../../base/types";
+
+import {
+  NotificationsInterface,
+  NotificationInterface,
+  NotificationsFiltersInterface,
+} from "../../../api-facade/v1/notifications";
+
+class Notifications extends Api implements NotificationsInterface {
+  constructor(settings: ApiSettingsInterface) {
+    super(settings);
+    this.getNotifications = this.getNotifications.bind(this);
+    this.getNotification = this.getNotification.bind(this);
+    this.createNotification = this.createNotification.bind(this);
+    this.updateNotification = this.updateNotification.bind(this);
+    this.deleteNotification = this.deleteNotification.bind(this);
+  }
+
+  static apiEndpoint = "notifications/";
+
+  static getNotificationData = ({
+    name,
+    is_active,
+    http_method,
+    destination_url,
+    results,
+    age_from,
+    age_to,
+    sex,
+    moods,
+    sources,
+    persons_groups,
+    liveness,
+  }: NotificationInterface = {}): {} => ({
+    name,
+    is_active,
+    http_method,
+    destination_url,
+    results,
+    age_from,
+    age_to,
+    sex,
+    moods,
+    sources,
+    persons_groups,
+    liveness,
+  });
+
+  getNotifications(filters: NotificationsFiltersInterface = {}): Promise<null> {
+    const getFiltersData = ({
+      q,
+      limit,
+      offset,
+      spaces_ids,
+    }: NotificationsFiltersInterface): {} => ({
+      q,
+      limit,
+      offset,
+      spaces_ids,
+    });
+
+    return this.httpClient.get(
+      Notifications.apiEndpoint,
+      getFiltersData(filters)
+    );
+  }
+
+  getNotification(notificationId: id): Promise<NotificationInterface> {
+    return this.httpClient.get(
+      `${Notifications.apiEndpoint}${notificationId}/`
+    );
+  }
+
+  createNotification(
+    data: NotificationInterface
+  ): Promise<NotificationInterface> {
+    return this.httpClient.post(
+      Notifications.apiEndpoint,
+      Notifications.getNotificationData(data)
+    );
+  }
+
+  updateNotification({ id, ...restData }: NotificationInterface = {}): Promise<
+    NotificationInterface
+  > {
+    return this.httpClient.put(
+      `${Notifications.apiEndpoint}${id}/`,
+      Notifications.getNotificationData(restData)
+    );
+  }
+
+  deleteNotification(notificationId: id): Promise<null> {
+    return this.httpClient.delete(
+      `${Notifications.apiEndpoint}${notificationId}/`
+    );
+  }
+}
+
+export { Notifications };

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

@@ -0,0 +1,110 @@
+import { Api, ApiSettingsInterface } from "../../../../base/api";
+
+import { addFileToFormData, addDataToFormData } from "../../../../utils";
+import {
+  SearchPersonByImageParamsInterface,
+  PersonsInterface,
+  CreatePersonParamsInterface,
+  // ReinitializePersonByEntryParamsInterface,
+  ReinitializePersonByImageParamsInterface,
+  // CreatePersonFromEntryParamsInterface,
+  PersonResponseIterface,
+} from "../../../api-facade/v1/persons";
+
+class Persons extends Api implements PersonsInterface {
+  constructor(settings: ApiSettingsInterface) {
+    super(settings);
+    this.searchPersonByImage = this.searchPersonByImage.bind(this);
+    this.createPerson = this.createPerson.bind(this);
+    // this.createPersonFromEntry = this.createPersonFromEntry.bind(this);
+    this.deletePerson = this.deletePerson.bind(this);
+    // this.reinitializePersonByEntry = this.reinitializePersonByEntry.bind(this);
+    this.reinitializePersonByImage = this.reinitializePersonByImage.bind(this);
+  }
+
+  static apiEndpoint = "profiles/";
+
+  searchPersonByImage({
+    image,
+    identify_asm,
+  }: SearchPersonByImageParamsInterface): Promise<PersonResponseIterface> {
+    if (!image) return Promise.reject("No image provided");
+
+    const fieldsData = { identify_asm };
+    const data = new FormData();
+
+    addFileToFormData(data, image, "image");
+    addDataToFormData(data, fieldsData);
+
+    return this.httpClient.post(`${Persons.apiEndpoint}search/`, data);
+  }
+
+  createPerson({
+    image,
+    origin_id,
+    create_min_facesize,
+    create_ha,
+    create_junk,
+    identify_asm,
+  }: CreatePersonParamsInterface): Promise<PersonResponseIterface> {
+    const fieldsData = {
+      origin_id,
+      create_min_facesize,
+      create_ha,
+      create_junk,
+      identify_asm,
+    };
+    const data = new FormData();
+
+    addFileToFormData(data, image, "image");
+    addDataToFormData(data, fieldsData);
+
+    return this.httpClient.post(Persons.apiEndpoint, data);
+  }
+
+  // createPersonFromEntry({
+  //   entryId,
+  //   create_on_ha,
+  //   create_on_junk,
+  // }: CreatePersonFromEntryParamsInterface): Promise<null> {
+  //   return this.httpClient.post(`${Persons.apiEndpoint}entry/`, {
+  //     id: entryId,
+  //     create_on_ha,
+  //     create_on_junk,
+  //   });
+  // }
+
+  deletePerson(pid: string): Promise<null> {
+    return this.httpClient.delete(`${Persons.apiEndpoint}${pid}/`);
+  }
+
+  // reinitializePersonByEntry({
+  //   entryId,
+  // }: ReinitializePersonByEntryParamsInterface): Promise<null> {
+  //   if (!entryId) return Promise.reject("No entry id provided");
+  //
+  //   return this.httpClient.post(`${Persons.apiEndpoint}reinit/`, {
+  //     id: entryId,
+  //   });
+  // }
+
+  reinitializePersonByImage({
+    pid,
+    image,
+    min_conf,
+    identify_asm,
+    create_min_facesize,
+  }: ReinitializePersonByImageParamsInterface): Promise<null> {
+    if (!image) return Promise.reject("No image provided");
+
+    const fieldsData = { min_conf, create_min_facesize, identify_asm };
+    const data = new FormData();
+
+    addFileToFormData(data, image, "image");
+    addDataToFormData(data, fieldsData);
+
+    return this.httpClient.post(`${Persons.apiEndpoint}${pid}/reinit/`, data);
+  }
+}
+
+export { Persons };

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

@@ -0,0 +1,128 @@
+import { Api, ApiSettingsInterface } from "../../../../base/api";
+
+import {
+  PersonsGroupsInterface,
+  GetPersonsGroupsFiltersInterface,
+  PersonsGroupInterface,
+  GetPersonsGroupPersonsFiltersInterface,
+  AddPersonsToPersonsGroupsParamsInterface,
+  RemovePersonsFromPersonsGroupsParamsInterface,
+} from "../../../api-facade/v1/persons-groups";
+import { id } from "../../../../base/types";
+
+class PersonsGroups extends Api implements PersonsGroupsInterface {
+  constructor(settings: ApiSettingsInterface) {
+    super(settings);
+    this.getPersonsGroups = this.getPersonsGroups.bind(this);
+    this.getPersonsGroup = this.getPersonsGroup.bind(this);
+    this.createPersonsGroup = this.createPersonsGroup.bind(this);
+    this.updatePersonsGroup = this.updatePersonsGroup.bind(this);
+    this.deletePersonsGroup = this.deletePersonsGroup.bind(this);
+    this.getPersonsGroupPersons = this.getPersonsGroupPersons.bind(this);
+    this.addPersonsToPersonsGroups = this.addPersonsToPersonsGroups.bind(this);
+    this.removePersonsFromPersonsGroups = this.removePersonsFromPersonsGroups.bind(
+      this
+    );
+  }
+
+  static apiEndpoint = "groups/profiles/";
+
+  static getPersonsGroupData = ({ name }: PersonsGroupInterface = {}): {} => ({
+    name,
+  });
+
+  getPersonsGroups(filters: GetPersonsGroupsFiltersInterface): Promise<null> {
+    const getFiltersData = ({
+      q,
+      limit,
+      offset,
+      groups_ids,
+      spaces_ids,
+      person_ids_include,
+      person_ids_exclude,
+    }: GetPersonsGroupsFiltersInterface = {}): {} => ({
+      q,
+      limit,
+      offset,
+      groups_ids,
+      spaces_ids,
+      person_ids_include,
+      person_ids_exclude,
+    });
+
+    return this.httpClient.get(
+      PersonsGroups.apiEndpoint,
+      getFiltersData(filters)
+    );
+  }
+
+  getPersonsGroup(personGroupId: id): Promise<PersonsGroupInterface> {
+    return this.httpClient.get(`${PersonsGroups.apiEndpoint}${personGroupId}/`);
+  }
+
+  createPersonsGroup(
+    personsGroup: PersonsGroupInterface
+  ): Promise<PersonsGroupInterface> {
+    return this.httpClient.post(
+      PersonsGroups.apiEndpoint,
+      PersonsGroups.getPersonsGroupData(personsGroup)
+    );
+  }
+
+  updatePersonsGroup({ id, ...restData }: PersonsGroupInterface = {}): Promise<
+    PersonsGroupInterface
+  > {
+    return this.httpClient.put(
+      `${PersonsGroups.apiEndpoint}${id}/`,
+      PersonsGroups.getPersonsGroupData(restData)
+    );
+  }
+
+  deletePersonsGroup(personGroupId: id): Promise<null> {
+    return this.httpClient.delete(
+      `${PersonsGroups.apiEndpoint}${personGroupId}/`
+    );
+  }
+
+  getPersonsGroupPersons({
+    groupId,
+    ...filters
+  }: GetPersonsGroupPersonsFiltersInterface = {}): Promise<null> {
+    const getFiltersData = ({
+      limit,
+      offset,
+      person_ids,
+    }: GetPersonsGroupPersonsFiltersInterface = {}): {} => ({
+      limit,
+      offset,
+      person_ids,
+    });
+
+    return this.httpClient.get(
+      `${PersonsGroups.apiEndpoint}${groupId}/person_ids/`,
+      getFiltersData(filters)
+    );
+  }
+
+  addPersonsToPersonsGroups({
+    groupsIds,
+    persons,
+  }: AddPersonsToPersonsGroupsParamsInterface = {}): Promise<null> {
+    return this.httpClient.post(`${PersonsGroups.apiEndpoint}person_ids/`, {
+      groups_ids: groupsIds,
+      person_ids: persons,
+    });
+  }
+
+  removePersonsFromPersonsGroups({
+    groupsIds,
+    persons,
+  }: RemovePersonsFromPersonsGroupsParamsInterface = {}): Promise<null> {
+    return this.httpClient.delete(`${PersonsGroups.apiEndpoint}person_ids/`, null, {
+      groups_ids: groupsIds,
+      person_ids: persons,
+    });
+  }
+}
+
+export { PersonsGroups };

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

@@ -0,0 +1,113 @@
+import { Api, ApiSettingsInterface } from "../../../../base/api";
+import {
+  SourcesInterface,
+  SourceInterface,
+  SourcesFiltersInterface,
+} from "../../../api-facade/v1/sources";
+import { id } from "../../../../base/types";
+
+class Sources extends Api implements SourcesInterface {
+  constructor(settings: ApiSettingsInterface) {
+    super(settings);
+    this.getSources = this.getSources.bind(this);
+    this.getSource = this.getSource.bind(this);
+    this.createSource = this.createSource.bind(this);
+    this.updateSource = this.updateSource.bind(this);
+    this.deleteSource = this.deleteSource.bind(this);
+  }
+
+  static apiEndpoint = "origins/";
+
+  static getSourceData = ({
+    name,
+    identify_facesize_threshold,
+    use_pps_timestamp,
+
+    manual_create_facesize_threshold,
+    manual_create_on_ha,
+    manual_create_on_junk,
+    manual_identify_asm,
+
+    auto_create_persons,
+    auto_create_facesize_threshold,
+    auto_create_check_blur,
+    auto_create_check_exposure,
+    auto_create_on_ha,
+    auto_create_on_junk,
+    auto_check_face_angle,
+    auto_check_liveness,
+    auto_create_liveness_only,
+    auto_identify_asm,
+
+    store_images_for_results,
+    license_id,
+    license,
+  }: SourceInterface = {}): {} => ({
+    name,
+    identify_facesize_threshold,
+    use_pps_timestamp,
+
+    manual_create_facesize_threshold,
+    manual_create_on_ha,
+    manual_create_on_junk,
+    manual_identify_asm,
+
+    auto_create_persons,
+    auto_create_facesize_threshold,
+    auto_create_check_blur,
+    auto_create_check_exposure,
+    auto_create_on_ha,
+    auto_create_on_junk,
+    auto_check_face_angle,
+    auto_check_liveness,
+    auto_create_liveness_only,
+    auto_identify_asm,
+
+    store_images_for_results,
+    license_id,
+    license,
+  });
+
+  getSources(filters: SourcesFiltersInterface = {}): Promise<null> {
+    const getFiltersData = ({
+      q,
+      limit,
+      offset,
+      spaces_ids,
+    }: SourcesFiltersInterface = {}): {} => ({
+      q,
+      limit,
+      offset,
+      spaces_ids,
+    });
+
+    return this.httpClient.get(Sources.apiEndpoint, getFiltersData(filters));
+  }
+
+  getSource(sourceId: id): Promise<SourceInterface> {
+    return this.httpClient.get(`${Sources.apiEndpoint}${sourceId}/`);
+  }
+
+  createSource(data: SourceInterface): Promise<SourceInterface> {
+    return this.httpClient.post(
+      Sources.apiEndpoint,
+      Sources.getSourceData(data)
+    );
+  }
+
+  updateSource({
+    id,
+    ...restData
+  }: SourceInterface = {}): Promise<SourceInterface> {
+    return this.httpClient.put(
+      `${Sources.apiEndpoint}${id}/`,
+      Sources.getSourceData(restData)
+    );
+  }
+
+  deleteSource(sourceId: id): Promise<null> {
+    return this.httpClient.delete(`${Sources.apiEndpoint}${sourceId}/`);
+  }
+}
+
+export { Sources };

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

@@ -0,0 +1,65 @@
+import { AuthApi, AuthApiSettingsInterface } from "../../../../base/auth-api";
+import {
+  SpaceInterface,
+  SpaceDataInterface,
+  SpacesInterface,
+  GetSpacesParamsInterface,
+  CreateSpaceTokenInterface,
+} from "../../../api-facade/v1/spaces";
+import { id } from "../../../../base/types";
+import { TokenInterface } from "../../../api-facade/v1/tokens";
+
+class Spaces extends AuthApi implements SpacesInterface {
+  constructor(settings: AuthApiSettingsInterface) {
+    super(settings);
+    this.getSpaces = this.getSpaces.bind(this);
+    this.getSpace = this.getSpace.bind(this);
+    this.createSpace = this.createSpace.bind(this);
+    this.updateSpace = this.updateSpace.bind(this);
+    this.deleteSpace = this.deleteSpace.bind(this);
+    this.createToken = this.createToken.bind(this);
+  }
+
+  static apiEndpoint = "spaces/";
+
+  static getSpaceData = ({ name }: SpaceDataInterface): { name: string } => ({
+    name,
+  });
+
+  getSpaces(params: GetSpacesParamsInterface): Promise<Array<SpaceInterface>> {
+    return this.httpClient.get(this.authURL + Spaces.apiEndpoint, params);
+  }
+
+  getSpace(id: id): Promise<SpaceInterface> {
+    return this.httpClient.get(this.authURL + `${Spaces.apiEndpoint}${id}/`);
+  }
+
+  createSpace(data: SpaceDataInterface): Promise<SpaceInterface> {
+    return this.httpClient.post(
+      this.authURL + Spaces.apiEndpoint,
+      Spaces.getSpaceData(data)
+    );
+  }
+
+  updateSpace(data: SpaceInterface): Promise<SpaceInterface> {
+    return this.httpClient.put(
+      this.authURL + `${Spaces.apiEndpoint}${data.id}/`,
+      Spaces.getSpaceData(data)
+    );
+  }
+
+  deleteSpace(id: id): Promise<null> {
+    return this.httpClient.delete(this.authURL + `${Spaces.apiEndpoint}${id}/`);
+  }
+
+  createToken(data: CreateSpaceTokenInterface): Promise<TokenInterface> {
+    const { id, ...restData } = data;
+
+    return this.httpClient.post(
+      this.authURL + `${Spaces.apiEndpoint}${id}/tokens/access/`,
+      restData
+    );
+  }
+}
+
+export { Spaces };

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

@@ -0,0 +1,76 @@
+import { Api, ApiSettingsInterface } from "../../../../base/api";
+import {
+  StreamTokensInterface,
+  StreamTokenInterface,
+  GetStreamTokenInterface,
+  GetStreamTokensParamsInterface,
+  UpdateStreamTokenParamsInterface,
+} from "../../../api-facade/v1/stream-tokens";
+import { id } from "../../../../base/types";
+
+class StreamTokens extends Api implements StreamTokensInterface {
+  constructor(settings: ApiSettingsInterface) {
+    super(settings);
+    this.getStreamTokens = this.getStreamTokens.bind(this);
+    this.getStreamToken = this.getStreamToken.bind(this);
+    this.createStreamToken = this.createStreamToken.bind(this);
+    this.updateStreamToken = this.updateStreamToken.bind(this);
+    this.deleteStreamToken = this.deleteStreamToken.bind(this);
+    this.deleteStreamTokens = this.deleteStreamTokens.bind(this);
+  }
+
+  static apiEndpoint = "tokens/streams/";
+
+  getStreamTokens(
+    params: GetStreamTokensParamsInterface
+  ): Promise<Array<StreamTokenInterface>> {
+    return this.httpClient.get(StreamTokens.apiEndpoint, params);
+  }
+
+  deleteStreamTokens(params: GetStreamTokensParamsInterface): Promise<null> {
+    const getFiltersData = ({
+      limit,
+      offset,
+      permanent,
+    }: GetStreamTokensParamsInterface = {}) => ({
+      limit,
+      offset,
+      permanent,
+    });
+
+    return this.httpClient.delete(
+      StreamTokens.apiEndpoint,
+      getFiltersData(params)
+    );
+  }
+
+  getStreamToken(id: id): Promise<StreamTokenInterface> {
+    return this.httpClient.get(`${StreamTokens.apiEndpoint}${id}/`);
+  }
+
+  createStreamToken(
+    data: GetStreamTokenInterface
+  ): Promise<StreamTokenInterface> {
+    const { permanent } = data || {};
+
+    return this.httpClient.post(StreamTokens.apiEndpoint, {
+      permanent,
+    });
+  }
+
+  updateStreamToken(
+    data: UpdateStreamTokenParamsInterface
+  ): Promise<StreamTokenInterface> {
+    const { id, is_active } = data || {};
+
+    return this.httpClient.put(`${StreamTokens.apiEndpoint}${id}/`, {
+      is_active,
+    });
+  }
+
+  deleteStreamToken(id: id): Promise<null> {
+    return this.httpClient.delete(`${StreamTokens.apiEndpoint}${id}/`);
+  }
+}
+
+export { StreamTokens };

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

@@ -0,0 +1,32 @@
+import { Api, ApiSettingsInterface } from "../../../../base/api";
+import {
+  ThresholdsClassInterface,
+  ThresholdsInterface,
+} from "../../../api-facade/v1/thresholds";
+
+class Thresholds extends Api implements ThresholdsClassInterface {
+  constructor(settings: ApiSettingsInterface) {
+    super(settings);
+    this.getThresholds = this.getThresholds.bind(this);
+    this.updateThresholds = this.updateThresholds.bind(this);
+    this.resetThresholds = this.resetThresholds.bind(this);
+  }
+
+  static apiEndpoint = "settings/thresholds/";
+
+  getThresholds(): Promise<ThresholdsInterface> {
+    return this.httpClient.get(Thresholds.apiEndpoint);
+  }
+
+  updateThresholds({ exact, ha, junk }: ThresholdsInterface = {}): Promise<
+    ThresholdsInterface
+  > {
+    return this.httpClient.put(Thresholds.apiEndpoint, { exact, ha, junk });
+  }
+
+  resetThresholds(): Promise<ThresholdsInterface> {
+    return this.httpClient.post(`${Thresholds.apiEndpoint}reset/`);
+  }
+}
+
+export { Thresholds };

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

@@ -0,0 +1,61 @@
+import { AuthApi, AuthApiSettingsInterface } from "../../../../base/auth-api";
+import {
+  TokenInterface,
+  TokensInterface,
+  GetTokensParamsInterface,
+  GetTokenInterface,
+  UpdateTokenParamsInterface,
+} from "../../../api-facade/v1/tokens";
+import { id } from "../../../../base/types";
+
+class Tokens extends AuthApi implements TokensInterface {
+  constructor(settings: AuthApiSettingsInterface) {
+    super(settings);
+    this.getTokens = this.getTokens.bind(this);
+    this.getToken = this.getToken.bind(this);
+    this.deleteTokens = this.deleteTokens.bind(this);
+    this.createToken = this.createToken.bind(this);
+    this.updateToken = this.updateToken.bind(this);
+    this.deleteToken = this.deleteToken.bind(this);
+  }
+
+  static apiEndpoint = "tokens/access/";
+
+  getTokens(params: GetTokensParamsInterface): Promise<Array<TokenInterface>> {
+    return this.httpClient.get(this.authURL + Tokens.apiEndpoint, params);
+  }
+
+  deleteTokens(data: GetTokenInterface): Promise<void> {
+    const { permanent } = data || {};
+
+    return this.httpClient.delete(this.authURL + Tokens.apiEndpoint, {
+      permanent,
+    });
+  }
+
+  getToken(id: id): Promise<TokenInterface> {
+    return this.httpClient.get(this.authURL + `${Tokens.apiEndpoint}${id}/`);
+  }
+
+  createToken(data: GetTokenInterface): Promise<TokenInterface> {
+    const { permanent } = data || {};
+
+    return this.httpClient.post(this.authURL + Tokens.apiEndpoint, {
+      permanent,
+    });
+  }
+
+  updateToken(data: UpdateTokenParamsInterface): Promise<TokenInterface> {
+    const { id, is_active } = data || {};
+
+    return this.httpClient.put(this.authURL + `${Tokens.apiEndpoint}${id}/`, {
+      is_active,
+    });
+  }
+
+  deleteToken(id: id): Promise<void> {
+    return this.httpClient.delete(this.authURL + `${Tokens.apiEndpoint}${id}/`);
+  }
+}
+
+export { Tokens };