feat: 任务和社区页面

utils/request.js

@@ -0,0 +1,208 @@
+class WxRequest {
+    constructor(options = {}) {
+        this.baseUrl = options.baseUrl || '';
+        this.header = options.header || {};
+        this.interceptors = {
+            request: (config) => config,
+            response: (response) => response
+        };
+    }
+
+    /**
+     * Set request interceptor
+     * @param {Function} callback 
+     */
+    setRequestInterceptor(callback) {
+        this.interceptors.request = callback;
+    }
+
+    /**
+     * Set response interceptor
+     * @param {Function} callback 
+     */
+    setResponseInterceptor(callback) {
+        this.interceptors.response = callback;
+    }
+
+    /**
+     * Core request method
+     * @param {Object} options 
+     */
+    request(options = {}) {
+        // Merge headers
+        const header = { ...this.header, ...options.header };
+
+        // Prepare config
+        let config = {
+            url: (options.url.startsWith('http') ? options.url : this.baseUrl + options.url),
+            method: options.method || 'GET',
+            data: options.data || {},
+            header: header,
+            timeout: options.timeout || 60000
+        };
+
+        // Apply request interceptor
+        config = this.interceptors.request(config);
+
+        return new Promise((resolve, reject) => {
+            wx.request({
+                ...config,
+                success: (res) => {
+                    // Apply response interceptor (pass the whole wx response)
+                    const processedResponse = this.interceptors.response(res);
+                    const { statusCode, data } = processedResponse;
+
+                    // 1. Check HTTP Status Code
+                    if (statusCode >= 200 && statusCode < 300) {
+                        // 2. Check Business Logic Code (Assuming 200 is success based on common Go patterns, 
+                        // matching the user's struct: Code, Data, Msg)
+                        // If data.code exists, we check it. If not (maybe not JSON), we pass through or handle.
+                        const businessCode = data.code;
+
+                        // Strict check: if code is 200, success.
+                        if (businessCode === 200) {
+                            resolve(data.data); // Return the inner Data object
+                        } else {
+                            // Business logic error
+                            this.handleError({
+                                errMsg: data.msg || 'Error',
+                                code: businessCode
+                            });
+                            reject(data);
+                        }
+                    } else {
+                        // Handle non-200 HTTP errors
+                        this.handleError({ errMsg: `HTTP Error: ${statusCode}`, ...res });
+                        reject(res);
+                    }
+                },
+                fail: (err) => {
+                    this.handleError({ errMsg: 'Network Error', ...err });
+                    reject(err);
+                }
+            });
+        });
+    }
+
+    /**
+     * Handle global errors (Toast)
+     * @param {Object} error 
+     */
+    handleError(error) {
+        const message = error.errMsg || error.msg || '请求失败，请稍后重试';
+        wx.showToast({
+            title: message,
+            icon: 'none',
+            duration: 3000
+        });
+        console.error('API Error:', error);
+    }
+
+    /**
+     * Upload file
+     * @param {string} filePath Local file path
+     * @param {string} name Form field name (default: file)
+     * @param {Object} formData Additional form data
+     */
+    upload(filePath, name = 'file', formData = {}) {
+        // Prepare config
+        let config = {
+            url: this.baseUrl + '/oss/upload',
+            header: { ...this.header }, // Copy default headers
+            filePath: filePath,
+            name: name,
+            formData: formData
+        };
+
+        // Apply request interceptor (reuse logic for token injection)
+        // Note: wx.uploadFile doesn't support method/data in the same way, but we use interceptor for header mainly
+        config = this.interceptors.request(config);
+
+        return new Promise((resolve, reject) => {
+            wx.uploadFile({
+                url: config.url,
+                filePath: config.filePath,
+                name: config.name,
+                formData: config.formData,
+                header: config.header,
+                success: (res) => {
+                    // wx.uploadFile returns data as String, need to parse
+                    let data;
+                    try {
+                        data = JSON.parse(res.data);
+                    } catch (e) {
+                        data = { code: 500, msg: 'Response parse error', data: res.data };
+                    }
+
+                    // Reconstruct a response object for interceptor
+                    const responseObj = { ...res, data: data };
+
+                    // Apply response interceptor
+                    const processedResponse = this.interceptors.response(responseObj);
+                    const { statusCode, data: finalData } = processedResponse;
+
+                    // Status Code check (uploadFile also returns statusCode)
+                    if (statusCode >= 200 && statusCode < 300) {
+                        const businessCode = finalData.code;
+                        if (businessCode === 200) {
+                            resolve(finalData.data);
+                        } else {
+                            this.handleError({
+                                errMsg: finalData.msg || 'Upload Error',
+                                code: businessCode
+                            });
+                            reject(finalData);
+                        }
+                    } else {
+                        this.handleError({ errMsg: `HTTP Error: ${statusCode}`, ...res });
+                        reject(res);
+                    }
+                },
+                fail: (err) => {
+                    this.handleError({ errMsg: 'Upload Network Error', ...err });
+                    reject(err);
+                }
+            });
+        });
+    }
+
+    get(url, data = {}, header = {}) {
+        return this.request({ url, method: 'GET', data, header });
+    }
+
+    post(url, data = {}, header = {}) {
+        return this.request({ url, method: 'POST', data, header });
+    }
+}
+
+// Initialize with default instance
+const request = new WxRequest({
+    baseUrl: 'http://192.168.0.184:8888',
+    header: {
+        'Content-Type': 'application/json'
+    }
+});
+
+// Example: Setup default interceptors
+request.setRequestInterceptor((config) => {
+    // Inject token if available
+    const token = wx.getStorageSync('token');
+    if (token) {
+        // User requested: Bearer + token
+        config.header['Authorization'] = `Bearer ${token}`;
+    }
+    return config;
+});
+
+request.setResponseInterceptor((response) => {
+    // Handle global token expiration (e.g., HTTP 401 or Business Code 401)
+    if (response.statusCode === 401 || response.data?.code === 401) {
+        wx.removeStorageSync('token');
+        // Redirect to login if needed, or just warn
+        // wx.reLaunch({ url: '/pages/login/index' });
+    }
+    return response;
+});
+
+export default request;
+export { WxRequest };