// 消息提示
import {
  notify
} from '../util/item';
import {
  mapActions
} from 'vuex';
// 表格组件
import xfTable from '../model/tableColmn';
// 按钮组件
import xfButtons from '../model/buttons.vue';
// 按钮权限引入
import {
  buttonPermiss
} from '../util/authority';

/**
 * 项目站点管理等公有属性标识
 */
export default {
  data () {
    return {
      'authority': {},
      'projectData': [],
      'siteDataTc': [],
      'deleteList': [],
      'searchVal': '', //搜索框内容
      'modelHead': ['添加数据', '修改数据'],
      'page': { //表格分页
        'pageSizes': [10, 20, 30, 40], //默认可以调节展示的页数
        'currentPage': 1, //当前页数
        'total': 1, //总条数
        'pageSize': 10 //默认展示多少条数据
      }
    };
  },
  created () {
    // 按钮权限问题,
    this.authority = buttonPermiss(this.$route.name);
    // this.loadOption.menu = buttonPermiss(this.$route.name)['menu'];
  },
  mounted () { },
  'components': {
    xfTable,
    xfButtons
  },
  'methods': {
    ...mapActions({
      'distingLoading': 'system/distingLoading' // 取消或添加请求的loading状态框
    }),
    authorityMeth (name) {
      // 按钮权限问题,
      this.authority = buttonPermiss(name);
    },
    async getTableData (params, url, dif = 1) {
      /**
       * 初次进入,获取表格的值
       * @param {Object} params 传入的值
       * @param {String} url http路径
       * @return {Object} promise对象 成功或者失败的callback
       */
      try {
        // this.distingLoading(true)
        let res = '';

        if (dif === 1) {
          res = await this.$http.get(url, params);
        } else {
          res = await this.$http.post(url, params);
        }
        // this.distingLoading(false)

        return new Promise((resolve, reject) => {
          this.setCurrent();
          resolve(res);
        });
      } catch (error) {
        this.$store.commit('system/loading', false);
        throw new Error(error)
      }
    },
    async getHttpDatas (url, params = {}, httpType = 1, type = 1) {
      /**
       * 数据存储
       * @param {String} url 请求到的连接，格式为data-code类型
       * @param {Object} params 请求连接
       * @param {Number} httpType 数据请求类型，1为get，2为post
       * @param {Number} type 类型2为有提示消息
       */

      try {
        // 请求的loading的隐藏
        // this.distingLoading(true)
        let res = '';

        if (httpType === 1) {
          res = await this.$http.get(url, {
            params: params
          });
        } else {
          res = await this.$http.post(url, params);
        }
        // this.distingLoading(false)
        let response = res.data.data ? res.data.data : [];

        if (type === 2 && res.data.code === 200) {
          // 成功提示
          notify(res);
        }

        return new Promise((resolve, reject) => {
          resolve(response);
        });
      } catch (error) {
        console.log(error);
      }

    },
    setCurrent () {
      // 清理选中行
      this.clickValue = '';
      this.$refs.table ? this.$refs.table.emptyCurrentRo() : null;
    },
    correct (formName) {
      // 表单验证
      return new Promise((resolve, reject) => {
        this.$refs[formName].validate((valid) => {
          if (valid) {
            resolve()
          } else {
            console.log('error submit!!');
            reject()
            return false;
          }
        });
      })
    },
    searChange (val) {
      // 输入框改变时触发
      this.searchVal = val;
    },
    rendering (response) {
      // 表格数据渲染

      if (response.data.code !== 200) {
        notify(response);
      }

      this.$set(this.page, 'total', response.data.data ? response.data.data.total : 1)
      this.getSiteData = response.data.data ? response.data.data.list : [];

      // 当删除多条数据的时候，监测上一页数据量，并展示
      if (this.getSiteData.length === 0 && this.page.currentPage !== 1) {
        this.$set(this.page, 'currentPage', this.page.currentPage - 1)

        this.getLists(this.searchVal);
      }
      // 调用子组件首次加载数据
      this.$refs.table.onLoad(this.getSiteData, this.loadOption, this.page);
    },
    handleCurrentRowChange (row) {
      // 表格行单击选中,进行数据存储,并进行判断
      this.clickValue = row;
    },
    clickeEdit () {
      // 单击选中行修改
      if (!this.clickValue) {
        this.$notify.warning('请先选择要修改的行,再进行数据修改!');
        return;
      } else {
        this.handleEdit(this.clickValue);
      }
    },
    searchChange (val = '') {
      // 搜索数据
      this.searchVal = val;
      this.$set(this.page, 'currentPage', 1)
      if (val === '') {
        this.getLists();
        return
      }

      this.getLists(val);

    },
    currentChange (val) {
      /**
       * 翻页功能
       * @param {String} val 当前页数
       */

      this.$set(this.page, 'currentPage', val)
      this.getLists(this.searchVal);
    },
    sizeChange (val) {
      /**
       * 选择展示默认展示多少条数据
       * @param {String} val 当前选中每次展示多少条
       */
      this.$set(this.page, 'currentPage', 1)
      this.$set(this.page, 'pageSize', val)

      this.getLists();
    },
    resetChecked (formName = 'ruleForm') {
      // 清空表单状态和值
      this.$nextTick(() => {
        setTimeout(() => {
          let falge = this.$refs[formName];

          if (falge) {
            this.$refs[formName].clearValidate();
          }
        }, 300);
      });
    },
    refreshChange (val) {
      // 暂无数据,点击刷新
      this.getLists(val);
    },
    openContent () {
      // 打开模态框方法
    },
    closeContent () {
      // 关闭模态框方法
    },
    delectVals () {
      /**
       * 批量删除
       * @param {Number} type 1为,分割；2为数组格式
       */
      if (this.deleteList.length === 0) {
        this.$notify({
          'message': '请选择要删除的数据!',
          'type': 'warning'
        });
      } else {
        this.$confirm('是否确认删除选择数据,删除后不可恢复?', '提示', {
          'confirmButtonText': '确定',
          'cancelButtonText': '取消',
          'type': 'warning'
        }).then(() => {
          let datas = [];

          this.deleteList.forEach(item => {
            datas.push(item[this.deleteId]);
          });

          datas = datas.join(',');
          this.deleteUserLise(datas, this.deleteList = []);
        }).catch(() => {
          this.$notify({
            'type': 'info',
            'message': '已取消删除'
          });
        });
      }
    },
    selectionChange (list) {
      // 删除选中框
      this.deleteList = list;
    },
    delectVal (row = []) {
      /**
       * 删除此行数据
       * @param {object} row
       */
      let rows = row;
      this.$confirm('是否删除选择数据 , 删除后不可恢复 ?', '提示', {
        'cancelButtonText': '取消',
        'confirmButtonText': '确定',
        'type': 'warning'
      }).then(() => {
        if (Array.isArray(row)) {
          // 删除多条数据
          let datas = [];

          this.deleteList.forEach(item => {
            datas.push(item[this.deleteId]);
          });
          datas = datas.join(',');
          this.deleteUserLise(datas, this.deleteList);
        } else {
          // 单行删除
          this.deleteUserLise(row[this.deleteId], rows);
        }

      }).catch(() => {
        this.$notify({
          'type': 'info',
          'message': '已取消删除'
        });
      });
    },
    async asyncDelete (params, url) {
      // 删除
      const response = await this.$http.delete(url, params);

      notify(response);
      if (response.data.code === 200) {
        this.getLists();
      }

    },
    async projectDatas () {
      /**
       * 获取项目信息
       */
      this.deleteList = [];
      let datas = {
        'params': {
          'projectName': '',
          'pageNo': 1,
          'pageSize': 1000
        }
      };
      let response = await this.getTableData(datas, this.nozzle.projectGet);

      this.projectData = response.data ? response.data.data.list : [];
    },
    async siteGet (projectNo) {
      // 站点数据填充
      let datas = {
        'params': {
          'projectNo': projectNo
        }
      };
      const response = await this.$http.get(this.nozzle.getListByNosA, datas);

      if (response.data.code === 200) {
        this.siteDataTc = response.data.data.list;
      } else {
        this.siteDataTc = [];
      }
    },
    getWarrantS () {
      /**
       * 获取权限信息
       */
      this.ruleFormWarrant['permissionIds'] = [];
      this.deleteList = [];
      let datas = {
        'pageSize': 1000,
        'pageNo': 1
      };

      this.$http.get(this.nozzle.permissionList, {
        'params': datas
      }).then(response => {
        this.warrantDatas = response.data ? response.data.data.list : [];
        // 调用子组件首次加载数据
      });
    },
    async warrantAdd (datas, url) {
      // 权限控制处理
      this.dataWarrant = false;
      let response = await this.$http.get(url, {
        'params': datas
      });

      notify(response);
    },
    compareTime (startDate, endDate) {
      // 开始时间和结束时间的比较
      if (startDate.length > 0 && endDate.length > 0) {
        var startDateTemp = startDate.split(' ');
        var endDateTemp = endDate.split(' ');

        var arrStartDate = startDateTemp[0].split('-');
        var arrEndDate = endDateTemp[0].split('-');

        var arrStartTime = startDateTemp[1].split(':');
        var arrEndTime = endDateTemp[1].split(':');

        var allStartDate = new Date(arrStartDate[0], arrStartDate[1], arrStartDate[2], arrStartTime[0], arrStartTime[1], arrStartTime[2]);
        var allEndDate = new Date(arrEndDate[0], arrEndDate[1], arrEndDate[2], arrEndTime[0], arrEndTime[1], arrEndTime[2]);

        if (allStartDate.getTime() >= allEndDate.getTime()) {
          this.$notify({
            'type': 'warning',
            'message': '项目开始时间不能大于项目结束时间'
          });
          return false;
        } else {
          // alert("startTime小于endTime，所以通过了");
          return true;
        }
      } else {
        alert('时间不能为空');
        return false;
      }
    },
    notEmpty (value, serial) {
      // 输入框首字母为非空
      if (value.length === 1 && value === ' ') {
        this.ruleForm[serial] = '';
        this.$notify({
          'type': 'warning',
          'message': '首字母不能为空格,请重新输入'
        });
      }
    },
    onCopy (e) {
      // 复制成功
      this.$notify({
        type: 'success',
        message: '复制成功'
      })
    },
    // 复制失败
    onError (e) {
      this.$notify({
        type: 'success',
        message: '复制失败'
      })
    },
  }
};