@neuralinnovations/dataisland-sdk 0.0.1-dev74 → 0.0.1-dev75

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

@@ -0,0 +1,192 @@
+import {Libraries} from "./libraries"
+import {Library, LibraryId} 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"
+
+
+export class LibrariesImpl extends Libraries {
+  private readonly _libraries: LibraryImpl[] = []
+
+  constructor(
+    private readonly context: Context
+  ) {
+    super()
+  }
+
+  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
+  }
+
+  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
+      )
+    }
+  }
+
+}

package/src/storages/library/libraries.ts

@@ -0,0 +1,20 @@
+
+import {Library, LibraryId} from "./library"
+import {OrganizationId} from "../organizations/organizations"
+import {LibraryDto} from "../../dto/libraryResponse"
+
+
+export abstract class Libraries {
+
+  abstract get collection(): ReadonlyArray<Library>
+
+  abstract createLibrary(name: string, region: number, isPublic: boolean): Promise<LibraryId>
+
+  abstract addOrgToLibrary(libraryId: LibraryId, organizationId: OrganizationId): Promise<void>
+
+  abstract getLibraries(): Promise<LibraryDto[]>
+
+  abstract deleteOrgFromLibrary(libraryId: LibraryId, organizationId: OrganizationId): Promise<void>
+
+  abstract deleteLibrary(libraryId: LibraryId): Promise<void>
+}

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

@@ -0,0 +1,150 @@
+import {Library, LibraryId} 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 {FolderId, LibraryFolder} from "./libraryFolder"
+
+
+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.id
+    }
+    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,16 @@
+import {LibraryPage} from "./libraryPage"
+import {LibraryFolder, FolderId} from "./libraryFolder"
+
+export type LibraryId = string
+
+
+export abstract class Library {
+
+  abstract get id(): LibraryId
+
+  abstract get name(): string
+
+  abstract getFolder(folderId: FolderId): Promise<LibraryFolder>
+
+  abstract query(query: string, page: number, limit: number): Promise<LibraryPage>
+}

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

@@ -0,0 +1,136 @@
+import {LibraryFolder, FolderId} from "./libraryFolder"
+import {LibraryId} from "./library"
+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} from "./libraryPage.impl"
+import {FileImpl} from "../files/file.impl"
+
+
+export class LibraryFolderImpl extends  LibraryFolder {
+  private _libFolder?: LibraryFolderDto
+
+  public libraryPage?: LibraryPage
+
+  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 parents(): string[] {
+    if (this.libraryPage) {
+      return this.libraryPage.parents
+    }
+    throw new Error("Library page is not loaded, try query first")
+  }
+
+  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
+
+    // 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)
+    }
+
+    // set files list
+    this.libraryPage = libraryPage
+
+    return libraryPage
+  }
+
+}

package/src/storages/library/libraryFolder.ts

@@ -0,0 +1,25 @@
+import {LibraryId} from "./library"
+import {LibraryPage} from "./libraryPage"
+
+
+export type FolderId = string
+
+export abstract class LibraryFolder {
+
+  abstract get libraryId(): LibraryId
+
+  abstract get parents(): FolderId[]
+
+  abstract get folderId(): FolderId
+
+  abstract get name(): 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/libraryPage.impl.ts

@@ -0,0 +1,23 @@
+import {LibraryPage} from "./libraryPage"
+import {LibraryFolder} from "./libraryFolder"
+import {File} from "../files/file"
+
+
+export class LibraryPageImpl extends LibraryPage {
+
+  public parents: string[] = []
+
+  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))
+  }
+
+
+}

package/src/storages/library/libraryPage.ts

@@ -0,0 +1,37 @@
+import {LibraryFolder} from "./libraryFolder"
+import {File} from "../files/file"
+
+
+export abstract class LibraryPage {
+
+  /**
+   * Get current page.
+   */
+  abstract get parents(): string[]
+
+  /**
+   * Get page files.
+   */
+  abstract get files(): File[]
+
+  /**
+   * Get page folders
+   */
+  abstract get folders(): LibraryFolder[]
+
+  /**
+   * Get pages count.
+   */
+  abstract get pages(): number
+
+  /**
+   * Get total count.
+   */
+  abstract get total(): number
+
+  /**
+   * Get current page.
+   */
+  abstract get page(): number
+
+}

package/src/storages/workspaces/workspace.impl.ts

@@ -42,6 +42,13 @@ export class WorkspaceImpl extends Workspace {
     throw new Error("Workspace is not loaded.")
   }
 
+  get isShared(): boolean {
+    if (this._workspace) {
+      return this._workspace.isShared
+    }
+    throw new Error("Workspace is not loaded.")
+  }
+
   get files(): Files {
     return this._files
   }
@@ -115,6 +122,42 @@ export class WorkspaceImpl extends Workspace {
     })
   }
 
+  async share(isShared: boolean): Promise<void> {
+    if (!this._workspace) {
+      throw new Error("Workspace is not loaded.")
+    }
+    if (this._isMarkAsDeleted) {
+      throw new Error("Workspace is marked as deleted.")
+    }
+    if (isShared === this.isShared) {
+      return Promise.resolve()
+    }
+    if (isShared === undefined || isShared === null) {
+      throw new Error("Is shared parameter is required.")
+    }
+
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/workspaces/library")
+      .sendPutJson({
+        workspaceId: this.id,
+        isShared: isShared
+      })
+
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError("Failed to change workspace shared state", response)
+    }
+
+    if (this._workspace) {
+      this._workspace.isShared = isShared
+    }
+
+    this.dispatch({
+      type: WorkspaceEvent.CHANGED,
+      data: this
+    })
+  }
+
   async initFrom(workspace: WorkspaceDto) {
     this._workspace = workspace
   }

package/src/storages/workspaces/workspace.ts

@@ -37,6 +37,8 @@ export abstract class Workspace extends EventDispatcher<
    */
   abstract get description(): string
 
+  abstract get isShared(): boolean
+
   /**
    * Workspace files.
    */
@@ -51,4 +53,10 @@ export abstract class Workspace extends EventDispatcher<
    * Change workspace name and description.
    */
   abstract change(name: string, description: string): Promise<void>
+
+  /**
+   * Make workspace available for the library implementation
+   * @param isShared
+   */
+  abstract share(isShared: boolean): Promise<void>
 }