process

ui/src/core/extensions/extensions.ts

@@ -2,7 +2,8 @@ import { ArrayExtensions } from "./array";
 import { MapExtensions } from "./map";
 import { StringExtensions } from "./string";
 
-export type CallBackFunction = <T>(value: T) => void;
+export type CallBackVoidFunction = <T>(value: T) => void;
+export type CallBackStringVoidFunction = (value: string) => void;
 
 declare global {
   interface Array<T> {
@@ -17,7 +18,7 @@ declare global {
     isEmpty(): boolean;
   }
   interface Map<K, V> {
-    addValueOrMakeCallback(key: K, value: V, callBack: CallBackFunction): void;
+    addValueOrMakeCallback(key: K, value: V, callBack: CallBackVoidFunction): void;
   }
 }
 export const extensions = () => {

ui/src/core/model/ui_base_error.ts

@@ -0,0 +1,6 @@
+export class UiBaseError {
+  text: string;
+  constructor(text: string) {
+    this.text = text;
+  }
+}

ui/src/core/repository/http_repository.ts

@@ -16,18 +16,32 @@ export class HttpError extends Error {
 
 export class HttpRepository {
   private server = "http://localhost:4001";
+  public async formDataRequest<T>(method: HttpMethod, url: string, data?: any): Promise<Result<HttpError, T>> {
+    let formData = new FormData();
+    formData.append("file", data);
 
-  public async jsonRequest<T>(
-    method: HttpMethod,
-    url: string,
-    data?: any
-  ): Promise<Result<HttpError, T>> {
+    const reqInit = {
+      body: formData,
+      method: method,
+    };
+
+    if (data !== undefined) {
+      reqInit["body"] = data;
+    }
+    const response = await fetch(this.server + url, reqInit);
+    if (response.status !== 200) {
+      throw Result.error(new Error(await response.json()));
+    }
+    return Result.ok(response.text as T);
+  }
+  public async jsonRequest<T>(method: HttpMethod, url: string, data?: any): Promise<Result<HttpError, T>> {
     try {
       const reqInit = {
         body: data,
         method: method,
         headers: { "Content-Type": "application/json" },
       };
+      console.log(reqInit);
       if (data !== undefined) {
         reqInit["body"] = JSON.stringify(data);
       }
@@ -37,28 +51,25 @@ export class HttpRepository {
         return Result.error(new HttpError(this.server + url, response.status));
       }
 
-      return Result.ok(await  response.json());
+      return Result.ok(await response.json());
     } catch (error) {
       return Result.error(new HttpError(error, 0));
     }
   }
 
-  public async request<T>(
-    method: HttpMethod,
-    url: string,
-    data?: any
-  ): Promise<T> {
+  public async request<T>(method: HttpMethod, url: string, data?: any): Promise<Result<HttpError, T>> {
     const reqInit = {
       body: data,
       method: method,
     };
+
     if (data !== undefined) {
       reqInit["body"] = data;
     }
     const response = await fetch(this.server + url, reqInit);
     if (response.status !== 200) {
-      throw new Error(await response.json());
+      throw Result.error(new Error(await response.json()));
     }
-    return response.json();
+    return Result.ok(response.text as T);
   }
 }

ui/src/core/routers/routers.tsx

@@ -21,18 +21,17 @@ import {
   CreateProcessScreen,
   CreateProcessScreenPath,
 } from "../../features/create_process/presentation/create_process_screen";
-import { ProjectRepository } from "../../features/all_projects/data/project_repository";
 import {
   CreateProjectInstancePath,
   CreateProjectInstanceScreen,
 } from "../../features/create_project_instance/create_project_instance";
+import { SceneManger, SceneManagerPath } from "../../features/scene_manager/scene_manager";
 
 const idURL = ":id";
 
 export const router = createBrowserRouter([
   {
     path: AllProjectScreenPath,
-    loader: new ProjectRepository().loader,
     element: <AllProjectScreen />,
   },
   {
@@ -63,4 +62,8 @@ export const router = createBrowserRouter([
     path: CreateProjectInstancePath + idURL,
     element: <CreateProjectInstanceScreen />,
   },
+  {
+    path: SceneManagerPath + idURL,
+    element: <SceneManger />,
+  },
 ]);

ui/src/core/store/base_store.ts

@@ -1,22 +1,49 @@
 // TODO(IDONTSUDO): нужно переписать все  запросы под BaseStore
 
 import { Result } from "../helper/result";
+import { UiBaseError } from "../model/ui_base_error";
+import { HttpError } from "../repository/http_repository";
 
-export class BaseStore {
+export type CoreError = HttpError | Error;
+
+export abstract class UiLoader {
   isLoading = false;
-  isError = false;
-
   async loadingHelper<T>(callBack: Promise<Result<any, T>>) {
     this.isLoading = true;
 
     const result = await callBack;
     if (result.isFailure()) {
-      this.isError = true;
       this.isLoading = false;
+      this.errorHandingStrategy(result.error);
       return result.forward();
     }
 
     this.isLoading = false;
     return result;
   }
+  abstract errorHandingStrategy: (error?: any) => void;
+
+  mapOk = async <T>(property: string, callBack: Promise<Result<CoreError, T>>) => {
+    return (
+      (await this.loadingHelper(callBack))
+        // eslint-disable-next-line array-callback-return
+        .map((el) => {
+          // @ts-ignore
+          this[property] = el;
+        })
+    );
+  };
+}
+export class SimpleErrorState extends UiLoader {
+  errorHandingStrategy = () => {
+    this.isError = true;
+  };
+  isError = false;
+}
+
+export abstract class UiErrorState<T> extends UiLoader {
+  abstract errorHandingStrategy: (error: T) => void;
+  abstract init(): Promise<any>;
+  dispose() {}
+  errors: UiBaseError[] = [];
 }