("add-mod-dialog-init-data", async (event) => {
117 | console.log("AddModDialog init event", event);
118 | this.setState({
119 | addModType: event.payload.addModType,
120 | groupId: event.payload.groupId,
121 | groupOptions: event.payload.groupOptions,
122 | text: event.payload.text
123 | });
124 | }).then();
125 | }
126 |
127 | render() {
128 | return (
129 |
133 | ,
141 | },
142 | {
143 | key: AddModType.MODIO,
144 | label: 'mod.io',
145 | children: ,
147 | }
148 | ]
149 | }>
150 |
151 |
163 |
170 |
176 |
181 |
182 |
183 | );
184 | }
185 | }
186 |
187 |
188 |
--------------------------------------------------------------------------------
/src/pages/SettingPage/MintCatSettings.tsx:
--------------------------------------------------------------------------------
1 | import {t} from "i18next";
2 | import React from "react";
3 | import {openPath} from "@tauri-apps/plugin-opener";
4 | import {open} from "@tauri-apps/plugin-dialog";
5 | import i18n from "@/locales/i18n.ts";
6 | import {IntegrateApi} from "@/apis/IntegrateApi.ts";
7 | import {CacheApi} from "@/apis/CacheApi.ts";
8 | import {ConfigApi} from "@/apis/ConfigApi.ts";
9 | import {Button, Card, Flex, Form, Input, message, Select} from "antd";
10 | import {FolderAddOutlined} from "@ant-design/icons";
11 | import Search from "antd/es/input/Search";
12 | import {ButtonLayout, SettingLayout} from "@/pages/SettingPage/Layout.ts";
13 | import {AppViewModel} from "@/vm/AppViewModel.ts";
14 | import {emit, listen} from "@tauri-apps/api/event";
15 |
16 |
17 | export function MintCatSettings() {
18 |
19 | const languageOptions = [
20 | {value: 'en', label: t("English")},
21 | {value: 'zh', label: t('Chinese')},
22 | ];
23 |
24 | const themeOptions = [
25 | {value: 'Light', label: t('Light')},
26 | {value: 'Dark', label: t('Dark')},
27 | {value: 'Pink', label: t('Pink')},
28 | ];
29 |
30 | const [language, setLanguage] = React.useState("en");
31 | const [theme, setTheme] = React.useState("Light");
32 | const [configDirectory, setConfigDirectory] = React.useState("");
33 | const [cacheDirectory, setCacheDirectory] = React.useState("");
34 |
35 | const onOpenConfigDirClick = async () => {
36 | await openPath(await ConfigApi.getConfigPath());
37 | }
38 |
39 | const onOpenCacheDirClick = async () => {
40 | await openPath(cacheDirectory);
41 | }
42 |
43 | const onSelectCacheDirClick = async () => {
44 | const result = await open({
45 | directory: true
46 | });
47 | if (result) {
48 | setCacheDirectory(result);
49 | const vm = await AppViewModel.getInstance();
50 | vm.setting.cachePath = result;
51 | await vm.saveSettings();
52 | }
53 | }
54 |
55 | const onLanguageChange = async (value: string) => {
56 | setLanguage(value);
57 | await i18n.changeLanguage(value);
58 | const vm = await AppViewModel.getInstance();
59 | vm.setting.language = value;
60 | await vm.saveSettings();
61 | window.location.reload();
62 | }
63 |
64 | const onThemeChange = async (value: string) => {
65 | setTheme(value);
66 | const vm = await AppViewModel.getInstance();
67 | vm.setting.guiTheme = value;
68 | localStorage.setItem('theme', value);
69 | await emit("theme-change", value);
70 | await vm.saveSettings();
71 | }
72 |
73 | const onDevToolsClick = async () => {
74 | await IntegrateApi.openDevTools();
75 | }
76 |
77 | const onClearCacheClick = async () => {
78 | if (await CacheApi.cleanOldCacheFiles()) {
79 | message.success(t("Clean Cache Success"));
80 | }
81 | }
82 |
83 | const onImportConfigClick = async () => {
84 | await emit("config-manage-dialog-open");
85 | }
86 |
87 | listen("theme-change", (event) => {
88 | setTheme(event.payload);
89 | }).then();
90 |
91 | React.useEffect(() => {
92 | const fetchData = async () => {
93 | const vm = await AppViewModel.getInstance();
94 | setLanguage(vm.setting.language);
95 | setTheme(vm.setting.guiTheme);
96 | setConfigDirectory(vm.setting.configPath);
97 | setCacheDirectory(vm.setting.cachePath);
98 | }
99 | fetchData().then();
100 | }, []);
101 |
102 | return (
103 |
106 |
169 |
170 | )
171 | }
172 |
--------------------------------------------------------------------------------
/src/apis/ConfigApi.ts:
--------------------------------------------------------------------------------
1 | import {path} from "@tauri-apps/api";
2 | import {appConfigDir, configDir} from "@tauri-apps/api/path";
3 | import {BaseDirectory, exists, readTextFile, writeTextFile, mkdir, remove, rename} from '@tauri-apps/plugin-fs';
4 | import {ProfileTree} from "../vm/config/ProfileList.ts";
5 | import {TimeUtils} from "../utils/TimeUtils.ts";
6 | import {ConfigDataType, IConfig} from "@/apis/ConfigApi/DataType.ts";
7 | import {ConfigV4} from "@/apis/ConfigApi/ConfigV4.ts";
8 | import {ConfigV2} from "@/apis/ConfigApi/ConfigV2.ts";
9 | import {ConfigV3} from "@/apis/ConfigApi/ConfigV3.ts";
10 |
11 |
12 | export class ConfigApi {
13 |
14 | public static async getConfigPath() {
15 | return await appConfigDir();
16 | }
17 |
18 | public static async readDataToFile(fileName: string): Promise {
19 | try {
20 | return await readTextFile(fileName, {
21 | baseDir: BaseDirectory.AppConfig,
22 | });
23 | } catch (error) {
24 | console.error(`Failed to read file ${fileName}: ${error}`);
25 | return undefined;
26 | }
27 | }
28 |
29 | public static async saveDataToFile(fileName: string, data: string): Promise {
30 | try {
31 | const configDir = await ConfigApi.getConfigPath();
32 | if (!await exists(configDir)) {
33 | await mkdir(configDir)
34 | }
35 | await writeTextFile(fileName, data, {
36 | baseDir: BaseDirectory.AppConfig,
37 | });
38 | return true;
39 | } catch (error) {
40 | console.error(`Failed to write file ${fileName}: ${error}`);
41 | }
42 | return false;
43 | }
44 |
45 | public static async loadModListData(): Promise {
46 | const fileName = "mods.json";
47 | return await ConfigApi.readDataToFile(fileName);
48 | }
49 |
50 | public static async saveModListData(data: string): Promise {
51 | const fileName = "mods.json";
52 | return await ConfigApi.saveDataToFile(fileName, data);
53 | }
54 |
55 | public static async loadProfileData(): Promise {
56 | const fileName = "profile.json";
57 | return await ConfigApi.readDataToFile(fileName);
58 | }
59 |
60 | public static async saveProfileData(data: string): Promise {
61 | const fileName = "profile.json";
62 | return await ConfigApi.saveDataToFile(fileName, data);
63 | }
64 |
65 | public static async loadProfileDetails(name: string): Promise {
66 | const fileName = `profile_${name}.json`;
67 | return await ConfigApi.readDataToFile(fileName);
68 | }
69 |
70 | public static async deleteProfileDetails(name: string) {
71 | const fileName = `profile_${name}.json`;
72 | const profilePath = await path.join(await ConfigApi.getConfigPath(), fileName);
73 | if (await exists(profilePath)) {
74 | await remove(profilePath);
75 | }
76 | }
77 |
78 | public static async renameProfileDetails(oldName: string, newName: string) {
79 | const oldFileName = `profile_${oldName}.json`;
80 | const newFileName = `profile_${newName}.json`;
81 | const oldProfilePath = await path.join(await ConfigApi.getConfigPath(), oldFileName);
82 | const newProfilePath = await path.join(await ConfigApi.getConfigPath(), newFileName);
83 | if (await exists(oldProfilePath)) {
84 | await rename(oldProfilePath, newProfilePath);
85 | }
86 | }
87 |
88 | public static async saveProfileDetails(name: string, tree: ProfileTree, noEdit: boolean = false): Promise {
89 | const fileName = `profile_${name}.json`;
90 | if (!noEdit)
91 | tree.editTime = TimeUtils.getCurrentTime();
92 | return await ConfigApi.saveDataToFile(fileName, tree.toJson());
93 | }
94 |
95 | public static async saveUserData(data: string): Promise {
96 | const fileName = "user.json";
97 | return await ConfigApi.saveDataToFile(fileName, data);
98 | }
99 |
100 | public static async loadSettings(): Promise {
101 | const fileName = "settings.json";
102 | return await ConfigApi.readDataToFile(fileName);
103 | }
104 |
105 | public static async saveSettings(data: string): Promise {
106 | const fileName = "settings.json";
107 | return await ConfigApi.saveDataToFile(fileName, data);
108 | }
109 |
110 | private static async getModListDataV1Path(): Promise {
111 | let oldFilePath = await path.join(await configDir(), "drg-mod-integration", "config", "mod_data.json"); // 0.2
112 | if (!await exists(oldFilePath)) {
113 | oldFilePath = await path.join(await configDir(), "mint", "config", "mod_data.json"); // 0.3
114 | }
115 | return oldFilePath;
116 | }
117 |
118 | private static async getSettingV1Path(): Promise {
119 | let oldFilePath = await path.join(await configDir(), "drg-mod-integration", "config", "config.json"); // 0.2
120 | if (!await exists(oldFilePath)) {
121 | oldFilePath = await path.join(await configDir(), "mint", "config", "config.json"); // 0.3
122 | }
123 | return oldFilePath;
124 | }
125 |
126 | public static async readTextFile(path: string): Promise {
127 | try {
128 | return await readTextFile(path);
129 | } catch (error) {
130 | console.error(error);
131 | }
132 | }
133 |
134 | public static async loadSettingV1(): Promise {
135 | try {
136 | return await readTextFile(await ConfigApi.getSettingV1Path());
137 | } catch (error) {
138 | console.error(error);
139 | }
140 | }
141 |
142 | public static async getExistingConfigList() {
143 | const configs = [
144 | new ConfigV2(),
145 | new ConfigV3(),
146 | new ConfigV4(),
147 | ];
148 | const configDataList: ConfigDataType[] = [];
149 | for (const config of configs) {
150 | const configData = await config.checkConfig();
151 | if (configData) {
152 | configDataList.push(configData);
153 | }
154 | }
155 | return configDataList;
156 | }
157 |
158 | public static async importConfig(configData: ConfigDataType) {
159 | let config: IConfig;
160 | switch (configData.version) {
161 | case "0.2.0":
162 | config = new ConfigV2();
163 | break;
164 | case "0.3.0":
165 | config = new ConfigV3();
166 | break;
167 | case "0.4.0":
168 | default:
169 | config = new ConfigV4();
170 | break;
171 | }
172 | await config.loadConfig();
173 | }
174 |
175 | public static async loadModioUserData(): Promise {
176 | const fileName = "user.json";
177 | const oldFilePath = "C:\\Users\\-\\AppData\\Local\\mod.io\\2475\\S-1-5-21-1688096665-3863216114-603340213-1000\\user.json";
178 |
179 | return await ConfigApi.readDataToFile(fileName);
180 | }
181 |
182 | }
183 |
184 |
--------------------------------------------------------------------------------
/src/dialogs/ConfigManageDialog.tsx:
--------------------------------------------------------------------------------
1 | import React, {useState, useImperativeHandle, forwardRef, useEffect} from 'react';
2 | import {Button, Checkbox, Flex, List, message, Modal, Space, Tag} from 'antd';
3 | import {t} from "i18next";
4 | import {remove} from "@tauri-apps/plugin-fs";
5 | import {CloseOutlined, FileOutlined, FolderOpenOutlined} from "@ant-design/icons";
6 | import {ConfigDataType} from "@/apis/ConfigApi/DataType.ts";
7 | import {ConfigApi} from "@/apis/ConfigApi.ts";
8 | import {openPath} from "@tauri-apps/plugin-opener";
9 | import {MessageBox} from "@/components/MessageBox.ts";
10 | import {listen} from "@tauri-apps/api/event";
11 |
12 |
13 | interface ListDataType extends ConfigDataType {
14 | checked?: boolean;
15 | }
16 |
17 |
18 | export const ConfigManageDialog = forwardRef((_props, ref) => {
19 | const [isModalOpen, setIsModalOpen] = useState(false);
20 | const [dataSource, setDataSource] = useState([]);
21 |
22 | useImperativeHandle(ref, () => ({
23 | show: () => setIsModalOpen(true),
24 | }));
25 |
26 | const handleOk = async () => {
27 | const result = dataSource.find((data) => {
28 | if (data.checked) {
29 | return data;
30 | }
31 | });
32 | if (result) {
33 | if (result.version === "0.4.0") {
34 | setIsModalOpen(false);
35 | return;
36 | }
37 | await ConfigApi.importConfig(result);
38 | window.location.reload();
39 | } else {
40 | message.error(t("Please select a config"));
41 | }
42 | };
43 |
44 | const handleCancel = () => {
45 | setIsModalOpen(false);
46 | };
47 |
48 | const onOpenClick = async (path: string) => {
49 | await openPath(path);
50 | };
51 |
52 | const onDeleteClick = async (path: string) => {
53 | const confirmed = await MessageBox.confirm({
54 | title: t("Delete Config"),
55 | content: t("Are you sure to delete the configuration folder?"),
56 | });
57 | if (confirmed) {
58 | await remove(path, {recursive: true});
59 | getData().then();
60 | }
61 | };
62 |
63 | const onCheckedChange = (checked: boolean, item: ListDataType) => {
64 | const newDataSource = dataSource.map((data) => {
65 | if (data.path === item.path) {
66 | data.checked = checked;
67 | } else {
68 | data.checked = false;
69 | }
70 | return data;
71 | })
72 | setDataSource(newDataSource);
73 | }
74 |
75 | const getData = async () => {
76 | const configs = await ConfigApi.getExistingConfigList();
77 | setDataSource(configs);
78 | }
79 |
80 |
81 | listen("config-manage-dialog-open", async () => {
82 | setIsModalOpen(true);
83 | }).then();
84 |
85 | useEffect(() => {
86 | getData().then();
87 | }, []);
88 |
89 | return (
90 |
99 |
105 |
106 | {t("Detected the following configurations. Please select the configurations to import")}
107 |
108 | (
112 |
113 |
117 |
118 |
121 | onCheckedChange(event.target.checked, item)
122 | }/>
123 |
124 |
125 | {`${t("Saved at")}: ${item.saveTime}`}
126 |
127 |
134 | {item.version}
135 |
136 | {
137 | item.version === "0.4.0" &&
138 |
145 | {t("Loaded")}
146 |
147 | }
148 |
149 |
150 |
164 |
165 |
166 | )}
167 | />
168 |
169 |
170 | );
171 | });
172 |
173 |
--------------------------------------------------------------------------------
/src/apis/ModUpdateApi.ts:
--------------------------------------------------------------------------------
1 | import {t} from "i18next";
2 | import {exists, stat} from "@tauri-apps/plugin-fs";
3 | import {ModioApi} from "./ModioApi.ts";
4 | import {ConfigApi} from "./ConfigApi.ts";
5 | import {HomeViewModel} from "../vm/HomeViewModel.ts";
6 | import {MOD_INVALID_ID, ModListItem, ModSourceType} from "../vm/config/ModList.ts";
7 | import {emit} from "@tauri-apps/api/event";
8 | import {TimeUtils} from "../utils/TimeUtils.ts";
9 |
10 | export class ModUpdateApi {
11 |
12 | private static loading = false;
13 |
14 | public static async updateMod(mod: ModListItem) {
15 | const viewModel = await HomeViewModel.getInstance();
16 | const resp = await ModioApi.getModInfoByLink(mod.url);
17 | if (!resp) {
18 | mod.onlineAvailable = false;
19 | viewModel.ModList.update(mod, mod);
20 | await emit("mod-treeview-update" + mod.id, mod);
21 | return;
22 | }
23 |
24 | let newItem = new ModListItem(resp);
25 | newItem = viewModel.ModList.update(mod, newItem);
26 | await viewModel.updateUI();
27 | await emit("status-bar-log", `${t("Update Mod")} [${newItem.displayName}]`);
28 |
29 | await this.updateModFile(newItem);
30 |
31 | await ConfigApi.saveModListData(viewModel.ModList.toJson());
32 | await emit("status-bar-log", t("Update Finish"));
33 | }
34 |
35 | public static async updateModFile(mod: ModListItem) {
36 | const viewModel = await HomeViewModel.getInstance();
37 |
38 | const newItem = await ModioApi.downloadModFile(mod, async (loaded: number, total: number) => {
39 | await emit("status-bar-log", `${t("Downloading")} [${mod.displayName}] (${loaded} / ${total})`);
40 | mod.downloadProgress = (loaded / total) * 100;
41 | await emit("mod-treeview-update" + mod.id, mod);
42 | });
43 | viewModel.ModList.update(mod, newItem);
44 |
45 | await ConfigApi.saveModListData(viewModel.ModList.toJson());
46 | await emit("status-bar-log", t("Update Finish"));
47 | }
48 |
49 | public static async checkOnlineModUpdate(modItem: ModListItem) {
50 | if (modItem.sourceType === ModSourceType.Modio &&
51 | //modItem.onlineAvailable === true &&
52 | modItem.enabled === true
53 | ) {
54 | if (!await exists(modItem.cachePath) ||
55 | modItem.onlineUpdateDate > modItem.lastUpdateDate ||
56 | modItem.downloadProgress != 100
57 | ) {
58 | await ModUpdateApi.updateMod(modItem);
59 | }
60 | }
61 | }
62 |
63 | public static async checkLocalModCache(modItem: ModListItem) {
64 | if (modItem.sourceType === ModSourceType.Local) {
65 | if (!await exists(modItem.cachePath)) {
66 | modItem.localNoFound = true;
67 | return false;
68 | } else {
69 | modItem.localNoFound = false;
70 | }
71 |
72 | const viewModel = await HomeViewModel.getInstance();
73 | viewModel.ModList.update(modItem, modItem);
74 | await ConfigApi.saveModListData(viewModel.ModList.toJson());
75 | await emit("mod-treeview-update" + modItem.id, modItem);
76 | }
77 | return true;
78 | }
79 |
80 | public static async checkLocalModModify(modItem: ModListItem) {
81 | if (modItem.sourceType === ModSourceType.Local && modItem.enabled === true) {
82 | if (await exists(modItem.cachePath)) {
83 | const fileInfo = await stat(modItem.cachePath);
84 | const mtime = TimeUtils.getTimeSecond(fileInfo.mtime.getTime());
85 | if (mtime === modItem.lastUpdateDate) {
86 | return false;
87 | } else {
88 | modItem.lastUpdateDate = mtime;
89 | const viewModel = await HomeViewModel.getInstance();
90 | viewModel.ModList.update(modItem, modItem, true);
91 | await ConfigApi.saveModListData(viewModel.ModList.toJson());
92 | return true;
93 | }
94 | }
95 | }
96 | return false;
97 | }
98 |
99 | public static async checkModList() {
100 | await emit("home-page-loading", true);
101 | ModUpdateApi.loading = true;
102 |
103 | const viewModel = await HomeViewModel.getInstance();
104 | const subModList = viewModel.ActiveProfile.getModList(viewModel.ModList);
105 | for (const item of subModList.Mods) {
106 | if (item.enabled) {
107 | await this.checkOnlineModUpdate(item);
108 | await this.checkLocalModCache(item);
109 | }
110 | }
111 | await ConfigApi.saveModListData(viewModel.ModList.toJson());
112 |
113 | ModUpdateApi.loading = false;
114 | await emit("home-page-loading", false);
115 | return true;
116 | }
117 |
118 | public static async checkModUpdate() {
119 | await emit("status-bar-log", t("Mod Update Check Start"));
120 | if (ModUpdateApi.loading) {
121 | return;
122 | }
123 |
124 | const viewModel = await HomeViewModel.getInstance();
125 | let updateTime = 0;
126 | if (!viewModel.ActiveProfile.lastUpdate) {
127 | updateTime = TimeUtils.getCurrentTime() - 60 * 60 * 24 * 30; // 最近 1 一个月的更新
128 | } else {
129 | updateTime = viewModel.ActiveProfile.lastUpdate;
130 | }
131 |
132 | const subModList = viewModel.ActiveProfile.getModList(viewModel.ModList);
133 | const modIdList = [];
134 | for (const item of subModList.Mods) {
135 | if (item.sourceType === ModSourceType.Modio || item.modId !== MOD_INVALID_ID) {
136 | modIdList.push(item.modId);
137 | }
138 | }
139 |
140 | const events = await ModioApi.getEvents(updateTime, modIdList.join(","));
141 | for (const event of events) {
142 | switch (event.event_type) {
143 | case "MODFILE_CHANGED": {
144 | let modItem = viewModel.ModList.getByModId(event.mod_id);
145 | if (modItem) {
146 | modItem.onlineUpdateDate = event.date_added;
147 | if (!modItem.lastUpdateDate) {
148 | modItem.lastUpdateDate = 0;
149 | }
150 | }
151 | }
152 | break;
153 | case "MOD_UNAVAILABLE":
154 | case "MOD_DELETED": {
155 | let modItem = viewModel.ModList.getByModId(event.mod_id);
156 | if (modItem) {
157 | modItem.onlineAvailable = false;
158 | modItem.lastUpdateDate = event.date_added;
159 | modItem.onlineUpdateDate = event.date_added;
160 | }
161 | }
162 | break;
163 | }
164 | }
165 |
166 | viewModel.ActiveProfile.lastUpdate = TimeUtils.getCurrentTime();
167 | await ConfigApi.saveProfileDetails(viewModel.ActiveProfileName, viewModel.ActiveProfile);
168 | await ConfigApi.saveModListData(viewModel.ModList.toJson());
169 | await viewModel.updateUI();
170 |
171 | await emit("status-bar-log", t("Mod Update Check Finish"));
172 | }
173 |
174 |
175 | }
--------------------------------------------------------------------------------
/src/components/TitleBar.tsx:
--------------------------------------------------------------------------------
1 | import React from "react";
2 | import {Avatar, Badge, Button, Flex, Image, List, Popover} from "antd";
3 | import {t} from "i18next";
4 | import {
5 | BellOutlined,
6 | PlayCircleOutlined,
7 | QuestionCircleOutlined,
8 | SkinOutlined,
9 | UserOutlined
10 | } from '@ant-design/icons';
11 | import {open} from "@tauri-apps/plugin-shell";
12 | import packageJson from '../../package.json';
13 | import {IntegrateApi} from "../apis/IntegrateApi.ts";
14 | import {ModioApi} from "../apis/ModioApi.ts";
15 | import {MessageBox} from "./MessageBox.ts";
16 | import {CacheApi} from "../apis/CacheApi.ts";
17 | import {AppViewModel} from "../vm/AppViewModel.ts";
18 | import {emit, once} from "@tauri-apps/api/event";
19 |
20 |
21 | interface TitleBarState {
22 | profileUrl?: string,
23 | username?: string,
24 | modioId: number
25 | }
26 |
27 | class TitleBar extends React.Component {
28 |
29 | public constructor(props: any) {
30 | super(props);
31 |
32 | this.state = {
33 | username: "",
34 | modioId: 0,
35 | }
36 |
37 | this.onLaunchGameClick = this.onLaunchGameClick.bind(this);
38 | }
39 |
40 | private async onOpenWikiClick() {
41 | await open("https://mintcat.v1st.net");
42 | }
43 |
44 | private async onLaunchGameClick() {
45 | if (await IntegrateApi.installMods())
46 | await IntegrateApi.launchGame();
47 | }
48 |
49 | private async loadAvatar() {
50 | const vm = await AppViewModel.getInstance();
51 | if (!await vm.checkOauth()) {
52 | return;
53 | }
54 |
55 | const userInfo = await ModioApi.getUserInfo();
56 | if (userInfo) {
57 | const url = await CacheApi.cacheImage(userInfo.avatar.thumb_50x50);
58 | vm.setting.modioUid = userInfo.id;
59 | this.setState({
60 | profileUrl: url,
61 | username: userInfo.username,
62 | modioId: userInfo.id
63 | })
64 | }
65 | }
66 |
67 | private async onThemeClick(value: string) {
68 | const vm = await AppViewModel.getInstance();
69 | vm.setting.guiTheme = value;
70 | localStorage.setItem('theme', value);
71 | await vm.saveSettings();
72 | await emit("theme-change", value);
73 | }
74 |
75 | componentDidMount(): void {
76 | once("title-bar-load-avatar", () => {
77 | this.loadAvatar().then();
78 | }).then();
79 | }
80 |
81 | render() {
82 | return (
83 |
84 |
85 |
90 |
91 |
92 | MINT
97 | CAT
102 |
103 |
104 |
105 | v{packageJson.version}
106 |
107 |
108 |
109 |
120 |
121 |
124 |
128 |
129 |
130 | (
141 |
142 |
150 |
151 | )}
152 | >
153 |
154 | }
155 | >
156 |
160 |
161 |
162 |
167 | }
169 | src={
170 | this.state.profileUrl &&
171 | 
172 | }
173 | onClick={async () => {
174 | await MessageBox.confirm({
175 | title: t("User Info"),
176 | content: <>
177 | ID: {this.state.modioId}
178 | {t("Username")}: {this.state.username}
179 |
180 | })
181 | }}
182 | />
183 |
184 |
185 | );
186 | }
187 | }
188 |
189 | export default TitleBar;
--------------------------------------------------------------------------------
/src/apis/ModioApi.ts:
--------------------------------------------------------------------------------
1 | import {message} from "antd";
2 | import {t} from "i18next";
3 | import {ModFile, ModInfo} from "../vm/modio/ModInfo.ts";
4 | import {ModListItem} from "../vm/config/ModList.ts";
5 | import {AppViewModel} from "../vm/AppViewModel.ts";
6 | import {UserInfo} from "../vm/modio/UserInfo.ts";
7 | import {EventInfo} from "../vm/modio/EventInfo.ts";
8 | import {CacheApi} from "./CacheApi.ts";
9 | import {DownloadApi} from "./DownloadApi.ts";
10 | import {TimeUtils} from "../utils/TimeUtils.ts";
11 | import {retry} from "ts-retry";
12 | import {NetworkApi} from "@/apis/NetworkApi.ts";
13 |
14 | //const MODIO_API_URL = "https://api.mod.io/v1";
15 | const MODIO_GAME_ID = 2475;
16 | const MODIO_UID = "13595141";
17 |
18 | export class ModioApi {
19 |
20 | static IS_PROXY = false;
21 |
22 | private static async getHost() {
23 | const vm = await AppViewModel.getInstance();
24 | const modioUid = vm.setting?.modioUid ?? MODIO_UID;
25 | return `https://u-${modioUid}.modapi.io/v1`;
26 | }
27 |
28 | private static async getHeaders() {
29 | const vm = await AppViewModel.getInstance();
30 | return {
31 | Authorization: `Bearer ${vm.setting?.modioOAuth}`,
32 | }
33 | }
34 |
35 | private static async getRequest(path: string) {
36 | let host = await ModioApi.getHost();
37 | let url = host + path;
38 |
39 | let resp: Response = await NetworkApi.get(url, await ModioApi.getHeaders());
40 |
41 | switch (resp.status) {
42 | case 200:
43 | return await resp.json();
44 | case 401:
45 | throw Error(`${t("mod.io Unauthorized")}`);
46 | case 404:
47 | throw Error(`${t("mod.io Not Found")}`);
48 | case 422:
49 | throw Error(`${t("mod.io Request Parameter Error")}: ${url}`);
50 | case 429:
51 | throw Error(`${t("mod.io Too Many Requests")}`);
52 | default:
53 | throw Error(`${t("mod.io Error")}: ${resp.status}`);
54 | }
55 | }
56 |
57 | public static parseModLinks(link: string) {
58 | let regex = new RegExp('^https://mod\.io/g/drg/m/([^/#]+)');
59 | let match = link.match(regex);
60 | if (match !== null) {
61 | return match[1];
62 | }
63 | }
64 |
65 | public static async getModInfoByLink(url: string): Promise {
66 | const nameId = ModioApi.parseModLinks(url);
67 | if (nameId === undefined) {
68 | message.error(`${t("Invalid Mod Link")}: ${url}`);
69 | return;
70 | }
71 | const modData = await ModioApi.getModInfoByName(nameId);
72 | if (modData === undefined) {
73 | message.error(`${t("Mod Not Existed")}: ${url}`);
74 | return;
75 | }
76 | return modData;
77 | }
78 |
79 | public static async getUserInfo() {
80 | try {
81 | const path = "/me";
82 | const data = await ModioApi.getRequest(path);
83 | return data as UserInfo;
84 | } catch (e) {
85 | message.error(`${t("Fetch User Info Error")}: ${e}`);
86 | }
87 | }
88 |
89 | public static async ping() {
90 | try {
91 | const path = "/ping";
92 | const data = await ModioApi.getRequest(path);
93 | if (data.code === 200)
94 | return true;
95 | } catch (_) {
96 | }
97 | return false;
98 | }
99 |
100 | public static async getModInfoByName(nameId: string): Promise {
101 | try {
102 | const path = `/games/${MODIO_GAME_ID}/mods?name_id=${nameId}`;
103 | const data = await ModioApi.getRequest(path);
104 | if (data["data"].length === 0)
105 | return;
106 | else {
107 | return data["data"][0];
108 | }
109 | } catch (e) {
110 | message.error(`${t("Fetch Mod Info Error")}: ${e}`);
111 | throw e;
112 | }
113 | }
114 |
115 | public static async getModInfoById(modId: string): Promise {
116 | try {
117 | const path = `/games/${MODIO_GAME_ID}/mods/${modId}`;
118 | const data = await ModioApi.getRequest(path);
119 | return data as ModInfo;
120 | } catch (e) {
121 | message.error(`${t("Fetch Mod Info Error")}: ${e}`);
122 | }
123 | }
124 |
125 | public static async getModList(pageNo: number = 0, pageSize: number = 20, name: string = undefined): Promise {
126 | try {
127 | let path: string;
128 | if (name) {
129 | path = `/games/${MODIO_GAME_ID}/mods?name-lk=*${name}*`;
130 | } else {
131 | path = `/games/${MODIO_GAME_ID}/mods?_limit=${pageSize}&_offset=${pageSize * pageNo}`;
132 | }
133 | const data = await ModioApi.getRequest(path);
134 | return data.data as ModInfo[];
135 | } catch (e) {
136 | message.error(`${t("Fetch Mod Info Error")}: ${e}`);
137 | return [];
138 | }
139 | }
140 |
141 | public static async getDependencies(modId: number) {
142 | try {
143 | const path = `/games/${MODIO_GAME_ID}/mods/${modId}/dependencies`;
144 | const data = await ModioApi.getRequest(path);
145 | return data.data as ModInfo[];
146 | } catch (e) {
147 | message.error(`${t("Fetch Dependence Error")}: ${e}`);
148 | }
149 | }
150 |
151 | public static async getEvents(dateAdded: number, modIds: string) {
152 | try {
153 | // 如果时间小 10 分钟，不请求
154 | if (TimeUtils.getCurrentTime() - dateAdded < 10 * 60) {
155 | return [];
156 | }
157 |
158 | const event_type = ["MODFILE_CHANGED", "MOD_UNAVAILABLE", "MOD_DELETED"];
159 | const path = `/games/${MODIO_GAME_ID}/mods/events?mod_id-in=${modIds}&date_added-min=${dateAdded}&event_type-in=${event_type.join(",")}`;
160 | const data = await ModioApi.getRequest(path);
161 | return data.data as EventInfo[];
162 | } catch (e) {
163 | message.error(`${t("Fetch Events Error")}: ${e}`);
164 | }
165 | }
166 |
167 | public static async getModFiles(modId: number) {
168 | try {
169 | const path = `/games/${MODIO_GAME_ID}/mods/${modId}/files`;
170 | const data = await ModioApi.getRequest(path);
171 | return data.data as ModFile[];
172 | } catch (e) {
173 | message.error(`${t("Fetch Events Error")}: ${e}`);
174 | }
175 | }
176 |
177 | public static async downloadModFile(modInfo: ModListItem,
178 | onProgress?: (loaded: number, total: number) => void) {
179 |
180 | if (await CacheApi.checkCacheFile(modInfo.nameId, modInfo.usedVersion, modInfo.fileSize)) {
181 | modInfo.cachePath = await CacheApi.getModCachePath(modInfo.nameId, modInfo.usedVersion);
182 | onProgress(modInfo.fileSize, modInfo.fileSize);
183 | return modInfo;
184 | }
185 |
186 | if (modInfo.fileSize < 100 * 1024 * 1024) {
187 | const data = await DownloadApi.downloadFile(modInfo.downloadUrl, onProgress);
188 | modInfo.cachePath = await CacheApi.saveCacheFile(modInfo.nameId, modInfo.usedVersion, data);
189 | } else {
190 | modInfo.cachePath = await CacheApi.getModCachePath(modInfo.nameId, modInfo.usedVersion);
191 | await DownloadApi.downloadLargeFile(modInfo.downloadUrl, modInfo.cachePath, onProgress);
192 | }
193 |
194 | modInfo.downloadProgress = 100;
195 | onProgress(modInfo.fileSize, modInfo.fileSize);
196 | return modInfo;
197 | }
198 |
199 | }
200 |
--------------------------------------------------------------------------------