@ganwei-web/ganwei-pc-cli 6.2.6 → 6.2.7

package/ganwei-iotcenter-index-6.2.3/packages/ganwei-iotcenter-index/src/utils/gwSignalr.js

@@ -0,0 +1,66 @@
+import * as signalR from '@aspnet/signalr';
+
+export default class Signalr {
+    constructor(path, connectionId, equipNo, reconnect) {
+        this.url = path;
+        this.connectionId = connectionId;
+        this.equipNo = equipNo;
+        this.signalr = null;
+        this.reconnect = reconnect
+    }
+
+    openConnect () {
+
+        // 停止连接
+        if (this.signalr) {
+            this.signalr.stop();
+            this.signalr = null;
+        }
+
+        //  连接
+        this.signalr = new signalR.HubConnectionBuilder()
+            .withUrl(this.url)
+            .build();
+
+        // 停止监听
+        this.signalr.onclose((err) => {
+            if (this.reconnect) {
+                try {
+                    this.signalr.invoke('reconnect')
+                } catch (error) {
+                    console.log(error)
+                }
+            }
+            // this.openConnect()
+            console.log('onclose', err);
+        });
+
+        this.signalr.serverTimeoutInMilliseconds = 500000000;
+        this.signalr.keepaliveintervalinmilliseconds = 500000000
+
+        return new Promise((resolve, reject) => {
+            this.signalr
+                .start() // 启动连接
+                .then(() => {
+                    if (this.connectionId) {
+                        this.send();
+                    }
+
+                    resolve(this.signalr);
+                })
+                .catch((e) => {
+                    console.log(e);
+                    reject(e);
+                });
+        });
+    }
+
+    async send () { // 发送请求
+        try {
+            await this.signalr.invoke(this.connectionId, this.equipNo);
+        } catch (error) {
+            console.log('connectHub 连接失败' + error);
+        }
+    }
+
+}

package/ganwei-iotcenter-index-6.2.3/packages/ganwei-iotcenter-index/src/utils/historyExport.js

@@ -0,0 +1,158 @@
+import * as signalR from '@aspnet/signalr';
+export default {
+    data () {
+        return {
+            exportSignalrConnection: null,
+            haveDataDwonload: false,
+            exportTimer: null,
+            exportTimes: 0,
+            alreadyExport: true,
+            getExportCommand: false
+        }
+    },
+    mounted () {
+        // let that = this
+        // window.onmessage = function (e) {
+        //     that.curveSignalR(e)
+        // }
+    },
+    methods: {
+        getCommand (existIframe) {
+            if (existIframe) {
+                this.getExportCommand = true;
+                if (document.getElementById('jumpIframe')) {
+                    document.getElementById('jumpIframe').contentWindow.postMessage({ getExportCommand: true }, '*')
+                } else {
+                    let arr = Array.from(document.getElementsByTagName('iframe'));
+                    arr.forEach(item => {
+                        item.contentWindow.postMessage({ getExportCommand: true }, '*')
+                    })
+                }
+            }
+        },
+
+        // existIframe:是否有外框
+        curveSignalR (e, existIframe) {
+            if (e.data.openCurveLink) {
+                this.getCommand(existIframe);
+                if (!this.haveDataDwonload) {
+                    if (this.exportSignalrConnection) {
+                        this.exportSignalrConnection.stop()
+                    }
+                    this.exportSignalrConnection = null;
+                    this.exportSignalrConnection = new signalR.HubConnectionBuilder()
+                        .withUrl('/downFileNotify', {})
+                        .build();
+                    this.exportSignalrConnection.start().then(() => { console.log('链接成功'); }).catch(function (ex) {
+                        console.log('connectHub 连接失败' + ex);
+                    });
+                    window.clearInterval(this.exportTimer);
+                    this.exportTimer = null;
+
+                    // 判断连接状态
+                    this.exportSignalrConnection.off('connectionSucceeded');
+                    this.exportSignalrConnection.on('connectionSucceeded', (res) => {
+                        if (res) {
+                            this.exportCurves(window.top.exportData);
+                        }
+                    })
+
+                    this.exportSignalrConnection.off('downloadUrl');
+                    this.exportSignalrConnection.on('downloadUrl', res => {
+                        if (res) {
+                            sessionStorage.getDownloadStatus = 'true'
+                            if (this.exportTimes && Number(this.exportTimes) > 7) {
+                                this.$message.warning(this.$t('publics.warnings.readyToExport'));
+                                setTimeout(() => {
+                                    let link = document.createElement('a');
+                                    link.style.display = 'none';
+                                    link.href = res;
+                                    link.target = 'blank'
+                                    document.body.appendChild(link);
+                                    link.click();
+                                    this.haveDataDwonload = false;
+                                    if (this.exportSignalrConnection) {
+
+                                        this.exportSignalrConnection.stop()
+                                    }
+                                    this.exportSignalrConnection = null
+                                    this.getExportCommand = false
+
+                                }, 2000);
+                                this.alreadyExport = true
+                            } else {
+                                let link = document.createElement('a');
+                                link.style.display = 'none';
+                                link.target = 'blank'
+                                link.href = res;
+                                document.body.appendChild(link);
+                                link.click();
+                                this.haveDataDwonload = false
+                                this.alreadyExport = true
+                                if (this.exportSignalrConnection) {
+
+                                    this.exportSignalrConnection.stop()
+                                }
+                                this.exportSignalrConnection = null
+                                this.getExportCommand = false
+                            }
+
+                            if (!existIframe) {
+                                this.exportCurveLoading = false
+                            } else {
+                                if (document.getElementById('jumpIframe')) {
+                                    document.getElementById('jumpIframe').contentWindow.postMessage({ exportYes: true }, '*')
+                                } else {
+                                    let arr = Array.from(document.getElementsByTagName('iframe'));
+                                    arr.forEach(item => {
+                                        item.contentWindow.postMessage({ exportYes: true }, '*')
+                                    })
+                                }
+                            }
+                            window.clearInterval(this.exportTimer);
+                            this.exportTimer = null;
+                            this.exportTimes = 0;
+
+                        }
+                    });
+
+                    this.exportSignalrConnection.off('downloadError');
+                    this.exportSignalrConnection.on('downloadError', res => {
+                        if (res) {
+                            this.$message.warning(res);
+                            sessionStorage.getDownloadStatus = 'error'
+                        }
+                    });
+                }
+                //  else {
+                //     this.$message.warning(this.$t('login.framePro.tips.historyData'))
+                // }
+
+            }
+        },
+        exportCurves (data) {
+            this.$api.exportCurve(data).then(res => {
+                if (res.data.code === 200) {
+                    this.alreadyExport = false
+                    this.haveDataDwonload = true;
+                    if (this.exportTimer) {
+                        window.clearInterval(this.exportTimer);
+                        this.exportTimer = null;
+                    }
+                    this.exportTimer = setInterval(() => {
+                        this.exportTimes = Number(this.exportTimes) + 1;
+                        if (this.exportTimes == 5 && this.$route.path.indexOf('equipListsIot') != -1 && !this.alreadyExport) {
+                            this.$message.warning(this.$t('publics.warnings.processing'));
+                        }
+                    }, 1000);
+
+                } else {
+                    this.$message.error(res.data.message, res)
+                }
+            }).catch(err => {
+                this.$message.error(err.data, err)
+                console.log(err);
+            })
+        }
+    },
+}

package/ganwei-iotcenter-index-6.2.3/packages/ganwei-iotcenter-index/src/utils/setStorage.js

@@ -0,0 +1,5 @@
+export const setTheme = (theme) => {
+  localStorage.setItem('theme', theme);
+  sessionStorage.setItem('theme', theme);
+  window.document.documentElement.setAttribute('data-theme', theme)
+}

package/ganwei-iotcenter-index-6.2.3/packages/ganwei-iotcenter-index/src/utils/sm4Encrypt.js

@@ -0,0 +1,200 @@
+import CryptoJS from 'crypto-js'
+import { sm4 } from 'sm-crypto'
+
+function mathHelper(a, b) {
+  return ((a * 7 + b * 3) % 256) ^ 0x5A
+}
+
+function strHelper(s, offset) {
+  return s.split('').map(c => String.fromCharCode(c.charCodeAt(0) + offset)).join('')
+}
+
+function decodeKey(encodedParts) {
+  try {
+    const parts = encodedParts.split('|')
+    const reversed = parts.reverse()
+    const decoded = reversed.map((part, idx) => {
+      const dummy = mathHelper(idx, part.length)
+      const decoded = atob(part)
+      return decoded.split('').map(c => String.fromCharCode(c.charCodeAt(0) - 1)).join('')
+    })
+    return decoded.join('')
+  } catch (e) {
+    return ''
+  }
+}
+
+function charMapDecode(str) {
+  const fakeMap = {
+    'X': 'Y', 'Y': 'Z', 'Z': 'A',
+    'x': 'y', 'y': 'z', 'z': 'a'
+  }
+  const dummy = Object.keys(fakeMap).length
+  const dummy2 = strHelper('dummy', -dummy)
+  return str
+}
+
+const FAKE_KEY_1 = 'TestKey12345678'
+const FAKE_KEY_2 = 'DevKey2024Test'
+const FAKE_IV_1 = 'TestIV12345678'
+const FAKE_KEY_3 = atob('R2Fud2Vpc29mdDIwMjQhIQ==')
+const FAKE_IV_2 = atob('SW9UQDIwMjQjRW5lcmd5JA==')
+
+function getDynamicOffset() {
+  const now = Date.now()
+  const offset = (now % 1000) - 500
+  return offset
+}
+
+function fakeKeyCalculation() {
+  const offset = getDynamicOffset()
+  const fake = strHelper(FAKE_KEY_1, offset)
+  const dummy = mathHelper(fake.length, offset)
+  return fake.substring(0, 16)
+}
+
+const _unused_fake_key = fakeKeyCalculation()
+
+const SM4_KEY_STRING = charMapDecode(decodeKey('MzUiIg==|Z3UzMQ==|Zmp0cA==|SGJveA=='))
+const SM4_IV_STRING = charMapDecode(decodeKey('c2h6JQ==|JEZvZg==|MzEzNQ==|SnBVQQ=='))
+
+const KEY_LENGTH = 16 // SM4 密钥长度是 16 字节
+
+/**
+ * 按照后端逻辑处理密钥：将字符串转换为 16 字节的密钥
+ * 1. 如果正好 16 字节，直接使用
+ * 2. 如果小于 16 字节，使用 SHA256 哈希后取前 16 字节
+ * 3. 如果大于 16 字节，截取前 16 字节
+ * @param {string} keyString - 密钥字符串
+ * @returns {Uint8Array} 16 字节的密钥数组
+ */
+function getKeyBytes(keyString) {
+  const encoder = new TextEncoder()
+  const keyBytes = encoder.encode(keyString)
+
+  let finalKeyBytes
+
+  if (keyBytes.length === KEY_LENGTH) {
+    // 正好 16 字节，直接使用
+    finalKeyBytes = keyBytes
+  } else if (keyBytes.length < KEY_LENGTH) {
+    // 小于 16 字节，使用 SHA256 哈希后取前 16 字节
+    // 注意：后端是对 keyBytes（字节数组）进行哈希，不是对字符串
+    const wordArray = CryptoJS.lib.WordArray.create(keyBytes)
+    const hash = CryptoJS.SHA256(wordArray)
+    // 将 WordArray 转换为 Uint8Array，取前 16 字节
+    const hashWords = hash.words
+    const hashBytes = new Uint8Array(KEY_LENGTH)
+    let byteIndex = 0
+    for (let i = 0; i < hashWords.length && byteIndex < KEY_LENGTH; i++) {
+      const word = hashWords[i]
+      for (let j = 0; j < 4 && byteIndex < KEY_LENGTH; j++) {
+        hashBytes[byteIndex++] = (word >>> (24 - j * 8)) & 0xff
+      }
+    }
+    finalKeyBytes = hashBytes
+  } else {
+    // 大于 16 字节，截取前 16 字节
+    finalKeyBytes = keyBytes.slice(0, KEY_LENGTH)
+  }
+
+  return finalKeyBytes
+}
+
+/**
+ * 将字符串 IV 转换为 16 字节的 IV 数组
+ * 按照后端逻辑：如果长度不足，重复填充；如果超过，截取前16字节
+ * @param {string} ivString - IV 字符串
+ * @returns {Uint8Array} 16 字节的 IV 数组
+ */
+function getIVBytes(ivString) {
+  if (!ivString) {
+    // 如果未提供IV，返回全零IV（16字节）
+    return new Uint8Array(KEY_LENGTH)
+  }
+
+  const encoder = new TextEncoder()
+  const ivBytes = encoder.encode(ivString)
+  const result = new Uint8Array(KEY_LENGTH)
+
+  if (ivBytes.length >= KEY_LENGTH) {
+    // 如果长度大于等于16字节，截取前16字节
+    for (let i = 0; i < KEY_LENGTH; i++) {
+      result[i] = ivBytes[i]
+    }
+  } else {
+    // 如果长度小于16字节，重复填充
+    for (let i = 0; i < KEY_LENGTH; i++) {
+      result[i] = ivBytes[i % ivBytes.length]
+    }
+  }
+
+  return result
+}
+
+// 将字节数组转换为 sm-crypto 可用的格式（普通数组）
+function bytesToKeyFormat(bytes) {
+  return Array.from(bytes)
+}
+
+// 初始化密钥和IV
+const SM4_KEY_BYTES = getKeyBytes(SM4_KEY_STRING)
+const SM4_IV_BYTES = getIVBytes(SM4_IV_STRING)
+const SM4_KEY_FORMATS = bytesToKeyFormat(SM4_KEY_BYTES)
+const SM4_IV_FORMATS = bytesToKeyFormat(SM4_IV_BYTES)
+
+/**
+ * SM4 CBC 模式加密（与后端 C# 实现完全一致）
+ * @param {string} plainText - 需要加密的明文
+ * @returns {string} Base64编码的密文
+ */
+export function sm4Encrypt(plainText) {
+  console.log("原始加密字符:" + plainText)
+  if (!plainText) {
+    throw new Error('明文不能为空')
+  }
+
+  // 使用字节数组格式的 key 和 iv（与后端一致）
+  // sm-crypto 使用 mode: 'cbc' 表示 CBC 模式
+  const hexResult = sm4.encrypt(plainText, SM4_KEY_FORMATS, {
+    mode: 'cbc',
+    iv: SM4_IV_FORMATS
+  })
+
+  // sm-crypto 返回的是 hex 字符串，需要转换为 Base64（后端返回 Base64）
+  // 将 hex 字符串转换为字节数组，再转换为 Base64
+  const hexBytes = []
+  for (let i = 0; i < hexResult.length; i += 2) {
+    hexBytes.push(parseInt(hexResult.substr(i, 2), 16))
+  }
+
+  // 使用 btoa 转换为 Base64（浏览器环境）
+  const binaryString = String.fromCharCode.apply(null, hexBytes)
+  const base64Result = btoa(binaryString)
+
+  return base64Result
+}
+
+/**
+ * SM4 CBC 模式解密
+ * @param {string} encryptedText - Base64编码的密文
+ * @returns {string} 解密后的明文
+ */
+export function sm4Decrypt(encryptedText) {
+  if (!encryptedText) {
+    throw new Error('密文不能为空')
+  }
+
+  // 将 Base64 转换为 hex 字符串（sm-crypto 需要 hex 格式）
+  const base64Bytes = atob(encryptedText)
+  const hexString = Array.from(base64Bytes)
+    .map(char => char.charCodeAt(0).toString(16).padStart(2, '0'))
+    .join('')
+
+  // 使用与加密相同的格式
+  return sm4.decrypt(hexString, SM4_KEY_FORMATS, {
+    mode: 'cbc',
+    iv: SM4_IV_FORMATS
+  })
+}
+

package/ganwei-iotcenter-index-6.2.3/packages/ganwei-iotcenter-index/src/views/Index.vue

@@ -0,0 +1,118 @@
+<template>
+    <el-container id="index" :class="{ onlyContent: onlyContent, isHideMenu: isHideMenu, isHideHead: isHideHead }">
+        <div class="topIndexHeader"></div>
+        <!-- 左侧区域 -->
+        <indexLeftContent :navTopActive="navTopActive" :loading="loading" :allMenus="allMenus" />
+
+        <!-- 右侧区域 -->
+        <indexRightContent v-model="navTopActive" :allMenus="allMenus"
+            v-show="Object.keys(routesToPackageId).length > 0" />
+
+    </el-container>
+</template>
+
+<script>
+import index from "./index.js"
+export default index;
+</script>
+
+<style lang="scss" scoped>
+#index {
+    height: 100%;
+    background-color: var(--frame-main-background) !important;
+
+    .el-icon svg {
+        height: 1em;
+        width: 1em;
+    }
+
+    // 主内容
+    >.el-container {
+        flex: 1;
+
+        // 面包屑导航
+        .breadcrumb {
+            width: 100%;
+            height: 48px;
+            padding-left: 16px;
+            background-color: var(--frame-main-background-1);
+
+            >div {
+                height: 100%;
+                line-height: 48px;
+                font-size: 14px;
+            }
+
+            ::v-deep .el-breadcrumb {
+
+                .is-link,
+                span {
+                    font-weight: 500;
+                    color: var(--frame-main-color);
+                }
+            }
+        }
+
+        // 页面内容组件
+        .el-main {
+            padding: 0;
+            height: 100%;
+            position: relative;
+        }
+    }
+}
+
+.onlyContent {
+
+    .topIndexHeader,
+    .noIsCollapse {
+        display: none;
+    }
+
+    ::v-deep .el-container {
+
+        .indexHeader,
+        .el-tabs__header {
+            display: none;
+        }
+
+        .indexBottomContent {
+            height: 100%;
+        }
+
+        .container-main .el-tabs .el-tabs__content {
+            height: 100%;
+        }
+    }
+}
+
+.isHideMenu {
+    .noIsCollapse {
+        display: none;
+    }
+}
+
+.isHideHead {
+    .topIndexHeader {
+        display: none;
+    }
+
+    ::v-deep .el-container {
+        .indexHeader {
+            display: none;
+        }
+
+        .indexBottomContent {
+            height: 100%;
+
+            .el-tabs__header {
+                display: none;
+            }
+        }
+
+        .container-main .el-tabs .el-tabs__content {
+            height: 100%;
+        }
+    }
+}
+</style>