lifepartner/src/lib/ncloud.ts

import * as Parse from 'parse';

// CloudObject.ts
export class CloudObject {
    className: string;
    id: string | null = null;
    createdAt: any;
    updatedAt: any;
    data: Record<string, any> = {};

    constructor(className: string) {
        this.className = className;
    }

    toPointer() {
        return { "__type": "Pointer", "className": this.className, "objectId": this.id };
    }

    set(json: Record<string, any>) {
        Object.keys(json).forEach(key => {
            if (["objectId", "id", "createdAt", "updatedAt", "ACL"].indexOf(key) > -1) {
                if (key === "objectId") this.id = json[key];
                return;
            }
            this.data[key] = json[key];
        });
    }

    get(key: string) {
        return this.data[key] || null;
    }

    async save() {
        let method = "POST";
        let url = `https://dev.fmode.cn/parse/classes/${this.className}`;

        if (this.id) {
            url += `/${this.id}`;
            method = "PUT";
        }

        const body = JSON.stringify(this.data);
        const response = await fetch(url, {
            headers: {
                "content-type": "application/json;charset=UTF-8",
                "x-parse-application-id": "dev"
            },
            body: body,
            method: method,
            mode: "cors",
            credentials: "omit"
        });

        const result = await response?.json();
        if (result?.error) {
            throw new Error(result.error);
        }
        if (result?.objectId) {
            this.id = result?.objectId;
        }
        return this;
    }

    async destroy() {
        if (!this.id) return;
        const response = await fetch(`https://dev.fmode.cn/parse/classes/${this.className}/${this.id}`, {
            headers: {
                "x-parse-application-id": "dev"
            },
            method: "DELETE",
            mode: "cors",
            credentials: "omit"
        });

        const result = await response?.json();
        if (result?.error) {
            throw new Error(result.error);
        }
        this.id = null;
        return true;
    }

    protected setParseObject(obj: Parse.Object) {
        this.parseObject = obj;
    }
}

export class CloudQuery {
    private query: Parse.Query;
    className: string;
    queryParams: Record<string, any> = {};

    constructor(className: string) {
        this.className = className;
    }
    // 作用是将查询参数转换为对象
    include(...fileds:string[]) {
        this.queryParams["include"] = fileds;
    }
    greaterThan(key: string, value: any) {
        if (!this.queryParams["where"][key]) this.queryParams["where"][key] = {};
        this.queryParams["where"][key]["$gt"] = value;
    }

    greaterThanAndEqualTo(key: string, value: any) {
        if (!this.queryParams["where"][key]) this.queryParams["where"][key] = {};
        this.queryParams["where"][key]["$gte"] = value;
    }

    lessThan(key: string, value: any) {
        if (!this.queryParams["where"][key]) this.queryParams["where"][key] = {};
        this.queryParams["where"][key]["$lt"] = value;
    }

    lessThanAndEqualTo(key: string, value: any) {
        if (!this.queryParams["where"][key]) this.queryParams["where"][key] = {};
        this.queryParams["where"][key]["$lte"] = value;
    }

    equalTo(key: string, value: any) {
        this.queryParams["where"][key] = value;
    }

    async get(id: string) {
        const url = `http://dev.fmode.cn:1337/parse/classes/${this.className}/${id}?`;

        const response = await fetch(url, {
            headers: {
                "if-none-match": "W/\"1f0-ghxH2EwTk6Blz0g89ivf2adBDKY\"",
                "x-parse-application-id": "dev"
            },
            body: null,
            method: "GET",
            mode: "cors",
            credentials: "omit"
        });

        const json = await response?.json();
        // return json || {};
        const exists = json?.results?.[0] || null;
        if (exists) {
            let existsObject = this.dataToObj(exists)
            return existsObject;
        }
        return null

    }

    async find(): Promise<CloudObject[]> {
        try {
            const results = await this.query.find();
            return results.map((result: Parse.Object) => {
                const obj = new CloudObject(this.className);
                (obj as any).parseObject = result;  // 使用类型断言
                return obj;
            });
        } catch (error) {
            console.error('Query failed:', error);
            throw error;
        }
    }

    async first() {
        let url = `http://dev.fmode.cn:1337/parse/classes/${this.className}?`;

        if (Object.keys(this.queryParams["where"]).length) {
            const whereStr = JSON.stringify(this.queryParams["where"]);
            url += `where=${whereStr}`;
        }

        const response = await fetch(url, {
            headers: {
                "x-parse-application-id": "dev"
            }
        });

        const json = await response?.json();
        // const exists = json?.results?.[0] || null;
        // if (exists) {
        //     let existsObject = this.dataToObj(exists)
        //     return existsObject;
        // }
        // return null
        let list = json?.results || []
        let objList = list.map((item:any)=>this.dataToObj(item))
        return objList || [];
    }
}

export class CloudUser extends CloudObject {
    sessionToken: string | null = null;

    constructor() {
        super("_User"); // 假设用户类在Parse中是"_User"
        // 读取用户缓存信息
        let userCacheStr = localStorage.getItem("NCloud/dev/User")
        if(userCacheStr){
            let userData = JSON.parse(userCacheStr)
            // 设置用户信息
            this.id = userData?.objectId;
            this.sessionToken = userData?.sessionToken;
            this.data = userData; // 保存用户数据
        }
    }

    sessionToken:string|null = ""
    /** 获取当前用户信息 */
    async current() {
        if (!this.sessionToken) {
            console.error("用户未登录");
            return null;
        }
        return this;
        // const response = await fetch(`http://dev.fmode.cn:1337/parse/users/me`, {
        //     headers: {
        //         "x-parse-application-id": "dev",
        //         "x-parse-session-token": this.sessionToken // 使用sessionToken进行身份验证
        //     },
        //     method: "GET"
        // });

        // const result = await response?.json();
        // if (result?.error) {
        //     console.error(result?.error);
        //     return null;
        // }
        // return result;
    }

    /** 登录 */
    async login(username: string, password: string):Promise<CloudUser|null> {
        const response = await fetch(`http://dev.fmode.cn:1337/parse/login`, {
            headers: {
                'Content-Type': 'application/json',
                'X-Parse-Application-Id': 'dev'
            },
            body: JSON.stringify({ username, password })
        });

        const result = await response.json();
        if (result?.error) {
            throw new Error(result.error);
        }

        this.id = result.objectId;
        this.sessionToken = result.sessionToken;
        this.data = result;
        localStorage.setItem("NCloud/dev/User", JSON.stringify(result));
        return this;
    }

    async logOut() {
        if (!this.sessionToken) {
            throw new Error('User not logged in');
        }

        const response = await fetch(`https://dev.fmode.cn/parse/logout`, {
            headers: {
                'X-Parse-Application-Id': 'dev',
                'X-Parse-Session-Token': this.sessionToken
            },
            method: 'POST'
        });

        const result = await response?.json();
        if (result?.error) {
            console.error(result?.error);
            return false;
        }

        // 清除用户信息
        localStorage.removeItem("NCloud/dev/User")
        this.id = null;
        this.sessionToken = null;
        this.data = {};
        return true;
    }

    async signUp(username: string, password: string, additionalData: Record<string, any> = {}) {
        const userData = {
            username,
            password,
            ...additionalData // 合并额外的用户��据
        };

        const response = await fetch(`https://dev.fmode.cn/parse/users`, {
            headers: {
                "x-parse-application-id": "dev",
                "Content-Type": "application/json"
            },
            body: JSON.stringify(userData),
            method: "POST"
        });

        const result = await response?.json();
        if (result?.error) {
            throw new Error(result.error);
        }

        this.id = result?.objectId;
        this.sessionToken = result?.sessionToken;
        this.data = result;
        localStorage.setItem("NCloud/dev/User", JSON.stringify(result));
        return this;
    }

    override async save() {
        let method = "POST";
        let url = `http://dev.fmode.cn:1337/parse/users`;
    
        // 更新用户信息
        if (this.id) {
            url += `/${this.id}`;
            method = "PUT";
        }
    
        let data:any = JSON.parse(JSON.stringify(this.data))
        delete data.createdAt
        delete data.updatedAt
        delete data.ACL
        delete data.objectId
        const body = JSON.stringify(data);
        let headersOptions:any = {
            "content-type": "application/json;charset=UTF-8",
            "x-parse-application-id": "dev",
            "x-parse-session-token": this.sessionToken, // 添加sessionToken以进行身份验证
        }
        const response = await fetch(url, {
            headers: {
                "content-type": "application/json;charset=UTF-8",
                "x-parse-application-id": "dev",
                "x-parse-session-token": this.sessionToken
            },
            body: JSON.stringify(data),
            method: "PUT",
            mode: "cors",
            credentials: "omit"
        });

        const result = await response?.json();
        if (result?.error) {
            throw new Error(result.error);
        }
        
        localStorage.setItem("NCloud/dev/User", JSON.stringify(this.data));
        return this;
    }
}

export class CloudApi{
    async fetch(path:string,body:any,options?:{
        method:string
        body:any
    }){

        let reqOpts:any =  {
            headers: {
                "x-parse-application-id": "dev",
                "Content-Type": "application/json"
            },
            method: options?.method || "POST",
            mode: "cors",
            credentials: "omit"
        }
        if(body||options?.body){
            reqOpts.body = JSON.stringify(body || options?.body);
            reqOpts.json = true;
        }
        let host = `https://dev.fmode.cn`
        // host = `http://127.0.0.1:1337`
        let url = `${host}/api/`+path
        console.log(url,reqOpts)
        const response = await fetch(url,reqOpts);
        let json = await response.json();
        return json
    }
}