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

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.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,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/organizations/organization.impl.ts

@@ -104,6 +104,10 @@ export class OrganizationImpl extends Organization implements Disposable {
     return <string>this._content?.profile.iconId
   }
 
+  get isAllowedInLibraries(): boolean {
+    return <boolean>this._content?.profile.isAllowedInLibraries
+  }
+
   get workspaces(): Workspaces {
     return this._workspaces
   }

package/src/storages/organizations/organization.ts

@@ -52,6 +52,11 @@ export abstract class Organization extends EventDispatcher<
    */
   abstract get icon(): string
 
+  /**
+   * If organizations allowed in libraries
+   */
+  abstract get isAllowedInLibraries(): boolean
+
   /**
    * Workspaces.
    */

package/src/storages/queryFlows/queryFlow.impl.ts

@@ -54,7 +54,14 @@ export class QueryFlowImpl extends QueryFlow {
     if (this._id)
       return this._id
     else
-      throw new Error("Query fLow is not loaded")
+      throw new Error("Query flow is not loaded")
+  }
+
+  get name(): string {
+    if (this._content)
+      return this._content.name
+    else
+      throw new Error("Query flow is not loaded")
   }
 
   get resultUrl(): string {

package/src/storages/queryFlows/queryFlow.ts

@@ -13,6 +13,8 @@ export abstract class QueryFlow extends EventDispatcher<
 
   abstract get id(): FlowId
 
+  abstract get name(): string
+
   abstract get status(): QueryFlowStatus
 
   abstract get resultUrl(): string

package/src/storages/queryFlows/queryFlows.impl.ts

@@ -64,7 +64,10 @@ export class QueryFlowsImpl extends QueryFlows {
     return this._collection
   }
 
-  async create(workspaceId: WorkspaceId, fileId: FileId, file: UploadFile ): Promise<FlowId> {
+  async create(name: string, workspaceId: WorkspaceId, fileId: FileId, file: UploadFile ): Promise<FlowId> {
+    if (name === undefined || name === null || name.trim() === "") {
+      throw new Error("Name is required, must be not empty")
+    }
     if (workspaceId === undefined || workspaceId === null || workspaceId.trim() === "") {
       throw new Error("WorkspaceId is required, must be not empty")
     }
@@ -80,6 +83,7 @@ export class QueryFlowsImpl extends QueryFlows {
     form.append("organizationId", this.organization.id)
     form.append("workspaceId", workspaceId)
     form.append("fileId", fileId)
+    form.append("name", name)
     form.append("file", file, file.name)
 
     // send request to the server

package/src/storages/queryFlows/queryFlows.ts

@@ -25,7 +25,7 @@ export abstract class QueryFlows extends EventDispatcher<
 
   abstract get collection(): QueryFlow[]
 
-  abstract create(workspaceId: WorkspaceId, fileId: FileId, file: UploadFile ): Promise<FlowId>
+  abstract create(name: string, workspaceId: WorkspaceId, fileId: FileId, file: UploadFile ): Promise<FlowId>
 
   abstract delete(id: FlowId): Promise<void>
 

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
   }
@@ -81,12 +88,9 @@ export class WorkspaceImpl extends Workspace {
     }
     if (
       description === undefined ||
-      description === null ||
-      description.trim() === ""
+      description === null
     ) {
-      throw new Error(
-        "Description is required. Please provide a valid description."
-      )
+      description = ""
     }
 
     const response = await this.context
@@ -115,6 +119,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>
 }