@datagrok/sequence-translator 1.2.7 → 1.3.0

package/src/apps/common/view/isolated-app-ui.ts

@@ -0,0 +1,43 @@
+/* Do not change these import lines to match external modules in webpack configuration */
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+
+import {_package} from '../../../package';
+import {AppUIBase} from './app-ui-base';
+
+export abstract class IsolatedAppUIBase extends AppUIBase {
+  constructor(appName: string) {
+    super(appName);
+    this.view = DG.View.create();
+    this.configureView();
+  }
+
+  protected view: DG.View;
+  async constructView(): Promise<DG.ViewBase> {
+    await this.initView();
+    const name = this.parentAppName ? this.parentAppName + '/' + this.appName : this.appName;
+    this.view.path = `/apps/${_package.name}/${name.replace(/\s/g, '')}/`;
+    return this.view;
+  }
+
+  protected abstract getContent(): Promise<HTMLDivElement>;
+  async initView(): Promise<void> {
+    const content = await this.getContent();
+    this.view.append(content);
+  }
+
+  protected configureView(): void {
+    this.view.box = true;
+    this.view.name = this.appName;
+
+    const windows = grok.shell.windows;
+    windows.showProperties = false;
+    windows.showToolbox = false;
+    windows.showHelp = false;
+  }
+
+  getView(): DG.View {
+    return this.view;
+  }
+}
+

package/src/{view/monomer-lib-viewer/viewer.ts → apps/common/view/monomer-lib-viewer.ts}

@@ -3,8 +3,8 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {drawZoomedInMolecule} from '../utils/draw-molecule';
-import {MonomerLibWrapper} from '../../model/monomer-lib/lib-wrapper';
+import {drawZoomedInMolecule} from './components/draw-molecule';
+import {MonomerLibWrapper} from '../model/monomer-lib/lib-wrapper';
 
 export class MonomerLibViewer {
   static async view(): Promise<void> {

package/src/apps/common/view/utils.ts

@@ -0,0 +1,29 @@
+import {OligoPatternUI} from '../../pattern/view/ui';
+import {OligoStructureUI} from '../../structure/view/ui';
+import {OligoTranslatorUI} from '../../translator/view/ui';
+import {IsolatedAppUIBase} from './isolated-app-ui';
+import {APP_NAME} from './const';
+
+/** For plugins from external packages */
+export class ExternalPluginUI extends IsolatedAppUIBase {
+  constructor(viewName: string, private content: HTMLDivElement) {
+    super(viewName);
+  }
+
+  protected getContent(): Promise<HTMLDivElement> {
+    return Promise.resolve(this.content);
+  }
+}
+
+export function getSpecifiedAppUI(appName: string): IsolatedAppUIBase {
+  switch (appName) {
+  case APP_NAME.TRANSLATOR:
+    return new OligoTranslatorUI();
+  case APP_NAME.PATTERN:
+    return new OligoPatternUI();
+  case APP_NAME.STRUCTURE:
+    return new OligoStructureUI();
+  default:
+    throw new Error(`Unknown app name: ${appName}`);
+  }
+}

package/src/apps/pattern/model/const.ts

@@ -0,0 +1,121 @@
+import {StrandType} from './types';
+
+export const enum STRAND {
+  SENSE = 'SS',
+  ANTISENSE = 'AS',
+};
+export const STRANDS = [STRAND.SENSE, STRAND.ANTISENSE] as const;
+export const STRAND_LABEL: Record<StrandType, string> = {
+  [STRAND.SENSE]: 'Sense strand',
+  [STRAND.ANTISENSE]: 'Anti sense',
+};
+
+export const enum STRAND_END {
+  LEFT,
+  RIGHT,
+};
+
+export const STRAND_ENDS = [STRAND_END.LEFT, STRAND_END.RIGHT] as const;
+
+export const enum TERMINUS {
+  FIVE_PRIME = '5\'',
+  THREE_PRIME = '3\'',
+};
+export const TERMINI = [TERMINUS.THREE_PRIME, TERMINUS.FIVE_PRIME] as const;
+
+export const STRAND_TO_END_TERMINUS_MAP = {
+  [STRAND.SENSE]: {
+    [STRAND_END.LEFT]: TERMINUS.THREE_PRIME,
+    [STRAND_END.RIGHT]: TERMINUS.FIVE_PRIME
+  },
+  [STRAND.ANTISENSE]: {
+    [STRAND_END.LEFT]: TERMINUS.FIVE_PRIME,
+    [STRAND_END.RIGHT]: TERMINUS.THREE_PRIME
+  }
+} as const;
+
+export const MAX_SEQUENCE_LENGTH = 34;
+
+export const STORAGE_NAME: string = 'OligoToolkit';
+export const EXAMPLE_MIN_WIDTH: string = '400px';
+
+export const OTHER_USERS = 'Other users';
+
+export namespace GRAPH_SETTINGS_KEYS {
+  export const IS_ANTISENSE_STRAND_INCLUDED = 'isAntisenseStrandIncluded';
+  export const NUCLEOTIDE_SEQUENCES = 'nucleotideSequences';
+  export const PHOSPHOROTHIOATE_LINKAGE_FLAGS = 'phosphorothioateLinkageFlags';
+  export const STRAND_TERMINUS_MODIFICATIONS = 'strandTerminusModifications';
+}
+
+export namespace LEGEND_SETTINGS_KEYS {
+  export const PATTERN_NAME = 'patternName';
+  export const PATTERN_COMMENT = 'patternComment';
+  export const NUCLEOTIDES_WITH_NUMERIC_LABELS = 'nucleotidesWithNumericLabels';
+}
+
+export namespace PATTERN_RECORD_KEYS {
+  export const PATTERN_CONFIG = 'patternConfig';
+  export const AUTHOR_ID = 'authorID';
+}
+
+export const GRAPH_SETTINGS_KEY_LIST = [
+  GRAPH_SETTINGS_KEYS.IS_ANTISENSE_STRAND_INCLUDED,
+  GRAPH_SETTINGS_KEYS.NUCLEOTIDE_SEQUENCES,
+  GRAPH_SETTINGS_KEYS.PHOSPHOROTHIOATE_LINKAGE_FLAGS,
+  GRAPH_SETTINGS_KEYS.STRAND_TERMINUS_MODIFICATIONS
+];
+
+export const LEGEND_SETTINGS_KEY_LIST = [
+  LEGEND_SETTINGS_KEYS.PATTERN_NAME,
+  LEGEND_SETTINGS_KEYS.PATTERN_COMMENT,
+  LEGEND_SETTINGS_KEYS.NUCLEOTIDES_WITH_NUMERIC_LABELS
+];
+
+export const PATTERN_RECORD_KEY_LIST = [
+  PATTERN_RECORD_KEYS.PATTERN_CONFIG,
+  PATTERN_RECORD_KEYS.AUTHOR_ID
+];
+
+export const EXAMPLE_PATTERN_CONFIG =
+{
+  'patternConfig': {
+    'patternName': '<default example>',
+    'isAntisenseStrandIncluded': true,
+    'nucleotideSequences': {
+      'SS': [
+        'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA',
+        'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA'
+      ],
+      'AS': [
+        'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA',
+        'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA'
+      ]
+    },
+    'phosphorothioateLinkageFlags': {
+      'SS': [
+        true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true,
+        true, true, true, true, true, true, true, true
+      ],
+      'AS': [
+        true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true,
+        true, true, true, true, true, true, true, true
+      ]
+    },
+    'strandTerminusModifications': {
+      'SS': {
+        '3\'': '',
+        '5\'': ''
+      },
+      'AS': {
+        '3\'': '',
+        '5\'': ''
+      }
+    },
+    'patternComment': '',
+    'nucleotidesWithNumericLabels': [
+      'RNA'
+    ]
+  },
+  'authorID': ''
+};

package/src/apps/pattern/model/data-manager.ts

@@ -0,0 +1,297 @@
+/* Do not change these import lines to match external modules in webpack configuration */
+import * as grok from 'datagrok-api/grok';
+
+import {
+  EXAMPLE_PATTERN_CONFIG,
+  GRAPH_SETTINGS_KEY_LIST as GKL, LEGEND_SETTINGS_KEYS as L, OTHER_USERS, PATTERN_RECORD_KEYS as R, STORAGE_NAME
+} from './const';
+import {
+  PatternConfigRecord, PatternConfiguration, PatternExistsError, PatternNameExistsError, RawPatternRecords
+} from './types';
+
+import objectHash from 'object-hash';
+import {EventBus} from './event-bus';
+import {PATTERN_APP_DATA} from '../../common/model/data-loader/json-loader';
+
+
+export class DataManager {
+  private currentUserName: string;
+  private currentUserId: string;
+  private otherUsersPatternNameToHash = new Map<string, string>();
+  private currentUserPatternNameToHash = new Map<string, string>();
+
+  // WARNING: init logic encapsulated
+  private constructor( ) { }
+
+  static async getInstance(): Promise<DataManager> {
+    const instance = new DataManager();
+
+    instance.currentUserName = await instance.fetchCurrentUserName();
+    instance.currentUserId = await instance.fetchCurrentUserId();
+
+    const patternRecords = await instance.fetchPatterns();
+    await instance.initializePatternMaps(patternRecords);
+
+    return instance;
+  }
+
+  getCurrentUserPatternNames(): string[] {
+    return Array.from(this.currentUserPatternNameToHash.keys())
+      .sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+  }
+
+  getOtherUsersPatternNames(): string[] {
+    return Array.from(this.otherUsersPatternNameToHash.keys())
+      .sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+  }
+
+  getCurrentUserName(): string {
+    return this.currentUserName;
+  }
+
+  private validatePatternNameUniqueness(patternName: string): void {
+    if (this.currentUserPatternNameToHash.has(patternName))
+      throw new PatternNameExistsError(`Pattern with name ${patternName} already exists`);
+  }
+
+  private validatePatternUniqueness(hash: string): void {
+    const existingHashes = Array.from(this.currentUserPatternNameToHash.values())
+      .concat(Array.from(this.otherUsersPatternNameToHash.values()));
+
+    if (existingHashes.includes(hash))
+      throw new PatternExistsError(hash);
+  }
+
+  getPatternHash(patternName: string, isCurrentUserPattern: boolean): string {
+    const patternHash = isCurrentUserPattern ?
+      this.currentUserPatternNameToHash.get(patternName) :
+      this.otherUsersPatternNameToHash.get(patternName);
+
+    if (patternHash === undefined)
+      throw new Error(`Pattern with name ${patternName} not found`);
+
+    return patternHash;
+  }
+
+  async getPatternRecord(hash: string): Promise<PatternConfigRecord | null> {
+    if (hash === null || hash === '')
+      return null;
+    try {
+      const patternConfig = await grok.dapi.userDataStorage.getValue(STORAGE_NAME, hash, false);
+      const config = JSON.parse(patternConfig) as PatternConfigRecord;
+      return config;
+    } catch {
+      return null;
+    }
+  }
+
+  async getPatternConfig(hash: string | null): Promise<PatternConfiguration | null> {
+    if (hash === '' || hash === null)
+      return null;
+    const record = await this.getPatternRecord(hash);
+    const config = record === null ? null : record[R.PATTERN_CONFIG] as PatternConfiguration;
+    return config;
+  }
+
+  getDefaultPatternRecord(): PatternConfigRecord {
+    const record = EXAMPLE_PATTERN_CONFIG as PatternConfigRecord;
+    record[R.AUTHOR_ID] = this.currentUserId;
+    return record;
+  }
+
+  getDefaultPatternConfig(): PatternConfiguration {
+    return EXAMPLE_PATTERN_CONFIG[R.PATTERN_CONFIG] as PatternConfiguration;
+  }
+
+  private getAuthorCategoryByHash(hash: string): string {
+    if (this.isCurrentUserPattern(hash))
+      return this.getCurrentUserAuthorshipCategory();
+    else if (this.isOtherUserPattern(hash))
+      return this.getOtherUsersAuthorshipCategory();
+    else
+      throw new Error(`Pattern with hash ${hash} not found`);
+  }
+
+  private isCurrentUserPattern(hash: string): boolean {
+    return Array.from(this.currentUserPatternNameToHash.values()).includes(hash);
+  }
+
+  private isOtherUserPattern(hash: string): boolean {
+    return Array.from(this.otherUsersPatternNameToHash.values()).includes(hash);
+  }
+
+  getPatternNameByHash(hash: string): string {
+    const maps = [this.currentUserPatternNameToHash, this.otherUsersPatternNameToHash];
+    for (const map of maps) {
+      for (const [patternName, patternHash] of map.entries()) {
+        if (patternHash === hash)
+          return patternName;
+      }
+    }
+    throw new Error(`Pattern with hash ${hash} not found`);
+  }
+
+  private getHashOfPatternToBeLoadedAfterDeletion(): string {
+    const nameOfPatternToBeLoaded = this.getCurrentUserPatternNames()[0];
+    if (!nameOfPatternToBeLoaded)
+      throw new Error('Cannot load pattern after deletion, as there are no patterns left');
+    const hash = this.currentUserPatternNameToHash.get(nameOfPatternToBeLoaded);
+    if (hash === undefined)
+      throw new Error(`Pattern with name ${nameOfPatternToBeLoaded} not found`);
+    return hash;
+  }
+
+  private async getRecordFromPattern(patternConfig: PatternConfiguration): Promise<string> {
+    const record = {
+      [R.PATTERN_CONFIG]: patternConfig,
+      [R.AUTHOR_ID]: await grok.dapi.users.current().then((u) => u.id),
+    };
+    const stringifiedRecord = JSON.stringify(record);
+    return stringifiedRecord;
+  }
+
+  private getHash(patternConfig: PatternConfiguration): string {
+    // WARNING: hash is computed over the graph settings only, as the ones defining the pattern's identity
+    const graphSettings = GKL.reduce((acc, key) => {
+      acc[key] = patternConfig[key as keyof PatternConfiguration];
+      return acc;
+    }, {} as any);
+    return objectHash.sha1(graphSettings);
+  }
+
+  async savePatternToUserStorage(
+    eventBus: EventBus
+  ): Promise<void> {
+    const patternConfig = eventBus.getPatternConfig();
+    try {
+      const hash = this.getHash(patternConfig);
+      this.validatePatternUniqueness(hash);
+
+      const patternName = patternConfig[L.PATTERN_NAME];
+      this.validatePatternNameUniqueness(patternName);
+
+      const record = await this.getRecordFromPattern(patternConfig);
+      await grok.dapi.userDataStorage.postValue(STORAGE_NAME, hash, record, false);
+      this.currentUserPatternNameToHash.set(patternName, hash);
+
+      eventBus.selectAuthor(this.getCurrentUserAuthorshipCategory());
+
+      eventBus.updatePatternList();
+    } catch (e) {
+      if (e instanceof PatternNameExistsError || e instanceof PatternExistsError)
+        throw e;
+      else
+        console.error('Error while saving pattern to user storage', e);
+    }
+  }
+
+  async overwritePatternInUserStorage(
+    eventBus: EventBus
+  ): Promise<void> {
+    const patternConfig = eventBus.getPatternConfig();
+    const hash = this.getHash(patternConfig);
+    const patternName = patternConfig[L.PATTERN_NAME];
+    const record = await this.getRecordFromPattern(patternConfig);
+    await grok.dapi.userDataStorage.postValue(STORAGE_NAME, hash, record, false);
+    this.currentUserPatternNameToHash.set(patternName, hash);
+    // eventBus.selectUser(this.getCurrentUserAuthorshipCategory());
+    eventBus.updatePatternList();
+  }
+
+  async deletePattern(
+    patternName: string,
+    eventBus: EventBus
+  ): Promise<void> {
+    const hash = this.currentUserPatternNameToHash.get(patternName);
+    if (patternName === this.getDefaultPatternName()) {
+      grok.shell.warning(`Cannot delete default pattern`);
+      return;
+    }
+    if (hash === undefined)
+      throw new Error(`Pattern with name ${patternName} not found`);
+    await grok.dapi.userDataStorage.remove(STORAGE_NAME, hash, false);
+    this.currentUserPatternNameToHash.delete(patternName);
+    eventBus.updatePatternList();
+
+    const hashOfPatternToBeLoaded = this.getHashOfPatternToBeLoadedAfterDeletion();
+    eventBus.requestPatternLoad(hashOfPatternToBeLoaded);
+  }
+
+  fetchDefaultNucleobase(): string {
+    return this.fetchAvailableNucleotideBases()[0];
+  }
+
+  fetchAvailableNucleotideBases(): string[] {
+    const format = Object.keys(PATTERN_APP_DATA)[0];
+    const nucleotideBases: string[] = Object.keys(PATTERN_APP_DATA[format]);
+    return nucleotideBases;
+  }
+
+
+  private async fetchCurrentUserName(): Promise<string> {
+    return (await grok.dapi.users.current()).friendlyName;
+  }
+
+  private async fetchCurrentUserId(): Promise<string> {
+    return (await grok.dapi.users.current()).id;
+  }
+
+  private async fetchPatterns() {
+    const patternsRecord = await grok.dapi.userDataStorage.get(STORAGE_NAME, false) as RawPatternRecords;
+    return patternsRecord;
+  }
+
+  private async initializePatternMaps(patternRecords: RawPatternRecords) {
+    if (!this.currentUserId)
+      throw new Error('Current user ID is not set');
+
+    const userIdsToUserNames = new Map<string, string>();
+
+    for (const [patternHash, stringifiedRecord] of Object.entries(patternRecords))
+      await this.extractDataFromRecordToMaps(patternHash, stringifiedRecord, userIdsToUserNames);
+
+    this.setDefaultPattern();
+  }
+
+  private setDefaultPattern(): void {
+    const defaultPatternConfig = EXAMPLE_PATTERN_CONFIG[R.PATTERN_CONFIG] as PatternConfiguration;
+    this.currentUserPatternNameToHash.set(defaultPatternConfig[L.PATTERN_NAME], '');
+  }
+
+  private async extractDataFromRecordToMaps(
+    patternHash: string,
+    stringifiedRecord: string,
+    userIdsToUserNames: Map<string, string>
+  ) {
+    const record = JSON.parse(stringifiedRecord);
+    const patternConfig = record[R.PATTERN_CONFIG] as PatternConfiguration;
+    const patternName = patternConfig.patternName;
+    const authorID = record[R.AUTHOR_ID];
+    if (this.isCurrentUserId(authorID)) {
+      this.currentUserPatternNameToHash.set(patternName, patternHash);
+    } else {
+      if (!userIdsToUserNames.has(authorID)) {
+        const userFriendlyName = (await grok.dapi.users.find(authorID)).friendlyName;
+        userIdsToUserNames.set(authorID, userFriendlyName);
+      }
+      const fullPatternName = patternName + ` (created by ${userIdsToUserNames.get(authorID)})`;
+      this.otherUsersPatternNameToHash.set(fullPatternName, patternHash);
+    }
+  }
+
+  getDefaultPatternName(): string {
+    return EXAMPLE_PATTERN_CONFIG[R.PATTERN_CONFIG][L.PATTERN_NAME];
+  }
+
+  getCurrentUserAuthorshipCategory(): string {
+    return this.currentUserName + ' (me)';
+  }
+
+  getOtherUsersAuthorshipCategory(): string {
+    return OTHER_USERS;
+  }
+
+  isCurrentUserId(userId: string): boolean {
+    return userId === this.currentUserId;
+  }
+}