<!-- 任务列表 - 数据任务 && 数据补遗 编辑界面 -->
<template>
<div id="dailyWindow">
<h2 class="text-center sectionH2">
<span class='pull-left' @click='gohistory'>
< 返回 </span> {{modelH}} </h2> <el-form :model="ruleForm" :rules="rules" ref="ruleForm" label-width="120px"
class="demo-ruleForm">
<el-row class="basicB">
<p class="formJcDoc">基本信息</p>
<el-col :span='15' class="m-t-20 p-l-22">
<el-form-item label="任务名称：" prop="taskName">
<el-input v-model="ruleForm.taskName" placeholder="请输入任务名称"></el-input>
</el-form-item>
</el-col>
<el-col :span='15' class="p-l-22">
<el-form-item label="任务描述：" style='margin:5px 0 17px 0'>
<el-input type="textarea" v-model="ruleForm.taskDetail" placeholder="请输入任务描述"></el-input>
</el-form-item>
</el-col>
</el-row>
<!-- 连接 -->
<el-row class="basicB m-t-24">
<p class="formJcDoc">连接</p>
<el-col :span='7' class="m-t-20 p-l-22">
<el-form-item label="连接：" prop='taskParams.dataBase'>
<el-select @change="dataSourceChange" v-model="ruleForm.taskParams.dataBase" placeholder="请选择连接">
<el-option v-for='(item,index) in datasSources' :key='index' :label="item.value" :value="item.value">
</el-option>
</el-select>
</el-form-item>
</el-col>
<el-col :span='7' class="m-t-20 p-l-22">
<el-form-item label="数据表：" prop='taskParams.tableName'>
<el-autocomplete @select='dataSourceTable' class="inline-input w130"
v-model="ruleForm.taskParams.tableName" :fetch-suggestions="querySearch" placeholder="请选择数据表">
</el-autocomplete>
</el-form-item>
</el-col>
<el-col :span='1' class="text-right m-t-30">
<div class="aboutType">
<el-tooltip class="item" effect="dark" content="数据处理任务将直接更新表中的数据" placement="top-start">
<span><i class="iconfont icon-49"></i></span>
</el-tooltip>
</div>
</el-col>
<el-col :span='15' class="p-l-22">
<el-form-item label="过滤条件：">
<el-input type="textarea" v-model="ruleForm.taskParams.queryConditions" placeholder="请输入过滤条件">
</el-input>
<div class="aboutType">
<span><i class="iconfont icon-49"></i>SQL过滤条件，对站点进行过滤</span>
<!-- <el-button @click.native='detectionTest' type='primary' size="mini" class='dataSourceTest'>连接测试</el-button> -->
</div>
<div :class="{'el-form-itemSuccess':sourceStatus,'el-form-item__error':!sourceStatus}"
v-show='sourceErrorStatus'>
{{sourceError}}
</div>
</el-form-item>
</el-col>
</el-row>
<!-- 数据处理 -->
<el-row class="basicB m-t-24">
<p class="formJcDoc">数据处理</p>
<!-- 数据自动检测和阈值检测 -->
<el-form-item v-if='!addendum' style='margin-left:-120px;'>
<el-col :span='14' class="p-l-22 m-t-20" style='height:28px;'>
<el-form-item label='检测方式：' prop='taskParams.detectionType'>
<el-select @change='detectionTypeChange' v-model="ruleForm.taskParams.detectionType" placeholder="
阈值检测">
<el-option v-for='(item,index) in testJC' :key='index' :label="item.label" :value="item.value">
</el-option>
</el-select>
</el-form-item>
</el-col>
<el-col :span='1' class="text-right m-t-10" style='display: inline-block;
transform: translatey(10px);'>
<div class="aboutType ">
<el-tooltip class="item" effect="dark"
content="阈值检测是需要指定异常值的范围，阈值检测将使用随机值替换异常值；自动检测只需要指定检测字段，由系统自动根据算法检测异常值，将使用预测值替换异常值"
placement="top-start">
<span><i class="iconfont icon-49"></i>
</span>
</el-tooltip>
</div>
</el-col>
</el-form-item>
<!-- 补遗数据 -->
<el-row class="p-l-22 m-t-24">
<el-col :span='15' v-if='addendum'>
<el-form-item label="主键字段：" prop='taskParams.primaryKey'>
<el-select v-model="ruleForm.taskParams.primaryKey" placeholder="请选择主键字段">
<el-option v-for='(item,index) in sourcesKeysField' :key='item+666' :label="item" :value="item">
</el-option>
</el-select>
</el-form-item>
</el-col>
</el-row>
<!-- 数据处理之 阈值检测和自动检测 -->
<el-row class="p-l-22">
<el-col :span='15'>
<el-form-item label="标识字段：" prop='taskParams.markField'>
<el-select v-model="ruleForm.taskParams.markField" placeholder="请选择标识字段">
<el-option v-for='(item,index) in sourcesField' :key='item.value' :label="item.label"
:value="item.value">
</el-option>
</el-select>
</el-form-item>
</el-col>
</el-row>
<el-row class="p-l-22">
<el-col :span='7'>
<el-form-item label="时间字段：" prop='taskParams.tt'>
<el-select v-model="ruleForm.taskParams.tt" placeholder="请选择时间字段">
<el-option v-for='(item,index) in sourcesField' :key='item.value' :label="item.label"
:value="item.value">
</el-option>
</el-select>
</el-form-item>
</el-col>
<el-col :span='7' class="p-l-22">
<el-form-item :label="timeDataText + '：'" prop='taskParams.interval'>
<el-input type='number' v-model.number="ruleForm.taskParams.interval"
:placeholder="'请输入'+timeDataText">
</el-input>
</el-form-item>
</el-col>
<el-col :span='1' class="text-right">
<div class="aboutType m-t-10">
<el-tooltip class="item" effect="dark" :content="'时间序列需要指定时间字段，以及'+timeDataText"
placement="top-start">
<span><i class="iconfont icon-49"></i>
</span>
</el-tooltip>
</div>
</el-col>
<el-col :span='14'>
<el-form-item label="补遗时间：" prop='taskParams.timeArray'>
<el-date-picker :editable="false" v-model="ruleForm.taskParams.timeArray" type="datetimerange"
range-separator=" ~ " start-placeholder="开始日期" end-placeholder="结束日期">
</el-date-picker>
</el-form-item>
</el-col>
<el-col :span='1' class="text-right">
<div class="aboutType m-t-10">
<el-tooltip class="item" effect="dark" content="补遗时间指定了数据异常检测和补遗的时间段" placement="top-start">
<span><i class="iconfont icon-49"></i>
</span>
</el-tooltip>
</div>
</el-col>
</el-row>
<!-- 数据补遗表单 -->
<div v-if='addendum'>
<el-row v-for='(items,indexs) in ruleForm.taskParams.addendum' :key='indexs+99' class="p-l-22">
<el-col :span='7'>
<el-form-item label="补遗字段：" prop='taskParams.addendum[0].factor'>
<el-select v-model="items.factor" placeholder="请选择补遗字段">
<el-option v-for='(item,index) in sourcesField' :key='item.value' :label="item.label"
:value="item.value">
</el-option>
</el-select>
</el-form-item>
</el-col>
<el-col :span='7' class="p-l-22">
<el-form-item label="补遗值：" prop='taskParams.addendum[0].value'>
<el-input type='number' v-model.number="items.value" placeholder="请输入补遗值"></el-input>
</el-form-item>
</el-col>
<el-col :span='1' class="addendumNames text-right">
<i @click='deleteAutoIcons("addendum",indexs)' class="iconfont icon-qiyong deleteIcon"></i>
</el-col>
</el-row>
<div class="aboutType conditiona">
<span @click='addendumAdd'><i class="iconfont icon-jia"></i>
添加补遗字段</span>
</div>
</div>
<div v-if='!addendum'>
<!-- 阈值检测 -->
<el-row v-show='threshold' v-for='(items,indexs) in ruleForm.taskParams.mapList' :key='indexs'
class="p-l-22">
<el-col :span='7'>
<el-form-item label="检测字段：">
<el-select v-model="items.factor" placeholder="请选择检测字段">
<el-option v-for='(item,index) in sourcesField' :key='item.value' :label="item.label"
:value="item.value">
</el-option>
</el-select>
</el-form-item>
</el-col>
<el-col :span='7' class="yzFlex l-h-40">
<span class="fzs addendumNames" style='margin-top:0'>取值范围</span>
<el-input type='number' v-model.number="items.minVal" placeholder="下限值"></el-input>
<span style='padding:0 10px;' class="addendumNames"> ~ </span>
<el-input type='number' v-model.number="items.maxVal" placeholder="上限值"></el-input>
</el-col>
<el-col :span='1' class="addendumNames text-right">
<i @click='deleteAutoIcons("mapList",indexs)' class="iconfont icon-qiyong deleteIcon"></i>
</el-col>
</el-row>
<!-- 自动检测 -->
<div v-show='automatic' v-for='(items,indexs) in ruleForm.taskParams.autoMapList' :key='indexs+299'>
<el-row class="p-l-22">
<el-col :span='7'>
<el-form-item label="检测字段：">
<el-select v-model="items.factor" placeholder="请选择检测字段">
<el-option v-for='(item,index) in sourcesField' :key='item.value' :label="item.label"
:value="item.value">
</el-option>
</el-select>
</el-form-item>
</el-col>
<el-col :span='7' class="p-l-22">
<el-form-item label="关联字段：" class="multiSelected">
<el-select v-model="items.multiples" multiple placeholder="请选择关联字段">
<el-option v-for="item in sourcesField" :key="item.value+1" :label="item.label"
:value="item.value">
</el-option>
</el-select>
</el-form-item>
</el-col>
<el-col :span='1' class="addendumNames text-right">
<i @click='deleteAutoIcons("autoMapList",indexs)' class="iconfont icon-qiyong deleteIcon"></i>
</el-col>
</el-row>
</div>
<!-- 条件检测 -->
<div v-show='condition'>
<el-row class="p-l-22">
<el-col :span='14'>
<el-form-item label="异常条件：">
<el-input v-model="ruleForm.taskParams.abnormalCondition" placeholder="请输入异常条件"></el-input>
</el-form-item>
</el-col>
<el-col :span='1' class="text-right">
<div class="aboutType m-t-10">
<el-tooltip class="item" effect="dark" content="异常条件指定了异常数据的判定条件" placement="top-start">
<span><i class="iconfont icon-49"></i>
</span>
</el-tooltip>
</div>
</el-col>
</el-row>
</div>
<!-- 条件检测 -->
<div v-show='condition' v-for='(items,indexs) in ruleForm.taskParams.conditionList' :key='indexs+399'>
<el-row class="p-l-22">
<el-col :span='7'>
<el-form-item label="更新字段：">
<el-select v-model="items.updateField" placeholder="请选择更新字段">
<el-option v-for='(item,index) in sourcesField' :key='item.value' :label="item.label"
:value="item.value">
</el-option>
</el-select>
</el-form-item>
</el-col>
<el-col :span='7' class="p-l-22">
<el-form-item label="更新值：" class="multiSelected">
<el-input v-model="items.updateValue" placeholder="请输入更新值"></el-input>
</el-form-item>
</el-col>
<el-col :span='1' class="addendumNames text-right">
<i @click='deleteAutoIcons("conditionList",indexs)' class="iconfont icon-qiyong deleteIcon"></i>
</el-col>
</el-row>
</div>
<!-- 阈值检测 -->
<div class="aboutType conditiona" v-show='threshold'>
<span @click='filterCondition'><i class="iconfont icon-jia"></i>
添加检测字段</span>
</div>
<!-- 自动检测 -->
<div class="aboutType conditiona" v-show='automatic'>
<span @click='filterAutoCondition'><i class="iconfont icon-jia"></i> 添加自动检测字段</span>
</div>
<!-- 条件检测 -->
<div class="aboutType conditiona" v-show='condition'>
<span @click='conditionAdd'><i class="iconfont icon-jia"></i> 添加检测字段</span>
</div>
</div>
<!-- 备份数据库 -->
<el-row class="p-l-22">
<el-col :span='15'>
<el-form-item label="更新策略：" prop='taskParams.updateStatus'>
<el-select v-model="ruleForm.taskParams.updateStatus" placeholder="请选择" @change='isUpdateS'>
<el-option v-for="item in updateStatu" :key="item.value" :label="item.label" :value="item.value">
</el-option>
</el-select>
</el-form-item>
</el-col>
</el-row>
<el-row v-if='bgcData' class="p-l-22">
<el-col :span='7'>
<el-form-item label="数据源：" prop='taskParams.backupDatabase'>
<el-select @change="dataSourceChangeDatabase" v-model="ruleForm.taskParams.backupDatabase"
placeholder="请选择数据源">
<el-option v-for='(item,index) in datasSources' :key='index' :label="item.value"
:value="item.value">
</el-option>
</el-select>
</el-form-item>
</el-col>
<el-col :span='8' class="p-l-22">
<el-form-item label="数据表：" prop='taskParams.backupTableName'>
<el-autocomplete class="inline-input w130" v-model="ruleForm.taskParams.backupTableName"
:fetch-suggestions="querySearchs" placeholder="请选择数据表">
</el-autocomplete>
</el-form-item>
</el-col>
</el-row>
<!-- 消息队列 -->
<div class="p-l-22" v-if='bgcData'>
<el-row>
<el-col :span='15'>
<el-form-item label="写入队列：" prop='taskParams.writeQueue'>
<el-select v-model="ruleForm.taskParams.writeQueue" placeholder="请选择" @change='writeQueChange'>
<el-option v-for="item in writeQueueDatas" :key="item.value" :label="item.label"
:value="item.value">
</el-option>
</el-select>
</el-form-item>
</el-col>
</el-row>
<el-row v-if='writeQue'>
<el-col :span='7'>
<el-form-item label="消息连接：">
<el-select @change="sqlSourceShow" v-model="ruleForm.taskParams.queueDataSource"
placeholder="请选择消息连接">
<el-option v-for='(item,index) in addSourceMap' :key='index' :label="item.value"
:value="item.value">
</el-option>
</el-select>
</el-form-item>
</el-col>
<el-col :span='8' class="p-l-22">
<el-form-item label="队列名称：">
<el-select class="inline-input w130" v-model="ruleForm.taskParams.queueName" placeholder="请选择队列名称">
<el-option v-for='(item,index) in addSourceValue1' :key='index' :label="item.value"
:value="item.value">
</el-option>
</el-select>
</el-form-item>
</el-col>
</el-row>
</div>
</el-row>
<!-- 调度配置 -->
<el-row class="basicB m-t-24">
<p class="formJcDoc">调度配置</p>
<el-form-item label="周期类型：" class="p-l-22 m-t-20">
<el-radio-group @change='executeChange' v-model="ruleForm.isTemp">
<el-radio label="Y">临时任务</el-radio>
<el-radio label="N">周期任务</el-radio>
</el-radio-group>
</el-form-item>
<el-row v-if='cronExpree' class="p-l-22">
<el-col :span='15'>
<el-form-item label="cron表达式选项：" prop="cronExpression">
<el-input v-model="ruleForm.cronExpression" placeholder="请输入cron表达式"></el-input>
<div class="aboutType">
<span :class="{'el-form-itemSuccess':cronStatus,'el-form-item__error':!cronStatus}"
v-show='cronErrorStatus'>
{{cronError}}
</span>
<el-button type='primary' size="mini" class='dataSourceTest' @click='cronTest'>cron表达式测试</el-button>
</div>
</el-form-item>
</el-col>
</el-row>
<div class="text-left p-l-22 m-b-20">
<el-button type="primary" v-show='editAdd' @click="submitForm('ruleForm',1)">添 加</el-button>
<el-button type="primary" v-show='!editAdd' @click="submitForm('ruleForm',2)">修 改</el-button>
<el-button @click="gohistory">取 消</el-button>
</div>
</el-row>
</el-form>
</div>
</template>
<script>
import project from '../../mixins/project'
var moment = require('moment');
import {
notify
} from '../../util/item'
import devisor from '../../util/devisor'
export default {
name: 'dailyModel',
data() {
return {
modelHead: ['添加任务信息', '修改任务信息', '任务信息数据补遗'],
modelH: '',
dataSelect: false,
testJC: [{
value: 1,
label: '阈值检测',
enName: 'thresholdDetectionService'
}, {
value: 2,
label: '自动检测',
enName: 'automaticDetectionService'
}, {
value: 3,
label: '条件检测',
enName: 'conditionDetectionService'
}],
updateStatu: [{
value: 0,
label: '更新源表'
}, {
value: 1,
label: '插入新表'
}],
writeQueueDatas: [{
value: 0,
label: '否'
}, {
value: 1,
label: '是'
}],
sourcesField: [],
addSourceValue1: [],
addSourceMap: [],
sourcesKeysField: [],
dailyFlage: false,
addendum: false,
bgcData: false,
writeQue: false,
timeDataText: '',
sourceErrorStatus: false, //连接错误信息展示
cronErrorStatus: false, //连接错误信息展示
sourceError: '', //连接类型状态
cronError: '', //cron类型信息
sourceStatus: false, //连接是否测试通过
cronStatus: false, //cron表达式是否测试通过
threshold: true, //阈值检测
automatic: false, //自动检测
condition: false, //条件检测
cronExpree: false,
datasSources: [],
datasSourceTypes: [],
datasSourceTypesData: [],
ruleForm: {
taskType: '', //任务类型
taskDetail: '', //任务名称
taskName: '', //任务名称
taskParams: {
timeArray: '', //时间字段
dataBase: '', //连接
tableName: '', // 表名
primaryKey: '', // 主键字段
tt: '', // 时间字段
markField: '', // 标识字段
time: '', // 补遗时间
interval: '', // 数据间隔
detectionType: 1, //检测方式（阈值1 自动检测2）
detectionTypeService: '', //检测方式（名称）
mapList: [{
factor: '', //检测字段
minVal: '', //小于阈值
maxVal: '', //大于阈值
}],
addendum: [{
factor: '', //补遗字段
value: '' //补遗值
}], //补遗字段
autoMapList: [{
factor: '', //检测字段
multiples: [], //检测字段
}],
abnormalCondition: '', //异常条件
conditionList: [{
updateField: '', //更新字段
updateValue: '' //更新值
}],
queryConditions: '', //过滤条件
updateStatus: 0, //是否处理更新策略
backupDatabase: '', //备份数据库
backupTableName: '', //备份数据表
writeQueue: 0, //选择消息队列
queueDataSource: '', //队列连接
queueName: '', //队列名称
},
cronExpression: '', //cron表达式
isTemp: 'Y', //cron表达式类型
},
rules: {
taskName: [{
required: true,
message: '请输入任务名称',
trigger: 'blur'
}],
taskParams: {
tableName: [{
required: true,
message: '请选择数据表',
trigger: 'change'
}],
backupDatabase: [{
required: true,
message: '请选择备份数据表',
trigger: 'change'
}],
updateStatus: [{
required: true,
message: '请选择更新策略',
trigger: 'change'
}],
writeQueue: [{
required: true,
message: '请选择消息队列',
trigger: 'change'
}],
backupTableName: [{
required: true,
message: '请选择备份连接',
trigger: 'change'
}],
timeArray: [{
required: true,
message: '请选择补遗时间',
trigger: 'change'
}],
queryConditions: [{
required: true,
message: '请输入过滤条件',
trigger: 'blur'
}],
dataBase: [{
required: true,
message: '请选择连接',
trigger: 'change'
}],
primaryKey: [{
required: true,
message: '请选择主键',
trigger: 'change'
}],
tt: [{
required: true,
message: '请选择时间字段',
trigger: 'change'
}],
markField: [{
required: true,
message: '请选择标识字段',
trigger: 'change'
}],
interval: [{
required: true,
message: '请选择数据间隔',
trigger: 'change'
}],
addendum: [{
value: [{
required: true,
message: '请输入补遗字段',
trigger: 'blur'
}],
factor: [{
required: true,
message: '请选择数据间隔',
trigger: 'change'
}],
}], //检测方式（阈值1 自动检测2）
mapList: [{
factor: [{
required: true,
message: '请选择检测字段',
trigger: 'change'
}], //检测字段
minVal: [{
required: true,
message: '请输入小于阈值',
trigger: 'blur'
}], //小于阈值
maxVal: [{
required: true,
message: '请输入大于阈值',
trigger: 'blur'
}], //大于阈值
}],
autoMapList: [{
factor: [{
required: true,
message: '请选择检测字段',
trigger: 'change'
}], //检测字段
multiples: [{
required: true,
message: '请选择关联字段',
trigger: 'change'
}], //检测字段
}],
detectionType: [{
required: true,
message: '请选择检测方式',
trigger: 'change'
}]
},
cronExpression: [{
required: true,
message: '请选择cron表达式执行周期',
trigger: 'change'
}],
taskType: [{
required: true,
message: '请选择任务类型',
trigger: 'change'
}],
},
dialogVisible: false,
loading: false,
dailyParams: {},
center: true,
editAdd: true,
scrollLock: false,
closeOnClick: false,
deleteList: [],
ruleFormEdit: {
taskType: '', //任务类型
taskDetail: '', //任务名称
taskName: '', //任务名称
disable: false,
taskParams: {
timeArray: '', //时间字段
dataBase: '', //连接
tableName: '', // 表名
primaryKey: '', // 主键字段
tt: '', // 时间字段
time: '', // 补遗时间
interval: '', // 数据间隔
detectionType: 1, //检测方式（阈值1 自动检测2）
detectionTypeService: '', //检测方式（名称）
mapList: [{
factor: '', //检测字段
minVal: '', //小于阈值
maxVal: '', //大于阈值
}],
addendum: [{
factor: '', //补遗字段
value: '' //补遗值
}], //补遗字段
autoMapList: [{
factor: '', //检测字段
multiples: [], //检测字段
}],
abnormalCondition: '', //异常条件
conditionList: [{
updateField: '', //更新字段
updateValue: '' //更新值
}],
queryConditions: '', //过滤条件
updateStatus: 0, //是否处理到备份数据库
backupDatabase: '', //备份数据库
backupTableName: '', //备份数据表
writeQueue: 0, //选择消息队列
queueDataSource: '', //队列连接
queueName: '', //队列名称
},
cronExpression: '', //cron表达式
isTemp: 'Y', //cron表达式类型
}, //修改数据
}
},
mixins: [project],
mounted() {
this.dataSourceChanges();
this.dataSourceChangesRabbitMq();
this.startInit(this.$route.query.headTitle)
},
methods: {
startInit(headTitle = 0) {
// 初始化进入页面，进行刷新
this.timeDataText = '时间间隔';
this.ruleForm.taskType = this.$route.query.taskType
if (headTitle === '1') {
// 数据修改
this.handleEdit(this.$route.query.taskId)
} else if (headTitle === '0') {
// 数据新增
this.editAdd = true;
// this.clearFormVal();
this.addendum = false;
} else if (headTitle === '2') {
// 数据补遗
this.ruleForm.taskParams.detectionType = 0;
this.ruleForm.taskParams.detectionTypeService = 'dataAddendumService';
this.editAdd = true;
this.addendum = true;
this.timeDataText = '数据间隔';
}
// 添加数据类型
this.modelH = this.modelHead[headTitle];
},
gohistory() {
// 返回上一页
this.$router.push({
path: '/quality/dataProcess/scheduledTasks'
})
},
detectionTypeChange(val) {
// 自动检测和阈值检测窗口数值变化
switch (val) {
case 1:
// 阈值检测
this.threshold = true;
this.condition = false;
this.automatic = false;
break;
case 2:
// 自动检测
this.threshold = false;
this.condition = false;
this.automatic = true;
break;
default:
// 条件检测
this.threshold = false;
this.condition = true;
this.automatic = false;
break;
}
},
isUpdateS(val = 0) {
// 是否备份数据到数据库
this.ruleForm.taskParams.updateStatus = val;
if (val === 0) {
this.bgcData = false;
} else {
this.bgcData = true;
}
},
writeQueChange(val) {
// 是否写入队列
if (val === 0) {
this.writeQue = false;
} else {
this.writeQue = true;
}
},
querySearch(queryString, cb) {
var restaurants = this.datasSourceTypes;
var results = queryString ? restaurants.filter(this.createFilter(queryString)) : restaurants;
// 调用 callback 返回建议列表的数据
if (results.length !== 0) {
for (let item of results.values()) {
item['value'] = item['value'];
}
}
cb(results);
},
querySearchs(queryString, cb) {
// 备份数据库内容
var restaurants = this.datasSourceTypesData;
var results = queryString ? restaurants.filter(this.createFilter(queryString)) : restaurants;
// 调用 callback 返回建议列表的数据
if (results.length !== 0) {
for (let item of results.values()) {
item['value'] = item['value'];
}
}
cb(results);
},
createFilter(queryString) {
return (restaurant) => {
return (restaurant.value.indexOf(queryString) !== -1);
};
},
async cronTest() {
// cron表达式检测
const datas = await this.getHttpDatas(this.nozzle.checkCron, {
cronStr: this.ruleForm.cronExpression
});
if (datas === true) {
this.cronStatus = true;
this.cronError = 'cron表达式测试成功'
} else {
this.cronError = '操作失败'
this.cronStatus = false;
}
this.cronErrorStatus = true;
},
async detectionTest() {
// 连接测试
const datas = await this.getHttpDatas(this.nozzle.testConnectionFilterCondition, {
dataSourceName: this.ruleForm.taskParams.dataBase,
tableName: this.ruleForm.taskParams.tableName,
sqlCondition: this.ruleForm.taskParams.queryConditions
})
// 连接是否测试通过
if (datas === true) {
this.sourceError = '连接测试成功';
this.sourceStatus = true;
} else {
this.sourceError = datas;
this.sourceStatus = false;
}
this.sourceErrorStatus = true;
},
filterCondition() {
/**
* 添加检测字段，修改时刻，渲染并进行赋值
*/
this.ruleForm.taskParams.mapList.push({
factor: '',
minVal: '',
maxVal: '',
});
},
addendumAdd() {
/**
* 添加检测字段，修改时刻，渲染并进行赋值
*/
this.ruleForm.taskParams.addendum.push({
factor: '',
value: '',
});
},
conditionAdd() {
/**
* 添加条件检测字段，修改时刻，渲染并进行赋值
*/
this.ruleForm.taskParams.conditionList.push({
updateField: '',
updateValue: '',
});
},
filterAutoCondition() {
/**
* 添加自动检测字段，修改时刻，渲染并进行赋值
*/
this.ruleForm.taskParams.autoMapList.push({
factor: '',
multiples: [], //检测字段
});
},
deleteAutoIcons(fieldName, index) {
// 删除字段
this.ruleForm.taskParams[fieldName].splice(index, 1);
},
async dataSourceChanges() {
// 连接列表渲染
let datas = await this.getHttpDatas(this.nozzle.queryDataSrouceName, {
dbType: 'Relational'
});
let dataBase = [];
for (let item of datas.values()) {
dataBase.push({
value: item
})
}
this.datasSources = dataBase;
},
async dataSourceChange(val) {
// 数据表内容获取以及填充
this.ruleForm['taskParams']['tableName'] = '';
if (this.ruleForm['taskParams']['detectionType'] == 1) {
let mapList = this.ruleForm['taskParams']['mapList'];
if (mapList.length !== 0) {
for (let item of mapList.values()) {
item['factor'] = ''
}
}
} else {
this.ruleForm['taskParams']['factor'] = '';
}
let datas = await this.getHttpDatas(this.nozzle.getAllTableNameByDateSourceName, {
dataSourceName: val,
pageSize: 999999,
pageNo: 1
});
let dataBase = [];
for (let item of datas.list.values()) {
dataBase.push({
value: item
})
}
this.datasSourceTypes = dataBase;
},
async dataSourceTable(val, dataBase = this.ruleForm.taskParams.dataBase, dif = 1) {
// 数据表内容变化发生改变
if (typeof val === 'object') {
val = val['value'];
}
this.sourceFieldChange(dataBase, val, dif)
// 清空字段名
this.ruleForm.taskParams.tt = '';
this.ruleForm.taskParams.markField = '';
},
async dataSourceChangeDatabase(val) {
// 备份数据表
this.ruleForm['taskParams']['backupTableName'] = '';
let datas = await this.getHttpDatas(this.nozzle.getAllTableNameByDateSourceName, {
dataSourceName: val,
pageSize: 999999,
pageNo: 1
});
let dataBase = [];
for (let item of datas.list.values()) {
dataBase.push({
value: item
})
}
this.datasSourceTypesData = dataBase;
},
async sourceFieldChange(dataSourceName, tableName, dif = 1) {
// 检测字段填充
// 下拉框改变状态，则进行数据清空
if (dif === 1) {
this.multiples = [];
this.ruleForm['taskParams']['factor'] = '';
let mapList = this.ruleForm['taskParams']['mapList'];
if (mapList.length !== 0) {
for (let item of mapList.values()) {
item['factor'] = ''
}
}
}
const datas = await this.getHttpDatas(this.nozzle.getDataStructureByTableName, {
dataSourceName: dataSourceName,
tableName: tableName
})
if (datas['list'].length !== 0) {
let newDatas = [];
for (let item of datas['list'].values()) {
newDatas.push({
value: item['columnName'],
label: devisor[item['columnName'].toLowerCase()]
})
}
this.sourcesField = newDatas;
this.sourcesKeysField = this.enOrChin(datas['primaryKeys']);
} else {
this.sourcesField = [];
this.sourcesKeysField = [];
}
},
enOrChin(datas = []) {
// 英文转换成中文
if (datas.length !== 0) {
let newDevisor = [];
for (const item of datas.values()) {
newDevisor.push({
label: devisor[item.toLowerCase()],
value: item
})
}
return newDevisor
}
},
executeChange(value) {
/**
* 时间执行方法
*/
if (value === 'N') {
// 周期任务
this.cronExpree = true;
} else {
// 临时任务
this.ruleForm.cronExpression = '';
this.cronExpree = false;
}
},
typeQf(datas) {
// 数据处理类型区分
if (datas['taskParams']['detectionType'] === 2) {
// 自动检测
datas['taskParams']['mapList'] = [];
datas['taskParams']['conditionList'] = [];
} else if (datas['taskParams']['detectionType'] === 1) {
// 阈值检测
datas['taskParams']['autoMapList'] = [];
datas['taskParams']['conditionList'] = [];
} else if (datas['taskParams']['detectionType'] === 3) {
// 条件检测
datas['taskParams']['autoMapList'] = [];
datas['taskParams']['mapList'] = [];
} else {
// 数据补遗
datas['taskParams']['mapList'] = [];
}
},
addParameter(api) {
// 新增数据传值
let datas = Object.assign({}, this.ruleForm);
// 清除其他检测方案数据
this.typeQf(datas);
datas['taskParams']['time'] = moment(datas['taskParams']['timeArray'][0]).format('YYYY-MM-DD HH:mm:ss') +
' ~ ' + moment(datas['taskParams']['timeArray'][1]).format('YYYY-MM-DD HH:mm:ss');
if (datas['taskParams']['detectionType'] !== 0) {
// 除去数据补遗参数，填写英文名称
datas['taskParams']['detectionTypeService'] = this.testJC[datas['taskParams']['detectionType'] - 1]['enName'];
}
datas['taskParams'] = JSON.stringify(datas['taskParams']);
// 新增数据传值
this.$http.post(api, datas).then(response => {
notify(response);
this.$emit('getLists')
this.$router.push({
path: '/quality/dataProcess/scheduledTasks'
})
})
},
async editParameter(api) {
// 修改数据传值
let datas = Object.assign({}, this.ruleForm);
this.typeQf(datas);
datas['taskId'] = this.ruleFormEdit['taskId']
datas['taskParams']['time'] = moment(datas['taskParams']['timeArray'][0]).format('YYYY-MM-DD HH:mm:ss') +
' ~ ' + moment(datas['taskParams'][
'timeArray'
][1]).format('YYYY-MM-DD HH:mm:ss');
if (datas['taskParams']['detectionType'] !== 0) {
// 除去数据补遗参数，填写英文名称
datas['taskParams']['detectionTypeService'] = this.testJC[datas['taskParams']['detectionType'] - 1][
'enName'
];
}
datas['taskParams'] = typeof datas['taskParams'] === 'string' ? datas['taskParams'] : JSON.stringify(datas[
'taskParams']);
const response = await this.$http.put(api, datas);
this.$emit('getLists')
this.$router.push({
path: '/quality/dataProcess/scheduledTasks'
})
},
submitForm(formName, dif) {
// 添加数据,修改数据传值
let api = '';
this.$refs[formName].validate((valid) => {
if (valid) {
// 选择站点编号
// 连接和cron表达式那个数据
// if (!this.sourceStatus) {
// this.$notify({
// type: "warning",
// message: '连接需要测试通过才可进行数据处理'
// })
// return
// }
// if (!this.cronStatus && this.ruleForm.isTemp === 'N') {
// this.$notify({
// type: "warning",
// message: 'cron表达式需要测试才可进行数据处理'
// })
// return
// }
// 增加数据和修改数据处理
if (dif === 1) {
api = this.nozzle.taskAdd;
this.addParameter(api)
} else {
api = this.nozzle.taskEdit;
this.editParameter(api)
}
} else {
console.log('error submit!!');
return false;
}
});
},
resetClear(item, keys) {
// 递归清空复杂数据类型的值
for (let items of Object.keys(this.ruleForm[item])) {
if (items === keys) {
this.ruleForm[item][items] = []
} else {
this.ruleForm[item][items] = ''
}
}
},
clearFormVal() {
this.ruleForm['isTemp'] = 'Y';
this.ruleForm['taskParams']['detectionType'] = 1;
// 状态
this.executeChange('Y');
// 默认阈值检测
this.detectionTypeChange(1);
},
modelAdd() {
// 添加数据按钮
this.dataSelect = true;
},
traversalEdit(data) {
// 通过修改数据进行遍历,填充修改数据窗口
/**
* @param {Object} data 表内连接,单行数据
* @param {String} dif 连接请求
*/
// 启用，禁用，执行数据启动
this.dataSourceChange(data['taskParam']['dataBase']);
this.dataSourceChangeDatabase(data['taskParam']['dataBase']);
// 获取调度配置
this.executeChange(data['isTemp']);
// 获取检测字段
this.dataSourceTable(data['taskParam']['tableName'], data['taskParam']['dataBase'], 2)
this.detectionTypeChange(data['taskParam']['detectionType']);
let {
keys
} = Object;
for (let items of keys(this.ruleForm)) {
if (items === 'taskParams') {
// 数据表和检测字段获取
this.ruleForm['taskParams'] = data['taskParam'];
} else {
this.ruleForm[items] = data[items];
}
}
this.ruleForm['disabled'] = data['disabled']
// 数据补遗修改
if (this.ruleForm.taskParams.detectionType === 0) {
this.addendum = true;
this.timeDataText = '数据间隔';
}
this.isUpdateS(data['taskParam']['updateStatus']);
this.writeQueChange(data['taskParam']['writeQueue']);
},
async editFill(taskId) {
// 修改窗口数据填充
const datas = await this.getHttpDatas(this.nozzle.queryTaskByTaskId, {
taskId: taskId
});
this.traversalEdit(datas);
// 使用申明修改对象接收当前修改的参数值
this.ruleFormEdit = Object.assign({}, this.ruleForm);
this.ruleFormEdit['taskId'] = datas['taskId']
},
handleEdit(taskId) {
// 行内点击修改
this.editAdd = false;
// 修改状态提示标签
this.cronErrorStatus = false;
this.sourceErrorStatus = false;
this.sourceStatus = false;
this.cronStatus = false;
this.editFill(taskId)
},
deleteUserLise(ids) {
// 删除用户
let datas = {
"params": {
"taskIds": ids
}
}
this.asyncDelete(datas, this.nozzle.taskDelete);
},
async dataSourceChangesRabbitMq(dif, dis) {
/**
* 消息队列渲染
*/
let dbTypeName = 'rabbitMq';
let datas = await this.getHttpDatas(this.nozzle.queryDataSrouceName, {
dbType: dbTypeName
});
let dataBase = [];
for (let item of datas.values()) {
dataBase.push({
value: item
})
}
this.addSourceMap = dataBase
},
async sqlSourceShow(val) {
// 连接改变，获取队列名称
let nowApi = '';
// 消息队列
nowApi = this.nozzle.getQueues
let datas = await this.getHttpDatas(nowApi, {
dataSourceName: val,
pageSize: 999999,
pageNo: 1
});
let dataBase = [];
for (let item of datas.values()) {
dataBase.push({
value: item
})
}
this.addSourceValue1 = dataBase;
},
}
}
</script>
<style scoped>
#dailyWindow .el-date-editor .el-range__icon,
.el-date-editor .el-range-separator {
line-height: 23px;
}
#dailyWindow .fzs {
display: inline-block;
width: 330px;
text-align: right;
padding-right: 10px;
}
#dailyWindow .w60 {
width: 60%;
}
#dailyWindow .datainterval {
width: 26%;
}
#dailyWindow .yzFlex {
display: flex;
justify-content: space-around;
}
#dailyWindow .dataSourceTest {
float: right;
margin-top: 5px;
}
#dailyWindow .conditiona {
padding: 0px 0 10px 141px;
}
#dailyWindow .addendumNames {
line-height: 40px;
}
#dailyWindow .el-autocomplete {
width: 100%;
}
#dailyWindow .icon-qiyong:before {
color: red;
cursor: pointer;
}
#dailyWindow .el-form-itemSuccess {
color: #63e06e;
font-size: 12px;
line-height: 1;
padding-top: 4px;
position: absolute;
top: 100%;
left: 0;
}
#dailyWindow .pull-left {
float: left;
color: #1890ff !important;
font-size: 14px;
line-height: 23px;
cursor: pointer;
}
#dailyWindow .sectionH2 {
font-size: 16px;
color: #000;
padding-bottom: 12px;
}
/*
#dailyWindow .basicB {
box-shadow: 2px 2px 9px 0px #ccc;
background-color: #fff;
} */
#dailyWindow .el-form-item {
margin-bottom: 12px;
}
</style>
