Time intervals

Author: Stigmatoz

src/compositions/daily-intervals.ts

@@ -1,12 +1,12 @@
 import { TimeInterval } from "../entity/time-interval";
 import { injecStorage } from "../storage/inject-storage";
-import { StorageParams } from "../storage/storage-params";
+import { StorageDeserializeParam, StorageParams } from "../storage/storage-params";
 import { todayLocalDate } from "../utils/common";
 
 export async function closeInterval(domain:string | null): Promise<void>{
     if (domain == null) return;
     const storage = injecStorage();
-    const timeIntervalList = await storage.getValue(StorageParams.TIMEINTERVAL_LIST) as TimeInterval[];
+    const timeIntervalList = await storage.getDeserializeList(StorageDeserializeParam.TIMEINTERVAL_LIST) as TimeInterval[];
     const item = timeIntervalList?.find(x => x.domain === domain && x.day == todayLocalDate());
     item?.closeInterval();
     await storage.saveValue(StorageParams.TIMEINTERVAL_LIST, timeIntervalList);
@@ -16,18 +16,22 @@ export async function addInterval(domain:string | null): Promise<void>{
     if (domain == null) return;
 
     const storage = injecStorage();
-    const timeIntervalList = await storage.getValue(StorageParams.TIMEINTERVAL_LIST) as TimeInterval[];
+    let timeIntervalList = await storage.getDeserializeList(StorageDeserializeParam.TIMEINTERVAL_LIST) as TimeInterval[];
+    if (timeIntervalList == undefined)
+        timeIntervalList = [];
     const item = timeIntervalList?.find(x => x.domain === domain && x.day == todayLocalDate());
     if (item != undefined) {
         if (item.day == todayLocalDate())
             item.addInterval();
         else {
-            const newInterval = new TimeInterval(todayLocalDate(), domain);
+            const newInterval = new TimeInterval();
+            newInterval.init(todayLocalDate(), domain);
             newInterval.addInterval();
             timeIntervalList.push(newInterval);
         }
     } else {
-        const newInterval = new TimeInterval(todayLocalDate(), domain);
+        const newInterval = new TimeInterval();
+        newInterval.init(todayLocalDate(), domain);
         newInterval.addInterval();
         timeIntervalList.push(newInterval);
     }

src/entity/ISerializable.ts

@@ -0,0 +1,3 @@
+interface ISerializable<T> {
+    deserialize(input: Object): T;
+}

src/entity/tab.ts

@@ -1,10 +1,7 @@
 import { todayLocalDate } from "../utils/common";
+import { logger } from "../compositions/logger";
 
-interface Serializable<T> {
-    deserialize(input: Object): T;
-}
-
-export class Tab implements Serializable<Tab> {
+export class Tab implements ISerializable<Tab> {
     url: string = '';
     favicon: string = '';
     summaryTime: number = 0;
@@ -17,7 +14,8 @@ export class Tab implements Serializable<Tab> {
     }
 
     incSummaryTime() :void {
-        this.summaryTime += 1;  
+        this.summaryTime += 1;
+        //logger.log(`Summary time ${this.url} - ${this.summaryTime}`);
 
         const day = this.days.find(x => x.date == todayLocalDate());
         if (day === undefined) 
@@ -27,6 +25,7 @@ export class Tab implements Serializable<Tab> {
 
     incCounter() :void {
         this.counter +=1;
+        logger.log(`Counter ${this.url} - ${this.counter}`);
         const day = this.days.find(x => x.date == todayLocalDate());
         if (day === undefined)
             this.addNewDay();
@@ -51,7 +50,7 @@ export class Tab implements Serializable<Tab> {
     }
 }
 
-export class TabDay implements Serializable<TabDay> {
+export class TabDay implements ISerializable<TabDay> {
     counter: number = 0;
     date: string = '';
     summary: number = 0;

src/entity/time-interval.ts

@@ -1,9 +1,11 @@
-export class TimeInterval {
-    domain: string;
+import { logger } from "../compositions/logger";
+
+export class TimeInterval implements ISerializable<TimeInterval> {
+    domain: string = '';
     intervals: any;
-    day: string;
+    day: string = '';
 
-    constructor(day:string, domain:string) {
+    init(day:string, domain:string) {
         this.domain = domain;
         this.intervals = [];
         this.day = day;
@@ -12,19 +14,29 @@ export class TimeInterval {
     addInterval() {
         const stringDate = this.getCurrentStringDate();
         this.intervals.push(stringDate + '-' + stringDate);
+        logger.log(`Add interval ${this.domain} - ${stringDate} - ${stringDate}`);
     }
 
     closeInterval() {
         const stringDate = this.getCurrentStringDate();
         const currentInterval = this.intervals[this.intervals.length - 1];
-        if (!currentInterval) {
+        if (currentInterval != null) {
             if (currentInterval.split('-')[0] == currentInterval.split('-')[1]) {
                 this.intervals.pop();
                 this.intervals.push(currentInterval.split('-')[0] + '-' + stringDate);
+                logger.log(`Close interval ${this.domain} - ${currentInterval.split('-')[0]} - ${stringDate}`);
             }
         }
     }
 
+    deserialize(input: TimeInterval): TimeInterval {
+        this.domain = input.domain;
+        this.day = input.day;
+        this.intervals = input.intervals;
+
+        return this;
+    }
+
     private getCurrentStringDate():string{
         const date = new Date();
         return date.getHours() + ':' + date.getMinutes() + ':' + date.getSeconds();

src/repository/tabs-repository-interface.ts

@@ -4,5 +4,5 @@ import Browser from 'webextension-polyfill';
 export interface ITabsRepository {
     getTabs(): Tab[];
     getTab(domain:string): Tab | undefined;
-    addTab(tab:Browser.Tabs.Tab): Promise<void>;
+    addTab(tab:Browser.Tabs.Tab): Promise<Tab | null>;
 }

src/repository/tabs-repository.ts

@@ -5,19 +5,17 @@ import { injecStorage } from "../storage/inject-storage";
 import { isValidPage } from '../compositions/valid-page';
 import { isInBlackList } from "../compositions/black-list";
 import { extractHostname } from "../compositions/extract-hostname";
-import { addInterval, closeInterval } from "../compositions/daily-intervals";
-import { ActiveTab } from "../compositions/activeTab"
+import { StorageDeserializeParam } from "../storage/storage-params";
 
 export class TabsRepository implements ITabsRepository {
     private tabs: Tab[];
-    private activeTab = ActiveTab.getInstance();
 
     constructor() {
         this.tabs = [];
     }
 
     async initAsync(){
-        this.tabs = await injecStorage().getTabs();
+        this.tabs = await injecStorage().getDeserializeList(StorageDeserializeParam.TABS) as Tab[];
     }
 
     getTabs(): Tab[] {
@@ -28,7 +26,7 @@ export class TabsRepository implements ITabsRepository {
         return this.tabs?.find(x => x.url === domain);
     }
 
-    async addTab(tab: Browser.Tabs.Tab): Promise<void> {
+    async addTab(tab: Browser.Tabs.Tab): Promise<Tab | undefined> {
         if (isValidPage(tab)) {
             if (tab.id && (tab.id != 0)) {
                 const domain = extractHostname(tab.url);
@@ -44,20 +42,12 @@ export class TabsRepository implements ITabsRepository {
                         const newTab = new Tab();
                         newTab.init(domain, favicon);
                         this.tabs.push(newTab);
-                    }
-                    else {
-                        tabFromStorage.incCounter();
-                        if (this.activeTab.getActiveTab() != domain) this.setCurrentActiveTab(domain);
-                        await closeInterval(this.activeTab.getActiveTab());
-                        await addInterval(this.activeTab.getActiveTab());
+                        return newTab;
                     }
                 }
-                else await closeInterval(this.activeTab.getActiveTab());
             }
-        } else await closeInterval(this.activeTab.getActiveTab());
-    }
+        }
 
-    private setCurrentActiveTab(domain:string){
-        this.activeTab.setActiveTab(domain);
+        return undefined;
     }
 }