[webapp] 批量处理eslint格式告警

2021-12-23 15:59:49 +08:00
parent 1469e85443
commit 7e41f64491
72 changed files with 1724 additions and 2170 deletions
--- a/web-app/src/app/service/alert-define.service.ts
+++ b/web-app/src/app/service/alert-define.service.ts
@@ -1,66 +1,64 @@
+import { HttpClient, HttpParams } from '@angular/common/http';
 import { Injectable } from '@angular/core';
-import {HttpClient, HttpParams} from "@angular/common/http";
-import {Observable} from "rxjs";
-import {Message} from "../pojo/Message";
-import {Page} from "../pojo/Page";
-import {AlertDefine} from "../pojo/AlertDefine";
-import {AlertDefineBind} from "../pojo/AlertDefineBind";
+import { Observable } from 'rxjs';

-const alert_define_uri = "/alert/define";
-const alert_defines_uri = "/alert/defines";
+import { AlertDefine } from '../pojo/AlertDefine';
+import { AlertDefineBind } from '../pojo/AlertDefineBind';
+import { Message } from '../pojo/Message';
+import { Page } from '../pojo/Page';
+
+const alert_define_uri = '/alert/define';
+const alert_defines_uri = '/alert/defines';

@Injectable({
  providedIn: 'root'
 })
 export class AlertDefineService {
+  constructor(private http: HttpClient) {}

-  constructor(private http : HttpClient) { }
-
-  public newAlertDefine(body: AlertDefine) : Observable<Message<any>> {
+  public newAlertDefine(body: AlertDefine): Observable<Message<any>> {
    return this.http.post<Message<any>>(alert_define_uri, body);
  }

-  public editAlertDefine(body: AlertDefine) : Observable<Message<any>> {
+  public editAlertDefine(body: AlertDefine): Observable<Message<any>> {
    return this.http.put<Message<any>>(alert_define_uri, body);
  }

-  public getAlertDefine(alertDefineId: number) : Observable<Message<AlertDefine>> {
+  public getAlertDefine(alertDefineId: number): Observable<Message<AlertDefine>> {
    return this.http.get<Message<AlertDefine>>(`${alert_define_uri}/${alertDefineId}`);
  }

-  public applyAlertDefineMonitorsBind(alertDefineId: number,
-                                      binds: AlertDefineBind[]): Observable<Message<any>> {
+  public applyAlertDefineMonitorsBind(alertDefineId: number, binds: AlertDefineBind[]): Observable<Message<any>> {
    return this.http.post<Message<any>>(`${alert_define_uri}/${alertDefineId}/monitors`, binds);
  }

-  public getAlertDefineMonitorsBind(alertDefineId: number) : Observable<Message<AlertDefineBind[]>> {
+  public getAlertDefineMonitorsBind(alertDefineId: number): Observable<Message<AlertDefineBind[]>> {
    return this.http.get<Message<AlertDefineBind[]>>(`${alert_define_uri}/${alertDefineId}/monitors`);
  }

-  public deleteAlertDefines(alertDefineIds: Set<number>) : Observable<Message<any>> {
+  public deleteAlertDefines(alertDefineIds: Set<number>): Observable<Message<any>> {
    let httpParams = new HttpParams();
    alertDefineIds.forEach(alertDefineId => {
      // 注意HttpParams是不可变对象 需要保存append后返回的对象为最新对象
      // append方法可以叠加同一key, set方法会把key之前的值覆盖只留一个key-value
      httpParams = httpParams.append('ids', alertDefineId);
-    })
+    });
    const options = { params: httpParams };
    return this.http.delete<Message<any>>(alert_defines_uri, options);
  }

-  public getAlertDefines(pageIndex: number, pageSize: number) : Observable<Message<Page<AlertDefine>>> {
+  public getAlertDefines(pageIndex: number, pageSize: number): Observable<Message<Page<AlertDefine>>> {
    pageIndex = pageIndex ? pageIndex : 0;
    pageSize = pageSize ? pageSize : 8;
    // 注意HttpParams是不可变对象 需要保存set后返回的对象为最新对象
    let httpParams = new HttpParams();
    httpParams = httpParams.appendAll({
-      'sort': 'id',
-      'order': 'desc',
-      'pageIndex': pageIndex,
-      'pageSize': pageSize
+      sort: 'id',
+      order: 'desc',
+      pageIndex: pageIndex,
+      pageSize: pageSize
    });
    const options = { params: httpParams };
    return this.http.get<Message<Page<AlertDefine>>>(alert_defines_uri, options);
  }
-
 }
--- a/web-app/src/app/service/alert.service.ts
+++ b/web-app/src/app/service/alert.service.ts
@@ -1,9 +1,10 @@
+import { HttpClient, HttpParams } from '@angular/common/http';
 import { Injectable } from '@angular/core';
-import {HttpClient, HttpParams} from "@angular/common/http";
-import {Observable} from "rxjs";
-import {Message} from "../pojo/Message";
-import {Page} from "../pojo/Page";
-import {Alert} from "../pojo/Alert";
+import { Observable } from 'rxjs';
+
+import { Alert } from '../pojo/Alert';
+import { Message } from '../pojo/Message';
+import { Page } from '../pojo/Page';

 const alerts_uri = '/alerts';

@@ -13,35 +14,39 @@ const alerts_status_uri = '/alerts/status';
  providedIn: 'root'
 })
 export class AlertService {
+  constructor(private http: HttpClient) {}

-  constructor(private http : HttpClient) { }
-
-  public getAlerts(pageIndex: number, pageSize: number) : Observable<Message<Page<Alert>>> {
+  public getAlerts(pageIndex: number, pageSize: number): Observable<Message<Page<Alert>>> {
    pageIndex = pageIndex ? pageIndex : 0;
    pageSize = pageSize ? pageSize : 8;
    // 注意HttpParams是不可变对象 需要保存set后返回的对象为最新对象
    let httpParams = new HttpParams();
    httpParams = httpParams.appendAll({
-      'sort': 'id',
-      'order': 'desc',
-      'pageIndex': pageIndex,
-      'pageSize': pageSize
+      sort: 'id',
+      order: 'desc',
+      pageIndex: pageIndex,
+      pageSize: pageSize
    });
    const options = { params: httpParams };
    return this.http.get<Message<Page<Alert>>>(alerts_uri, options);
  }

-  public searchAlerts(status: number | undefined, priority: number | undefined, content: string | undefined,
-                      pageIndex: number, pageSize: number) : Observable<Message<Page<Alert>>> {
+  public searchAlerts(
+    status: number | undefined,
+    priority: number | undefined,
+    content: string | undefined,
+    pageIndex: number,
+    pageSize: number
+  ): Observable<Message<Page<Alert>>> {
    pageIndex = pageIndex ? pageIndex : 0;
    pageSize = pageSize ? pageSize : 8;
    // 注意HttpParams是不可变对象 需要保存set后返回的对象为最新对象
    let httpParams = new HttpParams();
    httpParams = httpParams.appendAll({
-      'sort': 'id',
-      'order': 'desc',
-      'pageIndex': pageIndex,
-      'pageSize': pageSize
+      sort: 'id',
+      order: 'desc',
+      pageIndex: pageIndex,
+      pageSize: pageSize
    });
    if (status != undefined && status != 9) {
      httpParams = httpParams.append('status', status);
@@ -56,26 +61,25 @@ export class AlertService {
    return this.http.get<Message<Page<Alert>>>(alerts_uri, options);
  }

-  public deleteAlerts(alertIds: Set<number>) : Observable<Message<any>> {
+  public deleteAlerts(alertIds: Set<number>): Observable<Message<any>> {
    let httpParams = new HttpParams();
    alertIds.forEach(alertId => {
      // 注意HttpParams是不可变对象 需要保存append后返回的对象为最新对象
      // append方法可以叠加同一key, set方法会把key之前的值覆盖只留一个key-value
      httpParams = httpParams.append('ids', alertId);
-    })
+    });
    const options = { params: httpParams };
    return this.http.delete<Message<any>>(alerts_uri, options);
  }

-  public applyAlertsStatus(alertIds: Set<number>, status: number) : Observable<Message<any>> {
+  public applyAlertsStatus(alertIds: Set<number>, status: number): Observable<Message<any>> {
    let httpParams = new HttpParams();
    alertIds.forEach(alertId => {
      // 注意HttpParams是不可变对象 需要保存append后返回的对象为最新对象
      // append方法可以叠加同一key, set方法会把key之前的值覆盖只留一个key-value
      httpParams = httpParams.append('ids', alertId);
-    })
+    });
    const options = { params: httpParams };
    return this.http.put<Message<any>>(`${alerts_status_uri}/${status}`, null, options);
  }
-
 }
--- a/web-app/src/app/service/app-define.service.ts
+++ b/web-app/src/app/service/app-define.service.ts
@@ -1,8 +1,9 @@
+import { HttpClient, HttpParams } from '@angular/common/http';
 import { Injectable } from '@angular/core';
-import {HttpClient, HttpParams} from '@angular/common/http';
-import {Message} from "../pojo/Message";
-import {Observable} from "rxjs";
-import {ParamDefine} from "../pojo/ParamDefine";
+import { Observable } from 'rxjs';
+
+import { Message } from '../pojo/Message';
+import { ParamDefine } from '../pojo/ParamDefine';

 const app_hierarchy = '/apps/hierarchy';

@@ -10,21 +11,19 @@ const app_hierarchy = '/apps/hierarchy';
  providedIn: 'root'
 })
 export class AppDefineService {
+  constructor(private http: HttpClient) {}

-  constructor(private http : HttpClient) { }
-
-  public getAppParamsDefine(app: string | undefined | null) : Observable<Message<ParamDefine[]>> {
+  public getAppParamsDefine(app: string | undefined | null): Observable<Message<ParamDefine[]>> {
    if (app === null || app === undefined) {
-      console.log("getAppParamsDefine app can not null");
+      console.log('getAppParamsDefine app can not null');
    }
    const paramDefineUri = `/apps/${app}/params`;
    return this.http.get<Message<ParamDefine[]>>(paramDefineUri);
  }

-  public getAppHierarchy() : Observable<Message<any>> {
-    let httpParams = new HttpParams().append("lang",'zh-CN');
+  public getAppHierarchy(): Observable<Message<any>> {
+    let httpParams = new HttpParams().append('lang', 'zh-CN');
    const options = { params: httpParams };
-    return this.http.get<Message<any>>(app_hierarchy,options);
+    return this.http.get<Message<any>>(app_hierarchy, options);
  }
-
 }
--- a/web-app/src/app/service/local-storage.service.ts
+++ b/web-app/src/app/service/local-storage.service.ts
@@ -7,8 +7,7 @@ const refreshToken = 'refresh-token';
  providedIn: 'root'
 })
 export class LocalStorageService {
-
-  constructor() { }
+  constructor() {}

  public putData(key: string, value: string) {
    localStorage.setItem(key, value);
@@ -36,11 +35,10 @@ export class LocalStorageService {
  }

  public hasAuthorizationToken() {
-    return localStorage.getItem(Authorization) === null;
+    return localStorage.getItem(Authorization) != null;
  }

  public clear() {
    localStorage.clear();
  }
-
 }
--- a/web-app/src/app/service/monitor.service.ts
+++ b/web-app/src/app/service/monitor.service.ts
@@ -1,115 +1,113 @@
+import { HttpClient, HttpParams } from '@angular/common/http';
 import { Injectable } from '@angular/core';
-import {HttpClient, HttpParams} from "@angular/common/http";
-import {Observable} from "rxjs";
-import {Message} from "../pojo/Message";
-import {Page} from "../pojo/Page";
-import {Monitor} from "../pojo/Monitor";
+import { Observable } from 'rxjs';

-const monitor_uri = "/monitor";
-const monitors_uri = "/monitors";
-const detect_monitor_uri = "/monitor/detect"
-const manage_monitors_uri = "/monitors/manage";
-const summary_uri = "/summary";
+import { Message } from '../pojo/Message';
+import { Monitor } from '../pojo/Monitor';
+import { Page } from '../pojo/Page';
+
+const monitor_uri = '/monitor';
+const monitors_uri = '/monitors';
+const detect_monitor_uri = '/monitor/detect';
+const manage_monitors_uri = '/monitors/manage';
+const summary_uri = '/summary';

@Injectable({
  providedIn: 'root'
 })
 export class MonitorService {
+  constructor(private http: HttpClient) {}

-  constructor(private http : HttpClient) { }
-
-  public newMonitor(body: any) : Observable<Message<any>> {
+  public newMonitor(body: any): Observable<Message<any>> {
    return this.http.post<Message<any>>(monitor_uri, body);
  }

-  public editMonitor(body: any) : Observable<Message<any>> {
+  public editMonitor(body: any): Observable<Message<any>> {
    return this.http.put<Message<any>>(monitor_uri, body);
  }

-  public deleteMonitor(monitorId: number) : Observable<Message<any>> {
+  public deleteMonitor(monitorId: number): Observable<Message<any>> {
    return this.http.delete<Message<any>>(`${monitor_uri}/${monitorId}`);
  }

-  public deleteMonitors(monitorIds: Set<number>) : Observable<Message<any>> {
+  public deleteMonitors(monitorIds: Set<number>): Observable<Message<any>> {
    let httpParams = new HttpParams();
    monitorIds.forEach(monitorId => {
      // 注意HttpParams是不可变对象 需要保存append后返回的对象为最新对象
      // append方法可以叠加同一key, set方法会把key之前的值覆盖只留一个key-value
      httpParams = httpParams.append('ids', monitorId);
-    })
+    });
    const options = { params: httpParams };
    return this.http.delete<Message<any>>(monitors_uri, options);
  }

-  public cancelManageMonitors(monitorIds: Set<number>) : Observable<Message<any>> {
+  public cancelManageMonitors(monitorIds: Set<number>): Observable<Message<any>> {
    let httpParams = new HttpParams();
    monitorIds.forEach(monitorId => {
      // 注意HttpParams是不可变对象 需要保存append后返回的对象为最新对象
      // append方法可以叠加同一key, set方法会把key之前的值覆盖只留一个key-value
      httpParams = httpParams.append('ids', monitorId);
-    })
+    });
    const options = { params: httpParams };
    return this.http.delete<Message<any>>(manage_monitors_uri, options);
  }

-  public enableManageMonitors(monitorIds: Set<number>) : Observable<Message<any>> {
+  public enableManageMonitors(monitorIds: Set<number>): Observable<Message<any>> {
    let httpParams = new HttpParams();
    monitorIds.forEach(monitorId => {
      httpParams = httpParams.append('ids', monitorId);
-    })
+    });
    const options = { params: httpParams };
    return this.http.get<Message<any>>(manage_monitors_uri, options);
  }

-  public detectMonitor(body: any) : Observable<Message<any>> {
+  public detectMonitor(body: any): Observable<Message<any>> {
    return this.http.post<Message<any>>(detect_monitor_uri, body);
  }

-  public getMonitor(monitorId: number) : Observable<Message<any>> {
+  public getMonitor(monitorId: number): Observable<Message<any>> {
    return this.http.get<Message<any>>(`${monitor_uri}/${monitorId}`);
  }

-  public getMonitorsByApp(app: string) : Observable<Message<Monitor[]>> {
+  public getMonitorsByApp(app: string): Observable<Message<Monitor[]>> {
    return this.http.get<Message<Monitor[]>>(`${monitors_uri}/${app}`);
  }

-  public getMonitors(app: string, pageIndex: number, pageSize: number) : Observable<Message<Page<Monitor>>> {
+  public getMonitors(app: string, pageIndex: number, pageSize: number): Observable<Message<Page<Monitor>>> {
    app = app.trim();
    pageIndex = pageIndex ? pageIndex : 0;
    pageSize = pageSize ? pageSize : 8;
    // 注意HttpParams是不可变对象 需要保存set后返回的对象为最新对象
    let httpParams = new HttpParams();
    httpParams = httpParams.appendAll({
-      'app': app,
-      'pageIndex': pageIndex,
-      'pageSize': pageSize
+      app: app,
+      pageIndex: pageIndex,
+      pageSize: pageSize
    });
    const options = { params: httpParams };
    return this.http.get<Message<Page<Monitor>>>(monitors_uri, options);
  }

-  public searchMonitors(monitorName: string, monitorHost: string,
-                        pageIndex: number, pageSize: number): Observable<Message<Page<Monitor>>> {
+  public searchMonitors(monitorName: string, monitorHost: string, pageIndex: number, pageSize: number): Observable<Message<Page<Monitor>>> {
    pageIndex = pageIndex ? pageIndex : 0;
    pageSize = pageSize ? pageSize : 8;
    // 注意HttpParams是不可变对象 需要保存set后返回的对象为最新对象
    let httpParams = new HttpParams();
    httpParams = httpParams.appendAll({
-      'name': monitorName,
-      'host': monitorHost,
-      'pageIndex': pageIndex,
-      'pageSize': pageSize
+      name: monitorName,
+      host: monitorHost,
+      pageIndex: pageIndex,
+      pageSize: pageSize
    });
    const options = { params: httpParams };
    return this.http.get<Message<Page<Monitor>>>(monitors_uri, options);
  }

-  public getMonitorMetricsData(monitorId: number, metrics: string) : Observable<Message<any>> {
+  public getMonitorMetricsData(monitorId: number, metrics: string): Observable<Message<any>> {
    return this.http.get<Message<any>>(`/monitor/${monitorId}/metrics/${metrics}`);
  }

-  public getAppsMonitorSummary() : Observable<Message<any>> {
+  public getAppsMonitorSummary(): Observable<Message<any>> {
    return this.http.get<Message<any>>(summary_uri);
  }
-
 }
--- a/web-app/src/app/service/notice-receiver.service.ts
+++ b/web-app/src/app/service/notice-receiver.service.ts
@@ -1,8 +1,9 @@
+import { HttpClient } from '@angular/common/http';
 import { Injectable } from '@angular/core';
-import {HttpClient} from "@angular/common/http";
-import {Observable} from "rxjs";
-import {Message} from "../pojo/Message";
-import {NoticeReceiver} from "../pojo/NoticeReceiver";
+import { Observable } from 'rxjs';
+
+import { Message } from '../pojo/Message';
+import { NoticeReceiver } from '../pojo/NoticeReceiver';

 const notice_receiver_uri = '/notice/receiver';
 const notice_receivers_uri = '/notice/receivers';
@@ -11,22 +12,20 @@ const notice_receivers_uri = '/notice/receivers';
  providedIn: 'root'
 })
 export class NoticeReceiverService {
+  constructor(private http: HttpClient) {}

-  constructor(private http : HttpClient) { }
-
-  public newReceiver(body: NoticeReceiver) : Observable<Message<any>> {
+  public newReceiver(body: NoticeReceiver): Observable<Message<any>> {
    return this.http.post<Message<any>>(notice_receiver_uri, body);
  }

-  public editReceiver(body: NoticeReceiver) : Observable<Message<any>> {
+  public editReceiver(body: NoticeReceiver): Observable<Message<any>> {
    return this.http.put<Message<any>>(notice_receiver_uri, body);
  }
-  public deleteReceiver(receiverId: number) : Observable<Message<any>> {
+  public deleteReceiver(receiverId: number): Observable<Message<any>> {
    return this.http.delete<Message<any>>(`${notice_receiver_uri}/${receiverId}`);
  }

-  public getReceivers() : Observable<Message<NoticeReceiver[]>> {
+  public getReceivers(): Observable<Message<NoticeReceiver[]>> {
    return this.http.get<Message<NoticeReceiver[]>>(notice_receivers_uri);
  }
-
 }
--- a/web-app/src/app/service/notice-rule.service.ts
+++ b/web-app/src/app/service/notice-rule.service.ts
@@ -1,8 +1,9 @@
+import { HttpClient } from '@angular/common/http';
 import { Injectable } from '@angular/core';
-import {Observable} from "rxjs";
-import {Message} from "../pojo/Message";
-import {HttpClient} from "@angular/common/http";
-import {NoticeRule} from "../pojo/NoticeRule";
+import { Observable } from 'rxjs';
+
+import { Message } from '../pojo/Message';
+import { NoticeRule } from '../pojo/NoticeRule';

 const notice_rule_uri = '/notice/rule';
 const notice_rules_uri = '/notice/rules';
@@ -11,22 +12,21 @@ const notice_rules_uri = '/notice/rules';
  providedIn: 'root'
 })
 export class NoticeRuleService {
+  constructor(private http: HttpClient) {}

-  constructor(private http : HttpClient) { }
-
-  public newNoticeRule(body: NoticeRule) : Observable<Message<any>> {
+  public newNoticeRule(body: NoticeRule): Observable<Message<any>> {
    return this.http.post<Message<any>>(notice_rule_uri, body);
  }

-  public editNoticeRule(body: NoticeRule) : Observable<Message<any>> {
+  public editNoticeRule(body: NoticeRule): Observable<Message<any>> {
    return this.http.put<Message<any>>(notice_rule_uri, body);
  }

-  public deleteNoticeRule(ruleId: number) : Observable<Message<any>> {
+  public deleteNoticeRule(ruleId: number): Observable<Message<any>> {
    return this.http.delete<Message<any>>(`${notice_rule_uri}/${ruleId}`);
  }

-  public getNoticeRules() : Observable<Message<NoticeRule[]>> {
+  public getNoticeRules(): Observable<Message<NoticeRule[]>> {
    return this.http.get<Message<NoticeRule[]>>(notice_rules_uri);
  }
 }