platform-bi-web/src/models/dataSource.js

import { message } from 'antd'
import * as service from '../services/index'
import URLS from '../constants/url'

export default {
    namespace: 'dataSource',
    state: {
        newOne: {},
        list: [],
        filterLabel: ''
    },
    reducers: {
        list(state, action) {
            let data = action.data;
            return Object.assign({}, state, {list: data});
        },
        add(state, action) {
            let newOne = Object.assign({}, state.newOne);
            let list = state.list;
            newOne.key = new Date().getMilliseconds()+(Math.random()*100).toFixed(0);
            newOne.code = new Date().getMilliseconds()+(Math.random()*100).toFixed(0);
            newOne.creator = 'zhuth';
            newOne.createTime = new Date();
            list.push(newOne);
            return Object.assign({}, state, {list});
        },
        modify(state, action) {
            const { newOne } = state;
            let list = state.list;
            for(let i = 0; i < list.length; i++) {
                if(list[i].code === newOne.code) {
                    list[i] = Object.assign({}, newOne);
                    break;
                }
            }
            return Object.assign({}, state, {list});
        },
        delete(state, action) {
            const { model } = action;
            let { list } = state;
            for(let i = 0; i < list.length; i++) {
                if(list[i].code === model.code) {
                    list.splice(i, 1);
                }
            }
            return Object.assign({}, state, {list});

        },
        setNewModelFields(state, action) {
            const { fields } = action;
            let newOne = state.newOne;
            for(let i = 0; i < fields.length; i++) {
                newOne[fields[i]['name']] = fields[i]['value'];
            }
            let obj = Object.assign({}, state, {newOne});
            return obj;
        },
        setNewModelField(state, action) {
            const { name, value } = action;
            let newOne = state.newOne;
            newOne[name] = value;
            let obj = Object.assign({}, state, {newOne});
            return obj;
        },
        setNewModel(state, action) {
            const { model } = action;
            let newOne = Object.assign({}, model);
            return Object.assign({}, state, {newOne});
        },
        resetNewModel(state, action) {
            return Object.assign({}, state, {newOne: {}});
        },
        setFilterLabel(state, action) {
            const { label } = action;
            return Object.assign({}, state, {filterLabel: label});
        }
    },
    effects: {
        *fetchList(action, { select, call, put, takeEvery, takeLatest }) {
            try {
                const dataSource = yield select(state => state.present.dataSource);
                if(!action.mandatory && dataSource.list.length > 0) {
                    return;
                }
                const res = yield call(service.fetch, {
                    url: URLS.DATASOURCE_LIST,
                    body: {}
                });
                if(!res.err && res.data.code > 0) {
                    let data = res.data.data.map((r, i) => {
                        let dbConfig = JSON.parse(r.dbConfig);
                        let tags = JSON.parse(r.dataTag);
                        return {
                            key: r.dataId,
                            code: r.dataId,
                            name: r.dataName,
                            type: r.type || 'database',
                            dbType: dbConfig.databaseType,
                            creator: r.createBy,
                            createTime: new Date(r.createDate),
                            tags: tags,
                            description: r.note
                        }
                    });
                    yield put({ type: 'list', data });
                }else {
                    message.error('读取数据源列表错误');
                }
            }catch(e) {
                message.error('读取数据源列表错误');
            }
            
        },
        *remoteAdd(action, { select, call, put }) {
            const dataSource = yield select(state => state.present.dataSource);
            const model = dataSource.newOne;
            try {
                const data = {
                    dataName: model.name,
                    note: model.description,
                    loadObject: model.target,
                    dataTag: model.tags,
                    type: model.type,
                    createBy: 'admin',
                    dbConfig: {
                        addrass: model.address,
                        port: model.port,
                        databaseType: model.dbType,
                        dataName: model.dbName,
                        userName: model.userName,
                        passWord: model.password
                    },
                    columnConfig: model.columns.map((c, i) => {
                        return {
                            columnName: c.name,
                            columnLable: c.alias,
                            dataType: c.dataType,
                            columnType: c.columnType,
                            isGroup: c.groupable?'1':'0',
                            isSubsection: c.bucketizable?'1':'0',
                            isOpen: c.using?'1':'0',
                            remarks: c.description
                        }
                    })
                };
                const res = yield call(service.fetch, {
                    url: URLS.DATASOURCE_ADD,
                    body: data
                });
                if(!res.err && res.data.code > 0) {
                    let list = dataSource.list;
                    list.unshift(model);
                    yield put({ type: 'list', data: list });
                    yield put({ type: 'main/redirect', path: { pathname: '/datasource' } });
                    message.success('新增成功!');
                }else {
                    message.error('新增失败!');
                }
            }catch(e) {
                message.error('新增失败!');

            }
        },
        *remoteDetail(action, { select, call, put }) {
            const code = action.code;
            try {
                const res = yield call(service.fetch, {
                    url: URLS.DATASOURCE_DETAIL,
                    body: code
                });
                if(!res.err && res.data.code > 0) {
                    let resData = res.data.data;
                    let columnConfig = JSON.parse(resData.columnConfig);
                    let dbConfig = JSON.parse(resData.dbConfig);
                    let tags = JSON.parse(resData.dataTag);
                    let data = {
                        code: resData.dataId,
                        name: resData.dataName,
                        type: resData.type,
                        dbType: dbConfig.databaseType,
                        dbName: dbConfig.dataName,
                        address: dbConfig.addrass,
                        port: dbConfig.port,
                        target: resData.loadObject,
                        creator: resData.createBy,
                        createTime: new Date(resData.createDate),
                        userName: dbConfig.userName,
                        password: dbConfig.passWord,
                        tags: tags,
                        description: resData.note,
                        columns: columnConfig.map((c, i) => {
                            return {
                                key: i,
                                using: c.isOpen==='1'?true:false,
                                name: c.columnName,
                                alias: c.columnLable,
                                dataType: c.dataType,
                                columnType: c.columnType,
                                groupable: c.isGroup==='1'?true:false,
                                bucketizable: c.isSubsection==='1'?true:false,
                                description: c.remarks
                            }
                        })
                    }
                    yield put({ type: 'setNewModel', model: data });
                }else {
                    message.error('数据源解析错误');
                    console.log(res);
                }
            }catch(e) {
                console.log(e);
                message.error('数据源解析错误');
                yield put({ type: 'list', data: [] });
            }
        },
        *importNewModelColumns(action, { select, call, put }) {
            const dataSource = yield select(state => state.present.dataSource);
            const sqlStr = dataSource.newOne.target;
            const res = yield call(service.fetch, {
                url: URLS.DATASOURCE_QUERY_SQLCOLUMNS,
                body: {
                    "String": sqlStr
                }
            });

            const getColumnType = (dataType) => {
                let columnType = 'string';
                if(dataType === 'VARCHAR2') {
                    columnType = 'categorical';
                }else if(dataType === 'NUMBER') {
                    columnType = 'scale'
                }else if(dataType === 'DATE') {
                    columnType = 'time'
                }else if(dataType === 'NUMBER') {
                    columnType = 'scale'
                }
                return columnType;
            }

            if(!res.err && res.data.code > 0) {
                let columns = res.data.data.map((d, i) => {
                    return {
                        key: i,
                        using: true,
                        name: d.columnName,
                        alias: d.remarks?d.remarks.substring(0, 10):'',
                        dataType: d.columnType,
                        columnType: getColumnType(d.columnType),
                        groupable: d.columnType === 'VARCHAR2',
                        bucketizable: d.columnType === 'NUMBER',
                        description: d.remarks
                    }
                });
                yield put({ type: 'setNewModelField', name: 'columns', value: columns });
            }else {
                yield put({ type: 'setNewModelField', name: 'columns', value: [] });
                message.error('请求数据错误');
            }
        },
        *remoteDelete(action, { select, call, put }) {
            const dataSource = yield select(state => state.present.dataSource);
            const code = action.code;
            let list = dataSource.list;
            try {
                const res = yield call(service.fetch, {
                    url: URLS.DATASOURCE_DELETE,
                    body: [code]
                });
                if(!res.err && res.data.code > 0) {
                    for(let i = 0; i < list.length; i++) {
                        if((list[i].code + '') === (code + '')) {
                            list.splice(i, 1);
                            break;
                        }
                    }
                    yield put({ type: 'list', data: list });
                    message.success('删除成功');
                }else {
                    message.error('删除失败');
                }
            }catch(e) {
                message.error('删除失败');
                console.log(e);
            }
        },
        *remoteModify(action, { select, call, put }) {
            try{
                const dataSource = yield select(state => state.present.dataSource);
                let model = dataSource.newOne;
                const code = action.code;
                let list = dataSource.list;
    
    
                let data = {
                    dataId: code,
                    dataName: model.name,
                    note: model.description,
                    loadObject: model.target,
                    dataTag: model.tags,
                    type: model.type,
                    createBy: 'admin',
                    dbConfig: {
                        addrass: model.address,
                        port: model.port,
                        databaseType: model.dbType,
                        dataName: model.dbName,
                        userName: model.userName,
                        passWord: model.password
                    },
                    columnConfig: model.columns.map((c, i) => {
                        return {
                            columnName: c.name,
                            columnLable: c.alias,
                            dataType: c.dataType,
                            columnType: c.columnType,
                            isGroup: c.groupable?'1':'0',
                            isSubsection: c.bucketizable?'1':'0',
                            isOpen: c.using?'1':'0',
                            remarks: c.description
                        }
                    })
                };
                const res = yield call(service.fetch, {
                    url: URLS.DATASOURCE_UPDATE,
                    body: data
                });
                if(!res.err && res.data.code > 0) {
                    list = list.map(l => {
                        if((l.code + '') === (action.code + '')) {
                            l = model;
                        }
                        return l;
                    });
                    yield put({ type: 'list', data: list });
                    message.success('修改成功');
                }else {
                    message.error('修改失败');
    
                }
            }catch(e) {
                message.error('修改失败');
            }
        }
    },
    subscriptions: {
        setup({ dispatch, history }) {
            return history.listen(({ pathname, query }) => {
                if(pathname === '/datasource' || pathname.match(/chart\/(\w+)/)) {
                    dispatch({ type: 'fetchList' });
                }
                let detail = pathname.match(/datasource\/(\w+)\/(\w+)/);
                if(detail) {
                    if(pathname.match(/datasource\/(\w+)\/(\w+)\/(\w+)/)) {
                        detail = pathname.match(/datasource\/(\w+)\/(\w+)\/(\w+)/);
                        let code = detail[2];
                        if(code !== 'create') {
                            dispatch({ type: 'remoteDetail', code: code })
                        }
                    }else {
                        // 缺省跳转到属性配置tab
                        dispatch({ type: 'main/redirect', path: pathname + (pathname.endsWith('/') ? '' : '/') + 'base' })
                    }
                }
            })
        }
    }
};