@datagrok/sequence-translator 1.3.9 → 1.3.10

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datagrok/sequence-translator",
   "friendlyName": "Sequence Translator",
-  "version": "1.3.9",
+  "version": "1.3.10",
   "author": {
     "name": "Alexey Choposky",
     "email": "achopovsky@datagrok.ai"

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

@@ -57,6 +57,12 @@ export namespace LEGEND_SETTINGS_KEYS {
 export namespace PATTERN_RECORD_KEYS {
   export const PATTERN_CONFIG = 'patternConfig';
   export const AUTHOR_ID = 'authorID';
+  export const DATE = 'date';
+}
+
+export namespace DATE_KEYS {
+  export const CREATE = 'create';
+  export const MODIFY = 'modify';
 }
 
 export const GRAPH_SETTINGS_KEY_LIST = [
@@ -72,11 +78,6 @@ export const LEGEND_SETTINGS_KEY_LIST = [
   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': {
@@ -119,3 +120,5 @@ export const EXAMPLE_PATTERN_CONFIG =
   },
   'authorID': ''
 };
+
+export const DEFAULT_DATE = '2024-01-01T18:00:00.000Z';

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

@@ -3,7 +3,8 @@ 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
+  GRAPH_SETTINGS_KEY_LIST as GKL, LEGEND_SETTINGS_KEYS as L,
+  OTHER_USERS, PATTERN_RECORD_KEYS as R, STORAGE_NAME, DATE_KEYS as D
 } from './const';
 import {
   PatternConfigRecord, PatternConfiguration, PatternExistsError, PatternNameExistsError, RawPatternRecords
@@ -76,7 +77,7 @@ export class DataManager {
     return patternHash;
   }
 
-  async getPatternRecord(hash: string): Promise<PatternConfigRecord | null> {
+  async getPatternRecordByHash(hash: string): Promise<PatternConfigRecord | null> {
     if (hash === null || hash === '')
       return null;
     try {
@@ -91,7 +92,7 @@ export class DataManager {
   async getPatternConfig(hash: string | null): Promise<PatternConfiguration | null> {
     if (hash === '' || hash === null)
       return null;
-    const record = await this.getPatternRecord(hash);
+    const record = await this.getPatternRecordByHash(hash);
     const config = record === null ? null : record[R.PATTERN_CONFIG] as PatternConfiguration;
     return config;
   }
@@ -144,13 +145,13 @@ export class DataManager {
     return hash;
   }
 
-  private async getRecordFromPattern(patternConfig: PatternConfiguration): Promise<string> {
-    const record = {
+  private async getRecordFromPattern(
+    patternConfig: PatternConfiguration
+  ): Promise<PatternConfigRecord> {
+    return {
       [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 {
@@ -173,13 +174,21 @@ export class DataManager {
       const patternName = patternConfig[L.PATTERN_NAME];
       this.validatePatternNameUniqueness(patternName);
 
-      const record = await this.getRecordFromPattern(patternConfig);
+      const recordObj = await this.getRecordFromPattern(patternConfig);
+      const timestamp = new Date().toISOString();
+      recordObj[R.DATE] = {
+        [D.CREATE]: timestamp,
+        [D.MODIFY]: timestamp,
+      };
+      const record = JSON.stringify(recordObj);
       await grok.dapi.userDataStorage.postValue(STORAGE_NAME, hash, record, false);
       this.currentUserPatternNameToHash.set(patternName, hash);
 
       eventBus.selectAuthor(this.getCurrentUserAuthorshipCategory());
 
       eventBus.updatePatternList();
+      eventBus.requestPatternLoad(hash);
+      eventBus.updateUrlState(hash);
     } catch (e) {
       if (e instanceof PatternNameExistsError || e instanceof PatternExistsError)
         throw e;
@@ -188,17 +197,33 @@ export class DataManager {
     }
   }
 
-  async overwritePatternInUserStorage(
+  async overwriteExistingPatternInUserStorage(
     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();
+    const oldHash = this.currentUserPatternNameToHash.get(patternName);
+
+    if (oldHash === undefined)
+      throw new Error(`Old hash is undefined`);
+    const newHash = this.getHash(patternConfig);
+    const newRecordObj = await this.getRecordFromPattern(patternConfig);
+    const timestamp = new Date().toISOString();
+    newRecordObj[R.DATE] = {
+      [D.MODIFY]: timestamp,
+    };
+    const oldPattern = await grok.dapi.userDataStorage.getValue(STORAGE_NAME, oldHash, false);
+    const oldPatternsRecord = JSON.parse(oldPattern) as PatternConfigRecord;
+    if (oldPatternsRecord[R.DATE] !== undefined && oldPatternsRecord[R.DATE][D.CREATE] != undefined)
+      newRecordObj[R.DATE][D.CREATE] = oldPatternsRecord[R.DATE][D.CREATE];
+
+    const newRecord = JSON.stringify(newRecordObj);
+    await grok.dapi.userDataStorage.postValue(STORAGE_NAME, newHash, newRecord, false);
+    await grok.dapi.userDataStorage.remove(STORAGE_NAME, oldHash, false);
+
+    this.currentUserPatternNameToHash.set(patternName, newHash);
+    eventBus.requestPatternLoad(newHash);
+    eventBus.updateUrlState(newHash);
   }
 
   async deletePattern(

package/src/apps/pattern/model/event-bus.ts

@@ -434,6 +434,8 @@ export class EventBus {
   }
 
   selectAuthor(username: string) {
+    if (typeof username !== 'string')
+      throw new Error('Selected user must be defined');
     this._patternAuthorSelection$.next(username);
   }
 

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

@@ -1,11 +1,7 @@
-/* Do not change these import lines to match external modules in webpack configuration */
-import * as grok from 'datagrok-api/grok';
-import * as ui from 'datagrok-api/ui';
-import * as DG from 'datagrok-api/dg';
-
 import {
   TERMINI, STRANDS,
-  GRAPH_SETTINGS_KEYS as G, LEGEND_SETTINGS_KEYS as L, PATTERN_RECORD_KEYS as R
+  GRAPH_SETTINGS_KEYS as G, LEGEND_SETTINGS_KEYS as L, PATTERN_RECORD_KEYS as R,
+  DATE_KEYS as D
 } from './const';
 
 export type StrandType = typeof STRANDS[number];
@@ -30,9 +26,15 @@ export type PatternLegendSettings = {
 
 export type PatternConfiguration = PatternGraphSettings & PatternLegendSettings;
 
+type DateRecord = {
+  [D.CREATE]?: string,
+  [D.MODIFY]: string;
+}
+
 export type PatternConfigRecord = {
   [R.PATTERN_CONFIG]: PatternConfiguration,
   [R.AUTHOR_ID]: string,
+  [R.DATE]?: DateRecord
 }
 
 export class PatternNameExistsError extends Error {

package/src/apps/pattern/view/components/load-block-controls.ts

@@ -94,12 +94,15 @@ export class PatternLoadControlsManager {
       possibleValues.push(this.dataManager.getOtherUsersAuthorshipCategory());
 
     const authorChoiceInput = ui.input.choice(
-      'Author', {value: this.eventBus.getSelectedAuthor(), items: possibleValues,
-        onValueChanged: (input) => {
-          this.authorSelectedByUser = true;
-          this.eventBus.selectAuthor(input.value);
-        }}
-    );
+      'Author', {value: this.eventBus.getSelectedAuthor(), items: possibleValues});
+
+    authorChoiceInput.onInput(() => {
+      this.authorSelectedByUser = true;
+      if (authorChoiceInput.value === null)
+        throw new Error('author choice must be non-null');
+      this.eventBus.selectAuthor(authorChoiceInput.value);
+    });
+
     this.setAuthorChoiceInputStyle(authorChoiceInput);
     authorChoiceInput.setTooltip('Select pattern author');
 

package/src/apps/pattern/view/components/right-section.ts

@@ -7,6 +7,7 @@ import {PatternExistsError, PatternNameExistsError} from '../../model/types';
 import {SvgDisplayManager} from '../svg-utils/svg-display-manager';
 import {NumericLabelVisibilityControls} from './numeric-label-visibility-controls';
 import {TranslationExamplesBlock} from './translation-examples-block';
+import {DEFAULT_DATE, PATTERN_RECORD_KEYS as P, DATE_KEYS as D, LEGEND_SETTINGS_KEYS as L} from '../../model/const';
 
 export class PatternAppRightSection {
   private svgDisplay: HTMLDivElement;
@@ -44,6 +45,7 @@ export class PatternAppRightSection {
       this.createSavePatternButton(),
       this.createDownloadPngButton(),
       this.createShareLinkButton(),
+      this.createInfoButton(),
     ], {style: {gap: '12px', marginTop: '12px'}});
   }
 
@@ -55,6 +57,53 @@ export class PatternAppRightSection {
     return svgDownloadButton;
   }
 
+  private createInfoButton(): HTMLButtonElement {
+    const shareLinkButton = ui.button(
+      ui.iconFA('info-circle'),
+      () => this.openInfoDialog()
+    );
+
+    this.eventBus.patternHasUnsavedChanges$.subscribe((hasUnsavedChanges: boolean) => {
+      shareLinkButton.disabled = hasUnsavedChanges;
+    });
+
+    ui.tooltip.bind(shareLinkButton, 'View pattern metadata');
+    return shareLinkButton;
+  }
+
+  private async openInfoDialog() {
+    let author = this.dataManager.getCurrentUserName();
+    let patternName = this.dataManager.getDefaultPatternName();
+    let createDate = DEFAULT_DATE;
+    let modifyDate = DEFAULT_DATE;
+    const hash = new URLSearchParams(window.location.search).get('pattern');
+    if (hash !== null) {
+      const record = await this.dataManager.getPatternRecordByHash(hash);
+      if (record !== null) {
+        const authorID = record[P.AUTHOR_ID];
+        const userFriendlyName = (await grok.dapi.users.find(authorID)).friendlyName;
+        author = userFriendlyName;
+        patternName = record[P.PATTERN_CONFIG][L.PATTERN_NAME];
+        if (record[P.DATE] !== undefined) {
+          const create = record[P.DATE][D.CREATE];
+          if (create !== undefined)
+            createDate = create;
+          const modify = record[P.DATE][D.MODIFY];
+          if (modify !== undefined)
+            modifyDate = modify;
+        }
+      }
+    }
+
+    const message = ui.divV([
+      ui.divText(`Author: ${author}`),
+      ui.divText(`Pattern Name: ${patternName}`),
+      ui.divText(`Created: ${new Date(createDate).toLocaleString()}`),
+      ui.divText(`Modified: ${new Date(modifyDate).toLocaleString()}`),
+    ]);
+    grok.shell.info(message);
+  }
+
   private createShareLinkButton(): HTMLButtonElement {
     const shareLinkButton = ui.button(
       ui.iconFA('link'),
@@ -135,7 +184,7 @@ class OverwritePatternDialog {
 
   private processOverwriteNamesakePattern(): void {
     const patternName = this.eventBus.getPatternName();
-    this.dataManager.overwritePatternInUserStorage(this.eventBus)
+    this.dataManager.overwriteExistingPatternInUserStorage(this.eventBus)
       .then(() => {
         grok.shell.info(`Pattern ${patternName} overwritten`);
       })

package/src/apps/pattern/view/ui.ts

@@ -55,7 +55,7 @@ async function getInitialPatternRecord(
     return dataManager.getDefaultPatternRecord();
   }
 
-  let initialPatternRecord = await dataManager.getPatternRecord(patternHash);
+  let initialPatternRecord = await dataManager.getPatternRecordByHash(patternHash);
   if (!initialPatternRecord) {
     urlRouter.clearPatternURL();
     initialPatternRecord = dataManager.getDefaultPatternRecord();