@nyris/nyris-webapp 0.3.5 → 0.3.12

package/src/epics/search.ts

@@ -0,0 +1,239 @@
+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}`);
+      }
+      if ("image" in action) {
+        let { image, normalizedRect } = action;
+
+        // refactor this
+        let selectedFilters = new Array<Filter>();
+        if (state.search.selectedFilters.size > 0) {
+          state.search.selectedFilters.forEach((values, key) => {
+            if (values && values.length > 0) {
+              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);
+        return { type: "LOAD_FILTERS_SUCCESS", filters };
+      } catch (e) {
+        console.error(e);
+        return { type: "LOAD_FILTERS_FAIL", reason: e.message, exception: e };
+      }
+    })
+  );
+
+const searchFilters: EpicConf = (action$, state$, { api }) =>
+  action$.pipe(
+    ofType("SEARCH_FILTERS"),
+    withLatestFrom(state$),
+    switchMap(async ([action, state]): Promise<AppAction> => {
+      if (action.type !== "SEARCH_FILTERS") {
+        throw new Error(`Wrong action type ${action.type}`);
+      }
+      try {
+        // use find filters
+        let { key, value } = action;
+        let values: string[] = [];
+        if (value) {
+          let response = await api.searchFilters(key, value);
+          if (response && response.length > 0) {
+            values = values.concat(await api.searchFilters(key, value));
+          }
+        } else {
+          // if no value load default values in search
+          let defaultfilters = await api.getFilters();
+          let filter = defaultfilters.find((x) => x.key === key);
+          if (filter && filter.values && filter.values.length > 0) {
+            values = filter.values;
+          }
+        }
+        return { type: "UPDATE_FILTERS", key, values };
+      } catch (e) {
+        console.error(e);
+        return { type: "LOAD_FILTERS_FAIL", reason: e.message, exception: e };
+      }
+    })
+  );
+
+export default combineEpics(
+  imageSearch,
+  regionSearch,
+  loadFile,
+  loadImage,
+  loadFilters,
+  searchFilters
+);

package/src/epics/types.ts

@@ -0,0 +1,12 @@
+import NyrisAPI from "@nyris/nyris-api";
+import {Epic} from "redux-observable";
+import {AppAction, AppState} from "../types";
+import {History} from "history";
+
+export interface EpicsDependencies {
+    api: NyrisAPI,
+    history: History
+}
+
+export type EpicConf = Epic<AppAction, AppAction, AppState, EpicsDependencies>;
+