Move action and task handlers in their own space

src/Action/ActionController.ts

@@ -1,46 +0,0 @@
-import { Scheduler } from '../Scheduler';
-import { taskError, TryLaterError } from '../Errors';
-import { grabActiveVillageId } from '../Page/VillageBlock';
-import { Args } from '../Queue/Args';
-import { Task } from '../Queue/TaskProvider';
-import { VillageStorage } from '../Storage/VillageStorage';
-import { VillageFactory } from '../Village/VillageFactory';
-import { aroundMinutes } from '../Helpers/Time';
-
-const actionMap: { [name: string]: Function | undefined } = {};
-
-export function registerAction(constructor: Function) {
-    actionMap[constructor.name] = constructor;
-}
-
-export function createActionHandler(
-    name: string,
-    scheduler: Scheduler,
-    villageFactory: VillageFactory
-): ActionController | undefined {
-    const storedFunction = actionMap[name];
-    if (storedFunction === undefined) {
-        return undefined;
-    }
-    const constructor = (storedFunction as unknown) as typeof ActionController;
-    return new constructor(scheduler, villageFactory);
-}
-
-export class ActionController {
-    protected readonly scheduler: Scheduler;
-    protected readonly villageFactory: VillageFactory;
-    constructor(scheduler: Scheduler, villageFactory: VillageFactory) {
-        this.scheduler = scheduler;
-        this.villageFactory = villageFactory;
-    }
-
-    async run(args: Args, task: Task) {}
-
-    ensureSameVillage(args: Args, task: Task) {
-        let villageId = args.villageId || taskError('Undefined village id');
-        const activeVillageId = grabActiveVillageId();
-        if (villageId !== activeVillageId) {
-            throw new TryLaterError(aroundMinutes(1), 'Not same village');
-        }
-    }
-}

src/Action/BuildBuildingAction.ts

@@ -1,22 +0,0 @@
-import { ActionController, registerAction } from './ActionController';
-import { GrabError, taskError, TryLaterError } from '../Errors';
-import { clickBuildButton } from '../Page/BuildingPage/BuildingPage';
-import { Args } from '../Queue/Args';
-import { Task } from '../Queue/TaskProvider';
-import { aroundMinutes } from '../Helpers/Time';
-
-@registerAction
-export class BuildBuildingAction extends ActionController {
-    async run(args: Args, task: Task): Promise<any> {
-        try {
-            this.ensureSameVillage(args, task);
-            const buildTypeId = args.buildTypeId || taskError('Undefined build type id');
-            clickBuildButton(buildTypeId);
-        } catch (e) {
-            if (e instanceof GrabError) {
-                throw new TryLaterError(aroundMinutes(5), 'No upgrade button, try later');
-            }
-            throw e;
-        }
-    }
-}

src/Action/CelebrationAction.ts

@@ -1,21 +0,0 @@
-import { ActionController, registerAction } from './ActionController';
-import { GrabError, TryLaterError } from '../Errors';
-import { Args } from '../Queue/Args';
-import { Task } from '../Queue/TaskProvider';
-import { clickCelebrationButton } from '../Page/BuildingPage/GuildHallPage';
-import { aroundMinutes } from '../Helpers/Time';
-
-@registerAction
-export class CelebrationAction extends ActionController {
-    async run(args: Args, task: Task): Promise<any> {
-        try {
-            this.ensureSameVillage(args, task);
-            clickCelebrationButton(args.celebrationIndex);
-        } catch (e) {
-            if (e instanceof GrabError) {
-                throw new TryLaterError(aroundMinutes(60), e.message);
-            }
-            throw e;
-        }
-    }
-}

src/Action/CompleteTaskAction.ts

@@ -1,10 +0,0 @@
-import { ActionController, registerAction } from './ActionController';
-import { Args } from '../Queue/Args';
-import { Task } from '../Queue/TaskProvider';
-
-@registerAction
-export class CompleteTaskAction extends ActionController {
-    async run(args: Args, task: Task): Promise<any> {
-        this.scheduler.completeTask(task.id);
-    }
-}

src/Action/ForgeImprovementAction.ts

@@ -1,22 +0,0 @@
-import { ActionController, registerAction } from './ActionController';
-import { GrabError, taskError, TryLaterError } from '../Errors';
-import { Args } from '../Queue/Args';
-import { Task } from '../Queue/TaskProvider';
-import { clickResearchButton } from '../Page/BuildingPage/ForgePage';
-import { aroundMinutes } from '../Helpers/Time';
-
-@registerAction
-export class ForgeImprovementAction extends ActionController {
-    async run(args: Args, task: Task): Promise<any> {
-        try {
-            this.ensureSameVillage(args, task);
-            const unitId = args.unitId || taskError('No unitId in args');
-            clickResearchButton(unitId);
-        } catch (e) {
-            if (e instanceof GrabError) {
-                throw new TryLaterError(aroundMinutes(15), e.message);
-            }
-            throw e;
-        }
-    }
-}

src/Action/GoToPageAction.ts

@@ -1,12 +0,0 @@
-import { ActionController, registerAction } from './ActionController';
-import { taskError } from '../Errors';
-import { Args } from '../Queue/Args';
-import { Task } from '../Queue/TaskProvider';
-
-@registerAction
-export class GoToPageAction extends ActionController {
-    async run(args: Args, task: Task): Promise<any> {
-        const path = args.path || taskError('Empty path');
-        window.location.assign(path);
-    }
-}

src/Action/UpgradeBuildingAction.ts

@@ -1,21 +0,0 @@
-import { ActionController, registerAction } from './ActionController';
-import { GrabError, TryLaterError } from '../Errors';
-import { clickUpgradeButton } from '../Page/BuildingPage/BuildingPage';
-import { Args } from '../Queue/Args';
-import { Task } from '../Queue/TaskProvider';
-import { aroundMinutes } from '../Helpers/Time';
-
-@registerAction
-export class UpgradeBuildingAction extends ActionController {
-    async run(args: Args, task: Task): Promise<any> {
-        try {
-            this.ensureSameVillage(args, task);
-            clickUpgradeButton();
-        } catch (e) {
-            if (e instanceof GrabError) {
-                throw new TryLaterError(aroundMinutes(5), 'No upgrade button, try later');
-            }
-            throw e;
-        }
-    }
-}

src/ControlPanel.ts

@@ -1,6 +1,6 @@
 import { Scheduler } from './Scheduler';
 import { BuildingPageController } from './Page/BuildingPageController';
-import { UpgradeBuildingTask } from './Task/UpgradeBuildingTask';
+import { UpgradeBuildingTask } from './Handler/Task/UpgradeBuildingTask';
 import { grabActiveVillageId } from './Page/VillageBlock';
 import {
     onBuildingSlotCtrlClick,

src/Executor.ts

@@ -7,7 +7,6 @@ import {
     VillageNotFound,
 } from './Errors';
 import { TaskQueueRenderer } from './TaskQueueRenderer';
-import { createActionHandler } from './Action/ActionController';
 import { Logger } from './Logger';
 import { GrabberManager } from './Grabber/GrabberManager';
 import { Scheduler } from './Scheduler';
@@ -15,10 +14,11 @@ import { Statistics } from './Statistics';
 import { ExecutionStorage } from './Storage/ExecutionStorage';
 import { Action } from './Queue/ActionQueue';
 import { Task } from './Queue/TaskProvider';
-import { createTaskHandler } from './Task/TaskMap';
+import { createTaskHandler } from './Handler/TaskMap';
 import { VillageFactory } from './Village/VillageFactory';
 import { sleepMicro, timestamp } from './Helpers/Time';
 import { markPage, waitForLoad } from './Helpers/Browser';
+import { createActionHandler } from './Handler/ActionMap';
 
 export interface ExecutionSettings {
     pauseTs: number;
@@ -27,11 +27,11 @@ export interface ExecutionSettings {
 export class Executor {
     private readonly version: string;
     private readonly scheduler: Scheduler;
-    private villageFactory: VillageFactory;
-    private grabberManager: GrabberManager;
-    private statistics: Statistics;
-    private executionState: ExecutionStorage;
-    private logger: Logger;
+    private readonly villageFactory: VillageFactory;
+    private readonly grabberManager: GrabberManager;
+    private readonly statistics: Statistics;
+    private readonly executionState: ExecutionStorage;
+    private readonly logger: Logger;
 
     constructor(
         version: string,
@@ -101,18 +101,18 @@ export class Executor {
 
         try {
             if (task && action) {
-                return await this.processActionCommand(action, task);
+                return await this.processAction(action, task);
             }
 
             if (task) {
-                return await this.processTaskCommand(task);
+                return await this.processTask(task);
             }
         } catch (e) {
             this.handleError(e, task);
         }
     }
 
-    private async processActionCommand(action: Action, task: Task) {
+    private async processAction(action: Action, task: Task) {
         const actionHandler = createActionHandler(action.name, this.scheduler, this.villageFactory);
         this.logger.info('Process action', action.name, actionHandler);
         if (actionHandler) {
@@ -123,7 +123,7 @@ export class Executor {
         }
     }
 
-    private async processTaskCommand(task: Task) {
+    private async processTask(task: Task) {
         const taskHandler = createTaskHandler(task.name, this.scheduler, this.villageFactory);
         this.logger.info('Process task', task.name, task, taskHandler);
         if (taskHandler) {

src/Handler/Action/BalanceHeroResourcesAction.ts

@@ -1,14 +1,15 @@
-import { ActionController, registerAction } from './ActionController';
-import { changeHeroResource, grabCurrentHeroResource } from '../Page/HeroPage';
-import { grabActiveVillageId } from '../Page/VillageBlock';
-import { HeroStorage } from '../Storage/HeroStorage';
-import { calcHeroResource } from '../Core/HeroBalance';
-import { HeroAllResources } from '../Core/Hero';
-import { Args } from '../Queue/Args';
-import { Task } from '../Queue/TaskProvider';
+import { BaseAction } from './BaseAction';
+import { changeHeroResource, grabCurrentHeroResource } from '../../Page/HeroPage';
+import { grabActiveVillageId } from '../../Page/VillageBlock';
+import { HeroStorage } from '../../Storage/HeroStorage';
+import { calcHeroResource } from '../../Core/HeroBalance';
+import { HeroAllResources } from '../../Core/Hero';
+import { Args } from '../../Queue/Args';
+import { Task } from '../../Queue/TaskProvider';
+import { registerAction } from '../ActionMap';
 
 @registerAction
-export class BalanceHeroResourcesAction extends ActionController {
+export class BalanceHeroResourcesAction extends BaseAction {
     async run(args: Args, task: Task): Promise<any> {
         const thisVillageId = grabActiveVillageId();
         const heroVillageId = new HeroStorage().getVillageId();

src/Handler/Action/BaseAction.ts

@@ -0,0 +1,26 @@
+import { Scheduler } from '../../Scheduler';
+import { taskError, TryLaterError } from '../../Errors';
+import { grabActiveVillageId } from '../../Page/VillageBlock';
+import { Args } from '../../Queue/Args';
+import { Task } from '../../Queue/TaskProvider';
+import { VillageFactory } from '../../Village/VillageFactory';
+import { aroundMinutes } from '../../Helpers/Time';
+
+export class BaseAction {
+    protected readonly scheduler: Scheduler;
+    protected readonly villageFactory: VillageFactory;
+    constructor(scheduler: Scheduler, villageFactory: VillageFactory) {
+        this.scheduler = scheduler;
+        this.villageFactory = villageFactory;
+    }
+
+    async run(args: Args, task: Task) {}
+
+    ensureSameVillage(args: Args) {
+        let villageId = args.villageId || taskError('Undefined village id');
+        const activeVillageId = grabActiveVillageId();
+        if (villageId !== activeVillageId) {
+            throw new TryLaterError(aroundMinutes(1), 'Not same village');
+        }
+    }
+}

src/Handler/Action/BuildBuildingAction.ts

@@ -0,0 +1,23 @@
+import { BaseAction } from './BaseAction';
+import { GrabError, taskError, TryLaterError } from '../../Errors';
+import { clickBuildButton } from '../../Page/BuildingPage/BuildingPage';
+import { Args } from '../../Queue/Args';
+import { Task } from '../../Queue/TaskProvider';
+import { aroundMinutes } from '../../Helpers/Time';
+import { registerAction } from '../ActionMap';
+
+@registerAction
+export class BuildBuildingAction extends BaseAction {
+    async run(args: Args, task: Task): Promise<any> {
+        try {
+            this.ensureSameVillage(args);
+            const buildTypeId = args.buildTypeId || taskError('Undefined build type id');
+            clickBuildButton(buildTypeId);
+        } catch (e) {
+            if (e instanceof GrabError) {
+                throw new TryLaterError(aroundMinutes(5), 'No upgrade button, try later');
+            }
+            throw e;
+        }
+    }
+}

src/Handler/Action/CelebrationAction.ts

@@ -0,0 +1,22 @@
+import { BaseAction } from './BaseAction';
+import { GrabError, TryLaterError } from '../../Errors';
+import { Args } from '../../Queue/Args';
+import { Task } from '../../Queue/TaskProvider';
+import { clickCelebrationButton } from '../../Page/BuildingPage/GuildHallPage';
+import { aroundMinutes } from '../../Helpers/Time';
+import { registerAction } from '../ActionMap';
+
+@registerAction
+export class CelebrationAction extends BaseAction {
+    async run(args: Args, task: Task): Promise<any> {
+        try {
+            this.ensureSameVillage(args);
+            clickCelebrationButton(args.celebrationIndex);
+        } catch (e) {
+            if (e instanceof GrabError) {
+                throw new TryLaterError(aroundMinutes(60), e.message);
+            }
+            throw e;
+        }
+    }
+}

src/Handler/Action/CheckBuildingRemainingTimeAction.ts

@@ -1,12 +1,13 @@
-import { ActionController, registerAction } from './ActionController';
-import { GrabError, TryLaterError } from '../Errors';
-import { grabBuildingQueueInfo } from '../Page/VillageBlock';
-import { Args } from '../Queue/Args';
-import { Task } from '../Queue/TaskProvider';
-import { BuildingQueueInfo } from '../Core/BuildingQueueInfo';
+import { BaseAction } from './BaseAction';
+import { GrabError, TryLaterError } from '../../Errors';
+import { grabBuildingQueueInfo } from '../../Page/VillageBlock';
+import { Args } from '../../Queue/Args';
+import { Task } from '../../Queue/TaskProvider';
+import { BuildingQueueInfo } from '../../Core/BuildingQueueInfo';
+import { registerAction } from '../ActionMap';
 
 @registerAction
-export class CheckBuildingRemainingTimeAction extends ActionController {
+export class CheckBuildingRemainingTimeAction extends BaseAction {
     async run(args: Args, task: Task): Promise<any> {
         const info = this.grabBuildingQueueInfoOrDefault();
         if (info.seconds > 0) {

src/Handler/Action/ClickButtonAction.ts

@@ -1,10 +1,11 @@
-import { ActionController, registerAction } from './ActionController';
-import { taskError } from '../Errors';
-import { Args } from '../Queue/Args';
-import { Task } from '../Queue/TaskProvider';
+import { BaseAction } from './BaseAction';
+import { taskError } from '../../Errors';
+import { Args } from '../../Queue/Args';
+import { Task } from '../../Queue/TaskProvider';
+import { registerAction } from '../ActionMap';
 
 @registerAction
-export class ClickButtonAction extends ActionController {
+export class ClickButtonAction extends BaseAction {
     async run(args: Args, task: Task): Promise<any> {
         const selector = args.selector || taskError('No selector');
         const el = jQuery(selector);

src/Handler/Action/CompleteTaskAction.ts

@@ -0,0 +1,11 @@
+import { BaseAction } from './BaseAction';
+import { Args } from '../../Queue/Args';
+import { Task } from '../../Queue/TaskProvider';
+import { registerAction } from '../ActionMap';
+
+@registerAction
+export class CompleteTaskAction extends BaseAction {
+    async run(args: Args, task: Task): Promise<any> {
+        this.scheduler.completeTask(task.id);
+    }
+}

src/Handler/Action/FindSendResourcesPathAction.ts

@@ -1,25 +1,26 @@
-import { ActionController, registerAction } from './ActionController';
-import { FailTaskError, taskError, TryLaterError } from '../Errors';
-import { Resources } from '../Core/Resources';
-import { Coordinates } from '../Core/Village';
-import { Args } from '../Queue/Args';
-import { Task } from '../Queue/TaskProvider';
-import { clickSendButton, fillSendResourcesForm } from '../Page/BuildingPage/MarketPage';
-import { VillageState } from '../Village/VillageState';
-import { MerchantsInfo } from '../Core/Market';
-import { goToMarketSendResourcesPage, goToResourceViewPage } from '../Task/ActionBundles';
+import { BaseAction } from './BaseAction';
+import { FailTaskError, taskError, TryLaterError } from '../../Errors';
+import { Resources } from '../../Core/Resources';
+import { Coordinates } from '../../Core/Village';
+import { Args } from '../../Queue/Args';
+import { Task } from '../../Queue/TaskProvider';
+import { clickSendButton, fillSendResourcesForm } from '../../Page/BuildingPage/MarketPage';
+import { VillageState } from '../../Village/VillageState';
+import { MerchantsInfo } from '../../Core/Market';
+import { goToMarketSendResourcesPage, goToResourceViewPage } from '../ActionBundles';
 import {
     compareReports,
     ResourceTransferCalculator,
     ResourceTransferReport,
-} from '../Village/ResourceTransfer';
-import { ResourceTransferStorage } from '../Storage/ResourceTransferStorage';
-import { path } from '../Helpers/Path';
-import { MARKET_ID } from '../Core/Buildings';
-import { aroundMinutes, timestamp } from '../Helpers/Time';
+} from '../../Village/ResourceTransfer';
+import { ResourceTransferStorage } from '../../Storage/ResourceTransferStorage';
+import { path } from '../../Helpers/Path';
+import { MARKET_ID } from '../../Core/Buildings';
+import { aroundMinutes, timestamp } from '../../Helpers/Time';
+import { registerAction } from '../ActionMap';
 
 @registerAction
-export class FindSendResourcesPath extends ActionController {
+export class FindSendResourcesPathAction extends BaseAction {
     async run(args: Args, task: Task): Promise<any> {
         const reports: Array<ResourceTransferReport> = [];
         const calculator = new ResourceTransferCalculator(this.villageFactory);

src/Handler/Action/ForgeImprovementAction.ts

@@ -0,0 +1,23 @@
+import { BaseAction } from './BaseAction';
+import { GrabError, taskError, TryLaterError } from '../../Errors';
+import { Args } from '../../Queue/Args';
+import { Task } from '../../Queue/TaskProvider';
+import { clickResearchButton } from '../../Page/BuildingPage/ForgePage';
+import { aroundMinutes } from '../../Helpers/Time';
+import { registerAction } from '../ActionMap';
+
+@registerAction
+export class ForgeImprovementAction extends BaseAction {
+    async run(args: Args, task: Task): Promise<any> {
+        try {
+            this.ensureSameVillage(args);
+            const unitId = args.unitId || taskError('No unitId in args');
+            clickResearchButton(unitId);
+        } catch (e) {
+            if (e instanceof GrabError) {
+                throw new TryLaterError(aroundMinutes(15), e.message);
+            }
+            throw e;
+        }
+    }
+}

src/Handler/Action/GoToHeroVillageAction.ts

@@ -1,13 +1,14 @@
-import { ActionController, registerAction } from './ActionController';
-import { grabVillageList } from '../Page/VillageBlock';
-import { grabHeroVillage } from '../Page/HeroPage';
-import { HeroStorage } from '../Storage/HeroStorage';
-import { Args } from '../Queue/Args';
-import { Task } from '../Queue/TaskProvider';
-import { path } from '../Helpers/Path';
+import { BaseAction } from './BaseAction';
+import { grabVillageList } from '../../Page/VillageBlock';
+import { grabHeroVillage } from '../../Page/HeroPage';
+import { HeroStorage } from '../../Storage/HeroStorage';
+import { Args } from '../../Queue/Args';
+import { Task } from '../../Queue/TaskProvider';
+import { path } from '../../Helpers/Path';
+import { registerAction } from '../ActionMap';
 
 @registerAction
-export class GoToHeroVillageAction extends ActionController {
+export class GoToHeroVillageAction extends BaseAction {
     async run(args: Args, task: Task): Promise<any> {
         const heroVillageId = this.getHeroVillageId();
         if (heroVillageId) {

src/Handler/Action/GoToPageAction.ts

@@ -0,0 +1,13 @@
+import { BaseAction } from './BaseAction';
+import { taskError } from '../../Errors';
+import { Args } from '../../Queue/Args';
+import { Task } from '../../Queue/TaskProvider';
+import { registerAction } from '../ActionMap';
+
+@registerAction
+export class GoToPageAction extends BaseAction {
+    async run(args: Args, task: Task): Promise<any> {
+        const path = args.path || taskError('Empty path');
+        window.location.assign(path);
+    }
+}

src/Handler/Action/SendOnAdventureAction.ts

@@ -1,8 +1,9 @@
-import { ActionController, registerAction } from './ActionController';
-import { AbortTaskError } from '../Errors';
-import { Args } from '../Queue/Args';
-import { Task } from '../Queue/TaskProvider';
-import { trimPrefix } from '../Helpers/Convert';
+import { BaseAction } from './BaseAction';
+import { AbortTaskError } from '../../Errors';
+import { Args } from '../../Queue/Args';
+import { Task } from '../../Queue/TaskProvider';
+import { trimPrefix } from '../../Helpers/Convert';
+import { registerAction } from '../ActionMap';
 
 const CONFIG = [
     { level: 0, health: 60 },
@@ -19,7 +20,7 @@ interface Adventure {
 }
 
 @registerAction
-export class SendOnAdventureAction extends ActionController {
+export class SendOnAdventureAction extends BaseAction {
     async run(args: Args, task: Task): Promise<any> {
         const adventures = this.findAdventures();
 

src/Handler/Action/SendResourcesAction.ts

@@ -1,14 +1,15 @@
-import { ActionController, registerAction } from './ActionController';
-import { Args } from '../Queue/Args';
-import { Task } from '../Queue/TaskProvider';
-import { clickSendButton, fillSendResourcesForm } from '../Page/BuildingPage/MarketPage';
-import { ResourceTransferCalculator } from '../Village/ResourceTransfer';
-import { ResourceTransferStorage } from '../Storage/ResourceTransferStorage';
-import { Resources } from '../Core/Resources';
-import { AbortTaskError } from '../Errors';
+import { BaseAction } from './BaseAction';
+import { Args } from '../../Queue/Args';
+import { Task } from '../../Queue/TaskProvider';
+import { clickSendButton, fillSendResourcesForm } from '../../Page/BuildingPage/MarketPage';
+import { ResourceTransferCalculator } from '../../Village/ResourceTransfer';
+import { ResourceTransferStorage } from '../../Storage/ResourceTransferStorage';
+import { Resources } from '../../Core/Resources';
+import { AbortTaskError } from '../../Errors';
+import { registerAction } from '../ActionMap';
 
 @registerAction
-export class SendResourcesAction extends ActionController {
+export class SendResourcesAction extends BaseAction {
     async run(args: Args, task: Task): Promise<any> {
         const storage = new ResourceTransferStorage();
         const savedReport = storage.getReport();

src/Handler/Action/TrainTrooperAction.ts

@@ -1,19 +1,20 @@
-import { ActionController, registerAction } from './ActionController';
-import { taskError, TryLaterError } from '../Errors';
-import { Args } from '../Queue/Args';
-import { Task } from '../Queue/TaskProvider';
+import { BaseAction } from './BaseAction';
+import { taskError, TryLaterError } from '../../Errors';
+import { Args } from '../../Queue/Args';
+import { Task } from '../../Queue/TaskProvider';
 import {
     clickTrainButton,
     fillTrainCount,
     getAvailableCount,
-} from '../Page/BuildingPage/TrooperPage';
+} from '../../Page/BuildingPage/TrooperPage';
 import { TrainTroopTask } from '../Task/TrainTroopTask';
-import { Resources } from '../Core/Resources';
-import { randomInRange } from '../Helpers/Random';
-import { aroundMinutes } from '../Helpers/Time';
+import { Resources } from '../../Core/Resources';
+import { randomInRange } from '../../Helpers/Random';
+import { aroundMinutes } from '../../Helpers/Time';
+import { registerAction } from '../ActionMap';
 
 @registerAction
-export class TrainTrooperAction extends ActionController {
+export class TrainTrooperAction extends BaseAction {
     async run(args: Args, task: Task): Promise<any> {
         const troopId = args.troopId || taskError('No troop id');
         const trainCount = args.trainCount || taskError('No troop train count');

src/Handler/Action/UpgradeBuildingAction.ts

@@ -0,0 +1,22 @@
+import { BaseAction } from './BaseAction';
+import { GrabError, TryLaterError } from '../../Errors';
+import { clickUpgradeButton } from '../../Page/BuildingPage/BuildingPage';
+import { Args } from '../../Queue/Args';
+import { Task } from '../../Queue/TaskProvider';
+import { aroundMinutes } from '../../Helpers/Time';
+import { registerAction } from '../ActionMap';
+
+@registerAction
+export class UpgradeBuildingAction extends BaseAction {
+    async run(args: Args, task: Task): Promise<any> {
+        try {
+            this.ensureSameVillage(args);
+            clickUpgradeButton();
+        } catch (e) {
+            if (e instanceof GrabError) {
+                throw new TryLaterError(aroundMinutes(5), 'No upgrade button, try later');
+            }
+            throw e;
+        }
+    }
+}

src/Handler/Action/UpgradeResourceToLevelAction.ts

@@ -1,15 +1,16 @@
-import { ActionController, registerAction } from './ActionController';
-import { ActionError, taskError, TryLaterError } from '../Errors';
-import { grabResourceSlots } from '../Page/SlotBlock';
+import { BaseAction } from './BaseAction';
+import { ActionError, taskError, TryLaterError } from '../../Errors';
+import { grabResourceSlots } from '../../Page/SlotBlock';
 import { UpgradeBuildingTask } from '../Task/UpgradeBuildingTask';
-import { Args } from '../Queue/Args';
-import { Task } from '../Queue/TaskProvider';
-import { ResourceSlot } from '../Core/Slot';
-import { getNumber } from '../Helpers/Convert';
-import { aroundMinutes } from '../Helpers/Time';
+import { Args } from '../../Queue/Args';
+import { Task } from '../../Queue/TaskProvider';
+import { ResourceSlot } from '../../Core/Slot';
+import { getNumber } from '../../Helpers/Convert';
+import { aroundMinutes } from '../../Helpers/Time';
+import { registerAction } from '../ActionMap';
 
 @registerAction
-export class UpgradeResourceToLevel extends ActionController {
+export class UpgradeResourceToLevelAction extends BaseAction {
     async run(args: Args, task: Task): Promise<any> {
         const deposits = grabResourceSlots();
         if (deposits.length === 0) {

src/Handler/ActionBundles.ts

@@ -1,5 +1,5 @@
-import { ActionDefinition } from './TaskController';
-import { GoToPageAction } from '../Action/GoToPageAction';
+import { ActionDefinition } from './Task/BaseTask';
+import { GoToPageAction } from './Action/GoToPageAction';
 import { FORGE_ID, GUILD_HALL_ID, MARKET_ID } from '../Core/Buildings';
 import { path } from '../Helpers/Path';
 import { Village } from '../Core/Village';

src/Handler/ActionMap.ts

@@ -0,0 +1,22 @@
+import { Scheduler } from '../Scheduler';
+import { VillageFactory } from '../Village/VillageFactory';
+import { BaseAction } from './Action/BaseAction';
+
+const actionMap: { [name: string]: Function | undefined } = {};
+
+export function registerAction(constructor: Function) {
+    actionMap[constructor.name] = constructor;
+}
+
+export function createActionHandler(
+    name: string,
+    scheduler: Scheduler,
+    villageFactory: VillageFactory
+): BaseAction | undefined {
+    const storedFunction = actionMap[name];
+    if (storedFunction === undefined) {
+        return undefined;
+    }
+    const constructor = (storedFunction as unknown) as typeof BaseAction;
+    return new constructor(scheduler, villageFactory);
+}

src/Handler/Task/BalanceHeroResourcesTask.ts

@@ -1,14 +1,14 @@
-import { ActionDefinition, TaskController } from './TaskController';
+import { ActionDefinition, BaseTask } from './BaseTask';
 import { GoToPageAction } from '../Action/GoToPageAction';
 import { CompleteTaskAction } from '../Action/CompleteTaskAction';
 import { BalanceHeroResourcesAction } from '../Action/BalanceHeroResourcesAction';
 import { GoToHeroVillageAction } from '../Action/GoToHeroVillageAction';
-import { Task } from '../Queue/TaskProvider';
-import { path } from '../Helpers/Path';
-import { registerTask } from './TaskMap';
+import { Task } from '../../Queue/TaskProvider';
+import { path } from '../../Helpers/Path';
+import { registerTask } from '../TaskMap';
 
 @registerTask()
-export class BalanceHeroResourcesTask extends TaskController {
+export class BalanceHeroResourcesTask extends BaseTask {
     defineActions(task: Task): Array<ActionDefinition> {
         return [
             {

src/Handler/Task/BaseTask.ts

@@ -1,16 +1,16 @@
-import { Scheduler } from '../Scheduler';
+import { Scheduler } from '../../Scheduler';
 import { CompleteTaskAction } from '../Action/CompleteTaskAction';
-import { Action } from '../Queue/ActionQueue';
-import { Args } from '../Queue/Args';
-import { Task } from '../Queue/TaskProvider';
-import { VillageFactory } from '../Village/VillageFactory';
+import { Action } from '../../Queue/ActionQueue';
+import { Args } from '../../Queue/Args';
+import { Task } from '../../Queue/TaskProvider';
+import { VillageFactory } from '../../Village/VillageFactory';
 
 export interface ActionDefinition {
     name: string;
     args?: Args;
 }
 
-export class TaskController {
+export class BaseTask {
     protected readonly scheduler: Scheduler;
     protected readonly factory: VillageFactory;
 

src/Handler/Task/BuildBuildingTask.ts

@@ -1,15 +1,15 @@
 import { BuildBuildingAction } from '../Action/BuildBuildingAction';
 import { GoToPageAction } from '../Action/GoToPageAction';
-import { ActionDefinition, TaskController } from './TaskController';
-import { Task } from '../Queue/TaskProvider';
-import { path } from '../Helpers/Path';
-import { registerTask } from './TaskMap';
-import { taskError } from '../Errors';
-import { goToResourceViewPage } from './ActionBundles';
-import { ProductionQueue } from '../Core/ProductionQueue';
+import { ActionDefinition, BaseTask } from './BaseTask';
+import { Task } from '../../Queue/TaskProvider';
+import { path } from '../../Helpers/Path';
+import { registerTask } from '../TaskMap';
+import { taskError } from '../../Errors';
+import { goToResourceViewPage } from '../ActionBundles';
+import { ProductionQueue } from '../../Core/ProductionQueue';
 
 @registerTask({ queue: ProductionQueue.Building })
-export class BuildBuildingTask extends TaskController {
+export class BuildBuildingTask extends BaseTask {
     defineActions(task: Task): Array<ActionDefinition> {
         const args = task.args;
         const villageId = args.villageId || taskError('No village id');

src/Handler/Task/CelebrationTask.ts

@@ -1,13 +1,13 @@
-import { ActionDefinition, TaskController } from './TaskController';
+import { ActionDefinition, BaseTask } from './BaseTask';
 import { GoToPageAction } from '../Action/GoToPageAction';
-import { Task } from '../Queue/TaskProvider';
-import { path } from '../Helpers/Path';
+import { Task } from '../../Queue/TaskProvider';
+import { path } from '../../Helpers/Path';
 import { CelebrationAction } from '../Action/CelebrationAction';
-import { registerTask } from './TaskMap';
-import { ProductionQueue } from '../Core/ProductionQueue';
+import { registerTask } from '../TaskMap';
+import { ProductionQueue } from '../../Core/ProductionQueue';
 
 @registerTask({ queue: ProductionQueue.Celebration })
-export class CelebrationTask extends TaskController {
+export class CelebrationTask extends BaseTask {
     defineActions(task: Task): Array<ActionDefinition> {
         const args = task.args;
 

src/Handler/Task/ForgeImprovementTask.ts

@@ -1,13 +1,13 @@
-import { ActionDefinition, TaskController } from './TaskController';
+import { ActionDefinition, BaseTask } from './BaseTask';
 import { GoToPageAction } from '../Action/GoToPageAction';
-import { Task } from '../Queue/TaskProvider';
+import { Task } from '../../Queue/TaskProvider';
 import { ForgeImprovementAction } from '../Action/ForgeImprovementAction';
-import { path } from '../Helpers/Path';
-import { registerTask } from './TaskMap';
-import { ProductionQueue } from '../Core/ProductionQueue';
+import { path } from '../../Helpers/Path';
+import { registerTask } from '../TaskMap';
+import { ProductionQueue } from '../../Core/ProductionQueue';
 
 @registerTask({ queue: ProductionQueue.UpgradeUnit })
-export class ForgeImprovementTask extends TaskController {
+export class ForgeImprovementTask extends BaseTask {
     defineActions(task: Task): Array<ActionDefinition> {
         const args = task.args;
 

src/Handler/Task/GrabVillageStateTask.ts

@@ -0,0 +1,12 @@
+import { BaseTask, ActionDefinition } from './BaseTask';
+import { scanAllVillagesBundle } from '../ActionBundles';
+import { Task } from '../../Queue/TaskProvider';
+import { registerTask } from '../TaskMap';
+
+@registerTask()
+export class GrabVillageStateTask extends BaseTask {
+    defineActions(task: Task): Array<ActionDefinition> {
+        const villages = this.factory.getAllVillages();
+        return scanAllVillagesBundle(villages);
+    }
+}

src/Handler/Task/ResourcesToLevelTask.ts

@@ -0,0 +1,15 @@
+import { BaseTask, ActionDefinition } from './BaseTask';
+import { UpgradeResourceToLevelAction } from '../Action/UpgradeResourceToLevelAction';
+import { Task } from '../../Queue/TaskProvider';
+import { registerTask } from '../TaskMap';
+import { goToResourceViewPage } from '../ActionBundles';
+import { taskError } from '../../Errors';
+
+@registerTask()
+export class ResourcesToLevelTask extends BaseTask {
+    defineActions(task: Task): Array<ActionDefinition> {
+        const villageId = task.args.villageId || taskError('No village id');
+
+        return [goToResourceViewPage(villageId), { name: UpgradeResourceToLevelAction.name }];
+    }
+}

src/Handler/Task/RunVillageProductionTask.ts

@@ -0,0 +1,10 @@
+import { BaseTask, ActionDefinition } from './BaseTask';
+import { Task } from '../../Queue/TaskProvider';
+import { registerTask } from '../TaskMap';
+
+@registerTask()
+export class RunVillageProductionTask extends BaseTask {
+    defineActions(task: Task): Array<ActionDefinition> {
+        return [];
+    }
+}

src/Handler/Task/SendOnAdventureTask.ts

@@ -1,13 +1,13 @@
-import { ActionDefinition, TaskController } from './TaskController';
+import { ActionDefinition, BaseTask } from './BaseTask';
 import { GoToPageAction } from '../Action/GoToPageAction';
 import { SendOnAdventureAction } from '../Action/SendOnAdventureAction';
 import { ClickButtonAction } from '../Action/ClickButtonAction';
-import { Task } from '../Queue/TaskProvider';
-import { path } from '../Helpers/Path';
-import { registerTask } from './TaskMap';
+import { Task } from '../../Queue/TaskProvider';
+import { path } from '../../Helpers/Path';
+import { registerTask } from '../TaskMap';
 
 @registerTask()
-export class SendOnAdventureTask extends TaskController {
+export class SendOnAdventureTask extends BaseTask {
     defineActions(task: Task): Array<ActionDefinition> {
         return [
             {

src/Handler/Task/SendResourcesTask.ts

@@ -1,13 +1,13 @@
-import { TaskController, ActionDefinition } from './TaskController';
+import { BaseTask, ActionDefinition } from './BaseTask';
 import { SendResourcesAction } from '../Action/SendResourcesAction';
 import { ClickButtonAction } from '../Action/ClickButtonAction';
-import { goToMarketSendResourcesPage, goToResourceViewPage } from './ActionBundles';
-import { Task } from '../Queue/TaskProvider';
-import { registerTask } from './TaskMap';
-import { FindSendResourcesPath } from '../Action/FindSendResourcesPath';
+import { goToMarketSendResourcesPage, goToResourceViewPage } from '../ActionBundles';
+import { Task } from '../../Queue/TaskProvider';
+import { registerTask } from '../TaskMap';
+import { FindSendResourcesPathAction } from '../Action/FindSendResourcesPathAction';
 
 @registerTask()
-export class SendResourcesTask extends TaskController {
+export class SendResourcesTask extends BaseTask {
     defineActions(task: Task): Array<ActionDefinition> {
         const actions: Array<ActionDefinition> = [];
 
@@ -17,7 +17,7 @@ export class SendResourcesTask extends TaskController {
             actions.push(goToMarketSendResourcesPage(village.id));
         }
 
-        actions.push({ name: FindSendResourcesPath.name });
+        actions.push({ name: FindSendResourcesPathAction.name });
         actions.push({ name: SendResourcesAction.name });
         actions.push({
             name: ClickButtonAction.name,

src/Handler/Task/TrainTroopTask.ts

@@ -1,13 +1,13 @@
-import { ActionDefinition, TaskController } from './TaskController';
+import { ActionDefinition, BaseTask } from './BaseTask';
 import { GoToPageAction } from '../Action/GoToPageAction';
 import { TrainTrooperAction } from '../Action/TrainTrooperAction';
-import { Task } from '../Queue/TaskProvider';
-import { path } from '../Helpers/Path';
-import { registerTask } from './TaskMap';
-import { ProductionQueue } from '../Core/ProductionQueue';
+import { Task } from '../../Queue/TaskProvider';
+import { path } from '../../Helpers/Path';
+import { registerTask } from '../TaskMap';
+import { ProductionQueue } from '../../Core/ProductionQueue';
 
 @registerTask({ queue: ProductionQueue.TrainUnit })
-export class TrainTroopTask extends TaskController {
+export class TrainTroopTask extends BaseTask {
     defineActions(task: Task): Array<ActionDefinition> {
         const args = task.args;
 

src/Handler/Task/UpdateResourceContractsTask.ts

@@ -1,13 +1,13 @@
-import { ActionDefinition, TaskController } from './TaskController';
+import { ActionDefinition, BaseTask } from './BaseTask';
 import { GoToPageAction } from '../Action/GoToPageAction';
 import { UpgradeBuildingTask } from './UpgradeBuildingTask';
-import { ImmutableTaskList, Task } from '../Queue/TaskProvider';
+import { ImmutableTaskList, Task } from '../../Queue/TaskProvider';
 import { ForgeImprovementTask } from './ForgeImprovementTask';
-import { path, PathList, uniqPaths } from '../Helpers/Path';
-import { registerTask } from './TaskMap';
+import { path, PathList, uniqPaths } from '../../Helpers/Path';
+import { registerTask } from '../TaskMap';
 
 @registerTask()
-export class UpdateResourceContracts extends TaskController {
+export class UpdateResourceContractsTask extends BaseTask {
     defineActions(task: Task): Array<ActionDefinition> {
         const villages = this.factory.getAllVillages();
 

src/Handler/Task/UpgradeBuildingTask.ts

@@ -1,15 +1,15 @@
 import { UpgradeBuildingAction } from '../Action/UpgradeBuildingAction';
-import { TaskController, ActionDefinition } from './TaskController';
+import { BaseTask, ActionDefinition } from './BaseTask';
 import { GoToPageAction } from '../Action/GoToPageAction';
-import { Task } from '../Queue/TaskProvider';
-import { path } from '../Helpers/Path';
-import { registerTask } from './TaskMap';
-import { goToResourceViewPage } from './ActionBundles';
-import { taskError } from '../Errors';
-import { ProductionQueue } from '../Core/ProductionQueue';
+import { Task } from '../../Queue/TaskProvider';
+import { path } from '../../Helpers/Path';
+import { registerTask } from '../TaskMap';
+import { goToResourceViewPage } from '../ActionBundles';
+import { taskError } from '../../Errors';
+import { ProductionQueue } from '../../Core/ProductionQueue';
 
 @registerTask({ queue: ProductionQueue.Building })
-export class UpgradeBuildingTask extends TaskController {
+export class UpgradeBuildingTask extends BaseTask {
     defineActions(task: Task): Array<ActionDefinition> {
         const args = task.args;
         const villageId = args.villageId || taskError('No village id');

src/Handler/TaskMap.ts

@@ -1,5 +1,5 @@
 import { Scheduler } from '../Scheduler';
-import { TaskController } from './TaskController';
+import { BaseTask } from './Task/BaseTask';
 import {
     OrderedProductionQueues,
     ProductionQueue,
@@ -43,12 +43,12 @@ export function createTaskHandler(
     name: string,
     scheduler: Scheduler,
     factory: VillageFactory
-): TaskController | undefined {
+): BaseTask | undefined {
     const taskDescription = taskMap[name];
     if (taskDescription === undefined) {
         return undefined;
     }
-    const constructor = (taskDescription.ctor as unknown) as typeof TaskController;
+    const constructor = (taskDescription.ctor as unknown) as typeof BaseTask;
     return new constructor(scheduler, factory);
 }
 

src/Page/BuildingPageController.ts

@@ -1,13 +1,13 @@
-import { UpgradeBuildingTask } from '../Task/UpgradeBuildingTask';
+import { UpgradeBuildingTask } from '../Handler/Task/UpgradeBuildingTask';
 import { Scheduler } from '../Scheduler';
-import { TrainTroopTask } from '../Task/TrainTroopTask';
+import { TrainTroopTask } from '../Handler/Task/TrainTroopTask';
 import { grabActiveVillageId, grabVillageList } from './VillageBlock';
 import { ConsoleLogger, Logger } from '../Logger';
 import { createBuildButton, createUpgradeButton } from './BuildingPage/BuildingPage';
-import { BuildBuildingTask } from '../Task/BuildBuildingTask';
+import { BuildBuildingTask } from '../Handler/Task/BuildBuildingTask';
 import { Resources } from '../Core/Resources';
 import { Coordinates } from '../Core/Village';
-import { SendResourcesTask } from '../Task/SendResourcesTask';
+import { SendResourcesTask } from '../Handler/Task/SendResourcesTask';
 import { EMBASSY_ID, HORSE_STABLE_ID, PALACE_ID, QUARTERS_ID } from '../Core/Buildings';
 import {
     BuildingPageAttributes,
@@ -18,9 +18,9 @@ import {
 import { createTrainTroopButtons } from './BuildingPage/TrooperPage';
 import { createSendResourcesButton } from './BuildingPage/MarketPage';
 import { createResearchButtons } from './BuildingPage/ForgePage';
-import { ForgeImprovementTask } from '../Task/ForgeImprovementTask';
+import { ForgeImprovementTask } from '../Handler/Task/ForgeImprovementTask';
 import { createCelebrationButtons } from './BuildingPage/GuildHallPage';
-import { CelebrationTask } from '../Task/CelebrationTask';
+import { CelebrationTask } from '../Handler/Task/CelebrationTask';
 import { VillageController } from '../Village/VillageController';
 import { notify } from '../Helpers/Browser';
 

src/Queue/TaskProvider.ts

@@ -1,7 +1,7 @@
 import { Args } from './Args';
 import { ResourcesInterface } from '../Core/Resources';
 import { ProductionQueue } from '../Core/ProductionQueue';
-import { getProductionQueue } from '../Task/TaskMap';
+import { getProductionQueue } from '../Handler/TaskMap';
 import { uniqId } from '../Helpers/Identity';
 
 export type TaskId = string;

src/Scheduler.ts

@@ -1,16 +1,16 @@
 import { TaskQueue } from './Queue/TaskQueue';
-import { BalanceHeroResourcesTask } from './Task/BalanceHeroResourcesTask';
+import { BalanceHeroResourcesTask } from './Handler/Task/BalanceHeroResourcesTask';
 import { Logger } from './Logger';
-import { GrabVillageState } from './Task/GrabVillageState';
+import { GrabVillageStateTask } from './Handler/Task/GrabVillageStateTask';
 import { Action, ActionQueue, ImmutableActionList } from './Queue/ActionQueue';
-import { UpdateResourceContracts } from './Task/UpdateResourceContracts';
-import { SendResourcesTask } from './Task/SendResourcesTask';
+import { UpdateResourceContractsTask } from './Handler/Task/UpdateResourceContractsTask';
+import { SendResourcesTask } from './Handler/Task/SendResourcesTask';
 import { Args } from './Queue/Args';
 import { ImmutableTaskList, Task, TaskId, uniqTaskId, withTime } from './Queue/TaskProvider';
 import { VillageRepositoryInterface } from './Village/VillageRepository';
 import { VillageFactory } from './Village/VillageFactory';
-import { RunVillageProductionTask } from './Task/RunVillageProductionTask';
-import { isProductionTask } from './Task/TaskMap';
+import { RunVillageProductionTask } from './Handler/Task/RunVillageProductionTask';
+import { isProductionTask } from './Handler/TaskMap';
 import { around } from './Helpers/Random';
 import { timestamp } from './Helpers/Time';
 
@@ -39,8 +39,8 @@ export class Scheduler {
         this.villageControllerFactory = villageControllerFactory;
         this.logger = logger;
 
-        // this.taskQueue.push(GrabVillageState.name, {}, timestamp());
-        // this.taskQueue.push(UpdateResourceContracts.name, {}, timestamp());
+        // this.taskQueue.push(GrabVillageStateTask.name, {}, timestamp());
+        // this.taskQueue.push(UpdateResourceContractsTask.name, {}, timestamp());
         // this.taskQueue.push(BalanceHeroResourcesTask.name, {}, timestamp());
 
         const villages = this.villageRepository.all();
@@ -50,10 +50,10 @@ export class Scheduler {
             });
         }
 
-        this.createUniqTaskTimer(10 * 60, GrabVillageState.name);
+        this.createUniqTaskTimer(10 * 60, GrabVillageStateTask.name);
         this.createUniqTaskTimer(10 * 60, SendResourcesTask.name);
         this.createUniqTaskTimer(10 * 60, BalanceHeroResourcesTask.name);
-        this.createUniqTaskTimer(20 * 60, UpdateResourceContracts.name);
+        this.createUniqTaskTimer(20 * 60, UpdateResourceContractsTask.name);
         // this.createUniqTaskTimer(60 * 60, SendOnAdventureTask.name);
     }
 

src/Task/GrabVillageState.ts

@@ -1,12 +0,0 @@
-import { TaskController, ActionDefinition } from './TaskController';
-import { scanAllVillagesBundle } from './ActionBundles';
-import { Task } from '../Queue/TaskProvider';
-import { registerTask } from './TaskMap';
-
-@registerTask()
-export class GrabVillageState extends TaskController {
-    defineActions(task: Task): Array<ActionDefinition> {
-        const villages = this.factory.getAllVillages();
-        return scanAllVillagesBundle(villages);
-    }
-}

src/Task/ResourcesToLevel.ts

@@ -1,15 +0,0 @@
-import { TaskController, ActionDefinition } from './TaskController';
-import { UpgradeResourceToLevel } from '../Action/UpgradeResourceToLevel';
-import { Task } from '../Queue/TaskProvider';
-import { registerTask } from './TaskMap';
-import { goToResourceViewPage } from './ActionBundles';
-import { taskError } from '../Errors';
-
-@registerTask()
-export class ResourcesToLevel extends TaskController {
-    defineActions(task: Task): Array<ActionDefinition> {
-        const villageId = task.args.villageId || taskError('No village id');
-
-        return [goToResourceViewPage(villageId), { name: UpgradeResourceToLevel.name }];
-    }
-}

src/Task/RunVillageProductionTask.ts

@@ -1,10 +0,0 @@
-import { TaskController, ActionDefinition } from './TaskController';
-import { Task } from '../Queue/TaskProvider';
-import { registerTask } from './TaskMap';
-
-@registerTask()
-export class RunVillageProductionTask extends TaskController {
-    defineActions(task: Task): Array<ActionDefinition> {
-        return [];
-    }
-}

src/Village/VillageController.ts

@@ -7,7 +7,7 @@ import { MerchantsInfo } from '../Core/Market';
 import { VillageStorage } from '../Storage/VillageStorage';
 import { ReceiveResourcesMode } from '../Core/Village';
 import { ResourceType } from '../Core/ResourceType';
-import { UpgradeBuildingTask } from '../Task/UpgradeBuildingTask';
+import { UpgradeBuildingTask } from '../Handler/Task/UpgradeBuildingTask';
 import { GARNER_ID, WAREHOUSE_ID } from '../Core/Buildings';
 import { first } from '../Helpers/Collection';
 

src/Village/VillageState.ts

@@ -7,7 +7,7 @@ import { VillageNotFound } from '../Errors';
 import { OrderedProductionQueues, ProductionQueue } from '../Core/ProductionQueue';
 import { isInQueue, TaskCore, TaskId } from '../Queue/TaskProvider';
 import { VillageTaskCollection } from './VillageTaskCollection';
-import { TrainTroopTask } from '../Task/TrainTroopTask';
+import { TrainTroopTask } from '../Handler/Task/TrainTroopTask';
 import { Args } from '../Queue/Args';
 import { timestamp } from '../Helpers/Time';
 

src/Village/VillageTaskCollection.ts

@@ -3,9 +3,9 @@ import { Task, TaskId, uniqTaskId, withResources, withTime } from '../Queue/Task
 import { Args } from '../Queue/Args';
 import { Resources } from '../Core/Resources';
 import { ContractAttributes, ContractType } from '../Core/Contract';
-import { UpgradeBuildingTask } from '../Task/UpgradeBuildingTask';
-import { ForgeImprovementTask } from '../Task/ForgeImprovementTask';
-import { isProductionTask } from '../Task/TaskMap';
+import { UpgradeBuildingTask } from '../Handler/Task/UpgradeBuildingTask';
+import { ForgeImprovementTask } from '../Handler/Task/ForgeImprovementTask';
+import { isProductionTask } from '../Handler/TaskMap';
 import { timestamp } from '../Helpers/Time';
 
 export class VillageTaskCollection {