• 讲讲项目里的仪表盘编辑器（二）

    应用场景

            正常来说，编辑器应用场景应该包括：

    •         编辑器-预览
    •         编辑器
    •         最终运行时    

    怎么去设计

            

            上一篇推文，我们已经大概了解了编辑器场景。接下来，我们来看预览时的设计

    编辑器-预览

            点击预览按钮，执行以下逻辑：

    1.   /** @name 预览 **/
    2.   async handlePreview() {
    3.     ...
    4.     // 打开抽屉组件，并往里面放置运行时模块
    5.     createDrawer(
    6.       h => h(DashboardRuntime, { props: { dashboard: this.form } }),
    7.       {
    8.         title: '预览仪表盘',
    9.         width: 'calc(100vw - 200px)',
    10.       },
    11.     );
    12.   }

            也就是说：

            所以我们直接关注运行时表现

    运行时设计

    1. <template>
    2.   <HabitContext :habitKey="habitKey" @init="habitContextInit">
    3.     
    4.     <a-spin v-if="loading" />
    5.     <div
    6.       v-else
    7.       :style="styleCSSVariable"
    8.     >
    9.       <background :background="themeBackground" :class="$style.background">
    10.           <grid-layout v-bind="layoutProps">
    11.             <dashboard-item
    12.               v-for="field in fields"
    13.               :key="field.pkId"
    14.             />
    15.           grid-layout>
    16.       background>
    17.     div>
    18.   HabitContext>
    19. template>

             这里套了一层HabitContext框架，是用来应用和记录用户习惯的（后面讲）。a-spin是加载层。紧接着和设计器差不多，局部变量样式集里面套了个背景框架和grid-layout布局。

            我们再看看dashboard-item的实现：

    1. <template>
    2.   <grid-item
    3.     v-bind="layout"
    4.     static
    5.   >
    6.     ...
    7.   grid-item>
    8. template>

             这里通过v-bind动态传入grid-item的属性（也就是拣选出来的x/y/w/h这些）。同时用static固定gird-item，使其无法缩放、拖动、被其他元素影响。

    1. <template>
    2.   <grid-item
    3.     v-bind="layout"
    4.     static
    5.   >
    6.     <div
    7.       v-if="showChart"
    8.     >
    9.      ...
    10.     div>
    11.     
    12.     <div
    13.       v-else
    14.       style="height: 100%; width: 100%; display: flex; flex-direction: column"
    15.     >
    16.       <div>
    17.         <span :style="titleCss">
    18.           {{ field.name }}
    19.         span>
    20.       div>
    21.     div>
    22.   grid-item>
    23. template>

            这里就是简单的做了一个占位

    1. <template>
    2.   <grid-item
    3.     v-bind="layout"
    4.     static
    5.   >
    6.     <div
    7.       v-if="showChart"
    8.     >
    9.       <div :class="$style.action">
    10.         <template v-for="action in actions">
    11.           <a-tooltip
    12.             :key="action.key"
    13.             placement="bottom"
    14.             :mouseLeaveDelay="0"
    15.             :title="action.name"
    16.           >
    17.             <x-icon
    18.               :type="action.icon"
    19.               @click="execAction(action)"
    20.             />
    21.           a-tooltip>
    22.         template>
    23.       div>
    24.       <component
    25.         :is="component"
    26.         :field="field"
    27.       />
    28.     div>
    29.     
    30.     <div
    31.       v-else
    32.       style="height: 100%; width: 100%; display: flex; flex-direction: column"
    33.     >
    34.       <div>
    35.         <span :style="titleCss">
    36.           {{ field.name }}
    37.         span>
    38.       div>
    39.     div>
    40.   grid-item>
    41. template>

            浮层按钮还有具体的图表组件

    数据流设计

            到这里，我们已经看完了编辑器功能的大概设计。接下来该写写这套系统最核心的部分，数据流设计了。

            创建一个仪表盘编辑器

            点下新增按钮后，我们传入一些系统参数【应用id，功能类别等等，在这里我们并不需要关注】储存新建仪表盘在系统的位置和属性。

            在接口储存完这些系统信息后，跳转到仪表盘页面进行最为关键的仪表盘初始化数据生成。

    1. async handleAddForm(category) {
    2.     // 弹窗让填写名称、图标等基础信息
    3.     const result = await GroupForm.createModal(
    4.       {
    5.         data: { parentId: this.groupId, appId: this.appId, category },
    6.       },
    7.       {
    8.         title: this.getCategoryName(category),
    9.         width: '427px',
    10.       },
    11.     );
    12.     // 调用接口保存
    13.     const formId = await add(result);
    14.     this.$message.success(this.$t('common.tips.add'));
    15.     // 保存完毕后跳转到页面
    16.     switch (category) {
    17.       case FormCategoryType.DASHBOARD:
    18.         return this.$router.push(`/dashboard-design/${formId}`);
    19.         ...
    20.       default:
    21.         return this.$router.push(`/form-design/${formId}/form`);
    22.     }
    23.   }

            这里是通过vue-router进行跳转。这里也简单贴出路由代码

    1. import DashboardDesign from '@/views/dashboard-design';
    2.  
    3. const DashboardDesignRoutes = [
    4.   {
    5.     path: '/dashboard-design/:id',
    6.     component: DashboardDesign,
    7.   },
    8.   ...
    9. ];
    10.  
    11. export default DashboardDesignRoutes;

            到这里结束，一个仪表盘编辑器已经创建完毕了。它只存储了系统数据，没有仪表盘的初始数据。而当我们进入仪表盘编辑器页面的时候，完成有效编辑之后，才会以正式数据存储下来。

            当然这里指的是前端数据，后端还是会根据我们穿进去的系统参数生成一份默认的接口向的仪表盘数据模板（比如默认权限、默认刷新时间上面的）

            进入仪表盘编辑器页面 

            先通过后端接口，拿到当前仪表盘编辑器id的接口数据

    1. @formDesignModule.Action init;
    2. async created() {
    3.   ...
    4.   await this.init(this.formId).then(() => {
    5.       ...
    6.   }
    7. }

            大概长这样，记录一些系统信息或默认属性 。这里的init是vuex的action操作。为了是把数据保存到前端本地。更多关于本项目的vuex方法请看我另外一篇文章的介绍

    讲讲项目里的状态存储器vuex_AI3D_WebEngineer的博客-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/weixin_42274805/article/details/133237271?spm=1001.2014.3001.5501

             看看这个init的actions做了什么？

    1. actions: {
    2.     async init({ commit }, formId) {
    3.         const form = await getFormData(formId);
    4.         commit('saveForm', form);
    5.     }
    6. }
    7. mutations: {
    8.     saveForm(state, data) {
    9.       state.form = data;
    10.       ...
    11.       state.loading = false;
    12.       state.changed = false;
    13.     }
    14. }

              这里是通过调用接口获取当前仪表盘的数据，并把它存到当前的formDesignModule，也就是formDesign这个命名空间的仓库里。

            

            仪表盘编辑页面的状态管理器

            我们刚刚看到了代码，在编辑页面created里我们执行了init。其实就是非显示地获取数据。吧获取数据的过程从页面隐式地放到了状态管理器里的actions里面。并通过state返回关注的数据。这样子无论我们在仪表盘功能里怎么去跳转页面，都不需要再重新调用接口了，而是直接从仓库里拿。

    1.   @formDesignModule.State form;
    2.   @formDesignModule.Action init;
    3.   @formDesignModule.State loading;
    4.   @formDesignModule.State selectedField;
    5.   @formDesignModule.Getter fields;
    6.   @formDesignModule.Mutation updateSelectedField;
    7.   @formDesignModule.Mutation selectField;
    8.   @formDesignModule.Mutation updateSetting;
    9.   @formDesignModule.Mutation saveForm;
    10.   @formDesignModule.Mutation updateDashboardConfig;
    11.   @formDesignModule.Action save;

            大概有这些属性和方法来完成编辑器的功能实现。看看就行了。紧接着我们来讲其中一些实现

            点击添加组件到仪表盘

            有两种添加方法：

            ① 点击组件按钮添加

            ② 拖拽组件添加

            点击组件

    1.  
    2. handleClickAdd() {
    3.     ...
    4.     // 初始化layout
    5.     const layout = getDashboardLayoutByType(type);
    6.     const layoutList = ensureArray(this.$refs.container.layout);
    7.     layout.x = (layoutList.length * 2) % 60;
    8.     layout.y = layoutList.length + 60;
    9.     field.widget.layout = layout;
    10.  
    11.     // 初始化风格
    12.     field = this.initFieldStyle(field);
    13. }

            getDashboardLayoutByType是根据你点击的组件生成默认的组件layout数据。比如图片组件定义的默认layout是：

    1. export function getDashboardLayoutByType(type) {
    2.   const layout = getDashboardControlMeta(type, 'layout');
    3.   return { x: 0, y: 0, ...(typeof layout === 'function' ? layout() : layout) };
    4. }

             这时返回了一个初始化的layout即{w:30,h:15,minH:7,x:0,y:0}。

         const layoutList = ensureArray(this.$refs.container.layout);这里是直接获取设计器组件里面的layout属性（它的data值）。这个layout目前是个空数组（因为是新建的仪表盘，里面没有组件）。

    1. layout.x = (layoutList.length * 2) % 60;
    2. layout.y = layoutList.length + 60;
    3. field.widget.layout = layout;
    4.  
    5.  
    6. // 更新布局
    7. this.$refs.container.syncLayout();

            很好理解啦，我们吧初始化layout的横纵坐标调整到它应该在的位置上，并吧这个调整过的layout信息存储到新增组件的布局属性里(替换掉初始化layout)。讲讲为什么这么计算：        

            可以看到实例中这两个组件的x/y值并不像上面这个逻辑计算出来的。 如果按照上面那个逻辑计算出来，则应该是{x:0,y:60...}和{x:2,y:61...}。其实这个计算过程是为了保证第n+1个组件的x和y一定大于第n个。从而避免重叠出错，而至于精准的layout数据，是借助vue-layout-grid插件行自适应生成。具体怎么做，我们看代码：

    1.   /** @name 同步layout **/
    2.   syncLayout() {
    3.     this.layout = ensureArray(this.fields).map(field => ({
    4.       ...field.widget.layout,
    5.       i: field.pkId,
    6.     }));
    7.   }
    1. <grid-layout
    2.      ref="layout"
    3.      :class="$style.layout"
    4.      :layout.sync="layout"
    5. >
    6.     ...
    7. grid-layout>

            很多人看到这里就要骂了，骗人，你这不是啥都没干？只是把layout重新赋值了一遍。让我们改下代码看看：

    1.   /** @name 同步layout **/
    2.   async syncLayout() {
    3.     this.layout = ensureArray(this.fields).map(field => ({
    4.       ...field.widget.layout,
    5.       i: field.pkId,
    6.     }));
    7.     console.log(this.layout);
    8.     await this.$nextTick();
    9.     console.log(this.layout);
    10.   }

            第一个输出：

    1. [
    2.     {
    3.             h: 10,w: 12,x: 0,y: 0
    4.  
    5.     },
    6.     {
    7.             h: 20,w: 60,x: 2,y: 61
    8.      }   
    9. ]

            第二个输出：

    1. [
    2. {
    3.    h: 10,w: 12,x: 0,y: 0,i: "39b19b29-c8ef-4fd3-8604-d7e168196ae6"
    4. },
    5. {
    6.    h: 20,w: 60,x: 2,y: 10,i: "5d684834-26bd-4d35-b7ff-36d8de9d903e"
    7. },
    8. ]

            可以看到此时this.layout已经变了。这是因为已经自适应了布局。

            由此，我们的保存仪表盘布局方法也呼之欲出了：

    1. save() {
    2.      // 拿到同步后的this.layout
    3.      const layout = this.$refs.container.layout;
    4.     // 生成组件id和layout信息的映射表
    5.     const layoutMap = generateMap(layout, 'i', item =>
    6.       pick(item, 'x', 'y', 'w', 'h'),
    7.     );
    8.     ...
    9. }

            先看到这里，这里要生成一份类似于:'amdous123623': {w:10,h:20,x:0,y:0...}这样的映射表，是整个仪表盘布局的储存并不是直接存储类似于girdLayout的这种数组，而是由一个个组件自身的layout属性（甚至无视组件排序）拣选出来生成this.layout。也就是说仪表盘的存储结构为Array这样的。

    1. save(fields) {
    2.     const layout = this.$refs.container.layout;
    3.     const layoutMap = generateMap(layout, 'i', item =>
    4.       pick(item, 'x', 'y', 'w', 'h'),
    5.     );
    6.     this.privateUpdateFields(
    7.       (fields || this.fields).map(field => {
    8.         if (!layoutMap[field.pkId]) return field;
    9.         return {
    10.           ...field,
    11.           widget: {
    12.             ...field.widget,
    13.             layout:{
    14.                   ...field.widget.layout,
    15.                   ...layoutMap[field.pkId],
    16.                 }
    17.           },
    18.         };
    19.       }),
    20.     );
    21.   }

            拖拽添加组件到仪表盘

            前面我们已经讲了拖拽添加组件的思路，和预防错位或重叠的处理。现在来讲讲具体代码实现。

            之前讲过了，在control-list.vue也就是左边的组件列表拖拽出组件，触发@dragstart方法，同时往设计器里传入dragType。设计器里根据dragType找对对应的组件初始化layout

    1. @Watch('dragType')
    2.   handleDragTypeChange(type) {
    3.     this.isInChildCom = false; // 重新拖动需要重置
    4.     if (type) {
    5.       this.dragLayout = {
    6.         i: 'drag',
    7.         ...getDashboardLayoutByType(type),
    8.       };
    9.     } else {
    10.       this.dragLayout = null;
    11.     }
    12.   }

            假设此时拖拽元素已经拖拽到在设计器（也就是gird-layout）上面。触发@dragover.native="handleDrag"

    1. handleDrag(ev) {
    2.     if (this.isInChildCom) return; // 进入子元素范围则无需触发
    3.     ev.preventDefault();
    4.     this._handleDrag(ev);
    5. }
    6. @throttle(100)
    7. _handleDrag(ev) {
    8.     if (!this.dragType || !this.$el) return;
    9.     if (
    10.       this.dragContext.clientX === ev.clientX &&
    11.       this.dragContext.clientY === ev.clientY
    12.     )
    13.       return;
    14.     this.dragContext.clientX = ev.clientX;
    15.     this.dragContext.clientY = ev.clientY;
    16.     this.updateInside(ev);
    17.     this.updateDrag(ev);
    18. }

             _handleDrag每100秒记录一次拖拽元素的位置，当拖拽元素发生变动时，更新设计器视图。

    1.  updateInside(ev) {
    2.     if (!this.dragType || !this.$el) return;
    3.     const rect = this.$el.getBoundingClientRect();
    4.     const errorRate = 10;
    5.     const inside =
    6.       ev.clientX > rect.left + errorRate &&
    7.       ev.clientX < rect.right - errorRate &&
    8.       ev.clientY > rect.top + errorRate &&
    9.       ev.clientY < rect.bottom - errorRate;
    10.     if (inside && this.dragLayoutIndex === -1) {
    11.       this.layout.push(this.dragLayout);
    12.     }
    13.     if (!inside && this.dragLayoutIndex !== -1) {
    14.       this.layout.splice(this.dragLayoutIndex, 1);
    15.     }
    16.   }

            这里是获取设计器边界的位置属性（errorRate为误差范围，你可以理解为设计器有padding），判断拖拽元素是否在设计器边界内，如果是，就往layout里面加入它（重复则不加入），如果已经超出设计器，则移除。

             我们往编辑器拖拽移动，可以看到这个虚线框会一直跟随变动，可能你们就要问了，上面的代码里dragLayout一但被添加进layout，那么dragLayoutIndex就不会是-1，也就是说layout里面的dragLayout不会改变（x或y）。那这个虚框是怎么还在移动的？

            其实啊，这个虚框并不由layout里的数据决定。而是由vue-grid-layout这个插件负责渲染的。在拖动的时候，this.layout是不会变的。我们只需要每100毫秒记录一次拖拽元素的当前位置this.dragLayout，直到放置生效之后，用this.dragLayout去覆盖this.layout里面的那个被拖动元素。

             所以updateDrag是为了更新this.dragLayout。通过clientY/X换算成vue-grid-layout的x,y

    1.  const dragRef = this.getDragRef();
    2.     if (!this.dragType || !dragRef) return;
    3.     const rect = this.$el.getBoundingClientRect();
    4.     const dragging = {
    5.       top: this.dragContext.clientY - rect.top,
    6.       left: this.dragContext.clientX - rect.left,
    7.     };
    8.     dragRef.dragging = dragging;
    9.     const newLayout = dragRef.calcXY(dragging.top, dragging.left);
    10.     this.dragLayout.x = newLayout.x;
    11.     this.dragLayout.y = newLayout.y;
    12.   }
    13. getDragRef() {
    14.     // vue-grid-layout默认在$children内存在一个组件实例了, 其实每次拖动直接取最后一个实例应该就可以了
    15.     return this.$refs.layout.$children[this.$refs.layout.$children.length - 1];
    16. }

            当我们放手时，触发 组件上的drop事件，我们来看看@drop.native="handleDrop"的handleDrop方法

    1.  async handleDrop() {
    2.     if (this.isInChildCom) return; // 进入子元素范围则无需触发
    3.     if (!this.dragType) return;
    4.     ...
    5. }

            重叠和空类型直接当做无效动作处理

    1.  async handleDrop() {
    2.     if (this.isInChildCom) return; // 进入子元素范围则无需触发
    3.     if (!this.dragType) return;
    4.     try {...}
    5.     catch (e) {
    6.       this.layout.splice(this.dragLayoutIndex, 1);
    7.       throw e;
    8.     }
    9.     finally {
    10.         this.$emit('update:dragType', null);
    11.     }
    12. }

             这个try catch我们之前已经讲过了。try里面的逻辑也很简单

    1. try {
    2.      let field = createDashboardField(this.dragType);
    3.      ...
    4.      field.widget.layout = pick(this.dragLayout, 'x', 'y', 'w', 'h');
    5.      ...
    6.      // 更新布局
    7.       this.layout.splice(this.dragLayoutIndex, 1, {
    8.         ...field.widget.layout,
    9.         i: field.pkId,
    10.       });
    11.      // 提交数据存储
    12.       this.$emit('add', field);
    13. }

            拖拽移动组件位置

             由插件处理，会自动更新到this.layout

            放大缩小组件

            由插件处理，会自动更新到this.layout

            删除组件

    1. async handleDelete(pkId) {
    2.     const cloneFields = deepClone(this.fields);
    3.     // 摘除删除的组件数据
    4.     this.updateFields(
    5.       cloneFields.filter(field => {
    6.         return field.pkId !== pkId;
    7.       }),
    8.     );
    9.     await this.$nextTick();
    10.     this.$refs.container.syncLayout();
    11. }
    1.  /** @name 同步layout **/
    2.   async syncLayout() {
    3.     this.layout = ensureArray(this.fields).map(field => ({
    4.       ...field.widget.layout,
    5.       i: field.pkId,
    6.     }));
    7.     await this.$nextTick();
    8.   }

            额外讲一下选中组件对组件进行修改

            当我们选中组件的时候，需要在vuex里登记一下当前的选中状态

    1. <grid-item
    2.     v-for="layoutItem in layout"
    3.     ...
    4.     @mousedown.native="handlePointerDown"
    5.     @mouseup.native="handlePointerUp($event, layoutItem.i)"
    6. >
    7.     ...
    8. grid-item>

          加了一些位置判断，以防这个组件位置出错或已经不在布局里

    1.   /** @name 鼠标设备按下与抬起事件处理 **/
    2.   _pointerContext = null;
    3.   handlePointerDown(ev) {
    4.     this._pointerContext = {
    5.       x: ev.clientX,
    6.       y: ev.clientY,
    7.     };
    8.   }
    9.   handlePointerUp(ev, pkId) {
    10.     if (!this._pointerContext || !this.fieldMap[pkId]) return;
    11.     const { x, y } = this._pointerContext;
    12.     if (x !== ev.clientX || y !== ev.clientY) return;
    13.     this.selectField(this.fieldMap[pkId]);
    14.   }
    15.  @formDesignModule.Mutation selectField;

            再来看看仓库的代码

    1.     // fromdesign.js
    2.     selectField(state, field) {
    3.       state.selectedField = field;
    4.     },

             如果当前组件的内容或属性发送变更，则执行

     commit('selectField', newField);

            

            

  • 相关阅读:
    git常见 操作仓库指令
    深入UDP收发数据(上)
    金蝶OA server_file 目录遍历漏洞
    38.移动端常用事件
    解决Visual studio 未能正确加载...包问题
    【优化算法】多目标晶体结构算法算法（Matlab代码实现）
    Python+Django前后端分离
    【红外与可见光图像融合】离散平稳小波变换域中基于离散余弦变换和局部空间频率的红外与视觉图像融合方法（Matlab代码实现）
    Vue开发中常见问题记录
    驱动开发：内核枚举PspCidTable句柄表
  • 原文地址：https://blog.csdn.net/weixin_42274805/article/details/133204351