form-create-designer-ant/src/utils/index.js

由@form-create/designer修改而来，基于ant design组件

export function makeOptionsRule(to) {
    return {
        type: 'radio',
        title: '选项数据',
        field: '_optionType',
        value: 0,
        options: [
            {'label': '静态数据', 'value': 0},
            {'label': '字典数据', 'value': 1},
        ],
        props: {
            type: 'button'
        },
        control: [
            {
                value: 0,
                rule: [
                    {
                        type: 'Struct',
                        field: 'formCreate'+ upper(to).replace('.', '>'),
                        props: {defaultValue: [{value: '1', label: '选项1'},
                            {value: '2', label: '选项2'}]}
                    },
                ],
            },
            {
                value: 1,
                rule: [
                    {
                        type:'select',
                        field:'formCreateDict'+ upper(to).replace('.', '>'),
                        title:'选择字典项',
                        value:'',
                        options: getDictType(),
                    }
                ]
            }
        ]

    };
}
import axios from 'axios';
import Vue from 'vue';

export const dictOriginDataKey = 'UI_CACHE_DB_DICT_DATA';
export const dictStructDataKey = 'UI_CACHE_DB_DICT_STRUCT_DATA';
export const dictTypeDataKey = 'UI_CACHE_DB_DICT_TYPE_DATA';
export const formSearchUrl = 'http://localhost:8080/biz-table/search';
export const userSearchUrl = 'http://localhost:8080/user/search';
export const formDataSearchUrl = 'http://localhost:8080/biz-table-data/search';
export const fileUploadUrl = ()=>{ return Vue.lsl.get('FILE_UPLOAD_URL')?window._CONFIG['domianURL']+Vue.lsl.get('FILE_UPLOAD_URL'):'http://localhost:8080/file/upload'; };
// export const fileUploadUrl = '/file/upload';
export const requestHeaders = ()=> { return{
    token: Vue.lsl.get('Access-Token')
}; };
export const handleUpload = (callback)=>{
    console.log('handleUpload');
    if(callback)callback();
};

export const fetchForm = ()=>{ return{
    action: formSearchUrl,
    to: 'options',
    method:'POST',
    headers: requestHeaders(),
    data:{},
    dataType:'json',
    parse: (result,rule,fApi)=>{
        Vue.lsl.set('Forms',result);
        let formId = fApi.getValue('formId');
        if(formId){
            let options = getFieldsByFormId(formId);
            fApi.updateRule('labelCol',{options:options});
        }
        return result.data.map(item=>{
            return {
                label: item.formName,
                value: item.id
            };
        });
    },
    onError:(e)=>{
        Vue.prototype['$message'].error('发生错误'+e.message);
    }
}; };

export const getFieldsByFormId = (formId)=>{
    console.log('formid',formId);
    console.log('forms ', Vue.lsl.get('Forms'));
    let options = JSON.parse(Vue.lsl.get('Forms').data.filter((f)=>{
        return f.id == formId;
    })[0].definition).rule.map((r)=>{
        return {
            label: r.title,
            value: r.field,
            id: r.field
        };
    });
    console.log('selectedForm',options);
    return options;
};

export const fetchFormFields = (params)=>{ return{
    action: formSearchUrl,
    to: 'options',
    method:'POST',
    headers: requestHeaders(),
    data:params,
    dataType:'json',
    parse: (result,rule,fApi)=>{
        return result.data.map(item=>{
            return {
                label: item.formName,
                value: item.id
            };
        });
    },
    onError:(e)=>{
        Vue.prototype['$message'].error('发生错误'+e.message);
    }
}; };

export function upper(str) {
    return str.replace(str[0], str[0].toLocaleUpperCase());
}

export function setDictsCache(){
    //return [{label:'dict1',value:['v1','v2']},{label:'dict2',value:['v3','v4']}];
    let cachedDicts = Vue.lsl.get(dictOriginDataKey);
    // console.log('cachedDicts',cachedDicts);
    if(!cachedDicts) return [];
    let newArr = [];
    let dictArr = [];
    cachedDicts.forEach(element => {
        let dictTypeCode = element.typeCode;
        let dictTypeName = element.dictTypeName;
        let containsType = dictArr.filter(item=>item.key==dictTypeCode).length>0;
        if(!containsType){
            dictArr.push({key:dictTypeCode,label:dictTypeName,value:dictTypeCode});
        }
        // console.log('item',element);
        let newArrItem = newArr.filter(item=>item.key==dictTypeCode);
        let contains = newArrItem.length>0;
        // console.log('newArr',newArr);
        let childObj = {key:element.id,value:element.dictCode,label:element.dictName};
        if(contains) 
        {
            // console.log('newArrItem',newArrItem); 
            newArrItem[0].value.push(childObj); 
            // console.log('newArrItem-asfterPush',newArrItem); 
        }
        else
        {
            let parentObj = {key:dictTypeCode,value:[],label:dictTypeName};
            parentObj.value.push(childObj);
            newArr.push(parentObj);
        }
    });
    Vue.lsl.set(dictStructDataKey,newArr);
    Vue.lsl.set(dictTypeDataKey,[...new Set(dictArr)]);
}

export function getDictType(){
    let dictTypeData = Vue.lsl.get(dictTypeDataKey);
    if(!dictTypeData || dictTypeData.length==0) return [];
    return dictTypeData;
}

export function getDictStructData(){
    let dictStructData = Vue.lsl.get(dictStructDataKey);
    if(!dictStructData || dictStructData.length==0) return [];
    return dictStructData;
}

export function getCachedDictData(){
    let dictCachedData = Vue.lsl.get(dictOriginDataKey);
    if(!dictCachedData || dictCachedData.length==0) return [];
    return dictCachedData;
}

export function getDictTypeItems(dictTypeCode){
    let dictStructData = getDictStructData();
    let items = dictStructData.filter(item=>item.key==dictTypeCode);
    
    if(items && items.length>0) return items[0].value;
    return [];
}


export function getUserList(pageIndex,pageSize,params){
    return axios.post(userSearchUrl,Object.assign(params,{pageIndex:pageIndex,pageSize:pageSize}),{headers:requestHeaders()});
}

export function getFromDataList(pageIndex,pageSize,params){
    return axios.post(formDataSearchUrl,Object.assign(params,{pageIndex:pageIndex,pageSize:pageSize}),{headers:requestHeaders()});
}

export function uploadExtentions(){
    return '.jpeg,.jpg,.gif,.png,.pdf,.doc.docx,.xls,.xlsx,.ppt,.pptx,.txt,.7z,.zip,.rar';
}

export function previewSupportFileTypes(){
    return '.jpeg,.jpg,.gif,.png,.pdf';
}


export function downFile(url, parameter, method) {
    return axios({
        url: url,
        method: method ? method :'get',
        data: parameter,
        responseType: 'blob',
        headers:requestHeaders()
    });
}

export function downloadFile(url, fileName, parameter) {
    return downFile(url, parameter).then((data) => {
        let type = data.headers.content-type;
        if (!data.data || data.data.size === 0) {
            Vue.prototype['$message'].warning('文件下载失败');
            return;
        }
        if (typeof window.navigator.msSaveBlob !== 'undefined') {
            window.navigator.msSaveBlob(new Blob([data.data],{type: type}), fileName);
        } else {
            let url = window.URL.createObjectURL(new Blob([data.data],{type: type}));
            let link = document.createElement('a');
            link.style.display = 'none';
            link.href = url;
            link.setAttribute('download', fileName);
            document.body.appendChild(link);
            link.click();
            document.body.removeChild(link); //下载完成移除元素
            window.URL.revokeObjectURL(url); //释放掉blob对象
        }
    });
}