解压

package com.hoteam.sview.demo;

import cn.hutool.core.util.StrUtil;
import cn.hutool.http.Header;
import cn.hutool.http.HttpRequest;
import cn.hutool.http.HttpResponse;
import cn.hutool.http.HttpStatus;
import cn.hutool.core.util.JsonUtil;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;

/**
 * 压缩包解压调用 Demo
 * 接口：POST /login-register/open-api/documents/unzip
 * 业务成功判定：code=0 成功，code≠0 取 msg 提示
 * 返回taskId可作为socketId建立socket监听解压进度
 */
@Slf4j
public class DocumentUnzipDemo {

    // ===================== 入参实体 =====================
    @Data
    public static class UnzipReq {
        /**
         * 文件唯一ID
         */
        private String fileId;
        /**
         * 文件归属域：personal 我的空间 / project 项目空间
         */
        private String fileScope;
    }

    // ===================== 返回体实体 =====================
    @Data
    public static class UnzipResp {
        private Integer code;
        private String msg;
        private Boolean ok;
        private UnzipData data;
    }

    @Data
    public static class UnzipData {
        /**
         * 解压任务ID，前端socketId监听解压进度
         */
        private String taskId;
    }

    // ===================== 核心调用方法 =====================
    public static UnzipResp unzipFile(String apiBaseUrl, String accessToken, UnzipReq req) {
        if (StrUtil.isBlank(apiBaseUrl)) {
            log.warn("接口基础地址不能为空");
            return null;
        }
        if (StrUtil.isBlank(accessToken)) {
            log.warn("AccessToken不能为空");
            return null;
        }
        if (req == null
                || StrUtil.isBlank(req.getFileId())
                || StrUtil.isBlank(req.getFileScope())) {
            log.warn("解压请求必填参数缺失，req:{}", req);
            return null;
        }

        String fullUrl = apiBaseUrl + "/login-register/open-api/documents/unzip";

        try (HttpResponse response = HttpRequest.post(fullUrl)
                .header(Header.AUTHORIZATION, "Bearer " + accessToken)
                .header(Header.CONTENT_TYPE, "application/json")
                .body(JsonUtil.toJsonStr(req))
                .timeout(60_000)
                .execute()) {

            int status = response.getStatus();
            String respBody = response.body();
            log.info("解压接口响应 status=[{}], body=[{}]", status, respBody);

            if (status != HttpStatus.HTTP_OK) {
                log.warn("解压HTTP请求失败，响应状态码=[{}]", status);
                return null;
            }

            UnzipResp resp = JsonUtil.parse(respBody, UnzipResp.class);
            if (resp == null) {
                log.warn("解压接口返回JSON解析失败");
                return null;
            }

            if (resp.getCode() != null && resp.getCode() != 0) {
                String errMsg = StrUtil.isNotBlank(resp.getMsg()) ? resp.getMsg() : "未知业务异常";
                log.warn("解压业务失败，code=[{}], msg=[{}]", resp.getCode(), errMsg);
                return resp;
            }

            log.info("解压任务提交成功");
            return resp;

        } catch (Exception e) {
            log.error("调用解压接口异常", e);
            return null;
        }
    }

    // ===================== Main 调用示例 =====================
    public static void main(String[] args) {
        String baseApi = "https://xxx.xxx.com";
        String token = "你的AccessToken";

        UnzipReq req = new UnzipReq();
        req.setFileId("平台返回的压缩包文件fileId");
        // personal=我的空间，project=项目空间
        req.setFileScope("personal");

        UnzipResp result = unzipFile(baseApi, token, req);
        if (result == null) {
            log.error("解压请求整体失败");
            return;
        }
        if (result.getCode() != 0) {
            log.error("提交解压任务失败，错误码:{}, 错误信息:{}", result.getCode(), result.getMsg());
            return;
        }

        UnzipData data = result.getData();
        if (data == null || StrUtil.isBlank(data.getTaskId())) {
            log.warn("解压接口未返回taskId");
            return;
        }

        // 获取任务ID，用于socket监听解压进度
        String taskId = data.getTaskId();
        log.info("解压任务提交成功，taskId={}，可建立Socket监听解压进度", taskId);
    }
}

// socket地址
ws(s)://{baseURL}/emh/ws/info?socketId={taksId}
// 举例,若域名配置了oss安全证书，则需要以 wss:// 开头
// ws://10.1.201.7:9999/emh/ws/info?socketId=aaaaaaaa
// wss://www.baidu.com/emh/ws/info?socketId=aaaaaaaa

{"code":0,"command":"UNCOMPRESS_FILE","data":"{\"taskId\":\"2fa1931b7f004bb7b1577098368d0729\",\"subTaskType\":\"unzip\",\"status\":\"success\",\"msg\":\"ptc-wire_test.zip文件已解压完毕，请到压缩文件所在文件夹查看\",\"waitingLength\":\"0\",\"waitingTime\":\"0\"}

<template>
  <div class="unzip-container">
    <div v-if="loading">提交解压任务中...</div>
    <div v-if="progress > 0">解压进度：{{ progress }}%</div>
    <div v-if="errorMsg" class="error">{{ errorMsg }}</div>

    <div v-if="unzipSuccess">
      <span>✅ 解压任务完成，可浏览解压后的文件</span>
    </div>
  </div>
</template>

<script>
import axios from 'axios'

export default {
  name: 'DocumentUnzip',
  data() {
    return {
      // 接口基础地址
      baseUrl: 'https://xxx.xxx.com',
      // 你的 token
      token: '你的 accessToken',

      fileId: '压缩包对应的fileId',
      fileScope: 'personal', // personal(我的空间) / project(项目空间)

      taskId: '',
      socket: null,

      loading: false,
      progress: 0,
      errorMsg: '',
      unzipSuccess: false
    }
  },
  mounted() {
    this.submitUnzipTask()
  },
  beforeDestroy() {
    // 页面销毁关闭 socket
    if (this.socket) {
      this.socket.close()
    }
  },
  methods: {
    /**
     * 1. 提交解压任务
     */
    async submitUnzipTask() {
      this.loading = true
      this.errorMsg = ''
      this.unzipSuccess = false

      try {
        const res = await axios({
          url: `${this.baseUrl}/login-register/open-api/documents/unzip`,
          method: 'post',
          headers: {
            Authorization: 'Bearer ' + this.token
          },
          data: {
            fileId: this.fileId,
            fileScope: this.fileScope
          }
        })

        const { code, msg, data } = res.data

        // 业务失败
        if (code !== 0) {
          this.errorMsg = msg || '提交解压任务失败'
          return
        }

        // 获取解压任务taskId，建立socket监听解压进度
        if (data?.taskId) {
          this.taskId = data.taskId
          this.connectSocket()
          return
        }

        this.errorMsg = '接口返回异常：taskId为空'

      } catch (err) {
        console.error(err)
        this.errorMsg = '网络请求异常'
      } finally {
        this.loading = false
      }
    },

    /**
     * 2. 建立 WebSocket 监听解压进度
     */
    connectSocket() {
      // 拼接 socket 地址，http转ws、https转wss
      const socketUrl = `${this.baseUrl.replace('http', 'ws')}/emh/ws/info?socketId=${this.taskId}`
      this.socket = new WebSocket(socketUrl)

      this.socket.onopen = () => {
        console.log('WebSocket‑解压进度监听连接成功')
      }

      this.socket.onmessage = (evt) => {
        try {
          const msg = JSON.parse(evt.data)
          // 解压任务消息（和预览转码socket消息格式一致）
          if (msg.command === 'CONVERT_TASK') {
            const { status, percent } = msg.data || {}
            this.progress = percent || 0

            // 解压成功
            if (status === 'success') {
              this.socket.close()
              this.unzipSuccess = true
            }

            // 解压失败
            if (status === 'failed') {
              this.errorMsg = '压缩包解压失败'
              this.socket.close()
            }
          }
        } catch (e) {
          console.error('socket消息解析失败', e)
        }
      }

      this.socket.onerror = (err) => {
        console.error('socket异常', err)
        this.errorMsg = '解压进度监听连接失败'
      }

      this.socket.onclose = () => {
        console.log('解压‑socket已关闭')
      }
    }
  }
}
</script>

<style scoped>
.error {
  color: red;
  margin: 10px 0;
}
</style>