wiz-frameworks/es/framework/index.js

wizlong react framework

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

/**
 * 框架启动方法
 * @author mll
 * @date 2019-9-19
 */

import { component_tool as wizComponents, utils_tool } from '../tool';
var log = utils_tool.log,
    Storage = utils_tool.Storage,
    network = utils_tool.network;

import { ergodicObj, exception, onError, logStorageUtils, templateUtils } from '../utils';
import { registerModels, registerDynamicModels } from '../models';
import createLoading from 'dva-loading';
import dynamic from 'dva/dynamic';
import dva from 'dva';
import createHistory from 'history/createHashHistory';
import React from 'react';
import { Router } from 'dva/router';
import _requestConfig from '../request';
import _request from '../utils/request';
import buildCreateRotues from '../rotues/buildCreateRoutes';
import { action, click, rotue, error } from '../log';
import upload from '../models/upload';
import user from '../models/user';
var WizNotice = wizComponents.WizNotice,
    WizPageLoading = wizComponents.WizPageLoading,
    WizLocaleProvider = wizComponents.WizLocaleProvider,
    zh_CN = wizComponents.zh_CN;


global.rotueHistory = createHistory({
    basename: '/'
});
/**
 * 初始本地化设置，并设置全局数据
 * @param {*} g 
 * @param {*} constants 
 * @param {*} settings 
 */
export function initLocalSetting(_ref) {
    var _ref$g = _ref.g,
        g = _ref$g === undefined ? global : _ref$g,
        _ref$constants = _ref.constants,
        constants = _ref$constants === undefined ? 'constants' : _ref$constants,
        _ref$initLocalSetting = _ref.initLocalSetting,
        initLocalSetting = _ref$initLocalSetting === undefined ? {} : _ref$initLocalSetting;

    g[constants] = {};
    ergodicObj(initLocalSetting, function (obj, key) {
        g[constants][key] = obj[key];
    });
    log.info('config localSetting finish');
}

/**
 * 初始全局的变量
 * 1\注册缓存工具
 * 2\注册全局log方法
 * 3\注册全局提示
 * 4\注册全局网络状态
 */
export function initGlobal(_ref2) {
    var _ref2$g = _ref2.g,
        g = _ref2$g === undefined ? global : _ref2$g,
        _ref2$initGlobal = _ref2.initGlobal,
        initGlobal = _ref2$initGlobal === undefined ? {} : _ref2$initGlobal;

    g.log = log;
    g.storage = Storage;
    g.wizNotice = WizNotice;
    g.network = network.getNetworkState;
    g.networkListerner = network.startNetInfoListerner;
    g.request = _request;
    ergodicObj(initGlobal, function (obj, key) {
        g[key] = obj[key];
    });
    log.info('config global finish');
}

/**
 * 网络监控
 * @param {*} callback 
 */
export function initNetworkInfoListerner(_ref3) {
    var networkCallback = _ref3.networkCallback;

    network.startNetInfoListerner(function (connection) {
        if (connection) {
            if (networkCallback) {
                networkCallback(true);
            } else {
                WizNotice.warn({
                    description: '网络已连接',
                    key: 'networkNotice',
                    message: '网络情况',
                    duration: 3
                });
            }
        } else {
            if (networkCallback) {
                networkCallback(false);
            } else {
                WizNotice.error({
                    description: '当前网络不可用，请切换网络',
                    key: 'networkNotice',
                    message: '网络错误',
                    duration: null
                });
            }
        }
    });
    log.info('config networkInfoListerner finish');
}

/**
 * 初始化redeux模型
 * @param {*} app 
 * @param {*} {models,appDevModels} 
 */
export function initReduxFramework(app, _ref4) {
    var models = _ref4.models,
        appDevModels = _ref4.appDevModels;


    // 注册全局模型
    var _models = models ? [].concat(_toConsumableArray(models), [upload, user]) : [upload, user];
    registerModels(app, _models);
    // 注册动态模型
    registerDynamicModels(app, appDevModels);

    !models && !appDevModels ? log.warn('config reduxFramework:未传入rudex数据模型') : log.info('config reduxFramework finish');
}

/**
 * 初始化插件
 * @param {*} app 
 * @param {*} {use}
 */
export function initPlugIn(app, _ref5) {
    var _ref5$use = _ref5.use,
        use = _ref5$use === undefined ? [] : _ref5$use;

    app.use(createLoading());
    app.use({ onError: exception });
    use.forEach(function (u) {
        app.use(u);
    });
    log.info('config Plug-in finish');
}

/**
 * 初始化请求
 * @param {*} {request,requestConfig} 
 */
export function initRequest(_ref6) {
    var _ref6$request = _ref6.request,
        request = _ref6$request === undefined ? _request : _ref6$request,
        _ref6$requestConfig = _ref6.requestConfig,
        requestConfig = _ref6$requestConfig === undefined ? _requestConfig : _ref6$requestConfig;

    requestConfig.headers.endpoint = global.endpoint || 'admin';
    request.config(requestConfig);
    log.info('config request finish');
}

/**
 * 初始化路由
 * @param {*} app
 * @param {*} {router,createRoutes}
 */
export function initRoutes(app, _ref7) {
    var router = _ref7.router,
        createRoutes = _ref7.createRoutes;

    var f = true;
    if (router) {
        app.router(router);
    } else if (createRoutes) {
        app.router(function (_ref8) {
            var history = _ref8.history,
                app = _ref8.app;
            return React.createElement(
                WizLocaleProvider,
                { locale: zh_CN },
                React.createElement(
                    Router,
                    { history: history },
                    buildCreateRotues(app, createRoutes)
                )
            );
        });
    } else {
        f = false;
    }
    f ? log.info('config routes finish') : onError('config routes:请传入 <路由:router> 或者 设置<路由参数:createRoutes>');
}

/**
 * 初始化动态模型loading
 * @param {*} {pageLoading} 
 */
export function initDynamicLoading(_ref9) {
    var pageLoading = _ref9.pageLoading;

    dynamic.setDefaultLoadingComponent(pageLoading || function () {
        return React.createElement(WizPageLoading, { loading: true });
    });
    log.info('config dynamicLoading finish');
}

/**
 * 初始化记录日志
 * @param {*} app 
 * @param {*} {recodeLog} 
 * click日志记录方式
 * 1、通过传值  例：recodeLogParams.clickNeedRecord : ['a','button'] ,会自动记录 a标签和button标签的日志
 * 2、通过'data-wiz-log'标示 例: <div data-wiz-log>点击我会被记录</div>
 */
export function initRecodeLog(app, _ref10) {
    var _ref10$recodeLog = _ref10.recodeLog,
        recodeLog = _ref10$recodeLog === undefined ? true : _ref10$recodeLog,
        _ref10$recodeLogParam = _ref10.recodeLogParams,
        recodeLogParams = _ref10$recodeLogParam === undefined ? {} : _ref10$recodeLogParam;

    //用户行为日志
    logStorageUtils.setKey(recodeLogParams['userLogKey'] ? recodeLogParams['userLogKey'] : 'wiz-frameworks-user-log');
    if (recodeLog) {
        //暂时不使用记录action的日志
        //app.use(action);
        app.model(rotue);
        click && click(recodeLogParams['clickNeedRecord']);
        log.info('config recodeLog finish');
    } else {
        log.warn('recode log not enabled');
    }
    //系统日志
    error && error(recodeLogParams['sysLogKey']);
}

/**
 * 初始化动态模型loading
 * @param {*} {pageLoading} 
 */
export function initTemplateComponent(_ref11) {
    var templates = _ref11.templates;

    var form = wizComponents;
    templates && _extends(form, templates);
    templateUtils.setTemplates(form);
    log.info('config template component finish');
}

/**
 * 项目启动方法
 * @param {*} settings
 */
export function init() {
    var settings = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

    log.warn('framework start loading');
    var storageKey = settings['storageKey'] ? settings['storageKey'] : 'wiz-frameworks';
    Storage.setKey(storageKey);
    var app = settings.app || dva({
        history: rotueHistory
    });
    // -> 本地设置
    initLocalSetting(settings);
    // -> 全局变量
    initGlobal(settings);
    // -> 网络检查
    initNetworkInfoListerner(settings);
    // -> 数据模型
    initReduxFramework(app, settings);
    // -> 插件
    initPlugIn(app, settings);
    // -> 请求
    initRequest(settings);
    // -> loading
    initDynamicLoading(settings);
    // -> 记录日志
    initRecodeLog(app, settings);
    // -> 初始化路由
    initRoutes(app, settings);
    // -> 初始化模版组件
    initTemplateComponent(settings);
    // -> Start
    app.start('#root');
    log.warn('framework loading success');
    return {
        app: app,
        store: app._store,
        dispatch: app._store.dispatch
    };
}

export default (function (e) {
    return init(e);
});