同步sys-ui代码

src/api/common/admin.js

@@ -0,0 +1,10 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base = config.getSysBasePath();
+
+//没用到的api请注释掉
+
+export const listAdmin = params => { return axios.post(`${base}/pub/admin/list`, params) };
+

src/api/common/bMap.js

@@ -0,0 +1,15 @@
+import axios from '@/utils/request'
+
+
+
+
+/**
+ * 商品信息
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={id:'商品编号 主键',categoryId:'分类编号',goodsSn:'商品编码',name:'商品名称',brandId:'品牌编号',goodsNumber:'商品数量',keywords:'关键词',goodsBrief:'商品简介',goodsDesc:'商品详情',isOnSale:'是否在售',addTime:'添加时间',sortOrder:'排序',isDelete:'是否已删除',attributeCategory:'商品属性分类',isNew:'是否是新品',goodsUnit:'商品单位',primaryPicUrl:'商品主图',listPicUrl:'商品列表图',primaryProductId:'主产品编号',promotionDesc:'推广描述',promotionTag:'推广标签',isLimited:'是否限制',isHot:'是否热销',shopLocationId:'商品所属门店编号',retailPrice:'零售价格',wholesalePrice:'批发价格',purchasePrice:'进货价格',floorPrice:'最低价格'}
+ **/
+// '/api/m1/bMap/'    target: 'https://api.map.baidu.com/
+// https://api.map.baidu.com/?qt=rgc&x=12609455&y=2620453.94&dis_poi=100&poi_num=10&latest_admin=1&ie=utf-8&oue=1&fromproduct=jsapi&res=api&callback=BMap._rd._cbk30753&ak=T4lll3sQi7ZdbnVb1INOCrxequ1kp4PG
+// 百度地图api,点转纤细
+// export const pointToLocation = params => { return axios.get(`https://api.map.baidu.com/`, { params: params }) }
+export const pointToLocation = params => { return axios.get(`/bmap`, { params: params }) }

src/api/common/code.js

@@ -0,0 +1,283 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base = config.getSysBasePath();
+
+/***
+ * {
+ * 	  
+ * }
+ */
+var cacheOptions={};
+
+var cacheSeconds={};
+
+var cacheOptionsBySecondCodeRows={};
+
+var cacheCompanyDepts=null;
+
+var cacheCompanyEmployees=null;
+
+//默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:1,pageSize:10,total:0}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+
+//普通查询
+export const listCode = params => { return axios.get(`${base}/sys/code/list`, { params: params }); };
+
+//关键字模糊查询 {字段1:v1,字段2:v1,字段3:v1},字段驼峰命名，条件之间默认为or关系
+export const listCodeKey = params => {
+
+	return axios.get(`${base}/sys/code/listKey`, { params: params }); 
+
+};
+
+
+/**
+ * 查询下拉选项目 参数为数组型参数 如 selectOptions( { fieldNames:['sex','age','student'],code:'all' } ),code为数据分类
+ * 返回结果为：
+ * res.data.data:{
+ * 	sex:[{codeName:男,codeValue:1,ifdefault:'1'},{codeName:女,codeValue:2,ifdefault:'0'}],
+ *  age:[{codeName:1岁,codeValue:1,ifdefault:'1'},{codeName:2岁,codeValue:2,ifdefault:'0'},{codeName:3岁,codeValue:3,ifdefault:'0'}]
+ * }
+ */
+export const selectCacheOptions = params => { 
+	
+	let code=params.code;
+	let fieldNames=params.fieldNames;
+	if(!cacheOptions[code]){
+		return new Promise((resolve, reject) => {
+			axios.get(`${base}/sys/code/selectOptions`, { params:params }).then(res=>{
+				let options=res.data.data; 
+				cacheOptions[code]=options;
+				resolve({
+			           data: {data:options}
+			         });
+			});
+	         
+	     });
+		
+	}else{
+		let codeOptions=cacheOptions[code];
+		var lostFieldNames=[];
+		var cacheHasOptions={};
+		fieldNames.forEach(item=>{
+			if(codeOptions[item]){
+				cacheHasOptions[item]=codeOptions[item];
+			}else{
+				lostFieldNames.push(item);
+			}
+		});
+		if(lostFieldNames.length>0){
+			 return new Promise((resolve, reject) => {
+				 axios.get(`${base}/sys/code/selectOptions`, { params:{code:code,fieldNames:lostFieldNames} }).then(res=>{
+						let options2=res.data.data; 
+						lostFieldNames.forEach(item=>{
+							codeOptions[item]=options2[item];
+							cacheHasOptions[item]=options2[item];
+							cacheOptions[code]=codeOptions;
+							
+						});
+						resolve( {
+								data: {data:cacheHasOptions} 
+					         });
+					});
+				 
+		     });
+			
+		}else{
+			 return new Promise((resolve, reject) => {
+		         resolve( {
+		        	 data: {data:cacheHasOptions}  
+		         });
+		     });
+		}
+		
+	}
+	
+	
+};
+/**
+ * 查询下拉选项目 参数为数组型参数 如 selectOptionsBySecondCodeRows( {secondCodeRows:['secondCodeRow1','secondCodeRow2']} )
+ * 返回结果为：
+ * res.data.data:{
+ * 	secondCodeRow1:[{codeName:男,codeValue:1,ifdefault:'1'},{codeName:女,codeValue:2,ifdefault:'0'}],
+ *  secondCodeRow1:[{codeName:1岁,codeValue:1,ifdefault:'1'},{codeName:2岁,codeValue:2,ifdefault:'0'},{codeName:3岁,codeValue:3,ifdefault:'0'}]
+ * }
+ */
+export const selectOptionsBySecondCodeRows = params => {  
+		let secondCodeRows=params.secondCodeRows;
+		var lostSecondCodeRows=[];
+		var cacheHasOptions={};
+		secondCodeRows.forEach(item=>{
+			if(cacheOptionsBySecondCodeRows[item]){
+				cacheHasOptions[item]=cacheOptionsBySecondCodeRows[item];
+			}else{
+				lostSecondCodeRows.push(item);
+			}
+		});
+		if(lostSecondCodeRows.length>0){
+			 return new Promise((resolve, reject) => {
+				 axios.get(`${base}/sys/code/selectOptionsBySecondCodeRows`, { params:{secondCodeRows:lostSecondCodeRows }}).then(res=>{
+						let options2=res.data.data; 
+						lostSecondCodeRows.forEach(item=>{
+							cacheOptionsBySecondCodeRows[item]=options2[item];
+							cacheHasOptions[item]=options2[item];
+						});
+						resolve( {
+								data: {data:cacheHasOptions} 
+					         });
+					});
+				 
+		     });
+			
+		}else{
+			 return new Promise((resolve, reject) => {
+		         resolve( {
+		        	 data: {data:cacheHasOptions}  
+		         });
+		     });
+		}
+};
+/**
+ * 查询下拉选项目 参数为数组型参数 如 selectOptions( { fieldNames:['sex','age','student'],code:'all' } ),code为数据分类
+ * 返回结果为：
+ * res.data.data:{
+ * 	sex:[{codeName:男,codeValue:1,ifdefault:'1'},{codeName:女,codeValue:2,ifdefault:'0'}],
+ *  age:[{codeName:1岁,codeValue:1,ifdefault:'1'},{codeName:2岁,codeValue:2,ifdefault:'0'},{codeName:3岁,codeValue:3,ifdefault:'0'}]
+ * }
+ */
+export const selectOptions = params => { 
+		return axios.get(`${base}/sys/code/selectOptions`, { params:params }) 
+};
+//获取代码对应的名称 用于数据反显 如 getCodeName(options.sex,'1');
+export const getCodeName = (options,codeValue)=>{
+	if(!options)return codeValue;
+	let code=options.filter(i=>i.codeValue==codeValue);
+	if(code.length>0){
+		return code[0].codeName
+	}else{
+		return codeValue
+	} 
+};
+
+/**
+ * 获取某个字段的默认值
+ * getDefaultValue(options.sex,'1');
+ */
+export const getDefaultValue = (fieldOptions,defaultValue) =>{
+	if(fieldOptions==null || fieldOptions.length==0){
+		return defaultValue;
+	}
+	let defaultV=defaultValue;
+	fieldOptions.forEach(i=>{
+		if(i.ifdefault=='1'){
+			defaultV=i.codeValue;
+		}
+	});
+	return defaultV;
+};
+
+/**
+* 根据一级分类列表查询所有的二级分类
+* @param codes 分类编码  列表  如['JCBM_TPL','SystemParas']
+* @return 返回如下格式的map。secondCodeRow为主键,dtcodeId为编码，dtcodeName中文描述
+* {
+* 	JCBM_TPL:[{secondCodeRow:'xxxx',dtcodeId:1,dtcodeName:男},{secondCodeRow:'xxxx',dtcodeid:1,dtcodeName:男}],
+*  SystemParas:[{secondCodeRow:'xxxx',dtcodeId:3,dtcodeName:其它},{secondCodeRow:'xxxx',dtcodeid:2,dtcodeName:其它2}]
+* }
+*/
+export const selectSeconds = params => { return axios.get(`${base}/sys/code/selectSeconds`, { params:params }); };
+
+/**
+* 根据一级分类列表查询所有的二级分类
+* @param codes 分类编码  列表  如['JCBM_TPL','SystemParas']
+* @return 返回如下格式的map。secondCodeRow为主键,dtcodeId为编码，dtcodeName中文描述
+* {
+* 	JCBM_TPL:[{secondCodeRow:'xxxx',dtcodeId:1,dtcodeName:男},{secondCodeRow:'xxxx',dtcodeid:1,dtcodeName:男}],
+*  SystemParas:[{secondCodeRow:'xxxx',dtcodeId:3,dtcodeName:其它},{secondCodeRow:'xxxx',dtcodeid:2,dtcodeName:其它2}]
+* }
+*/
+export const selectCacheSeconds = params => { 
+	let codes=params.codes;
+	let lostCodes=[];
+	codes.forEach(item=>{
+		if(!cacheSeconds[item]){
+			lostCodes.push(item);
+		}
+	});
+	if(lostCodes.length>0){
+		return new Promise((resolve, reject) => {
+			selectSeconds({codes:lostCodes}).then(res=>{
+				let seconds=res.data.data;
+				lostCodes.forEach(item=>{
+					cacheSeconds[item]=seconds[item];
+				});
+				let result={};
+				codes.forEach(item=>{
+					result[item]=cacheSeconds[item];
+				});
+				 resolve( {
+		        	 data: {data:result}  
+		         });
+			});
+		});
+	}else{
+		let result={};
+		codes.forEach(item=>{
+			result[item]=cacheSeconds[item];
+		});
+		 return new Promise((resolve, reject) => {
+	         resolve( {
+	        	 data: {data:result}  
+	         });
+	     });
+	}
+	
+
+};
+// [{dpetid:'',displayDeptid:'',deptName:'',shortName:'',pdeptid:''},{dpetid:'',displayDeptid:'',deptName:'',shortName:'',pdeptid:''}]
+export const getCompanyDepts = () => {  
+	if(cacheCompanyDepts!=null && cacheCompanyDepts.length>=0){ 
+		 return new Promise((resolve, reject) => {
+	         resolve( {
+	        	 data: {data:cacheCompanyDepts}
+	         });
+	     });
+	}
+	
+	return axios.get(`${base}/sys/code/companyDepts`).then(res=>{
+		if(res.data.data==null){
+			cacheCompanyDepts=[];
+		}else{
+			cacheCompanyDepts=res.data.data;
+		}
+		return new Promise((resolve, reject) => {
+	         resolve( {
+	        	 data: {data:cacheCompanyDepts}
+	         });
+	     });
+	});
+};
+//[{userid:'',displayUserid:'',username:'',deptid:'',shortName:'',deptName:''},{userid:'',displayUserid:'',username:'',deptid:'',shortName:'',deptName:''}]
+export const getCompanyEmployees = () => {  
+	if(cacheCompanyEmployees!=null && cacheCompanyEmployees.length>=0){ 
+		 return new Promise((resolve, reject) => {
+	         resolve( {
+	        	 data: {data:cacheCompanyEmployees}
+	         });
+	     });
+	}
+	
+	return axios.get(`${base}/sys/code/companyEmployees`).then(res=>{
+		if(res.data.data==null){
+			cacheCompanyEmployees=[];
+		}else{
+			cacheCompanyEmployees=res.data.data;
+		}
+		return new Promise((resolve, reject) => {
+	         resolve( {
+	        	 data: {data:cacheCompanyEmployees}
+	         });
+	     });
+	});
+};

src/api/mdp/app/appBizType.js

@@ -0,0 +1,31 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base=config.getSysBasePath();
+
+ 
+
+/**
+ * app_biz_type
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={id:'业务分类编号 主键',name:'分类名称'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listAppBizType = params => { return axios.get(`${base}/mdp/app/appBizType/list`, { params: params }); };
+
+//模糊查询app_biz_type 条件之间or关系  
+//export const listAppBizTypeKey = params => { return axios.get(`${base}/mdp/app/appBizType/listKey`, { params: params }); };
+
+//删除一条app_biz_type params={id:'业务分类编号 主键'}
+export const delAppBizType = params => { return axios.post(`${base}/mdp/app/appBizType/del`,params); };
+
+//批量删除app_biz_type  params=[{id:'业务分类编号 主键'}]
+export const batchDelAppBizType = params => { return axios.post(`${base}/mdp/app/appBizType/batchDel`, params); };
+
+//修改一条app_biz_type记录
+export const editAppBizType = params => { return axios.post(`${base}/mdp/app/appBizType/edit`, params); };
+
+//新增一条app_biz_type
+export const addAppBizType = params => { return axios.post(`${base}/mdp/app/appBizType/add`, params); };

src/api/mdp/app/appMdpDef.js

@@ -0,0 +1,29 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base=config.getSysBasePath();
+
+/**
+ * MDP平台应用定义表
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={mdpAppid:'应用编号 主键',name:'应用名称',logoUrl:'应用logo',remark:'应用描述',bizType:'应用分类',deptid:'归属部门',branchId:'归属机构',cdate:'创建日期',cuserid:'创建人',enabled:'应用状态0下架1上架'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listAppMdpDef = params => { return axios.get(`${base}/mdp/app/appMdpDef/list`, { params: params }); };
+
+//模糊查询MDP平台应用定义表 条件之间or关系  
+//export const listAppMdpDefKey = params => { return axios.get(`${base}/mdp/app/appMdpDef/listKey`, { params: params }); };
+
+//删除一条MDP平台应用定义表 params={mdpAppid:'应用编号 主键'}
+export const delAppMdpDef = params => { return axios.post(`${base}/mdp/app/appMdpDef/del`,params); };
+
+//批量删除MDP平台应用定义表  params=[{mdpAppid:'应用编号 主键'}]
+export const batchDelAppMdpDef = params => { return axios.post(`${base}/mdp/app/appMdpDef/batchDel`, params); };
+
+//修改一条MDP平台应用定义表记录
+export const editAppMdpDef = params => { return axios.post(`${base}/mdp/app/appMdpDef/edit`, params); };
+
+//新增一条MDP平台应用定义表
+export const addAppMdpDef = params => { return axios.post(`${base}/mdp/app/appMdpDef/add`, params); };

src/api/mdp/app/appShopConfig.js

@@ -0,0 +1,30 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base = config.getSysBasePath();
+
+
+/**
+ * app_shop_config
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={shopId:'商户编号 主键',shopBranchId:'商户自身归属机构号',tpServiceCharges:'第三方手续费费率如支付宝/微信支付的费率比如0.003',platServiceCharges:'mdp平台附加手续费费率比如0.002,即该商户下所有交易需要支付给平台的手续费费率',platShopDepositAccountId:'mdp平台分配给该商户（门店）预存款账户（一般商户编号-门店编号-01，用于mdp平台与该商户的结算，商户充值等），如果是总部店，为一般商户编号-0-01',platAssetAccountId:'平台资产账户，商户缴纳给平台手续费等，从商户预存款账户转出，转入该账户计入平台主营业务收入',platShopId:'归属平台商户编号',shopServiceCharges:'mdp平台商户手续费费率一般为门店订单交易需要支付一定的手续费给商户',shopAssetAccountId:'商户内部主营业务收入账户，在途资金到账后，转入主营业务收入',isPlatSc:'商户是否需要向平台缴纳手续费',isShopSc:'门店是否需要向商户缴纳手续费',acctPrjType:'核算项目platform-由平台结算，shop-由商户独立结算，location-由门店独立结算',paySetType:'支付结算方式platform-使用平台支付通道结算，shop-使用商户结算通道，location-使用门店独立结算通道',setLevel:'结算级别1-商户2-门店，将在途资金账户余额归入商户的预存款账户还是门店预存款账户',allowLocationWithdraw:'是否允许门店提现0否1允许3按门店配置自定义',settleShopId:'归属计算商户pay_set_type=platform时，指向平台商户编号platform_shop_id，pay_set_type=shop时指向本商户编号shop_id',isJoinPlat:'是否加入平台，如果加入平台将在平台的大商城可以展现数据-同步到shop表，避免多表关联',shopDepositAccountId:'商户预存款账户，shop模式下，作为客户',settleBranchId:'结算商户对应的机构号',platBranchId:'商户归属的平台机构号'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listAppShopConfig = params => { return axios.get(`${base}/mdp/app/appShopConfig/list`, { params: params }); };
+
+//模糊查询app_shop_config 条件之间or关系  
+//export const listAppShopConfigKey = params => { return axios.get(`${base}/mdp/app/appShopConfig/listKey`, { params: params }); };
+
+//删除一条app_shop_config params={shopId:'商户编号 主键'}
+export const delAppShopConfig = params => { return axios.post(`${base}/mdp/app/appShopConfig/del`,params); };
+
+//批量删除app_shop_config  params=[{shopId:'商户编号 主键'}]
+export const batchDelAppShopConfig = params => { return axios.post(`${base}/mdp/app/appShopConfig/batchDel`, params); };
+
+//修改一条app_shop_config记录
+export const editAppShopConfig = params => { return axios.post(`${base}/mdp/app/appShopConfig/edit`, params); };
+
+//新增一条app_shop_config
+export const addAppShopConfig = params => { return axios.post(`${base}/mdp/app/appShopConfig/add`, params); };

src/api/mdp/app/appTpAuth.js

@@ -0,0 +1,29 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base=config.getSysBasePath();
+
+/**
+ * MDP平台应用与第三方应用关系
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={authId:'第三方应用编号 主键',mdpAppid:'应用编号',name:'应用名称',logoUrl:'应用logo',remark:'应用描述',bizType:'应用分类',deptid:'归属部门',branchId:'归属机构',appToken:'登录验证码',loginUrl:'登录地址',cdate:'创建日期',cuserid:'创建人',appSecret:'加密串',authUrl:'授权地址',authPattern:'监听发起授权地址',encKey:'秘钥EncodingAESKey(消息加密密钥)',enabled:'应用状态0下架1上架',appid:'对应第三方提供给的appid',payMchid:'商户编号',payNotifyUrl:'付款成功通知地址',openPay:'开通支付',payKey:'支付加密秘钥',msgNotifyUrl:'消息推送地址',ips:'服务器IP地址列表ip1,ip2,ip3',locationId:'绑定的门店',shopId:'绑定的商户编号',locationName:'门店名称',shopName:'商户名称',multiLoca:'是否为多点0否1是'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listAppTpAuth = params => { return axios.get(`${base}/mdp/app/appTpAuth/list`, { params: params }); };
+
+//模糊查询MDP平台应用与第三方应用关系 条件之间or关系  
+//export const listAppTpAuthKey = params => { return axios.get(`${base}/mdp/app/appTpAuth/listKey`, { params: params }); };
+
+//删除一条MDP平台应用与第三方应用关系 params={authId:'第三方应用编号 主键'}
+export const delAppTpAuth = params => { return axios.post(`${base}/mdp/app/appTpAuth/del`,params); };
+
+//批量删除MDP平台应用与第三方应用关系  params=[{authId:'第三方应用编号 主键'}]
+export const batchDelAppTpAuth = params => { return axios.post(`${base}/mdp/app/appTpAuth/batchDel`, params); };
+
+//修改一条MDP平台应用与第三方应用关系记录
+export const editAppTpAuth = params => { return axios.post(`${base}/mdp/app/appTpAuth/edit`, params); };
+
+//新增一条MDP平台应用与第三方应用关系
+export const addAppTpAuth = params => { return axios.post(`${base}/mdp/app/appTpAuth/add`, params); };

src/api/mdp/app/appTpPay.js

@@ -0,0 +1,30 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base = config.getSysBasePath();
+
+
+/**
+ * app_tp_pay
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={payAuthId:'主键 主键',mdpAppid:'应用编号',name:'应用名称',logoUrl:'应用logo',remark:'应用描述',payType:'付款方式0余额1微信2V麦3支付宝4银行5网银6其他',deptid:'归属部门',branchId:'归属机构',cdate:'创建日期',cuserid:'创建人',enabled:'应用状态0下架1上架',appid:'对应第三方提供给的appid',payMchid:'商户编号',payNotifyUrl:'付款成功通知地址',openPay:'开通支付',payKey:'支付加密秘钥私钥',ips:'服务器IP地址列表ip1,ip2,ip3',locationId:'绑定的门店',shopId:'绑定的商户编号',locationName:'门店名称',shopName:'商户名称',payPubKey:'支付加密秘钥公钥',tpServiceCharges:'第三方手续费费率比如0.003',mdpServiceCharges:'mdp平台附加手续费费率比如0.002',mdpPayAccountId:'mdp平台商户账户（一般商户编号+门店编号，用于mdp平台与该商户的结算）'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listAppTpPay = params => { return axios.get(`${base}/mdp/app/appTpPay/list`, { params: params }); };
+
+//模糊查询app_tp_pay 条件之间or关系  
+//export const listAppTpPayKey = params => { return axios.get(`${base}/mdp/app/appTpPay/listKey`, { params: params }); };
+
+//删除一条app_tp_pay params={payAuthId:'主键 主键'}
+export const delAppTpPay = params => { return axios.post(`${base}/mdp/app/appTpPay/del`,params); };
+
+//批量删除app_tp_pay  params=[{payAuthId:'主键 主键'}]
+export const batchDelAppTpPay = params => { return axios.post(`${base}/mdp/app/appTpPay/batchDel`, params); };
+
+//修改一条app_tp_pay记录
+export const editAppTpPay = params => { return axios.post(`${base}/mdp/app/appTpPay/edit`, params); };
+
+//新增一条app_tp_pay
+export const addAppTpPay = params => { return axios.post(`${base}/mdp/app/appTpPay/add`, params); };

src/api/mdp/app/shopLocation.js

@@ -0,0 +1,14 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base=config.getMallmBasePath();
+ 
+/**
+ * 门店地址表
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={id:'门店编号 主键',shopId:'店铺编号',longitude:'经度',latitude:'纬度',address:'地址',rank:'服务范围',province:'省',city:'市',district:'区',admin:'主负责人',createTime:'创建时间',title:'门店简称',formatAddress:'地址简称',country:'国家',districtId:'区县编号',deptid:'机构编号',branchId:'云用户机构编号',businessName:'门店名称（仅为商户名，如：国美、麦当劳，不应包含地区、地址、分店名等信息，错误示例：北京国美）',branchName:'分店名称（不应包含地区信息，不应与门店名有重复，错误示例：北京王府井店）',telephone:'门店的电话（纯数字，区号、分机号均由“-”隔开）',categories:'门店的类型（不同级分类用“,”隔开，如：美食，川菜，火锅。详细分类参见附件：微信门店类目表）',offsetType:'坐标类型：',recommend:'推荐品，餐厅可为推荐菜；酒店为推荐套房；景点为推荐游玩景点等，针对自己行业的推荐内容',special:'特色服务，如免费wifi，免费停车，送货上门等商户能提供的特色功能或服务',introduction:'商户简介，主要介绍商户信息等',openTime:'营业时间，24',avgPrice:'人均价格，大于0',status:'审核状态'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listSimpleLocation = params => { return axios.get(`${base}/shop/shopLocation/list/simple`, { params: params }); }; 

src/api/mdp/im/group/imGroupMessage.js

@@ -0,0 +1,30 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base = config.getImBasePath();
+
+
+/**
+ * 群组消息
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={id:'主键ID 主键',sendUserid:'发送者ID',sendTime:'发送时间',sendObject:'发送对象L门店P商品K规格O订单S物流T其他M手机号码W微信号码M邮箱A广告',sendContent:'发送内容',readTime:'读取时间',fp:'备用参数1',groupId:'群组编号',atUserid:'@用户',sendUsername:'发送者姓名',msgAction:'消息动作inviteJoinFrend邀请成为好友,inviteJoinGroup邀请加入群,invitePhone邀请发送手机号码,inviteWeixin邀请发送微信,inviteResume邀请发送简历,inviteInterview邀请面试,showAd展示广告',msgClass:'消息分类0普通消息1群组通知公告2IM通知3广告CSS客服',msgState:'消息状态send已发送reach已送达read已读back已回撤'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listImGroupMessage = params => { return axios.get(`${base}/mdp/im/group/imGroupMessage/list`, { params: params }); };
+
+//模糊查询群组消息 条件之间or关系  
+//export const listImGroupMessageKey = params => { return axios.get(`${base}/mdp/im/group/imGroupMessage/listKey`, { params: params }); };
+
+//删除一条群组消息 params={id:'主键ID 主键'}
+export const delImGroupMessage = params => { return axios.post(`${base}/mdp/im/group/imGroupMessage/del`,params); };
+
+//批量删除群组消息  params=[{id:'主键ID 主键'}]
+export const batchDelImGroupMessage = params => { return axios.post(`${base}/mdp/im/group/imGroupMessage/batchDel`, params); };
+
+//修改一条群组消息记录
+export const editImGroupMessage = params => { return axios.post(`${base}/mdp/im/group/imGroupMessage/edit`, params); };
+
+//新增一条群组消息
+export const addImGroupMessage = params => { return axios.post(`${base}/mdp/im/group/imGroupMessage/add`, params); };

src/api/mdp/im/prichat/imPrichatMessage.js

@@ -0,0 +1,33 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base = config.getImBasePath();
+
+
+/**
+ * 私聊消息
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={id:'主键ID 主键',sendUserid:'发送者ID',sendTime:'发送时间',sendObject:'发送对象L门店P商品K规格O订单S物流T其他M手机号码W微信号码M邮箱A广告',sendContent:'发送内容',readTime:'读取时间',groupId:'群组编号',toUserid:'接收者编号',sendUsername:'发送者名称',msgAction:'消息动作inviteJoinFrend邀请成为好友,inviteJoinGroup邀请加入群,invitePhone邀请发送手机号码,inviteWeixin邀请发送微信,inviteResume邀请发送简历,inviteInterview邀请面试,showAd展示广告',msgClass:'消息分类0普通消息1群组通知公告2IM通知3广告',msgState:'消息状态send已发送reach已送达read已读back已回撤'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listImPrichatMessage = params => { return axios.get(`${base}/mdp/im/prichat/imPrichatMessage/list`, { params: params }); };
+
+//查询我的私聊组
+export const listMyPrichatChannelGroups = params => { return axios.get(`${base}/mdp/im/prichat/imPrichatMessage/listMyPrichatChannelGroups`, { params: params }); };
+
+//模糊查询私聊消息 条件之间or关系  
+//export const listImPrichatMessageKey = params => { return axios.get(`${base}/mdp/im/prichat/imPrichatMessage/listKey`, { params: params }); };
+
+//删除一条私聊消息 params={id:'主键ID 主键'}
+export const delImPrichatMessage = params => { return axios.post(`${base}/mdp/im/prichat/imPrichatMessage/del`,params); };
+
+//批量删除私聊消息  params=[{id:'主键ID 主键'}]
+export const batchDelImPrichatMessage = params => { return axios.post(`${base}/mdp/im/prichat/imPrichatMessage/batchDel`, params); };
+
+//修改一条私聊消息记录
+export const editImPrichatMessage = params => { return axios.post(`${base}/mdp/im/prichat/imPrichatMessage/edit`, params); };
+
+//新增一条私聊消息
+export const addImPrichatMessage = params => { return axios.post(`${base}/mdp/im/prichat/imPrichatMessage/add`, params); };

src/api/mdp/mallm/shop/shop.js

@@ -0,0 +1,12 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base=config.getSysBasePath();
+
+//普通查询 条件之间and关系  
+export const createShopApi = params => { return axios.post(`${base}/mdp/mallm/shop/shop/createShop`, params); };
+
+
+export const listShop = params => { return axios.get(`${base}/mdp/mallm/shop/shop/list`, {params:params}); };
+

src/api/mdp/mallm/shop/shopLocation.js

@@ -0,0 +1,9 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base=config.getSysBasePath();
+
+//普通查询 条件之间and关系  
+export const selectshopLocationBySysDeptIdApi = params => { return axios.post(`${base}/mdp/mallm/shop/shopLocation/selectshopLocationBySysDeptId`, params); };
+

src/api/mdp/menu/menuBranch.js

@@ -0,0 +1,29 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base=config.getSysBasePath();
+
+/**
+ * 菜单分配到机构
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={id:'主键 主键',mid:'菜单编号',branchId:'机构编号'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listMenuBranch = params => { return axios.get(`${base}/mdp/menu/menuBranch/list`, { params: params }); };
+
+//模糊查询菜单分配到机构 条件之间or关系  
+//export const listMenuBranchKey = params => { return axios.get(`${base}/mdp/menu/menuBranch/listKey`, { params: params }); };
+
+//删除一条菜单分配到机构 params={id:'主键 主键'}
+export const delMenuBranch = params => { return axios.post(`${base}/mdp/menu/menuBranch/del`,params); };
+
+//批量删除菜单分配到机构  params=[{id:'主键 主键'}]
+export const batchDelMenuBranch = params => { return axios.post(`${base}/mdp/menu/menuBranch/batchDel`, params); };
+
+//修改一条菜单分配到机构记录
+export const editMenuBranch = params => { return axios.post(`${base}/mdp/menu/menuBranch/edit`, params); };
+
+//新增一条菜单分配到机构
+export const addMenuBranch = params => { return axios.post(`${base}/mdp/menu/menuBranch/add`, params); };

src/api/mdp/menu/menuDef.js

@@ -0,0 +1,49 @@
+import axios from '@/utils/request'
+import { getDicts,initSimpleDicts,initComplexDicts } from '@/api/mdp/meta/item';//字典表
+
+import config from '@/common/config'
+
+let base=config.getSysBasePath();
+
+/**
+ * 前端功能菜单表
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={id:'菜单编号 主键',pid:'上级菜单编号',accUrl:'访问路径',msort:'菜单顺序',category:'菜单大类',icon:'菜单图标',mname:'菜单名称',rpath:'路由PATH',rid:'路由编号',isShow:'是否显示',menuType:'菜单类型1菜单2按钮',operQxId:'绑定的操作权限编号'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listMenuDef = params => { return axios.get(`${base}/mdp/menu/menuDef/list`, { params: params }); };
+
+export const listMenuTree = params => { return axios.get(`${base}/mdp/menu/menuDef/list/tree`, { params: params }); };
+//模糊查询前端功能菜单表 条件之间or关系  
+//export const listMenuDefKey = params => { return axios.get(`${base}/mdp/menu/menuDef/listKey`, { params: params }); };
+
+//删除一条前端功能菜单表 params={id:'菜单编号 主键'}
+export const delMenuDef = params => { return axios.post(`${base}/mdp/menu/menuDef/del`,params); };
+
+//批量删除前端功能菜单表  params=[{id:'菜单编号 主键'}]
+export const batchDelMenuDef = params => { return axios.post(`${base}/mdp/menu/menuDef/batchDel`, params); };
+
+export const batchInsertMenuDef = params => { return axios.post(`${base}/mdp/menu/menuDef/batchInsert`, params); };
+
+//修改一条前端功能菜单表记录
+export const editMenuDef = params => { return axios.post(`${base}/mdp/menu/menuDef/edit`, params); };
+
+//新增一条前端功能菜单表
+export const addMenuDef = params => { return axios.post(`${base}/mdp/menu/menuDef/add`, params); };
+
+
+//批量保存按钮
+export const batchSaveMenuButton = params => { return axios.post(`${base}/mdp/menu/menuDef/batchSaveButton`, params); };
+
+/**-------------------------前端mng|add|edit界面公共函数---------------请写在下面----------------------------------------------- */
+//初始化页面上的字典
+export const initDicts = (that) => {
+    var itemCodes=['menuSupVers'];//在此添加要加载的字典 如['sex','grade','lvl']
+    that.dicts['status']=[{id:'0',name:'停用'},{id:'1',name:'启用'}]
+    if(itemCodes.length>0){
+       initSimpleDicts('all',itemCodes).then(res=>{
+           Object.assign(that.dicts,res.data.data)
+       });
+    }
+   };

src/api/mdp/menu/menuFavorite.js

@@ -0,0 +1,37 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base = config.getSysBasePath();
+
+
+/**
+ * 菜单收藏夹
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={favoriteid:'菜单收藏夹ID 主键',deptPostUserid:'部门-岗位-用户ID（暂时不用）',deptid:'部门ID（暂时不用）',postid:'岗位ID（暂时不用）',userid:'用户ID（暂时不用）',menuid:'菜单ID（暂时不用）',menuname:'菜单名称',sort:'排序',branchId:'云用户机构编号',cuserid:'创建人',cdate:'创建时间',lopuserid:'最后操作人',lopcreate:'最后操作时间',accUrl:'访问路径',icon:'菜单图标'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listMenuFavorite = params => { return axios.get(`${base}/mdp/menu/menuFavorite/list`, { params: params }); };
+
+//模糊查询菜单收藏夹 条件之间or关系  
+//export const listMenuFavoriteKey = params => { return axios.get(`${base}/mdp/menu/menuFavorite/listKey`, { params: params }); };
+
+//删除一条菜单收藏夹 params={favoriteid:'菜单收藏夹ID 主键'}
+export const delMenuFavorite = params => { return axios.post(`${base}/mdp/menu/menuFavorite/del`,params); };
+
+//批量删除菜单收藏夹  params=[{favoriteid:'菜单收藏夹ID 主键'}]
+export const batchDelMenuFavorite = params => { return axios.post(`${base}/mdp/menu/menuFavorite/batchDel`, params); };
+
+//修改一条菜单收藏夹记录
+export const editMenuFavorite = params => { return axios.post(`${base}/mdp/menu/menuFavorite/edit`, params); };
+
+//新增一条菜单收藏夹
+export const addMenuFavorite = params => { return axios.post(`${base}/mdp/menu/menuFavorite/add`, params); };
+
+
+export const saveMenuFavoritesApi = params => { return axios.post(`${base}/mdp/menu/menuFavorite/saveMenuFavorites`, params); };
+
+export const getMenuFavoritesApi = params => { return axios.post(`${base}/mdp/menu/menuFavorite/getMenuFavorites`, params); };
+
+export const addMenuFavoriteIconApi = params => { return axios.post(`${base}/mdp/menu/menuFavorite/addMenuFavoriteIcon`, params); };

src/api/mdp/menu/menuModule.js

@@ -0,0 +1,44 @@
+import axios from '@/utils/request'
+
+import { getDicts,initSimpleDicts,initComplexDicts } from '@/api/mdp/meta/item';//字典表
+import config from '@/common/config'
+
+let base = config.getSysBasePath();
+
+/**-------------------------与后端通讯接口------------------请写在下面-------------------------------------------- */
+/**
+ * 模块定义表-用于进行机构级别的权限控制，机构如果购买了模块，则能够进行访问
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {pageNum:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={id:'编号 主键',name:'模块名称',fee:'模块费用',billMode:'计费模式：0-不计费，1-按购买人数计费，2-总包费用,3-按实际使用人数每月计费',uniFee:'人均费用',discount:'折扣比率，可折上折，叠加折扣。-按最大人数、按月数优惠',url:'匹配的url,如果匹配得到，则计费，以逗号分割多个',ignoreUrl:'匹配这个地址的不计费',bizFlowState:'审核状态',procInstId:'审核流程实例编号',status:'0-下架，1-上架。开放后才可以购买使用',mcate:'分类1-协同、2-研发、3-电商',logoUrl:'logo地址',feeDesc:'费用解释',udisRate:'人数折算比例。购买总人数*折扣率为当前模块购买人数',udis:'是否折算人数0否1是',saleDesc:'营销文案',ucheck:'是否控制总人数0-否1是',crow:'是否为众包'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listMenuModule = params => { return axios.get(`${base}/mdp/menu/menuModule/list`, { params: params }); };
+
+//删除一条模块定义表-用于进行机构级别的权限控制，机构如果购买了模块，则能够进行访问 params={id:'编号 主键'}
+export const delMenuModule = params => { return axios.post(`${base}/mdp/menu/menuModule/del`,params); };
+
+//批量删除模块定义表-用于进行机构级别的权限控制，机构如果购买了模块，则能够进行访问  params=[{id:'编号 主键'}]
+export const batchDelMenuModule = params => { return axios.post(`${base}/mdp/menu/menuModule/batchDel`, params); };
+
+//修改一条模块定义表-用于进行机构级别的权限控制，机构如果购买了模块，则能够进行访问记录
+export const editMenuModule = params => { return axios.post(`${base}/mdp/menu/menuModule/edit`, params); };
+
+//新增一条模块定义表-用于进行机构级别的权限控制，机构如果购买了模块，则能够进行访问
+export const addMenuModule = params => { return axios.post(`${base}/mdp/menu/menuModule/add`, params); };
+
+//批量修改某些字段
+export const editSomeFieldsMenuModule = params => { return axios.post(`${base}/mdp/menu/menuModule/editSomeFields`, params); };
+
+
+
+/**-------------------------前端mng|add|edit界面公共函数---------------请写在下面----------------------------------------------- */
+//初始化页面上的字典
+export const initDicts = (that) => {
+ var itemCodes=['moduleBillMode','bizFlowState','mcate'];//在此添加要加载的字典 如['sex','grade','lvl']
+ if(itemCodes.length>0){
+    initSimpleDicts('all',itemCodes).then(res=>{
+        Object.assign(that.dicts,res.data.data)
+    });
+ }
+};

src/api/mdp/menu/menuModuleBranch.js

@@ -0,0 +1,48 @@
+import axios from '@/utils/request'
+
+import { getDicts,initSimpleDicts,initComplexDicts } from '@/api/mdp/meta/item';//字典表
+import config from '@/common/config'
+
+let base = config.getSysBasePath();
+
+/**-------------------------与后端通讯接口------------------请写在下面-------------------------------------------- */
+/**
+ * 机构开通模块对应关系表
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {pageNum:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={branchId:'机构编号 主键',moduleId:'模块编号 主键',startTime:'启用日期',endTime:'结束日期',ctime:'创建日期',ltime:'更新日期',cuserid:'创建人编号',cusername:'创建人姓名',luserid:'修改人编号',lusername:'修改人姓名',status:'状态0停用1启用',musers:'购买用户数',mbidNum:'可投标次数-每月恢复为套餐数量，包含公司账户次数+个人以组织名义接单的次数，以上每接一单扣减此处',sfeeRate:'服务费率，15=15%',ver:'购买版本',feeDate:'开始计费日期'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listMenuModuleBranch = params => { return axios.get(`${base}/mdp/menu/menuModuleBranch/list`, { params: params }); };
+
+//删除一条机构开通模块对应关系表 params={branchId:'机构编号 主键',moduleId:'模块编号 主键'}
+export const delMenuModuleBranch = params => { return axios.post(`${base}/mdp/menu/menuModuleBranch/del`,params); };
+
+//批量删除机构开通模块对应关系表  params=[{branchId:'机构编号 主键',moduleId:'模块编号 主键'}]
+export const batchDelMenuModuleBranch = params => { return axios.post(`${base}/mdp/menu/menuModuleBranch/batchDel`, params); };
+
+//修改一条机构开通模块对应关系表记录
+export const editMenuModuleBranch = params => { return axios.post(`${base}/mdp/menu/menuModuleBranch/edit`, params); };
+
+//新增一条机构开通模块对应关系表
+export const addMenuModuleBranch = params => { return axios.post(`${base}/mdp/menu/menuModuleBranch/add`, params); };
+
+//批量修改某些字段
+export const editSomeFieldsMenuModuleBranch = params => { return axios.post(`${base}/mdp/menu/menuModuleBranch/editSomeFields`, params); };
+
+
+//统计登录机构的产品购买情况
+export const calcBranchModule = params => { return axios.get(`${base}//mdp/menu/menuModuleBranch/calcBranchModule`, { params: params }); };
+
+
+/**-------------------------前端mng|add|edit界面公共函数---------------请写在下面----------------------------------------------- */
+//初始化页面上的字典
+export const initDicts = (that) => {
+ var itemCodes=[];//在此添加要加载的字典 如['sex','grade','lvl']
+ that.dicts['status']=[{id:'0',name:'停用'},{id:'1',name:'启用'}]
+ if(itemCodes.length>0){
+    initSimpleDicts('all',itemCodes).then(res=>{
+        Object.assign(that.dicts,res.data.data)
+    });
+ }
+};

src/api/mdp/menu/menuRole.js

@@ -0,0 +1,36 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base=config.getSysBasePath();
+
+/**
+ * 菜单角色分配
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={id:'编号 主键',roleid:'用户组编号',mid:'菜单编号',branchId:'机构编号'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listMenuRole = params => { return axios.get(`${base}/mdp/menu/menuRole/list`, { params: params }); };
+
+//模糊查询菜单角色分配 条件之间or关系  
+//export const listMenuRoleKey = params => { return axios.get(`${base}/mdp/menu/menuRole/listKey`, { params: params }); };
+
+//删除一条菜单角色分配 params={id:'编号 主键'}
+export const delMenuRole = params => { return axios.post(`${base}/mdp/menu/menuRole/del`,params); };
+
+//批量删除菜单角色分配  params=[{id:'编号 主键'}]
+export const batchDelMenuRole = params => { return axios.post(`${base}/mdp/menu/menuRole/batchDel`, params); };
+
+export const batchEditMenusToRole = params => { return axios.post(`${base}/mdp/menu/menuRole/batchEditMenusToRole`, params); };
+export const batchEditMenusToRoles = params => { return axios.post(`${base}/mdp/menu/menuRole/batchEditMenusToRoles`, params); };
+
+export const batchEditMenuToRoles = params => { return axios.post(`${base}/mdp/menu/menuRole/batchEditMenuToRoles`, params); };
+
+
+
+//修改一条菜单角色分配记录
+export const editMenuRole = params => { return axios.post(`${base}/mdp/menu/menuRole/edit`, params); };
+
+//新增一条菜单角色分配
+export const addMenuRole = params => { return axios.post(`${base}/mdp/menu/menuRole/add`, params); };

src/api/mdp/meta/pushLink.js

@@ -0,0 +1,34 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base = config.getSysBasePath();
+
+
+/**
+ * 发布关联，管理端客户管理界面只能看到发布到各自平台的字典
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={itemId:'item_id 主键',targetId:'发布到目标编号 主键',ptime:'发布时间'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listPushLink = params => { return axios.get(`${base}/mdp/meta/pushLink/list`, { params: params }); };
+
+//模糊查询发布关联，管理端客户管理界面只能看到发布到各自平台的字典 条件之间or关系  
+//export const listPushLinkKey = params => { return axios.get(`${base}/mdp/meta/pushLink/listKey`, { params: params }); };
+
+//删除一条发布关联，管理端客户管理界面只能看到发布到各自平台的字典 params={itemId:'item_id 主键',targetId:'发布到目标编号 主键'}
+export const delPushLink = params => { return axios.post(`${base}/mdp/meta/pushLink/del`,params); };
+
+//批量删除发布关联，管理端客户管理界面只能看到发布到各自平台的字典  params=[{itemId:'item_id 主键',targetId:'发布到目标编号 主键'}]
+export const batchDelPushLink = params => { return axios.post(`${base}/mdp/meta/pushLink/batchDel`, params); };
+
+//修改一条发布关联，管理端客户管理界面只能看到发布到各自平台的字典记录
+export const editPushLink = params => { return axios.post(`${base}/mdp/meta/pushLink/edit`, params); };
+
+//新增一条发布关联，管理端客户管理界面只能看到发布到各自平台的字典
+export const addPushLink = params => { return axios.post(`${base}/mdp/meta/pushLink/add`, params); };
+
+
+//新增一条发布关联，管理端客户管理界面只能看到发布到各自平台的字典
+export const pushToTargetApps = params => { return axios.post(`${base}/mdp/meta/pushLink/pushToTargetApps`, params); };

src/api/mdp/mo/moOrder.js

@@ -0,0 +1,45 @@
+import axios from '@/utils/request'
+
+import { getDicts,initSimpleDicts,initComplexDicts } from '@/api/mdp/meta/item';//字典表
+import config from '@/common/config'
+
+let base = config.getMoBasePath();
+
+/**-------------------------与后端通讯接口------------------请写在下面-------------------------------------------- */
+/**
+ * mo_order
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {pageNum:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={id:'订单编号 主键',name:'订单名称',obranchId:'下单机构号码',ouserid:'下单用户编号',ousername:'下单用户名称',moFinalFee:'模块合计总金额=模块中的final_fee合计',status:'订单状态0-初始，1-待确认，2-待付款，3-已付款，4-已完成，5-已取消-未付款前可取消，取消后可删除，6-退单-退单后变为已取消，8已关闭-售后完成后可以关闭订单',sstatus:'结算状态0-待结算，1-已结算',ctime:'创建时间',payTime:'付款时间',payCtime:'付款确认时间',moOrginFee:'折扣前总价=模块中orgin_fee合计',ousers:'购买人数',ocates:'购买分类数',omodules:'购买模块数',poid:'上级订单-如果是续费订单，记录原订单号',startTime:'启用日期',endTime:'结束日期',payType:'支付方式1-微信，2-支付宝，3-线下支付',payId:'付款流水号',prepayId:'付款订单号（第三方返回）',topenId:'第三方账号编号',pbankId:'收款银行编号(支付方式为3时必填)',pbankName:'收款银行名称(支付方式为3时必填)',pbankCardNo:'收款银行卡号(支付方式为3时必填)',pbankUsername:'收款账户姓名(支付方式为3时必填)',remark:'备注',finishTime:'完成时间',closeTime:'关闭时间',setTime:'结算时间',odays:'购买天数',ofinalFee:'最终订单价格、最终付款金额=mo_final_fee+oth_fee',odisRate:'订单折扣率(下单后后台根据不同客户进行折扣调整)=将在模块表中执行折扣操作，再从新合计价格',othFee:'其它费用',otype:'订单类型0-电商商城商品，1-应用模块使用购买，2-vip购买会员',osource:'订单来源1-前端客户下单，2-后台待客下单',memType:'客户类型-参考sys_user表mem_type',atype:'账户类型-根据sys_user表atype',saleUserid:'销售经理编号',saleUsername:'销售经理名称',custPhone:'客户联系电话',custAddress:'客户联系地址',payAt:'最终付款金额-客户付款后回填',obranchName:'下单机构名称',ooper:'订单操作类型1-新购，2-续费，3-新增人数'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listMoOrder = params => { return axios.get(`${base}/mdp/mo/moOrder/list`, { params: params }); };
+
+//删除一条mo_order params={id:'订单编号 主键'}
+export const delMoOrder = params => { return axios.post(`${base}/mdp/mo/moOrder/del`,params); };
+
+//批量删除mo_order  params=[{id:'订单编号 主键'}]
+export const batchDelMoOrder = params => { return axios.post(`${base}/mdp/mo/moOrder/batchDel`, params); };
+
+//修改一条mo_order记录
+export const editMoOrder = params => { return axios.post(`${base}/mdp/mo/moOrder/edit`, params); };
+
+//新增一条mo_order
+export const addMoOrder = params => { return axios.post(`${base}/mdp/mo/moOrder/add`, params); };
+
+//批量修改某些字段
+export const editSomeFieldsMoOrder = params => { return axios.post(`${base}/mdp/mo/moOrder/editSomeFields`, params); };
+
+
+
+/**-------------------------前端mng|add|edit界面公共函数---------------请写在下面----------------------------------------------- */
+//初始化页面上的字典
+export const initDicts = (that) => {
+ var itemCodes=['mo_order_status','tpAppPayType','mo_ooper','moduleBillMode'];//在此添加要加载的字典 如['sex','grade','lvl']
+ that.dicts.osource=[{id:'1',name:'前端客户下单'},{id:'2',name:'后台待客下单'}]//1-前端客户下单，2-后台待客下单
+ if(itemCodes.length>0){
+    initSimpleDicts('all',itemCodes).then(res=>{
+        Object.assign(that.dicts,res.data.data)
+    });
+ }
+};

src/api/mdp/mo/moOrderModule.js

@@ -0,0 +1,44 @@
+import axios from '@/utils/request'
+
+import { getDicts,initSimpleDicts,initComplexDicts } from '@/api/mdp/meta/item';//字典表
+import config from '@/common/config'
+
+let base = config.getMoBasePath();
+
+/**-------------------------与后端通讯接口------------------请写在下面-------------------------------------------- */
+/**
+ * 订单与模块关系表
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {pageNum:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={orderId:'订单编号 主键',moduleId:'模块编号 主键',name:'模块名称',fee:'模块费用',billMode:'计费模式：0-不计费，1-按购买人数计费，2-总包费用,3-按实际使用人数每月计费',uniFee:'人均费用,单位人天',discount:'折扣比率，可折上折，叠加折扣。-按最大人数、按月数优惠',mcate:'分类(关联mo_cate)',logoUrl:'logo地址',feeDesc:'费用解释',udisRate:'人数折算比例。购买总人数*折扣率为当前模块购买人数',udis:'是否折算人数0否1是',musers:'购买人数=订单表中购买总人数*人数折扣',finalFee:'最终总费用=orgin_fee*dis_rate',days:'购买天数',orginFee:'原始总费用，未进行折扣方案前的总费用如果计费模式为1，则为uni_fee*musers*days单价*折扣方案天数折扣*折扣方案中人数折扣，如果计费模式为2，则为fee',disRate:'订单折扣率（可能会根据客户类型后台改订单折扣，从新计算订单价格）',ucheck:'是否控制总人数0-否1-是',ousers:'企业总人数=订单表中ousers',ver:'购买的版本0免费版，1企业版'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listMoOrderModule = params => { return axios.get(`${base}/mdp/mo/moOrderModule/list`, { params: params }); };
+
+//删除一条订单与模块关系表 params={orderId:'订单编号 主键',moduleId:'模块编号 主键'}
+export const delMoOrderModule = params => { return axios.post(`${base}/mdp/mo/moOrderModule/del`,params); };
+
+//批量删除订单与模块关系表  params=[{orderId:'订单编号 主键',moduleId:'模块编号 主键'}]
+export const batchDelMoOrderModule = params => { return axios.post(`${base}/mdp/mo/moOrderModule/batchDel`, params); };
+
+//修改一条订单与模块关系表记录
+export const editMoOrderModule = params => { return axios.post(`${base}/mdp/mo/moOrderModule/edit`, params); };
+
+//新增一条订单与模块关系表
+export const addMoOrderModule = params => { return axios.post(`${base}/mdp/mo/moOrderModule/add`, params); };
+
+//批量修改某些字段
+export const editSomeFieldsMoOrderModule = params => { return axios.post(`${base}/mdp/mo/moOrderModule/editSomeFields`, params); };
+
+
+
+/**-------------------------前端mng|add|edit界面公共函数---------------请写在下面----------------------------------------------- */
+//初始化页面上的字典
+export const initDicts = (that) => {
+ var itemCodes=['moduleBillMode'];//在此添加要加载的字典 如['sex','grade','lvl']
+ if(itemCodes.length>0){
+    initSimpleDicts('all',itemCodes).then(res=>{
+        Object.assign(that.dicts,res.data.data)
+    });
+ }
+};

src/api/mdp/plat/bankAccount.js

@@ -0,0 +1,30 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base = config.getSysBasePath();
+
+
+/**
+ * 平台收付款账户
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={cardAccountId:'银行卡账户编号 主键',platformId:'平台编号 主键',bankName:'银行名称',bankCode:'银行机构码',cardAccountName:'银行卡账户名称',subBankName:'银行分支机构名称',subBankCode:'分支机构编码',ctime:'新增时间',ltime:'更新时间',opUserid:'操作用户编号',opUsername:'操作用户名称',status:'账户状态0无效1有效',type:'账户性质0-平台收款'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listBankAccount = params => { return axios.get(`${base}/mdp/plat/bankAccount/list`, { params: params }); };
+
+//模糊查询平台收付款账户 条件之间or关系  
+//export const listBankAccountKey = params => { return axios.get(`${base}/mdp/plat/bankAccount/listKey`, { params: params }); };
+
+//删除一条平台收付款账户 params={cardAccountId:'银行卡账户编号 主键',platformId:'平台编号 主键'}
+export const delBankAccount = params => { return axios.post(`${base}/mdp/plat/bankAccount/del`,params); };
+
+//批量删除平台收付款账户  params=[{cardAccountId:'银行卡账户编号 主键',platformId:'平台编号 主键'}]
+export const batchDelBankAccount = params => { return axios.post(`${base}/mdp/plat/bankAccount/batchDel`, params); };
+
+//修改一条平台收付款账户记录
+export const editBankAccount = params => { return axios.post(`${base}/mdp/plat/bankAccount/edit`, params); };
+
+//新增一条平台收付款账户
+export const addBankAccount = params => { return axios.post(`${base}/mdp/plat/bankAccount/add`, params); };

src/api/mdp/plat/platform.js

@@ -0,0 +1,30 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base = config.getSysBasePath();
+
+
+/**
+ * plat_platform
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={id:'平台编号建议为platform-001 主键',platformName:'平台名称',status:'0-未启用，1-已启用，只能有一条数据有效',ctime:'创建时间',ltime:'更新时间',cuserid:'创建人编号',cusername:'创建人姓名',logoUrl:'平台logo图片地址',platformTitle:'前端显示的平台名称',keywords:'关键词逗号分割',minBuyAmount:'最小购买金额，达到此购物金额，才能提交订单',autoConfirmReceipt:'自动确认收货0否1是，确认收货时长请在订单设置中进行设置',canBill:'是否可开发票0否1是',billContextList:'发票内容选项,逗号分割',cutStock:'扣减库存时机0-下单付款完成，1-发货后',remarkJson:'备注填写要求',plusSales:'增加销量时机0-发货后，1-付款后',evaluate:'评价是否需要审核0否1是',discountPct:'全局折扣0~100之间',usePriceGroup:'是否使用价格套0否1是'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listPlatform = params => { return axios.get(`${base}/mdp/plat/platform/list`, { params: params }); };
+
+//模糊查询plat_platform 条件之间or关系  
+//export const listPlatformKey = params => { return axios.get(`${base}/mdp/plat/platform/listKey`, { params: params }); };
+
+//删除一条plat_platform params={id:'平台编号建议为platform-001 主键'}
+export const delPlatform = params => { return axios.post(`${base}/mdp/plat/platform/del`,params); };
+
+//批量删除plat_platform  params=[{id:'平台编号建议为platform-001 主键'}]
+export const batchDelPlatform = params => { return axios.post(`${base}/mdp/plat/platform/batchDel`, params); };
+
+//修改一条plat_platform记录
+export const editPlatform = params => { return axios.post(`${base}/mdp/plat/platform/edit`, params); };
+
+//新增一条plat_platform
+export const addPlatform = params => { return axios.post(`${base}/mdp/plat/platform/add`, params); };

src/api/mdp/sys/branchConfig.js

@@ -0,0 +1,44 @@
+import axios from '@/utils/request'
+
+import { getDicts,initSimpleDicts,initComplexDicts } from '@/api/mdp/meta/item';//字典表
+import config from '@/common/config'
+
+let base = config.getSysBasePath();
+
+/**-------------------------与后端通讯接口------------------请写在下面-------------------------------------------- */
+/**
+ * sys_branch_config
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {pageNum:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={branchId:'机构编号 主键',musers:'购买用户数',lvl:'机构等级',mbidNum:'可投标次数-每月恢复为套餐数量，包含公司账户次数+个人以组织名义接单的次数，以上每接一单扣减此处',startTime:'开始日期yyyy-MM-dd',endTime:'结束日期yyyy-MM-dd',sfeeRate:'服务费率，15=15%'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listBranchConfig = params => { return axios.get(`${base}/mdp/sys/branchConfig/list`, { params: params }); };
+
+//删除一条sys_branch_config params={branchId:'机构编号 主键'}
+export const delBranchConfig = params => { return axios.post(`${base}/mdp/sys/branchConfig/del`,params); };
+
+//批量删除sys_branch_config  params=[{branchId:'机构编号 主键'}]
+export const batchDelBranchConfig = params => { return axios.post(`${base}/mdp/sys/branchConfig/batchDel`, params); };
+
+//修改一条sys_branch_config记录
+export const editBranchConfig = params => { return axios.post(`${base}/mdp/sys/branchConfig/edit`, params); };
+
+//新增一条sys_branch_config
+export const addBranchConfig = params => { return axios.post(`${base}/mdp/sys/branchConfig/add`, params); };
+
+//批量修改某些字段
+export const editSomeFieldsBranchConfig = params => { return axios.post(`${base}/mdp/sys/branchConfig/editSomeFields`, params); };
+
+
+
+/**-------------------------前端mng|add|edit界面公共函数---------------请写在下面----------------------------------------------- */
+//初始化页面上的字典
+export const initDicts = (that) => {
+ var itemCodes=[];//在此添加要加载的字典 如['sex','grade','lvl']
+ if(itemCodes.length>0){
+    initSimpleDicts('all',itemCodes).then(res=>{
+        Object.assign(that.dicts,res.data.data)
+    });
+ }
+};

src/api/mdp/sys/branchInterests.js

@@ -0,0 +1,47 @@
+import axios from '@/utils/request'
+
+import { getDicts,initSimpleDicts,initComplexDicts } from '@/api/mdp/meta/item';//字典表
+import config from '@/common/config'
+
+let base = config.getSysBasePath();
+
+/**-------------------------与后端通讯接口------------------请写在下面-------------------------------------------- */
+/**
+ * 机构权益关联表
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {pageNum:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={branchId:'公司ID 主键',ilvlId:'等级ID',ilvlName:'等级名称',idesc:'等级描述',ilevel:'1-粉丝,2-',discount:'权益，折扣',istatus:'等级状态',ctime:'创建时间',ltime:'更新时间',picUrl:'等级图标url',isFree:'是否付费获取权益',rtimeRule:'续会时间叠加规则：1.有效期日期后叠加续会时间',rtimeType:'续会时间类型：1.天数',rtime:'下次续会时间yyyy-MM-dd型',itype:'权益分类',shopId:'商户编号',instId:'当前流程实例编号',flowState:'当前流程状态，0初始1审批中2审批通过3审批不通过4流程取消或者删除',smaxAt:'单个任务最大金额（任务型用户才有）0代表不限制',totalAt:'累计接单金额（任务型用户才有）0代表不限制',mtype:'适用会员类型（2商户型、1普通型、3任务型）',totalExp:'累计经验值0代表不限制',smaxExp:'单个任务最大经验值0代表不限制',bids:'投标次数上限',sfeeRate:'服务费率0-100之间',idBak:'覆盖上一条的等级编号，即变成当前等级之前的等级编号',currTotalExp:'累计完成工作量',currBids:'当前月份投标次数（每月最后一天清零）',currTotalAt:'当前累计完成金额',currTotalBids:'累计投标总数',mfee:'月均费用',maxUsers:'最大人员数',currUsers:'当前人员数',maxRtime:'产品模块下次续费截止时间yyyy-MM-dd类型',mver:'产品版本0个人版1企业版'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listBranchInterests = params => { return axios.get(`${base}/mdp/sys/branchInterests/list`, { params: params }); };
+
+
+export const getBranchInterestsDetail = params => { return axios.get(`${base}/mdp/sys/branchInterests/detail`, { params: params }); };
+
+//删除一条机构权益关联表 params={branchId:'公司ID 主键'}
+export const delBranchInterests = params => { return axios.post(`${base}/mdp/sys/branchInterests/del`,params); };
+
+//批量删除机构权益关联表  params=[{branchId:'公司ID 主键'}]
+export const batchDelBranchInterests = params => { return axios.post(`${base}/mdp/sys/branchInterests/batchDel`, params); };
+
+//修改一条机构权益关联表记录
+export const editBranchInterests = params => { return axios.post(`${base}/mdp/sys/branchInterests/edit`, params); };
+
+//新增一条机构权益关联表
+export const addBranchInterests = params => { return axios.post(`${base}/mdp/sys/branchInterests/add`, params); };
+
+//批量修改某些字段
+export const editSomeFieldsBranchInterests = params => { return axios.post(`${base}/mdp/sys/branchInterests/editSomeFields`, params); };
+
+
+
+/**-------------------------前端mng|add|edit界面公共函数---------------请写在下面----------------------------------------------- */
+//初始化页面上的字典
+export const initDicts = (that) => {
+ var itemCodes=[];//在此添加要加载的字典 如['sex','grade','lvl']
+ if(itemCodes.length>0){
+    initSimpleDicts('all',itemCodes).then(res=>{
+        Object.assign(that.dicts,res.data.data)
+    });
+ }
+};

src/api/mdp/sys/branchModule.js

@@ -0,0 +1,49 @@
+import axios from '@/utils/request'
+
+import { getDicts,initSimpleDicts,initComplexDicts } from '@/api/mdp/meta/item';//字典表
+import config from '@/common/config'
+
+let base = config.getSysBasePath();
+
+/**-------------------------与后端通讯接口------------------请写在下面-------------------------------------------- */
+/**
+ * 管理端机构表（机构下面若干部门）
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {pageNum:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={branchId:'机构编号 主键',moduleId:'模块编号 主键',startTime:'启用日期',endTime:'结束日期',ctime:'创建日期',ltime:'更新日期',cuserid:'创建人编号',cusername:'创建人姓名',luserid:'修改人编号',lusername:'修改人姓名',status:'状态0停用1启用',musers:'购买用户数',mbidNum:'可投标次数-每月恢复为套餐数量，包含公司账户次数+个人以组织名义接单的次数，以上每接一单扣减此处',sfeeRate:'服务费率，15=15%',ver:'购买版本'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listBranchModule = params => { return axios.get(`${base}/mdp/sys/branchModule/list`, { params: params }); };
+
+
+//统计登录机构的产品购买情况
+export const calcBranchModule = params => { return axios.get(`${base}/mdp/sys/branchModule/calcBranchModule`, { params: params }); };
+
+//删除一条管理端机构表（机构下面若干部门） params={branchId:'机构编号 主键',moduleId:'模块编号 主键'}
+export const delBranchModule = params => { return axios.post(`${base}/mdp/sys/branchModule/del`,params); };
+
+//批量删除管理端机构表（机构下面若干部门）  params=[{branchId:'机构编号 主键',moduleId:'模块编号 主键'}]
+export const batchDelBranchModule = params => { return axios.post(`${base}/mdp/sys/branchModule/batchDel`, params); };
+
+//修改一条管理端机构表（机构下面若干部门）记录
+export const editBranchModule = params => { return axios.post(`${base}/mdp/sys/branchModule/edit`, params); };
+
+//新增一条管理端机构表（机构下面若干部门）
+export const addBranchModule = params => { return axios.post(`${base}/mdp/sys/branchModule/add`, params); };
+
+//批量修改某些字段
+export const editSomeFieldsBranchModule = params => { return axios.post(`${base}/mdp/sys/branchModule/editSomeFields`, params); };
+
+
+
+/**-------------------------前端mng|add|edit界面公共函数---------------请写在下面----------------------------------------------- */
+//初始化页面上的字典
+export const initDicts = (that) => {
+ that.dicts['status']=[{id:'0',name:'停用'},{id:'1',name:'启用'}]
+ var itemCodes=['moduleBillMode',"bizFlowState"];//在此添加要加载的字典 如['sex','grade','lvl']
+ if(itemCodes.length>0){
+    initSimpleDicts('all',itemCodes).then(res=>{
+        Object.assign(that.dicts,res.data.data)
+    });
+ }
+};

src/api/mdp/sys/deptLocation.js

@@ -0,0 +1,33 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base=config.getSysBasePath();
+
+/**
+ * sys_dept_location
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={deptid:'部门地址编号 主键',longitude:'经度',latitude:'纬度',address:'地址',province:'省',city:'市',district:'区'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listDeptLocation = params => { return axios.get(`${base}/mdp/sys/deptLocation/list`, { params: params }); };
+
+//模糊查询sys_dept_location 条件之间or关系  
+//export const listDeptLocationKey = params => { return axios.get(`${base}/mdp/sys/deptLocation/listKey`, { params: params }); };
+
+//删除一条sys_dept_location params={deptid:'部门地址编号 主键'}
+export const delDeptLocation = params => { return axios.post(`${base}/mdp/sys/deptLocation/del`,params); };
+
+//批量删除sys_dept_location  params=[{deptid:'部门地址编号 主键'}]
+export const batchDelDeptLocation = params => { return axios.post(`${base}/mdp/sys/deptLocation/batchDel`, params); };
+
+//修改一条sys_dept_location记录
+export const editDeptLocation = params => { return axios.post(`${base}/mdp/sys/deptLocation/edit`, params); };
+
+//新增一条sys_dept_location
+export const addDeptLocation = params => { return axios.post(`${base}/mdp/sys/deptLocation/add`, params); };
+//addAndEditDeptLocation
+export const addAndEditDeptLocation = params => { return axios.post(`${base}/mdp/sys/deptLocation/addAndEditDeptLocation`, params); };
+//getDeptLocation
+export const getDeptLocation = params => { return axios.post(`${base}/mdp/sys/deptLocation/getDeptLocation`, params); };

src/api/mdp/sys/module.js

@@ -0,0 +1,43 @@
+import axios from '@/utils/request'
+import { getDicts,initSimpleDicts,initComplexDicts } from '@/api/mdp/meta/item';//字典表
+import config from '@/common/config'
+
+let base = config.getSysBasePath();
+
+/**-------------------------与后端通讯接口------------------请写在下面-------------------------------------------- */
+/**
+ * 模块定义表-用于进行机构级别的权限控制，机构如果购买了模块，则能够进行访问
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {pageNum:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={id:'编号 主键',name:'模块名称',fee:'模块费用',billMode:'计费模式：0-不计费，1-按购买人数计费，2-总包费用,3-按实际使用人数每月计费',uniFee:'人均费用',discount:'折扣比率，可折上折，叠加折扣。-按最大人数、按年份优惠(',url:'匹配的url,如果匹配得到，则计费，以逗号分割多个',ignoreUrl:'匹配这个地址的不计费',bizFlowState:'审核状态',procInstId:'审核流程实例编号'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listModule = params => { return axios.get(`${base}/mdp/sys/module/list`, { params: params }); };
+
+//删除一条模块定义表-用于进行机构级别的权限控制，机构如果购买了模块，则能够进行访问 params={id:'编号 主键'}
+export const delModule = params => { return axios.post(`${base}/mdp/sys/module/del`,params); };
+
+//批量删除模块定义表-用于进行机构级别的权限控制，机构如果购买了模块，则能够进行访问  params=[{id:'编号 主键'}]
+export const batchDelModule = params => { return axios.post(`${base}/mdp/sys/module/batchDel`, params); };
+
+//修改一条模块定义表-用于进行机构级别的权限控制，机构如果购买了模块，则能够进行访问记录
+export const editModule = params => { return axios.post(`${base}/mdp/sys/module/edit`, params); };
+
+//新增一条模块定义表-用于进行机构级别的权限控制，机构如果购买了模块，则能够进行访问
+export const addModule = params => { return axios.post(`${base}/mdp/sys/module/add`, params); };
+
+//批量修改某些字段
+export const editSomeFieldsModule = params => { return axios.post(`${base}/mdp/sys/module/editSomeFields`, params); };
+
+
+
+/**-------------------------前端mng|add|edit界面公共函数---------------请写在下面----------------------------------------------- */
+//初始化页面上的字典
+export const initDicts = (that) => {
+ var itemCodes=['moduleBillMode','bizFlowState'];//在此添加要加载的字典 如['sex','grade','lvl']
+ if(itemCodes.length>0){
+    initSimpleDicts('all',itemCodes).then(res=>{
+        Object.assign(that.dicts,res.data.data)
+    });
+ }
+};

src/api/mdp/sys/operDataTrail.js

@@ -0,0 +1,28 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base=config.getSysBasePath();
+
+//默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:1,pageSize:10,total:0}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+
+//普通查询
+export const listOperDataTrail = params => { return axios.get(`${base}/sys/operDataTrail/list`, { params: params }); };
+
+//关键字模糊查询 {字段1:v1,字段2:v1,字段3:v1},字段驼峰命名，条件之间默认为or关系
+//export const listOperDataTrailKey = params => { return axios.get(`${base}/sys/operDataTrail/listKey`, { params: params }); };
+
+//删除一个
+export const delOperDataTrail = params => { return axios.post(`${base}/sys/operDataTrail/del`,params); };
+
+//批量删除
+export const batchDelOperDataTrail = params => { return axios.post(`${base}/sys/operDataTrail/batchDel`, params); };
+
+//修改一个
+export const editOperDataTrail = params => { return axios.post(`${base}/sys/operDataTrail/edit`, params); };
+
+//新增一个
+export const addOperDataTrail = params => { return axios.post(`${base}/sys/operDataTrail/add`, params); };
+
+//修改一个
+export const operEnd = params => { return axios.post(`${base}/sys/operDataTrail/edit/end`, params); };

src/api/mdp/sys/post/postRole.js

@@ -0,0 +1,33 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base = config.getSysBasePath();
+
+
+/**
+ * 岗位角色关系表
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={id:'主键 主键',postId:'岗位编号',roleid:'角色编号'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listPostRole = params => { return axios.get(`${base}/mdp/sys/post/postRole/list`, { params: params }); };
+
+//模糊查询岗位角色关系表 条件之间or关系  
+//export const listPostRoleKey = params => { return axios.get(`${base}/mdp/sys/post/postRole/listKey`, { params: params }); };
+
+//删除一条岗位角色关系表 params={id:'主键 主键'}
+export const delPostRole = params => { return axios.post(`${base}/mdp/sys/post/postRole/del`,params); };
+
+//批量删除岗位角色关系表  params=[{id:'主键 主键'}]
+export const batchDelPostRole = params => { return axios.post(`${base}/mdp/sys/post/postRole/batchDel`, params); };
+
+//批量删除岗位角色关系表  params=[{id:'主键 主键'}]
+export const batchAddPostRole = params => { return axios.post(`${base}/mdp/sys/post/postRole/batchAdd`, params); };
+
+//修改一条岗位角色关系表记录
+export const editPostRole = params => { return axios.post(`${base}/mdp/sys/post/postRole/edit`, params); };
+
+//新增一条岗位角色关系表
+export const addPostRole = params => { return axios.post(`${base}/mdp/sys/post/postRole/add`, params); };

src/api/mdp/sys/qx.js

@@ -0,0 +1,29 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base=config.getSysBasePath();
+
+/**
+ * 权限定义
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={qxId:'权限编号 主键',qxName:'权限名称',qxType:'权限类型data/url/base/area',remark:'备注',qxCode:'权限编码',enabled:'是否启用',deptid:'机构编号',branchId:'云用户机构编号'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listQx = params => { return axios.get(`${base}/mdp/sys/qx/list`, { params: params }); };
+
+//模糊查询权限定义 条件之间or关系  
+//export const listQxKey = params => { return axios.get(`${base}/mdp/sys/qx/listKey`, { params: params }); };
+
+//删除一条权限定义 params={qxId:'权限编号 主键'}
+export const delQx = params => { return axios.post(`${base}/mdp/sys/qx/del`,params); };
+
+//批量删除权限定义  params=[{qxId:'权限编号 主键'}]
+export const batchDelQx = params => { return axios.post(`${base}/mdp/sys/qx/batchDel`, params); };
+
+//修改一条权限定义记录
+export const editQx = params => { return axios.post(`${base}/mdp/sys/qx/edit`, params); };
+
+//新增一条权限定义
+export const addQx = params => { return axios.post(`${base}/mdp/sys/qx/add`, params); };

src/api/mdp/sys/region.js

@@ -0,0 +1,26 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base=config.getSysBasePath();
+
+//默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:1,pageSize:10,total:0}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+
+//普通查询
+export const listRegion = params => { return axios.get(`${base}/mdp/sys/region/list`, { params: params }); };
+
+//关键字模糊查询 {字段1:v1,字段2:v1,字段3:v1},字段驼峰命名，条件之间默认为or关系
+//export const listRegionKey = params => { return axios.get(`${base}/mdp/sys/region/listKey`, { params: params }); };
+export const listTreeRegion = params => { return axios.get(`${base}/mdp/sys/region/list/tree`, { params: params }); };
+
+//删除一个
+export const delRegion = params => { return axios.post(`${base}/mdp/sys/region/del`,params); };
+
+//批量删除
+export const batchDelRegion = params => { return axios.post(`${base}/mdp/sys/region/batchDel`, params); };
+
+//修改一个
+export const editRegion = params => { return axios.post(`${base}/mdp/sys/region/edit`, params); };
+
+//新增一个
+export const addRegion = params => { return axios.post(`${base}/mdp/sys/region/add`, params); };

src/api/mdp/sys/roleQx.js

@@ -0,0 +1,29 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base=config.getSysBasePath();
+
+/**
+ * 角色权限关系表
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={id:'主键 主键',qxId:'权限编号增删改查批量更新导出导入',remark:'备注',roleid:'角色编号',enabled:'是否启用',deptid:'机构编号',branchId:'云用户机构编号'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listRoleQx = params => { return axios.get(`${base}/mdp/sys/roleQx/list`, { params: params }); };
+
+//模糊查询角色权限关系表 条件之间or关系  
+//export const listRoleQxKey = params => { return axios.get(`${base}/mdp/sys/roleQx/listKey`, { params: params }); };
+
+//删除一条角色权限关系表 params={id:'主键 主键'}
+export const delRoleQx = params => { return axios.post(`${base}/mdp/sys/roleQx/del`,params); };
+
+//批量删除角色权限关系表  params=[{id:'主键 主键'}]
+export const batchDelRoleQx = params => { return axios.post(`${base}/mdp/sys/roleQx/batchDel`, params); };
+
+//批量更新角色权限
+export const batchEditRoleQx = params => { return axios.post(`${base}/sys/roleQx/batchEdit`, params); };
+
+//新增一条角色权限关系表
+export const addRoleQx = params => { return axios.post(`${base}/mdp/sys/roleQx/add`, params); };

src/api/mdp/sys/thirdPartyAccount.js

@@ -0,0 +1,25 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base=config.getSysBasePath();
+
+//默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:1,pageSize:10,total:0}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+
+//普通查询
+export const listThirdPartyAccount = params => { return axios.get(`${base}/sys/thirdPartyAccount/list`, { params: params }); };
+
+//关键字模糊查询 {字段1:v1,字段2:v1,字段3:v1},字段驼峰命名，条件之间默认为or关系
+//export const listThirdPartyAccountKey = params => { return axios.get(`${base}/sys/thirdPartyAccount/listKey`, { params: params }); };
+
+//删除一个
+//export const delThirdPartyAccount = params => { return axios.post(`${base}/sys/thirdPartyAccount/del`,params); };
+
+//批量删除
+//export const batchDelThirdPartyAccount = params => { return axios.post(`${base}/sys/thirdPartyAccount/batchDel`, params); };
+
+//修改一个
+//export const editThirdPartyAccount = params => { return axios.post(`${base}/sys/thirdPartyAccount/edit`, params); };
+
+//新增一个
+//export const addThirdPartyAccount = params => { return axios.post(`${base}/sys/thirdPartyAccount/add`, params); };

src/api/mdp/sys/userRole.js

@@ -0,0 +1,35 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base=config.getSysBasePath();
+
+/**
+ * 用户角色表
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={id:'主键ID 主键',roleid:'用户组编号',userid:'用户编号',remark:'备注',userroleBeg:'有效时间始',userroleEnd:'有效时间止',createDate:'创建日期',roleSort:'顺序号',enabled:'0不启用1启用',deptid:'机构编号',branchId:'云用户机构编号'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listUserRole = params => { return axios.get(`${base}/mdp/sys/userRole/list`, { params: params }); };
+
+//普通查询
+export const listUserInfosByRoleid = params => { return axios.get(`${base}/sys/userRole/list/users`, { params: params }); };
+
+//删除一条用户角色表 params={id:'主键ID 主键'}
+export const delUserRole = params => { return axios.post(`${base}/mdp/sys/userRole/del`,params); };
+
+//批量删除用户角色表  params=[{id:'主键ID 主键'}]
+export const batchDelUserRole = params => { return axios.post(`${base}/mdp/sys/userRole/batchDel`, params); };
+
+//修改一条用户角色表记录
+export const editUserRole = params => { return axios.post(`${base}/mdp/sys/userRole/edit`, params); };
+
+//批量删除
+export const batchEditUserRole = params => { return axios.post(`${base}/sys/userRole/batchEdit`, params); };
+
+//修改一个
+//export const editUserRole = params => { return axios.post(`${base}/sys/userRole/edit`, params); };
+
+//新增一个
+//export const addUserRole = params => { return axios.post(`${base}/sys/userRole/add`, params); };

src/api/mdp/sys/userTpa.js

@@ -0,0 +1,36 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base=config.getSysBasePath();
+
+/**
+ * 第三方系统向我方开放的用户列表
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={id:'主键 主键',unionid:'全局唯一编号',openid:'帐户加密后的编号，用于对第三方系统进行开放',userid:'MDP用户编号',locked:'是否被锁定',startdate:'启用日期',nickname:'昵称',username:'用户名称',phoneno:'移动电话号码',country:'国家',city:'城市',headimgurl:'头像地址',province:'省份',userunionid:'对应本系统user表的UNIONID',mdpAppid:'前端应用系统编号',deptid:'机构编号',branchId:'云用户机构编号',appid:'第三方登录应用系统编号',authId:'授权编号'}
+ **/
+
+//普通查询 条件之间and关系
+export const listUserTpa = params => { return axios.get(`${base}/mdp/sys/userTpa/list`, { params: params }); };
+
+//模糊查询第三方系统向我方开放的用户列表 条件之间or关系
+//export const listUserTpaKey = params => { return axios.get(`${base}/mdp/sys/userTpa/listKey`, { params: params }); };
+
+//删除一条第三方系统向我方开放的用户列表 params={id:'主键 主键'}
+export const delUserTpa = params => { return axios.post(`${base}/mdp/sys/userTpa/del`,params); };
+
+//批量删除第三方系统向我方开放的用户列表  params=[{id:'主键 主键'}]
+export const batchDelUserTpa = params => { return axios.post(`${base}/mdp/sys/userTpa/batchDel`, params); };
+
+//修改一条第三方系统向我方开放的用户列表记录
+export const editUserTpa = params => { return axios.post(`${base}/mdp/sys/userTpa/edit`, params); };
+
+//新增一条第三方系统向我方开放的用户列表
+export const addUserTpa = params => { return axios.post(`${base}/mdp/sys/userTpa/add`, params); };
+
+//查询用户表关联的第三方系统的向我方开放的用户列表
+export const selectByUserTpa = params => { return axios.get(`${base}/mdp/sys/userTpa/selectByUserTpa`, { params: params }); };
+//查看mk的会员表
+export const selectByMemMember = params => { return axios.get(`${base}/mdp/sys/userTpa/selectByMemMember`, { params: params }); };
+//添加
+export const addSubacctAddForm = params => { return axios.post(`${base}/mdp/sys/userTpa/addSubacctAddForm`, params); };

src/api/mdp/sys/userTpaApply.js

@@ -0,0 +1,30 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base = config.getSysBasePath();
+
+
+/**
+ * sys_user_tpa_apply
+ *1    默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:当前页码从1开始,pageSize:每页记录数,total:总记录【数如果是0后台会自动计算总记录数非0不会自动计算】}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+ *2 查询、新增、修改的参数格式  params={id:'主键 主键',userid:'申请人的用户编号',applyPostName:'申请的岗位名称',applyBranchId:'申请的机构编号',applyShopId:'申请的商户编号',applyLocationId:'申请的门店编号',source:'申请来源(从哪个途径申请)',status:'申请的状态(0.申请中',remark:'备注',createDate:'申请时间',updateDate:'修改时间',cuserid:'创建人id',lopuserid:'最后操作人'}
+ **/
+ 
+//普通查询 条件之间and关系  
+export const listSysUserTpaApply = params => { return axios.get(`${base}/mdp/sys/userTpaApply/list`, { params: params }); };
+
+//模糊查询sys_user_tpa_apply 条件之间or关系  
+//export const listSysUserTpaApplyKey = params => { return axios.get(`${base}/mdp/sys/userTpaApply/listKey`, { params: params }); };
+
+//删除一条sys_user_tpa_apply params={id:'主键 主键'}
+export const delSysUserTpaApply = params => { return axios.post(`${base}/mdp/sys/userTpaApply/del`,params); };
+
+//批量删除sys_user_tpa_apply  params=[{id:'主键 主键'}]
+export const batchDelSysUserTpaApply = params => { return axios.post(`${base}/mdp/sys/userTpaApply/batchDel`, params); };
+
+//修改一条sys_user_tpa_apply记录
+export const editSysUserTpaApply = params => { return axios.post(`${base}/mdp/sys/userTpaApply/edit`, params); };
+
+//新增一条sys_user_tpa_apply
+export const addSysUserTpaApply = params => { return axios.post(`${base}/mdp/sys/userTpaApply/add`, params); };

src/api/mdp/workflow/re/actAssignee.js

@@ -0,0 +1,29 @@
+import axios from '@/utils/request'
+
+import config from '@/common/config'
+
+let base=config.getWorkflowBasePath();
+
+//默认只开放普通查询，所有查询，只要上传	 分页参数 {currentPage:1,pageSize:10,total:0}，后台都会自动按分页查询 其它 api用到再打开，没用到的api请注释掉，
+
+//普通查询
+export const listActAssignee = params => { return axios.get(`${base}/mdp/workflow/re/actAssignee/list`, { params: params }); };
+
+//普通查询模型中的所有节点的执行人列表，需要procDefId
+export const getBpmnActAssignees = params => { return axios.get(`${base}/mdp/workflow/re/actAssignee/getBpmnActAssignees`, { params: params }); };
+
+
+//关键字模糊查询 {字段1:v1,字段2:v1,字段3:v1},字段驼峰命名，条件之间默认为or关系
+//export const listActAssigneeKey = params => { return axios.get(`${base}/mdp/workflow/re/actAssignee/listKey`, { params: params }); };
+
+//删除一个
+export const delActAssignee = params => { return axios.post(`${base}/mdp/workflow/re/actAssignee/del`,params); };
+
+//批量删除
+export const batchDelActAssignee = params => { return axios.post(`${base}/mdp/workflow/re/actAssignee/batchDel`, params); };
+
+//修改一个
+export const editActAssignee = params => { return axios.post(`${base}/mdp/workflow/re/actAssignee/edit`, params); };
+
+//新增一个
+export const addActAssignee = params => { return axios.post(`${base}/mdp/workflow/re/actAssignee/add`, params); };

src/components/ExtInfos/Index.vue

@@ -0,0 +1,211 @@
+<template>
+	<section> 
+	   	<el-row> 
+			<el-form  v-if="configVisible" ref="extInfosRef">  
+				<!-- 扩展字段[{name:'中文名称',id:'编号',value:'值',remark:'备注',type:'支持简单的1-普通文本2-数字，3-日期，8-富文本，9单图文，15-是否'}] -->
+				<el-row v-for="(item, index) in extInfosList" :key="index">
+					<el-form-item v-if="!item.type" > 
+						<el-select v-model="item.type" style="width:120px;">
+							<el-option v-for="(it,indexx) in itemTypes" :key="indexx" :label="it.name" :value="it.id">{{it.name}} </el-option>
+						</el-select>
+						<el-input  style="width:10%;" v-model="item.id" placeholder="字段代码(可空)"></el-input>&nbsp;&nbsp;:&nbsp;&nbsp;
+						<el-input  style="width:10%;" v-model="item.name" placeholder="字段名称"></el-input>&nbsp;&nbsp;:&nbsp;&nbsp;
+						<el-input style="width:30%;" v-model="item.value" placeholder="请输入数据"></el-input>&nbsp;&nbsp; 
+ 						<el-button  @click.prevent="removeExtInfosItem(item,index)" icon="el-icon-delete">
+						</el-button><el-button @click="addExtInfosItem(item,index)" icon="el-icon-plus"></el-button> 
+					</el-form-item>
+					<el-form-item v-else-if="item.type=='1'" > 
+						<el-select v-model="item.type"  style="width:120px;">
+							<el-option v-for="(it,indexx) in itemTypes" :key="indexx" :label="it.name" :value="it.id">{{it.name}} </el-option>
+						</el-select>
+						<el-input  style="width:10%;" v-model="item.id" placeholder="字段代码(可空)"></el-input>&nbsp;&nbsp;:&nbsp;&nbsp;
+						<el-input  style="width:10%;" v-model="item.name" placeholder="字段名称"></el-input>&nbsp;&nbsp;:&nbsp;&nbsp;
+						<el-input style="width:30%;" v-model="item.value" placeholder="请输入数据"></el-input>&nbsp;&nbsp; 
+ 						<el-button  @click.prevent="removeExtInfosItem(item,index)" icon="el-icon-delete">
+						</el-button><el-button @click="addExtInfosItem(item,index)" icon="el-icon-plus"></el-button> 
+					</el-form-item>
+					<el-form-item v-else-if="item.type=='2'"  > 
+						<el-select v-model="item.type" style="width:120px;">
+							<el-option v-for="(it,indexx) in itemTypes" :key="indexx" :label="it.name" :value="it.id">{{it.name}} </el-option>
+						</el-select>
+						<el-input  style="width:10%;" v-model="item.id" placeholder="字段代码(可空)"></el-input>&nbsp;&nbsp;:&nbsp;&nbsp;
+						<el-input  style="width:10%;" v-model="item.name" placeholder="字段名称"></el-input>&nbsp;&nbsp;:&nbsp;&nbsp;
+						<el-input type="number" style="width:30%;" v-model="item.value" placeholder="请输入数据"></el-input>&nbsp;&nbsp; 
+ 						<el-button  @click.prevent="removeExtInfosItem(item,index)" icon="el-icon-delete">
+						</el-button><el-button @click="addExtInfosItem(item,index)" icon="el-icon-plus"></el-button> 
+					</el-form-item>
+					<el-form-item v-else-if="item.type=='3'"  > 
+						<el-select v-model="item.type" style="width:120px;">
+							<el-option v-for="(it,indexx) in itemTypes" :key="indexx" :label="it.name" :value="it.id">{{it.name}} </el-option>
+						</el-select>
+						<el-input  style="width:10%;" v-model="item.id" placeholder="字段代码(可空)"></el-input>&nbsp;&nbsp;:&nbsp;&nbsp;
+						<el-input  style="width:10%;" v-model="item.name" placeholder="字段名称"></el-input>&nbsp;&nbsp;:&nbsp;&nbsp;
+						<el-date-picker style="width:30%;" value-format="yyyy-MM-dd HH:mm:ss" format="yyyy-MM-dd" v-model="item.value" placeholder="请输入数据"></el-date-picker>&nbsp;&nbsp;
+ 
+ 						<el-button  @click.prevent="removeExtInfosItem(item,index)" icon="el-icon-delete">
+						</el-button><el-button @click="addExtInfosItem(item,index)" icon="el-icon-plus"></el-button> 
+					</el-form-item>
+					<el-form-item v-else-if="item.type=='8'"  > 
+						<el-select v-model="item.type" style="width:120px;">
+							<el-option v-for="(it,indexx) in itemTypes" :key="indexx" :label="it.name" :value="it.id">{{it.name}} </el-option>
+						</el-select>
+						<el-input  style="width:10%;" v-model="item.id" placeholder="字段代码(可空)"></el-input>&nbsp;&nbsp;:&nbsp;&nbsp;
+						<el-input  style="width:10%;" v-model="item.name" placeholder="字段名称"></el-input>&nbsp;&nbsp;:&nbsp;&nbsp;
+						<el-input type="textarea" rows=6 style="width:30%;" v-model="item.value" placeholder="请输入数据"></el-input>&nbsp;&nbsp; 
+ 						<el-button  @click.prevent="removeExtInfosItem(item,index)" icon="el-icon-delete">
+						</el-button><el-button @click="addExtInfosItem(item,index)" icon="el-icon-plus"></el-button> 
+					</el-form-item>
+					<el-form-item v-else-if="item.type=='9'"  > 
+						<el-select v-model="item.type" style="width:120px;">
+							<el-option v-for="(it,indexx) in itemTypes" :key="indexx" :label="it.name" :value="it.id">{{it.name}} </el-option>
+						</el-select>
+						<el-input  style="width:10%;" v-model="item.id" placeholder="字段代码(可空)"></el-input>&nbsp;&nbsp;:&nbsp;&nbsp;
+						<el-input  style="width:10%;" v-model="item.name" placeholder="图片名称"></el-input>&nbsp;&nbsp;:&nbsp;&nbsp;
+						<el-input  style="width:20%;" v-model="item.value" placeholder="图片访问地址"></el-input>&nbsp;&nbsp; 
+						<el-input  style="width:20%;" v-model="item.link" placeholder="跳转地址"></el-input>&nbsp;&nbsp; 
+						<el-input  style="width:20%;" v-model="item.remark" placeholder="图片备注"></el-input>&nbsp;&nbsp;  
+ 						<el-button  @click.prevent="removeExtInfosItem(item,index)" icon="el-icon-delete">
+						</el-button><el-button @click="addExtInfosItem(item,index)" icon="el-icon-plus"></el-button> 
+					</el-form-item>
+					<el-form-item v-else-if="item.type=='15'"  > 
+						<el-select v-model="item.type" style="width:120px;">
+							<el-option v-for="(it,indexx) in itemTypes" :key="indexx" :label="it.name" :value="it.id">{{it.name}} </el-option>
+						</el-select>
+						<el-input  style="width:10%;" v-model="item.id" placeholder="字段代码(可空)"></el-input>&nbsp;&nbsp;:&nbsp;&nbsp;
+						<el-input  style="width:10%;" v-model="item.name" placeholder="字段名称"></el-input>&nbsp;&nbsp;:&nbsp;&nbsp;
+						<el-radio   v-model="item.value" :label="'1'" placeholder="">是</el-radio>&nbsp;&nbsp;
+						<el-radio   v-model="item.value" :label="'0'" placeholder="">否</el-radio>&nbsp;&nbsp;  
+						<el-button  @click.prevent="removeExtInfosItem(item,index)" icon="el-icon-delete">
+						</el-button><el-button @click="addExtInfosItem(item,index)" icon="el-icon-plus"></el-button> 
+					</el-form-item>
+					 
+				</el-row>
+				<el-form-item>
+					<el-button @click="configVisible=false" icon="el-icon-back"><slot>返回</slot></el-button> 
+					<el-button @click="addExtInfosFirstItem" icon="el-icon-plus"><slot>新增一行</slot></el-button> 
+				</el-form-item>
+			</el-form> 
+			<el-form  v-else ref="extInfosRef" class="demo-dynamic">  
+				<!-- 扩展字段[{name:'中文名称',id:'编号',value:'值',remark:'备注',type:'支持简单的1-普通文本2-数字，3-日期，8-富文本，9单图文，15-是否'}] -->
+				<el-row v-for="(item, index) in extInfosList" :key="index">
+					<el-form-item v-if="!item.type" :label="item.name">  
+						<el-input style="width:30%;" v-model="item.value" placeholder="请输入数据"></el-input>&nbsp;&nbsp; 
+						<el-input style="width:20%;" v-model="item.url" placeholder="请输入跳转链接"></el-input>&nbsp;&nbsp;
+						<el-input style="width:20%;" v-model="item.extInfo" placeholder="其它信息"></el-input>&nbsp;&nbsp;
+ 					</el-form-item>
+					<el-form-item v-else-if="item.type=='1'" :label="item.name"> 
+ 						<el-input style="width:30%;" v-model="item.value" placeholder="请输入数据"></el-input>&nbsp;&nbsp; 
+ 					</el-form-item>
+					<el-form-item v-else-if="item.type=='2'" :label="item.name"> 
+ 						<el-input type="number" style="width:30%;" v-model="item.value" placeholder="请输入数据"></el-input>&nbsp;&nbsp; 
+					</el-form-item>
+					<el-form-item v-else-if="item.type=='3'" :label="item.name"> 
+						 
+						<el-date-picker style="width:30%;" value-format="yyyy-MM-dd HH:mm:ss" format="yyyy-MM-dd" v-model="item.value" placeholder="请输入数据"></el-date-picker>&nbsp;&nbsp;
+						 
+					</el-form-item>
+					<el-form-item v-else-if="item.type=='8'" :label="item.name">  
+						<el-input type="textarea" rows=6 style="width:30%;" v-model="item.value" placeholder="请输入数据"></el-input>&nbsp;&nbsp;
+						 
+					</el-form-item>
+					<el-form-item v-else-if="item.type=='9'" :label="item.name">  
+						<el-input  style="width:30%;" v-model="item.value" placeholder="请输入图片地址"></el-input>&nbsp;&nbsp; 
+					</el-form-item>
+					<el-form-item v-else-if="item.type=='15'" :label="item.name">  
+						<el-radio   v-model="item.value" :label="'1'" placeholder="">是</el-radio>&nbsp;&nbsp;
+						<el-radio   v-model="item.value" :label="'0'" placeholder="">否</el-radio>&nbsp;&nbsp; 
+					</el-form-item>
+					 
+				</el-row> 
+				
+				<el-form-item v-if="!unConfig"> 
+					<el-button @click="configVisible=true" icon="el-icon-setting"><slot>配置扩展字段</slot></el-button> 
+				</el-form-item>
+			</el-form> 
+		   </el-row>
+	</section>
+</template>
+
+<script> 
+	import { mapGetters } from 'vuex'
+	 
+ 	
+	export default {  
+		name: 'extInfos',
+		props:['value','unConfig'],
+		computed: {
+		    ...mapGetters([
+		      'workSpace','userInfo'
+		    ])
+		},
+		watch:{
+			value(val){
+				
+				this.initData();
+			},
+			extInfosList:{
+				deep:true,
+				handler(val,oldVal){  
+					if(this.value instanceof Array){
+						this.$emit("input",val)
+					}else{ 
+						this.$emit("input",JSON.stringify(val))
+					}
+				}
+			}, 
+		},
+		data() { 
+			return{
+				configVisible:false,
+				itemTypes:[//支持简单的1-普通文本2-数字，3-日期，8-富文本，9单图文，15-是否'
+					{id:'1',name:'普通文本'},
+					{id:'2',name:'数字'},
+					{id:'3',name:'日期'},
+					{id:'8',name:'富文本'},
+					{id:'9',name:'单图文'},
+					{id:'15',name:'是否'}
+				],
+				extInfosList:[],//[{name:'中文名称',id:'编号',value:'值',link:'超链接',remark:'备注',type:'支持简单的1-普通文本2-数字，3-日期，8-富文本，9单图文，15-是否'}]
+
+			}
+		},//end data
+		methods: { 
+			addExtInfosFirstItem(){
+				if(!this.extInfosList){
+					this.extInfosList=[]
+				}
+				this.extInfosList.push({id:'',name:'字段名'+this.extInfosList.length+'(请修改)',value:'',url:'',extInfo:'',type:'1',remark:''})
+			},
+			addExtInfosItem(item,index){ 
+				this.extInfosList.splice(index+1,0,{id:'',name:'字段名'+(index+1)+'(请修改)',value:'',url:'',extInfo:'',type:'1',remark:''})
+			},
+			removeExtInfosItem(item,index){
+				this.extInfosList.splice(index,1)
+			},
+			initData(){
+				if(this.value){
+					if(this.value instanceof Array){
+						this.extInfosList=this.value
+					}else{
+						this.extInfosList=JSON.parse(this.value)
+					}
+				}else{
+					this.extInfosList=[]
+				}
+			}
+		},//end methods
+		components: {  
+			 
+		},
+		mounted() { 
+			 this.initData();
+			
+			
+		}
+	}
+
+</script>
+
+<style scoped>
+	 
+</style>

src/components/MyTransfer/index.vue

@@ -0,0 +1,96 @@
+<template>
+	<div>
+		<el-row>
+			<el-col :span="20">
+				<el-transfer v-model="outputListTemp" :data="inputList" :props="alias" target-order="push" @right-check-change="rightCheck"></el-transfer>
+			</el-col>
+			<el-col :span="4" style="margin-top: 95px;">
+				<div style="margin-bottom: 10px;">
+					<el-button icon="el-icon-arrow-up" circle :disabled="upDownDisable" @click="upData"></el-button>
+				</div>
+				<div>
+					<el-button icon="el-icon-arrow-down" circle :disabled="upDownDisable" @click="downData"></el-button>
+				</div>
+			</el-col>
+		</el-row>
+	</div>
+</template>
+ 
+<script>
+	import {
+		Message,
+		Notification
+	} from 'element-ui';
+	export default {
+		name: 'myTransfer',
+		props: [
+			'value',
+			'inputList',
+			'alias'
+			],
+		data() {
+			return {
+				upDownDisable:true,
+				tempSelectionKeys:[],
+				outputListTemp:[]
+			}
+		},
+		watch: {
+			value(val) {
+				this.outputListTemp = val;
+			},
+			outputListTemp(val){
+				this.$emit('input', val);
+			}
+		},
+		mounted() {
+			
+		},
+		methods: {
+            rightCheck(selectionKeys, changeKeys){
+            	this.tempSelectionKeys = selectionKeys;
+            	if(selectionKeys.length > 0){
+            		this.upDownDisable = false;
+            	}else{
+            		this.upDownDisable = true;
+            	}
+            },
+            upData(){
+				if(this.tempSelectionKeys.length > 1){
+					this.$message({
+						type: 'warning',
+						message: '仅支持单选调顺序'
+					});
+					return ;
+				}
+            	let indexNum = 0;
+            	for(let i=0; i<this.tempSelectionKeys.length; i++){
+            		indexNum = this.outputListTemp.indexOf(this.tempSelectionKeys[i])
+            		if(indexNum > 0){
+            			this.outputListTemp.splice(indexNum - 1, 0, this.tempSelectionKeys[i]);
+            			this.outputListTemp.splice(indexNum + 1, 1);
+            		}
+            	}
+            },
+            downData(){
+				if(this.tempSelectionKeys.length > 1){
+					this.$message({
+						type: 'warning',
+						message: '仅支持单选调顺序'
+					});
+					return ;
+				}
+            	let indexNum = 0;
+            	for(let i=0; i<this.tempSelectionKeys.length; i++){
+            		indexNum = this.outputListTemp.indexOf(this.tempSelectionKeys[i]);
+            		if(indexNum > -1 && indexNum != this.outputListTemp.length - 1){
+            			this.outputListTemp.splice(indexNum + 2, 0, this.tempSelectionKeys[i]);
+            			this.outputListTemp.splice(indexNum, 1);
+            		}
+            	}
+            }
+		}
+	}
+</script>
+<style type="text/css">
+</style>

src/components/TopModules/top_modules_oa.js

@@ -0,0 +1,85 @@
+var topModules=
+[
+    {
+      moduleName:"待审批",
+      topModuleId:'oa',
+      link:"/mdp/workflow/ru/task/TaskListAssigneeToMe",
+      icon: require("../../assets/image/platform/module-task.png"),
+      isHighlight:false,
+      moduleType : '1' // 模块类型，1-系统类模块 2-系统外模块
+    },
+    {
+      moduleName:"日程",
+      topModuleId:'oa',
+      link:"/oa/rc/rcScheduleMy/RcScheduleMyMng",
+      icon: require("../../assets/image/platform/module-schedule.png"),
+      isHighlight:false,
+      moduleType : '1' // 模块类型，1-系统类模块 2-系统外模块
+    },
+    {
+      moduleName:"会议",
+      topModuleId:'oa',
+      link:"/oa/meet/meetMeeting/MeetMeetingRequire",
+      icon: require("../../assets/image/platform/module-meeting.png"),
+      isHighlight:false,
+      moduleType : '1' // 模块类型，1-系统类模块 2-系统外模块
+    },
+    {
+      moduleName:"办公用品",
+      topModuleId:'oa',
+      link:"/oa/om/omCategory/OmCategoryMng",
+      icon: require("../../assets/image/platform/module-office.png"),
+      isHighlight:false,
+      moduleType : '1' // 模块类型，1-系统类模块 2-系统外模块
+    },
+    {
+      moduleName:"档案",
+      topModuleId:'oa',
+      link:"/oa/hr/user/employeeInfo",
+      icon: require("../../assets/image/platform/module-record.png"),
+      isHighlight:false,
+      moduleType : '1' // 模块类型，1-系统类模块 2-系统外模块
+    },
+    {
+      moduleName:"通讯录",
+      topModuleId:'sys',
+      link:"/mdp/sys/user/deptUserMng",
+      icon: require("../../assets/image/platform/module-addressBook.png"),
+      isHighlight:false,
+      moduleType : '2' // 模块类型，1-系统类模块 2-系统外模块
+    },
+    {
+      moduleName:"合同",
+      topModuleId:'oa',
+      link:"/oa/ht/contractCard/ContractCardMng",
+      icon: require("../../assets/image/platform/module-contract.png"),
+      isHighlight:false,
+      moduleType : '1' // 模块类型，1-系统类模块 2-系统外模块
+    },
+    {
+      moduleName:"财务",
+      topModuleId:'ac',
+      link:"",
+      icon: require("../../assets/image/platform/module-finance.png"),
+      isHighlight:false,
+      moduleType : '2' // 模块类型，1-系统类模块 2-系统外模块
+    },
+    {
+      moduleName:"项目",
+      topModuleId:'xm',
+      link:"/xm/core/xmProject/XmProjectMng",
+      icon: require("../../assets/image/platform/module-project.png"),
+      isHighlight:false,
+      moduleType : '1' // 模块类型，1-系统类模块 2-系统外模块
+    },
+    {
+      moduleName:"资产",
+      topModuleId:'oa',
+      link:"/oa/erp/pur/require/RequireMng",
+      icon: require("../../assets/image/platform/module-property.png"),
+      isHighlight:false,
+      moduleType : '1' // 模块类型，1-系统类模块 2-系统外模块
+    },
+]
+
+export default topModules

src/components/TopModules/top_modules_sys.js

@@ -0,0 +1,85 @@
+var topModules=
+[
+    {
+      moduleName:"待审批",
+      topModuleId:'oa',
+      link:"/mdp/workflow/ru/task/TaskListAssigneeToMe",
+      icon: require("../../assets/image/platform/module-task.png"),
+      isHighlight:false,
+      moduleType : '1' // 模块类型，1-系统类模块 2-系统外模块
+    },
+    {
+      moduleName:"日程",
+      topModuleId:'oa',
+      link:"/oa/rc/rcScheduleMy/RcScheduleMyMng",
+      icon: require("../../assets/image/platform/module-schedule.png"),
+      isHighlight:false,
+      moduleType : '1' // 模块类型，1-系统类模块 2-系统外模块
+    },
+    {
+      moduleName:"会议",
+      topModuleId:'oa',
+      link:"/oa/meet/meetMeeting/MeetMeetingRequire",
+      icon: require("../../assets/image/platform/module-meeting.png"),
+      isHighlight:false,
+      moduleType : '1' // 模块类型，1-系统类模块 2-系统外模块
+    },
+    {
+      moduleName:"办公用品",
+      topModuleId:'oa',
+      link:"/oa/om/omCategory/OmCategoryMng",
+      icon: require("../../assets/image/platform/module-office.png"),
+      isHighlight:false,
+      moduleType : '1' // 模块类型，1-系统类模块 2-系统外模块
+    },
+    {
+      moduleName:"档案",
+      topModuleId:'oa',
+      link:"/oa/hr/user/employeeInfo",
+      icon: require("../../assets/image/platform/module-record.png"),
+      isHighlight:false,
+      moduleType : '1' // 模块类型，1-系统类模块 2-系统外模块
+    },
+    {
+      moduleName:"通讯录",
+      topModuleId:'sys',
+      link:"/mdp/sys/user/deptUserMng",
+      icon: require("../../assets/image/platform/module-addressBook.png"),
+      isHighlight:false,
+      moduleType : '2' // 模块类型，1-系统类模块 2-系统外模块
+    },
+    {
+      moduleName:"合同",
+      topModuleId:'oa',
+      link:"/oa/ht/contractCard/ContractCardMng",
+      icon: require("../../assets/image/platform/module-contract.png"),
+      isHighlight:false,
+      moduleType : '1' // 模块类型，1-系统类模块 2-系统外模块
+    },
+    {
+      moduleName:"财务",
+      topModuleId:'ac',
+      link:"",
+      icon: require("../../assets/image/platform/module-finance.png"),
+      isHighlight:false,
+      moduleType : '2' // 模块类型，1-系统类模块 2-系统外模块
+    },
+    {
+      moduleName:"项目",
+      topModuleId:'xm',
+      link:"/xm/core/xmProject/XmProjectMng",
+      icon: require("../../assets/image/platform/module-project.png"),
+      isHighlight:false,
+      moduleType : '1' // 模块类型，1-系统类模块 2-系统外模块
+    },
+    {
+      moduleName:"资产",
+      topModuleId:'oa',
+      link:"/oa/erp/pur/require/RequireMng",
+      icon: require("../../assets/image/platform/module-property.png"),
+      isHighlight:false,
+      moduleType : '1' // 模块类型，1-系统类模块 2-系统外模块
+    },
+]
+
+export default topModules

src/components/Upload/singleImage.vue

@@ -0,0 +1,123 @@
+<template>
+    <div class="upload-container">
+        <el-upload class="image-uploader" :data="dataObj" drag :multiple="false" :show-file-list="false" action="https://httpbin.org/post"
+            :on-success="handleImageScucess">
+            <i class="el-icon-upload"></i>
+            <div class="el-upload__text">将文件拖到此处，或<em>点击上传</em></div>
+        </el-upload>
+        <div class="image-preview">
+            <div class="image-preview-wrapper" v-show="imageUrl.length>1">
+                <img :src="imageUrl+'?imageView2/1/w/200/h/200'">
+                <div class="image-preview-action">
+                    <i @click="rmImage" class="el-icon-delete"></i>
+                </div>
+            </div>
+        </div>
+    </div>
+</template>
+
+<script>
+// 预览效果见付费文章
+import { getToken } from '@/api/qiniu'
+
+export default {
+  name: 'singleImageUpload',
+  props: {
+    value: String
+  },
+  computed: {
+    imageUrl() {
+      return this.value
+    }
+  },
+  data() {
+    return {
+      tempUrl: '',
+      dataObj: { token: '', key: '' }
+    }
+  },
+  methods: {
+    rmImage() {
+      this.emitInput('')
+    },
+    emitInput(val) {
+      this.$emit('input', val)
+    },
+    handleImageScucess() {
+      this.emitInput(this.tempUrl)
+    },
+    beforeUpload() {
+      const _self = this
+      return new Promise((resolve, reject) => {
+        getToken().then(response => {
+          const key = response.data.qiniu_key
+          const token = response.data.qiniu_token
+          _self._data.dataObj.token = token
+          _self._data.dataObj.key = key
+          this.tempUrl = response.data.qiniu_url
+          resolve(true)
+        }).catch(err => {
+          console.log(err)
+          reject(false)
+        })
+      })
+    }
+  }
+}
+</script>
+
+<style rel="stylesheet/scss" lang="scss" scoped>
+    @import "src/styles/mixin.scss";
+    .upload-container {
+        width: 100%;
+        position: relative;
+        @include clearfix;
+        .image-uploader {
+            width: 60%;
+            float: left;
+        }
+        .image-preview {
+            width: 200px;
+            height: 200px;
+            position: relative;
+            border: 1px dashed #d9d9d9;
+            float: left;
+            margin-left: 50px;
+            .image-preview-wrapper {
+                position: relative;
+                width: 100%;
+                height: 100%;
+                img {
+                    width: 100%;
+                    height: 100%;
+                }
+            }
+            .image-preview-action {
+                position: absolute;
+                width: 100%;
+                height: 100%;
+                left: 0;
+                top: 0;
+                cursor: default;
+                text-align: center;
+                color: #fff;
+                opacity: 0;
+                font-size: 20px;
+                background-color: rgba(0, 0, 0, .5);
+                transition: opacity .3s;
+                cursor: pointer;
+                text-align: center;
+                line-height: 200px;
+                .el-icon-delete {
+                    font-size: 36px;
+                }
+            }
+            &:hover {
+                .image-preview-action {
+                    opacity: 1;
+                }
+            }
+        }
+    }
+
+</style>

src/components/Upload/singleImage2.vue

@@ -0,0 +1,118 @@
+<template>
+  <div class="singleImageUpload2 upload-container">
+    <el-upload class="image-uploader" :data="dataObj" drag :multiple="false" :show-file-list="false" action="https://httpbin.org/post"
+      :on-success="handleImageScucess">
+      <i class="el-icon-upload"></i>
+      <div class="el-upload__text">Drag或<em>点击上传</em></div>
+    </el-upload>
+    <div v-show="imageUrl.length>0" class="image-preview">
+      <div class="image-preview-wrapper" v-show="imageUrl.length>1">
+        <img :src="imageUrl">
+        <div class="image-preview-action">
+          <i @click="rmImage" class="el-icon-delete"></i>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script>
+import { getToken } from '@/api/qiniu'
+
+export default {
+  name: 'singleImageUpload2',
+  props: {
+    value: String
+  },
+  computed: {
+    imageUrl() {
+      return this.value
+    }
+  },
+  data() {
+    return {
+      tempUrl: '',
+      dataObj: { token: '', key: '' }
+    }
+  },
+  methods: {
+    rmImage() {
+      this.emitInput('')
+    },
+    emitInput(val) {
+      this.$emit('input', val)
+    },
+    handleImageScucess() {
+      this.emitInput(this.tempUrl)
+    },
+    beforeUpload() {
+      const _self = this
+      return new Promise((resolve, reject) => {
+        getToken().then(response => {
+          const key = response.data.qiniu_key
+          const token = response.data.qiniu_token
+          _self._data.dataObj.token = token
+          _self._data.dataObj.key = key
+          this.tempUrl = response.data.qiniu_url
+          resolve(true)
+        }).catch(() => {
+          reject(false)
+        })
+      })
+    }
+  }
+}
+</script>
+
+<style rel="stylesheet/scss" lang="scss" scoped>
+.upload-container {
+  width: 100%;
+  height: 100%;
+  position: relative;
+  .image-uploader {
+    height: 100%;
+  }
+  .image-preview {
+    width: 100%;
+    height: 100%;
+    position: absolute;
+    left: 0px;
+    top: 0px;
+    border: 1px dashed #d9d9d9;
+    .image-preview-wrapper {
+      position: relative;
+      width: 100%;
+      height: 100%;
+      img {
+        width: 100%;
+        height: 100%;
+      }
+    }
+    .image-preview-action {
+      position: absolute;
+      width: 100%;
+      height: 100%;
+      left: 0;
+      top: 0;
+      cursor: default;
+      text-align: center;
+      color: #fff;
+      opacity: 0;
+      font-size: 20px;
+      background-color: rgba(0, 0, 0, .5);
+      transition: opacity .3s;
+      cursor: pointer;
+      text-align: center;
+      line-height: 200px;
+      .el-icon-delete {
+        font-size: 36px;
+      }
+    }
+    &:hover {
+      .image-preview-action {
+        opacity: 1;
+      }
+    }
+  }
+}
+</style>

src/components/Upload/singleImage3.vue

@@ -0,0 +1,145 @@
+<template>
+  <div class="upload-container">
+    <el-upload class="image-uploader" :data="dataObj" drag :multiple="false" :show-file-list="false" action="https://httpbin.org/post"
+      :on-success="handleImageScucess">
+      <i class="el-icon-upload"></i>
+      <div class="el-upload__text">将文件拖到此处，或<em>点击上传</em></div>
+    </el-upload>
+    <div class="image-preview image-app-preview">
+      <div class="image-preview-wrapper" v-show="imageUrl.length>1">
+        <img :src="imageUrl">
+        <div class="image-preview-action">
+          <i @click="rmImage" class="el-icon-delete"></i>
+        </div>
+      </div>
+    </div>
+    <div class="image-preview">
+      <div class="image-preview-wrapper" v-show="imageUrl.length>1">
+        <img :src="imageUrl">
+        <div class="image-preview-action">
+          <i @click="rmImage" class="el-icon-delete"></i>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script>
+import { getToken } from '@/api/qiniu'
+
+export default {
+  name: 'singleImageUpload3',
+  props: {
+    value: String
+  },
+  computed: {
+    imageUrl() {
+      return this.value
+    }
+  },
+  data() {
+    return {
+      tempUrl: '',
+      dataObj: { token: '', key: '' }
+    }
+  },
+  methods: {
+    rmImage() {
+      this.emitInput('')
+    },
+    emitInput(val) {
+      this.$emit('input', val)
+    },
+    handleImageScucess(file) {
+      this.emitInput(file.files.file)
+    },
+    beforeUpload() {
+      const _self = this
+      return new Promise((resolve, reject) => {
+        getToken().then(response => {
+          const key = response.data.qiniu_key
+          const token = response.data.qiniu_token
+          _self._data.dataObj.token = token
+          _self._data.dataObj.key = key
+          this.tempUrl = response.data.qiniu_url
+          resolve(true)
+        }).catch(err => {
+          console.log(err)
+          reject(false)
+        })
+      })
+    }
+  }
+}
+</script>
+
+<style rel="stylesheet/scss" lang="scss" scoped>
+@import "src/styles/mixin.scss";
+.upload-container {
+  width: 100%;
+  position: relative;
+  @include clearfix;
+  .image-uploader {
+    width: 35%;
+    float: left;
+  }
+  .image-preview {
+    width: 200px;
+    height: 200px;
+    position: relative;
+    border: 1px dashed #d9d9d9;
+    float: left;
+    margin-left: 50px;
+    .image-preview-wrapper {
+      position: relative;
+      width: 100%;
+      height: 100%;
+      img {
+        width: 100%;
+        height: 100%;
+      }
+    }
+    .image-preview-action {
+      position: absolute;
+      width: 100%;
+      height: 100%;
+      left: 0;
+      top: 0;
+      cursor: default;
+      text-align: center;
+      color: #fff;
+      opacity: 0;
+      font-size: 20px;
+      background-color: rgba(0, 0, 0, .5);
+      transition: opacity .3s;
+      cursor: pointer;
+      text-align: center;
+      line-height: 200px;
+      .el-icon-delete {
+        font-size: 36px;
+      }
+    }
+    &:hover {
+      .image-preview-action {
+        opacity: 1;
+      }
+    }
+  }
+  .image-app-preview {
+    width: 320px;
+    height: 180px;
+    position: relative;
+    border: 1px dashed #d9d9d9;
+    float: left;
+    margin-left: 50px;
+    .app-fake-conver {
+      height: 44px;
+      position: absolute;
+      width: 100%; // background: rgba(0, 0, 0, .1);
+      text-align: center;
+      line-height: 64px;
+      color: #fff;
+    }
+  }
+}
+</style>

src/components/selectShopLocation/selectDept.vue

@@ -0,0 +1,184 @@
+<template>
+	<div>
+		<el-row v-loading="elRowLoading">
+			<el-col :span="6" style=" overflow-x:auto; height:400px;">
+				<span style="font-weight:bold;">请选择机构与部门</span>
+				<dept-tree show-root default-expand-all :expand-on-click-node="false" @node-click="handleLeftDeptNodeClick"
+				 @branch-row-click="branchRowClick"></dept-tree>
+			</el-col>
+			<el-col :span="15">
+				<el-col :span="5" style="margin-left:70px;"><el-input v-model="filters.key"  placeholder="模糊查询"></el-input></el-col>
+				<el-col :span="8"><el-button type="danger" @click="selectshopLocationBySysDeptIdMethodLike">模糊搜索</el-button>
+				<el-button type="primary" @click="checkSureMethod" v-if="isSupportCheck">确定</el-button>
+				</el-col>
+				<el-table    ref="multipleTable" :data="shopLocationTable" style="width: 100%;margin-left:70px;"   @selection-change="handleSelectionChange">
+					<el-table-column type="selection" width="55" v-if="isSupportCheck">
+					</el-table-column>
+					<!-- <el-table-column prop="shopId" label="商户编号" width="180" align="center">
+					</el-table-column> -->
+					<el-table-column prop="deptid" label="部门编号" width="180" align="center">
+					</el-table-column>
+					<el-table-column prop="deptName" label="部门名称" align="center">
+					</el-table-column>
+					<el-table-column label="操作" align="center" v-if="!isSupportCheck">
+						<template slot-scope="scope">
+							<el-button type="primary" @click="sureMethod(scope.row,scope.$index)">确定</el-button>
+						</template>
+					</el-table-column>
+				</el-table>
+				<el-pagination style="float:right" layout="total, sizes, prev, pager, next,jumper" @current-change="handleCurrentChange" @size-change="handleSizeChange"
+					 :page-sizes="[10,20, 50, 100, 500]" :current-page.sync="pageInfo.pageNum" :page-size="pageInfo.pageSize" :total="pageInfo.total"></el-pagination>
+
+			</el-col>
+		</el-row>
+	</div>
+</template>
+
+<script>
+	import util from '@/common/js/util'; //全局公共库
+	import Sticky from '@/components/Sticky' // 粘性header组件
+	import DeptTree from './DeptTree.vue';
+	import {
+		listDept
+	} from './shopLocation';
+	import {
+		mapGetters
+	} from 'vuex'
+	export default {
+		computed: {
+			...mapGetters([
+				'workSpace'
+			])
+		},
+		props: ['isSupportCheck'],
+		watch: {},
+		data() {
+			return {
+        filters: {
+        	key: ''
+        },
+				multipleSelection: [],
+				filterBusinessName:'',//搜索名字过滤
+				currentSelectDeptObject:{},//当前选择的部门对象
+				elRowLoading: false,
+				shopLocationTable: [],
+				pageInfo: { //分页数据
+					total: 0, //服务器端收到0时，会自动计算总记录数，如果上传>0的不自动计算。  计算出有多少条记录
+					pageSize: 10, //每页数据		每页现实的数据的大小
+					count: false, //是否需要重新计算总记录数
+					pageNum: 1, //当前页码、从1开始计算
+					orderFields: [], //排序列 如 ['sex','student_id']，必须为数据库字段
+					orderDirs: [] //升序 asc,降序desc 如 性别 升序、学生编号降序 ['asc','desc']
+				}
+			}
+		}, //end data
+		methods: {
+			selectshopLocationBySysDeptIdMethodLike(){
+				if(this.currentSelectDeptObject.branchId==null||this.currentSelectDeptObject.branchId==''){
+					this.$message({
+						 message: "请选择机构和部门",
+						 type: "error"
+					});
+					return
+				}
+				this.selectshopLocationBySysDeptIdMethod();
+			},
+			handleCurrentChange(pageNum) { //分页组件的修改当前页数
+				this.pageInfo.pageNum = pageNum;
+				this.selectshopLocationBySysDeptIdMethod();
+			},
+			handleSizeChange(pageSize) { //分页组建的修改每页显示的大小
+				this.pageInfo.pageSize = pageSize;
+				this.selectshopLocationBySysDeptIdMethod();
+			},
+			//点击创建商户对话框左边的树触发的事件
+			handleLeftDeptNodeClick(data, node, comp) {
+				if (!data.isBranch) { //选择的不是机构节点
+					let branchId = data.branchId;
+					let deptid = data.deptid;
+					this.pageInfo.count=true;
+					this.currentSelectDeptObject=data;
+					this.selectshopLocationBySysDeptIdMethod();
+				}
+			},
+			//点击切换机构按钮的时候触发的事件
+			branchRowClick: function(row, event, column) {
+
+			},
+
+			selectshopLocationBySysDeptIdMethod() {
+				let that = this;
+				let params = {
+					"branchId": this.currentSelectDeptObject.branchId,
+					"pdeptid": this.currentSelectDeptObject.deptid,
+					"pageSize":this.pageInfo.pageSize,
+					"pageNum":this.pageInfo.pageNum,
+					"count":this.pageInfo.count
+				};
+				if(this.filters.key!==""){
+					params.key='%'+this.filters.key+'%';
+				}
+
+        if(this.branch!=null){
+        	params.branchId=this.branch.id
+        }
+				if (this.pageInfo.orderFields != null && this.pageInfo.orderFields.length > 0) { //获取排序的字段的内容 以及排序的方式 按时间倒叙排序
+					let orderBys = [];
+					for (var i = 0; i < this.pageInfo.orderFields.length; i++) {
+						orderBys.push(this.pageInfo.orderFields[i] + " " + this.pageInfo.orderDirs[i])
+					}
+					params.orderBy = orderBys.join(",") //多个排序字段直接进行拼接的处理
+				};
+				this.elRowLoading = true;
+				listDept(params).then(res => {
+					this.elRowLoading = false;
+					let tips = res.data.tips;
+					if (tips.isOk) {
+						this.pageInfo.total=res.data.total;
+						this.pageInfo.count=false;
+						that.shopLocationTable = res.data.data;
+					}
+					// this.$message({
+					// 	message: tips.msg,
+					// 	type: tips.isOk ? 'success' : 'error'
+					// });
+				}).catch(() => {
+					this.elRowLoading = false
+				});
+			},
+
+			 handleSelectionChange(val) {
+				this.multipleSelection = val;
+			 },
+			sureMethod(row,index){
+				this.$emit('sure',row);
+			},
+			checkSureMethod(){
+				if(this.multipleSelection.length<1){
+					this.$message({
+						 message: "必须选择某个门店",
+						 type: "error"
+					});
+					return;
+				}
+				this.$emit('checkSureMethod',this.multipleSelection);
+			},
+			clearSelectionMethod(){
+				this.$refs.multipleTable.clearSelection();
+			}
+
+		}, //end methods
+		components: {
+			'dept-tree': DeptTree,
+			'sticky': Sticky
+			//在下面添加其它组件
+		},
+		mounted() {
+
+		}
+	}
+</script>
+
+<style scoped>
+
+</style>

src/icons/svg/edit.svg

@@ -0,0 +1 @@
+<svg width="128" height="128" xmlns="http://www.w3.org/2000/svg"><path d="M106.133 67.2a4.797 4.797 0 0 0-4.8 4.8c0 .187.014.36.027.533h-.027V118.4H9.6V26.667h50.133c2.654 0 4.8-2.147 4.8-4.8 0-2.654-2.146-4.8-4.8-4.8H9.6a9.594 9.594 0 0 0-9.6 9.6V118.4c0 5.307 4.293 9.6 9.6 9.6h91.733c5.307 0 9.6-4.293 9.6-9.6V72.533h-.026c.013-.173.026-.346.026-.533 0-2.653-2.146-4.8-4.8-4.8z"/><path d="M125.16 13.373L114.587 2.8c-3.747-3.747-9.854-3.72-13.6.027l-52.96 52.96a4.264 4.264 0 0 0-.907 1.36L33.813 88.533c-.746 1.76-.226 3.534.907 4.68 1.133 1.147 2.92 1.667 4.693.92l31.4-13.293c.507-.213.96-.52 1.36-.907l52.96-52.96c3.747-3.746 3.774-9.853.027-13.6zM66.107 72.4l-18.32 7.76 7.76-18.32L92.72 24.667l10.56 10.56L66.107 72.4zm52.226-52.227l-8.266 8.267-10.56-10.56 8.266-8.267.027-.026 10.56 10.56-.027.026z"/></svg>

src/icons/svg/eye-open.svg

@@ -0,0 +1 @@
+<svg class="icon" viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg" width="128" height="128"><defs><style/></defs><path d="M512 128q69.675 0 135.51 21.163t115.498 54.997 93.483 74.837 73.685 82.006 51.67 74.837 32.17 54.827L1024 512q-2.347 4.992-6.315 13.483T998.87 560.17t-31.658 51.669-44.331 59.99-56.832 64.34-69.504 60.16-82.347 51.5-94.848 34.687T512 896q-69.675 0-135.51-21.163t-115.498-54.826-93.483-74.326-73.685-81.493-51.67-74.496-32.17-54.997L0 513.707q2.347-4.992 6.315-13.483t18.816-34.816 31.658-51.84 44.331-60.33 56.832-64.683 69.504-60.331 82.347-51.84 94.848-34.816T512 128.085zm0 85.333q-46.677 0-91.648 12.331t-81.152 31.83-70.656 47.146-59.648 54.485-48.853 57.686-37.675 52.821-26.325 43.99q12.33 21.674 26.325 43.52t37.675 52.351 48.853 57.003 59.648 53.845T339.2 767.02t81.152 31.488T512 810.667t91.648-12.331 81.152-31.659 70.656-46.848 59.648-54.186 48.853-57.344 37.675-52.651T927.957 512q-12.33-21.675-26.325-43.648t-37.675-52.65-48.853-57.345-59.648-54.186-70.656-46.848-81.152-31.659T512 213.334zm0 128q70.656 0 120.661 50.006T682.667 512 632.66 632.661 512 682.667 391.339 632.66 341.333 512t50.006-120.661T512 341.333zm0 85.334q-35.328 0-60.33 25.002T426.666 512t25.002 60.33T512 597.334t60.33-25.002T597.334 512t-25.002-60.33T512 426.666z"/></svg>

src/icons/svg/list.svg

@@ -0,0 +1 @@
+<svg width="128" height="128" xmlns="http://www.w3.org/2000/svg"><path d="M1.585 12.087c0 6.616 3.974 11.98 8.877 11.98 4.902 0 8.877-5.364 8.877-11.98 0-6.616-3.975-11.98-8.877-11.98-4.903 0-8.877 5.364-8.877 11.98zM125.86.107H35.613c-1.268 0-2.114 1.426-2.114 2.852v18.255c0 1.712 1.057 2.853 2.114 2.853h90.247c1.268 0 2.114-1.426 2.114-2.853V2.96c0-1.711-1.057-2.852-2.114-2.852zM.106 62.86c0 6.615 3.974 11.979 8.876 11.979 4.903 0 8.877-5.364 8.877-11.98 0-6.616-3.974-11.98-8.877-11.98-4.902 0-8.876 5.364-8.876 11.98zM124.17 50.88H33.921c-1.268 0-2.114 1.425-2.114 2.851v18.256c0 1.711 1.057 2.852 2.114 2.852h90.247c1.268 0 2.114-1.426 2.114-2.852V53.73c0-1.426-.846-2.852-2.114-2.852zM.106 115.913c0 6.616 3.974 11.98 8.876 11.98 4.903 0 8.877-5.364 8.877-11.98 0-6.616-3.974-11.98-8.877-11.98-4.902 0-8.876 5.364-8.876 11.98zm124.064-11.98H33.921c-1.268 0-2.114 1.426-2.114 2.853v18.255c0 1.711 1.057 2.852 2.114 2.852h90.247c1.268 0 2.114-1.426 2.114-2.852v-18.255c0-1.427-.846-2.853-2.114-2.853z"/></svg>

src/icons/svg/nested.svg

@@ -0,0 +1 @@
+<svg width="128" height="128" xmlns="http://www.w3.org/2000/svg"><path d="M.002 9.2c0 5.044 3.58 9.133 7.998 9.133 4.417 0 7.997-4.089 7.997-9.133 0-5.043-3.58-9.132-7.997-9.132S.002 4.157.002 9.2zM31.997.066h95.981V18.33H31.997V.066zm0 45.669c0 5.044 3.58 9.132 7.998 9.132 4.417 0 7.997-4.088 7.997-9.132 0-3.263-1.524-6.278-3.998-7.91-2.475-1.63-5.524-1.63-7.998 0-2.475 1.632-4 4.647-4 7.91zM63.992 36.6h63.986v18.265H63.992V36.6zm-31.995 82.2c0 5.043 3.58 9.132 7.998 9.132 4.417 0 7.997-4.089 7.997-9.132 0-5.044-3.58-9.133-7.997-9.133s-7.998 4.089-7.998 9.133zm31.995-9.131h63.986v18.265H63.992V109.67zm0-27.404c0 5.044 3.58 9.133 7.998 9.133 4.417 0 7.997-4.089 7.997-9.133 0-3.263-1.524-6.277-3.998-7.909-2.475-1.631-5.524-1.631-7.998 0-2.475 1.632-4 4.646-4 7.91zm31.995-9.13h31.991V91.4H95.987V73.135z"/></svg>

src/icons/svg/return.svg

@@ -0,0 +1 @@
+<?xml version="1.0" standalone="no"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"><svg t="1572851412917" class="icon" viewBox="0 0 1201 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="816" xmlns:xlink="http://www.w3.org/1999/xlink" width="351.85546875" height="300"><defs><style type="text/css"></style></defs><path d="M1130.726 590.552c0 47.88-8.23 94.264-23.192 136.908-54.613-159.352-199.75-273.067-371.82-273.067v68.08c0 26.184-14.214 49.376-36.657 61.346-8.978 4.489-19.452 7.481-29.177 7.481-14.215 0-27.681-4.488-39.651-13.466L366.888 372.847c-16.46-12.718-26.185-32.918-26.185-54.613s9.726-41.895 26.185-54.614l263.34-205.735c11.223-8.977 25.437-13.466 39.652-13.466 9.725 0 20.199 2.244 29.177 7.481 22.443 11.222 36.658 35.162 36.658 61.347v68.08c217.705-0.749 395.011 183.29 395.011 409.225z" p-id="817"></path><path d="M982.198 580.875c-26.184 0-47.88 21.695-47.88 47.88v57.606c0 100.997-3.74 181.795-191.52 181.795H359.755c-193.765 0-191.52-86.035-191.52-191.521V437.234c-13.467-150.374 57.605-183.291 143.64-190.025h2.992c26.185 0 47.88-21.695 47.88-47.88 0-26.184-21.695-48.628-47.88-48.628h-2.992v-0.748h-47.88c-105.486 0-191.521 86.035-191.521 191.52v430.922c0 105.486 86.035 191.521 191.52 191.521H837.81c105.486 0 191.52-86.035 191.52-191.52V628.754c0.749-26.185-20.947-47.88-47.132-47.88z" p-id="818"></path></svg>

src/icons/svg/shopping.svg

@@ -0,0 +1 @@
+<svg width="128" height="128" xmlns="http://www.w3.org/2000/svg"><path d="M42.913 101.36c1.642 0 3.198.332 4.667.996a12.28 12.28 0 0 1 3.89 2.772c1.123 1.184 1.987 2.582 2.592 4.193.605 1.612.908 3.318.908 5.118 0 1.8-.303 3.507-.908 5.118-.605 1.611-1.469 3.01-2.593 4.194a13.3 13.3 0 0 1-3.889 2.843 10.582 10.582 0 0 1-4.667 1.066c-1.729 0-3.306-.355-4.732-1.066a13.604 13.604 0 0 1-3.825-2.843c-1.123-1.185-1.988-2.583-2.593-4.194a14.437 14.437 0 0 1-.907-5.118c0-1.8.302-3.506.907-5.118.605-1.61 1.47-3.009 2.593-4.193a12.515 12.515 0 0 1 3.825-2.772c1.426-.664 3.003-.996 4.732-.996zm53.932.285c1.643 0 3.22.331 4.733.995a11.386 11.386 0 0 1 3.889 2.772c1.08 1.185 1.945 2.583 2.593 4.194.648 1.61.972 3.317.972 5.118 0 1.8-.324 3.506-.972 5.117-.648 1.611-1.513 3.01-2.593 4.194a12.253 12.253 0 0 1-3.89 2.843 11 11 0 0 1-4.732 1.066 10.58 10.58 0 0 1-4.667-1.066 12.478 12.478 0 0 1-3.824-2.843c-1.08-1.185-1.945-2.583-2.593-4.194a13.581 13.581 0 0 1-.973-5.117c0-1.801.325-3.507.973-5.118.648-1.611 1.512-3.01 2.593-4.194a11.559 11.559 0 0 1 3.824-2.772 11.212 11.212 0 0 1 4.667-.995zm21.781-80.747c2.42 0 4.3.355 5.64 1.066 1.34.71 2.29 1.587 2.852 2.63a6.427 6.427 0 0 1 .778 3.34c-.044 1.185-.195 2.204-.454 3.057-.26.853-.8 2.606-1.62 5.26a589.268 589.268 0 0 1-2.788 8.743 1236.373 1236.373 0 0 0-3.047 9.453c-.994 3.128-1.75 5.592-2.269 7.393-1.123 3.79-2.55 6.42-4.278 7.89-1.728 1.469-3.846 2.203-6.352 2.203H39.023l1.945 12.795h65.342c4.148 0 6.223 1.943 6.223 5.828 0 1.896-.41 3.53-1.232 4.905-.821 1.374-2.442 2.061-4.862 2.061H38.505c-1.729 0-3.176-.426-4.343-1.28-1.167-.852-2.14-1.966-2.917-3.34a21.277 21.277 0 0 1-1.88-4.478 44.128 44.128 0 0 1-1.102-4.55c-.087-.568-.324-1.942-.713-4.122-.39-2.18-.865-4.904-1.426-8.174l-1.88-10.947c-.692-4.027-1.383-8.079-2.075-12.154-1.642-9.572-3.5-20.234-5.574-31.986H6.87c-1.296 0-2.377-.356-3.24-1.067a9.024 9.024 0 0 1-2.14-2.558 10.416 10.416 0 0 1-1.167-3.2C.108 8.53 0 7.488 0 6.54c0-1.896.583-3.46 1.75-4.69C2.917.615 4.494 0 6.482 0h13.095c1.728 0 3.111.284 4.148.853 1.037.569 1.858 1.28 2.463 2.132a8.548 8.548 0 0 1 1.297 2.701c.26.948.475 1.754.648 2.417.173.758.346 1.825.519 3.199.173 1.374.345 2.772.518 4.193.26 1.706.519 3.507.778 5.403h88.678z"/></svg>

src/icons/svg/tree-table.svg

@@ -0,0 +1 @@
+<svg width="128" height="128" xmlns="http://www.w3.org/2000/svg"><path d="M44.8 0h79.543C126.78 0 128 1.422 128 4.267v23.466c0 2.845-1.219 4.267-3.657 4.267H44.8c-2.438 0-3.657-1.422-3.657-4.267V4.267C41.143 1.422 42.362 0 44.8 0zm22.857 48h56.686c2.438 0 3.657 1.422 3.657 4.267v23.466c0 2.845-1.219 4.267-3.657 4.267H67.657C65.22 80 64 78.578 64 75.733V52.267C64 49.422 65.219 48 67.657 48zm0 48h56.686c2.438 0 3.657 1.422 3.657 4.267v23.466c0 2.845-1.219 4.267-3.657 4.267H67.657C65.22 128 64 126.578 64 123.733v-23.466C64 97.422 65.219 96 67.657 96zM50.286 68.267c2.02 0 3.657-1.91 3.657-4.267 0-2.356-1.638-4.267-3.657-4.267H17.37V32h6.4c2.02 0 3.658-1.91 3.658-4.267V4.267C27.429 1.91 25.79 0 23.77 0H3.657C1.637 0 0 1.91 0 4.267v23.466C0 30.09 1.637 32 3.657 32h6.4v80c0 2.356 1.638 4.267 3.657 4.267h36.572c2.02 0 3.657-1.91 3.657-4.267 0-2.356-1.638-4.267-3.657-4.267H17.37V68.267h32.915z"/></svg>

src/icons/svg/tree.svg

@@ -0,0 +1 @@
+<svg width="128" height="128" xmlns="http://www.w3.org/2000/svg"><path d="M126.713 90.023c.858.985 1.287 2.134 1.287 3.447v29.553c0 1.423-.429 2.6-1.287 3.53-.858.93-1.907 1.395-3.146 1.395H97.824c-1.145 0-2.146-.465-3.004-1.395-.858-.93-1.287-2.107-1.287-3.53V93.47c0-.875.19-1.696.572-2.462.382-.766.906-1.368 1.573-1.806a3.84 3.84 0 0 1 2.146-.657h9.725V69.007a3.84 3.84 0 0 0-.43-1.806 3.569 3.569 0 0 0-1.143-1.313 2.714 2.714 0 0 0-1.573-.492h-36.47v23.149h9.725c1.144 0 2.145.492 3.004 1.478.858.985 1.287 2.134 1.287 3.447v29.553c0 .876-.191 1.696-.573 2.463-.38.766-.905 1.368-1.573 1.806a3.84 3.84 0 0 1-2.145.656H51.915a3.84 3.84 0 0 1-2.145-.656c-.668-.438-1.216-1.04-1.645-1.806a4.96 4.96 0 0 1-.644-2.463V93.47c0-1.313.43-2.462 1.288-3.447.858-.986 1.907-1.478 3.146-1.478h9.582v-23.15h-37.9c-.953 0-1.74.356-2.359 1.068-.62.711-.93 1.56-.93 2.544v19.538h9.726c1.239 0 2.264.492 3.074 1.478.81.985 1.216 2.134 1.216 3.447v29.553c0 1.423-.405 2.6-1.216 3.53-.81.93-1.835 1.395-3.074 1.395H4.29c-.476 0-.93-.082-1.358-.246a4.1 4.1 0 0 1-1.144-.657 4.658 4.658 0 0 1-.93-1.067 5.186 5.186 0 0 1-.643-1.395 5.566 5.566 0 0 1-.215-1.56V93.47c0-.437.048-.875.143-1.313a3.95 3.95 0 0 1 .429-1.15c.19-.328.429-.656.715-.984.286-.329.572-.602.858-.821.286-.22.62-.383 1.001-.493.382-.11.763-.164 1.144-.164h9.726V61.619c0-.985.31-1.833.93-2.544.619-.712 1.358-1.068 2.216-1.068h44.335V39.62h-9.582c-1.24 0-2.288-.492-3.146-1.477a5.09 5.09 0 0 1-1.287-3.448V5.14c0-1.423.429-2.627 1.287-3.612.858-.985 1.907-1.477 3.146-1.477h25.743c.763 0 1.478.246 2.145.739a5.17 5.17 0 0 1 1.573 1.888c.382.766.573 1.587.573 2.462v29.553c0 1.313-.43 2.463-1.287 3.448-.859.985-1.86 1.477-3.004 1.477h-9.725v18.389h42.762c.954 0 1.74.355 2.36 1.067.62.711.93 1.56.93 2.545v26.925h9.582c1.239 0 2.288.492 3.146 1.478z"/></svg>

src/lang/zh_arc.js

@@ -0,0 +1,29 @@
+export default {
+  route: { 
+	dashboard: '首页',
+	arc:'内容中心',
+	ArcIndex:'文章管理',
+	ArchiveAdd:'创建文章',
+	ArchiveDetail:'浏览文章',
+	ArchiveCommentMng:'评论管理',
+	ArchiveMngQuery:'文档查阅',
+	ArchiveListFlow:'流程归档查阅',
+	ArchiveAttachmentMng:'附件管理',
+	ArcCategoryMng:'文章分类管理',
+	CategoryTreeTable:'文章分类定义',
+	ChannelMng: '频道定义',
+	ImageCategoryMng:'图片分类定义',
+	ImageMng:'图片管理',
+	MaterialMng:'素材管理',
+	ImageMng1:'图片管理1',
+	arcSend:'内容分发',
+	SendPlanMng:'分发计划管理',
+	
+	aq:'咨询中心',
+	AqQuestionMng:'问题管理',
+	AqCategoryMng:'问题分类',
+	AqFaqMng:'常见问题管理',
+	AqQuestionAdd:'发起咨询'
+		
+  }
+}

src/lang/zh_mallm.js

@@ -0,0 +1,102 @@
+export default {
+  route: {
+  dashboard: '首页',
+	orders: '订单',
+	stock:'库存',
+	OrdersMng: '订单列表',
+	OutBillMng: '出库',
+	OrdersDeliver: '发货',
+	OrdersReceiptConfirm:'确认收货',
+	OrdersMngUnpaid:'未付款',
+	OrdersMngDelivered:'待发货',
+	OrdersMngShipped:'已发货',
+	OrdersMngEvaluated:'待评价',
+	OrdersMngService:'退款/售后',
+	OrdersMngCancel:'订单取消',
+	OrdersMngCompleted:'订单完成',
+	GoodsMng: '商品管理',
+	CategoryTypeComplexSet:'商品属性标签管理',
+	GoodsRecycleBin: '商品回收站',
+	GoodsProductMng: '商品库存',
+	GoodsPriceMng: '价格套应用',
+	goods: '商品',
+	ShopMng: '商户管理',
+	GoodsSoldUp:'网店商品上下架',
+	GoodsApprove:'商品审核',
+	ShopLocationMng: '店铺管理',
+	LocationGoodsSoldUp: '店铺商品上下架',
+	ShopLocationAdd: '添加店铺',
+	ShopLocationPutaway: '店铺商品上下架',
+	ShopLocationDetail: '店铺详情',
+	ShopLocationEdit: '店铺编辑',
+	LocationSortMng:'店铺分类',
+	NetProductStockMng:'网店库存调整',
+	LocationProductStockMng:'店铺库存调整',
+	LocationGoodsPriceMng:'店铺价格套应用',
+
+	pub: '基础数据',
+	CategoryMng: '分类定义',
+	AttributeMng: '商品参数管理',
+	SpecificationMng: '规格定义',
+	BrandMng: '品牌商定义',
+	ChannelMng: '频道管理',
+	AdMng: '广告投放',
+	SupplierMng: '供应商管理',
+	WarehouseMng: '仓库管理',
+	specification:'规格管理',
+	SpecificationCategoryMng:'规格定义',
+	GoodsPriceSet:'价格套定义',
+	evaluationMng:'评价管理',
+	WaitEvaluationOrder:'待评价订单',
+	EvaluationListMng:'已评价订单',
+	EvaluationSet:'评价参数配置',
+	EvaluationAward:'评价奖励',
+	OrderCenter:'订单管理',
+	OrderCenterList:'订单中心',
+	CreateOrder:'新建订单',
+	OrdersProcessApprovaMng:'赠书订单审核',
+	OrdersProcessNodeSet:'赠书订单审核设置',
+	SpeCategoryMng:'商品分类设置',
+  PressMng:'出版社/厂商管理',
+  TopicMng:"专题管理",
+  HelpMng:"帮助管理",
+  FAQMng:"常见问题",
+  UserAgreementMng:"用户协议",
+  InnerMsgMng:'站内信管理',
+  PartnerMng:'合作机构管理',
+  FriendlyLinkMng:'友情链接管理',
+  ContactSerMng:'联系客服',
+  ContactUsMng:'联系我们',
+  AboutUsMng:'关于我们',
+  ServiceAgreementMng:'服务协议',
+  UserReceiptOrderMng:'用户发票管理',
+
+
+	shopDecoration:'店铺装修',
+	preView:'预览',
+	customModuleMng:'自定义页面',
+	shopDecorationMng:'店铺装修',
+	timeOutSetting:'超时设置',
+	typeSetting:'类型设置',
+	expressEntrySet:'快捷入口设置',
+	expressTemplateMng:'物流模板管理',
+	customService:'客服',
+	greetingMng:'预约管理',
+	GreetingMng:'预约管理',
+
+	tradeareaMng:'商圈',
+	tradearea:'商圈管理',
+
+	cpdIndicators:'指标统计',
+	cpdShop:'商户指标',
+	cpdLoction:'店铺指标',
+	cpdGoods:'商品指标',
+
+	KeywordsMng:'关键词管理',
+	TagMng:'标签管理',
+	AdPositionMng:'广告位置管理',
+	CacheMng:'缓存清理',
+  GoodsCommentMng:'商品评价',
+
+  }
+}

src/lang/zh_mk.js

@@ -0,0 +1,59 @@
+export default {
+  route: {  
+	  	dashboard: '首页',
+		BaseInfoMng:'卡券营销',
+		gbuy:'商品团购',
+		mk:'营销管理',
+		dist:'分销管理',
+		mkDetail:'营销明细',
+		mkFenxi:'营销分析',
+		GbuyActivityMng:'拼单管理',
+		GbuyGroupMng:'开团记录明细',
+		GbuyGroupUserMng:'参团用户资料',
+		MkLevelDefineMng:'业务员级别定义',
+		AreaLevelDefineMng:'区域代理级别定义',
+		AgentDefineMng:'代理商管理',
+		agent:'代理管理',
+		AgentGoodsRuleMng:'商品代理价格设置',
+		FeeRuleMng:'业务员提成设置',
+		GoodsRuleMng:'营销商品设置',
+		DistUserMng:'分销商设置',
+		DistGoodsRuleMng:'分销商品设置',
+		DistLevelDefineMng:'分销商级别定义',
+		OrderFeeMng:'订单明细',
+		StaffFeeMng:'业务员销售明细',
+		OrderProductFeeMng:'产品销售明细',
+		OrderCardMng:'卡券消费明细',
+		dayOrderFeeMng:'订单日报',
+		dayStaffFeeMng:'业务员业绩日报',
+		dayOrderProductFeeMng:'商品销售日报',
+		dayLocaOrderFeeMng:'店铺销售日报',
+		dayUserOrderMng:'客户消费日报',
+		dayUserActiveMng:'活跃用户日报',
+		AddMemberCard:'创建会员卡',
+		AddCard:'创建优惠券',
+		AddCardDiscount:'创建折扣券',
+		AddCardCash:'创建代金券',
+		AddCardGift:'创建兑换券',
+		AddCardGroupon:'创建团购券',
+		AddCardGeneral_Coupon:'创建优惠券',
+		MemberCard:'会员卡管理',
+		Card:'卡卷管理',
+		CardMng:'优惠券管理',
+		VerficationCodeMng:'核销码管理',
+		DistUserTreeMng:'分销商管理',
+		DistUserDetail:'分销详情',
+		DistUserWithdrawCashMng:'分销商佣金提现申请表',
+		DistRuleRewardMng:'分销商提成计算佣金策略表',
+		DistRuleQualMng:'资格规则配置',
+		DistRuleWithdrawCashMng:'提现规则',
+		SeckillActivityMng:'秒杀管理',
+		SeckillActivityGoodsMng:'商品秒杀商品管理',
+		join:'拼单管理',
+		seckill:'秒杀管理',
+		GbuyActivityGoodsMng:'商品团购',
+		GbuyGroupStateMng:'开团状态',
+		distUserTrees:'分销商管理',
+		distWithdrawalMng:'分销提现',
+  }
+}

src/lang/zh_sys.js

@@ -0,0 +1,55 @@
+export default {
+  route: {
+    dashboard: '首页', 
+    UserMng:'用户管理',
+    DeptUserMng:'部门用户管理',
+    NoDeptUserMng:'用户管理(未分配部门)',
+    DeptPostUserMng: '用户岗位快捷查询',
+    DeptPostUserRole: '用户角色快捷查询',
+    DeptPostUserMenu: '用户菜单快捷查询',
+    RoleQxMng:'角色权限',
+    RoleMng:'角色管理',
+    PostMng: '岗位管理',
+    QxMng:'权限定义',
+    OrgMng:'组织管理',
+    BranchMng:'公司管理',
+    DeptMng:'部门管理',
+    BaseData:'基础数据',
+    CodeMng:'分类管理',
+    DataMng:'数据管理',
+    CompanyMng:'往来单位管理',
+    CategoryMng:'分类管理',
+    BranchAdd:'创建机构',
+    
+    MetaData:'元数据管理',
+    MetaCategoryMng:'元数据分类',
+    ItemMng:'字典管理',
+    dicts:'字典列表',
+    ItemList:'列表维护',
+    ItemOptionMng:'数据列表管理', 
+    branchParamMng:'机构个性化参数', 
+    SysParamMng:'参数定义',
+    SysParamSet:'参数设置',
+
+    plat:'平台管理',
+    PlatformMng:'平台配置', 
+    BankAccountMng:'收款账户',
+    
+    ResMng:'资源管理',
+    ResDefMng:'资源定义',
+    ResOperMng:'资源操作管理',
+    ResOperRoleMng:'资源角色管理',
+    ResBizCategoryMng:'资源业务分类',
+    ResIgnoreMng:'全局不受限资源',
+    	
+    MenuDefMng:'菜单管理',
+    MenuModuleMng:'菜单分类',
+    
+    AppMdpMng: '应用商店',
+    AppMdpDefMng : '应用管理',
+    AppTpAuthMng : '应用授权',
+    AppBizTypeMng : '应用分类',
+		OpenAccount:'开户',
+	UserPostApplyRecord:'用户岗位申请记录'
+  }
+}

src/mock/mdp/pub/branch.js

@@ -0,0 +1,13 @@
+ import Mock from 'mockjs';
+
+const Branchs = [];
+
+for (let i = 0; i < 25; i++) {
+  Branchs.push(Mock.mock({
+		branchId:Mock.Random.string(5),
+		branchName:Mock.Random.ctitle(1,0) , 
+		enabled:Mock.Random.character('lower')
+  }));
+}
+
+export { Branchs };

src/mock/mdp/pub/branchMock.js

@@ -0,0 +1,152 @@
+import { Branchs } from './branch';
+let _Branchs = Branchs;
+/**
+ * 拷贝下面两行到 mock/index.js中,即可支持客户端虚拟数据、免服务端连接
+ * import BranchMock from './mdp/pub/branchMock';
+ * BranchMock.bootstrap(mock);
+ */
+export default {
+  /**
+   * mock bootstrap
+   */
+  bootstrap(mock) {    
+  
+    //获取列表 模糊查询、根据关键字查询
+    mock.onGet('/mdp/pub/branch/listKey').reply(config => {
+      let params = config.params;
+      let mockBranchs = _Branchs.filter(branch => {
+      	if(params.branchId||params.branchId==''){ if( branch.branchId.indexOf(params.branchId)>=0) return true;}
+      	if(params.branchName||params.branchName==''){ if( branch.branchName.indexOf(params.branchName)>=0) return true;}
+      	if(params.enabled||params.enabled==''){ if( branch.enabled.indexOf(params.enabled)>=0) return true;}
+        return false;
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            data: mockBranchs
+          }]);
+        }, 1000);
+      });
+    });
+    
+    
+
+    //获取列表（分页/不分页）
+    mock.onGet('/mdp/pub/branch/list').reply(config => {
+      let params = config.params;
+      let mockBranchs = _Branchs.filter(branch => {
+      	var isTrue=false;
+      	if(params.branchId||params.branchId==''){if(branch.branchId.indexOf(params.branchId)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.branchName||params.branchName==''){if(branch.branchName.indexOf(params.branchName)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.enabled||params.enabled==''){if(branch.enabled.indexOf(params.enabled)>=0){isTrue=true;}else{isTrue=false;}}
+      	return isTrue;
+	  });
+      if(!config.params.currentPage){ 
+	      return new Promise((resolve, reject) => {
+	        setTimeout(() => {
+	          resolve([200, {
+	            data: mockBranchs
+	          }]);
+	        }, 1000);
+	      });
+      }
+    
+      let {pageSize,currentPage, total} = config.params;
+      total = mockBranchs.length;
+      mockBranchs = mockBranchs.filter((branch, index) => index < pageSize * currentPage && index >= pageSize * (currentPage - 1));
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            pageInfo: {
+            	total:total
+            },
+            data: mockBranchs,
+            tips:{
+            	isOk:true,
+            	msg:'查询成功'
+            }
+          }]);
+        }, 1000);
+      });
+    });
+
+    //删除
+    mock.onPost('/mdp/pub/branch/del').reply(config => {
+      var params = JSON.parse( config.data );
+      let {  branchId  } = params;
+      _Branchs = _Branchs.filter(branch => branch.branchId !== branchId);
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'删除成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //批量删除
+    mock.onPost('/mdp/pub/branch/batchDel').reply(config => {
+      var params = JSON.parse( config.data );
+      _Branchs = _Branchs.filter(branch => !params.includes(branch.branchId));
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+           tips:{
+            	isOk:true,
+            	msg:'删除成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //编辑
+    mock.onPost('/mdp/pub/branch/edit').reply(config => {
+      var params = JSON.parse( config.data );
+      let { branchId,branchName,enabled } = params;
+      _Branchs.some(branch => {
+        if (branch.branchId === branchId) {
+			branch.branchId = branchId;
+			branch.branchName = branchName;
+			branch.enabled = enabled
+          return true;
+        }
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'编辑成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //新增
+    mock.onPost('/mdp/pub/branch/add').reply(config => {
+      var params = JSON.parse( config.data );
+      let { branchId,branchName,enabled } = params;
+      _Branchs.push({
+		branchId:branchId,
+		branchName:branchName,
+		enabled:enabled
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'新增成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+  }
+};

src/mock/mdp/pub/company.js

@@ -0,0 +1,18 @@
+ import Mock from 'mockjs';
+
+const Companys = [];
+
+for (let i = 0; i < 25; i++) {
+  Companys.push(Mock.mock({
+		companyId:Mock.Random.string(5),
+		branchId:Mock.Random.string(5),
+		companyName:Mock.Random.ctitle(1,0) , 
+		districtId:Mock.Random.ctitle(1,0) , 
+		categoryId:Mock.Random.ctitle(1,0) , 
+		phoneNo:Mock.Random.ctitle(1,0) , 
+		orgId:Mock.Random.ctitle(1,0) , 
+		address:Mock.Random.ctitle(1,0)
+  }));
+}
+
+export { Companys };

src/mock/mdp/pub/companyMock.js

@@ -0,0 +1,172 @@
+import { Companys } from './company';
+let _Companys = Companys;
+/**
+ * 拷贝下面两行到 mock/index.js中,即可支持客户端虚拟数据、免服务端连接
+ * import CompanyMock from './mdp/pub/companyMock';
+ * CompanyMock.bootstrap(mock);
+ */
+export default {
+  /**
+   * mock bootstrap
+   */
+  bootstrap(mock) {    
+  
+    //获取列表 模糊查询、根据关键字查询
+    mock.onGet('/mdp/pub/company/listKey').reply(config => {
+      let params = config.params;
+      let mockCompanys = _Companys.filter(company => {
+      	if(params.companyId||params.companyId==''){ if( company.companyId.indexOf(params.companyId)>=0) return true;}
+      	if(params.companyName||params.companyName==''){ if( company.companyName.indexOf(params.companyName)>=0) return true;}
+      	if(params.districtId||params.districtId==''){ if( company.districtId.indexOf(params.districtId)>=0) return true;}
+      	if(params.categoryId||params.categoryId==''){ if( company.categoryId.indexOf(params.categoryId)>=0) return true;}
+      	if(params.phoneNo||params.phoneNo==''){ if( company.phoneNo.indexOf(params.phoneNo)>=0) return true;}
+      	if(params.orgId||params.orgId==''){ if( company.orgId.indexOf(params.orgId)>=0) return true;}
+      	if(params.address||params.address==''){ if( company.address.indexOf(params.address)>=0) return true;}
+      	if(params.branchId||params.branchId==''){ if( company.branchId.indexOf(params.branchId)>=0) return true;}
+        return false;
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            data: mockCompanys
+          }]);
+        }, 1000);
+      });
+    });
+    
+    
+
+    //获取列表（分页/不分页）
+    mock.onGet('/mdp/pub/company/list').reply(config => {
+      let params = config.params;
+      let mockCompanys = _Companys.filter(company => {
+      	var isTrue=false;
+      	if(params.companyId||params.companyId==''){if(company.companyId.indexOf(params.companyId)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.companyName||params.companyName==''){if(company.companyName.indexOf(params.companyName)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.districtId||params.districtId==''){if(company.districtId.indexOf(params.districtId)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.categoryId||params.categoryId==''){if(company.categoryId.indexOf(params.categoryId)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.phoneNo||params.phoneNo==''){if(company.phoneNo.indexOf(params.phoneNo)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.orgId||params.orgId==''){if(company.orgId.indexOf(params.orgId)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.address||params.address==''){if(company.address.indexOf(params.address)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.branchId||params.branchId==''){if(company.branchId.indexOf(params.branchId)>=0){isTrue=true;}else{isTrue=false;}}
+      	return isTrue;
+	  });
+      if(!config.params.currentPage){ 
+	      return new Promise((resolve, reject) => {
+	        setTimeout(() => {
+	          resolve([200, {
+	            data: mockCompanys
+	          }]);
+	        }, 1000);
+	      });
+      }
+    
+      let {pageSize,currentPage, total} = config.params;
+      total = mockCompanys.length;
+      mockCompanys = mockCompanys.filter((company, index) => index < pageSize * currentPage && index >= pageSize * (currentPage - 1));
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            pageInfo: {
+            	total:total
+            },
+            data: mockCompanys,
+            tips:{
+            	isOk:true,
+            	msg:'查询成功'
+            }
+          }]);
+        }, 1000);
+      });
+    });
+
+    //删除
+    mock.onPost('/mdp/pub/company/del').reply(config => {
+      var params = JSON.parse( config.data );
+      let {  companyId  } = params;
+      _Companys = _Companys.filter(company => company.companyId !== companyId);
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'删除成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //批量删除
+    mock.onPost('/mdp/pub/company/batchDel').reply(config => {
+      var params = JSON.parse( config.data );
+      _Companys = _Companys.filter(company => !params.includes(company.companyId));
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+           tips:{
+            	isOk:true,
+            	msg:'删除成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //编辑
+    mock.onPost('/mdp/pub/company/edit').reply(config => {
+      var params = JSON.parse( config.data );
+      let { companyId,companyName,districtId,categoryId,phoneNo,orgId,address,branchId } = params;
+      _Companys.some(company => {
+        if (company.companyId === companyId) {
+			company.companyId = companyId;
+			company.companyName = companyName;
+			company.districtId = districtId;
+			company.categoryId = categoryId;
+			company.phoneNo = phoneNo;
+			company.orgId = orgId;
+			company.address = address;
+			company.branchId = branchId
+          return true;
+        }
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'编辑成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //新增
+    mock.onPost('/mdp/pub/company/add').reply(config => {
+      var params = JSON.parse( config.data );
+      let { companyId,companyName,districtId,categoryId,phoneNo,orgId,address,branchId } = params;
+      _Companys.push({
+		companyId:companyId,
+		companyName:companyName,
+		districtId:districtId,
+		categoryId:categoryId,
+		phoneNo:phoneNo,
+		orgId:orgId,
+		address:address,
+		branchId:branchId
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'新增成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+  }
+};

src/mock/mdp/pub/cust.js

@@ -0,0 +1,14 @@
+ import Mock from 'mockjs';
+
+const Custs = [];
+
+for (let i = 0; i < 25; i++) {
+  Custs.push(Mock.mock({
+		custId:Mock.Random.string(5),
+		branchId:Mock.Random.string(5),
+		custName:Mock.Random.ctitle(1,0) , 
+		enabled:Mock.Random.character('lower')
+  }));
+}
+
+export { Custs };

src/mock/mdp/pub/custMock.js

@@ -0,0 +1,156 @@
+import { Custs } from './cust';
+let _Custs = Custs;
+/**
+ * 拷贝下面两行到 mock/index.js中,即可支持客户端虚拟数据、免服务端连接
+ * import CustMock from './mdp/pub/custMock';
+ * CustMock.bootstrap(mock);
+ */
+export default {
+  /**
+   * mock bootstrap
+   */
+  bootstrap(mock) {    
+  
+    //获取列表 模糊查询、根据关键字查询
+    mock.onGet('/mdp/pub/cust/listKey').reply(config => {
+      let params = config.params;
+      let mockCusts = _Custs.filter(cust => {
+      	if(params.custId||params.custId==''){ if( cust.custId.indexOf(params.custId)>=0) return true;}
+      	if(params.custName||params.custName==''){ if( cust.custName.indexOf(params.custName)>=0) return true;}
+      	if(params.enabled||params.enabled==''){ if( cust.enabled.indexOf(params.enabled)>=0) return true;}
+      	if(params.branchId||params.branchId==''){ if( cust.branchId.indexOf(params.branchId)>=0) return true;}
+        return false;
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            data: mockCusts
+          }]);
+        }, 1000);
+      });
+    });
+    
+    
+
+    //获取列表（分页/不分页）
+    mock.onGet('/mdp/pub/cust/list').reply(config => {
+      let params = config.params;
+      let mockCusts = _Custs.filter(cust => {
+      	var isTrue=false;
+      	if(params.custId||params.custId==''){if(cust.custId.indexOf(params.custId)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.custName||params.custName==''){if(cust.custName.indexOf(params.custName)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.enabled||params.enabled==''){if(cust.enabled.indexOf(params.enabled)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.branchId||params.branchId==''){if(cust.branchId.indexOf(params.branchId)>=0){isTrue=true;}else{isTrue=false;}}
+      	return isTrue;
+	  });
+      if(!config.params.currentPage){ 
+	      return new Promise((resolve, reject) => {
+	        setTimeout(() => {
+	          resolve([200, {
+	            data: mockCusts
+	          }]);
+	        }, 1000);
+	      });
+      }
+    
+      let {pageSize,currentPage, total} = config.params;
+      total = mockCusts.length;
+      mockCusts = mockCusts.filter((cust, index) => index < pageSize * currentPage && index >= pageSize * (currentPage - 1));
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            pageInfo: {
+            	total:total
+            },
+            data: mockCusts,
+            tips:{
+            	isOk:true,
+            	msg:'查询成功'
+            }
+          }]);
+        }, 1000);
+      });
+    });
+
+    //删除
+    mock.onPost('/mdp/pub/cust/del').reply(config => {
+      var params = JSON.parse( config.data );
+      let {  custId  } = params;
+      _Custs = _Custs.filter(cust => cust.custId !== custId);
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'删除成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //批量删除
+    mock.onPost('/mdp/pub/cust/batchDel').reply(config => {
+      var params = JSON.parse( config.data );
+      _Custs = _Custs.filter(cust => !params.includes(cust.custId));
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+           tips:{
+            	isOk:true,
+            	msg:'删除成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //编辑
+    mock.onPost('/mdp/pub/cust/edit').reply(config => {
+      var params = JSON.parse( config.data );
+      let { custId,custName,enabled,branchId } = params;
+      _Custs.some(cust => {
+        if (cust.custId === custId) {
+			cust.custId = custId;
+			cust.custName = custName;
+			cust.enabled = enabled;
+			cust.branchId = branchId
+          return true;
+        }
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'编辑成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //新增
+    mock.onPost('/mdp/pub/cust/add').reply(config => {
+      var params = JSON.parse( config.data );
+      let { custId,custName,enabled,branchId } = params;
+      _Custs.push({
+		custId:custId,
+		custName:custName,
+		enabled:enabled,
+		branchId:branchId
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'新增成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+  }
+};

src/mock/mdp/pub/dist.js

@@ -0,0 +1,14 @@
+ import Mock from 'mockjs';
+
+const Dists = [];
+
+for (let i = 0; i < 25; i++) {
+  Dists.push(Mock.mock({
+		distId:Mock.Random.string(5),
+		branchId:Mock.Random.string(5),
+		distName:Mock.Random.ctitle(1,0) , 
+		enabled:Mock.Random.character('lower')
+  }));
+}
+
+export { Dists };

src/mock/mdp/pub/distMock.js

@@ -0,0 +1,156 @@
+import { Dists } from './dist';
+let _Dists = Dists;
+/**
+ * 拷贝下面两行到 mock/index.js中,即可支持客户端虚拟数据、免服务端连接
+ * import DistMock from './mdp/pub/distMock';
+ * DistMock.bootstrap(mock);
+ */
+export default {
+  /**
+   * mock bootstrap
+   */
+  bootstrap(mock) {    
+  
+    //获取列表 模糊查询、根据关键字查询
+    mock.onGet('/mdp/pub/dist/listKey').reply(config => {
+      let params = config.params;
+      let mockDists = _Dists.filter(dist => {
+      	if(params.distId||params.distId==''){ if( dist.distId.indexOf(params.distId)>=0) return true;}
+      	if(params.distName||params.distName==''){ if( dist.distName.indexOf(params.distName)>=0) return true;}
+      	if(params.enabled||params.enabled==''){ if( dist.enabled.indexOf(params.enabled)>=0) return true;}
+      	if(params.branchId||params.branchId==''){ if( dist.branchId.indexOf(params.branchId)>=0) return true;}
+        return false;
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            data: mockDists
+          }]);
+        }, 1000);
+      });
+    });
+    
+    
+
+    //获取列表（分页/不分页）
+    mock.onGet('/mdp/pub/dist/list').reply(config => {
+      let params = config.params;
+      let mockDists = _Dists.filter(dist => {
+      	var isTrue=false;
+      	if(params.distId||params.distId==''){if(dist.distId.indexOf(params.distId)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.distName||params.distName==''){if(dist.distName.indexOf(params.distName)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.enabled||params.enabled==''){if(dist.enabled.indexOf(params.enabled)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.branchId||params.branchId==''){if(dist.branchId.indexOf(params.branchId)>=0){isTrue=true;}else{isTrue=false;}}
+      	return isTrue;
+	  });
+      if(!config.params.currentPage){ 
+	      return new Promise((resolve, reject) => {
+	        setTimeout(() => {
+	          resolve([200, {
+	            data: mockDists
+	          }]);
+	        }, 1000);
+	      });
+      }
+    
+      let {pageSize,currentPage, total} = config.params;
+      total = mockDists.length;
+      mockDists = mockDists.filter((dist, index) => index < pageSize * currentPage && index >= pageSize * (currentPage - 1));
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            pageInfo: {
+            	total:total
+            },
+            data: mockDists,
+            tips:{
+            	isOk:true,
+            	msg:'查询成功'
+            }
+          }]);
+        }, 1000);
+      });
+    });
+
+    //删除
+    mock.onPost('/mdp/pub/dist/del').reply(config => {
+      var params = JSON.parse( config.data );
+      let {  distId  } = params;
+      _Dists = _Dists.filter(dist => dist.distId !== distId);
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'删除成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //批量删除
+    mock.onPost('/mdp/pub/dist/batchDel').reply(config => {
+      var params = JSON.parse( config.data );
+      _Dists = _Dists.filter(dist => !params.includes(dist.distId));
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+           tips:{
+            	isOk:true,
+            	msg:'删除成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //编辑
+    mock.onPost('/mdp/pub/dist/edit').reply(config => {
+      var params = JSON.parse( config.data );
+      let { distId,distName,enabled,branchId } = params;
+      _Dists.some(dist => {
+        if (dist.distId === distId) {
+			dist.distId = distId;
+			dist.distName = distName;
+			dist.enabled = enabled;
+			dist.branchId = branchId
+          return true;
+        }
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'编辑成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //新增
+    mock.onPost('/mdp/pub/dist/add').reply(config => {
+      var params = JSON.parse( config.data );
+      let { distId,distName,enabled,branchId } = params;
+      _Dists.push({
+		distId:distId,
+		distName:distName,
+		enabled:enabled,
+		branchId:branchId
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'新增成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+  }
+};

src/mock/mdp/pub/supplier.js

@@ -0,0 +1,14 @@
+ import Mock from 'mockjs';
+
+const Suppliers = [];
+
+for (let i = 0; i < 25; i++) {
+  Suppliers.push(Mock.mock({
+		supplierId:Mock.Random.string(5),
+		branchId:Mock.Random.string(5),
+		supplierName:Mock.Random.ctitle(1,0) , 
+		enabled:Mock.Random.character('lower')
+  }));
+}
+
+export { Suppliers };

src/mock/mdp/pub/supplierMock.js

@@ -0,0 +1,156 @@
+import { Suppliers } from './supplier';
+let _Suppliers = Suppliers;
+/**
+ * 拷贝下面两行到 mock/index.js中,即可支持客户端虚拟数据、免服务端连接
+ * import SupplierMock from './mdp/pub/supplierMock';
+ * SupplierMock.bootstrap(mock);
+ */
+export default {
+  /**
+   * mock bootstrap
+   */
+  bootstrap(mock) {    
+  
+    //获取列表 模糊查询、根据关键字查询
+    mock.onGet('/mdp/pub/supplier/listKey').reply(config => {
+      let params = config.params;
+      let mockSuppliers = _Suppliers.filter(supplier => {
+      	if(params.supplierId||params.supplierId==''){ if( supplier.supplierId.indexOf(params.supplierId)>=0) return true;}
+      	if(params.supplierName||params.supplierName==''){ if( supplier.supplierName.indexOf(params.supplierName)>=0) return true;}
+      	if(params.enabled||params.enabled==''){ if( supplier.enabled.indexOf(params.enabled)>=0) return true;}
+      	if(params.branchId||params.branchId==''){ if( supplier.branchId.indexOf(params.branchId)>=0) return true;}
+        return false;
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            data: mockSuppliers
+          }]);
+        }, 1000);
+      });
+    });
+    
+    
+
+    //获取列表（分页/不分页）
+    mock.onGet('/mdp/pub/supplier/list').reply(config => {
+      let params = config.params;
+      let mockSuppliers = _Suppliers.filter(supplier => {
+      	var isTrue=false;
+      	if(params.supplierId||params.supplierId==''){if(supplier.supplierId.indexOf(params.supplierId)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.supplierName||params.supplierName==''){if(supplier.supplierName.indexOf(params.supplierName)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.enabled||params.enabled==''){if(supplier.enabled.indexOf(params.enabled)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.branchId||params.branchId==''){if(supplier.branchId.indexOf(params.branchId)>=0){isTrue=true;}else{isTrue=false;}}
+      	return isTrue;
+	  });
+      if(!config.params.currentPage){ 
+	      return new Promise((resolve, reject) => {
+	        setTimeout(() => {
+	          resolve([200, {
+	            data: mockSuppliers
+	          }]);
+	        }, 1000);
+	      });
+      }
+    
+      let {pageSize,currentPage, total} = config.params;
+      total = mockSuppliers.length;
+      mockSuppliers = mockSuppliers.filter((supplier, index) => index < pageSize * currentPage && index >= pageSize * (currentPage - 1));
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            pageInfo: {
+            	total:total
+            },
+            data: mockSuppliers,
+            tips:{
+            	isOk:true,
+            	msg:'查询成功'
+            }
+          }]);
+        }, 1000);
+      });
+    });
+
+    //删除
+    mock.onPost('/mdp/pub/supplier/del').reply(config => {
+      var params = JSON.parse( config.data );
+      let {  supplierId  } = params;
+      _Suppliers = _Suppliers.filter(supplier => supplier.supplierId !== supplierId);
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'删除成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //批量删除
+    mock.onPost('/mdp/pub/supplier/batchDel').reply(config => {
+      var params = JSON.parse( config.data );
+      _Suppliers = _Suppliers.filter(supplier => !params.includes(supplier.supplierId));
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+           tips:{
+            	isOk:true,
+            	msg:'删除成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //编辑
+    mock.onPost('/mdp/pub/supplier/edit').reply(config => {
+      var params = JSON.parse( config.data );
+      let { supplierId,supplierName,enabled,branchId } = params;
+      _Suppliers.some(supplier => {
+        if (supplier.supplierId === supplierId) {
+			supplier.supplierId = supplierId;
+			supplier.supplierName = supplierName;
+			supplier.enabled = enabled;
+			supplier.branchId = branchId
+          return true;
+        }
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'编辑成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //新增
+    mock.onPost('/mdp/pub/supplier/add').reply(config => {
+      var params = JSON.parse( config.data );
+      let { supplierId,supplierName,enabled,branchId } = params;
+      _Suppliers.push({
+		supplierId:supplierId,
+		supplierName:supplierName,
+		enabled:enabled,
+		branchId:branchId
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'新增成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+  }
+};

src/mock/mdp/sys/category.js

@@ -0,0 +1,14 @@
+ import Mock from 'mockjs';
+
+const Categorys = [];
+
+for (let i = 0; i < 25; i++) {
+  Categorys.push(Mock.mock({
+		id:Mock.Random.string(5),
+		pid:Mock.Random.ctitle(1,0) , 
+		name:Mock.Random.ctitle(1,0) , 
+		'sortOrder|0-5': 1
+  }));
+}
+
+export { Categorys };

src/mock/mdp/sys/categoryMock.js

@@ -0,0 +1,156 @@
+import { Categorys } from './category';
+let _Categorys = Categorys;
+/**
+ * 拷贝下面两行到 mock/index.js中,即可支持客户端虚拟数据、免服务端连接
+ * import CategoryMock from './mdp/sys/categoryMock';
+ * CategoryMock.bootstrap(mock);
+ */
+export default {
+  /**
+   * mock bootstrap
+   */
+  bootstrap(mock) {    
+  
+    //获取列表 模糊查询、根据关键字查询
+    mock.onGet('/mdp/sys/category/listKey').reply(config => {
+      let params = config.params;
+      let mockCategorys = _Categorys.filter(category => {
+      	if(params.id||params.id==''){ if( category.id.indexOf(params.id)>=0) return true;}
+      	if(params.pid||params.pid==''){ if( category.pid.indexOf(params.pid)>=0) return true;}
+      	if(params.name||params.name==''){ if( category.name.indexOf(params.name)>=0) return true;}
+      	if(params.sortOrder||params.sortOrder==''){ if( category.sortOrder.indexOf(params.sortOrder)>=0) return true;}
+        return false;
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            data: mockCategorys
+          }]);
+        }, 1000);
+      });
+    });
+    
+    
+
+    //获取列表（分页/不分页）
+    mock.onGet('/mdp/sys/category/list').reply(config => {
+      let params = config.params;
+      let mockCategorys = _Categorys.filter(category => {
+      	var isTrue=false;
+      	if(params.id||params.id==''){if(category.id.indexOf(params.id)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.pid||params.pid==''){if(category.pid.indexOf(params.pid)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.name||params.name==''){if(category.name.indexOf(params.name)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.sortOrder||params.sortOrder==''){if(category.sortOrder.indexOf(params.sortOrder)>=0){isTrue=true;}else{isTrue=false;}}
+      	return isTrue;
+	  });
+      if(!config.params.currentPage){ 
+	      return new Promise((resolve, reject) => {
+	        setTimeout(() => {
+	          resolve([200, {
+	            data: mockCategorys
+	          }]);
+	        }, 1000);
+	      });
+      }
+    
+      let {pageSize,currentPage, total} = config.params;
+      total = mockCategorys.length;
+      mockCategorys = mockCategorys.filter((category, index) => index < pageSize * currentPage && index >= pageSize * (currentPage - 1));
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            pageInfo: {
+            	total:total
+            },
+            data: mockCategorys,
+            tips:{
+            	isOk:true,
+            	msg:'查询成功'
+            }
+          }]);
+        }, 1000);
+      });
+    });
+
+    //删除
+    mock.onPost('/mdp/sys/category/del').reply(config => {
+      var params = JSON.parse( config.data );
+      let {  id  } = params;
+      _Categorys = _Categorys.filter(category => category.id !== id);
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'删除成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //批量删除
+    mock.onPost('/mdp/sys/category/batchDel').reply(config => {
+      var params = JSON.parse( config.data );
+      _Categorys = _Categorys.filter(category => !params.includes(category.id));
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+           tips:{
+            	isOk:true,
+            	msg:'删除成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //编辑
+    mock.onPost('/mdp/sys/category/edit').reply(config => {
+      var params = JSON.parse( config.data );
+      let { id,pid,name,sortOrder } = params;
+      _Categorys.some(category => {
+        if (category.id === id) {
+			category.id = id;
+			category.pid = pid;
+			category.name = name;
+			category.sortOrder = sortOrder
+          return true;
+        }
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'编辑成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //新增
+    mock.onPost('/mdp/sys/category/add').reply(config => {
+      var params = JSON.parse( config.data );
+      let { id,pid,name,sortOrder } = params;
+      _Categorys.push({
+		id:id,
+		pid:pid,
+		name:name,
+		sortOrder:sortOrder
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'新增成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+  }
+};

src/mock/mdp/sys/code.js

@@ -0,0 +1,21 @@
+ import Mock from 'mockjs';
+
+const Codes = [];
+
+for (let i = 0; i < 25; i++) {
+  Codes.push(Mock.mock({
+		codeRow:Mock.Random.string(5),
+		tcodeId:Mock.Random.ctitle(2,32) , 
+		tcodeName:Mock.Random.ctitle(2,12) , 
+		remark:Mock.Random.ctitle(2,24) , 
+		state:Mock.Random.ctitle(2,4) , 
+		codeBeg:Mock.Random.date('yyyy-MM-dd') , 
+		codeEnd:Mock.Random.date('yyyy-MM-dd') , 
+		createPerson:Mock.Random.ctitle(2,8) , 
+		createDate:Mock.Random.date('yyyy-MM-dd') , 
+		loperatePerson:Mock.Random.ctitle(2,8) , 
+		loperateDate:Mock.Random.date('yyyy-MM-dd')
+  }));
+}
+
+export { Codes };

src/mock/mdp/sys/codeDetail.js

@@ -0,0 +1,31 @@
+ import Mock from 'mockjs';
+
+const CodeDetails = [];
+
+for (let i = 0; i < 25; i++) {
+  CodeDetails.push(Mock.mock({
+		dcodeRow:Mock.Random.string(5),
+		codeValue:Mock.Random.ctitle(1,0) , 
+		codeName:Mock.Random.ctitle(1,2) , 
+		ifdefault:Mock.Random.character('lower') , 
+		state:Mock.Random.ctitle(1,4) , 
+		codeBeg:Mock.Random.date('yyyy-MM-dd') , 
+		codeEnd:Mock.Random.date('yyyy-MM-dd') , 
+		createPerson:Mock.Random.ctitle(1,8) , 
+		createDate:Mock.Random.date('yyyy-MM-dd') , 
+		loperatePerson:Mock.Random.ctitle(1,8) , 
+		loperateDate:Mock.Random.date('yyyy-MM-dd') , 
+		'seqOrder|0-5': 1 , 
+		keys:Mock.Random.ctitle(1,0) , 
+		fp:Mock.Random.ctitle(1,0) , 
+		sp:Mock.Random.ctitle(1,0) , 
+		tp:Mock.Random.ctitle(1,0) , 
+		secondCodeRow:Mock.Random.ctitle(1,0) , 
+		deptid:Mock.Random.ctitle(1,0) , 
+		codeRow:Mock.Random.ctitle(1,0) , 
+		dtcodeId:Mock.Random.ctitle(1,2) , 
+		dtcodeName:Mock.Random.ctitle(1,2)
+  }));
+}
+
+export { CodeDetails };

src/mock/mdp/sys/codeDetailMock.js

@@ -0,0 +1,224 @@
+import { CodeDetails } from './codeDetail';
+let _CodeDetails = CodeDetails;
+/**
+ * 拷贝下面两行到 mock/index.js中,即可支持客户端虚拟数据、免服务端连接
+ * import CodeDetailMock from './mdp/sys/codeDetailMock';
+ * CodeDetailMock.bootstrap(mock);
+ */
+export default {
+  /**
+   * mock bootstrap
+   */
+  bootstrap(mock) {    
+  
+    //获取列表 模糊查询、根据关键字查询
+    mock.onGet('/mdp/sys/codeDetail/listKey').reply(config => {
+      let params = config.params;
+      let mockCodeDetails = _CodeDetails.filter(codeDetail => {
+      	if(params.dcodeRow||params.dcodeRow==''){ if( codeDetail.dcodeRow.indexOf(params.dcodeRow)>=0) return true;}
+      	if(params.codeValue||params.codeValue==''){ if( codeDetail.codeValue.indexOf(params.codeValue)>=0) return true;}
+      	if(params.codeName||params.codeName==''){ if( codeDetail.codeName.indexOf(params.codeName)>=0) return true;}
+      	if(params.ifdefault||params.ifdefault==''){ if( codeDetail.ifdefault.indexOf(params.ifdefault)>=0) return true;}
+      	if(params.state||params.state==''){ if( codeDetail.state.indexOf(params.state)>=0) return true;}
+      	if(params.codeBeg||params.codeBeg==''){ if( codeDetail.codeBeg.indexOf(params.codeBeg)>=0) return true;}
+      	if(params.codeEnd||params.codeEnd==''){ if( codeDetail.codeEnd.indexOf(params.codeEnd)>=0) return true;}
+      	if(params.createPerson||params.createPerson==''){ if( codeDetail.createPerson.indexOf(params.createPerson)>=0) return true;}
+      	if(params.createDate||params.createDate==''){ if( codeDetail.createDate.indexOf(params.createDate)>=0) return true;}
+      	if(params.loperatePerson||params.loperatePerson==''){ if( codeDetail.loperatePerson.indexOf(params.loperatePerson)>=0) return true;}
+      	if(params.loperateDate||params.loperateDate==''){ if( codeDetail.loperateDate.indexOf(params.loperateDate)>=0) return true;}
+      	if(params.seqOrder||params.seqOrder==''){ if( codeDetail.seqOrder.indexOf(params.seqOrder)>=0) return true;}
+      	if(params.keys||params.keys==''){ if( codeDetail.keys.indexOf(params.keys)>=0) return true;}
+      	if(params.fp||params.fp==''){ if( codeDetail.fp.indexOf(params.fp)>=0) return true;}
+      	if(params.sp||params.sp==''){ if( codeDetail.sp.indexOf(params.sp)>=0) return true;}
+      	if(params.tp||params.tp==''){ if( codeDetail.tp.indexOf(params.tp)>=0) return true;}
+      	if(params.secondCodeRow||params.secondCodeRow==''){ if( codeDetail.secondCodeRow.indexOf(params.secondCodeRow)>=0) return true;}
+      	if(params.deptid||params.deptid==''){ if( codeDetail.deptid.indexOf(params.deptid)>=0) return true;}
+      	if(params.codeRow||params.codeRow==''){ if( codeDetail.codeRow.indexOf(params.codeRow)>=0) return true;}
+      	if(params.dtcodeId||params.dtcodeId==''){ if( codeDetail.dtcodeId.indexOf(params.dtcodeId)>=0) return true;}
+      	if(params.dtcodeName||params.dtcodeName==''){ if( codeDetail.dtcodeName.indexOf(params.dtcodeName)>=0) return true;}
+        return false;
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            data: mockCodeDetails
+          }]);
+        }, 1000);
+      });
+    });
+    
+    
+
+    //获取列表（分页/不分页）
+    mock.onGet('/mdp/sys/codeDetail/list').reply(config => {
+      let params = config.params;
+      let mockCodeDetails = _CodeDetails.filter(codeDetail => {
+      	var isTrue=false;
+      	if(params.dcodeRow||params.dcodeRow==''){if(codeDetail.dcodeRow.indexOf(params.dcodeRow)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.codeValue||params.codeValue==''){if(codeDetail.codeValue.indexOf(params.codeValue)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.codeName||params.codeName==''){if(codeDetail.codeName.indexOf(params.codeName)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.ifdefault||params.ifdefault==''){if(codeDetail.ifdefault.indexOf(params.ifdefault)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.state||params.state==''){if(codeDetail.state.indexOf(params.state)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.codeBeg||params.codeBeg==''){if(codeDetail.codeBeg.indexOf(params.codeBeg)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.codeEnd||params.codeEnd==''){if(codeDetail.codeEnd.indexOf(params.codeEnd)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.createPerson||params.createPerson==''){if(codeDetail.createPerson.indexOf(params.createPerson)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.createDate||params.createDate==''){if(codeDetail.createDate.indexOf(params.createDate)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.loperatePerson||params.loperatePerson==''){if(codeDetail.loperatePerson.indexOf(params.loperatePerson)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.loperateDate||params.loperateDate==''){if(codeDetail.loperateDate.indexOf(params.loperateDate)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.seqOrder||params.seqOrder==''){if(codeDetail.seqOrder.indexOf(params.seqOrder)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.keys||params.keys==''){if(codeDetail.keys.indexOf(params.keys)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.fp||params.fp==''){if(codeDetail.fp.indexOf(params.fp)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.sp||params.sp==''){if(codeDetail.sp.indexOf(params.sp)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.tp||params.tp==''){if(codeDetail.tp.indexOf(params.tp)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.secondCodeRow||params.secondCodeRow==''){if(codeDetail.secondCodeRow.indexOf(params.secondCodeRow)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.deptid||params.deptid==''){if(codeDetail.deptid.indexOf(params.deptid)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.codeRow||params.codeRow==''){if(codeDetail.codeRow.indexOf(params.codeRow)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.dtcodeId||params.dtcodeId==''){if(codeDetail.dtcodeId.indexOf(params.dtcodeId)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.dtcodeName||params.dtcodeName==''){if(codeDetail.dtcodeName.indexOf(params.dtcodeName)>=0){isTrue=true;}else{isTrue=false;}}
+      	return isTrue;
+	  });
+      if(!config.params.currentPage){ 
+	      return new Promise((resolve, reject) => {
+	        setTimeout(() => {
+	          resolve([200, {
+	            data: mockCodeDetails
+	          }]);
+	        }, 1000);
+	      });
+      }
+    
+      let {pageSize,currentPage, total} = config.params;
+      total = mockCodeDetails.length;
+      mockCodeDetails = mockCodeDetails.filter((codeDetail, index) => index < pageSize * currentPage && index >= pageSize * (currentPage - 1));
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            pageInfo: {
+            	total:total
+            },
+            data: mockCodeDetails,
+            tips:{
+            	isOk:true,
+            	msg:'查询成功'
+            }
+          }]);
+        }, 1000);
+      });
+    });
+
+    //删除
+    mock.onPost('/mdp/sys/codeDetail/del').reply(config => {
+      var params = JSON.parse( config.data );
+      let {  dcodeRow  } = params;
+      _CodeDetails = _CodeDetails.filter(codeDetail => codeDetail.dcodeRow !== dcodeRow);
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'删除成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //批量删除
+    mock.onPost('/mdp/sys/codeDetail/batchDel').reply(config => {
+      var params = JSON.parse( config.data );
+      _CodeDetails = _CodeDetails.filter(codeDetail => !params.includes(codeDetail.dcodeRow));
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+           tips:{
+            	isOk:true,
+            	msg:'删除成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //编辑
+    mock.onPost('/mdp/sys/codeDetail/edit').reply(config => {
+      var params = JSON.parse( config.data );
+      let { dcodeRow,codeValue,codeName,ifdefault,state,codeBeg,codeEnd,createPerson,createDate,loperatePerson,loperateDate,seqOrder,keys,fp,sp,tp,secondCodeRow,deptid,codeRow,dtcodeId,dtcodeName } = params;
+      _CodeDetails.some(codeDetail => {
+        if (codeDetail.dcodeRow === dcodeRow) {
+			codeDetail.dcodeRow = dcodeRow;
+			codeDetail.codeValue = codeValue;
+			codeDetail.codeName = codeName;
+			codeDetail.ifdefault = ifdefault;
+			codeDetail.state = state;
+			codeDetail.codeBeg = codeBeg;
+			codeDetail.codeEnd = codeEnd;
+			codeDetail.createPerson = createPerson;
+			codeDetail.createDate = createDate;
+			codeDetail.loperatePerson = loperatePerson;
+			codeDetail.loperateDate = loperateDate;
+			codeDetail.seqOrder = seqOrder;
+			codeDetail.keys = keys;
+			codeDetail.fp = fp;
+			codeDetail.sp = sp;
+			codeDetail.tp = tp;
+			codeDetail.secondCodeRow = secondCodeRow;
+			codeDetail.deptid = deptid;
+			codeDetail.codeRow = codeRow;
+			codeDetail.dtcodeId = dtcodeId;
+			codeDetail.dtcodeName = dtcodeName
+          return true;
+        }
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'编辑成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //新增
+    mock.onPost('/mdp/sys/codeDetail/add').reply(config => {
+      var params = JSON.parse( config.data );
+      let { dcodeRow,codeValue,codeName,ifdefault,state,codeBeg,codeEnd,createPerson,createDate,loperatePerson,loperateDate,seqOrder,keys,fp,sp,tp,secondCodeRow,deptid,codeRow,dtcodeId,dtcodeName } = params;
+      _CodeDetails.push({
+		dcodeRow:dcodeRow,
+		codeValue:codeValue,
+		codeName:codeName,
+		ifdefault:ifdefault,
+		state:state,
+		codeBeg:codeBeg,
+		codeEnd:codeEnd,
+		createPerson:createPerson,
+		createDate:createDate,
+		loperatePerson:loperatePerson,
+		loperateDate:loperateDate,
+		seqOrder:seqOrder,
+		keys:keys,
+		fp:fp,
+		sp:sp,
+		tp:tp,
+		secondCodeRow:secondCodeRow,
+		deptid:deptid,
+		codeRow:codeRow,
+		dtcodeId:dtcodeId,
+		dtcodeName:dtcodeName
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'新增成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+  }
+};

src/mock/mdp/sys/codeMock.js

@@ -0,0 +1,186 @@
+import { Codes } from './code';
+let _Codes = Codes;
+/**
+ * 拷贝下面两行到 mock/index.js中,即可支持客户端虚拟数据、免服务端连接
+ * import CodeMock from './mdp/sys/codeMock';
+ * CodeMock.bootstrap(mock);
+ */
+export default {
+  /**
+   * mock bootstrap
+   */
+  bootstrap(mock) {    
+  
+    //获取列表 模糊查询、根据关键字查询
+    mock.onGet('/mdp/sys/code/listKey').reply(config => {
+      let params = config.params;
+      let mockCodes = _Codes.filter(code => {
+      	if(params.codeRow||params.codeRow==''){ if( code.codeRow.indexOf(params.codeRow)>=0) return true;}
+      	if(params.tcodeId||params.tcodeId==''){ if( code.tcodeId.indexOf(params.tcodeId)>=0) return true;}
+      	if(params.tcodeName||params.tcodeName==''){ if( code.tcodeName.indexOf(params.tcodeName)>=0) return true;}
+      	if(params.remark||params.remark==''){ if( code.remark.indexOf(params.remark)>=0) return true;}
+      	if(params.state||params.state==''){ if( code.state.indexOf(params.state)>=0) return true;}
+      	if(params.codeBeg||params.codeBeg==''){ if( code.codeBeg.indexOf(params.codeBeg)>=0) return true;}
+      	if(params.codeEnd||params.codeEnd==''){ if( code.codeEnd.indexOf(params.codeEnd)>=0) return true;}
+      	if(params.createPerson||params.createPerson==''){ if( code.createPerson.indexOf(params.createPerson)>=0) return true;}
+      	if(params.createDate||params.createDate==''){ if( code.createDate.indexOf(params.createDate)>=0) return true;}
+      	if(params.loperatePerson||params.loperatePerson==''){ if( code.loperatePerson.indexOf(params.loperatePerson)>=0) return true;}
+      	if(params.loperateDate||params.loperateDate==''){ if( code.loperateDate.indexOf(params.loperateDate)>=0) return true;}
+        return false;
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            data: mockCodes
+          }]);
+        }, 1000);
+      });
+    });
+    
+    
+
+    //获取列表（分页/不分页）
+    mock.onGet('/mdp/sys/code/list').reply(config => {
+      let params = config.params;
+      let mockCodes = _Codes.filter(code => {
+      	var isTrue=false;
+      	if(params.codeRow||params.codeRow==''){if(code.codeRow.indexOf(params.codeRow)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.tcodeId||params.tcodeId==''){if(code.tcodeId.indexOf(params.tcodeId)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.tcodeName||params.tcodeName==''){if(code.tcodeName.indexOf(params.tcodeName)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.remark||params.remark==''){if(code.remark.indexOf(params.remark)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.state||params.state==''){if(code.state.indexOf(params.state)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.codeBeg||params.codeBeg==''){if(code.codeBeg.indexOf(params.codeBeg)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.codeEnd||params.codeEnd==''){if(code.codeEnd.indexOf(params.codeEnd)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.createPerson||params.createPerson==''){if(code.createPerson.indexOf(params.createPerson)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.createDate||params.createDate==''){if(code.createDate.indexOf(params.createDate)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.loperatePerson||params.loperatePerson==''){if(code.loperatePerson.indexOf(params.loperatePerson)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.loperateDate||params.loperateDate==''){if(code.loperateDate.indexOf(params.loperateDate)>=0){isTrue=true;}else{isTrue=false;}}
+      	return isTrue;
+	  });
+      if(!config.params.currentPage){ 
+	      return new Promise((resolve, reject) => {
+	        setTimeout(() => {
+	          resolve([200, {
+	            data: mockCodes
+	          }]);
+	        }, 1000);
+	      });
+      }
+    
+      let {pageSize,currentPage, total} = config.params;
+      total = mockCodes.length;
+      mockCodes = mockCodes.filter((code, index) => index < pageSize * currentPage && index >= pageSize * (currentPage - 1));
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            pageInfo: {
+            	total:total
+            },
+            data: mockCodes,
+            tips:{
+            	isOk:true,
+            	msg:'查询成功'
+            }
+          }]);
+        }, 1000);
+      });
+    });
+
+    //删除
+    mock.onPost('/mdp/sys/code/del').reply(config => {
+      var params = JSON.parse( config.data );
+      let {  codeRow  } = params;
+      _Codes = _Codes.filter(code => code.codeRow !== codeRow);
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'删除成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //批量删除
+    mock.onPost('/mdp/sys/code/batchDel').reply(config => {
+      var params = JSON.parse( config.data );
+       
+      codeRows = codeRows.split(',');
+      _Codes = _Codes.filter(code => !params.includes(code.codeRow));
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+           tips:{
+            	isOk:true,
+            	msg:'删除成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //编辑
+    mock.onPost('/mdp/sys/code/edit').reply(config => {
+      var params = JSON.parse( config.data );
+      let { codeRow,tcodeId,tcodeName,remark,state,codeBeg,codeEnd,createPerson,createDate,loperatePerson,loperateDate } = params;
+      _Codes.some(code => {
+        if (code.codeRow === codeRow) {
+			code.codeRow = codeRow;
+			code.tcodeId = tcodeId;
+			code.tcodeName = tcodeName;
+			code.remark = remark;
+			code.state = state;
+			code.codeBeg = codeBeg;
+			code.codeEnd = codeEnd;
+			code.createPerson = createPerson;
+			code.createDate = createDate;
+			code.loperatePerson = loperatePerson;
+			code.loperateDate = loperateDate
+          return true;
+        }
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'编辑成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //新增
+    mock.onPost('/mdp/sys/code/add').reply(config => {
+      var params = JSON.parse( config.data );
+      let { codeRow,tcodeId,tcodeName,remark,state,codeBeg,codeEnd,createPerson,createDate,loperatePerson,loperateDate } = params;
+      _Codes.push({
+		codeRow:codeRow,
+		tcodeId:tcodeId,
+		tcodeName:tcodeName,
+		remark:remark,
+		state:state,
+		codeBeg:codeBeg,
+		codeEnd:codeEnd,
+		createPerson:createPerson,
+		createDate:createDate,
+		loperatePerson:loperatePerson,
+		loperateDate:loperateDate
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'新增成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+  }
+};

src/mock/mdp/sys/codeSecond.js

@@ -0,0 +1,18 @@
+ import Mock from 'mockjs';
+
+const CodeSeconds = [];
+
+for (let i = 0; i < 25; i++) {
+  CodeSeconds.push(Mock.mock({
+		secondCodeRow:Mock.Random.string(5),
+		codeRow:Mock.Random.ctitle(1,0) , 
+		dtcodeId:Mock.Random.ctitle(1,2) , 
+		dtcodeName:Mock.Random.ctitle(1,2) , 
+		fp:Mock.Random.ctitle(1,0) , 
+		sp:Mock.Random.ctitle(1,0) , 
+		state:Mock.Random.character('lower') , 
+		deptid:Mock.Random.ctitle(1,0)
+  }));
+}
+
+export { CodeSeconds };

src/mock/mdp/sys/codeSecondMock.js

@@ -0,0 +1,172 @@
+import { CodeSeconds } from './codeSecond';
+let _CodeSeconds = CodeSeconds;
+/**
+ * 拷贝下面两行到 mock/index.js中,即可支持客户端虚拟数据、免服务端连接
+ * import CodeSecondMock from './mdp/sys/codeSecondMock';
+ * CodeSecondMock.bootstrap(mock);
+ */
+export default {
+  /**
+   * mock bootstrap
+   */
+  bootstrap(mock) {    
+  
+    //获取列表 模糊查询、根据关键字查询
+    mock.onGet('/mdp/sys/codeSecond/listKey').reply(config => {
+      let params = config.params;
+      let mockCodeSeconds = _CodeSeconds.filter(codeSecond => {
+      	if(params.secondCodeRow||params.secondCodeRow==''){ if( codeSecond.secondCodeRow.indexOf(params.secondCodeRow)>=0) return true;}
+      	if(params.codeRow||params.codeRow==''){ if( codeSecond.codeRow.indexOf(params.codeRow)>=0) return true;}
+      	if(params.dtcodeId||params.dtcodeId==''){ if( codeSecond.dtcodeId.indexOf(params.dtcodeId)>=0) return true;}
+      	if(params.dtcodeName||params.dtcodeName==''){ if( codeSecond.dtcodeName.indexOf(params.dtcodeName)>=0) return true;}
+      	if(params.fp||params.fp==''){ if( codeSecond.fp.indexOf(params.fp)>=0) return true;}
+      	if(params.sp||params.sp==''){ if( codeSecond.sp.indexOf(params.sp)>=0) return true;}
+      	if(params.state||params.state==''){ if( codeSecond.state.indexOf(params.state)>=0) return true;}
+      	if(params.deptid||params.deptid==''){ if( codeSecond.deptid.indexOf(params.deptid)>=0) return true;}
+        return false;
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            data: mockCodeSeconds
+          }]);
+        }, 1000);
+      });
+    });
+    
+    
+
+    //获取列表（分页/不分页）
+    mock.onGet('/mdp/sys/codeSecond/list').reply(config => {
+      let params = config.params;
+      let mockCodeSeconds = _CodeSeconds.filter(codeSecond => {
+      	var isTrue=false;
+      	if(params.secondCodeRow||params.secondCodeRow==''){if(codeSecond.secondCodeRow.indexOf(params.secondCodeRow)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.codeRow||params.codeRow==''){if(codeSecond.codeRow.indexOf(params.codeRow)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.dtcodeId||params.dtcodeId==''){if(codeSecond.dtcodeId.indexOf(params.dtcodeId)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.dtcodeName||params.dtcodeName==''){if(codeSecond.dtcodeName.indexOf(params.dtcodeName)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.fp||params.fp==''){if(codeSecond.fp.indexOf(params.fp)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.sp||params.sp==''){if(codeSecond.sp.indexOf(params.sp)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.state||params.state==''){if(codeSecond.state.indexOf(params.state)>=0){isTrue=true;}else{isTrue=false;}}
+      	if(params.deptid||params.deptid==''){if(codeSecond.deptid.indexOf(params.deptid)>=0){isTrue=true;}else{isTrue=false;}}
+      	return isTrue;
+	  });
+      if(!config.params.currentPage){ 
+	      return new Promise((resolve, reject) => {
+	        setTimeout(() => {
+	          resolve([200, {
+	            data: mockCodeSeconds
+	          }]);
+	        }, 1000);
+	      });
+      }
+    
+      let {pageSize,currentPage, total} = config.params;
+      total = mockCodeSeconds.length;
+      mockCodeSeconds = mockCodeSeconds.filter((codeSecond, index) => index < pageSize * currentPage && index >= pageSize * (currentPage - 1));
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            pageInfo: {
+            	total:total
+            },
+            data: mockCodeSeconds,
+            tips:{
+            	isOk:true,
+            	msg:'查询成功'
+            }
+          }]);
+        }, 1000);
+      });
+    });
+
+    //删除
+    mock.onPost('/mdp/sys/codeSecond/del').reply(config => {
+      var params = JSON.parse( config.data );
+      let {  secondCodeRow  } = params;
+      _CodeSeconds = _CodeSeconds.filter(codeSecond => codeSecond.secondCodeRow !== secondCodeRow);
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'删除成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //批量删除
+    mock.onPost('/mdp/sys/codeSecond/batchDel').reply(config => {
+      var params = JSON.parse( config.data );
+      _CodeSeconds = _CodeSeconds.filter(codeSecond => !params.includes(codeSecond.secondCodeRow));
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+           tips:{
+            	isOk:true,
+            	msg:'删除成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //编辑
+    mock.onPost('/mdp/sys/codeSecond/edit').reply(config => {
+      var params = JSON.parse( config.data );
+      let { secondCodeRow,codeRow,dtcodeId,dtcodeName,fp,sp,state,deptid } = params;
+      _CodeSeconds.some(codeSecond => {
+        if (codeSecond.secondCodeRow === secondCodeRow) {
+			codeSecond.secondCodeRow = secondCodeRow;
+			codeSecond.codeRow = codeRow;
+			codeSecond.dtcodeId = dtcodeId;
+			codeSecond.dtcodeName = dtcodeName;
+			codeSecond.fp = fp;
+			codeSecond.sp = sp;
+			codeSecond.state = state;
+			codeSecond.deptid = deptid
+          return true;
+        }
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'编辑成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+    //新增
+    mock.onPost('/mdp/sys/codeSecond/add').reply(config => {
+      var params = JSON.parse( config.data );
+      let { secondCodeRow,codeRow,dtcodeId,dtcodeName,fp,sp,state,deptid } = params;
+      _CodeSeconds.push({
+		secondCodeRow:secondCodeRow,
+		codeRow:codeRow,
+		dtcodeId:dtcodeId,
+		dtcodeName:dtcodeName,
+		fp:fp,
+		sp:sp,
+		state:state,
+		deptid:deptid
+      });
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          resolve([200, {
+            tips:{
+            	isOk:true,
+            	msg:'新增成功'
+            }
+          }]);
+        }, 500);
+      });
+    });
+
+  }
+};

src/mock/mdp/sys/company.js

@@ -0,0 +1,17 @@
+ import Mock from 'mockjs';
+
+const Companys = [];
+
+for (let i = 0; i < 25; i++) {
+  Companys.push(Mock.mock({
+		id:Mock.Random.string(5),
+		companyName:Mock.Random.ctitle(1,0) , 
+		districtId:Mock.Random.ctitle(1,0) , 
+		categoryId:Mock.Random.ctitle(1,0) , 
+		phoneNo:Mock.Random.ctitle(1,0) , 
+		orgId:Mock.Random.ctitle(1,0) , 
+		address:Mock.Random.ctitle(1,0)
+  }));
+}
+
+export { Companys };

src/mock/mdp/sys/companyCategory.js

@@ -0,0 +1,13 @@
+ import Mock from 'mockjs';
+
+const CompanyCategorys = [];
+
+for (let i = 0; i < 25; i++) {
+  CompanyCategorys.push(Mock.mock({
+		id:Mock.Random.string(5),
+		categoryName:Mock.Random.ctitle(1,0) , 
+		pid:Mock.Random.ctitle(1,0)
+  }));
+}
+
+export { CompanyCategorys };