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

package/src/storages/chats/chats.impl.ts

@@ -212,6 +212,98 @@ export class ChatsImpl extends Chats {
     return chat
   }
 
+  async createWithLibraryFolder(libraryId: string, folderIds: string[] | null = null): Promise<Chat | undefined>{
+    if (libraryId === undefined || libraryId === null || libraryId.trim() === "")  {
+      throw new Error("Create chat with library folder, library id is undefined, null or empty")
+    }
+
+    // send create request to the server
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/chats/library/folders")
+      .sendPostJson({
+        libraryId: libraryId,
+        folderIds: folderIds,
+        model: "search",
+        clientContext: "",
+      })
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      if (await ResponseUtils.isLimitReached()){
+        return undefined
+      }
+
+      await ResponseUtils.throwError(`Failed to create chat in library with folder, library: ${libraryId}`, response)
+    }
+
+    // parse workspace from the server's response
+    const content = (await response!.json() as {
+      chat: ChatDto
+    }).chat as ChatDto
+
+    // create workspace implementation
+    const chat = new ChatImpl(this.context, this.organization)
+    await chat.initFrom(content)
+
+    // add chat to the collection
+    this._chats.push(chat)
+
+    // dispatch event
+    this.dispatch({
+      type: ChatsEvent.ADDED,
+      data: chat
+    })
+
+    return chat
+  }
+
+  async createWithLibraryFile(libraryId: string, fileId: string): Promise<Chat | undefined>{
+    if (libraryId === undefined || libraryId === null || libraryId.trim() === "")  {
+      throw new Error("Create chat with library file, library id is undefined, null or empty")
+    }
+
+    // send create request to the server
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/chats/library/file")
+      .sendPostJson({
+        libraryId: libraryId,
+        fileId: fileId,
+        model: "search",
+        clientContext: "",
+      })
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      if (await ResponseUtils.isLimitReached()){
+        return undefined
+      }
+
+      await ResponseUtils.throwError(`Failed to create chat in library with file, library: ${libraryId}`, response)
+    }
+
+    // parse workspace from the server's response
+    const content = (await response!.json() as {
+      chat: ChatDto
+    }).chat as ChatDto
+
+    // create workspace implementation
+    const chat = new ChatImpl(this.context, this.organization)
+    await chat.initFrom(content)
+
+    // add chat to the collection
+    this._chats.push(chat)
+
+    // dispatch event
+    this.dispatch({
+      type: ChatsEvent.ADDED,
+      data: chat
+    })
+
+    return chat
+  }
+
 
 
 

package/src/storages/chats/chats.ts

@@ -40,6 +40,20 @@ export abstract class Chats extends EventDispatcher<ChatsEvent, Chat> {
    */
   abstract createWithWorkspace(workspaceIds: string[], clientContext: string): Promise<Chat | undefined>
 
+  /**
+   * Create chat with library folders
+   * @param libraryId
+   * @param folderIds
+   */
+  abstract createWithLibraryFolder(libraryId: string, folderIds: string[]): Promise<Chat | undefined>
+
+  /**
+   * Create chat with library file
+   * @param libraryId
+   * @param fileId
+   */
+  abstract createWithLibraryFile(libraryId: string, fileId: string): Promise<Chat | undefined>
+
   /**
    * Get chat by id.
    * @param id

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))
+  }
+
+
+}