mirror
/
bazarr
mirror of https://github.com/morpheus65535/bazarr
1
0
Fork 0
Code Issues Releases Wiki Activity

Cleanup API Endpoints

This commit is contained in:
LASER-Yi 2021-08-17 22:52:50 +08:00
parent 8348118ff2
commit d689b6e58c
11 changed files with 151 additions and 393 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
frontend/src/apis/badges.ts
View File

@ -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;
}
}

11
frontend/src/apis/base.ts
View File

@ -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

114
frontend/src/apis/episodes.ts
View File

@ -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 });
}
}

15
frontend/src/apis/files.ts
View File

@ -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);
}
}

17
frontend/src/apis/history.ts
View File

@ -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;
}
}

128
frontend/src/apis/movies.ts
View File

@ -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 });
}
}

53
frontend/src/apis/providers.ts
View File

@ -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 });
}
}

34
frontend/src/apis/series.ts
View File

@ -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);
}
}

15
frontend/src/apis/subtitles.ts
View File

@ -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 });
}
}

131
frontend/src/apis/system.ts
View File

@ -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;
}
}

6
frontend/src/apis/utils.ts
View File

@ -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`,