harmonyos next 中端云一体化开发相关

// 引入云数据库模块
const db = context.database();
const collection = db.collection('userData');

// 新增数据
exports.createData = async (event, context) => {
  try {
    // 从事件中获取要插入的数据
    const data = event.data;
    
    // 插入数据到云数据库
    const result = await collection.add(data);
    
    return {
      code: 0,
      message: '数据添加成功',
      data: result
    };
  } catch (error) {
    return {
      code: -1,
      message: '数据添加失败',
      error: error.message
    };
  }
};

// 查询数据
exports.queryData = async (event, context) => {
  try {
    // 从事件中获取查询条件
    const condition = event.condition || {};
    
    // 执行查询
    const result = await collection.where(condition).get();
    
    return {
      code: 0,
      message: '数据查询成功',
      data: result
    };
  } catch (error) {
    return {
      code: -1,
      message: '数据查询失败',
      error: error.message
    };
  }
};

// 更新数据
exports.updateData = async (event, context) => {
  try {
    // 获取条件和更新数据
    const { id, updateData } = event;
    
    // 执行更新
    const result = await collection.doc(id).update(updateData);
    
    return {
      code: 0,
      message: '数据更新成功',
      data: result
    };
  } catch (error) {
    return {
      code: -1,
      message: '数据更新失败',
      error: error.message
    };
  }
};

// 删除数据
exports.deleteData = async (event, context) => {
  try {
    // 获取要删除的文档ID
    const { id } = event;
    
    // 执行删除
    const result = await collection.doc(id).remove();
    
    return {
      code: 0,
      message: '数据删除成功',
      data: result
    };
  } catch (error) {
    return {
      code: -1,
      message: '数据删除失败',
      error: error.message
    };
  }
};

// 引入云存储模块
const storage = context.storage();

// 上传文件到云存储
exports.uploadFile = async (event, context) => {
  try {
    // 获取文件信息和内容
    const { fileName, fileContent, mimeType } = event;
    
    // 定义存储路径
    const filePath = `uploads/${Date.now()}_${fileName}`;
    
    // 上传文件
    const result = await storage.uploadFile({
      cloudPath: filePath,
      content: Buffer.from(fileContent, 'base64'),
      contentType: mimeType
    });
    
    // 返回文件URL和路径
    return {
      code: 0,
      message: '文件上传成功',
      data: {
        fileId: result.fileID,
        url: result.downloadURL,
        path: filePath
      }
    };
  } catch (error) {
    return {
      code: -1,
      message: '文件上传失败',
      error: error.message
    };
  }
};

// 删除云存储中的文件
exports.deleteFile = async (event, context) => {
  try {
    // 获取要删除的文件ID
    const { fileId } = event;
    
    // 执行删除
    await storage.deleteFile({
      fileList: [fileId]
    });
    
    return {
      code: 0,
      message: '文件删除成功'
    };
  } catch (error) {
    return {
      code: -1,
      message: '文件删除失败',
      error: error.message
    };
  }
};

// 获取文件下载URL
exports.getFileUrl = async (event, context) => {
  try {
    const { fileId } = event;
    
    // 获取临时下载URL
    const result = await storage.getTempFileURL({
      fileList: [fileId]
    });
    
    return {
      code: 0,
      message: '获取文件URL成功',
      data: {
        url: result.fileList[0].tempFileURL
      }
    };
  } catch (error) {
    return {
      code: -1,
      message: '获取文件URL失败',
      error: error.message
    };
  }
};

// 引入所需模块
const db = context.database();
const storage = context.storage();
const collection = db.collection('userPosts');

// 上传文件并关联到数据库记录
exports.uploadAndSave = async (event, context) => {
  try {
    // 1. 先上传文件到云存储
    const { fileName, fileContent, mimeType, postData } = event;
    const filePath = `posts/${Date.now()}_${fileName}`;
    
    const uploadResult = await storage.uploadFile({
      cloudPath: filePath,
      content: Buffer.from(fileContent, 'base64'),
      contentType: mimeType
    });
    
    // 2. 将文件信息与其他数据一起保存到数据库
    const post = {
      ...postData,
      image: {
        fileId: uploadResult.fileID,
        url: uploadResult.downloadURL,
        name: fileName,
        size: uploadResult.size,
        uploadedAt: new Date()
      }
    };
    
    const dbResult = await collection.add(post);
    
    return {
      code: 0,
      message: '文件上传并保存数据成功',
      data: {
        postId: dbResult.id,
        fileId: uploadResult.fileID
      }
    };
  } catch (error) {
    return {
      code: -1,
      message: '操作失败',
      error: error.message
    };
  }
};

// 删除数据时同时删除关联的文件
exports.deletePostAndFile = async (event, context) => {
  try {
    const { postId } = event;
    
    // 1. 先查询帖子信息获取文件ID
    const post = await collection.doc(postId).get();
    if (!post.data || !post.data.image) {
      return {
        code: -1,
        message: '帖子不存在或没有关联文件'
      };
    }
    
    // 2. 删除云存储中的文件
    await storage.deleteFile({
      fileList: [post.data.image.fileId]
    });
    
    // 3. 删除数据库中的帖子记录
    await collection.doc(postId).remove();
    
    return {
      code: 0,
      message: '帖子及关联文件删除成功'
    };
  } catch (error) {
    return {
      code: -1,
      message: '删除失败',
      error: error.message
    };
  }
};

import agconnect from '@hw-agconnect/api-ohos';
import '@hw-agconnect/function-ohos';

export class CloudFunctionService {
  // 初始化AGC
  initAGC(context: Context) {
    agconnect.instance().init(context);
  }
  
  // 调用创建数据的云函数
  async createData(data: any): Promise<any> {
    try {
      const functionCallable = agconnect.function().wrap('createData');
      const result = await functionCallable.call({ data });
      return result.getValue();
    } catch (error) {
      console.error('调用云函数失败:', error);
      throw error;
    }
  }
  
  // 调用上传文件的云函数
  async uploadFile(fileName: string, fileContent: Uint8Array, mimeType: string, postData: any): Promise<any> {
    try {
      // 将文件内容转换为base64
      const base64Content = this.arrayBufferToBase64(fileContent.buffer);
      
      const functionCallable = agconnect.function().wrap('uploadAndSave');
      const result = await functionCallable.call({
        fileName,
        fileContent: base64Content,
        mimeType,
        postData
      });
      
      return result.getValue();
    } catch (error) {
      console.error('上传文件失败:', error);
      throw error;
    }
  }
  
  // ArrayBuffer转Base64
  private arrayBufferToBase64(buffer: ArrayBuffer): string {
    let binary = '';
    const bytes = new Uint8Array(buffer);
    const len = bytes.byteLength;
    
    for (let i = 0; i < len; i++) {
      binary += String.fromCharCode(bytes[i]);
    }
    
    return btoa(binary);
  }
}