@pilotdev/pilot-web-sdk 23.0.0-alpha.2 → 24.4.0

package/src/lib/injectable/objects-repository.ts

@@ -0,0 +1,74 @@
+import { Observable } from "rxjs";
+import { AccessLevel } from "../data/access";
+import { IDataObject, IPerson, IType, IOrganizationUnit } from "../data";
+
+/**
+ * Represents the repository that provides access to objects, types, organisation units and people
+ */
+export interface IObjectsRepository {
+  /**
+   * Get objects with specified ids
+   * 
+   * @param ids Ids of objects to subsribe
+   * @returns 
+   */
+  getObjects(ids: string[]): Observable<IDataObject[]>;
+  /**
+   * Get object's access for the person
+   * 
+   * @param objectId Object id
+   * @param personId Person Id
+   * @returns Cold Observable
+   */
+  getCurrentAccess(objectId: string, personId: number): Observable<AccessLevel>
+  /**
+   * Gets the person with specified id
+   * 
+   * @param id Person id
+   * @returns Person
+   */
+  getPerson(id: number): IPerson;
+  /**
+   * Gets the current person
+   * 
+   * @returns Person
+   */
+  getCurrentPerson(): IPerson
+  /**
+   * Gets all the people registred in database
+   * 
+   * @returns Person[]
+   */
+  getPeople(): IPerson[]
+  /**
+   * Gets type by identifier
+   * 
+   * @returns Type
+   */
+  getType(id: number): IType
+  /**
+   * Gets type by name
+   * 
+   * @returns Type
+   */
+  getTypeByName(name: string): IType
+  /**
+   * Gets all the types registered in database
+   * 
+   * @returns Type[]
+   */  
+  getTypes(): IType[];
+  /**
+   * Gets organisation unit by identifier
+   * 
+   * @returns OrganisationUnit
+   */
+  getOrganisationUnit(id: number): IOrganizationUnit;
+  /**
+   * Get all the organisation units registered in database
+   * 
+   * @returns OrganisationUnit
+   */  
+  getOrganisationUnits(): IOrganizationUnit[];
+}
+    

package/src/lib/injectable/render-context-provider.ts

@@ -0,0 +1,11 @@
+import { RenderContext } from "../contexts/render-context";
+
+/**
+ * Provides render context
+ */
+export interface IRenderContextProvider  {
+  /**
+   * 
+   */
+  getRenderContext(): RenderContext;
+}

package/src/lib/injectable/repository-events.ts

@@ -0,0 +1,33 @@
+import { Observable } from "rxjs";
+import { IDataObject, IPerson, IType, IOrganizationUnit } from "../data";
+
+
+/**
+ * Notifies on change events
+ */
+export interface IRepositoryEvents  {
+  /**
+   * Subsribes to changes in objects with specified identifiers
+   * 
+   * @returns Hot observable
+   */
+  subscribeObjects(ids: string[]): Observable<IDataObject>;
+  /**
+   * Subsribes to changes in people
+   * 
+   * @returns Hot observable
+   */
+  subscribePeople(): Observable<IPerson>
+  /**
+   * Subsribes to changes in types
+   * 
+   * @returns Hot observable
+   */
+  subscribeTypes(): Observable<IType>
+  /**
+   * Subsribes to changes in organisation units
+   * 
+   * @returns Hot observable
+   */
+  subscribeOrganisationUnits(): Observable<IOrganizationUnit>
+}

package/src/lib/menu/checkable-menu.builder.ts

@@ -0,0 +1,15 @@
+import { IMenuItemBuilder } from "./menu-item.builder";
+
+/**
+ * 
+ */
+export abstract class ICheckableMenuItemBuilder extends IMenuItemBuilder {
+  
+  /**
+   * 
+   * @param value 
+   */
+  withIsChecked(value: boolean): ICheckableMenuItemBuilder {
+    throw new Error("Method 'withIsChecked(value: boolean)' must be implemented.");
+  }
+}

package/{lib/menu/index.d.ts → src/lib/menu/index.ts}

@@ -1,4 +1,5 @@
-export * from './menu';
-export * from './checkable-menu.builder';
-export * from './menu-item.builder';
-export * from './menu.builder';
+
+export * from './menu';
+export * from './checkable-menu.builder';
+export * from './menu-item.builder';
+export * from './menu.builder';

package/src/lib/menu/menu-item.builder.ts

@@ -0,0 +1,45 @@
+import { IMenuBuilder } from "./menu.builder";
+
+/**
+ * Represents a menu item and enables to set parametres to it
+ */
+export abstract class IMenuItemBuilder {
+
+  constructor() {
+    if (this.constructor == IMenuItemBuilder) {
+      throw new Error("Abstract classes can't be instantiated.");
+    }
+  }
+
+  /**
+   * Item's name to be displayed
+   * @param header value
+   */
+  withHeader(header: string): IMenuItemBuilder {
+    throw new Error("Method 'withHeader(header: string)' must be implemented.");
+  }
+
+  /**
+   * Item's icon
+   * @param name Icon name
+   * @param iconSvg Url of icon or base64 string
+   */
+  withIcon(name: string, iconSvg: string): IMenuItemBuilder {
+    throw new Error("Method 'withIcon(name: string, iconSvg: string)' must be implemented.");
+  }
+
+  /**
+   * Enabled the item
+   * @param value value
+   */
+  withIsEnabled(value: boolean): IMenuItemBuilder {
+    throw new Error("Method 'withIsEnabled(value: boolean)' must be implemented.");
+  }
+  
+  /**
+   * Item's submenu
+   */
+  withSubmenu(): IMenuBuilder {
+    throw new Error("Method 'withSubmenu()' must be implemented.");
+  }
+}

package/src/lib/menu/menu.builder.ts

@@ -0,0 +1,79 @@
+import { ICheckableMenuItemBuilder } from "./checkable-menu.builder";
+import { IMenuItemBuilder } from "./menu-item.builder";
+
+/**
+ * Represents a menu and enables to add new items to it
+ */
+export abstract class IMenuBuilder {
+
+  constructor() {
+    if (this.constructor == IMenuBuilder) {
+      throw new Error("Abstract classes can't be instantiated.");
+    }
+  }
+
+  /**
+   * Gets the list of existing items of associated menu or subitems of an item
+   * @returns Existing menu item names
+   */
+  get itemNames(): string[] {
+    throw new Error("Getter 'itemNames()' must be implemented.");
+  }
+
+  /**
+   * Gets count of menu items
+   */
+  get count(): number { 
+    throw new Error("Getter 'count()' must be implemented.");
+  }
+
+  /**
+   * Adds a new separator to the associated menu
+   * @param index The index to put the new item at
+   */
+  addSeparator(index: number): void {
+    throw new Error("Method 'addSeparator(index: number)' must be implemented.");
+  }
+
+  /**
+   * Adds a new item to the associated menu
+   * @param name Item's internal name
+   * @param index The index to put the new item at
+   */
+  addItem(name: string, index: number): IMenuItemBuilder {
+    throw new Error("Method 'addItem(name: string, index: number)' must be implemented.");
+  }
+
+  /**
+   * Adds a new checkable item to the associated menu
+   * @param name Item's internal name
+   * @param index The index to put the new item at
+   */
+  addCheckableItem(name: string, index: number): ICheckableMenuItemBuilder {
+    throw new Error("Method 'addCheckableItem(name: string, index: number)' must be implemented.");
+  }
+
+  /**
+   * Replaces the item to the associated menu
+   * @param name Item's internal name
+   */
+  replaceItem(name: string): IMenuItemBuilder {
+    throw new Error("Method 'replaceItem(name: string)' must be implemented.");
+  }
+
+  /**
+   * Removes the item with the specified name
+   * @param name Item's internal name
+   */
+  removeItem(name: string): void {
+    throw new Error("Method 'removeItem(name: string)' must be implemented.");
+  }
+
+  /**
+   * Gets the item
+   * @param name Item's internal name
+   */
+  getItem(name: string): IMenuBuilder {
+    throw new Error("Method 'getItem(name: string)' must be implemented.");
+  }
+}

package/src/lib/menu/menu.ts

@@ -0,0 +1,24 @@
+import { IMenuBuilder } from "./menu.builder";
+
+/**
+ * Interface that allows to add new items to the menu and context menus
+ */
+export abstract class IMenu<TMenuContext> {
+  /**
+   * The method is called just before the menu is shown
+   * @param builder The menu builder object of associated menu
+   * @param context Context
+   */
+  build(builder: IMenuBuilder, context: TMenuContext): void {
+    throw new Error("Method 'build(builder: IMenuBuilder, context: TMenuContext)' must be implemented.");
+  }
+  
+  /**
+   * 
+   * @param name 
+   * @param context 
+   */
+  onMenuItemClick(name: string, context: TMenuContext): void {
+    throw new Error("Method 'onMenuItemClick(name: string, context: TMenuContext)' must be implemented.");
+  }
+}

package/{lib/toolbar/index.d.ts → src/lib/toolbar/index.ts}

@@ -1,6 +1,7 @@
-export * from './toolbar';
-export * from './toolbar-item.builder';
-export * from './toolbar-item-submenu.handler';
-export * from './toolbar-menu-item.builder';
-export * from './toolbar-toggle-item.builder';
-export * from './toolbar.builder';
+
+export * from './toolbar';
+export * from './toolbar-item.builder';
+export * from './toolbar-item-submenu.handler';
+export * from './toolbar-menu-item.builder';
+export * from './toolbar-toggle-item.builder';
+export * from './toolbar.builder';

package/src/lib/toolbar/toolbar-item-submenu.handler.ts

@@ -0,0 +1,12 @@
+import { IToolbarBuilder } from "./toolbar.builder";
+
+export abstract class IToolbarItemSubmenuHandler {
+   /**
+   * Build a submenu
+   * @param builder - toolbar builder
+   * @returns
+   */
+    onSubmenuRequested(builder: IToolbarBuilder): void {
+      throw new Error("Method 'onSubmenuRequested(builder: IToolbarBuilder)' must be implemented.");
+  }
+}

package/src/lib/toolbar/toolbar-item.builder.ts

@@ -0,0 +1,45 @@
+/**
+ * Represents a toolbar button and enables to set parametres to it
+ */
+export abstract class IToolbarButtonItemBuilder {
+  
+  constructor() {
+    if (this.constructor == IToolbarButtonItemBuilder) {
+      throw new Error("Abstract classes can't be instantiated.");
+    }
+  }
+
+  /**
+   * Item's name to be displayed
+   * @param header - value
+   * @returns instance of IToolbarButtonItemBuilder
+   */
+  withHeader(header: string): IToolbarButtonItemBuilder {
+    throw new Error("Method 'withHeader(header: string)' must be implemented.");
+  }
+
+  /**
+   * Item's icon in SVG format
+   * @param name - icon name
+   * @param svg - url icon or base64 string
+   */
+  withIcon(name: string, svg: string): IToolbarButtonItemBuilder {
+    throw new Error("Method 'withIcon(name: string, svg: string)' must be implemented.");
+  }
+
+  /**
+   * Enabled the item
+   * @param value - value
+   */
+  withIsEnabled(value: boolean): IToolbarButtonItemBuilder {
+    throw new Error("Method 'withIsEnabled(value: boolean)' must be implemented.");
+  }
+
+  /**
+   * Item's hint
+   * @param hint - value
+   */
+  withHint(hint:  string): IToolbarButtonItemBuilder {
+    throw new Error("Method 'withHint(hint:  string)' must be implemented.");
+  }
+}

package/src/lib/toolbar/toolbar-menu-item.builder.ts

@@ -0,0 +1,16 @@
+import { IToolbarButtonItemBuilder } from "./toolbar-item.builder";
+import { IToolbarItemSubmenuHandler } from "./toolbar-item-submenu.handler";
+
+/**
+ * Represents a toolbar menu button and enables to set parametres to it
+ */
+export abstract class IToolbarMenuButtonItemBuilder extends IToolbarButtonItemBuilder {
+  /**
+   * Build a dropdown menu
+   * @param itemSubmenuHandler - toolbar submenu handler
+   * @returns The toolbar button menu builder
+   */
+  withMenu(itemSubmenuHandler: IToolbarItemSubmenuHandler): IToolbarMenuButtonItemBuilder {
+    throw new Error("Method 'withMenu(itemSubmenuHandler: IToolbarItemSubmenuHandler)' must be implemented.");
+  }
+}

package/src/lib/toolbar/toolbar-toggle-item.builder.ts

@@ -0,0 +1,15 @@
+import { IToolbarButtonItemBuilder } from "./toolbar-item.builder";
+
+/**
+ * Represents a toolbar toggle button and enables to set parametres to it
+ */
+export abstract class IToolbarToggleButtonItemBuilder extends IToolbarButtonItemBuilder {
+  
+  /**
+   * 
+   * @param value 
+   */
+  withIsChecked(value: boolean): IToolbarToggleButtonItemBuilder {
+    throw new Error("Method 'withIsChecked(value: boolean)' must be implemented.");
+  }
+}

package/src/lib/toolbar/toolbar.builder.ts

@@ -0,0 +1,104 @@
+import { IToolbarButtonItemBuilder } from "./toolbar-item.builder";
+import { IToolbarItemSubmenuHandler } from "./toolbar-item-submenu.handler";
+import { IToolbarMenuButtonItemBuilder } from "./toolbar-menu-item.builder";
+import { IToolbarToggleButtonItemBuilder } from "./toolbar-toggle-item.builder";
+
+export abstract class IToolbarBuilder {
+
+  constructor() {
+    if (this.constructor == IToolbarBuilder) {
+      throw new Error("Abstract classes can't be instantiated.");
+    }
+  }
+
+  /**
+   * Adds a new separator to the associated toolbar
+   * @param index - The index to put the new item at
+   */
+  addSeparator(index: number): void {
+    throw new Error("Method 'addSeparator(index: number)' must be implemented.");
+  }
+
+  /**
+   * Adds a new button to the associated toolbar
+   * @param name - Internal item's name
+   * @param index - The index to put the new item at
+   */
+  addButtonItem(name: string, index: number): IToolbarButtonItemBuilder {
+    throw new Error("Method 'addButtonItem(name: string, index: number)' must be implemented.");
+  }
+
+  /**
+   * Adds a new menu button to the associated toolbar
+   * @param name - Internal item's name
+   * @param index - The index to put the new item at
+   */
+  addMenuButtonItem(name: string, index: number): IToolbarMenuButtonItemBuilder {
+    throw new Error("Method 'addMenuButtonItem(name: string, index: number)' must be implemented.");
+  }
+
+  /**
+   * Adds a new toggle button to the associated toolbar
+   * @param name -  Internal item's name
+   * @param index - The index to put the new item at
+   */
+  addToggleButtonItem(name: string, index: number): IToolbarToggleButtonItemBuilder {
+    throw new Error("Method 'addToggleButtonItem(name: string, index: number)' must be implemented.");
+  }
+
+  /**
+   * Replaces the item from the associated toolbar on button
+   * @param name - The name of toolbar button to replace
+   */
+  replaceButtonItem(name: string): IToolbarButtonItemBuilder {
+    throw new Error("Method 'replaceButtonItem(name: string)' must be implemented.");
+  }
+
+  /**
+   * Replace the item from the associated toolbar on menu button
+   * @param name - The name of toolbar menu button to replace 
+   */
+  replaceMenuButtonItem(name: string): IToolbarMenuButtonItemBuilder {
+    throw new Error("Method 'replaceMenuButtonItem(name: string)' must be implemented.");
+  }
+
+  /**
+   * Enables to set parametres to menu button item submenu
+   * @param name - Item's internal name
+   * @param itemSubmenuHandler - The toolbar button menu builder
+   */
+  handleMenuButtonItemSubmenu(name: string, itemSubmenuHandler: IToolbarItemSubmenuHandler): void {
+    throw new Error("Method 'handleMenuButtonItemSubmenu(name: string, itemSubmenuHandler: IToolbarItemSubmenuHandler)' must be implemented.");
+  }
+
+  /**
+   * Replaces the item from the associated toolbar on toggle button
+   * @param name - The name of toolbar toggle button to replace
+   */
+  replaceToggleButtonItem(name: string): IToolbarToggleButtonItemBuilder {
+    throw new Error("Method 'replaceToggleButtonItem(name: string)' must be implemented.");
+  }
+
+  /** 
+   * Gets the list of existing item names of associated toolbar 
+   * @returns - Existing toolbar item names 
+   */
+  get itemNames(): string[] {
+    throw new Error("Getter 'itemNames()' must be implemented.");
+  }
+
+  /**
+   * Gets count of toolbar items
+   */
+  get count(): number {
+    throw new Error("Getter 'count()' must be implemented.");
+  }
+
+  /**
+   * Removes specified item
+   * @param itemName - Item's internal name
+   */
+  removeItem(itemName: string): void {
+    throw new Error("Method 'removeItem(name: string)' must be implemented.");
+  }
+}

package/src/lib/toolbar/toolbar.ts

@@ -0,0 +1,31 @@
+import { IToolbarBuilder } from "./toolbar.builder";
+
+/**
+ * Interface that allows to add new items to the toolbar
+ */
+export abstract class IToolbar<TToolbarContext> {
+
+  constructor() {
+    if (this.constructor == IToolbar<TToolbarContext>) {
+      throw new Error("Abstract classes can't be instantiated.");
+    }
+  }
+
+  /**
+   * The method is called just before the toolbar is created
+   * @param builder - the toolbar builder object of associated toolbar
+   * @param context - context
+   */
+  build(builder: IToolbarBuilder, context: TToolbarContext): void {
+    throw new Error("Method 'build(builder: IToolbarBuilder, context: TToolbarContext)' must be implemented.");
+  }
+
+  /**
+   * 
+   * @param name 
+   * @param context 
+   */
+  onToolbarItemClick(name: string, context: TToolbarContext): void {
+    throw new Error("Method 'onToolbarItemClick(name: string, context: TToolbarContext)' must be implemented.");
+  }
+}

package/src/lib/tools/attribute-permission.info.ts

@@ -0,0 +1,51 @@
+import { objectToMap } from "./utils";
+
+export class AttributePermissionInfo {
+  private ATTRIBUTE_NAME_MARKER = '&';
+  
+  orgUnits: number[];
+  orgUnitAttributes: string[];
+
+  constructor(editableForPositionsSource: string[]) {
+    this.orgUnits = new Array<number>();
+    this.orgUnitAttributes = new Array<string>();
+
+    if (!editableForPositionsSource)
+      return;
+
+    editableForPositionsSource.forEach(str => {
+      if (str.length > 0 && str[0] === this.ATTRIBUTE_NAME_MARKER) {
+        this.orgUnitAttributes.push(str.substring(1));
+      }
+      else {
+        const num = Number(str);
+        if (!isNaN(num)) 
+          this.orgUnits.push(num);
+      }
+    });
+  }
+
+  extractAllOrgUnits(obj: any): number[] {
+    const attrMap = objectToMap<any>(obj.attributes);
+    return this.extractAllOrgUnitsByAttributes(attrMap);
+  }
+
+  extractAllOrgUnitsByAttributes(attributes: Map<string, any>) : number[] {
+    let result = new Array<number>();
+    if (!this.orgUnitAttributes || !attributes  )
+      return result;
+
+    this.orgUnitAttributes.forEach(permissionAttributeName => {
+      if (attributes.has(permissionAttributeName)){
+        const value = attributes.get(permissionAttributeName);
+        if (value && Array.isArray(value)){
+          value.forEach(intValue => {
+            result.push(intValue);
+          });
+        }
+      }
+    });
+
+    return result;
+  }
+}

package/src/lib/tools/guid.ts

@@ -0,0 +1,63 @@
+const byteToHex = Array();
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 0x100).toString(16).slice(1));
+}
+
+export class Guid {
+  private static readonly regex = "(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})";
+
+  static readonly EMPTY = "00000000-0000-0000-0000-000000000000";
+
+  static newGuid(): string {
+
+    if (window.isSecureContext) {
+      // If crypto.getRandomValues is available try to use it.
+      return window.crypto.randomUUID();
+    }
+
+    // Fall back to Math.random if a higher quality random number generator is not available.
+    const uuid = new Array(16);
+    var d = new Date().getTime();
+    for (var i = 0; i < 16; i++) {
+      var r = ((d + Math.random() * 256) % 256) | 0;
+      d = Math.trunc(d / 256);
+      uuid[i] = r;
+    }
+   
+    // Makes uuid compliant to RFC-4122
+    uuid[6] = (uuid[6] & 0x0F) | 0x40; // uuid version
+    uuid[8] = (uuid[8] & 0x3F) | 0x80; // uuid variant
+    
+    return this.stringify(uuid);
+  }
+
+  static isGuid(str: string) {
+    const regex = new RegExp(this.regex);
+    return regex.test(str) && str.length === 36;
+  }
+
+  private static stringify(arr: Array<number>) {
+    return (
+      byteToHex[arr[0]] +
+      byteToHex[arr[1]] +
+      byteToHex[arr[2]] +
+      byteToHex[arr[3]] +
+      '-' +
+      byteToHex[arr[4]] +
+      byteToHex[arr[5]] +
+      '-' +
+      byteToHex[arr[6]] +
+      byteToHex[arr[7]] +
+      '-' +
+      byteToHex[arr[8]] +
+      byteToHex[arr[9]] +
+      '-' +
+      byteToHex[arr[10]] +
+      byteToHex[arr[11]] +
+      byteToHex[arr[12]] +
+      byteToHex[arr[13]] +
+      byteToHex[arr[14]] +
+      byteToHex[arr[15]]
+    ).toLowerCase();
+  }
+}

package/src/lib/tools/index.ts

@@ -0,0 +1,3 @@
+export * from './attribute-permission.info';
+export * from './utils'
+export * from './guid'

package/src/lib/tools/utils.ts

@@ -0,0 +1,8 @@
+
+export function objectToMap<T>(objectMap: { [key: string]: any; }): Map<string, T> {
+  const map = new Map<string, T>();
+  Object.keys(objectMap).forEach(key => {
+    map.set(key, objectMap[key]);
+  });
+  return map;
+} 

package/src/public-api.ts

@@ -0,0 +1,10 @@
+/*
+ * Public API Surface of pilot-web-sdk
+ */
+export * from './lib/idata.plugin';
+export * from './lib/injectable/index';
+export * from './lib/toolbar/index';
+export * from './lib/menu/index';
+export * from './lib/contexts/index';
+export * from './lib/tools/index';
+export * from './lib/data/index';