1、最近开发的pim_vue

老年人随访记录 组件引用参照 数据采集

父组件index.vue

这个姓名下拉的table样式在公共的index.less中

index.less全局样式在App.vue中全局引入

table增删参照妇幼的儿童保健下的托幼机构登记 保存成功后，需要清空父组件传来的removeRecordId，组件直接的事件

2、pim_vue高血压和糖尿病的

这里以高血压为例，糖尿病的跟高血压一样的

vue项目中增删查改整个流程梳理

1、获取列表数据（路由进来和下砖返回时需要获取）

index.vue获取列表数据

<template>
  <div class="hlistContent clearfix">
    <el-container class="layout_container">
      <el-header>
        <div class="clearfix btn_header">
          <ul class="clearfix">
            <li>健康档案号：<el-input
              v-model="searchCriteria.healthNo"
              placeholder="请输入"
              style="width: 60%"/>
            </li>
            <li style="width: 20%">姓名：<el-input
              v-model="searchCriteria.name"
              placeholder="请输入"
              style="width: 75%"/>
            </li>
            <li style="width: 43%">上次随访时间：
              <el-date-picker
                v-model="searchCriteria.lastTimeStart"
                :clearable="true"
                type="date"
                placeholder="选择日期"
                value-format="yyyy-MM-dd"/>
              <span> - </span>
              <el-date-picker
                v-model="searchCriteria.lastTimeEnd"
                :clearable="true"
                type="date"
                placeholder="选择日期"
                value-format="yyyy-MM-dd"/>
            </li>
            <li style="float: right;width: 10%">
              <el-button
                type="primary"
                icon="el-icon-search"
                style="float: right;margin-right: 20px"
                @click="queryTableData()">查询</el-button>
            </li>
          </ul>
        </div>
      </el-header>
      <div style="background-color: #F0F2F5">
        <div class="addStyle" style="margin-right: 20px" @click="addRecord"><i class="el-icon-folder-add"/>新增随访记录</div>
        <div class="addStyle" @click="exportd"><i class="el-icon-upload2"/>导出</div>
      </div>
      <el-main>
        <el-table
          ref="SuccessmultipleTable"
          :data="tableData"
          :cell-style="{textAlign: 'center'}"
          :header-cell-style="{textAlign: 'center', backgroundColor: '#f2f2f2'}"
          border
          height="100%"
          highlight-current-row
          style="width: 100%"
          @current-change="rowClick"
          @row-dblclick="rowDblclick">
          <el-table-column
            v-for="item in tableTitle"
            :key="item.id"
            :label="item.name"
            :prop="item.prop"
            :fixed="item.fixed"
            :width="item.width"
            :align="item.align"
            show-overflow-tooltip />
          <el-table-column fixed="right" width="160" label="操作">
            <template slot-scope="scope">
              <el-button type="text" style="color: #305CBC" @click="viewRecords(scope.row)">查看管理卡</el-button>
              <el-button v-if="scope.row.validStatus === '1'" type="text" style="color: #305CBC" @click="stop(scope.row)">终止</el-button>
            </template>
          </el-table-column>
        </el-table>
        <el-pagination
          :current-page.sync="pageNum"
          :total="total"
          :page-sizes="[50, 100]"
          :page-size="pageSize"
          background
          layout="total, prev, pager, next, sizes, jumper"
          @size-change="handleSizeChange"
          @current-change="handleCurrentChange"/>
      </el-main>
    </el-container>
    <el-dialog
      :visible.sync="specialUsageDialog"
      :show-close="false"
      :close-on-click-modal="false"
      width="700px"
      center>
      <h5 style="font-size: 17px;margin-bottom: 20px">终止档案</h5>
      <el-form
        v-if="specialUsageDialog"
        ref="ruleForm"
        :model="terminationData"
        :rules="rules"
        label-width="110px">
        <el-row>
          <el-form-item prop="edate" label="终止管理日期">
            <el-date-picker
              v-model="terminationData.endDate"
              :disabled="true"
              type="date"
              placeholder="选择日期" />
          </el-form-item>
        </el-row>
        <el-row>
          <el-form-item label="终止理由" prop="endReason">
            <el-radio-group
              v-model="terminationData.endReason"
              @change="(label) => { label === '3' ? terminationData.endCause : terminationData.endCause = '' }">
              <el-radio label="1">死亡</el-radio>
              <el-radio label="2">迁出</el-radio>
              <el-radio label="3" style="margin-right: 10px">失访</el-radio>
              <el-input
                v-model="terminationData.endCause"
                :disabled="terminationData.endReason !== '3'"
                size="small"
                style="width: 150px;margin-right: 20px"
                placeholder="注明原因"/>
              <el-radio :label="4">拒绝</el-radio>
            </el-radio-group>
          </el-form-item>
        </el-row>
        <el-row>
          <el-form-item label="终止人员">
            <el-select v-model="terminationData.endPerson" :disabled="true" size="small">
              <el-option
                v-for="item in terminationPeopleOptions"
                :key="item.docId"
                :label="item.docName"
                :value="item.docCode"/>
            </el-select>
          </el-form-item>
        </el-row>
      </el-form>
      <div class="btn">
        <el-button type="primary" size="small" @click="saveSpecialUsage()" >确定</el-button>
        <el-button size="small" @click="cancel()" >取消</el-button>
      </div>
    </el-dialog>
  </div>
</template>

<script>
import { DEEP_CLONE } from '@/utils/constants.js'
import { TABLE_TITLE } from '@/utils/hypertensionManagement/hyperFollowupRecords.js'
import { GetdoctorData } from '@/api/DoctorMaintenance'
import { hypertensivePatientList, hypertensiveCardTermination } from '@/api/hypertensionManagement/hypertensionOverview'
import moment from 'moment'
import qs from 'qs'
export default {
  data() {
    return {
      searchCriteria: {
        healthNo: '',
        name: '',
        lastTimeStart: '',
        lastTimeEnd: ''
      },
      tableData: [],
      tableTitle: DEEP_CLONE(TABLE_TITLE.titleList),
      pageNum: 1,
      total: 0,
      pageSize: 50,
      specialUsageDialog: false,
      terminationData: {
        endDate: moment(new Date()).format('YYYY-MM-DD'),
        endReason: '',
        endCause: '',
        endPerson: ''
      },
      terminationPeopleOptions: [],
      selectedRow: {},
      rules: {
        endReason: [
          { required: true, message: '请选择终止理由', trigger: 'change' }
        ]
      },
      stopedId: ''
    }
  },
  created() {
    this.queryTableData()
  },
  activated() {
    this.queryTableData()
  },
  methods: {
    // 查询
    async queryTableData() {
      if (!!this.searchCriteria.lastTimeStart && !this.searchCriteria.lastTimeEnd) {
        this.$message.warning('请选择结束时间')
        return
      } else if (!this.searchCriteria.lastTimeStart && !!this.searchCriteria.lastTimeEnd) {
        this.$message.warning('请选择开始时间')
        return
      }
      let obj = JSON.parse(JSON.stringify(this.searchCriteria))
      obj.pageNum = this.pageNum
      obj.pageSize = this.pageSize
      let res = await hypertensivePatientList(obj)
      if (res.data.code === 200) {
        this.tableData = res.data.data.records
        this.total = res.data.data.total
        this.tableData.forEach(item => {
          item.sexName = item.sex
          if (item.validStatus === '1') {
            item.validStatusName = '有效'
          } else if (item.validStatus === '2') {
            item.validStatusName = '结束'
          }
        })
      }
      this.$nextTick(() => {
        this.$refs.SuccessmultipleTable.doLayout()
      })
    },
    // 导出
    async exportd() {
      let obj = JSON.parse(JSON.stringify(this.searchCriteria))
      obj.fileName = `高血压患者一览`
      obj.token = sessionStorage.getItem('token')
      let query = qs.stringify(obj)
      window.open(`${window.g.VUE_APP_HTTP_PHS}/hypertension/export?${query}`, '_self')
    },
    // 新增
    addRecord() {
      if (JSON.stringify(this.selectedRow) === '{}') {
        this.$message.warning('请选择一条用户信息')
        return
      }
      let obj = JSON.parse(JSON.stringify(this.selectedRow))
      obj.flag = 'add'
      this.$router.push({
        path: '/hypertensionManagement/hyperFollowupRecords',
        query: { sendData: JSON.stringify(obj) }
      })
    },
    // 单击row
    rowClick(row) {
      this.selectedRow = row
      console.log(this.selectedRow)
    },
    // 双击row
    rowDblclick(row) {
      let obj = JSON.parse(JSON.stringify(row))
      obj.flag = 'read'
      this.$router.push({
        path: '/hypertensionManagement/hyperFollowupRecords',
        query: { sendData: JSON.stringify(obj) }
      })
    },
    // 查看管理卡
    viewRecords(val) {
      let obj = JSON.parse(JSON.stringify(val))
      this.$router.push({
        path: '/hypertensionManagement/hyperManagementCard',
        query: { sendData: JSON.stringify(obj) }
      })
    },
    // 终止
    stop(val) {
      this.getDoctorData()
      this.specialUsageDialog = true
      this.terminationData.endPerson = JSON.parse(sessionStorage.getItem('user')).userNo
      this.stopedId = val.managerNo
    },
    // 分页处理当前页
    handleSizeChange(val) {
      this.pageSize = val
      this.queryTableData()
    },
    // 分页处理当前页
    handleCurrentChange(val) {
      this.pageNum = val
      this.queryTableData()
    },
    cancel() {
      this.specialUsageDialog = false
    },
    // 终止提交
    async saveSpecialUsage() {
      console.log(this.terminationData)
      this.$refs['ruleForm'].validate(async valid => {
        if (valid) {
          let obj = JSON.parse(JSON.stringify(this.terminationData))
          obj.managerNo = this.stopedId
          let res = await hypertensiveCardTermination(obj)
          if (res.data.code === 200) {
            this.$message.success('终止成功')
            this.specialUsageDialog = false
            this.queryTableData()
          }
        } else {
          console.log('error submit!!')
          return false
        }
      })
    },
    // 获取医生列表
    getDoctorData () {
      GetdoctorData({ current: 1, pageSize: 1000 })
        .then(res => {
          if (res.data.code === 200 && res.data.data !== null) {
            this.terminationPeopleOptions = res.data.data
          }
        })
    }
  }
}
</script>

<style lang="less" scoped>
.hlistContent {
  width: 100%;
  height: 100%;
  .btn_header {
    width: 100%;
    padding: 12px 0 7px 0;
    ul {
      float: left;
      width: 100%;
      li {
        float: left;
        cursor: pointer;
        padding: 5px 7px;
        border-radius: 8px;
        width: 22%;
        //&:hover {
        //  background-color: #f2f2f2;
        //}
        &:visited {
          background-color: #f2f2f2;
        }
      }
    }
    /deep/ .el-date-editor.el-input.el-input--prefix.el-input--suffix.el-date-editor--date {
      width: 30%;
    }
  }
  .addStyle {
    float: right;
    padding: 10px;
    cursor: pointer;
    i {
      color: #305CBC;
      margin-right: 5px;
    }
  }
  .el-pagination.is-background {
    text-align: right;
  }
  /deep/ .el-dialog__header {
    display: none;
  }
  /deep/ .el-dialog.el-dialog--center {
    border-radius: 10px;
  }
  .btn {
    text-align: center;
  }
}
</style>

utils/constants.js 封装的各个通用函数

// 通用常量类
import Validate from '@/utils/validate'
import moment from 'moment'
import { getLodop } from '@/utils/LodopFuncs.js'
import store from '@/store'
import blueimpMd5 from 'blueimp-md5'
import { Message } from 'element-ui'
/**
 * pim的menuCode，用于用户中心上识别系统的code
 */
export const SYSTEM_CODE = 'pim'
export const IS_FSMS_PROJECT = false // 是否是加床项目 用来区分是加床还是pim

/**
 * 叫铃服务websocket服务地址
 */
export const WEBSOCKET_API = 'ws://localhost:8540'

/**
 * 创建时的路由id识别
 */
export const CREATE_ACTION = 'create'

/**
 * 所有默认分页数量设置
 */
export const PAGE_CONFIG = {
  sizes: [10, 25, 50, 100],
  nowSize: 10
}

/**
 * API类型
 */
export const API_TYPE = {
  // pim基础服务，门诊，药房药库
  pim: 1,
  // pim 住院
  inp: 2,
  // 用户中心
  user: 3,
  // 鉴权中心
  auth: 4,
  // 公共卫生
  phs: 5,
  // oss系统
  oss: 6,
  // 康复系统
  rims: 7,
  // 抗菌药物管理系统
  adm: 8,
  // 物资管理系统
  spd: 9,
  // 医保
  mbf: 10,
  // 读卡
  card: 20
}

/**
 * 设置当前页面标题
 * @param {String} title 标题
 */
export const SET_TITLE = function (title) {
  title = title || '智赢-基层健康管理平台'
  window.document.title = title
}

/**
 * el-col规格配置，存放各个尺寸下生成的col的样式前缀，以及一行默认的col列数
 * xs: <1000；s: >1000；m: >1054；l: >1470；x: >1920
 */
export const EL_COL_CONFIG = [
  {
    symbol: 'xs',
    class: 'el-col-c-xs-',
    col: 1
  }, {
    symbol: 's',
    class: 'el-col-c-s-',
    col: 1
  }, {
    symbol: 'm',
    class: 'el-col-c-m-',
    col: 1
  }, {
    symbol: 'l',
    class: 'el-col-c-l-',
    col: 1
  }, {
    symbol: 'x',
    class: 'el-col-xl-',
    col: 1
  }]
/**
 * el-col规格配置，存放各个尺寸下生成的col的样式前缀，以及一行默认的col列数
 * xs: <1000；s: >1000；m: >1054；l: >1470；x: >1920
 */
export const EL_COL_VCONFIG = [
  {
    symbol: 'xs',
    class: 'el-col-v-xs-',
    col: 1
  }, {
    symbol: 's',
    class: 'el-col-v-s-',
    col: 1
  }, {
    symbol: 'm',
    class: 'el-col-v-m-',
    col: 1
  }, {
    symbol: 'l',
    class: 'el-col-v-l-',
    col: 1
  }, {
    symbol: 'x',
    class: 'el-col-v-xl-',
    col: 1
  }]

/**
 * el-col中列与栅格的对应关系
 * @param {Number} colNumber 每行列数
 */
export const EL_COL_GRID = function (colNumber) {
  switch (colNumber) {
    case 1:
      return 24
    case 2:
      return 12
    case 3:
      return 8
    case 4:
      return 6
    // 5列跟6列配置相同
    case 5:
      return 4
    case 6:
      return 4
    default:
      return 24
  }
}
// -----------------------------   五级联动地址 封装    -----------------------------
/**
 * 国家五级行政区codeType
 */
export const COUNTRY_AREA = ['省', '市', '县', '乡镇', '村']
/**
 * 根据当前codeType获取下一级
 * @param {*} val 当前级别的 codeType
 */
export const NEXT_AREA_CODETYPE = function (val) {
  let i = COUNTRY_AREA.findIndex(d => val === d)
  if (i + 1 < COUNTRY_AREA.length) {
    return COUNTRY_AREA[i + 1]
  }
  return null
}
/**
 * @param {*Object} getAreaApi 获取五级联动地址的接口名称
 * @param {*String} code 接口传的参数之一
 * @param {*String} codeType 接口传的参数之一
 */
export const GET_AREA = async function (getAreaApi, code = '100000', codeType = '省') {
  let queryData = {
    code: code,
    codeType
  }
  let citiesArr = null
  try {
    citiesArr = await getAreaApi(queryData)
  } catch (e) {
    console.log(e)
  }
  return citiesArr
}
/**
 * @param {*Object} cities 已经存储的地址数据
 * @param {*String} val 用户选中的地址的code
 * @param {*Object} getAreaApi 获取五级联动地址的接口名称
 */
export const HANDLE_ITEM_AREA = async function (cities, getAreaApi, val) { // 户点击某个省份时拉取该省份下的城市数据
  if (val.length >= COUNTRY_AREA.length) {
    return
  }
  let value = val[val.length - 1]
  // 获取下一级要取得codeType
  let codeType = COUNTRY_AREA[val.length]
  try {
    let res = await GET_AREA(getAreaApi, value, codeType) // res.data.data为选中的城市下面的城市数据
    let nextRes = null
    if (res.data.data.length > 0) {
      nextRes = await GET_AREA(getAreaApi, res.data.data[0].code, COUNTRY_AREA[val.length + 1]) // nextRes为选中城市的下下层数据
      if (nextRes.data.data.length > 0) {
        res.data.data.forEach(d => {
          d['children'] = []
        })
      }
    }
    // 不到最后一级则显示>箭头
    // if (val.length < COUNTRY_AREA.length - 1) { // 该方法不通用，例如选择台湾就不正确
    //   res.data.data.forEach(d => {
    //     d['children'] = []
    //     console.log('set children')
    //   })
    // }
    // console.log('handleItemChange', cities, res.data.data)
    // 赋值地区
    SET_COUNTRY_AREA(cities, DEEP_CLONE(val), res.data.data)
  } catch (err) {
    console.error(err)
  }
}
/**
 * 递归赋值地区
 */
export const SET_COUNTRY_AREA = function (cities, val, data) {
  // 每次取出一级
  let value = val[0]
  val.splice(0, 1)
  for (let item of cities) {
    // 确定级别
    if (value === item.code) {
      // 判定是否已经是最后一级，是则赋值
      if (val.length === 0) {
        item.children = data
        // if (data.length === 0) {
        //   delete item.children
        // }
      } else {
        // 不是继续递归下一级
        SET_COUNTRY_AREA(item.children, val, data)
      }
      break
    }
  }
}
// -----------------------------   Element Rule 封装   -----------------------------
/**
 * 获取el rule 必填验证实体
 * @param {String} message 错误提示
 * @param {String} type 验证类型，'array'（复选框），'date'（日期选择），文本 string（string element默认，可不设）
 * @param {Boolean} isBlur 是否失去焦点时触发（默认change，下拉菜单，日期等控件只能使用change触发）
 */
export const RULES_REQUIRED = function (message, type, isBlur) {
  let rule = {
    required: true,
    message: message || '此项为必填项',
    trigger: isBlur ? 'blur' : ['blur', 'change']
  }
  if (type) {
    rule.type = type
  }
  return rule
}

/**
 * 获取el rule 文本长度验证
 * @param {Boolean} isChange 是否绑定值改变时触发
 */
export const RULES_LENGTH = function (min, max, message, isChange) {
  let tips
  if (min && max) {
    tips = '长度在 ' + min + ' 到 ' + max + ' 个字'
  } else if (min) {
    tips = '长度不能少于 ' + min + ' 个字'
  } else if (max) {
    tips = '长度不能超过 ' + max + ' 个字'
  }
  // 长度验证规则
  return {
    min: min || '',
    max: max || '',
    message: message || tips,
    validator: Validate.chinaIdentityValid,
    trigger: isChange ? ['blur', 'change'] : 'blur'
  }
}

/**
 * 获取el rule 邮件验证
 * @param {String} message 错误提示
 * @param {Boolean} isChange 是否绑定值改变时触发
 */
export const RULES_EMAIL = function (message, isChange) {
  return { type: 'email', message: message || '请输入正确的邮箱地址', trigger: isChange ? ['blur', 'change'] : 'blur' }
}

/**
 * 获取el rule 网址验证
 * @param {String} message 错误提示
 * @param {Boolean} isChange 是否绑定值改变时触发
 */
export const RULES_URL = function (message, isChange) {
  return { type: 'url', message: message || '请输入正确的网址', trigger: isChange ? ['blur', 'change'] : 'blur' }
}

/**
 * 获取el rule 手机号验证，使用正则表达式实现
 * @param {String} message 错误提示
 * @param {Boolean} isChange 是否绑定值改变时触发
 */
export const RULES_PHONE = function (message, isChange) {
  return {
    message: message || '请输入正确的手机号',
    pattern: '^1(3|4|5|7|8)\\d{9}$',
    trigger: isChange ? ['blur', 'change'] : 'blur'
  }
}

/**
 * 获取el rule 数字范围，使用自定义函数实现
 * @param {Boolean} decimal 是否支持小数输入，=false时验证整数
 * @param {Number} decimalLength 支持小数的长度
 * @param {String} message 错误提示
 * @param {Boolean} isChange 是否绑定值改变时触发
 */
export const RULES_NUM_RANGE = function (minValue, maxValue, message, isChange) {
  return {
    message,
    validator: Validate.numberRange(minValue, maxValue),
    trigger: isChange ? ['blur', 'change'] : 'blur'
  }
}

/**
 * 获取el rule 小数规则，使用自定义函数实现
 * @param {Boolean} decimal 是否支持小数输入，=false时验证整数
 * @param {Number} decimalLength 支持小数的长度
 * @param {String} message 错误提示
 * @param {Boolean} isChange 是否绑定值改变时触发
 */
export const RULES_DECIMAL = function (decimal, decimalLength, message, isChange) {
  return {
    message,
    validator: Validate.decimalRule(decimal, decimalLength),
    trigger: isChange ? ['blur', 'change'] : 'blur'
  }
}

/**
 * 获取el rule 身份证验证，使用自定义函数实现
 * @param {Boolean} isChange 是否绑定值改变时触发
 */
export const RULES_CHINA_ID = function (isChange) {
  return {
    validator: Validate.chinaIdentityValid,
    trigger: isChange ? ['blur', 'change'] : 'blur'
  }
}

/**
 * 深拷贝对象，可以正确序列化日期
 * @param {*} obj
 */
export const DEEP_CLONE = function (obj) {
  let objClone = Array.isArray(obj) ? [] : {}
  if (obj && typeof obj === 'object') {
    for (let key in obj) {
      if (obj.hasOwnProperty(key)) {
        // 判断ojb子元素是否为对象，如果是，递归复制
        if (obj[key] && typeof obj[key] === 'object') {
          // 深拷贝日期类型
          if (obj[key] instanceof Date) {
            objClone[key] = new Date(obj[key].valueOf())
            // console.log('deepClone', objClone[key])
          } else {
            objClone[key] = DEEP_CLONE(obj[key])
          }
        } else {
          // 如果不是，简单复制
          objClone[key] = obj[key]
        }
      }
    }
  }
  return objClone
}

/**
 * 将mergeObj的数据合并至obj中，mergeObj中多余的属性也会被合并到obj中；
 * 常用于合并服务端传回的数据
 * @param {Object} obj 结构实体
 * @param {Object} mergeObj 数据实体
 * @param {Boolean} noEditMergeObj 不对mergeObj进行修改，默认会移除其中属性，出于性能考虑
 */
export const MERGE = function (obj, mergeObj, noEditMergeObj) {
  let _mergeObj = mergeObj
  if (noEditMergeObj) {
    _mergeObj = DEEP_CLONE(mergeObj)
  }
  for (let key in obj) {
    // 只判定自身属性和合并对象值存在的情况
    if (!obj.hasOwnProperty(key) || _mergeObj[key] === undefined) {
      continue
    }
    // 判断obj子元素是否为对象/数组，如果是则递归
    if (obj[key] && typeof obj[key] === 'object' && _mergeObj[key]) {
      // 数组直接赋值
      if (_mergeObj[key] instanceof Array) {
        obj[key] = _mergeObj[key]
      } else {
        MERGE(obj[key], _mergeObj[key], noEditMergeObj)
      }
    } else {
      // 如果不是，直接赋值
      obj[key] = _mergeObj[key]
    }
    // 移除合并对象
    delete _mergeObj[key]
  }
  // 将_mergeObj中多余属性合并过来
  for (let key in _mergeObj) {
    obj[key] = mergeObj[key]
  }
  return obj
}

/**
 * 追加mergeObj多余的属性到obj中，用于合并默认配置
 * @param {*} obj 当前对象
 * @param {*} mergeObj 要追加的对象
 */
export const MERGE_EXTEN = function (obj, mergeObj) {
  let _mergeObj = DEEP_CLONE(mergeObj)
  for (let key in obj) {
    // 只判定自身属性和合并对象值存在的情况
    if (!obj.hasOwnProperty(key) || _mergeObj[key] === undefined) {
      continue
    }
    // 移除合并对象
    delete _mergeObj[key]
  }
  // 将_mergeObj中多余属性合并过来
  for (let key in _mergeObj) {
    obj[key] = mergeObj[key]
  }
  return obj
}
/**
 * 性别常量
 */
export const SEX = {
  options: [
    {
      code: '0',
      name: '男'
    },
    {
      code: '1',
      name: '女'
    }
  ],
  val: ''
}

export const SWITCH_TYPE_CODE = {
  true: 1,
  false: 0
}

/**
 * 开关常量
 */
export const SWITCH = [
  { code: SWITCH_TYPE_CODE.false, label: '否' },
  { code: SWITCH_TYPE_CODE.true, label: '是' }]
/**
 * 单据途径维护状态开关常量
 */
export const STATE_TYPE = [
  { code: SWITCH_TYPE_CODE.false, label: '停用' },
  { code: SWITCH_TYPE_CODE.true, label: '启用' }]
/**
 * 处理对象中所有String属性中的空格
 * @param {*} obj
 */
export const REMOVE_BLANKS = function (obj) {
  if (obj && (obj instanceof Array || obj instanceof Object)) {
    for (let key in obj) {
      if (obj.hasOwnProperty(key)) {
        // 判断obj子元素是否为对象/数组，如果是则递归
        if (obj[key] && (obj[key] instanceof Array || obj[key] instanceof Object)) {
          REMOVE_BLANKS(obj[key])
        } else if (typeof obj[key] === 'string') {
          // 去除首尾空格
          obj[key] = obj[key].replace(/(^\s*)|(\s*$)/g, '')
        }
      }
    }
  } else if (typeof obj === 'string') {
    return obj.replace(/(^\s*)|(\s*$)/g, '')
  }
}

/**
 * 处理对象中所有String属性中的空格
 * @param {*} obj
 */
export const REMOVE_SPACE = function (params, special = []) {
  for (let i in params) {
    if (typeof params[i] === 'string') {
      // 去掉左右空格
      params[i] = params[i].replace(/(^\s*)|(\s*$)/g, '')
      for (let j in special) {
        if (i === special[j]) {
          continue
        }
        // 去掉所有空格
        params[i] = params[i].replace(/\s+/g, '')
      }
    }
  }
  return params
}

/**
 * 图片base64转换 图片压缩
 * @param  this
 * @param  file
 * @param  {boolean} 选参，默认压缩
 * @param {Array}  选参，默认支持的图片类型 jpeg ,png ,bmp
 * @param {Number}  选参，默认10M
 * @param {Number}  选参，压缩图片目标宽度,默认413px
 * @param {Number} 选参，压缩图片目标高度,默认626px
 * @param {Number} 选参，导出的图片质量,默认值是0.85
 * @date 2019/03/22
 * @version 0.0.1
 */
export const UPLOAD_PICTURE = function (obj, file, zip = true, fileType = ['jpeg', 'png', 'bmp'], s = 10, w = 413, h = 626, q = 0.85) {
  let that = obj
  return new Promise(function (resolve, reject) {
    // 限制图片大小
    const isLt10M = file.size / 1024 / 1024 < s

    // 限制图片格式
    let isFormat = 0
    for (var i = 0; i < fileType.length; i++) {
      if ('image/' + fileType[i] === file.type) {
        isFormat++
      }
    }
    let ft = fileType.join(',')
    if (!isFormat) {
      return that.$message.error(`上传头像图片仅限于 ${ft} 格式!`)
    }

    if (!isLt10M) {
      that.$message.error(`上传头像图片大小不能超过 ${s}MB!`)
      return false
    }

    // 选择的文件是图片
    if (file.type.indexOf('image') === 0) {
      // 压缩图片需要的一些元素和对象
      let reader = new FileReader()
      // 创建一个img对象
      let img = new Image()

      reader.readAsDataURL(file)
      // 文件base64化，以便获知图片原始尺寸
      reader.onload = function (e) {
        img.src = e.target.result
        if (!zip) {
          resolve(img.src)
        }
      }

      if (!zip) {
        return false
      }

      // base64地址图片加载完毕后执行
      img.onload = function () {
        // 缩放图片需要的canvas（也可以在DOM中直接定义canvas标签，这样就能把压缩完的图片不转base64也能直接显示出来）
        let canvas = document.createElement('canvas')
        let context = canvas.getContext('2d')

        // 图片原始尺寸
        let originWidth = this.width
        let originHeight = this.height

        // 最大尺寸限制，可通过设置宽高来实现图片压缩程度
        let maxWidth = w
        let maxHeight = h
        // 目标尺寸
        let targetWidth = originWidth
        let targetHeight = originHeight
        // 图片尺寸超过300x300的限制
        if (originWidth > maxWidth || originHeight > maxHeight) {
          if (originWidth / originHeight > maxWidth / maxHeight) {
            // 更宽，按照宽度限定尺寸
            targetWidth = maxWidth
            targetHeight = Math.round(maxWidth * (originHeight / originWidth))
          } else {
            targetHeight = maxHeight
            targetWidth = Math.round(maxHeight * (originWidth / originHeight))
          }
        }
        // canvas对图片进行缩放
        canvas.width = targetWidth
        canvas.height = targetHeight
        // 清除画布
        context.clearRect(0, 0, targetWidth, targetHeight)
        // 图片压缩
        context.drawImage(img, 0, 0, targetWidth, targetHeight)
        /* 第一个参数是创建的img对象；第二三个参数是左上角坐标，后面两个是画布区域宽高 */

        // 压缩后的图片转base64 url
        /* canvas.toDataURL(mimeType, qualityArgument),mimeType 默认值是'image/png';
         * qualityArgument表示导出的图片质量，只有导出为jpeg和webp格式的时候此参数才有效，默认值是0.92 */
        let newUrl = canvas.toDataURL('image/jpeg', q)// base64 格式
        resolve(newUrl)
      }
    }
  })
}
/**
 * 图片base64转换 裁剪图片
 * @param  myCroppa
 */
export const UPLOAD_PICTURE_CROP = function (myCroppa) {
  return new Promise(function (resolve, reject) {
    myCroppa.generateBlob((blob) => {
      // console.log(blob)
      resolve(myCroppa.generateDataUrl())
    }, 'image/png', 1.0)
  })
}
/**
 * 生成唯一ID（目前算法：本地时间戳+重复时累加。存在本地时间被修改的漏洞）
 * @param {Number} 是否是支持int长度
 */
export const UNIQUE_ID = function (isShort) {
  // 取出最后一次id生成使用的时间戳
  let timestamp
  let d = sessionStorage.getItem('timestamp')
  if (d) {
    timestamp = JSON.parse(d)
  } else {
    timestamp = {
      last: 0,
      count: 0
    }
  }

  let time = isShort ? moment().format('MMDDHHmm') : new Date().getTime()
  let id
  // 判定上一次的id是否重复，重复则使用count累计
  if (timestamp.last === time) {
    id = time + '' + timestamp.count
    timestamp.count++
  } else {
    id = time
    timestamp.count = 0
  }
  timestamp.last = time
  // 缓存最后一次id生成使用的时间戳
  sessionStorage.setItem('timestamp', JSON.stringify(timestamp))
  return id
}
/**
 * 判断一个数组中是否有重复的项，如果是对象数组的话根据其中某一项来确定
 * 如果是字符串数组，就不需要传key了
 * @param {* Array} list 数组
 * @param {* String} key 根据什么条件来判断
 */
export const UNIQUE_ARR = function (list, key) {
  let arr = []
  let newArr = []
  if (key) {
    list.forEach(item => {
      arr.push(item[key])
    })
    newArr = [...new Set(arr)]
  } else {
    newArr = [...new Set(list)]
  }
  if (newArr.length !== list.length) {
    return false
  } else {
    return true
  }
}

export const COMMON_KEYUP = function (arr) {
  document.onkeydown = e => {
    // 判断传的参数中是否有删除的键盘事件
    arr.forEach(item => {
      if (item.keyCode === e.keyCode && e.shiftKey && e.ctrlKey) {
        item.fun()
      }
      // if (item.keyArgs) {
      //   let flag = item.keyArgs.every(list => {
      //     let l = true
      //     if (l === e[list]) {
      //       console.log(888)
      //     }
      //   })
      //   console.log(flag)
      //   if (flag) {
      //     if (item.keyCode === e.keyCode || item.key === e.key) {
      //       item.fun()
      //     }
      //   }
      // } else {
      //   if (item.keyCode === e.keyCode || item.key === e.key) {
      //     item.fun()
      //   }
      // }
    })
  }
}

// lodop的list
let lodopTaskList = {}
/**
 * 获取本地唯一md5码，由cpuid，biosid，mac生成
 * 注意，请在vue.mounted生命周期上中使用
 * @param {Function} onBack 回调函数
 * @param {Boolean} userCache 是否从缓存中获取
 */
export const PC_INFO = function (onBack, userCache) {
  return new Promise((resolve, reject) => {
    // 优先读取本地缓存的MD5，防止设备变动引发的md5变动（低概率）
    let cache = localStorage.getItem('PC_INFO')
    let isLoad
    if (cache) {
      let info = JSON.parse(cache)
      // 如果获取缓存中的数据则直接返回
      if (userCache) {
        if (onBack) {
          onBack(info)
        }
        resolve()
        return info
      }
    }
    // isLoad 如果为true就表示插件或者lodop已经有返回 二者只要返回一个就可以
    let handleCache = msg => {
      if (isLoad) {
        return
      }
      let info = JSON.stringify(msg)
      localStorage.setItem('PC_INFO', info)
      isLoad = true
      if (onBack) {
        onBack(msg)
      }
      resolve()
    }
    exePCInfo().then(handleCache)
    lodopPCInfo().then(handleCache)
  })
}
/**
 * 使用插件获取设备信息
 */
async function exePCInfo() {
  return new Promise((resolve, reject) => {
    let msg
    exepostMessage(resolve, reject, msg)
    // 如果没有拿到msg，在获取一次，有可能插件没加载到
    setTimeout(async () => {
      if (!msg) {
        exepostMessage(resolve, reject, msg)
      }
    }, 500)
  })
}
/**
 * 使用插件获取设备信息
 */
function exepostMessage(resolve, reject, msg) {
  // 使用getPCInfo发送消息给插件获取信息
  window.postMessage({ type: 'getPCInfo' }, '*')
  // 如果vue，created中使用，需要使用setTimeout
  // 监听插件回发消息
  window.addEventListener('message', function (event) {
    if (event.data && event.data.type === 'setPCInfo') {
      msg = event.data.msg
      resolve(event.data.msg)
    }
  }, false)
}
/**
 * 使用lodop获取设备信息
 */
async function lodopPCInfo() {
  return new Promise(async (resolve, reject) => {
    // console.time('加载lodop时间')
    let LODOP = await getLodop()
    // console.timeEnd('加载lodop时间')
    // console.log(LODOP)
    let result
    let CLODOP = window['CLODOP']
    if (CLODOP.webskt && CLODOP.webskt.readyState === 1) {
      result = handleLoadLodopInfo(LODOP)
      resolve(result)
    } else {
      // 如果没有拿到msg，在获取一次，有可能lodop插件没加载到
      setTimeout(() => {
        if (CLODOP.webskt && CLODOP.webskt.readyState === 1) {
          result = handleLoadLodopInfo(LODOP)
          resolve(result)
        } else {
          console.error('无法通过lodop获取插件信息。。。')
        }
      }, 500)
    }
  })
}
/**
 * 使用lodop获取信息
 */
async function handleLoadLodopInfo(LODOP) {
  // console.warn('加载了。。。')
  let cpu, name, uuidBios, mainboard, newCpu, name2, mac, systemName
  // 获取设备信息
  if (LODOP.CVERSION) {
    console.time('获取全部设备信息时间')
    name = await checkLodopResult('PointingDevice.SystemName', LODOP) // 计算机名称
    cpu = await checkLodopResult('Processor.CPUID', LODOP)
    if (cpu) {
      newCpu = cpu.slice(-8) + cpu.slice(0, 8)
    }
    mainboard = await checkLodopResult('BaseBoard.SerialNumber', LODOP) // 主板序列号
    name2 = await checkLodopResult('OperatingSystem.Name', LODOP)
    if (name2) {
      systemName = name2.slice(0, 20)
    }
    uuidBios = await checkLodopResult('BIOS.SerialNumber', LODOP) // BIOS序列号
    mac = await checkLodopResult('NetworkAdapter.1.PhysicalAddress', LODOP) // BIOS序列号
    console.timeEnd('获取全部设备信息时间')
  }
  // 如果获取不到信息值 直接返回
  if (!newCpu || !name || !uuidBios || !mainboard) {
    return
  }
  let infoObj = {
    cpu: newCpu, // CPU序列号
    mac, // 主网卡MAC地址
    systemName, // 安装的系统
    name, // 主网卡MAC地址
    uuidBios, // BIOS序列号
    mainboard // 主板序列号
  }
  // 通过插件生成md5
  // console.time('生成MD5时间')
  infoObj['md5'] = blueimpMd5(infoObj.cpu + infoObj.uuidBios + infoObj.mainboard)
  // console.timeEnd('生成MD5时间')
  return infoObj
}

// 校验是否可以向lodop发送请求加载数据
function checkIsNeedLoad() {
  let isLoad = true
  for (let key in lodopTaskList) {
    if (lodopTaskList[key] && lodopTaskList[key].length > 0) {
      isLoad = false
      break
    }
  }
  return isLoad
}
/**
 * 使用lodop获取电脑信息（On_Return方法只能存在一个否则是覆盖关系）
 * 将同类型和对应的resovle存储到一个固定对象中 进行加载
 * 没有正在发送请求的时候直接请求获取 有的话存到对象中递归调用对应type的arr
 */
async function checkLodopResult(type, LODOP) {
  // console.log(lodopTaskList)
  // 当前无请求时加载数据
  if (checkIsNeedLoad() || JSON.stringify(lodopTaskList) === '{}') {
    let promiseArr = lodopTaskList[type] || []
    return new Promise(resolve => {
      // 记录回调函数
      promiseArr.push(resolve)
      lodopTaskList[type] = promiseArr
      loadLodopInfo(LODOP, 'GET_SYSTEM_INFO', type)
    })
  } else {
    // 当存在请求的时候存放到obj里面对应的type里面
    let promiseList = lodopTaskList[type] || []
    // 创建当前请求的promise 将resovle存到obj中对应的type内
    return new Promise(async (resolve, reject) => {
      promiseList.push(resolve)
      lodopTaskList[type] = promiseList
    })
  }
}
/**
 * 发送请求加载lodop数据，增加了缓存机制
 * @param {Object} LODOP 当前的打印控件
 * @param {String} funName 当前的类型
 * @param {String} param1 当前的类型
 * @param {String} param2 当前的类型
 */
async function loadLodopInfo(LODOP, funName, param1, param2) {
  let result
  let nextType
  try {
    // 加载数据
    // console.time('向lodop发送' + funName + ':' + param1 + '请求')
    result = await handleResponseInfo(LODOP, funName, param1, param2)
    // console.timeEnd('向lodop发送' + funName + ':' + param1 + '请求')
    console.log('lodopd返回结果：' + result)
  } catch (err) {
    result = null
    // 如果请求报错，也清除所有回调函数
    console.log(err)
  }
  // 执行回调函数，返回获取到的数据
  // 注意：此处应该使用funName+param1作为key，暂时先使用param1！！！
  for (let promise of lodopTaskList[param1]) {
    console.log(param1 + ': ===== ' + result)
    promise(result)
  }
  // 移除所有注册的并发回调
  delete lodopTaskList[param1]
  // 不存在当前类型 说明当前类型的可执行resovle已经执行完成 已被delete 找下一个继续未执行的继续执行
  if (!lodopTaskList[param1] && JSON.stringify(lodopTaskList) !== '{}') {
    // 循环找到下一个需要加载的type类型
    for (let key in lodopTaskList) {
      if (lodopTaskList[key] && lodopTaskList[key].length > 0) {
        // console.log(nextType)
        nextType = key
        break
      }
    }
    if (nextType) {
      return loadLodopInfo(LODOP, 'GET_SYSTEM_INFO', nextType)
      // return loadLodopInfo(LODOP, nextType)
    }
  }
}
/**
 * 处理通过GET_SYSTEM_INFO（）拿到ID之后通过CLODOP获取值
 * @param {Object} LODOP 当前的打印控件
 * @param {String} funName 当前的类型
 * @param {String} param1 当前的类型
 * @param {String} param2 当前的类型
 */
function handleResponseInfo(LODOP, funName, param1, param2) {
  return new Promise((resolve, reject) => {
    // LODOP.GET_SYSTEM_INFO(param1)
    // LODOP.GET_VALUE(param1, param2)
    LODOP[funName](param1, param2)
    // 不能加这个打印 否则获取的taskID 会有问题 出现错位的情况
    // console.log(LODOP[funName](param1, param2))
    window['CLODOP'].On_Return = function (taskID, value) {
      resolve(value)
    }
  })
}

/**
 * 获取所有设备信息 先将已经存在的本地的插件MD5信息存一份在定义的数组里
 * 再将用lodop获取到的新的push数组里 如果都存在的话就传给后台 不存在的话就直接报错退出
 * @param {Boolean} userCache 是否从缓存中获取
 */
export const ALL_PC_INFO = async function (userCache) {
  return new Promise((resolve, reject) => {
    let allPCInfo = []
    let count = 0
    let handleCache = msg => {
      console.log(msg)
      allPCInfo.push(msg)
      count++
      if (count === 2) {
        resolve(allPCInfo)
      }
    }
    exeCachePCInfo().then(handleCache) // 获取缓存数据 如果缓存中存在就直接返回 如果没有通过插件再次获取
    lodopCachePCInfo().then(handleCache) // 使用lodop获取当前设备信息 先读取缓存数据
    // 如果650ms后还没有拿到PC信息，则将已经获取到的数据返回 不管获得几个信息
    setTimeout(async () => {
      if (count !== 2) {
        resolve(allPCInfo)
      }
    }, 650)
  })
}

/**
 * 通过插件获取全部信息时先读缓存数据
 */
async function exeCachePCInfo() {
  return new Promise((resolve, reject) => {
    // 先查询本地是否已缓存插件获取到的信息 如果存在就直接返回缓存的信息
    // 不存在的话在通过插件加载
    let cache = localStorage.getItem('EXE_PC_INFO')
    if (cache) {
      let info = JSON.parse(cache)
      resolve(info)
      return
    } else {
      // 如果exe缓存不存在，则拉取PC_INFO的缓存，兼容旧数据
      let lastCache = localStorage.getItem('PC_INFO')
      if (lastCache) {
        localStorage.setItem('EXE_PC_INFO', lastCache)
        let info = JSON.parse(lastCache)
        resolve(info)
        return
      }
    }
    // 异步加载chrome插件获取PC信息
    let handleCache = msg => {
      if (msg) {
        let strJson = JSON.stringify(msg)
        // 不存在已经复制的EXE_PC_INFO设备信息时再赋值  否则会替换原有的EXE_PC_INFO的值
        localStorage.setItem('EXE_PC_INFO', strJson)
        resolve(msg)
      }
    }
    exePCInfo().then(handleCache)
  })
}

/**
 * 通过lodop获取全部信息时先读缓存数据在加载
 */
async function lodopCachePCInfo() {
  return new Promise((resolve, reject) => {
    // 先查询本地是否已缓存插件获取到的信息 如果存在就直接返回缓存的信息
    // 不存在的话在通过lodop加载
    let cache = localStorage.getItem('LODOP_PC_INFO')
    if (cache) {
      let info = JSON.parse(cache)
      resolve(info)
      return
    }
    // 异步加载lodop插件获取PC信息
    let handleCache = msg => {
      if (msg) {
        let strJson = JSON.stringify(msg)
        console.log(strJson + '异步加载lodop插件获取PC信息')
        // 保存通过lodop获取的信息
        localStorage.setItem('LODOP_PC_INFO', strJson)
        resolve(msg)
      }
    }
    lodopPCInfo().then(handleCache)
  })
}

/**
 * 获取URL参数 用户中心到pim
 * @param {String} 参数名称
 */
export const GET_URL_RATMS = function (name) {
  let tstr = window.location.href
  let index = tstr.lastIndexOf('?')
  let str = tstr.substring(index + 1)
  let arr = str.split('&')
  let result = {}
  arr.forEach((item) => {
    let a = item.split('=')
    result[a[0]] = a[1]
  })
  if (result[name]) {
    return decodeURIComponent(result[name])
  }
  return null
}
/**
 * 权限检查方法
 * @param {String} menuCode
 */
export const AUTH = function (value) {
  let isShow = true
  let btnPermissionsStr
  let tempBut
  if (store.getters.button) {
    btnPermissionsStr = store.getters.button
  } else {
    btnPermissionsStr = []
  }
  if (btnPermissionsStr.length === 0) {
    isShow = true
  }
  tempBut = btnPermissionsStr.find(item => {
    return item.menuCode === value
  })
  if (tempBut) {
    isShow = true
  } else {
    isShow = false
  }
  return isShow
}

/**
 * 分页返回当前页
 * @param {Number} totlePages 总条数
 * @param {Number} pageSize 每页条数
 * @param {Number} currentPage 返回参数 当前页
 */
export const currentPageMeth = function({ totlePages = 0, pageSize = 10 }) {
  let currentPage = Math.ceil(totlePages / pageSize)
  if (totlePages === 0) { currentPage = 1 }
  return currentPage
}

/**
 * 数组根据数组对象中的某个属性值进行排序的方法
 * 使用例子：newArray.sort(sortBy('number',false)) //表示根据number属性降序排列;若第二个参数不传递，默认表示升序排序
 * @param attr 排序的属性 如number属性
 * @param rev true表示升序排列，false降序排序
 */
export const sortBy = function(attr, rev) {
  // 第二个参数没有传递 默认升序排列
  if (rev === undefined) {
    rev = 1
  } else {
    rev = (rev) ? 1 : -1
  }
  return function(a, b) {
    a = a[attr]
    b = b[attr]
    if (a < b) {
      return rev * -1
    }
    if (a > b) {
      return rev * 1
    }
    return 0
  }
}
/*
*去除重复提交
*@param {Boolean} removeRandomNum 是否删除缓存数据
*/
export const removeDuplicationSubmit = function(removeRandomNum = false) {
  // 如果 removeRandomNum === true 删除缓存数据
  if (removeRandomNum === true) {
    sessionStorage.removeItem('RandomNum')
    // console.log('已经删除RandomNum')
    return false
  }
  //  如果存在，进行提示
  // console.log('RandomNum', sessionStorage.getItem('RandomNum'))
  if (sessionStorage.getItem('RandomNum')) {
    Message.warning('当前操作已提交，请稍后···')
    // console.log('已存在RandomNum')
    return false
    // 如果不存在创建一个
  } else {
    let RandomNum = `id` + (new Date()).getTime() * 1000
    sessionStorage.setItem('RandomNum', RandomNum)
    // console.log('创建一个RandomNum')
    return true
  }
}
/**
*拷贝一级对象，可以正确序列化日期
*@param{*}obj
*/
export const DEEP_CLONE_ONE = function (obj) {
  let objClone = Array.isArray(obj) ? [] : {}
  if (obj && typeof obj === 'object') {
    for (let key in obj) {
      // console.log('判定hasOwnProperty', obj, key)
      if (obj.hasOwnProperty && obj.hasOwnProperty(key)) {
        // 判断ojb子元素是否为对象，如果是，递归复制
        if (obj[key] && typeof obj[key] === 'object') {
          // 深拷贝日期类型
          if (obj[key] instanceof Date) {
            objClone[key] = new Date(obj[key].valueOf())
            // console.log('deepClone', objClone[key])
          } else {
            objClone[key] = obj[key]
            // console.log(key, objClone[key], obj[key])
          }
        } else {
          // 如果不是，简单复制
          objClone[key] = obj[key]
          // console.log(key, objClone[key], obj[key])
        }
      }
    }
  }
  return objClone
}
/**
* 合并mergeObj的属性到obj中，只合并一级
 * @param {*} obj 当前对象
 * @param {*} mergeObj 要追加的对象
 */
export const MERGE_ONE = function (obj, mergeObj) {
  // 将_mergeObj中属性合并过来
  for (let key in mergeObj) {
    // 只判定自身属性和合并对象值存在的情况
    if (!obj.hasOwnProperty(key) || mergeObj[key] === undefined) {
      continue
    }
    obj[key] = mergeObj[key]
  }
  return obj
}
// 贯标项目类别
export const XIANMU = function(index, data) {
  console.log(index, data)
  switch (index) {
    case '01':
      data = '床位费'
      break
    case '02':
      data = '诊察费'
      break
    case '03':
      data = '检查费'
      break
    case '04':
      data = '化验费'
      break
    case '05':
      data = '治疗费'
      break
    case '06':
      data = '手术费'
      break
    case '07':
      data = '护理费'
      break
    case '08':
      data = '卫生材料费'
      break
    case '09':
      data = '西药费'
      break
    case '10':
      data = '中药饮片费'
      break
    case '11':
      data = '中成药费'
      break
    case '12':
      data = '一般诊疗费'
      break
    case '13':
      data = '挂号费'
      break
    case '14':
      data = '其他费'
      break
    default:
      data = '按病种收费'
      break
  }
}
export const RELATION = function (index, data) {
  switch (index) {
    case '0':
      data = '夫妻'
      break
    case '1':
      data = '父母'
      break
    case '2':
      data = '子女'
      break
    case '3':
      data = '兄弟姐妹'
      break
    case '4':
      data = '祖父母和外祖父母'
      break
    case '5':
      data = '孙子女和外孙子女'
      break
    case '6':
      data = '儿媳和公婆'
      break
    case '7':
      data = '女婿和岳父母'
      break
    case '8':
      data = '伯伯'
      break
    case '9':
      data = '叔叔'
      break
    case '10':
      data = '姑母'
      break
    case '11':
      data = '舅'
      break
    case '12':
      data = '阿姨'
      break
    case '13':
      data = '侄子女'
      break
    case '14':
      data = '甥子女'
      break
    case '15':
      data = '堂兄弟姐妹'
      break
    case '16':
      data = '表兄弟姐妹'
      break
    default:
      data = '舅舅'
      break
  }
}
export { handleResponseInfo }
// 中国各民族名称的罗马字母拼写法和代码 （GB/T 3304-1991）
// export const NATION = function (ele) {
//   switch (ele) {
//     case '01':
//       return '汉族'
//     case '02':
//       return '蒙古族'
//     case '03':
//       return '回族'
//     case '04':
//       return '藏族'
//     case '05':
//       return '维吾尔族'
//     case '06':
//       return '苗族'
//     case '07':
//       return '彝族'
//     case '08':
//       return '壮族'
//     case '09':
//       return '布依族'
//     case '10':
//       return '朝鲜族'
//     case '11':
//       return '满族'
//     case '12':
//       return '侗族'
//     case '13':
//       return '瑶族'
//     case '14':
//       return '白族'
//     case '15':
//       return '土家族'
//     case '16':
//       return '哈尼族'
//     case '17':
//       return '哈萨克族'
//     case '18':
//       return '傣族'
//     case '19':
//       return '黎族'
//     case '20':
//       return '傈僳族'
//     case '21':
//       return '佤族'
//     case '22':
//       return '畲族'
//     case '23':
//       return '高山族'
//     case '24':
//       return '拉祜族'
//     case '25':
//       return '水族'
//     case '26':
//       return '东乡族'
//     case '27':
//       return '纳西族'
//     case '28':
//       return '景颇族'
//     case '29':
//       return '柯尔克孜族'
//     case '30':
//       return '土族'
//     case '31':
//       return '达斡尔族'
//     case '32':
//       return '仫佬族'
//     case '33':
//       return '羌族'
//     case '34':
//       return '布朗族'
//     case '35':
//       return '撒拉族'
//     case '36':
//       return '毛南族'
//     case '37':
//       return '仡佬族'
//     case '38':
//       return '锡伯族'
//     case '39':
//       return '阿昌族'
//     case '40':
//       return '普米族'
//     case '41':
//       return '塔吉克族'
//     case '42':
//       return '怒族'
//     case '43':
//       return '乌孜别克族'
//     case '44':
//       return '蒙古族'
//     case '45':
//       return '回族'
//     case '46':
//       return '藏族'
//     case '47':
//       return '维吾尔族'
//     case '48':
//       return '苗族'
//     case '49':
//       return '彝族'
//     case '50':
//       return '汉族'
//     case '51':
//       return '蒙古族'
//     case '52':
//       return '回族'
//     case '53':
//       return '藏族'
//     case '54':
//       return '维吾尔族'
//     case '55':
//       return '苗族'
//     case '56':
//       return '彝族'
//     case '81':
//       return '汉族'
//     case '58':
//       return '蒙古族'
//     case '97':
//       return '回族'
//     case '98':
//       return '藏族'
//   }
// }

utils/hypertensionManagement/hyperFollowupRecords.js 封装的TABLE_TITLE数据

export const TABLE_TITLE = {
  titleList: [
    {
      id: '1',
      name: '健康档案号',
      prop: 'healthNo',
      showOverflowTooltip: true,
      width: '200'
    },
    {
      id: '2',
      name: '姓名',
      prop: 'name',
      showOverflowTooltip: true,
      width: '100'
    },
    {
      id: '3',
      name: '性别',
      prop: 'sexName',
      showOverflowTooltip: true,
      width: '100'
    },
    {
      id: '4',
      name: '出生日期',
      prop: 'birthDate',
      showOverflowTooltip: true,
      width: '200'
    },
    {
      id: '5',
      name: '年龄',
      prop: 'age',
      showOverflowTooltip: true,
      width: '100'
    },
    {
      id: '6',
      name: '身份证号',
      prop: 'idNum',
      showOverflowTooltip: true,
      width: '200'
    },
    {
      id: '7',
      name: '家庭住址',
      prop: 'address',
      showOverflowTooltip: true,
      width: '200'
    },
    {
      id: '8',
      name: '随访次数',
      prop: 'followCount',
      showOverflowTooltip: true,
      width: '100'
    },
    {
      id: '9',
      name: '上次随访时间',
      prop: 'lastFollowDate',
      showOverflowTooltip: true,
      width: '200'
    },
    {
      id: '10',
      name: '随访方式',
      prop: 'followMode',
      showOverflowTooltip: true,
      width: '100'
    },
    {
      id: '11',
      name: '建档时间',
      prop: 'createDate',
      showOverflowTooltip: true,
      width: '200'
    },
    {
      id: '12',
      name: '状态',
      prop: 'validStatusName',
      showOverflowTooltip: true,
      width: '100'
    }
  ]
}

/api/DoctorMaintenance 封装的获取数据的函数

import $http from './index'

// 初始化，获取医生列表
export function GetdoctorData(data) {
  return $http({
    url: '/doctor/listDoctorInit',
    method: 'get',
    params: data,
    loading: false,
    tips: false
  })
}
// 模糊查询，获取医生列表
export function GetdimData(data) {
  return $http({
    url: '/doctor/getTest',
    method: 'get',
    params: data,
    loading: false,
    tips: false
  })
}
// 添加医生
export function AddDoctorData(data) {
  return $http({
    url: '/doctor/getAddDoctor',
    method: 'post',
    data: data,
    loading: false,
    tips: false
  })
}
// 修改医生信息
export function ChangeDoctorData(data) {
  return $http({
    url: '/doctor/getUpdateDoc',
    method: 'put',
    data: data,
    tips: false
  })
}
// 根据ID查询医生
export function GetDocId(data) {
  return $http({
    url: '/doctor/getDoc',
    method: 'get',
    params: data,
    tips: false
  })
}
// 删除医生信息
export function DeleteDoctorData(data) {
  return $http({
    url: '/doctor/getDeleteDoc',
    method: 'delete',
    params: data,
    tips: false
  })
}
// 分页显示医生信息
export function PageDoctorData(data) {
  return $http({
    url: '/doctor/listDoctorSorting',
    method: 'get',
    params: data,
    tips: false
  })
}
// 获取医生的下拉列表信息
export function SpinnerDoctorData(data) {
  return $http({
    url: '/common/standardCodes',
    method: 'get',
    params: data,
    tips: false
  })
}
// 获取医生的输入码
export function DoctorConversionData(data) {
  return $http({
    url: '/doctor/getConversion',
    method: 'get',
    params: data,
    tips: false
  })
}
// 查询医生科室
// export function DoctorlistDept(data) {
//   return $http({
//     url: '/doctor/listDept',
//     method: 'get',
//     params: data,
//     tips: false
//   })
// }
// 查询医生科室
export function DoctorlistDept(data) {
  return $http({
    url: '/deptInformation/listDeptOrWard',
    method: 'get',
    params: data,
    tips: false
  })
}
// 查询医生科室（家床）
export function getDoctorUseDeptList () {
  return $http({
    url: '/emr/getDoctorUseDeptList',
    method: 'POST',
    tips: false
  })
}
// 根据用户表，查询对应医生
export function getUserInfoByOrgNo(data) {
  return $http({
    url: '/doctor/getUserInfoByOrgNo',
    method: 'get',
    params: data,
    tips: false,
    loading: false
  })
}
// 获取挂号类型
export function showCategoryApi() {
  return $http({
    url: '/doctor/showCategory',
    method: 'get',
    tips: false
  })
}
// 获取门诊代码
export function showOutPCodeApi() {
  return $http({
    url: '/doctor/showOutPCode',
    method: 'get',
    tips: false
  })
}
// 获取所有病区
export function showAllAreaApi() {
  return $http({
    url: '/doctor/showAllArea',
    method: 'get',
    loading: false,
    tips: false
  })
}
// 获取病历权限列表--医疗小组
export function getEmrPermissionEnumList () {
  return $http({
    url: '/emr/getEmrPermissionEnumList',
    method: 'get',
    loading: false,
    tips: false
  })
}

/api/hypertensionManagement/hypertensionOverview 封装的获取数据的函数

import $http from '../index'
import { API_TYPE } from '@/utils/constants.js'

/**
 * 高血压查询
 */
export function hypertensivePatientList(data) {
  return $http({
    url: '/hypertension/hypertensivePatientList',
    method: 'get',
    params: data,
    api: API_TYPE.phs
  })
}

/**
 * 高血压终止
 */
export function hypertensiveCardTermination(data) {
  return $http({
    url: '/hypertension/hypertensiveCardTermination',
    method: 'post',
    data: data,
    api: API_TYPE.phs
  })
}

/**
 * 糖尿病查询
 */
export function diabetesPatientList(data) {
  return $http({
    url: '/diabetesMellitus/diabetesPatientList',
    method: 'get',
    params: data,
    api: API_TYPE.phs
  })
}

/**
 * 糖尿病终止
 */
export function diabetesCardTermination(data) {
  return $http({
    url: '/diabetesMellitus/diabetesCardTermination',
    method: 'post',
    data: data,
    api: API_TYPE.phs
  })
}

整个项目目录如下

2、列表进入详情

详情刷新数据丢失

<template>
  <el-container class="layout_container">
    <el-header class="top">
      <el-button
        v-show="!formData.managerNo"
        type="primary"
        size="medium"
        class="inportedBtn"
        @click="imported">健康档案中一键导入</el-button>
    </el-header>
    <el-main>
      <el-form ref="formData" :model="formData" :rules="rules">
        <div style="text-align: center; margin-bottom: 10px; font-weight: 600; font-size: 18px">高血压管理卡</div>
        <el-row>
          <el-col :span="6">
            <el-form-item label="管理卡编号" label-width="120px">
              <el-input v-model="formData.managerNo" disabled size="small"/>
            </el-form-item>
          </el-col>
          <el-col :span="6">
            <el-form-item label="个人档案编号" label-width="120px">
              <el-input v-model="formData.healthNo" disabled size="small"/>
            </el-form-item>
          </el-col>
          <el-col :span="6">
            <el-form-item label="姓名" label-width="120px">
              <el-input v-model="formData.name" disabled size="small"/>
            </el-form-item>
          </el-col>
          <el-col :span="6">
            <el-form-item label="性别" label-width="120px">
              <el-input v-model="formData.sex" disabled size="small"/>
            </el-form-item>
          </el-col>
          <el-col :span="6">
            <el-form-item label="婚姻" label-width="120px">
              <el-input v-model="formData.marital" disabled size="small"/>
            </el-form-item>
          </el-col>
          <el-col :span="6">
            <el-form-item label="职业" label-width="120px">
              <el-input v-model="formData.profession" disabled size="small"/>
            </el-form-item>
          </el-col>
          <el-col :span="6">
            <el-form-item label="出生日期" label-width="120px">
              <el-date-picker v-model="formData.birthDate" :clearable="false" disabled size="small" value-format="yyyy-MM-dd"/>
            </el-form-item>
          </el-col>
          <el-col :span="6">
            <el-form-item label="联系电话" label-width="120px">
              <el-input v-model="formData.phone" size="small"/>
            </el-form-item>
          </el-col>
          <el-col :span="6">
            <el-form-item label="管理组别" label-width="120px" prop="manageGroup">
              <el-select v-model="formData.manageGroup" type="number" size="small">
                <el-option
                  v-for="item in manageList"
                  :key="item.value"
                  :label="item.label"
                  :value="item.value"/>
              </el-select>
            </el-form-item>
          </el-col>
          <el-col :span="12">
            <el-form-item label="现住址" label-width="120px">
              <el-input v-model="formData.address" disabled size="small"/>
            </el-form-item>
          </el-col>
        </el-row>
        <el-row>
          <el-form-item label="病例来源" label-width="120px" prop="dataSource">
            <el-radio-group v-model="formData.dataSource">
              <el-radio label="1">健康档案</el-radio>
              <el-radio label="2">首次测压</el-radio>
              <el-radio label="3">人群调查/体检</el-radio>
              <el-radio label="4">社区门诊</el-radio>
            </el-radio-group>
          </el-form-item>
        </el-row>
        <el-row>
          <el-col :span="6">
            <el-form-item label="建档机构" label-width="120px">
              <el-input v-model="formData.createOrg" disabled size="small"/>
            </el-form-item>
          </el-col>
          <el-col :span="6">
            <el-form-item label="建档医生" label-width="120px">
              <el-select v-model="formData.createDoctor" disabled type="number" size="small">
                <el-option
                  v-for="item in docList"
                  :key="item.docId"
                  :label="item.docName"
                  :value="item.docCode"/>
              </el-select>
            </el-form-item>
          </el-col>
          <el-col :span="6">
            <el-form-item label="建卡日期" label-width="120px">
              <!-- <el-input size="small"/> -->
              <el-date-picker v-model="formData.createDate" :clearable="false" disabled size="small" value-format="yyyy-MM-dd"/>
            </el-form-item>
          </el-col>
        </el-row>
        <el-row>
          <el-col :span="6">
            <el-form-item label="家族史" label-width="120px">
              <!-- <el-input size="small"/> -->
              <el-select v-model="formData.familyHistoryAry" multiple collapse-tags size="small">
                <el-option
                  v-for="item in familyHistoryList"
                  :key="item.value"
                  :label="item.label"
                  :value="item.value"/>
              </el-select>
            </el-form-item>
          </el-col>
          <el-col :span="6">
            <el-form-item label="目前症状" label-width="120px">
              <!-- <el-input size="small"/> -->
              <el-select v-model="formData.symptomCodeAry" multiple collapse-tags size="small">
                <el-option
                  v-for="item in symptomCodeList"
                  :key="item.value"
                  :label="item.label"
                  :value="item.value"/>
              </el-select>
            </el-form-item>
          </el-col>
        </el-row>
        <el-row>
          <div style="margin-bottom: 10px; font-weight: 600; font-size: 16px">高血压并发症情况：</div>
          <el-col>
            <el-form-item label="脑血管疾病" label-width="110px">
              <el-checkbox-group v-model="formData.cerebrovascularDiseaseAry">
                <el-checkbox label="1">缺血性卒中</el-checkbox>
                <el-checkbox label="2">脑出血</el-checkbox>
                <el-checkbox label="3">短暂性脑缺血发作(TIA)</el-checkbox>
              </el-checkbox-group>
            </el-form-item>
          </el-col>
          <el-col>
            <el-form-item label="心脏疾病" label-width="110px">
              <el-checkbox-group v-model="formData.heartDiseaseAry">
                <el-checkbox label="1">心肌梗死</el-checkbox>
                <el-checkbox label="2">心绞痛</el-checkbox>
                <el-checkbox label="3">充血性心力衰竭</el-checkbox>
              </el-checkbox-group>
            </el-form-item>
          </el-col>
          <el-col>
            <el-form-item label="肾脏疾病" label-width="110px">
              <el-checkbox-group v-model="formData.kidneyDiseaseAry">
                <el-checkbox label="1">高血压肾病</el-checkbox>
                <el-checkbox label="2">肾功能衰竭</el-checkbox>
              </el-checkbox-group>
            </el-form-item>
          </el-col>
          <el-col>
            <el-form-item label="眼部疾病" label-width="110px">
              <el-checkbox-group v-model="formData.eyeDiseaseAry">
                <el-checkbox label="1">视网膜出血或渗出</el-checkbox>
                <el-checkbox label="2">视乳头水肿</el-checkbox>
              </el-checkbox-group>
            </el-form-item>
          </el-col>
        </el-row>
        <el-row>
          <!-- 近期药物治疗情况：数组里面的字段没对 -->
          <div style="margin-bottom: 10px; font-weight: 600; font-size: 16px">近期药物治疗情况：</div>
          <el-col :span="16">
            <el-table
              :data="formData.recentDrugListAry"
              :header-cell-style="{
                background: '#F7F7F7',
                padding: '8px 0',
                fontSize: '14px',
                textAlign: 'center',
              }"
              :cell-style="{ 'text-align': 'center' }"
              border=""
              @row-dblclick="editDetails3"
              @selection-change="handleSelectionChange"
            >
              <el-table-column label="药物名称" prop="">
                <template slot-scope="scope">
                  <span v-if="scope.row.isUpdate">{{ scope.row.drugName }}</span>
                  <el-form-item v-else>
                    <el-input v-model="scope.row.drugName" />
                  </el-form-item>
                </template>
              </el-table-column>
              <el-table-column label="使用方法" prop="">
                <template slot-scope="scope">
                  <span v-if="scope.row.isUpdate">{{
                    scope.row.usage
                  }}</span>
                  <el-form-item v-else>
                    <el-input v-model="scope.row.usage" />
                  </el-form-item>
                </template>
              </el-table-column>
              <el-table-column fixed="right" width="100">
                <template slot="header">
                  <el-button
                    type="primary"
                    size="mini"
                    icon="el-icon-plus"
                    @click="addRow()"
                  >添加</el-button
                  >
                </template>
                <template slot-scope="scope">
                  <span
                    v-if="scope.row.isUpdate"
                    class="delBtn"
                    @click="deleteRow(scope.$index, formData.recentDrugListAry)"
                  >
                    删除
                  </span>
                  <span
                    v-else
                    class="saveBtn"
                    @click="saveRow(scope.$index, formData.recentDrugListAry)">
                    保存
                  </span>
                </template>
              </el-table-column>
            </el-table>
          </el-col>
        </el-row>
        <el-row>
          <div style="margin-bottom: 10px; font-weight: 600; font-size: 16px">生活习惯：</div>
          <el-col :span="5">
            <el-form-item label="吸烟" label-width="100px">
              <el-input v-model="formData.smoke" size="small">
                <span slot="suffix" class="el-input__icon">支/天</span>
              </el-input>
            </el-form-item>
          </el-col>
          <el-col :span="5">
            <el-form-item label="饮酒" label-width="100px">
              <el-input v-model="formData.weekDrink" size="small">
                <span slot="suffix" class="el-input__icon">次/周</span>
              </el-input>
            </el-form-item>
          </el-col>
          <el-col :span="3">
            <el-form-item label-width="8px">
              <el-input v-model="formData.drinkCapacity" size="small">
                <span slot="suffix" class="el-input__icon">两(酒精)/次</span>
              </el-input>
            </el-form-item>
          </el-col>
          <el-col :span="5">
            <el-form-item label="运动" label-width="100px">
              <el-input v-model="formData.weekExercise" size="small">
                <span slot="suffix" class="el-input__icon">次/周</span>
              </el-input>
            </el-form-item>
          </el-col>
          <el-col :span="3">
            <el-form-item label-width="8px">
              <el-input v-model="formData.exerciseTimeLen" size="small">
                <span slot="suffix" class="el-input__icon">分钟/次</span>
              </el-input>
            </el-form-item>
          </el-col>
        </el-row>
        <el-row>
          <el-form-item label="生活自理能力" label-width="110px">
            <el-radio-group v-model="formData.performanceState">
              <el-radio label="1">完全自理</el-radio>
              <el-radio label="2">部分自理</el-radio>
              <el-radio label="3">完全不能自理</el-radio>
            </el-radio-group>
          </el-form-item>
        </el-row>
        <el-row>
          <div style="margin-bottom: 10px; font-weight: 600; font-size: 16px">体检结果：</div>
          <el-col :span="6">
            <el-form-item label="身高" label-width="100px">
              <el-input v-model="formData.height" size="small">
                <span slot="suffix" class="el-input__icon">cm</span>
              </el-input>
            </el-form-item>
          </el-col>
          <el-col :span="6">
            <el-form-item label="体重" label-width="100px">
              <el-input v-model="formData.weight" size="small">
                <span slot="suffix" class="el-input__icon">kg</span>
              </el-input>
            </el-form-item>
          </el-col>
          <el-col :span="5">
            <el-form-item label="BMI" label-width="100px">
              <el-input v-model="formData.bodyMassIndex" size="small">
                <span slot="suffix" class="el-input__icon">kg/㎡</span>
              </el-input>
            </el-form-item>
          </el-col>
          <el-col :span="6">
            <el-form-item label="腰围" label-width="100px">
              <el-input v-model="formData.waistline" size="small">
                <span slot="suffix" class="el-input__icon">cm</span>
              </el-input>
            </el-form-item>
          </el-col>
          <el-col :span="6">
            <el-form-item label="血压" label-width="100px">
              <el-input v-model="formData.systolicPressure" size="small">
                <span slot="suffix" class="el-input__icon">mmHg</span>
              </el-input>
            </el-form-item>
          </el-col>
          <el-col :span="1" class="line">/</el-col>
          <el-col :span="4">
            <el-form-item label-width="8px">
              <el-input v-model="formData.diastolicPressure" size="small">
                <span slot="suffix" class="el-input__icon">mmHg</span>
              </el-input>
            </el-form-item>
          </el-col>
          <el-col :span="6" style="line-height:40px;margin-left:8px;">
            <span>(</span>
            <el-radio-group v-model="formData.takeMedicine">
              <el-radio label="1">服药</el-radio>
              <el-radio label="2">未服药</el-radio>
            </el-radio-group>
            <span>)</span>
          </el-col>
          <el-col :span="6">
            <el-form-item label="空腹血糖" label-width="120px">
              <el-input v-model="formData.fastingBloodGlucose" size="small">
                <span slot="suffix" class="el-input__icon">mmol/L</span>
              </el-input>
            </el-form-item>
          </el-col>
          <el-col :span="6">
            <el-form-item label="高密度脂蛋白" label-width="140px">
              <el-input v-model="formData.highDensityLipoprotein" size="small">
                <span slot="suffix" class="el-input__icon">mmol/L</span>
              </el-input>
            </el-form-item>
          </el-col>
          <el-col :span="6">
            <el-form-item label="低密度脂蛋白" label-width="140px">
              <el-input v-model="formData.lowDensityLipoprotein" size="small">
                <span slot="suffix" class="el-input__icon">mmol/L</span>
              </el-input>
            </el-form-item>
          </el-col>
          <el-col :span="6">
            <el-form-item label="甘油三酯" label-width="120px">
              <el-input v-model="formData.triglyceride" size="small">
                <span slot="suffix" class="el-input__icon">mmol/L</span>
              </el-input>
            </el-form-item>
          </el-col>
          <el-col :span="6">
            <el-form-item label="总胆固醇" label-width="120px">
              <el-input v-model="formData.totalCholesterol" size="small">
                <span slot="suffix" class="el-input__icon">mmol/L</span>
              </el-input>
            </el-form-item>
          </el-col>
          <el-col :span="12">
            <el-form-item label="心电图检查" label-width="140px">
              <el-input v-model="formData.ecgCheckDesc" size="small">
                <span slot="suffix" class="el-input__icon">mg/L</span>
              </el-input>
            </el-form-item>
          </el-col>
        </el-row>
        <el-footer style="text-align: center;margin-top: 30px">
          <el-button type="primary" @click="saveFormFn">保存</el-button>
          <el-button plain @click="cancelFn">取消</el-button>
        </el-footer>
      </el-form>
    </el-main>
    <el-dialog
      :visible.sync="openDia"
      :close-on-click-modal="false"
      width="55%"
      center>
      <div>
        <el-input v-model="name" placeholder="录入姓名检索" style="width: 20%"/>
        <el-button icon="el-icon-search" type="primary" @click="fetchbasicinfo">查询</el-button>
      </div>
      <div style="margin-top: 10px; height: 350px">
        <el-table
          ref="appointmentTable"
          :data="userInfo"
          :header-cell-style="{textAlign: 'center', backgroundColor: '#f2f2f2'}"
          border
          height="500"
          class="selfAdaptive_H_table"
          style="width:100%"
          @row-dblclick="selectCur"
        >
          <el-table-column
            prop="healthNo"
            width="210"
            align="center"
            label="健康档案编号"/>
          <el-table-column
            prop="name"
            align="center"
            label="姓名"/>
          <el-table-column
            align="center"
            label="性别">
            <template slot-scope="scope">
              <span v-show="scope.row.sex == 1">男</span>
              <span v-show="scope.row.sex == 2">女</span>
            </template>
          </el-table-column>
          <el-table-column
            width="120"
            prop="birthday"
            align="center"
            label="出生日期"/>
          <el-table-column
            prop="age"
            align="center"
            label="年龄"/>
          <el-table-column
            width="210"
            prop="idNumber"
            align="center"
            label="身份证号"/>
          <el-table-column
            width="180"
            prop="homeAddress"
            align="center"
            label="家庭住址"/>
          <el-table-column
            prop="createTime"
            width="180"
            align="center"
            label="建档时间"/>
        </el-table>
      </div>
    </el-dialog>
  </el-container>
</template>

<script>
import { GetdoctorData } from '@/api/DoctorMaintenance'
import { addForm, editForm, queryByManagerNo, queryUerData } from '@/api/hyperManagementCard/index'
// import { queryUerData } from '@/api/oldsHealthManagement/basicInfo'
import moment from 'moment'
export default {
  data () {
    return {
      openDia: false,
      name: '',
      manageList: [ // 管理组别列表
        { label: '重点组', value: '1' },
        { label: '好转组', value: '2' },
        { label: '稳定组', value: '3' }
      ],
      // 高血压、冠心病、脑卒中、糖尿病、以上都无、不详、拒答
      familyHistoryList: [ // 家族史
        { label: '高血压', value: '1' },
        { label: '冠心病', value: '2' },
        { label: '脑卒中', value: '3' },
        { label: '糖尿病', value: '4' },
        { label: '以上都无', value: '5' },
        { label: '不详', value: '6' },
        { label: '拒答', value: '7' }
      ],
      symptomCodeList: [ // 目前症状
        { label: '头痛', value: '1' },
        { label: '头晕', value: '2' },
        { label: '心悸', value: '3' },
        { label: '胸闷', value: '4' },
        { label: '胸痛', value: '5' },
        { label: '咳嗽', value: '6' },
        { label: '咳痰', value: '7' },
        { label: '呼吸困难', value: '8' },
        { label: '多饮', value: '9' },
        { label: '多尿', value: '10' },
        { label: '体重下降', value: '11' },
        { label: '乏力', value: '12' },
        { label: '关节肿痛', value: '13' },
        { label: '视力模糊', value: '14' },
        { label: '四肢麻木', value: '15' },
        { label: '消瘦', value: '16' },
        { label: '尿痛', value: '17' },
        { label: '便秘', value: '18' },
        { label: '腹泻', value: '19' },
        { label: '恶心呕吐', value: '20' },
        { label: '眼花', value: '21' },
        { label: '耳鸣', value: '22' },
        { label: '发热', value: '23' },
        { label: '鼻衄', value: '24' },
        { label: '浮肿', value: '25' },
        { label: '多食', value: '26' },
        { label: '皮疹', value: '27' },
        { label: '其他', value: '99' }
      ],
      docList: [], // 建档医生列表
      userInfo: [],
      formData: {
        'address': '',
        'birthDate': '',
        'bodyMassIndex': '',
        'cerebrovascularDisease': '', // 脑血管疾病
        'cerebrovascularDiseaseAry': [], // 脑血管疾病
        'createDate': '',
        'createDoctor': '',
        'createOrg': '',
        'dataSource': '',
        'diastolicPressure': '',
        'drinkCapacity': '',
        'ecgCheckDesc': '',
        'endDate': '',
        'endPerson': '',
        'endReason': '',
        'exerciseTimeLen': '',
        'eyeDisease': '', // 眼部疾病
        'eyeDiseaseAry': [], // 眼部疾病
        'familyHistory': '',
        'familyHistoryAry': [],
        'fastingBloodGlucose': '',
        'healthNo': '',
        'heartDisease': '', // 心脏疾病
        'heartDiseaseAry': [], // 心脏疾病
        'height': '',
        'highDensityLipoprotein': '',
        // 'id': 0,
        'kidneyDisease': '', // 肾脏疾病
        'kidneyDiseaseAry': [], // 肾脏疾病
        'lowDensityLipoprotein': '',
        'manageGroup': '',
        'managerNo': '',
        'marital': '',
        'name': '',
        'performanceState': '',
        'phone': '',
        'profession': '',
        'recentDrugList': '', // 近期药物治疗情况
        // 'recentDrugList': [], // 近期药物治疗情况
        'recentDrugListAry': [], // 近期药物治疗情况
        'sex': '',
        'smoke': '',
        'symptomCode': '',
        'symptomCodeAry': '', // 目前症状
        'systolicPressure': '',
        'totalCholesterol': '',
        'triglyceride': '',
        'validStatus': '',
        'waistline': '',
        'weekDrink': '',
        'weekExercise': '',
        'weight': '',
        'age': 0,
        'idNum': ''
      },
      rules: {
        manageGroup: [
          { required: true, message: '请选择', trigger: 'change' }
        ],
        dataSource: [
          { required: true, message: '请选择病例来源', trigger: 'change' }
        ]

      }
    }
  },
  created() {
    this.getDoctorData()
    this.queryByManagerNoFn()
    this.formData.createDoctor = JSON.parse(sessionStorage.getItem('user')).userNo
    this.formData.createOrg = JSON.parse(sessionStorage.getItem('user')).orgNo
    this.formData.createDate = moment().format('YYYY-MM-DD')
    // this.formData.createOrg = this.$store.getters.user.orgNo
  },
  activated() {
    this.getDoctorData()
    this.queryByManagerNoFn()
    this.formData.createDoctor = JSON.parse(sessionStorage.getItem('user')).userNo
    this.formData.createOrg = JSON.parse(sessionStorage.getItem('user')).orgNo
    this.formData.createDate = moment().format('YYYY-MM-DD')
  },
  methods: {
    // 一键导入
    imported() {
      this.openDia = true
    },
    // 初始化获取医生列表
    getDoctorData () {
      GetdoctorData({ current: 1, pageSize: 1000 })
        .then(res => {
          if (res.data.code === 200 && res.data.data !== null) {
            this.docList = res.data.data
          }
        })
    },
    // 获取基本信息  点击查询
    async fetchbasicinfo() {
      const obj = {
        name: this.name,
        pageNum: 1,
        pageSize: 10
      }
      const { data: res } = await queryUerData(obj)
      if (res.code === 200) {
        this.userInfo = res.data.data
      }
    },
    // 获取基本信息  界面跳转过来
    async queryByManagerNoFn() {
      // this.managerNo = JSON.parse(this.$route.query.sendData).managerNo
      // console.log(this.managerNo)
      const obj = {
        managerNo: JSON.parse(this.$route.query.sendData).managerNo
      }
      const { data: res } = await queryByManagerNo(obj)
      console.log(res)
      if (res.code === 200) {
        // 这样赋值不能从新选择了
        // this.formData = res.data
        // this.formData.familyHistory ? this.formData.familyHistoryAry = res.data.familyHistory.split(',') : this.formData.familyHistoryAry = []
        // this.formData.symptomCode ? this.formData.symptomCodeAry = this.formData.symptomCode.split(',') : this.formData.symptomCodeAry = []
        // this.formData.cerebrovascularDisease ? this.formData.cerebrovascularDiseaseAry = this.formData.cerebrovascularDisease.split(',') : this.formData.cerebrovascularDiseaseAry = []
        // this.formData.heartDisease ? this.formData.heartDiseaseAry = this.formData.heartDisease.split(',') : this.formData.heartDiseaseAry = []
        // this.formData.kidneyDisease ? this.formData.kidneyDiseaseAry = this.formData.kidneyDisease.split(',') : this.formData.kidneyDiseaseAry = []
        // this.formData.eyeDisease ? this.formData.eyeDiseaseAry = this.formData.eyeDisease.split(',') : this.formData.eyeDiseaseAry = []
        res.data.familyHistory ? res.data.familyHistoryAry = res.data.familyHistory.split(',') : res.data.familyHistoryAry = []
        res.data.symptomCode ? res.data.symptomCodeAry = res.data.symptomCode.split(',') : res.data.symptomCodeAry = []
        res.data.cerebrovascularDisease ? res.data.cerebrovascularDiseaseAry = res.data.cerebrovascularDisease.split(',') : res.data.cerebrovascularDiseaseAry = []
        res.data.heartDisease ? res.data.heartDiseaseAry = res.data.heartDisease.split(',') : res.data.heartDiseaseAry = []
        res.data.kidneyDisease ? res.data.kidneyDiseaseAry = res.data.kidneyDisease.split(',') : res.data.kidneyDiseaseAry = []
        res.data.eyeDisease ? res.data.eyeDiseaseAry = res.data.eyeDisease.split(',') : res.data.eyeDiseaseAry = []
        res.data.recentDrugList ? res.data.recentDrugListAry = JSON.parse(res.data.recentDrugList) : res.data.recentDrugListAry = []
        this.formData = res.data
        // this.formData.recentDrugListAry = JSON.parse(res.data.recentDrugList)
        console.log(this.formData.cerebrovascularDiseaseAry)
        console.log(this.formData.heartDiseaseAry)
        console.log(this.formData.kidneyDiseaseAry)
        console.log(8889)
        console.log(this.formData)
      }
    },
    // 选中当前信息
    selectCur(row) {
      console.log(row)
      // 处理一键导入出来的字段和表单字段名称不一致
      this.formData.healthNo = row.healthNo
      this.formData.name = row.name
      this.formData.sex = row.sex === '1' ? '男' : '女'
      this.formData.marital = row.maritalstatus
      this.formData.profession = row.occupation
      this.formData.birthDate = row.birthday
      this.formData.address = row.homeAddress || ''
      this.formData.phone = row.phone
      // this.formData.managerNo = row.healthNo
      this.formData.age = row.age
      this.formData.idNum = row.idNumber
      console.log(this.formData)
      this.openDia = false
      // this.$refs.basicinfo.sendData(row)
      this.name = ''
      this.userInfo = []
    },
    // 添加
    addRow() {
      let propertyUpdate = this.formData.recentDrugListAry.filter(item => { return item.isUpdate === false })
      if (propertyUpdate.length === 0) {
        this.formData.recentDrugListAry.unshift({
          drugName: '',
          usage: '',
          dosage: '',
          isUpdate: false
        })
      } else {
        this.$message.warning('请完善添加的信息')
      }
    },
    // 删除
    deleteRow(index, tabledata) {
      this.formData.recentDrugListAry.splice(index, 1)
    },
    // 近期药物 保存
    saveRow(index, tabledata) {
      // tabledata[index].drugName = tabledata[index].drugName
      // tabledata[index].usage = tabledata[index].protection === '1' ? '是' : tabledata[index].protection === '2' ? '否' : ''
      // tabledata[index].dosage = this.codeToname(tabledata[index].virusType)
      console.log(123)
      console.log(tabledata[index])
      tabledata[index].isUpdate = true
    },
    // 保存
    saveFormFn() {
      this.formData.cerebrovascularDiseaseAry ? this.formData.cerebrovascularDisease = this.formData.cerebrovascularDiseaseAry.join(',') : this.formData.cerebrovascularDisease = ''
      this.formData.eyeDiseaseAry ? this.formData.eyeDisease = this.formData.eyeDiseaseAry.join(',') : this.formData.eyeDisease = ''
      this.formData.heartDiseaseAry ? this.formData.heartDisease = this.formData.heartDiseaseAry.join(',') : this.formData.heartDisease = ''
      this.formData.kidneyDiseaseAry ? this.formData.kidneyDisease = this.formData.kidneyDiseaseAry.join(',') : this.formData.kidneyDisease = ''
      this.formData.symptomCodeAry ? this.formData.symptomCode = this.formData.symptomCodeAry.join(',') : this.formData.symptomCode = ''
      this.formData.recentDrugListAry.length > 0 ? this.formData.recentDrugList = JSON.stringify(this.formData.recentDrugListAry) : this.formData.recentDrugList = ''
      this.formData.familyHistoryAry ? this.formData.familyHistory = this.formData.familyHistoryAry.join(',') : this.formData.familyHistory = ''
      console.log(this.formData.cerebrovascularDiseaseAry, this.formData.cerebrovascularDisease)
      this.$refs.formData.validate(async (valid) => {
        if (valid) {
          // alert('submit!')
          if (this.formData.managerNo) {
            // console.log('点了查看是编辑')
            const { data: res } = await editForm(this.formData)
            if (res.code === 200) {
              this.$message.success('编辑成功')
              this.formData = {
                'address': '',
                'birthDate': '',
                'bodyMassIndex': '',
                'cerebrovascularDisease': '', // 脑血管疾病
                'cerebrovascularDiseaseAry': [], // 脑血管疾病
                'createDate': '',
                'createDoctor': '',
                'createOrg': '',
                'dataSource': '',
                'diastolicPressure': '',
                'drinkCapacity': '',
                'ecgCheckDesc': '',
                'endDate': '',
                'endPerson': '',
                'endReason': '',
                'exerciseTimeLen': '',
                'eyeDisease': '', // 眼部疾病
                'eyeDiseaseAry': [], // 眼部疾病
                'familyHistory': '',
                'familyHistoryAry': [],
                'fastingBloodGlucose': '',
                'healthNo': '',
                'heartDisease': '', // 心脏疾病
                'heartDiseaseAry': [], // 心脏疾病
                'height': '',
                'highDensityLipoprotein': '',
                // 'id': 0,
                'kidneyDisease': '', // 肾脏疾病
                'kidneyDiseaseAry': [], // 肾脏疾病
                'lowDensityLipoprotein': '',
                'manageGroup': '',
                'managerNo': '',
                'marital': '',
                'name': '',
                'performanceState': '',
                'phone': '',
                'profession': '',
                'recentDrugList': '', // 近期药物治疗情况
                // 'recentDrugList': [], // 近期药物治疗情况
                'recentDrugListAry': [], // 近期药物治疗情况
                'sex': '',
                'smoke': '',
                'symptomCode': '',
                'symptomCodeAry': '', // 目前症状
                'systolicPressure': '',
                'totalCholesterol': '',
                'triglyceride': '',
                'validStatus': '',
                'waistline': '',
                'weekDrink': '',
                'weekExercise': '',
                'weight': '',
                'age': 0,
                'idNum': ''
              }
            }
          } else {
            // console.log('没点查看是新增')
            const { data: res } = await addForm(this.formData)
            if (res.code === 200) {
              this.$message.success('新增成功')
              this.formData = {
                'address': '',
                'birthDate': '',
                'bodyMassIndex': '',
                'cerebrovascularDisease': '', // 脑血管疾病
                'cerebrovascularDiseaseAry': [], // 脑血管疾病
                'createDate': '',
                'createDoctor': '',
                'createOrg': '',
                'dataSource': '',
                'diastolicPressure': '',
                'drinkCapacity': '',
                'ecgCheckDesc': '',
                'endDate': '',
                'endPerson': '',
                'endReason': '',
                'exerciseTimeLen': '',
                'eyeDisease': '', // 眼部疾病
                'eyeDiseaseAry': [], // 眼部疾病
                'familyHistory': '',
                'familyHistoryAry': [],
                'fastingBloodGlucose': '',
                'healthNo': '',
                'heartDisease': '', // 心脏疾病
                'heartDiseaseAry': [], // 心脏疾病
                'height': '',
                'highDensityLipoprotein': '',
                // 'id': 0,
                'kidneyDisease': '', // 肾脏疾病
                'kidneyDiseaseAry': [], // 肾脏疾病
                'lowDensityLipoprotein': '',
                'manageGroup': '',
                'managerNo': '',
                'marital': '',
                'name': '',
                'performanceState': '',
                'phone': '',
                'profession': '',
                'recentDrugList': '', // 近期药物治疗情况
                // 'recentDrugList': [], // 近期药物治疗情况
                'recentDrugListAry': [], // 近期药物治疗情况
                'sex': '',
                'smoke': '',
                'symptomCode': '',
                'symptomCodeAry': '', // 目前症状
                'systolicPressure': '',
                'totalCholesterol': '',
                'triglyceride': '',
                'validStatus': '',
                'waistline': '',
                'weekDrink': '',
                'weekExercise': '',
                'weight': '',
                'age': 0,
                'idNum': ''
              }
            }
          }
        } else {
          this.$message.warning('请填写完整！')
          return false
        }
      })
    }
  }

}
</script>

<style lang="less" scoped>
.layout_container {
  padding: 20px;
  .top{
    text-align: right;
  }
  .line{
    text-align: center;
    // vertical-align: middle;
    line-height: 40px;
  }
}
</style>

注意：

你直接赋值给formData数据没get和set

3、妇幼之前的 添加新生儿那一部分代码

所有项目归纳总结二

4、sass小程序医患端，小程序发送语音

所有项目归纳总结二

5、医疗质量指标前端，动态添加每行每列

所有项目归纳总结二

6、妇幼的，table每行可编辑

所有项目归纳总结二

7、小程序添加每行每列

所有项目归纳总结二

8、找博客上封装的组件全局组件，传颜色就可以改

所有项目归纳总结二

9、bi-wxapp小程序封装的echars组件，日期组件（这篇单独写了）

放链接：juejin.cn/post/707005…

10、妇幼的打印功能

所有项目归纳总结二

11、整个妇幼架构，妇幼的老年人健康管理

所有项目归纳总结二

12、各项目中遇到的问题

所有项目归纳总结二

13、项目中所用网站

Vue.js 中文文档

vuejs.bootcss.com/guide/compu…

element

element.eleme.cn/#/zh-CN/com…

vue-element-admin

panjiachen.github.io/vue-element…

Gitea 项目代码管理

http://192.168.0.168:3000/new-zy-crm/zy-crm

微信公众平台

mp.weixin.qq.com/

Wux Weapp 小程序ui组件

wux-weapp.github.io/wux-weapp-d…

icon阿里巴巴图标库

www.iconfont.cn/

轻量、可靠移动端组件库

youzan.github.io/vant-weapp/…

雀语

www.yuque.com/lyndon/dayl…

力扣算法网站

leetcode-cn.com/leetbook/de…

医院单点登录系统

https://192.168.0.183/portal_hosp

账户sjb 密码sjb123

腾讯企业邮箱

exmail.qq.com/cgi-bin/log…

廖雪峰git分支管理

www.liaoxuefeng.com/wiki/896043…

人人都是产品经理

www.woshipm.com/

工作得后端api文档地址

http://192.168.0.231:8801/doc.html