low-code/apps/designer/src/service/index.ts

import {
  type ProjectSchema,
  type BlockSchema,
  type HistorySchema,
  type HistoryItem,
  type MaterialDescription,
  type ExtensionConfig,
  type PageFile,
  type BlockFile,
  ProjectModel,
  HistoryModel
} from '@vtj/core';
import { Storage, mapToObject } from '@vtj/utils';
import { BaseService } from '@vtj/renderer';
import { getProject } from '@/io';
const storage = new Storage({
  type: 'local',
  expired: 0
  // prefix: '__VTJ_'
});

export class StorageService extends BaseService {
  public async init(project: ProjectSchema): Promise<ProjectSchema> {
    // console.log('init-project', project);
    // const model = new ProjectModel(project);
    // // console.log('init-project-model', model);
    // const match = storage.get(`project_${model.id}`);
    // console.log('init-project-match', match);
    // const dsl = Object.assign(model.toDsl(), match || {});
    // console.log('init-project-dsl', dsl);
    // storage.save(`project_${model.id}`, dsl);

    const remoteProject = await getProject(3);
    const model = new ProjectModel(remoteProject);
    const dsl = model.toDsl();
    console.log('dsl', dsl);
    storage.save(`project_${model.id}`, dsl);
    return Promise.resolve(dsl);
  }

  public getExtension(): Promise<ExtensionConfig | undefined> {
    const extension = storage.get('extension');
    console.log('ExtensionConfig', extension);
    return Promise.resolve(extension as ExtensionConfig | undefined);
  }

  public saveProject(project: ProjectSchema): Promise<boolean> {
    const model = new ProjectModel(project);
    storage.save(`project_${model.id}`, model.toDsl());
    return Promise.resolve(true);
  }

  public saveMaterials(
    project: ProjectSchema,
    materials: Map<string, MaterialDescription>
  ): Promise<boolean> {
    storage.save(`materials_${project.id}`, mapToObject(materials));
    console.log('saveMaterials', materials);
    return Promise.resolve(true);
  }

  public saveFile(file: BlockSchema): Promise<boolean> {
    storage.save(`file_${file.id}`, file);
    console.log('saveFile', file);
    return Promise.resolve(true);
  }

  public getFile(id: string): Promise<BlockSchema> {
    const dsl = storage.get(`file_${id}`);
    console.log('getFile', id, dsl);
    if (dsl) {
      return Promise.resolve(dsl as BlockSchema);
    } else {
      return Promise.reject(null);
    }
  }

  public removeFile(id: string): Promise<boolean> {
    storage.remove(`file_${id}`);
    console.log('removeFile', id);
    return Promise.resolve(true);
  }

  public saveHistory(history: HistorySchema): Promise<boolean> {
    storage.save(`history_${history.id}`, history);
    // console.log('saveHistory', history);
    return Promise.resolve(true);
  }

  public api = (type: string, data: any): Promise<any> => {
    console.log('api', type, data);
    return Promise.resolve(true);
  };

  protected uploader = (file: File, projectId: string): Promise<any> => {
    console.log('uploader', file, projectId);
    return Promise.resolve(true);
  };

  public removeHistory(id: string): Promise<boolean> {
    const history = storage.get(`history_${id}`) as HistorySchema;
    if (history) {
      const items = history.items || [];
      const ids = items.map((item) => item.id);
      this.removeHistoryItem(id, ids);
      storage.remove(`history_${id}`);
      console.log('removeHistory', history);
    }

    return Promise.resolve(true);
  }

  public getHistory(id: string): Promise<HistorySchema> {
    const dsl = storage.get(`history_${id}`);
    console.log('getHistoryDSL', dsl);
    const history = new HistoryModel(dsl || { id });
    console.log('getHistory', dsl, id, history);
    return Promise.resolve(history.toDsl());
  }

  public getHistoryItem(fId: string, id: string): Promise<HistoryItem> {
    const item = storage.get(`history_${fId}_${id}`);
    console.log('getHistoryItem', item);
    return Promise.resolve(item);
  }

  public saveHistoryItem(fId: string, item: HistoryItem): Promise<boolean> {
    console.log('saveHistoryItem', fId, item);
    storage.save(`history_${fId}_${item.id}`, item);
    return Promise.resolve(true);
  }

  public removeHistoryItem(fId: string, ids: string[]): Promise<boolean> {
    ids.forEach((id) => {
      storage.remove(`history_${fId}_${id}`);
      console.log('removeHistoryItem', fId, id);
    });
    return Promise.resolve(true);
  }
  public publish(project: ProjectSchema): Promise<boolean> {
    console.log('整站发布 project', project);
    return Promise.resolve(true);
  }

  public publishFile(
    project: ProjectSchema,
    file: PageFile | BlockFile
  ): Promise<boolean> {
    console.log('发布页面', project, file);
    return Promise.resolve(true);
  }
}