greybel-mock-environment 1.2.3 → 1.2.5

package/dist/environment.d.ts

@@ -3,8 +3,14 @@ import EmailGenerator from './generators/email';
 import NetworkGenerator from './generators/network';
 import UserGenerator from './generators/user';
 import VulnerabilityGenerator from './generators/vulnerability';
-import { Computer, EMail, Port, Router, Session, Switch } from './types';
+import { Computer, Device, EMail, Location, Port, Router, Session, Switch } from './types';
+export interface RouterLocation {
+    distance: number;
+    percentage: number;
+    router: Router;
+}
 export default class MockEnvironment {
+    readonly WIFI_MAX_DISTANCE: number;
     seed: string;
     basicGenerator: BasicGenerator;
     emailGenerator: EmailGenerator;
@@ -29,7 +35,9 @@ export default class MockEnvironment {
     setupLocalSession(username: string, password: string): void;
     getLatestSession(): Session;
     getLocal(): Session;
+    connect(router: Router, device: Device): void;
     connectLocal(router: Router): void;
+    findRoutersCloseToLocation(loc: Location): RouterLocation[];
     getRouterByIp(ipAddress: string): Router | null;
     getSwitchByIp(ipAddress: string): Switch | null;
     findRouterViaNS(name: string): Router;

package/dist/environment.js

@@ -40,6 +40,7 @@ var utils_1 = require("./utils");
 var MockEnvironment = /** @class */ (function () {
     function MockEnvironment(seed, localUser) {
         if (seed === void 0) { seed = 'test'; }
+        this.WIFI_MAX_DISTANCE = 10;
         var me = this;
         me.seed = seed;
         me.basicGenerator = new basic_1.default({ seed: seed });
@@ -149,7 +150,7 @@ var MockEnvironment = /** @class */ (function () {
             isProtected: true,
             type: types_1.FileType.Bin
         });
-        currentPath.putFile(programPath);
+        currentPath.putEntity(programPath);
         me.localSession = new types_1.Session({
             user: user,
             computer: computer,
@@ -164,21 +165,58 @@ var MockEnvironment = /** @class */ (function () {
     MockEnvironment.prototype.getLocal = function () {
         return this.localSession;
     };
-    MockEnvironment.prototype.connectLocal = function (router) {
+    MockEnvironment.prototype.connect = function (router, device) {
+        if (!(device instanceof types_1.Computer) && !(device instanceof types_1.Switch)) {
+            throw new Error('Cannot connect router to router.');
+        }
+        if (device.router) {
+            device.router.devices.delete(device.localIp);
+        }
         var me = this;
         var serverMap = me.networkGenerator.serverMap;
         if (!serverMap.has(router.publicIp)) {
             throw new Error("Router with ip ".concat(router.publicIp, " is unknown in serverMap."));
         }
-        var computer = me.localSession.computer;
-        if (computer.router) {
-            computer.router.devices.delete(computer.localIp);
-        }
         var serverMapGenerator = serverMap.get(router.publicIp);
         var localIp = serverMapGenerator.generateLocalIp(router);
-        computer.router = router;
-        computer.localIp = localIp;
-        router.devices.set(localIp, computer);
+        device.router = router;
+        device.localIp = localIp;
+        router.devices.set(localIp, device);
+    };
+    MockEnvironment.prototype.connectLocal = function (router) {
+        this.connect(router, this.localSession.computer);
+    };
+    MockEnvironment.prototype.findRoutersCloseToLocation = function (loc) {
+        var e_1, _a;
+        var me = this;
+        var getDistance = function (routerLoc) {
+            var y = routerLoc.x - loc.x;
+            var x = routerLoc.y - loc.y;
+            return Math.sqrt(x * x + y * y);
+        };
+        var result = [];
+        try {
+            for (var _b = __values(me.networkGenerator.serverMap.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var serverMapGenerator = _c.value;
+                var distance = getDistance(serverMapGenerator.router.location);
+                if (distance < me.WIFI_MAX_DISTANCE) {
+                    var percentage = Math.round(((me.WIFI_MAX_DISTANCE - distance) * 100) / me.WIFI_MAX_DISTANCE);
+                    result.push({
+                        percentage: percentage,
+                        distance: distance,
+                        router: serverMapGenerator.router
+                    });
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return result;
     };
     MockEnvironment.prototype.getRouterByIp = function (ipAddress) {
         var me = this;
@@ -194,7 +232,7 @@ var MockEnvironment = /** @class */ (function () {
         });
     };
     MockEnvironment.prototype.getSwitchByIp = function (ipAddress) {
-        var e_1, _a;
+        var e_2, _a;
         var me = this;
         if (!(0, utils_1.isValidIp)(ipAddress) || !(0, utils_1.isLanIp)(ipAddress)) {
             return null;
@@ -208,12 +246,12 @@ var MockEnvironment = /** @class */ (function () {
                 }
             }
         }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
         finally {
             try {
                 if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            finally { if (e_1) throw e_1.error; }
+            finally { if (e_2) throw e_2.error; }
         }
         return null;
     };

package/dist/fs.d.ts

@@ -1,30 +1,18 @@
 import { Service } from './types';
 import { Entity, File, Folder } from './types/file-system';
+import { MetaInfo } from './types/meta-info';
 import { Port } from './types/port';
 import { User } from './types/user';
-export declare enum FSDeviceOwnerType {
-    Player = 0,
-    Npc = 1
-}
-export declare enum FSCreationVariation {
-    Easy = 0,
-    Medium = 1,
-    Hard = 2
-}
-export declare enum FSDeviceType {
-    Unknown = 0,
-    Computer = 1,
-    Router = 2,
-    Switch = 3
-}
+export declare function getLibraryFile(service: Service, parent?: Entity): File;
+export declare type Files = Map<string, File>;
+export declare function generateFiles(...files: File[]): Files;
+export declare type Folders = Map<string, Folder>;
+export declare function generateFolders(...folders: Folder[]): Folders;
 export interface FSOptions {
     users: User[];
-    type: FSDeviceType;
-    ownerType: FSDeviceOwnerType;
-    difficulty?: FSCreationVariation;
+    meta: MetaInfo;
     parent?: Entity;
     ports?: Map<number, Port>;
 }
-export declare function getLibraryFile(service: Service, parent?: Entity): File;
 export declare function getUserFolder(options: FSOptions, user: string): Folder;
 export declare function getDefaultFileSystem(options: FSOptions): Folder;