Update label files while project is loaded. (microsoft#880)

simo-hsieh · web-flow · commit c9d57962d5e9 · 2021-03-04T10:58:49.000+08:00
* Match supported schema versions.

* Read $schema from file system into state asset.

* Check and update schema state and write to storage file system. 

* Write updated state to file system.
diff --git a/src/common/constants.ts b/src/common/constants.ts
@@ -11,6 +11,7 @@ const appVersion = appVersionArr.join(".");
 const enableAPIVersionSelection = appInfo.enableAPIVersionSelection;
 const enablePredictionResultUpload = appInfo.enablePredictionResultUpload;
 const apiVersion = "v2.1-preview.3";
+const supportedLabelsSchemas = new Set(["http://www.azure.com/schema/formrecognizer/labels.json", "https://schema.cognitiveservices.azure.com/formrecognizer/2021-03-01/labels.json"]);
 
 /**
  * Constants used throughout application
@@ -47,6 +48,7 @@ export const constants = {
     showOriginLabelsByDefault: true,
     fieldsSchema: "https://schema.cognitiveservices.azure.com/formrecognizer/2021-03-01/fields.json",
     labelsSchema: "https://schema.cognitiveservices.azure.com/formrecognizer/2021-03-01/labels.json",
+    supportedLabelsSchemas,
     enableMultiPageField: false,
     pdfjsWorkerSrc(version: string) {
         return `https://fotts.azureedge.net/npm/pdfjs-dist/${version}/pdf.worker.js`;
diff --git a/src/electron/providers/storage/localFileSystem.ts b/src/electron/providers/storage/localFileSystem.ts
@@ -184,6 +184,7 @@ export default class LocalFileSystem implements IStorageProvider {
                     const labelData = JSON.parse(json) as ILabelData;
                     if (labelData) {
                         asset.labelingState = labelData.labelingState || AssetLabelingState.ManuallyLabeled;
+                        asset.schema = labelData.$schema;
                     }
                 } else if (files.find((str) => str === ocrFileName)) {
                     asset.state = AssetState.Visited;
@@ -213,6 +214,7 @@ export default class LocalFileSystem implements IStorageProvider {
                     const labelData = JSON.parse(json) as ILabelData;
                     if (labelData) {
                         asset.labelingState = labelData.labelingState || AssetLabelingState.ManuallyLabeled;
+                        asset.schema = labelData.$schema;
                     }
                 } else if (files.find((str) => str === ocrFileName)) {
                     asset.state = AssetState.Visited;
diff --git a/src/models/applicationState.ts b/src/models/applicationState.ts
@@ -186,6 +186,7 @@ export interface IAsset {
     isRunningAutoLabeling?: boolean,
     cachedImage?: string,
     mimeType?: string,
+    schema?: string
 }
 
 export interface IPrebuiltSettings{
diff --git a/src/providers/storage/azureBlobStorage.ts b/src/providers/storage/azureBlobStorage.ts
@@ -219,6 +219,7 @@ export class AzureBlobStorage implements IStorageProvider {
                     const labelData = JSON.parse(json) as ILabelData;
                     if (labelData) {
                         asset.labelingState = labelData.labelingState || AssetLabelingState.ManuallyLabeled;
+                        asset.schema = labelData.$schema;
                     }
                 } else if (files.find((str) => str === ocrFileName)) {
                     asset.state = AssetState.Visited;
@@ -247,6 +248,7 @@ export class AzureBlobStorage implements IStorageProvider {
                     const labelData = JSON.parse(json) as ILabelData;
                     if (labelData) {
                         asset.labelingState = labelData.labelingState || AssetLabelingState.ManuallyLabeled;
+                        asset.schema = labelData.$schema;
                     }
                 } else if (files.find((str) => str === ocrFileName)) {
                     asset.state = AssetState.Visited;
diff --git a/src/react/components/pages/editorPage/canvas.tsx b/src/react/components/pages/editorPage/canvas.tsx
@@ -489,7 +489,7 @@ export default class Canvas extends React.Component<ICanvasProps, ICanvasState>
                         }
                     }
                 } else {
-                    if (labelsData.$schema === constants.labelsSchema) {
+                    if (constants.supportedLabelsSchemas.has(labelsData.$schema)) {
                         relatedLabel = labelsData.labels.find((label) => label.label === this.encodeLabelString(tag));
                     } else {
                         relatedLabel = labelsData.labels.find((label) => label.label === tag);
@@ -498,7 +498,7 @@ export default class Canvas extends React.Component<ICanvasProps, ICanvasState>
                 if (relatedLabel &&
                     (((relatedLabel.labelType === null || relatedLabel.labelType === undefined) && (selectedRegions[0].category === FeatureCategory.DrawnRegion))
                         || (relatedLabel.labelType !== null && relatedLabel.labelType !== undefined && relatedLabel.labelType !== selectedRegions[0].category))) {
-                    regions = this.convertLabelToRegion(relatedLabel, labelsData?.$schema === constants.labelsSchema);
+                    regions = this.convertLabelToRegion(relatedLabel, constants.supportedLabelsSchemas.has(labelsData?.$schema));
                     regions.forEach((region) => {
                         region.tags = [];
                         if (region.isTableRegion) {
@@ -1556,7 +1556,7 @@ export default class Canvas extends React.Component<ICanvasProps, ICanvasState>
 
     public convertLabelDataToRegions = (labelData: ILabelData): IRegion[] => {
         let regions = [];
-        const encodedSchema = labelData?.$schema === constants.labelsSchema;
+        const encodedSchema = constants.supportedLabelsSchemas.has(labelData?.$schema);
 
         labelData?.labels?.forEach((label) => {
             const newRegions = this.convertLabelToRegion(label, encodedSchema);
@@ -1643,7 +1643,7 @@ export default class Canvas extends React.Component<ICanvasProps, ICanvasState>
         };
 
         const labels = (this.props?.selectedAsset?.labelData?.labels?.map(label => {
-            if (this.props.selectedAsset.labelData.$schema === constants.labelsSchema) {
+            if (constants.supportedLabelsSchemas.has(this.props.selectedAsset.labelData.$schema)) {
                 return ({
                     ...label,
                     value: []
@@ -1701,7 +1701,7 @@ export default class Canvas extends React.Component<ICanvasProps, ICanvasState>
                     if (!tableTag) return
                     label = labels.find(label => label?.label === this.getTableLabelFromRegion(tableTag, tableRegion));
                 } else {
-                    if (this.props.selectedAsset.labelData?.$schema === constants.labelsSchema) {
+                    if (constants.supportedLabelsSchemas.has(this.props.selectedAsset.labelData?.$schema)) {
                         label = labels.find(label => this.decodeLabelString(label?.label) === tag);
                     } else {
                         label = labels.find(label => label?.label === tag);
diff --git a/src/react/components/pages/editorPage/editorPage.tsx b/src/react/components/pages/editorPage/editorPage.tsx
@@ -341,7 +341,7 @@ export default class EditorPage extends React.Component<IEditorPageProps, IEdito
                                     lockedTags={this.state.lockedTags}
                                     selectedRegions={this.state.selectedRegions}
                                     labels={labels}
-                                    encoded={selectedAsset?.labelData?.$schema === constants.labelsSchema}
+                                    encoded={constants.supportedLabelsSchemas.has(selectedAsset?.labelData?.$schema)}
                                     tableLabels={tableLabels}
                                     pageNumber={this.state.pageNumber}
                                     onChange={this.onTagsChanged}
diff --git a/src/redux/actions/projectActions.test.ts b/src/redux/actions/projectActions.test.ts
@@ -127,7 +127,7 @@ describe("Project Redux Actions", () => {
         mockAssetService.prototype.getAssets = jest.fn(() => Promise.resolve(testAssets));
 
         const project = MockFactory.createTestProject("TestProject");
-        const results = await projectActions.loadAssets(project)(store.dispatch);
+        const results = await projectActions.loadAssets(project)(store.dispatch, store.getState);
         const actions = store.getActions();
 
         expect(actions.length).toEqual(1);
diff --git a/src/redux/actions/projectActions.ts b/src/redux/actions/projectActions.ts
@@ -28,6 +28,9 @@ import { toast } from 'react-toastify';
 import { strings, interpolate } from "../../common/strings";
 import clone from "rfdc";
 import _ from "lodash";
+import { decryptProject } from "../../common/utils";
+import { StorageProviderFactory } from "../../providers/storage/storageProviderFactory";
+import { constants } from "../../common/constants";
 
 /**
  * Actions to be performed in relation to projects
@@ -88,9 +91,9 @@ export function loadProject(project: IProject, sharedToken?: ISecurityToken):
             throw new AppError(ErrorCode.SecurityTokenNotFound, "Security Token Not Found");
         }
         const loadedProject = await projectService.load(project, projectToken);
-
-        dispatch(loadProjectAction(loadedProject));
-        return loadedProject;
+        const schemaUpdatedProject = await AssetService.checkAndUpdateSchema(loadedProject);
+        dispatch(loadProjectAction(schemaUpdatedProject));
+        return schemaUpdatedProject;
     };
 }
 
@@ -104,25 +107,22 @@ export function saveProject(project: IProject, saveTags?: boolean, updateTagsFro
         project = Object.assign({}, project);
         const appState = getState();
         const projectService = new ProjectService();
-
         if (projectService.isDuplicate(project, appState.recentProjects)) {
             throw new AppError(ErrorCode.ProjectDuplicateName, `Project with name '${project.name}
                 already exists with the same target connection '${project.sourceConnection.name}'`);
         }
-
-        const projectToken = appState.appSettings.securityTokens
-            .find((securityToken) => securityToken.name === project.securityToken);
-
-        if (!projectToken) {
-            throw new AppError(ErrorCode.SecurityTokenNotFound, "Security Token Not Found");
+        const findMatchToken = (tokens, project) => {
+            const tokenFinded = tokens.find((securityToken) => securityToken.name === project.securityToken);
+            if (!tokenFinded) {
+                throw new AppError(ErrorCode.SecurityTokenNotFound, "Security Token Not Found");
+            }
+            return tokenFinded;
         }
 
+        const projectToken = findMatchToken(appState.appSettings.securityTokens, project);
         const savedProject = await projectService.save(project, projectToken, saveTags, updateTagsFromFiles);
         dispatch(saveProjectAction(savedProject));
-
-        // Reload project after save actions
-        await loadProject(savedProject)(dispatch, getState);
-
+        dispatch(loadProjectAction(await decryptProject(savedProject, projectToken)));
         return savedProject;
     };
 }
@@ -215,14 +215,24 @@ export function deleteAsset(project: IProject, assetMetadata: IAssetMetadata): (
  * Gets assets from project, dispatches load assets action and returns assets
  * @param project - Project from which to load assets
  */
-export function loadAssets(project: IProject): (dispatch: Dispatch) => Promise<IAsset[]> {
-    return async (dispatch: Dispatch) => {
+export function loadAssets(project: IProject): (dispatch: Dispatch, getState: () => IApplicationState) => Promise<IAsset[]> {
+    return async (dispatch: Dispatch, getState: () => IApplicationState) => {
         const assetService = new AssetService(project);
         const assets = await assetService.getAssets();
+        let shouldAssetsUpdate = false;
+        for (const asset of assets) {
+            if (AssetService.shouldSchemaUpdate(asset.schema)) {
+                shouldAssetsUpdate = true;
+                asset.schema = constants.labelsSchema;
+            }
+        }
         if (!areAssetsEqual(assets, project.assets)) {
             dispatch(loadProjectAssetsAction(assets));
         }
-
+        if (shouldAssetsUpdate) {
+            const {currentProject} = getState();
+            await AssetService.checkAndUpdateSchema(currentProject);
+        }
         return assets;
     };
 }
diff --git a/src/services/assetService.ts b/src/services/assetService.ts
@@ -444,7 +444,7 @@ export class AssetService {
             if (tagType === FieldType.Object || tagType === FieldType.Array) {
                 labelData.labels = labelData.labels.filter((label) => label.label.split("/")[0].replace(/~1/g, "/").replace(/~0/g, "~") !== tagName);
             } else {
-                if (labelData?.$schema === constants.labelsSchema) {
+                if (constants.supportedLabelsSchemas.has(labelData?.$schema)) {
                     labelData.labels = labelData.labels.filter((label) => label.label.replace(/~1/g, "/").replace(/~0/g, "~") !== tagName);
                 } else {
                     labelData.labels = labelData.labels.filter((label) => label.label !== tagName);
@@ -739,4 +739,39 @@ export class AssetService {
         };
         return new Promise(checkSucceeded);
     }
+
+    /**
+     * Chech and update schema version through label.json files relate to project assets.
+     * @param project to get assets and connect to file system.
+     * @returns updated project
+     */
+    public static checkAndUpdateSchema = async(project: IProject): Promise<IProject> => {
+        let shouldAssetsUpdate = false;
+        let updatedProject;
+        const { assets } = project;
+        const shouldSchemaUpdate = schema => constants.supportedLabelsSchemas.has(schema) && schema !== constants.labelsSchema;
+        if (_.isPlainObject(assets)) {
+            const assetService = new AssetService(project);
+            const assetMetadatas: IAssetMetadata[] = await Promise.all(Object.values(assets).map(async (asset) => await assetService.getAssetMetadata(asset)));
+            await Promise.all(assetMetadatas.map(async (assetMetadata) => {
+                if (_.isPlainObject(assetMetadata.labelData) && AssetService.shouldSchemaUpdate(assetMetadata.labelData?.$schema)) {
+                    shouldAssetsUpdate = true;
+                    assetMetadata.labelData = { ...assetMetadata.labelData, "$schema": constants.labelsSchema };
+                    await assetService.save(assetMetadata);
+                }
+            }))
+            const updatedAssets = { ...assets };
+            for (const [assetID, asset] of Object.entries(assets)) {
+                if (shouldSchemaUpdate(asset.schema)) {
+                    updatedAssets[assetID] = { ...assets[assetID], schema: constants.labelsSchema };
+                }
+            }
+            updatedProject = { ...project, assets: updatedAssets };
+        }
+        return shouldAssetsUpdate ? updatedProject : project;
+    }
+
+    public static shouldSchemaUpdate = (schema: string): boolean => {
+        return constants.supportedLabelsSchemas.has(schema) && schema !== constants.labelsSchema;
+    }
 }
diff --git a/src/services/projectService.ts b/src/services/projectService.ts
@@ -249,11 +249,11 @@ export default class ProjectService implements IProjectService {
                         if (!assetLabel || assetLabel === blob) {
                             const content = JSON.parse(await storageProvider.readText(blob)) as ILabelData;
                             content.labels.forEach((label) => {
-                                if (content?.$schema === constants.labelsSchema && label.label.split("/").length > 1) {
+                                if (constants.supportedLabelsSchemas.has(content?.$schema) && label.label.split("/").length > 1) {
                                     return;
                                 }
                                 let labelName;
-                                if (content?.$schema === constants.labelsSchema) {
+                                if (constants.supportedLabelsSchemas.has(content?.$schema)) {
                                     labelName = label.label.replace(/~1/g, "/").replace(/~0/g, "~");
                                 } else {
                                     labelName = label.label
@@ -411,13 +411,13 @@ export default class ProjectService implements IProjectService {
         project.tags = [...project.tags, ...missingTags];
     }
 
-    // private async getAllTagsInProjectCount(project: IProject, tags: ITag[]) {}
+    // public async getAllTagsInProjectCount(project: IProject, tags: ITag[]) {}
     /**
      * Save fields.json
      * @param project the project we're trying to create
      * @param storageProvider the storage we're trying to save the project
      */
-    private async saveFieldsFile(project: IProject, storageProvider: IStorageProvider) {
+    public async saveFieldsFile(project: IProject, storageProvider: IStorageProvider) {
         Guard.null(project);
         Guard.null(project.tags);
 

Original file line number	Diff line number	Diff line change
`@@ -186,6 +186,7 @@ export interface IAsset {`
`186`	`186`	`isRunningAutoLabeling?: boolean,`
`187`	`187`	`cachedImage?: string,`
`188`	`188`	`mimeType?: string,`
	`189`	`+ schema?: string`
`189`	`190`	`}`
`190`	`191`
`191`	`192`	`export interface IPrebuiltSettings{`