@nyris/nyris-webapp 0.3.3 → 0.3.6

package/src/epics/search.ts

@@ -0,0 +1,203 @@
+import {EpicConf} from "./types";
+import {combineEpics, ofType} from "redux-observable";
+import {switchMap, withLatestFrom} from "rxjs/operators";
+import {AppAction} from "../types";
+import {ImageSearchOptions, urlOrBlobToCanvas, isCadFile, isImageFile, Filter } from "@nyris/nyris-api";
+import {imageLoaded, cadFileLoaded} from "../actions/searchActions";
+
+const imageSearch: EpicConf = (action$, state$, {api}) => action$.pipe(
+    ofType('SEARCH_REQUEST_START'),
+    withLatestFrom(state$),
+    switchMap(async ([action, state]) : Promise<AppAction> => {
+        if (action.type !== 'SEARCH_REQUEST_START') {
+            throw new Error(`Wrong action type ${action.type}`);
+        }
+        console.log("state search ");
+        console.log(state.search.selectedFilters);
+        
+        if ('image' in action) {
+            let { image, normalizedRect} = action;
+            console.log("Selected Filters");
+            let selectedFilters = new Array<Filter>();
+             if(state.search.selectedFilters.size > 0 ){          
+                state.search.selectedFilters.forEach((values, key) => {
+                    let filterObj: Filter ={
+                        key : key,
+                        values : values
+                    }
+                  selectedFilters.push(filterObj);
+                });
+             }
+           
+            let options : ImageSearchOptions = {
+                cropRect: normalizedRect
+            };
+
+            try {
+                if(selectedFilters && selectedFilters.length> 0)
+                {
+                    console.log("With Filters");
+                    const {results, duration, requestId, categoryPredictions, codes} = await api.findByImageWithFilters(image, options, selectedFilters);
+                    return ({ type: 'SEARCH_REQUEST_SUCCEED', results, requestId, duration, categoryPredictions, codes });
+               
+                }
+                else{
+                    console.log("Without Filters");
+                    const {results, duration, requestId, categoryPredictions, codes} = await api.findByImage(image, options);
+                    return ({ type: 'SEARCH_REQUEST_SUCCEED', results, requestId, duration, categoryPredictions, codes });            
+                }
+            } catch (e) {
+                console.warn('search failed', e);
+                return ({ type: 'SEARCH_REQUEST_FAIL', reason: e.message, exception: e });
+            }
+        }
+
+        if ('file' in action) {
+            console.log('file');
+            let { file } = action;
+
+            let options : ImageSearchOptions = { };
+
+            try {
+                const {results, duration, requestId, categoryPredictions, codes} = await api.findByCad(file, options);
+                return ({ type: 'SEARCH_REQUEST_SUCCEED', results, requestId, duration, categoryPredictions, codes });
+            } catch (e) {
+                console.warn('search failed', e);
+                return ({ type: 'SEARCH_REQUEST_FAIL', reason: e.message, exception: e });
+            }
+        }
+        throw new Error(`Wrong action content ${action}`);
+    })
+);
+
+const regionSearch: EpicConf = (action$, state$, {api}) => action$.pipe(
+    ofType('REGION_REQUEST_START'),
+    withLatestFrom(state$),
+    switchMap(async ([action, {settings}]) : Promise<AppAction> => {
+        if (action.type !== 'REGION_REQUEST_START') {
+            throw new Error(`Wrong action type ${action.type}`);
+        }
+
+        let { image } = action;
+
+        try {
+            let regions = await api.findRegions(image);
+            return {type: 'REGION_REQUEST_SUCCEED', regions };
+
+        } catch (e) {
+            console.error(e);
+            return {type: 'REGION_REQUEST_FAIL', reason: e.message, exception: e};
+        }
+    })
+);
+
+const loadFile: EpicConf = (action$) => action$.pipe(
+    ofType('LOAD_FILE'),
+    switchMap(async (action) : Promise<AppAction> => {
+        if (action.type !== 'LOAD_FILE') {
+            throw new Error(`Wrong action type ${action.type}`);
+        }
+        const randomId = Math.random().toString();
+        if ('file' in action) {
+            const file = action.file;
+            if (isImageFile(file)) {
+                return imageLoaded(await urlOrBlobToCanvas(file), randomId);
+            }
+            if (isCadFile(file)) {
+                return cadFileLoaded(file, randomId);
+            }
+        }
+        throw new Error(`LOAD_FILE action wrong properties ${Object.keys(action).join(',')}`);
+    })
+);
+
+const loadImage: EpicConf = (action$) => action$.pipe(
+    ofType('LOAD_IMAGE'),
+    switchMap(async (action) : Promise<AppAction> => {
+        if (action.type !== 'LOAD_IMAGE') {
+            throw new Error(`Wrong action type ${action.type}`);
+        }
+        const randomId = Math.random().toString();
+        if ('url' in action) {
+            return imageLoaded(await urlOrBlobToCanvas(action.url), randomId);
+        }
+        if ('file' in action) {
+            return imageLoaded(await urlOrBlobToCanvas(action.file), randomId);
+        }
+        if ('image' in action) {
+            return imageLoaded(action.image, randomId);
+        }
+        throw new Error(`LOAD_IMAGE action wrong properties ${Object.keys(action).join(',')}`);
+    })
+);
+
+
+const loadFilters: EpicConf = (action$, state$, {api}) => action$.pipe(
+    ofType('LOAD_FILTERS'),
+    withLatestFrom(state$),
+    switchMap(async ([action, state]) : Promise<AppAction> => {
+        if(action.type !== 'LOAD_FILTERS'){
+            throw new Error(`Wrong action type ${action.type}`);
+        }
+        try {
+            // use find filters
+
+            let filters = await api.getFilters();
+    
+            filters= filters.slice(0, 3);
+            console.log(filters);
+            // let filters : Filter[] = [
+            //     {
+            //         filterType: 'MachineType',
+            //         filterValues : [
+            //              "MachineType1",
+            //              "MachineType2",
+            //              "MachineType3",
+            //              "MachineType4",
+            //              "MachineType5"
+            //        ]
+            //     },
+            //     {
+            //         filterType: 'Color',
+            //         filterValues :[
+            //             "Red",
+            //             "Green",
+            //             "Blue",
+            //             "Yellow",
+            //             "Black"
+            //         ]
+            //     }];                            
+            return {type: 'LOAD_FILTERS_SUCCESS', filters };
+
+        } catch (e) {
+            console.error(e);
+            return {type: 'LOAD_FILTERS_FAIL', reason: e.message, exception: e};
+        }
+    })
+);
+
+const addToSelectedFilters: EpicConf = (action$) => action$.pipe(
+    ofType('ADD_TO_SELECTEDFILTERS'),
+    switchMap(async (action) : Promise<AppAction> => {
+
+        if(action.type !== 'ADD_TO_SELECTEDFILTERS'){
+            throw new Error(`Wrong action type ${action.type}`);
+        }
+         if('key' in action && 'value' in action){
+         
+            let {key, value} = action;
+            console.log(key);
+            console.log(action);
+            return {type : 'ADD_TO_SELECTEDFILTERS_SUCCESS', key , value }
+         }
+         throw new Error(`Change filters action wrong properties ${Object.keys(action).join(',')}`);
+    })
+);
+
+export default combineEpics(
+    imageSearch,
+    regionSearch,
+    loadFile,
+    loadImage,
+    loadFilters,
+    addToSelectedFilters);

package/src/{Store/epics → epics}/types.ts

@@ -1,6 +1,6 @@
 import NyrisAPI from "@nyris/nyris-api";
 import {Epic} from "redux-observable";
-import {AppAction, AppState} from "../../types";
+import {AppAction, AppState} from "../types";
 import {History} from "history";
 
 export interface EpicsDependencies {