Cleanup API Endpoints

frontend/src/apis/badges.ts

@@ -1,19 +1,13 @@
-import { AxiosResponse } from "axios";
-import apis from ".";
+import BaseApi from "./base";
 
-class BadgesApi {
-  get<T>(path: string, params?: any): Promise<AxiosResponse<T>> {
-    return apis.axios.get(`/badges${path}`, { params });
+class BadgesApi extends BaseApi {
+  constructor() {
+    super("/badges");
   }
 
-  async all(): Promise<Badge> {
-    return new Promise<Badge>((resolve, reject) => {
-      this.get<Badge>("")
-        .then((result) => {
-          resolve(result.data);
-        })
-        .catch(reject);
-    });
+  async all() {
+    const response = await this.get<Badge>("");
+    return response;
   }
 }
 

frontend/src/apis/base.ts

@@ -30,11 +30,12 @@ class BaseApi {
     }
   }
 
-  protected get<T>(path: string, params?: any): Promise<AxiosResponse<T>> {
-    return apis.axios.get(this.prefix + path, { params });
+  protected async get<T = unknown>(path: string, params?: any) {
+    const response = await apis.axios.get<T>(this.prefix + path, { params });
+    return response.data;
   }
 
-  protected post<T>(
+  protected post<T = void>(
     path: string,
     formdata?: LooseObject,
     params?: any
@@ -43,7 +44,7 @@ class BaseApi {
     return apis.axios.post(this.prefix + path, form, { params });
   }
 
-  protected patch<T>(
+  protected patch<T = void>(
     path: string,
     formdata?: LooseObject,
     params?: any
@@ -52,7 +53,7 @@ class BaseApi {
     return apis.axios.patch(this.prefix + path, form, { params });
   }
 
-  protected delete<T>(
+  protected delete<T = void>(
     path: string,
     formdata?: any,
     params?: any

frontend/src/apis/episodes.ts

@@ -5,52 +5,34 @@ class EpisodeApi extends BaseApi {
     super("/episodes");
   }
 
-  async bySeriesId(seriesid: number[]): Promise<Item.Episode[]> {
-    return new Promise<Item.Episode[]>((resolve, reject) => {
-      this.get<DataWrapper<Item.Episode[]>>("", { seriesid })
-        .then((result) => {
-          resolve(result.data.data);
-        })
-        .catch((reason) => {
-          reject(reason);
-        });
+  async bySeriesId(seriesid: number[]) {
+    const response = await this.get<DataWrapper<Item.Episode[]>>("", {
+      seriesid,
     });
+    return response.data;
   }
 
-  async byEpisodeId(episodeid: number[]): Promise<Item.Episode[]> {
-    return new Promise<Item.Episode[]>((resolve, reject) => {
-      this.get<DataWrapper<Item.Episode[]>>("", { episodeid })
-        .then((result) => {
-          resolve(result.data.data);
-        })
-        .catch((reason) => {
-          reject(reason);
-        });
+  async byEpisodeId(episodeid: number[]) {
+    const response = await this.get<DataWrapper<Item.Episode[]>>("", {
+      episodeid,
     });
+    return response.data;
   }
 
   async wanted(params: Parameter.Range) {
-    return new Promise<AsyncDataWrapper<Wanted.Episode>>((resolve, reject) => {
-      this.get<AsyncDataWrapper<Wanted.Episode>>("/wanted", params)
-        .then((result) => {
-          resolve(result.data);
-        })
-        .catch((reason) => {
-          reject(reason);
-        });
-    });
+    const response = await this.get<AsyncDataWrapper<Wanted.Episode>>(
+      "/wanted",
+      params
+    );
+    return response;
   }
 
   async wantedBy(episodeid: number[]) {
-    return new Promise<AsyncDataWrapper<Wanted.Episode>>((resolve, reject) => {
-      this.get<AsyncDataWrapper<Wanted.Episode>>("/wanted", { episodeid })
-        .then((result) => {
-          resolve(result.data);
-        })
-        .catch((reason) => {
-          reject(reason);
-        });
-    });
+    const response = await this.get<AsyncDataWrapper<Wanted.Episode>>(
+      "/wanted",
+      { episodeid }
+    );
+    return response;
   }
 
   async history(params: Parameter.Range) {
@@ -58,7 +40,7 @@ class EpisodeApi extends BaseApi {
       "/history",
       params
     );
-    return response.data;
+    return response;
   }
 
   async historyBy(episodeid: number) {
@@ -66,76 +48,50 @@ class EpisodeApi extends BaseApi {
       "/history",
       { episodeid }
     );
-    return response.data;
+    return response;
   }
 
   async downloadSubtitles(
     seriesid: number,
     episodeid: number,
     form: FormType.Subtitle
-  ): Promise<void> {
-    return new Promise<void>((resolve, reject) => {
-      this.patch("/subtitles", form, { seriesid, episodeid })
-        .then(() => resolve())
-        .catch(reject);
-    });
+  ) {
+    await this.patch("/subtitles", form, { seriesid, episodeid });
   }
 
   async uploadSubtitles(
     seriesid: number,
     episodeid: number,
     form: FormType.UploadSubtitle
-  ): Promise<void> {
-    return new Promise<void>((resolve, reject) => {
-      this.post("/subtitles", form, { seriesid, episodeid })
-        .then(() => resolve())
-        .catch(reject);
-    });
+  ) {
+    await this.post("/subtitles", form, { seriesid, episodeid });
   }
 
   async deleteSubtitles(
     seriesid: number,
     episodeid: number,
     form: FormType.DeleteSubtitle
-  ): Promise<void> {
-    return new Promise<void>((resolve, reject) => {
-      this.delete("/subtitles", form, { seriesid, episodeid })
-        .then(() => resolve())
-        .catch(reject);
-    });
+  ) {
+    await this.delete("/subtitles", form, { seriesid, episodeid });
   }
 
-  async blacklist(): Promise<Blacklist.Episode[]> {
-    return new Promise<Blacklist.Episode[]>((resolve, reject) => {
-      this.get<DataWrapper<Blacklist.Episode[]>>("/blacklist")
-        .then((res) => {
-          resolve(res.data.data);
-        })
-        .catch(reject);
-    });
+  async blacklist() {
+    const response = await this.get<DataWrapper<Blacklist.Episode[]>>(
+      "/blacklist"
+    );
+    return response.data;
   }
 
   async addBlacklist(
     seriesid: number,
     episodeid: number,
     form: FormType.AddBlacklist
-  ): Promise<void> {
-    return new Promise((resolve, reject) => {
-      this.post<void>("/blacklist", form, { seriesid, episodeid })
-        .then(() => resolve())
-        .catch(reject);
-    });
+  ) {
+    await this.post("/blacklist", form, { seriesid, episodeid });
   }
 
-  async deleteBlacklist(
-    all?: boolean,
-    form?: FormType.DeleteBlacklist
-  ): Promise<void> {
-    return new Promise((resolve, reject) => {
-      this.delete<void>("/blacklist", form, { all })
-        .then(() => resolve())
-        .catch(reject);
-    });
+  async deleteBlacklist(all?: boolean, form?: FormType.DeleteBlacklist) {
+    await this.delete("/blacklist", form, { all });
   }
 }
 

frontend/src/apis/files.ts

@@ -5,23 +5,20 @@ class FilesApi extends BaseApi {
     super("/files");
   }
 
-  async browse(name: string, path?: string): Promise<FileTree[]> {
-    return new Promise((resolve, reject) => {
-      this.get<FileTree[]>(name, { path })
-        .then((res) => resolve(res.data))
-        .catch(reject);
-    });
+  async browse(name: string, path?: string) {
+    const response = await this.get<FileTree[]>(name, { path });
+    return response;
   }
 
-  async bazarr(path?: string): Promise<FileTree[]> {
+  async bazarr(path?: string) {
     return this.browse("", path);
   }
 
-  async sonarr(path?: string): Promise<FileTree[]> {
+  async sonarr(path?: string) {
     return this.browse("/sonarr", path);
   }
 
-  async radarr(path?: string): Promise<FileTree[]> {
+  async radarr(path?: string) {
     return this.browse("/radarr", path);
   }
 }

frontend/src/apis/history.ts

@@ -10,17 +10,14 @@ class HistoryApi extends BaseApi {
     action?: History.ActionOptions,
     provider?: string,
     language?: Language.CodeType
-  ): Promise<History.Stat> {
-    return new Promise((resolve, reject) => {
-      this.get<History.Stat>("/stats", {
-        timeframe,
-        action,
-        provider,
-        language,
-      })
-        .then((res) => resolve(res.data))
-        .catch(reject);
+  ) {
+    const response = await this.get<History.Stat>("/stats", {
+      timeframe,
+      action,
+      provider,
+      language,
     });
+    return response;
   }
 }
 

frontend/src/apis/movies.ts

@@ -5,92 +5,50 @@ class MovieApi extends BaseApi {
     super("/movies");
   }
 
-  async blacklist(): Promise<Blacklist.Movie[]> {
-    return new Promise<Blacklist.Movie[]>((resolve, reject) => {
-      this.get<DataWrapper<Blacklist.Movie[]>>("/blacklist")
-        .then((res) => {
-          resolve(res.data.data);
-        })
-        .catch(reject);
-    });
+  async blacklist() {
+    const response = await this.get<DataWrapper<Blacklist.Movie[]>>(
+      "/blacklist"
+    );
+    return response.data;
   }
 
-  async addBlacklist(
-    radarrid: number,
-    form: FormType.AddBlacklist
-  ): Promise<void> {
-    return new Promise((resolve, reject) => {
-      this.post<void>("/blacklist", form, { radarrid })
-        .then(() => resolve())
-        .catch(reject);
-    });
+  async addBlacklist(radarrid: number, form: FormType.AddBlacklist) {
+    await this.post("/blacklist", form, { radarrid });
   }
 
-  async deleteBlacklist(
-    all?: boolean,
-    form?: FormType.DeleteBlacklist
-  ): Promise<void> {
-    return new Promise((resolve, reject) => {
-      this.delete<void>("/blacklist", form, { all })
-        .then(() => resolve())
-        .catch(reject);
-    });
+  async deleteBlacklist(all?: boolean, form?: FormType.DeleteBlacklist) {
+    await this.delete("/blacklist", form, { all });
   }
 
   async movies(radarrid?: number[]) {
-    return new Promise<AsyncDataWrapper<Item.Movie>>((resolve, reject) => {
-      this.get<AsyncDataWrapper<Item.Movie>>("", { radarrid })
-        .then((result) => {
-          resolve(result.data);
-        })
-        .catch((reason) => {
-          reject(reason);
-        });
+    const response = await this.get<AsyncDataWrapper<Item.Movie>>("", {
+      radarrid,
     });
+    return response;
   }
 
   async moviesBy(params: Parameter.Range) {
-    return new Promise<AsyncDataWrapper<Item.Movie>>((resolve, reject) => {
-      this.get<AsyncDataWrapper<Item.Movie>>("", params)
-        .then((result) => {
-          resolve(result.data);
-        })
-        .catch((reason) => {
-          reject(reason);
-        });
-    });
+    const response = await this.get<AsyncDataWrapper<Item.Movie>>("", params);
+    return response;
   }
 
   async modify(form: FormType.ModifyItem) {
-    return new Promise<void>((resolve, reject) => {
-      this.post<void>("", { radarrid: form.id, profileid: form.profileid })
-        .then(() => resolve())
-        .catch((err) => reject(err));
-    });
+    await this.post("", { radarrid: form.id, profileid: form.profileid });
   }
 
   async wanted(params: Parameter.Range) {
-    return new Promise<AsyncDataWrapper<Wanted.Movie>>((resolve, reject) => {
-      this.get<AsyncDataWrapper<Wanted.Movie>>("/wanted", params)
-        .then((result) => {
-          resolve(result.data);
-        })
-        .catch((reason) => {
-          reject(reason);
-        });
-    });
+    const response = await this.get<AsyncDataWrapper<Wanted.Movie>>(
+      "/wanted",
+      params
+    );
+    return response;
   }
 
   async wantedBy(radarrid: number[]) {
-    return new Promise<AsyncDataWrapper<Wanted.Movie>>((resolve, reject) => {
-      this.get<AsyncDataWrapper<Wanted.Movie>>("/wanted", { radarrid })
-        .then((result) => {
-          resolve(result.data);
-        })
-        .catch((reason) => {
-          reject(reason);
-        });
+    const response = await this.get<AsyncDataWrapper<Wanted.Movie>>("/wanted", {
+      radarrid,
     });
+    return response;
   }
 
   async history(params: Parameter.Range) {
@@ -98,7 +56,7 @@ class MovieApi extends BaseApi {
       "/history",
       params
     );
-    return response.data;
+    return response;
   }
 
   async historyBy(radarrid: number) {
@@ -106,45 +64,23 @@ class MovieApi extends BaseApi {
       "/history",
       { radarrid }
     );
-    return response.data;
+    return response;
   }
 
   async action(action: FormType.MoviesAction) {
-    return new Promise<void>((resolve, reject) => {
-      this.patch("", action)
-        .then(() => resolve())
-        .catch(reject);
-    });
+    await this.patch("", action);
   }
 
-  async downloadSubtitles(id: number, form: FormType.Subtitle): Promise<void> {
-    return new Promise<void>((resolve, reject) => {
-      this.patch("/subtitles", form, { radarrid: id })
-        .then(() => resolve())
-        .catch(reject);
-    });
+  async downloadSubtitles(radarrid: number, form: FormType.Subtitle) {
+    await this.patch("/subtitles", form, { radarrid });
   }
 
-  async uploadSubtitles(
-    id: number,
-    form: FormType.UploadSubtitle
-  ): Promise<void> {
-    return new Promise<void>((resolve, reject) => {
-      this.post("/subtitles", form, { radarrid: id })
-        .then(() => resolve())
-        .catch(reject);
-    });
+  async uploadSubtitles(radarrid: number, form: FormType.UploadSubtitle) {
+    await this.post("/subtitles", form, { radarrid });
   }
 
-  async deleteSubtitles(
-    id: number,
-    form: FormType.DeleteSubtitle
-  ): Promise<void> {
-    return new Promise<void>((resolve, reject) => {
-      this.delete("/subtitles", form, { radarrid: id })
-        .then(() => resolve())
-        .catch(reject);
-    });
+  async deleteSubtitles(radarrid: number, form: FormType.DeleteSubtitle) {
+    await this.delete("/subtitles", form, { radarrid });
   }
 }
 

frontend/src/apis/providers.ts

@@ -6,47 +6,36 @@ class ProviderApi extends BaseApi {
   }
 
   async providers(history: boolean = false) {
-    return new Promise<System.Provider[]>((resolve, reject) => {
-      this.get<DataWrapper<System.Provider[]>>("", { history })
-        .then((result) => {
-          resolve(result.data.data);
-        })
-        .catch(reject);
+    const response = await this.get<DataWrapper<System.Provider[]>>("", {
+      history,
     });
+    return response.data;
   }
 
   async reset() {
-    return new Promise<void>((resolve, reject) => {
-      this.post<void>("", { action: "reset" })
-        .then(() => resolve())
-        .catch(reject);
-    });
+    await this.post("", { action: "reset" });
   }
 
   async movies(id: number) {
-    return new Promise<SearchResultType[]>((resolve, reject) => {
-      this.get<DataWrapper<SearchResultType[]>>("/movies", { radarrid: id })
-        .then((result) => resolve(result.data.data))
-        .catch(reject);
-    });
+    const response = await this.get<DataWrapper<SearchResultType[]>>(
+      "/movies",
+      { radarrid: id }
+    );
+    return response.data;
   }
 
   async downloadMovieSubtitle(radarrid: number, form: FormType.ManualDownload) {
-    return new Promise<void>((resolve, reject) => {
-      this.post<void>("/movies", form, { radarrid })
-        .then(() => resolve())
-        .catch(reject);
-    });
+    await this.post("/movies", form, { radarrid });
   }
 
-  async episodes(id: number) {
-    return new Promise<SearchResultType[]>((resolve, reject) => {
-      this.get<DataWrapper<SearchResultType[]>>("/episodes", {
-        episodeid: id,
-      })
-        .then((result) => resolve(result.data.data))
-        .catch(reject);
-    });
+  async episodes(episodeid: number) {
+    const response = await this.get<DataWrapper<SearchResultType[]>>(
+      "/episodes",
+      {
+        episodeid,
+      }
+    );
+    return response.data;
   }
 
   async downloadEpisodeSubtitle(
@@ -54,11 +43,7 @@ class ProviderApi extends BaseApi {
     episodeid: number,
     form: FormType.ManualDownload
   ) {
-    return new Promise<void>((resolve, reject) => {
-      this.post<void>("/episodes", form, { seriesid, episodeid })
-        .then(() => resolve())
-        .catch(reject);
-    });
+    await this.post("/episodes", form, { seriesid, episodeid });
   }
 }
 

frontend/src/apis/series.ts

@@ -6,43 +6,23 @@ class SeriesApi extends BaseApi {
   }
 
   async series(seriesid?: number[]) {
-    return new Promise<AsyncDataWrapper<Item.Series>>((resolve, reject) => {
-      this.get<AsyncDataWrapper<Item.Series>>("", { seriesid })
-        .then((result) => {
-          resolve(result.data);
-        })
-        .catch((reason) => {
-          reject(reason);
-        });
+    const response = await this.get<AsyncDataWrapper<Item.Series>>("", {
+      seriesid,
     });
+    return response;
   }
 
   async seriesBy(params: Parameter.Range) {
-    return new Promise<AsyncDataWrapper<Item.Series>>((resolve, reject) => {
-      this.get<AsyncDataWrapper<Item.Series>>("", params)
-        .then((result) => {
-          resolve(result.data);
-        })
-        .catch((reason) => {
-          reject(reason);
-        });
-    });
+    const response = await this.get<AsyncDataWrapper<Item.Series>>("", params);
+    return response;
   }
 
   async modify(form: FormType.ModifyItem) {
-    return new Promise<void>((resolve, reject) => {
-      this.post<void>("", { seriesid: form.id, profileid: form.profileid })
-        .then(() => resolve())
-        .catch((err) => reject(err));
-    });
+    await this.post("", { seriesid: form.id, profileid: form.profileid });
   }
 
   async action(form: FormType.SeriesAction) {
-    return new Promise<void>((resolve, reject) => {
-      this.patch("", form)
-        .then(() => resolve())
-        .catch(reject);
-    });
+    await this.patch("", form);
   }
 }
 

frontend/src/apis/subtitles.ts

@@ -6,21 +6,14 @@ class SubtitlesApi extends BaseApi {
   }
 
   async info(names: string[]) {
-    return new Promise<SubtitleInfo[]>((resolve, reject) => {
-      this.get<DataWrapper<SubtitleInfo[]>>(`/info`, {
-        filenames: names,
-      })
-        .then((result) => resolve(result.data.data))
-        .catch(reject);
+    const response = await this.get<DataWrapper<SubtitleInfo[]>>(`/info`, {
+      filenames: names,
     });
+    return response.data;
   }
 
   async modify(action: string, form: FormType.ModifySubtitle) {
-    return new Promise<void>((resolve, reject) => {
-      this.patch<void>("", form, { action })
-        .then(() => resolve())
-        .catch(reject);
-    });
+    await this.patch("", form, { action });
   }
 }
 

frontend/src/apis/system.ts

@@ -6,27 +6,15 @@ class SystemApi extends BaseApi {
   }
 
   private async performAction(action: string) {
-    return new Promise((resolve, reject) => {
-      this.post<void>("", undefined, { action })
-        .then(resolve)
-        .catch(reject);
-    });
+    await this.post("", undefined, { action });
   }
 
   async login(username: string, password: string) {
-    return new Promise((resolve, reject) => {
-      this.post<void>("/account", { username, password }, { action: "login" })
-        .then(resolve)
-        .catch(reject);
-    });
+    await this.post("/account", { username, password }, { action: "login" });
   }
 
   async logout() {
-    return new Promise((resolve, reject) => {
-      this.post<void>("/account", undefined, { action: "logout" })
-        .then(resolve)
-        .catch(reject);
-    });
+    await this.post("/account", undefined, { action: "logout" });
   }
 
   async shutdown() {
@@ -38,131 +26,66 @@ class SystemApi extends BaseApi {
   }
 
   async settings() {
-    return new Promise<Settings>((resolve, reject) => {
-      this.get<Settings>("/settings")
-        .then((result) => {
-          resolve(result.data);
-        })
-        .catch(reject);
-    });
+    const response = await this.get<Settings>("/settings");
+    return response;
   }
 
   async setSettings(data: object) {
-    return new Promise<void>((resolve, reject) => {
-      this.post<void>("/settings", data)
-        .then((res) => {
-          resolve();
-        })
-        .catch(reject);
-    });
+    await this.post("/settings", data);
   }
 
   async languages(history: boolean = false) {
-    return new Promise<Language.Server[]>((resolve, reject) => {
-      this.get<Language.Server[]>("/languages", { history })
-        .then((result) => {
-          resolve(result.data);
-        })
-        .catch((reason) => {
-          reject(reason);
-        });
+    const response = await this.get<Language.Server[]>("/languages", {
+      history,
     });
+    return response;
   }
 
   async languagesProfileList() {
-    return new Promise<Language.Profile[]>((resolve, reject) => {
-      this.get<Language.Profile[]>("/languages/profiles")
-        .then((result) => resolve(result.data))
-        .catch(reject);
-    });
+    const response = await this.get<Language.Profile[]>("/languages/profiles");
+    return response;
   }
 
   async status() {
-    return new Promise<System.Status>((resolve, reject) => {
-      this.get<DataWrapper<System.Status>>("/status")
-        .then((result) => {
-          resolve(result.data.data);
-        })
-        .catch((reason) => {
-          reject(reason);
-        });
-    });
+    const response = await this.get<DataWrapper<System.Status>>("/status");
+    return response.data;
   }
 
   async health() {
-    return new Promise<System.Health[]>((resolve, reject) => {
-      this.get<DataWrapper<System.Health[]>>("/health")
-        .then((result) => {
-          resolve(result.data.data);
-        })
-        .catch((reason) => {
-          reject(reason);
-        });
-    });
+    const response = await this.get<DataWrapper<System.Health[]>>("/health");
+    return response.data;
   }
 
   async logs() {
-    return new Promise<System.Log[]>((resolve, reject) => {
-      this.get<DataWrapper<System.Log[]>>("/logs")
-        .then((result) => resolve(result.data.data))
-        .catch((err) => reject(err));
-    });
+    const response = await this.get<DataWrapper<System.Log[]>>("/logs");
+    return response.data;
   }
 
   async releases() {
-    return new Promise<ReleaseInfo[]>((resolve, reject) => {
-      this.get<DataWrapper<ReleaseInfo[]>>("/releases")
-        .then((result) => resolve(result.data.data))
-        .catch(reject);
-    });
+    const response = await this.get<DataWrapper<ReleaseInfo[]>>("/releases");
+    return response.data;
   }
 
   async deleteLogs() {
-    return new Promise<void>((resolve, reject) => {
-      this.delete<void>("/logs")
-        .then(() => resolve())
-        .catch((err) => reject(err));
-    });
+    await this.delete("/logs");
   }
 
   async tasks() {
-    return new Promise<System.Task[]>((resolve, reject) => {
-      this.get<DataWrapper<System.Task[]>>("/tasks")
-        .then((result) => {
-          resolve(result.data.data);
-        })
-        .catch((reason) => {
-          reject(reason);
-        });
-    });
+    const response = await this.get<DataWrapper<System.Task[]>>("/tasks");
+    return response.data;
   }
 
-  async runTask(id: string) {
-    return new Promise<void>((resolve, reject) => {
-      this.post<void>("/tasks", { taskid: id })
-        .then(() => {
-          resolve();
-        })
-        .catch((reason) => {
-          reject(reason);
-        });
-    });
+  async runTask(taskid: string) {
+    await this.post("/tasks", { taskid });
   }
 
   async testNotification(url: string) {
-    return new Promise<void>((resolve, reject) => {
-      this.patch<void>("/notifications", { url })
-        .then(() => resolve())
-        .catch(reject);
-    });
+    await this.patch("/notifications", { url });
   }
 
   async search(query: string) {
-    return new Promise<ItemSearchResult[]>((resolve, reject) => {
-      this.get<ItemSearchResult[]>("/searches", { query })
-        .then((res) => resolve(res.data))
-        .catch(reject);
-    });
+    const response = await this.get<ItemSearchResult[]>("/searches", { query });
+    return response;
   }
 }
 

frontend/src/apis/utils.ts

@@ -11,11 +11,7 @@ type UrlTestResponse =
     };
 
 class RequestUtils {
-  async urlTest(
-    protocol: string,
-    url: string,
-    params?: any
-  ): Promise<UrlTestResponse> {
+  async urlTest(protocol: string, url: string, params?: any) {
     try {
       const result = await apis.axios.get<UrlTestResponse>(
         `../test/${protocol}/${url}api/system/status`,