@neuralinnovations/dataisland-sdk 0.0.1-dev9 → 0.1.0

package/src/storages/organizations/organization.ts

@@ -1,17 +1,48 @@
-import { Workspaces } from "../workspaces/workspaces"
+import { WorkspaceId, Workspaces } from "../workspaces/workspaces"
 import { OrganizationId } from "./organizations"
-import { GroupId, Groups } from "../groups/groups"
+import { Groups } from "../groups/groups"
 import { Chats } from "../chats/chats"
+import { EventDispatcher } from "../../events"
+import {
+  CurrentLimitsData,
+  UserDto,
+  UsersStatisticsResponse
+} from "../../dto/userInfoResponse"
+import { GroupId } from "../groups/group"
+import { StatisticsResponse } from "../../dto/statisticsResponse"
+import { SegmentData } from "../../dto/limitsResponse"
+import { FileId } from "../files/file"
+import { QuizData } from "../../dto/quizResponse"
+import { InviteResponse } from "../../dto/invitesResponse"
+import { OrganizationApiKey } from "../../dto/apiKeyResponse"
+import { UploadFile } from "../files/files"
+import { QueryFlows } from "../queryFlows/queryFlows"
+import { OrganizationPrompts } from "./organizationPrompts"
+
+/**
+ * Organization event.
+ */
+export enum OrganizationEvent {
+  CHANGED = "changed"
+}
 
 /**
  * Organization.
  */
-export abstract class Organization {
+export abstract class Organization extends EventDispatcher<
+  OrganizationEvent,
+  Organization
+> {
   /**
    * Organization id.
    */
   abstract get id(): OrganizationId
 
+  /**
+   * Is admin organization
+   */
+  abstract get isAdmin(): boolean
+
   /**
    * Organization name.
    */
@@ -22,6 +53,16 @@ export abstract class Organization {
    */
   abstract get description(): string
 
+  /**
+   * ID of organization icon
+   */
+  abstract get icon(): string
+
+  /**
+   * If organizations allowed in libraries
+   */
+  abstract get isAllowedInLibraries(): boolean
+
   /**
    * Workspaces.
    */
@@ -38,7 +79,128 @@ export abstract class Organization {
   abstract get accessGroups(): Groups
 
   /**
-   * Create invite link
+   * Query flows
+   */
+  abstract get queryFlows(): QueryFlows
+
+  /**
+   * Get organization prompts
+   */
+  abstract get prompts(): OrganizationPrompts
+
+  /**
+   * Get organization members
+   */
+  abstract members(): Promise<UserDto[]>
+
+  /**
+   *  Get organization statistics
+   * @param dateFrom
+   * @param dateTo
+   */
+  abstract statistics(dateFrom: number, dateTo: number): Promise<StatisticsResponse>
+
+  /**
+   *  Get organization statistics
+   * @param dateFrom
+   * @param dateTo
+   */
+  abstract membersStatistics(dateFrom: number, dateTo: number): Promise<UsersStatisticsResponse>
+
+  /**
+   * Get statistics for user
+   * @param userid
+   * @param dateFrom
+   * @param dateTo
+   */
+  abstract userStatistic(userid: string, dateFrom: number, dateTo: number): Promise<StatisticsResponse>
+
+  /**
+   * Get user limits data
+   */
+  abstract userLimits(): Promise<CurrentLimitsData>
+
+  /**
+   * Get default organization limits
+   */
+  abstract organizationLimits(): Promise<SegmentData>
+
+  /**
+   * Get all available segments data
+   */
+  abstract limitSegments(): Promise<SegmentData[]>
+
+  /**
+   * Change organization name and description.
+   */
+  abstract change(name: string, description: string): Promise<void>
+
+  /**
+   * Upload an icon for organization
+   * @param icon
+   */
+  abstract uploadIcon(icon: UploadFile): Promise<string>
+
+  /**
+   * Invite users with given emails to organization
+   */
+  abstract inviteUsers(emails: string[], accessGroups: GroupId[]): Promise<void>
+
+  /**
+   * Create invite code for users outside organization
+   */
+  abstract createInviteCode(accessGroups: GroupId[], validateDomain?: string): Promise<string>
+
+  /**
+   * Delete invite code
+   */
+  abstract deleteInviteCode(code: string): Promise<void>
+
+  /**
+   *  Get all invite links for organization
+   */
+  abstract getOrganizationInvites(): Promise<InviteResponse>
+
+  /**
+   * Create new Api key for organization
+   * @param name
+   * @param accessGroups
+   */
+  abstract createApiKey(name: string, accessGroups: string[]): Promise<OrganizationApiKey>
+
+  /**
+   * Get all organization api keys
+   */
+  abstract getApiKeys(): Promise<OrganizationApiKey[]>
+
+  /**
+   * Delete api key
+   */
+  abstract deleteApiKey(key: string): Promise<void>
+
+  /**
+   * Create quiz for given topic
+   * @param workspaces - workspaces to search for topic
+   * @param query - search query and quiz topic
+   * @param questionsCount - count of quiz tests
+   * @param optionsCount - count of one question options
+   * @param fileId - file id in case of test-on-file
+   */
+  abstract createQuiz(workspaces: WorkspaceId[], query: string, questionsCount: number, optionsCount: number, fileId: FileId): Promise<QuizData>
+
+  /**
+   * Delete users from organization by id
+   * @param userIds
+   */
+  abstract deleteOrganizationMember(userIds: string[]): Promise<void>
+
+  /**
+   * Fire changed event.
    */
-  abstract createInviteLink(emails: string[], accessGroups: GroupId[]): Promise<void>
+  fireChanged(): void {
+    this.dispatch({
+      type: OrganizationEvent.CHANGED,
+      data: this
+    })
+  }
 }

package/src/storages/organizations/organizationPrompts.impl.ts

@@ -0,0 +1,109 @@
+import { OrganizationPrompts } from "./organizationPrompts"
+import { OrganizationImpl } from "./organization.impl"
+import { Context } from "../../context"
+import { OrganizationPromptDto } from "../../dto/userInfoResponse"
+import { RpcService } from "../../services/rpcService"
+import { ResponseUtils } from "../../services/responseUtils"
+
+export class OrganizationPromptsImpl implements OrganizationPrompts {
+
+  private _cacheDefaultPrompts: OrganizationPromptDto[] | null = null
+
+  constructor(
+    private readonly organization: OrganizationImpl,
+    private readonly context: Context
+  ) {
+
+  }
+
+  async getDefaultPrompts(): Promise<OrganizationPromptDto[]> {
+    if (this._cacheDefaultPrompts !== null) {
+      return this._cacheDefaultPrompts
+    }
+
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/Organizations/prompts/default")
+      .searchParam("organizationId", this.organization.id)
+      .sendGet()
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError(
+        `Failed during fetch of organization prompts ${this.organization.id}`,
+        response
+      )
+    }
+
+    this._cacheDefaultPrompts = (await response!.json() as {
+      prompts: OrganizationPromptDto[]
+    }).prompts as OrganizationPromptDto[]
+
+    return this._cacheDefaultPrompts
+  }
+
+  async getPrompts(): Promise<OrganizationPromptDto[]> {
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/Organizations/prompts")
+      .searchParam("organizationId", this.organization.id)
+      .sendGet()
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError(
+        `Failed during fetch of organization prompts ${this.organization.id}`,
+        response
+      )
+    }
+
+    return (await response!.json() as {
+      prompts: OrganizationPromptDto[]
+    }).prompts as OrganizationPromptDto[]
+  }
+
+  async updatePrompts(prompts: OrganizationPromptDto[]): Promise<void> {
+    if (prompts === undefined || prompts === null || prompts.length === 0) {
+      return
+    }
+    for (let i = 0; i < prompts.length; i++) {
+      const prompt = prompts[i]
+      if (prompt === undefined || prompt === null) {
+        throw new Error("list of prompts has null item at index: " + i)
+      }
+    }
+
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/Organizations/prompts")
+      .searchParam("organizationId", this.organization.id)
+      .sendPutJson(prompts)
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError(
+        `Failed during update organization's list of prompts ${this.organization.id}`,
+        response
+      )
+    }
+  }
+
+  async updatePrompt(key: string, value: string | null): Promise<void> {
+    return this.updatePrompts([{
+      key,
+      value
+    }])
+  }
+
+  deletePrompt(key: string): Promise<void> {
+    return this.updatePrompt(key, null)
+  }
+
+  async deletePrompts(keys: string[]): Promise<void> {
+    return this.updatePrompts(keys.map(key => ({
+      key,
+      value: null
+    })))
+  }
+
+}

package/src/storages/organizations/organizationPrompts.ts

@@ -0,0 +1,41 @@
+import {
+  OrganizationPromptDto
+} from "../../dto/userInfoResponse"
+
+export abstract class OrganizationPrompts {
+
+  /**
+   * Get default organization prompts
+   */
+  abstract getDefaultPrompts(): Promise<OrganizationPromptDto[]>
+
+  /**
+   * Get all organization prompts
+   */
+  abstract getPrompts(): Promise<OrganizationPromptDto[]>
+
+  /**
+   * Create/Update/Delete new prompt
+   * @param key - key of prompt
+   * @param value - value of prompt, null|undefined to delete
+   */
+  abstract updatePrompt(key: string, value: string | undefined | null): Promise<void>
+
+  /**
+   * Update prompts in bulk
+   * @param prompts - array of prompts (value can be null|undefined to delete)
+   */
+  abstract updatePrompts(prompts: OrganizationPromptDto[]): Promise<void>
+
+  /**
+   * Delete prompt
+   * @param key
+   */
+  abstract deletePrompt(key: string): Promise<void>
+
+  /**
+   * Delete prompt
+   * @param keys
+   */
+  abstract deletePrompts(keys: string[]): Promise<void>
+}

package/src/storages/organizations/organizations.impl.ts

@@ -5,10 +5,13 @@ import {
 } from "./organizations"
 import { OrganizationImpl } from "./organization.impl"
 import { RpcService } from "../../services/rpcService"
-import { OrganizationDto, UserSettings } from "../../dto/userInfoResponse"
+import { ApplyInviteCodeResponse, OrganizationDto, UserSettings } from "../../dto/userInfoResponse"
 import { Context } from "../../context"
 import { Organization } from "./organization"
 import { ResponseUtils } from "../../services/responseUtils"
+import { UserProfileService } from "../../services/userProfileService"
+import {UploadFile} from "../files/files"
+import {IconDto, IconResponse, ResourceType} from "../../dto/workspacesResponse"
 
 export class OrganizationsImpl extends Organizations {
   constructor(public readonly context: Context) {
@@ -61,6 +64,27 @@ export class OrganizationsImpl extends Organizations {
     return this.internalDeleteOrganization(id)
   }
 
+  async applyInviteCode(code: string): Promise<ApplyInviteCodeResponse> {
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/Invites/apply")
+      .sendPutJson({
+        code: code
+      })
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError(
+        "Invite code validation failed",
+        response
+      )
+    }
+
+    await this.context.resolve(UserProfileService)?.fetch()
+
+    const result = (await response?.json()) as ApplyInviteCodeResponse
+
+    return result
+  }
+
   //----------------------------------------------------------------------------
   // INTERNALS
   //----------------------------------------------------------------------------
@@ -139,7 +163,8 @@ export class OrganizationsImpl extends Organizations {
         profile: {
           name: name,
           description: description
-        }
+        },
+        currentOrganizationId: this.currentOrganizationId
       })
     if (ResponseUtils.isFail(response)) {
       await ResponseUtils.throwError(
@@ -147,7 +172,9 @@ export class OrganizationsImpl extends Organizations {
         response
       )
     }
-    const content = (await response!.json()).organization as OrganizationDto
+    const content = (await response!.json() as {
+      organization: OrganizationDto
+    }).organization as OrganizationDto
 
     // create organization and init from content
     const org = await new OrganizationImpl(this.context).initFrom(content, true)
@@ -175,23 +202,139 @@ export class OrganizationsImpl extends Organizations {
     organizations: OrganizationDto[],
     settings: UserSettings | null | undefined
   ): Promise<void> {
+
+    this.organizations = []
+
+    // set current organization
     this.currentOrganizationId = settings?.activeOrganizationId
+
+    // wait list
+    const waitList: Promise<OrganizationImpl>[] = []
+
+    // init organizations
     for (const organization of organizations) {
       // create organization and init from content
-      const org = await new OrganizationImpl(this.context).initFrom(
+      const orgPromise = new OrganizationImpl(this.context).initFrom(
         organization,
         adminInOrganization.includes(organization.id)
       )
 
+      // add organization to wait list
+      waitList.push(orgPromise)
+    }
+
+    // wait for all organizations
+    const orgImpls = await Promise.all(waitList)
+
+    // add organizations to collection
+    for (const org of orgImpls) {
       // add organization to collection
       this.organizations.push(org)
+    }
+  }
 
-      // dispatch event, organization added
-      this.dispatch({
-        type: OrganizationsEvent.ADDED,
-        data: org
-      })
+
+  async uploadIconGlobal(organizationId: string, resourceId: string, resourceType: ResourceType, icon: UploadFile): Promise<string> {
+
+    // check icon file
+    if (icon === undefined || icon === null) {
+      throw new Error("Organization icon upload, file is undefined or null")
     }
+
+    const resourceTypeInt: number = resourceType
+
+    // form data to send
+    const form = new FormData()
+    form.append("OrganizationId", organizationId)
+    form.append("ResourceId", resourceId)
+    form.append("ResourceType", resourceTypeInt.toString())
+    form.append("FileName", icon.name)
+    form.append("File", icon, icon.name)
+
+    // send request to the server
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/Files/icon")
+      .sendPutFormData(form)
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError(`Organization icon upload ${icon.name}`, response)
+    }
+
+    const iconResponse = await response!.json() as IconResponse
+
+    return iconResponse.iconId
   }
 
+  async getIconData(id: string): Promise<IconDto> {
+    if (id === null || id === undefined || id.trim() === ""){
+      throw new Error("Icon id is null or empty")
+    }
+
+    // send request to the server
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/Files/icon")
+      .searchParam("iconId", id)
+      .sendGet()
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError(
+        `Failed during get of icon ${id}`,
+        response
+      )
+    }
+
+    return await response!.json() as IconDto
+  }
+
+  async getNewestIcon(resourceId: string, resourceType: ResourceType): Promise<IconDto>{
+    if (resourceId === null || resourceId === undefined || resourceId.trim() === ""){
+      throw new Error("Resource id is null or empty")
+    }
+
+    const resourceTypeInt: number = resourceType
+
+    // send request to the server
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/Files/icon/newest")
+      .searchParam("resourceId", resourceId)
+      .searchParam("resourceType", resourceTypeInt.toString())
+      .sendGet()
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError(
+        `Failed during get of icon for ${resourceId} ${resourceType.toString()}`,
+        response
+      )
+    }
+
+    return await response!.json() as IconDto
+  }
+
+  async deleteIcon(id: string): Promise<void> {
+    if (id === undefined || id === null) {
+      throw new Error("Icon delete, id is undefined or null")
+    }
+    if (id.length === 0 || id.trim().length === 0) {
+      throw new Error("Icon delete, id is empty")
+    }
+
+    // send request to the server
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/Files/icon")
+      .searchParam("iconId", id)
+      .sendDelete()
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError(`Failed to delete icon: ${id}`, response)
+    }
+
+  }
 }

package/src/storages/organizations/organizations.ts

@@ -1,5 +1,8 @@
+import { ApplyInviteCodeResponse } from "../../dto/userInfoResponse"
 import { EventDispatcher } from "../../events"
 import { Organization } from "./organization"
+import {IconDto, ResourceType} from "../../dto/workspacesResponse"
+import {UploadFile} from "../files/files"
 
 /**
  * Organization id.
@@ -53,4 +56,38 @@ export abstract class Organizations extends EventDispatcher<
    * Delete organization.
    */
   abstract delete(id: OrganizationId): Promise<void>
+
+  /**
+   * Apply invite code for user
+   */
+  abstract applyInviteCode(code: string): Promise<ApplyInviteCodeResponse>
+
+  /**
+   * Upload icon for any available resource ( organization, user, workspace, chat )
+   * @param organizationId
+   * @param resourceId
+   * @param resourceType
+   * @param icon
+   */
+  abstract uploadIconGlobal(organizationId: string, resourceId: string, resourceType: ResourceType, icon: UploadFile): Promise<string>
+
+  /**
+   * Get icon url and name for given id
+   * @param id
+   */
+  abstract getIconData(id: string): Promise<IconDto>
+
+  /**
+   * Get latest icon for provided resource
+   * @param resourceId
+   * @param resourceType
+   */
+  abstract getNewestIcon(resourceId: string, resourceType: ResourceType): Promise<IconDto>
+
+  /**
+   * Delete icon by ID
+   * @param id
+   */
+  abstract deleteIcon(id: string): Promise<void>
+
 }

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

@@ -0,0 +1,96 @@
+import { QueryFlow, QueryFlowEvent } from "./queryFlow"
+import {
+  QueryFileUrlDto,
+  QueryFlowDto,
+  QueryFlowState,
+  QueryFlowStatus
+} from "../../dto/queryFlowResponse"
+import { FlowId } from "./queryFlows"
+import { Context } from "../../context"
+import { RpcService } from "../../services/rpcService"
+import { ResponseUtils } from "../../services/responseUtils"
+
+export class QueryFlowImpl extends QueryFlow {
+  private _content?: QueryFlowDto
+  private _id?: FlowId
+
+  constructor(private readonly context: Context) {
+    super()
+  }
+
+  async initFrom(id: FlowId) {
+    this._id = id
+    await this.fetch()
+  }
+
+  async fetch() {
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/QueryFlows")
+      .searchParam("flowId", this.id)
+      .sendGet()
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError(`Failed to fetch query flow with id ${this.id}`, response)
+    }
+
+    // parse flow from the server's response
+    const flow = (await response!.json()) as QueryFlowDto
+
+    const lastState = this._content?.state
+
+    this._content = flow
+    if (lastState !== undefined && lastState !== this._content.state) {
+      this.dispatch({
+        type: QueryFlowEvent.UPDATED,
+        data: this
+      })
+    }
+
+    if (this._content.state === QueryFlowState.IN_PROGRESS) {
+      setTimeout(async () => await this.fetch(), 2000)
+    }
+  }
+
+  get id(): FlowId {
+    if (this._id) {
+      return this._id
+    } else {
+      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 urls(): QueryFileUrlDto[] | undefined {
+    if (this._content && this._content.result.files) {
+      return this._content.result.files
+    } else {
+      throw new Error("Query fLow is not loaded")
+    }
+  }
+
+  get state(): QueryFlowState {
+    if (this._content) {
+      return this._content.state
+    } else {
+      throw new Error("Query fLow is not loaded")
+    }
+  }
+
+  get status(): QueryFlowStatus {
+    if (this._content) {
+      return this._content.status
+    } else {
+      throw new Error("Query fLow is not loaded")
+    }
+  }
+
+}