Merge pull request #4 from Yadro/features-v1.0.2v2

Features v1.0.2

Author: Yadro

.env.example

@@ -1 +1,4 @@
 SENTRY_DSN='https://XXXX.ingest.sentry.io/00000000'
+GA_UACODE=UA-XXXXXXXXXX
+# DEBUG=universal-analytics
+# NODE_DEBUG=request # debug requests in analytics

package.json

@@ -200,7 +200,7 @@
     "@ant-design/colors": "6.0.0",
     "@ant-design/icons": "4.6.2",
     "@sentry/electron": "2.5.0",
-    "antd": "4.15.0",
+    "antd": "4.16.7",
     "caniuse-lite": "1.0.30001214",
     "clsx": "^1.1.1",
     "date-fns": "2.20.1",
@@ -221,7 +221,8 @@
     "react-jss": "^10.6.0",
     "react-router-dom": "^5.2.0",
     "regenerator-runtime": "^0.13.5",
-    "source-map-support": "^0.5.19"
+    "source-map-support": "^0.5.19",
+    "universal-analytics": "^0.4.23"
   },
   "devEngines": {
     "node": ">=10.x",

src/App.tsx

@@ -1,15 +1,20 @@
 import React from 'react';
-import { BrowserRouter as Router } from 'react-router-dom';
-import { observer } from 'mobx-react';
+import { BrowserRouter } from 'react-router-dom';
 
 import Main from './screens/Main';
 import 'antd/dist/antd.less';
 import './App.global.less';
 
-export default observer(() => {
+const App = () => {
+  // useEffect(() => {
+  //   Sentry.captureException(new Error(`${process.env.NODE_ENV} exception`));
+  // }, []);
+
   return (
-    <Router>
+    <BrowserRouter>
       <Main />
-    </Router>
+    </BrowserRouter>
   );
-});
+};
+
+export default App;

src/base/AbstractServiceWithProfile.ts

@@ -0,0 +1,15 @@
+import AbstractFileRepository from './repositories/AbstractFileRepository';
+import IService from './IService';
+
+export default abstract class AbstractServiceWithProfile<T>
+  implements IService<T> {
+  protected repository: AbstractFileRepository | undefined;
+
+  setProfile(profile: string) {
+    this.repository?.setProfile(profile);
+  }
+
+  abstract getAll(): T;
+
+  abstract save(data: T): void;
+}

src/base/TreeModelHelper.ts

@@ -0,0 +1,77 @@
+import { ITreeItem } from '../types/ITreeItem';
+
+const TreeModelHelper = {
+  modifyItemsWithIdsRecursive<T extends ITreeItem<any>>(
+    treeItems: T[],
+    ids: string[],
+    fn: (treeItem: T, ids: string[]) => void
+  ) {
+    treeItems.forEach((item) => {
+      fn(item, ids);
+      if (Array.isArray(item.children) && item.children.length) {
+        TreeModelHelper.modifyItemsWithIdsRecursive(item.children, ids, fn);
+      }
+    });
+  },
+
+  getItemRecursive<T extends ITreeItem<any>>(
+    tasks: T[],
+    condition: (task: T) => boolean
+  ): T | undefined {
+    for (const task of tasks) {
+      if (condition(task)) {
+        return task;
+      }
+      if (Array.isArray(task.children)) {
+        const found = this.getItemRecursive(task.children, condition);
+        if (found) {
+          return found;
+        }
+      }
+    }
+    return undefined;
+  },
+
+  getFlatItemsRecursive<T extends ITreeItem<any>>(
+    tree: T[],
+    condition: (task: T) => boolean
+  ): T[] {
+    const result: T[] = [];
+
+    this.getFlatItemsRecursiveBase(tree, condition, result);
+
+    return result;
+  },
+
+  getFlatItemsRecursiveBase<T extends ITreeItem<any>>(
+    treeItems: T[],
+    condition: (item: T) => boolean,
+    result: T[]
+  ): T[] {
+    for (const item of treeItems) {
+      if (condition(item)) {
+        result.push(item);
+      }
+      if (Array.isArray(item.children)) {
+        this.getFlatItemsRecursiveBase(item.children, condition, result);
+      }
+    }
+    return result;
+  },
+
+  deleteItems<T extends ITreeItem<any>>(
+    treeItems: T[],
+    condition: (task: T) => boolean
+  ): T[] {
+    const result = treeItems.filter((t) => !condition(t));
+    for (let i = 0; i < result.length; i++) {
+      const task = treeItems[i];
+      if (Array.isArray(task.children)) {
+        treeItems[i].children = this.deleteItems(task.children, condition);
+      }
+    }
+    return result;
+  },
+};
+
+export default TreeModelHelper;

src/base/TreeModelStoreHelper.ts

@@ -2,41 +2,60 @@ const fs = require('fs');
 const path = require('path');
 
 import FsHelper from '../../helpers/FsHelper';
+import PromiseQueue from '../../helpers/PromiseQueueHellper';
 
-const APP_FOLDER = 'YadroTimeTracker';
-const PROFILE_FOLDER = 'profile1';
+const APP_DIR = 'YadroTimeTracker_test';
 
 export default abstract class AbstractFileRepository<T = any> {
-  folderWithProfile: string = 'profile1';
+  dirWithProfileData: string = 'profile1';
   fileName: string = 'defaultFileName.json';
+  saveInRoot: boolean = false;
+
+  writeFileQueue = new PromiseQueue();
+
+  private get logPrefix() {
+    const filePath = !this.saveInRoot ? this.dirWithProfileData : '';
+    return `FileRepository [${filePath}/${this.fileName}]:`;
+  }
 
   private static get appDataFolder() {
     return process.env.APPDATA || '';
   }
 
-  private static get profileFolder() {
-    return path.join(
-      AbstractFileRepository.appDataFolder,
-      APP_FOLDER,
-      PROFILE_FOLDER,
-    );
+  private get destFolder() {
+    const pathItems = [AbstractFileRepository.appDataFolder, APP_DIR];
+    if (!this.saveInRoot) {
+      pathItems.push(this.dirWithProfileData);
+    }
+    return path.join(...pathItems);
   }
 
   private get filePath() {
-    return path.join(AbstractFileRepository.profileFolder, this.fileName);
+    return path.join(this.destFolder, this.fileName);
+  }
+
+  public setProfile(profile: string) {
+    this.dirWithProfileData = profile;
   }
 
   public restore(defaultValue: T): T {
+    console.log(`${this.logPrefix} restore`);
     if (fs.existsSync(this.filePath)) {
-      const data = fs.readFileSync(this.filePath);
+      const data = fs.readFileSync(this.filePath, { encoding: 'utf-8' });
       // TODO handle parse error. Backup file with issues and return defaultValue
       return JSON.parse(data);
     }
     return defaultValue;
   }
 
   public save(data: T) {
-    FsHelper.mkdirIfNotExists(AbstractFileRepository.profileFolder);
-    return FsHelper.writeFile(this.filePath, data);
+    FsHelper.mkdirIfNotExists(this.destFolder);
+    this.writeFileQueue.add(() => {
+      console.log(`${this.logPrefix} save`);
+      return FsHelper.writeFile(this.filePath, data).catch(() => {
+        console.error(`${this.logPrefix} can't save file '${this.filePath}'`);
+      });
+    });
+    this.writeFileQueue.execute();
   }
 }

src/base/repositories/AbstractFileRepository.ts

@@ -6,7 +6,7 @@ import { createUseStyles } from 'react-jss';
 
 import CircleButton from '../CircleButton/CircleButton';
 import rootStore from '../../modules/RootStore';
-import TaskModel from '../../models/TaskModel';
+import TaskModel from '../../modules/tasks/models/TaskModel';
 
 const { tasksStore } = rootStore;
 
@@ -27,7 +27,7 @@ export default observer(function PlayStopButton({
       if (!task?.active) {
         tasksStore.startTimer(task);
       } else {
-        tasksStore.stopTimer(task);
+        tasksStore.stopTimer();
       }
     }
   }

src/components/PlayStopButton/PlayStopButton.tsx

@@ -0,0 +1,35 @@
+import React from 'react';
+import { Space } from 'antd';
+import { SettingOutlined } from '@ant-design/icons';
+import { createUseStyles } from 'react-jss';
+
+import rootStore from '../../modules/RootStore';
+import useModal from '../../hooks/ModalHook';
+import SettingsModal from '../SettingsModal/SettingsModal';
+
+const { settingsStore } = rootStore;
+
+const Profile: React.VFC = () => {
+  const classes = useStyles();
+  const { settings } = settingsStore;
+  const { open, openModal, closeModal } = useModal();
+
+  return (
+    <Space className={classes.root}>
+      <span className={classes.white}>{settings.currentProfile}</span>
+      <SettingOutlined className={classes.white} onClick={openModal} />
+      <SettingsModal visible={open} onClose={closeModal} />
+    </Space>
+  );
+};
+
+const useStyles = createUseStyles({
+  root: {
+    marginLeft: 16,
+  },
+  white: {
+    color: 'white',
+  },
+});
+
+export default Profile;