ing

@overflow/model/meta/MetaCrawler.ts

@@ -0,0 +1,7 @@
+export interface MetaCrawler {
+  id?: number;
+  key?: string;
+  name?: string;
+  default?: boolean;
+  createDate?: Date;
+}

@overflow/model/meta/MetaCrawlerInputItem.ts

@@ -0,0 +1,15 @@
+import { MetaInputType } from './MetaInputType';
+import { MetaCrawler } from './MetaCrawler';
+
+export interface MetaCrawlerInputItem {
+  id?: number;
+  name?: string;
+  metaInputType?: MetaInputType;
+  metaCrawler?: MetaCrawler;
+  required?: boolean;
+  defaultValue?: string;
+  pattern?: string;
+  keyName?: string;
+  keyValue?: string;
+  createDate?: Date;
+}

@overflow/model/meta/MetaCrawlerMapping.ts

@@ -0,0 +1,9 @@
+import { MetaCrawler } from './MetaCrawler';
+import { MetaTargetType } from './MetaTargetType';
+
+export interface MetaCrawlerMapping {
+  id?: number;
+  metaTargetType?: MetaTargetType;
+  metaCrawler?: MetaCrawler;
+  createDate?: Date;
+}

@overflow/model/meta/MetaCryptoType.ts

@@ -0,0 +1,38 @@
+export interface MetaCryptoType {
+  id?: number;
+  name?: string;
+  key?: string;
+  createDate?: Date;
+}
+
+export enum MetaCryptoTypeEnum {
+  NONE = 'NONE',
+  UNKNOWN = 'UNKNOWN',
+  AES = 'AES',
+  CIPHER = 'CIPHER',
+  DES = 'DES',
+  DSA = 'DSA',
+  ECDSA = 'ECDSA',
+  ELLIPTIC = 'ELLIPTIC',
+  HMAC = 'HMAC',
+  MD5 = 'MD5',
+  RAND = 'RAND',
+  RC4 = 'RC4',
+  RSA = 'RSA',
+  SHA1 = 'SHA1',
+  SHA256 = 'SHA256',
+  SUBTLE = 'SUBTLE',
+  TLS = 'TLS',
+  X509 = 'X509',
+  PKIX = 'PKIX',
+}
+
+export const toMetaCryptoTypeEnum = (v: MetaCryptoType): MetaCryptoTypeEnum => {
+  return MetaCryptoTypeEnum[v.key];
+};
+
+export const toMetaCryptoType = (v: MetaCryptoTypeEnum): MetaCryptoType => {
+  return {
+    key: v,
+  };
+};

@overflow/model/meta/MetaEmailType.ts

@@ -0,0 +1,21 @@
+export interface MetaEmailType {
+  id?: number;
+  name?: string;
+  key?: string;
+  createDate?: Date;
+}
+
+export enum MetaEmailTypeEnum {
+  SIGNUP = 'SIGNUP',
+  RESET_PASSWORD = 'RESET_PASSWORD',
+}
+
+export const toMetaEmailTypeEnum = (v: MetaEmailType): MetaEmailTypeEnum => {
+  return MetaEmailTypeEnum[v.key];
+};
+
+export const toMetaEmailType = (v: MetaEmailTypeEnum): MetaEmailType => {
+  return {
+    key: v,
+  };
+};

@overflow/model/meta/MetaHistoryType.ts

@@ -0,0 +1,25 @@
+export interface MetaHistoryType {
+  id?: number;
+  key?: string;
+  name?: string;
+  createDate?: Date;
+}
+
+export enum MetaHistoryTypeEnum {
+  MEMBER = 'MEMBER',
+  PROBE = 'PROBE',
+  DISCOVERY = 'DISCOVERY',
+  TARGET = 'TARGET',
+  CRAWLER = 'CRAWLER',
+  SENSOR = 'SENSOR',
+}
+
+export const toMetaHistoryTypeEnum = (v: MetaHistoryType): MetaHistoryTypeEnum => {
+  return MetaHistoryTypeEnum[v.key];
+};
+
+export const toMetaHistoryType = (v: MetaHistoryTypeEnum): MetaHistoryType => {
+  return {
+    key: v,
+  };
+};

@overflow/model/meta/MetaIPType.ts

@@ -0,0 +1,21 @@
+export interface MetaIPType {
+  id?: number;
+  key?: string;
+  name?: string;
+  createDate?: Date;
+}
+
+export enum MetaIPTypeEnum {
+  V4 = 'V4',
+  V6 = 'V6',
+}
+
+export const toMetaIPTypeEnum = (v: MetaIPType): MetaIPTypeEnum => {
+  return MetaIPTypeEnum[v.key];
+};
+
+export const toMetaIPType = (v: MetaIPTypeEnum): MetaIPType => {
+  return {
+    key: v,
+  };
+};

@overflow/model/meta/MetaInfraType.ts

@@ -0,0 +1,22 @@
+export interface MetaInfraType {
+  id?: number;
+  key?: string;
+  name?: string;
+  createDate?: Date;
+}
+
+export enum MetaInfraTypeEnum {
+  ZONE = 'ZONE',
+  HOST = 'HOST',
+  SERVICE = 'SERVICE',
+}
+
+export const toMetaInfraTypeEnum = (v: MetaInfraType): MetaInfraTypeEnum => {
+  return MetaInfraTypeEnum[v.key];
+};
+
+export const toMetaInfraType = (v: MetaInfraTypeEnum): MetaInfraType => {
+  return {
+    key: v,
+  };
+};

@overflow/model/meta/MetaInputType.ts

@@ -0,0 +1,25 @@
+
+export interface MetaInputType {
+  id?: number;
+  key?: string;
+  name?: string;
+  createDate?: Date;
+}
+
+export enum MetaInputTypeEnum {
+  TEXT = 'TEXT',
+  PASSWORD = 'PASSWORD',
+  NUMBER = 'NUMBER',
+  BOOLEAN = 'BOOLEAN',
+  SELECT = 'SELECT',
+}
+
+export const toMetaInputTypeEnum = (v: MetaInputType): MetaInputTypeEnum => {
+  return MetaInputTypeEnum[v.key];
+};
+
+export const toMetaInputType = (v: MetaInputTypeEnum): MetaInputType => {
+  return {
+    key: v,
+  };
+};

@overflow/model/meta/MetaMemberStatus.ts

@@ -0,0 +1,24 @@
+
+export interface MetaMemberStatus {
+  id?: number;
+  key?: string;
+  name?: string;
+  createDate?: Date;
+}
+
+export enum MetaMemberStatusEnum {
+  NOAUTH = 'NOAUTH',
+  NORMAL = 'NORMAL',
+  DORMANCY = 'DORMANCY',
+  WITHDRAWAL = 'WITHDRAWAL',
+}
+
+export const toMetaMemberStatusEnum = (v: MetaMemberStatus): MetaMemberStatusEnum => {
+  return MetaMemberStatusEnum[v.key];
+};
+
+export const toMetaMemberStatus = (v: MetaMemberStatusEnum): MetaMemberStatus => {
+  return {
+    key: v,
+  };
+};

@overflow/model/meta/MetaNoAuthProbeStatus.ts

@@ -0,0 +1,23 @@
+
+export interface MetaNoAuthProbeStatus {
+  id?: number;
+  key?: string;
+  name?: string;
+  createDate?: Date;
+}
+
+export enum MetaNoAuthProbeStatusEnum {
+  ACCEPTED = 'ACCEPTED',
+  DENIED = 'DENIED',
+  PROCESSING = 'PROCESSING',
+}
+
+export const toMetaNoAuthProbeStatusEnum = (v: MetaNoAuthProbeStatus): MetaNoAuthProbeStatusEnum => {
+  return MetaNoAuthProbeStatusEnum[v.key];
+};
+
+export const toMetaNoAuthProbeStatus = (v: MetaNoAuthProbeStatusEnum): MetaNoAuthProbeStatus => {
+  return {
+    key: v,
+  };
+};

@overflow/model/meta/MetaPortType.ts

@@ -0,0 +1,23 @@
+
+export interface MetaPortType {
+  id?: number;
+  key?: string;
+  name?: string;
+  createDate?: Date;
+}
+
+
+export enum MetaPortTypeEnum {
+  TCP = 'TCP',
+  UDP = 'UDP',
+}
+
+export const toMetaPortTypeEnum = (v: MetaPortType): MetaPortTypeEnum => {
+  return MetaPortTypeEnum[v.key];
+};
+
+export const toMetaPortType = (v: MetaPortTypeEnum): MetaPortType => {
+  return {
+    key: v,
+  };
+};

@overflow/model/meta/MetaProbeStatus.ts

@@ -0,0 +1,22 @@
+
+export interface MetaProbeStatus {
+  id?: number;
+  key?: string;
+  name?: string;
+  createDate?: Date;
+}
+
+export enum MetaProbeStatusEnum {
+  INITIAL = 'INITIAL',
+  NORMAL = 'NORMAL',
+}
+
+export const toMetaProbeStatusEnum = (v: MetaProbeStatus): MetaProbeStatusEnum => {
+  return MetaProbeStatusEnum[v.key];
+};
+
+export const toMetaProbeStatus = (v: MetaProbeStatusEnum): MetaProbeStatus => {
+  return {
+    key: v,
+  };
+};

@overflow/model/meta/MetaSensorDisplayItem.ts

@@ -0,0 +1,15 @@
+import { MetaCrawler } from './MetaCrawler';
+import { MetaSensorItemUnit } from './MetaSensorItemUnit';
+import { MetaSensorItemType } from './MetaSensorItemType';
+
+
+export interface MetaSensorDisplayItem {
+  id?: number;
+  key?: string;
+  name?: string;
+  metaCrawler?: MetaCrawler;
+  metaSensorItemUnit?: MetaSensorItemUnit;
+  metaSensorItemType?: MetaSensorItemType;
+  createDate?: Date;
+  default?: boolean;
+}

@overflow/model/meta/MetaSensorDisplayMapping.ts

@@ -0,0 +1,9 @@
+import { MetaSensorDisplayItem } from './MetaSensorDisplayItem';
+import { MetaSensorItemKey } from './MetaSensorItemKey';
+
+export interface MetaSensorDisplayMapping {
+  id?: number;
+  metaSensorDisplayItem?: MetaSensorDisplayItem;
+  metaSensorItemKey?: MetaSensorItemKey;
+  createDate?: Date;
+}

@overflow/model/meta/MetaSensorItem.ts

@@ -0,0 +1,7 @@
+
+export interface MetaSensorItem {
+  id?: number;
+  key?: string;
+  name?: string;
+  createDate?: Date;
+}

@overflow/model/meta/MetaSensorItemKey.ts

@@ -0,0 +1,15 @@
+import { MetaSensorItem } from './MetaSensorItem';
+import { MetaCrawler } from './MetaCrawler';
+import { MetaSensorItemUnit } from './MetaSensorItemUnit';
+
+export interface MetaSensorItemKey {
+  id?: number;
+  key?: string;
+  name?: string;
+  froms?: string;
+  option?: string;
+  metaSensorItem?: MetaSensorItem;
+  metaCrawler?: MetaCrawler;
+  metaSensorItemUnit?: MetaSensorItemUnit;
+  createDate?: Date;
+}

@overflow/model/meta/MetaSensorItemType.ts

@@ -0,0 +1,7 @@
+
+export interface MetaSensorItemType {
+  id?: number;
+  key?: string;
+  name?: string;
+  createDate?: Date;
+}

@overflow/model/meta/MetaSensorItemUnit.ts

@@ -0,0 +1,8 @@
+
+export interface MetaSensorItemUnit {
+  id?: number;
+  key?: string;
+  unit?: string;
+  mark?: string;
+  createDate?: Date;
+}

@overflow/model/meta/MetaSensorStatus.ts

@@ -0,0 +1,7 @@
+
+export interface MetaSensorStatus {
+  id?: number;
+  key?: string;
+  name?: string;
+  createDate?: Date;
+}

@overflow/model/meta/MetaTargetCategory.ts

@@ -0,0 +1,9 @@
+import { MetaInfraType } from './MetaInfraType';
+
+export interface MetaTargetCategory {
+  id?: number;
+  metaInfraType?: MetaInfraType;
+  key?: string;
+  name?: string;
+  createDate?: Date;
+}

@overflow/model/meta/MetaTargetHostType.ts

@@ -0,0 +1,18 @@
+import { MetaTargetType } from './MetaTargetType';
+
+export interface MetaTargetHostType extends MetaTargetType {
+}
+
+export enum MetaTargetHostTypeEnum {
+  UNKNOWN = 'UNKNOWN',
+}
+
+export const toMetaTargetHostTypeEnum = (v: MetaTargetHostType): MetaTargetHostTypeEnum => {
+  return MetaTargetHostTypeEnum[v.key];
+};
+
+export const toMetaTargetHostType = (v: MetaTargetHostTypeEnum): MetaTargetHostType => {
+  return {
+    key: v,
+  };
+};

@overflow/model/meta/MetaTargetServiceType.ts

@@ -0,0 +1,18 @@
+import { MetaTargetType } from './MetaTargetType';
+
+export interface MetaTargetServiceType extends MetaTargetType {
+}
+
+export enum MetaTargetServiceTypeEnum {
+  UNKNOWN = 'UNKNOWN',
+}
+
+export const toMetaTargetServiceTypeEnum = (v: MetaTargetServiceType): MetaTargetServiceTypeEnum => {
+  return MetaTargetServiceTypeEnum[v.key];
+};
+
+export const toMetaTargetServiceType = (v: MetaTargetServiceTypeEnum): MetaTargetServiceType => {
+  return {
+    key: v,
+  };
+};

@overflow/model/meta/MetaTargetStatus.ts

@@ -0,0 +1,23 @@
+export interface MetaTargetStatus {
+  id?: number;
+  key?: string;
+  name?: string;
+  createDate?: Date;
+}
+
+export enum MetaTargetStatusEnum {
+  UP = 'UP',
+  DOWN = 'DOWN',
+  WARN = 'WARN',
+  ERROR = 'ERROR',
+}
+
+export const toMetaTargetStatusEnum = (v: MetaTargetStatus): MetaTargetStatusEnum => {
+  return MetaTargetStatusEnum[v.key];
+};
+
+export const toMetaTargetStatus = (v: MetaTargetStatusEnum): MetaTargetStatus => {
+  return {
+    key: v,
+  };
+};

@overflow/model/meta/MetaTargetType.ts

@@ -0,0 +1,10 @@
+import { MetaInfraType } from './MetaInfraType';
+
+export interface MetaTargetType {
+  id?: number;
+  metaInfraType?: MetaInfraType;
+  key?: string;
+  name?: string;
+  createDate?: Date;
+  supported?: boolean;
+}

@overflow/model/meta/MetaTargetTypeCategory.ts

@@ -0,0 +1,9 @@
+import { MetaInfraType } from './MetaInfraType';
+
+export interface MetaTargetTypeCategory {
+  id?: number;
+  metaInfraType?: MetaInfraType;
+  key?: string;
+  name?: string;
+  createDate?: Date;
+}

@overflow/model/meta/MetaTargetTypeCategoryMapping.ts

@@ -0,0 +1,9 @@
+import { MetaTargetType } from './MetaTargetType';
+import { MetaTargetTypeCategory } from './MetaTargetTypeCategory';
+
+export interface MetaTargetTypeCategoryMapping {
+  id?: number;
+  metaTargetTypeCategory?: MetaTargetTypeCategory;
+  metaTargetType?: MetaTargetType;
+  createDate?: Date;
+}

@overflow/model/meta/MetaTargetZoneType.ts

@@ -0,0 +1,19 @@
+import { MetaTargetType } from './MetaTargetType';
+
+export interface MetaTargetZoneType extends MetaTargetType {
+}
+
+export enum MetaTargetZoneTypeEnum {
+  UNKNOWN = 'UNKNOWN',
+  ZONE = 'ZONE',
+}
+
+export const toMetaTargetZoneTypeEnum = (v: MetaTargetZoneType): MetaTargetZoneTypeEnum => {
+  return MetaTargetZoneTypeEnum[v.key];
+};
+
+export const toMetaTargetZoneType = (v: MetaTargetZoneTypeEnum): MetaTargetZoneType => {
+  return {
+    key: v,
+  };
+};

@overflow/model/meta/index.ts

@@ -0,0 +1,28 @@
+export * from './MetaCrawler';
+export * from './MetaCrawlerInputItem';
+export * from './MetaCrawlerMapping';
+export * from './MetaCryptoType';
+export * from './MetaEmailType';
+export * from './MetaHistoryType';
+export * from './MetaInfraType';
+export * from './MetaInputType';
+export * from './MetaIPType';
+export * from './MetaMemberStatus';
+export * from './MetaNoAuthProbeStatus';
+export * from './MetaPortType';
+export * from './MetaProbeStatus';
+export * from './MetaSensorDisplayItem';
+export * from './MetaSensorDisplayMapping';
+export * from './MetaSensorItem';
+export * from './MetaSensorItemKey';
+export * from './MetaSensorItemType';
+export * from './MetaSensorItemUnit';
+export * from './MetaSensorStatus';
+export * from './MetaTargetCategory';
+export * from './MetaTargetHostType';
+export * from './MetaTargetServiceType';
+export * from './MetaTargetStatus';
+export * from './MetaTargetType';
+export * from './MetaTargetTypeCategory';
+export * from './MetaTargetTypeCategoryMapping';
+export * from './MetaTargetZoneType';

@overflow/model/net/nic.ts

@@ -0,0 +1,14 @@
+import { MetaIPType } from '../meta';
+
+export interface Interface {
+  iface: string;
+  mac: string;
+}
+
+export interface InterfaceAddress {
+  metaIPType: MetaIPType;
+  address: string;
+  netmask: string;
+  network: string;
+  gateway: string;
+}

src/commons/component/nic-dropdown.component.ts

@@ -5,6 +5,7 @@ import { catchError, exhaustMap, map, tap, take } from 'rxjs/operators';
 
 
 import { ProbeService } from '../service/probe.service';
+import { Interface } from '@overflow/model/net/nic';
 
 @Component({
   selector: 'app-nic-dropdown',
@@ -21,8 +22,8 @@ export class NicDropdownComponent implements OnInit {
   }
 
   ngOnInit(): void {
-    this.probeService.call<any>('MachineService.Interfaces').pipe(
+    this.probeService.call<Interface>('MachineService.Interfaces').pipe(
-      map((ifaces: any) => {
+      map((ifaces: Interface[]) => {
         console.log(ifaces);
       }),
       catchError(error => {

tslint.json

@@ -1,22 +1,36 @@
 {
-  "rulesDirectory": ["node_modules/codelyzer"],
+  "rulesDirectory": [
+    "node_modules/codelyzer"
+  ],
   "rules": {
     "arrow-return-shorthand": true,
     "callable-types": true,
     "class-name": true,
-    "comment-format": [true, "check-space"],
+    "comment-format": [
+      true,
+      "check-space"
+    ],
     "curly": true,
     "deprecation": {
       "severity": "warn"
     },
     "eofline": true,
     "forin": true,
-    "import-blacklist": [true, "rxjs/Rx"],
+    "import-blacklist": [
+      true,
+      "rxjs/Rx"
+    ],
     "import-spacing": true,
-    "indent": [true, "spaces"],
+    "indent": [
+      true,
+      "spaces"
+    ],
     "interface-over-type-literal": true,
     "label-position": true,
-    "max-line-length": [true, 140],
+    "max-line-length": [
+      true,
+      140
+    ],
     "member-access": false,
     "member-ordering": [
       true,
@@ -31,14 +45,24 @@
     ],
     "no-arg": true,
     "no-bitwise": true,
-    "no-console": [false, "debug", "info", "time", "timeEnd", "trace"],
+    "no-console": [
+      false,
+      "debug",
+      "info",
+      "time",
+      "timeEnd",
+      "trace"
+    ],
     "no-construct": true,
     "no-debugger": true,
     "no-duplicate-super": true,
     "no-empty": false,
-    "no-empty-interface": true,
+    "no-empty-interface": false,
     "no-eval": true,
-    "no-inferrable-types": [true, "ignore-params"],
+    "no-inferrable-types": [
+      true,
+      "ignore-params"
+    ],
     "no-misused-new": true,
     "no-non-null-assertion": true,
     "no-shadowed-variable": true,
@@ -59,10 +83,19 @@
       "check-whitespace"
     ],
     "prefer-const": true,
-    "quotemark": [true, "single"],
+    "quotemark": [
+      true,
+      "single"
+    ],
     "radix": true,
-    "semicolon": [true, "always"],
+    "semicolon": [
-    "triple-equals": [true, "allow-null-check"],
+      true,
+      "always"
+    ],
+    "triple-equals": [
+      true,
+      "allow-null-check"
+    ],
     "typedef-whitespace": [
       true,
       {