363 lines
15 KiB
JavaScript
363 lines
15 KiB
JavaScript
|
|
!(function (e, t) {
|
|
"object" == typeof exports && "undefined" != typeof module
|
|
? (module.exports = t(e))
|
|
: "function" == typeof define && define.amd
|
|
? define(t, e)
|
|
: ((e = "undefined" != typeof globalThis ? globalThis : e || self).http =
|
|
t(e));
|
|
})(this,
|
|
function (scope) {
|
|
if (!scope.axios) {
|
|
scope.require("/libs/axios/1.7.2/axios.min.js");
|
|
}
|
|
if (!scope.settings) {
|
|
scope.require("/settings.js");
|
|
}
|
|
const _original = axios;
|
|
const getToken = () => {
|
|
return localStorage.getItem("token");
|
|
}
|
|
const _axios = _original.create({
|
|
baseURL: settings.API_BASE, // url = base url + request url
|
|
// withCredentials: true, // send cookies when cross-domain requests
|
|
timeout: 1000 * 60 * 60 // request timeout
|
|
})
|
|
// request interceptor
|
|
_axios.interceptors.request.use(
|
|
config => {
|
|
config.headers['Authorization'] = getToken();
|
|
return config
|
|
},
|
|
error => {
|
|
return Promise.reject(error)
|
|
}
|
|
)
|
|
var absoluteUrlRegex = /^(http(s?):)?\/\//;
|
|
_axios.download = function ({ url, fileName, validFileSize, params, row }) {
|
|
if (!absoluteUrlRegex.test(url)) {
|
|
if (url[0] == "/") url = url.substring(1);
|
|
url = _axios.defaults.baseURL + url;
|
|
}
|
|
var target = new URL(url);
|
|
Object.entries(params).forEach(([key, value]) => {
|
|
target.searchParams.append(key, value)
|
|
})
|
|
Promise.resolve(0)
|
|
.then(() => {
|
|
//第一下载xml
|
|
return generateXml();
|
|
})
|
|
.then(() => {
|
|
/// 第二下载dat
|
|
var downloadIFramesrc = target.toString();
|
|
return downloadFile(downloadIFramesrc, fileName, validFileSize, row);
|
|
}).catch((error) => {
|
|
console.log(error.Message);
|
|
})
|
|
async function generateXml() {
|
|
return new Promise((resolve) => {
|
|
const xmlData = createXml();
|
|
downloadXml(xmlData).then(() => {
|
|
resolve();
|
|
});
|
|
})
|
|
}
|
|
function createXml() {
|
|
let _iq = 'I';
|
|
let _ptnSize = 2;
|
|
let _FerdPnt = null;
|
|
let _type = row.dataType;
|
|
if (row.dataType == 1) {
|
|
_iq = 'IQ';
|
|
_ptnSize = 4;
|
|
_FerdPnt = 61440000;
|
|
};
|
|
if (row.dataType == 3) {
|
|
_FerdPnt = 32768;
|
|
};
|
|
if (row.dataType == 5) {
|
|
_FerdPnt = 26624;
|
|
_type = 4;
|
|
};
|
|
if (row.dataType == 6) {
|
|
_FerdPnt = 61440000;
|
|
};
|
|
const xmlString = `<?xml version='1.0' encoding='UTF-8'?>
|
|
<FileInfo>
|
|
<DevCode>07G1B1DBWB0001</DevCode >
|
|
<DataType>${_iq}</DataType >
|
|
<FileType>dat</FileType>
|
|
<StartTime>${formattedTime(row.taskTimeCreate)}</StartTime >
|
|
<EndTime>${formattedTime(row.taskTimeEnd)}</EndTime >
|
|
<FileID>${row.fileId}</FileID >
|
|
<FileName>${fileName.replace(".dat", "")}</FileName >
|
|
<DataClas>${_type}</DataClas>
|
|
<PntSize>${_ptnSize}</PntSize>
|
|
<Channel>1</Channel >
|
|
<CentFreq>${row.centerFreqHz}</CentFreq>
|
|
<SampFreq>${row.sampleFreqHz}</SampFreq>
|
|
<BandWid>${row.bandWidthHz}</BandWid>
|
|
<DataTime>${formateTimer(row)}</DataTime>
|
|
<FerdPnt>${_FerdPnt}</FerdPnt>
|
|
<FileSize>${row.validFileSize}</FileSize>
|
|
<FileNote>${row.remark}</FileNote>
|
|
</FileInfo >`
|
|
return xmlString
|
|
}
|
|
function downloadXml(xml) {
|
|
return new Promise((resolve) => {
|
|
const blob = new Blob([xml], { type: "text/xml" });
|
|
const link = document.createElement('a');
|
|
const url = window.URL.createObjectURL(blob);
|
|
link.href = url;
|
|
let newfilename = fileName.replace(/\.(txt|dat)/g, '');
|
|
link.download = newfilename + ".xml";
|
|
link.style.display = 'none';
|
|
document.body.appendChild(link);
|
|
link.addEventListener('click', () => {
|
|
setTimeout(() => {
|
|
document.body.removeChild(link);
|
|
window.URL.revokeObjectURL(url);
|
|
resolve();
|
|
}, 3000)
|
|
})
|
|
link.click();
|
|
})
|
|
}
|
|
function toDate(_num, length) {
|
|
let str = _num.toString();
|
|
return str.length > length ? str.slice(0, length) : str.padStart(length, '0');
|
|
}
|
|
function formattedTime(_rowtime) {
|
|
const date = new Date(_rowtime * 1000 - 8 * 3600 * 1000)
|
|
const formattime = date.toLocaleString('zh-CN', {
|
|
year: "numeric",
|
|
month: '2-digit',
|
|
day: '2-digit',
|
|
hour: '2-digit',
|
|
minute: '2-digit',
|
|
second: '2-digit',
|
|
hour12: false
|
|
});
|
|
return formattime
|
|
}
|
|
function formateTimer(row) {
|
|
let year = '20' + toDate(row.mapSataInfo.year, 2);
|
|
let m = toDate(row.mapSataInfo.month, 2);
|
|
let day = toDate(row.mapSataInfo.day, 2);
|
|
let hour = toDate(row.mapSataInfo.hour, 2);
|
|
let minute = toDate(row.mapSataInfo.minute, 2);
|
|
let second = toDate(row.mapSataInfo.second, 2);
|
|
let nanoSec = toDate(row.mapSataInfo.nanoSec, 9);
|
|
let _time = year + m
|
|
+ day + hour + minute + second + '.' + nanoSec;
|
|
return _time
|
|
}
|
|
};
|
|
async function downloadFile(url, filename, validFileSize, row) {
|
|
const response = await fetch(url, { method: 'GET' });
|
|
if (!response.ok) {
|
|
throw new Error(`HTTP error! status: ${response.status}`);
|
|
};
|
|
let loaded = 0;
|
|
let speedSum = 0;
|
|
let timerId = null;
|
|
// 设置初始状态
|
|
vm.fileManager.storage.downloadSwitch = true;
|
|
vm.fileManager.storage.speed = 0;
|
|
vm.fileManager.storage.percentage = 0;
|
|
vm.fileManager.storage.isfullfill = '正在下载';
|
|
const reader = response.body.getReader();
|
|
const stream = new ReadableStream({
|
|
start(controller) {
|
|
async function push() {
|
|
const { done, value } = await reader.read();
|
|
if (done) {
|
|
controller.close();
|
|
clearInterval(timerId);
|
|
vm.fileManager.storage.isfullfill = "下载完成";
|
|
setTimeout(() => {
|
|
vm.onWorkSwitch(true);//打开开关
|
|
vm.currentDownload = null;
|
|
vm.fileManager.storage.downloadSwitch = false;
|
|
}, 1000);
|
|
return;
|
|
};
|
|
loaded += value.byteLength;
|
|
speedSum += value.byteLength;
|
|
controller.enqueue(value);
|
|
push();
|
|
};
|
|
push();
|
|
timerId = setInterval(() => {
|
|
//取消下载事件
|
|
if (vm.currentDownload == null) {
|
|
if (controller) {
|
|
controller.close();
|
|
clearInterval(timerId);
|
|
// 关闭可写流
|
|
setTimeout(() => {
|
|
vm.onWorkSwitch(true);//打开开关
|
|
vm.currentDownload = null;
|
|
vm.fileManager.storage.downloadSwitch = false;
|
|
}, 500);
|
|
return;
|
|
}
|
|
};
|
|
//进度条以及下载速度更新
|
|
vm.fileManager.storage.speed = speedSum / 2;
|
|
speedSum = 0;
|
|
// 计算下载进度
|
|
vm.fileManager.storage.percentage = ((loaded / validFileSize) * 100).toFixed(2);
|
|
|
|
}, 1000)
|
|
}
|
|
});
|
|
const blob = await new Response(stream).blob();
|
|
const downloadUrl = window.URL.createObjectURL(blob);
|
|
const anchor = document.createElement('a');
|
|
anchor.href = downloadUrl;
|
|
anchor.download = filename;
|
|
document.body.appendChild(anchor);
|
|
anchor.click();
|
|
document.body.removeChild(anchor);
|
|
window.URL.revokeObjectURL(downloadUrl);
|
|
}
|
|
_axios.sync = function (opts) {
|
|
let { url, method, data } = opts;
|
|
if (url.indexOf("http://") == -1) {
|
|
if (url[0] == "/") url = url.substring(1);
|
|
url = settings.API_BASE + url;
|
|
}
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open(method, url, false);
|
|
xhr.setRequestHeader("Content-type", "application/json;charset=utf-8");
|
|
xhr.send(data);
|
|
var response = JSON.parse(xhr.responseText);
|
|
return response;
|
|
}
|
|
_axios.interceptors.response.use(
|
|
response => {
|
|
const res = response.data
|
|
const statusCode = res.code || res.Code || response.status;
|
|
if (statusCode !== 200) {
|
|
const message = res.message || res.Message;
|
|
|
|
false && console.log({
|
|
message: message || 'Error',
|
|
type: 'error',
|
|
duration: 5 * 1000
|
|
});
|
|
return Promise.reject(new Error(message || 'Error'))
|
|
} else {
|
|
return res
|
|
}
|
|
},
|
|
error => {
|
|
false && console.log({
|
|
message: error.message,
|
|
type: 'error',
|
|
duration: 5 * 1000
|
|
})
|
|
return Promise.reject(error)
|
|
}
|
|
)
|
|
|
|
_axios.socket = (function () {
|
|
const core = function () {
|
|
function SocketWorker(url, token) {
|
|
var _ctx = this.$ctx = { state: null };
|
|
this.socket = new WebSocket(url);
|
|
this.socket.onopen = function () {
|
|
postMessage({ "name": "onopen", "payload": null }, []);
|
|
}
|
|
this.socket.onclose = function (args) {
|
|
let { code, reason, type, target } = args;
|
|
let { url } = target;
|
|
postMessage({ "name": "onclose", "payload": { code, reason, type, url } });
|
|
}
|
|
this.socket.onerror = function () {
|
|
postMessage({ "name": "onerror", "payload": null });
|
|
}
|
|
this.socket.onmessage = function (e) {
|
|
if (e.data.size < 32) return;
|
|
e.data.arrayBuffer().then(function (buffer) {
|
|
postMessage({ "name": "onmessage", "payload": buffer }, [buffer]);
|
|
});
|
|
}
|
|
}
|
|
SocketWorker.prototype.state = function (state) {
|
|
this.$ctx.state = state;
|
|
}
|
|
SocketWorker.prototype.close = function () {
|
|
if (this.socket) this.socket.close();
|
|
}
|
|
SocketWorker.prototype.postMessage = function () {
|
|
this.socket.postMessage(...arguments);
|
|
}
|
|
let _websocket;
|
|
addEventListener('message', function (e) {
|
|
let { name, payload } = e.data;
|
|
switch (name) {
|
|
case "create":
|
|
let { url, token, state } = payload;
|
|
_websocket = new SocketWorker(url, token);
|
|
break;
|
|
case "close":
|
|
_websocket?.close();
|
|
break;
|
|
default:
|
|
_websocket?.postMessage(e.data);
|
|
//?.取属性同时判断该属性是否存在
|
|
}
|
|
});
|
|
};
|
|
var blob = new Blob([`(${core})()`]);
|
|
var workurl = URL.createObjectURL(blob);
|
|
const create = (function (opts) {
|
|
let { url, callback, state } = opts;
|
|
if (url.indexOf("ws://") == -1) {
|
|
if (url[0] == "/") url = url.substring(1);
|
|
url = settings.WEBSOCKET_BASE + url;
|
|
};
|
|
var worker = new Worker(workurl);
|
|
URL.revokeObjectURL(workurl);
|
|
var receive = function (e) {
|
|
const { name, payload } = e.data;
|
|
handles.forEach(handle => handle(name, payload))
|
|
};
|
|
var handles = new Set();
|
|
if (callback) handles.add(callback);
|
|
// worker.addEventListener('message', receive);
|
|
worker.addEventListener('message', (e) => {
|
|
try {
|
|
const { name, payload } = e.data;
|
|
handles.forEach(handle => handle(name, payload))
|
|
} catch (error) {
|
|
console.log(error);
|
|
}
|
|
})
|
|
worker.addEventListener("error", (e) => {
|
|
console.error("worker发生错误", e.message, e.filename, e.lineno);
|
|
})
|
|
url = new URL(url);
|
|
url.searchParams.append("token", getToken());
|
|
worker.postMessage({ name: "create", payload: { url: url.href, state } });
|
|
return {
|
|
onmessage(handle) {
|
|
handles.add(handle);
|
|
},
|
|
postMessage() {
|
|
worker.postMessage(...arguments);
|
|
},
|
|
close() {
|
|
worker.postMessage({ name: "close" });
|
|
}
|
|
}
|
|
});
|
|
return create
|
|
})();
|
|
return _axios;
|
|
}
|
|
); |