@neuralinnovations/dataisland-sdk 0.0.1-dev8 → 0.0.1-dev80

package/src/storages/library/libraries.impl.ts

@@ -0,0 +1,209 @@
+import { Libraries, LibraryManagement } from "./libraries"
+import { Library } from "./library"
+import { LibraryImpl } from "./library.impl"
+import { Context } from "../../context"
+import {
+  CreateLibraryResponse,
+  LibrariesResponse, LibraryDto, LibraryResponse
+} from "../../dto/libraryResponse"
+import { RpcService } from "../../services/rpcService"
+import { ResponseUtils } from "../../services/responseUtils"
+import { OrganizationId } from "../organizations/organizations"
+import { LibraryId } from "./libraryId"
+
+export class LibraryManagementImpl extends LibraryManagement {
+  private context: Context
+
+  constructor(context: Context) {
+    super()
+    this.context = context
+  }
+
+  async createLibrary(name: string, region: number, isPublic: boolean): Promise<LibraryId> {
+    if (
+      name === undefined ||
+      name === null ||
+      name.trim() === ""
+    ) {
+      throw new Error("Name for library is required, must be not empty")
+    }
+
+    if (
+      isPublic === undefined ||
+      isPublic === null
+    ) {
+      throw new Error("IsPublic is required, must be not empty")
+    }
+
+    // send create request to the server
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/libraries/management")
+      .sendPostJson({
+        name: name,
+        region: region,
+        isPublic: isPublic
+      })
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError(`Failed to create library ${name}`, response)
+    }
+
+    const library = (await response!.json()) as CreateLibraryResponse
+
+    return library.libraryId
+  }
+
+  async addOrgToLibrary(libraryId: LibraryId, organizationId: OrganizationId): Promise<void> {
+    if (libraryId === undefined || libraryId === null) {
+      throw new Error("Organization add to library, libraryId is undefined or null")
+    }
+    if (libraryId.length === 0 || libraryId.trim().length === 0) {
+      throw new Error("Organization add to from library, libraryId is empty")
+    }
+    if (organizationId === undefined || organizationId === null) {
+      throw new Error("Organization add to from library, organizationId is undefined or null")
+    }
+    if (organizationId.length === 0 || organizationId.trim().length === 0) {
+      throw new Error("Organization add to from library, organizationId is empty")
+    }
+
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/libraries/management/allowed/organization")
+      .sendPutJson({
+        libraryId: libraryId,
+        organizationId: organizationId
+      })
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError(
+        `Organization ${organizationId} add to library ${libraryId} failed`,
+        response
+      )
+    }
+  }
+
+  async getLibraries(): Promise<LibraryDto[]> {
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/libraries/management/allowed/organizations")
+      .sendGet()
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError(
+        "Can not get libraries",
+        response
+      )
+    }
+
+    // parse libraries from the server's response
+    const libraries = (await response!.json()) as LibraryResponse
+
+    return libraries.libraries
+  }
+
+  async deleteOrgFromLibrary(libraryId: LibraryId, organizationId: OrganizationId): Promise<void> {
+    if (libraryId === undefined || libraryId === null) {
+      throw new Error("Organization delete from library, libraryId is undefined or null")
+    }
+    if (libraryId.length === 0 || libraryId.trim().length === 0) {
+      throw new Error("Organization delete from library, libraryId is empty")
+    }
+    if (organizationId === undefined || organizationId === null) {
+      throw new Error("Organization delete from library, organizationId is undefined or null")
+    }
+    if (organizationId.length === 0 || organizationId.trim().length === 0) {
+      throw new Error("Organization delete from library, organizationId is empty")
+    }
+
+    // send request to the server
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/libraries/management/allowed/organization")
+      .searchParam("libraryId", libraryId)
+      .searchParam("organizationId", organizationId)
+      .sendDelete()
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError(
+        `Organization ${organizationId} delete from library ${libraryId}, failed`,
+        response
+      )
+    }
+  }
+
+  async deleteLibrary(libraryId: LibraryId): Promise<void> {
+    if (libraryId === undefined || libraryId === null) {
+      throw new Error("Library delete, libraryId is undefined or null")
+    }
+    if (libraryId.length === 0 || libraryId.trim().length === 0) {
+      throw new Error("Library delete, libraryId is empty")
+    }
+
+    // send request to the server
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/libraries/management")
+      .searchParam("libraryId", libraryId)
+      .sendDelete()
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError(
+        `Library ${libraryId} delete, failed`,
+        response
+      )
+    }
+  }
+}
+
+export class LibrariesImpl extends Libraries {
+  private readonly _libraries: LibraryImpl[] = []
+  private readonly _management
+
+  constructor(
+    private readonly context: Context
+  ) {
+    super()
+    this._management = new LibraryManagementImpl(context)
+  }
+
+  async initialize() {
+    // fetch limits
+    const response = await this.context.resolve(RpcService)
+      ?.requestBuilder("api/v1/libraries")
+      .sendGet()
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError("Failed to get libraries", response)
+    }
+
+    const json = await response!.json()
+
+    // parse limits from the server's response
+    const libraries = (json as LibrariesResponse).libraries
+
+    for (const library of libraries) {
+      const impl = new LibraryImpl(this.context)
+      await impl.initFrom(library)
+      this._libraries.push(impl)
+    }
+  }
+
+  get collection(): readonly Library[] {
+    return this._libraries
+  }
+
+  getLibraryById(libraryId: LibraryId): Library | undefined {
+    return this._libraries.find((library) => library.id === libraryId)
+  }
+
+  get management(): LibraryManagement {
+    return this._management
+  }
+
+}

package/src/storages/library/libraries.ts

@@ -0,0 +1,56 @@
+import { Library } from "./library"
+import { OrganizationId } from "../organizations/organizations"
+import { LibraryDto } from "../../dto/libraryResponse"
+import { LibraryId } from "./libraryId"
+
+/**
+ * Library management, you must have permissions to manage libraries
+ */
+export abstract class LibraryManagement {
+  /**
+   * Create a new library
+   */
+  abstract createLibrary(name: string, region: number, isPublic: boolean): Promise<LibraryId>
+
+  /**
+   * Add permission for an organization to share its data through the library
+   */
+  abstract addOrgToLibrary(libraryId: LibraryId, organizationId: OrganizationId): Promise<void>
+
+  /**
+   * Get all libraries
+   */
+  abstract getLibraries(): Promise<LibraryDto[]>
+
+  /**
+   * Delete permission for an organization to share its data through the library
+   */
+  abstract deleteOrgFromLibrary(libraryId: LibraryId, organizationId: OrganizationId): Promise<void>
+
+  /**
+   * Delete a library by id
+   */
+  abstract deleteLibrary(libraryId: LibraryId): Promise<void>
+}
+
+/**
+ * Libraries
+ */
+export abstract class Libraries {
+
+  /**
+   * Collection of libraries
+   */
+  abstract get collection(): ReadonlyArray<Library>
+
+  /**
+   * Get library by id
+   * @param libraryId
+   */
+  abstract getLibraryById(libraryId: LibraryId): Library | undefined
+
+  /**
+   * You must have permissions to manage libraries
+   */
+  abstract get management(): LibraryManagement
+}

package/src/storages/library/library.impl.ts

@@ -0,0 +1,151 @@
+import { Library } from "./library"
+import {
+  LibraryFolderDto,
+  LibraryFolderResponse,
+  LibraryPageResponse
+} from "../../dto/libraryResponse"
+import { LibraryPage } from "./libraryPage"
+import { RpcService } from "../../services/rpcService"
+import { ResponseUtils } from "../../services/responseUtils"
+import { FileImpl } from "../files/file.impl"
+import { Context } from "../../context"
+import { LibraryPageImpl } from "./libraryPage.impl"
+import { LibraryFolderImpl } from "./libraryFolder.impl"
+import { LibraryFolder } from "./libraryFolder"
+import { FolderId } from "./folderId"
+import { LibraryId } from "./libraryId"
+
+export class LibraryImpl extends Library {
+
+  private _library?: LibraryFolderDto
+
+  public root?: LibraryPage
+
+  constructor(
+    private readonly context: Context
+  ) {
+    super()
+  }
+
+  async initFrom(library: LibraryFolderDto) {
+    this._library = library
+  }
+
+  get id(): LibraryId {
+    if (this._library) {
+      return this._library.id
+    }
+    throw new Error("Library is not loaded.")
+  }
+
+  get name(): string {
+    if (this._library) {
+      return this._library.name
+    }
+    throw new Error("Library is not loaded.")
+  }
+
+  async getFolder(folderId: FolderId): Promise<LibraryFolder> {
+    if (folderId === undefined || folderId === null || folderId.trim() === "") {
+      throw new Error("Query library folder, folderId is undefined or null")
+    }
+
+    // send request to the server
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/libraries/folder")
+      .searchParam("libraryId", this.id)
+      .searchParam("folderId", folderId)
+      .sendGet()
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError(
+        `Query library folder for ${folderId} failed`,
+        response
+      )
+    }
+
+    // parse files from the server's response
+    const folder = (await response!.json()) as LibraryFolderResponse
+
+    const libFolder = new LibraryFolderImpl(this, this.context)
+
+    await libFolder.initFrom(folder.folder)
+
+    return libFolder
+  }
+
+  async query(query: string, page: number, limit: number): Promise<LibraryPage> {
+    // check page
+    if (page === undefined || page === null) {
+      throw new Error("Query library root, page is undefined or null")
+    }
+    if (page < 0) {
+      throw new Error("Query library root, page is negative")
+    }
+
+    // check limit
+    if (limit === undefined || limit === null) {
+      throw new Error("Query library root, limit is undefined or null")
+    }
+    if (limit === 0) {
+      throw new Error("Query library root, limit is 0")
+    }
+
+    // send request to the server
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/libraries/content/list")
+      .searchParam("libraryId", this.id)
+      .searchParam("nodeId", "")
+      .searchParam("query", query)
+      .searchParam("page", page.toString())
+      .searchParam("limit", limit.toString())
+      .sendGet()
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError(
+        `Query library root :${query}, page:${page}, limit:${limit}, failed`,
+        response
+      )
+    }
+
+    // parse files from the server's response
+    const pageResponse = (await response!.json()) as LibraryPageResponse
+
+    // create files list
+    const root = new LibraryPageImpl()
+    root.total = pageResponse.totalItemsCount
+    root.filesPerPage = pageResponse.itemsPerPage
+    root.page = page
+
+    // init files from the server's response
+    for (const fl of pageResponse.files) {
+
+      // create file implementation
+      const file = await new FileImpl(this.context).initFrom(fl)
+
+      // add file to the collection
+      root.files.push(file)
+    }
+
+    for (const flr of pageResponse.folders) {
+
+      // create folder implementation
+      const folder = new LibraryFolderImpl(this, this.context)
+
+      await folder.initFrom(flr)
+
+      // add folder to the collection
+      root.folders.push(folder)
+    }
+
+    // set files list
+    this.root = root
+
+    return root
+  }
+
+}

package/src/storages/library/library.ts

@@ -0,0 +1,30 @@
+import { LibraryPage } from "./libraryPage"
+import { LibraryFolder } from "./libraryFolder"
+import { FolderId } from "./folderId"
+import { LibraryId } from "./libraryId"
+
+/**
+ * Library.
+ */
+export abstract class Library {
+
+  /**
+   * Library id.
+   */
+  abstract get id(): LibraryId
+
+  /**
+   * Library name.
+   */
+  abstract get name(): string
+
+  /**
+   * Get library folder by id.
+   */
+  abstract getFolder(folderId: FolderId): Promise<LibraryFolder>
+
+  /**
+   * Get library folders by query.
+   */
+  abstract query(query: string, page: number, limit: number): Promise<LibraryPage>
+}

package/src/storages/library/libraryFolder.impl.ts

@@ -0,0 +1,144 @@
+import { LibraryFolder } from "./libraryFolder"
+import { LibraryPage } from "./libraryPage"
+import { Context } from "../../context"
+import {
+  LibraryFolderDto,
+  LibraryPageResponse
+} from "../../dto/libraryResponse"
+import { LibraryImpl } from "./library.impl"
+import { RpcService } from "../../services/rpcService"
+import { ResponseUtils } from "../../services/responseUtils"
+import { LibraryPageImpl, LibraryParentImpl } from "./libraryPage.impl"
+import { FileImpl } from "../files/file.impl"
+import { FolderId } from "./folderId"
+import { LibraryId } from "./libraryId"
+
+export class LibraryFolderImpl extends LibraryFolder {
+  private _libFolder?: LibraryFolderDto
+
+  constructor(
+    private readonly libraryImpl: LibraryImpl,
+    private readonly context: Context
+  ) {
+    super()
+  }
+
+  async initFrom(libFolder: LibraryFolderDto) {
+    this._libFolder = libFolder
+  }
+
+  get iconId(): string {
+    if (this._libFolder) {
+      return this._libFolder.iconId
+    }
+    throw new Error("LibraryFolder is not loaded.")
+  }
+
+  itemsCount(): Promise<number> {
+    return Promise.resolve(0)
+  }
+
+  get libraryId(): LibraryId {
+    return this.libraryImpl.id
+  }
+
+  get name(): string {
+    if (this._libFolder) {
+      return this._libFolder.name
+    }
+    throw new Error("LibraryFolder is not loaded.")
+  }
+
+  get description(): string {
+    if (this._libFolder) {
+      return this._libFolder.description
+    }
+    throw new Error("LibraryFolder is not loaded.")
+  }
+
+  get folderId(): FolderId {
+    if (this._libFolder) {
+      return this._libFolder.id
+    }
+    throw new Error("LibraryFolder is not loaded.")
+  }
+
+  async query(query: string, page: number, limit: number): Promise<LibraryPage> {
+    if (page === undefined || page === null) {
+      throw new Error("Query library folder, page is undefined or null")
+    }
+    if (page < 0) {
+      throw new Error("Query library folder, page is negative")
+    }
+
+    // check limit
+    if (limit === undefined || limit === null) {
+      throw new Error("Query library folder, limit is undefined or null")
+    }
+    if (limit === 0) {
+      throw new Error("Query library folder, limit is 0")
+    }
+
+    // send request to the server
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/libraries/content/list")
+      .searchParam("libraryId", this.libraryId)
+      .searchParam("folderId", this.folderId)
+      .searchParam("query", query)
+      .searchParam("page", page.toString())
+      .searchParam("limit", limit.toString())
+      .sendGet()
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError(
+        `Query library folder :${query}, page:${page}, limit:${limit}, failed`,
+        response
+      )
+    }
+
+    // parse files from the server's response
+    const libPageResponse = (await response!.json()) as LibraryPageResponse
+
+    // create files list
+    const libraryPage = new LibraryPageImpl()
+    libraryPage.total = libPageResponse.totalItemsCount
+    libraryPage.filesPerPage = libPageResponse.itemsPerPage
+    libraryPage.page = page
+    libraryPage.libraryId = this.libraryId
+
+    const parentsWait = []
+    for (const parentId of libPageResponse.parentIds) {
+      parentsWait.push(this.libraryImpl.getFolder(parentId))
+    }
+    const parents = await Promise.all(parentsWait)
+    for (const parent of parents) {
+      libraryPage.parents.push(new LibraryParentImpl(parent.folderId, parent.name))
+    }
+
+    // init files from the server's response
+    for (const fl of libPageResponse.files) {
+
+      // create file implementation
+      const file = await new FileImpl(this.context).initFrom(fl)
+
+      // add file to the collection
+      libraryPage.files.push(file)
+    }
+
+    for (const flr of libPageResponse.folders) {
+
+      // create folder implementation
+      const folder = new LibraryFolderImpl(this.libraryImpl, this.context)
+
+      await folder.initFrom(flr)
+
+      // add folder to the collection
+      libraryPage.folders.push(folder)
+    }
+
+    return libraryPage
+  }
+
+}

package/src/storages/library/libraryFolder.ts

@@ -0,0 +1,23 @@
+import { LibraryPage } from "./libraryPage"
+import { FolderId } from "./folderId"
+import { LibraryId } from "./libraryId"
+
+export abstract class LibraryFolder {
+
+  abstract get libraryId(): LibraryId
+
+  abstract get folderId(): FolderId
+
+  abstract get name(): string
+
+  abstract get description(): string
+
+  abstract get iconId(): string
+
+  abstract itemsCount(): Promise<number>
+
+  /**
+   * Query files.
+   */
+  abstract query(query: string, page: number, limit: number): Promise<LibraryPage>
+}

package/src/storages/library/libraryId.ts

@@ -0,0 +1 @@
+export type LibraryId = string

package/src/storages/library/libraryPage.impl.ts

@@ -0,0 +1,39 @@
+import { LibraryPage, LibraryParent } from "./libraryPage"
+import { LibraryFolder } from "./libraryFolder"
+import { File } from "../files/file"
+import { FolderId } from "./folderId"
+
+export class LibraryParentImpl extends LibraryParent {
+  /**
+   * Get parent id.
+   */
+  public id: FolderId
+
+  /**
+   * Get parent name.
+   */
+  public name: string
+
+  constructor(id: FolderId, name: string) {
+    super()
+    this.id = id
+    this.name = name
+  }
+}
+
+export class LibraryPageImpl extends LibraryPage {
+
+  public libraryId: string = ""
+  public parents: LibraryParent[] = []
+  public files: File[] = []
+  public folders: LibraryFolder[] = []
+
+  public total: number = 0
+  public filesPerPage: number = 0
+  public page: number = 0
+
+  get pages(): number {
+    return Math.ceil(Math.max(this.total / this.filesPerPage, 1.0))
+  }
+
+}