wiz-frameworks
Version:
wizlong react framework
391 lines (350 loc) • 15.9 kB
JavaScript
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; };
/**
*
* Copyright 2017 sgmelearninng
* @author sin
* 动态创建数据管理器
*
*
*/
import { post, get, put, _delete } from '../../request';
var requestUrl = { post: post, get: get, put: put, _delete: _delete };
import { component_tool, utils_tool } from '../../tool';
var WizNotice = component_tool.WizNotice;
var getPropOfObjectByStr = utils_tool.getPropOfObjectByStr,
setPropOfObjectByStr = utils_tool.setPropOfObjectByStr,
Map = utils_tool.Map,
dateUtils = utils_tool.dateUtils;
var createAction = function createAction(type) {
return function (payload) {
return { type: type, payload: payload };
};
};
/*
1、通过定义的业务块，实现对请求的自动处理以及数据绑定。实现model动态创建、卸载
2、需处理动态创建的业务model重复使用情况
3、需处理业务访问出错处理 统一后台接口返回的数据结构
4、考虑补充业务链的处理?(业务链应有可复用的价值 接口不宜处理？)
5、需处理动态model之间的数据关联（事件机制，处理缓存）
6、初始结构可动态配置或api访问
*/
/**
* 动态创建数据模型(数组)
*
* @param {object} dvaApp dva context
* @param {object} businessOpts 模型data数组
*/
export function createModels(dvaApp, businessOpts) {
if (!(businessOpts instanceof Array)) {
throw new Error('businessOpts 数据模型必须为Array');
}
businessOpts.forEach(function (businessModel) {
createBusinessModel(dvaApp, businessModel);
});
}
/**
* 动态创建数据模型（单模型）
*
* @param {object} dvaApp dva context
* @param {object} businessModel 模型data数组
*/
function createBusinessModel(dvaApp) {
var businessModel = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
if (!(businessModel instanceof Object)) {
throw new Error('model \u6570\u636E\u6A21\u578B\u5FC5\u987B\u4E3AObject');
}
validateModels(businessModel); //be_update_flag_by_sin 验证模型是否合法
var model = buildModel(businessModel);
dvaApp.model(model);
}
/**
* 根据指定的数据结构、类型，动态构建Model
*
* @param {object} businessModel 业务模型结构
* @return {object} model 构建成功的model
*/
function buildModel(businessModel) {
// let returnModel = {};
// switch (businessModel.modelType) { // 判断model使用类型是 entity 还是 page 或者 。。。
// case 'entity':
// returnModel = buildEntityModel(businessModel);
// break;
// case 'page':
// returnModel = buildPageModel(businessModel);
// break;
// default:
// returnModel = buildEntityModel(businessModel);
// }
return buildEntityModel(businessModel);
}
/**
* 构建类型为Entity 的Model，可定义initstate、namespace、effects、subscriptions
*
* @param {object} model 单个模型实体
* @return {object} model 构建成功的model
*/
/*
be_update_flag_by_sin
1、缺少对subscriptions的定义
2、缺少effects的默认处理事件（watch、initState...）
3、缺少对操作失败信息详细解析、处理
*/
function buildEntityModel(businessModel) {
var requestConfig = businessModel['requestConfig'];
var entityModel = { //定义model基础信息
namespace: businessModel['businessName'], //model 名
state: Map({ '@default': _extends({}, businessModel['initData'], { '@isDefault': 'Yes', '@namespace': businessModel['businessName'] }) }),
reducers: {
//具体reducer状态管理器
doSuccess: function doSuccess(state, _ref) {
var payload = _ref.payload;
var entityData = getEntityData(state, payload);
var result = _extends({}, entityData, { actionCompleteTime: dateUtils.currentDateStr(), '@payloadKey': payload.key });
return putValue(state, payload.key, result);
},
doError: function doError(state, _ref2) {
var payload = _ref2.payload;
//be_update_flag_by_sin 需处理错误提示信息 考虑是否和执行成功方法合并
var returnValue = getValue(state, payload.defaultEntity, payload.key);
return putValue(state, key, _extends({
returnValue: returnValue
}, payload.result, {
actionCompleteTime: dateUtils.currentDateStr(),
'@payloadKey': payload.key
}));
},
doInit: function doInit(state, _ref3) {
var payload = _ref3.payload;
return deleteValue(state, payload.key);
}
},
effects: {
init: /*#__PURE__*/regeneratorRuntime.mark(function init(_ref4, _ref5) {
var payload = _ref4.payload;
var call = _ref5.call,
put = _ref5.put;
var key;
return regeneratorRuntime.wrap(function init$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
key = payload.key;
_context.next = 3;
return put(createAction('doInit')({ key: key }));
case 3:
case 'end':
return _context.stop();
}
}
}, init, this);
})
// be_update_flag_by_sin
//定义默认的处理事件
}
};
buildEntityModelEffects(businessModel.action, entityModel, businessModel);
return entityModel;
}
/**
* 构建类型为EntityModel 的处理方法
*
* @param {object} action 需要构建的处理方法
* @param {object} model 需要构建的实体Model
*
*/
/*
be_update_flag_by_sin
1、缺少对返回值的验证
2、缺少对api为function的处理
3、验证需要参数是否传入 //已完成
4、构造API请求地址 参数 //完成基础
5、需要指定请求的方式
*/
function buildEntityModelEffects(action, entityModel, businessModel) {
Object.keys(action).forEach(function (method) {
var action_method = action[method];
validateActionMethod(method, action_method, businessModel); //校验action的定义是否正确
entityModel.effects[method] = /*#__PURE__*/regeneratorRuntime.mark(function _callee(_ref6, _ref7) {
var payload = _ref6.payload;
var call = _ref7.call,
put = _ref7.put;
var api, defaultEntity, requestMethod, requestConfig, result, _payload, _key;
return regeneratorRuntime.wrap(function _callee$(_context2) {
while (1) {
switch (_context2.prev = _context2.next) {
case 0:
_context2.prev = 0;
validateActionParams(method, action_method, payload, businessModel);
api = action_method.api;
defaultEntity = _extends({}, businessModel.initData, { '@namespace': businessModel.businessName });
requestMethod = requestUrl.post;
if (action_method.methodType === 'GET') {
requestMethod = requestUrl.get;
} else if (action_method.methodType === 'PUT') {
requestMethod = requestUrl.put;
} else if (action_method.methodType === 'DELETE') {
requestMethod = requestUrl._delete;
}
requestConfig = action_method['requestConfig'];
if (!network()) {
_context2.next = 21;
break;
}
_context2.next = 10;
return call(requestMethod, api, payload.apiParams, requestConfig);
case 10:
result = _context2.sent;
_payload = _extends({}, payload), _key = _payload.key;
if (!result) {
_context2.next = 17;
break;
}
_context2.next = 15;
return put(createAction('doSuccess')({ result: result, defaultEntity: defaultEntity, key: _key }));
case 15:
_context2.next = 19;
break;
case 17:
_context2.next = 19;
return put(createAction('doError')({ defaultEntity: defaultEntity, key: _key }));
case 19:
_context2.next = 22;
break;
case 21:
WizNotice.error('当前网络不可用，请切换网络', 3);
case 22:
_context2.next = 27;
break;
case 24:
_context2.prev = 24;
_context2.t0 = _context2['catch'](0);
// WizNotice.error(`网络出现异常，请稍后再试`, 3);
log.error('\u7CFB\u7EDF\u51FA\u73B0\u5F02\u5E38\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5!Error:' + _context2.t0);
case 27:
case 'end':
return _context2.stop();
}
}
}, _callee, this, [[0, 24]]);
});
});
}
/**
* 验证动态方法必须的参数是否传入
* @param {String} methodKey 方法名
* @param {Object} method 方法对象
* @param {Object} payload 需要校验的对象
* @param {Object} entityModel 校验的基础值
*/
function validateActionParams(methodKey, method, payload, entityModel) {
if (!payload.key || payload.key === '') {
throw new Error('\u8C03\u7528' + entityModel.namespace + '/' + methodKey + ' \u65B9\u6CD5\uFF0Ckey\u503C\u4E3A:' + payload.key);
}
var require_params = method.params;
if (require_params && require_params instanceof Array && require_params.length > 0) {
var apiParams = payload.apiParams;
if (apiParams) {
require_params.forEach(function (field) {
if (!apiParams.hasOwnProperty(field)) {
throw new Error('\u8C03\u7528 ' + entityModel.namespace + '/' + methodKey + ' \u65B9\u6CD5\uFF0CapiParams\u7F3A\u5C11\u5BF9' + field + '\u5B9A\u4E49\u3002\u503C\u4E3A:' + apiParams[field]);
}
});
} else {
throw new Error('\u8C03\u7528' + entityModel.namespace + '/' + methodKey + ' \u65B9\u6CD5\uFF0CapiParams\u503C\u4E3A:' + apiParams);
}
}
}
/**
* 验证模型基础数据是否合法
*
* @param {object} model 单个模型实体
* @return {boolean} flag 验证是否成功
*/
function validateModels(model) {
var businessName = model['businessName'];
if (!model.hasOwnProperty('businessName') || businessName === '') {
throw new Error('\u6570\u636E\u6A21\u578B\u5FC5\u987B\u8BBE\u7F6EbusinessName\u5C5E\u6027\u4EE5\u53CA\u503C,\u5F53\u524D\u503C\u4E3A\uFF1A' + businessName);
}
var action = model.action;
if (action === undefined || !(action instanceof Object)) {
throw new Error(businessName + '\u6570\u636E\u6A21\u578B\u5FC5\u987B\u8BBE\u7F6Eaction\u5C5E\u6027\u4EE5\u53CA\u503C,\u5F53\u524D\u503C\u4E3A\uFF1A' + action);
}
var initData = model['initData'];
if (!model.hasOwnProperty('initData') || !(initData instanceof Object)) {
throw new Error(businessName + '\u6570\u636E\u6A21\u578B\u5FC5\u987B\u8BBE\u7F6E\u6B63\u786E\u7684initData\u503C,\u5F53\u524D\u503C\u4E3A\uFF1A' + initData);
}
return true;
}
/**
* 验证模型Action的设置是否正确
* @param {String} method_name 方法名
* @param {Object} method 方法对象
* @param {Object} model 模型对象
*/
function validateActionMethod(method_name, method, model) {
var namespace = model.namespace;
if (method instanceof Object) {
if (!method.hasOwnProperty('returnField') || method['returnField'] === '') {
throw new Error(namespace + '\u6570\u636E\u6A21\u578B,action\u4E3A' + method_name + '\u4E2DreturnField\u7684\u503C\u672A\u6B63\u786E\u8BBE\u7F6E,\u5F53\u524D\u503C\u4E3A\uFF1A' + method.returnField);
}
if (!method.hasOwnProperty('api') || method['api'] === '') {
throw new Error(namespace + '\u6570\u636E\u6A21\u578B,action\u4E3A' + method_name + '\u4E2DAPI\u7684\u503C\u672A\u6B63\u786E\u8BBE\u7F6E,\u5F53\u524D\u503C\u4E3A\uFF1A' + method.api);
}
if (!method.hasOwnProperty('params') || !(method['params'] instanceof Array)) {
throw new Error(namespace + '\u6570\u636E\u6A21\u578B,action\u4E3A' + method_name + '\u4E2Dparams\u7684\u503C\u5E94\u4E3AArray,\u5F53\u524D\u503C\u4E3A\uFF1A' + method.params);
}
} else {
throw new Error(namespace + '\u6570\u636E\u6A21\u578B\u4E2Daction\u4E3A' + method_name + '\u7684\u503C\u5E94\u4E3AObject\uFF0C\u5F53\u524D\u503C\u4E3A\uFF1A' + method);
}
}
function getValue(stateMap, defaultEntity, key) {
var returnValue = _extends({}, defaultEntity);
if (key && stateMap.has(key)) {
returnValue = stateMap.get(key);
}
return returnValue;
}
function putValue(stateMap, key, value) {
var returnValue = stateMap;
if (key) {
returnValue = stateMap.set(key, value);
}
return returnValue;
}
function deleteValue(stateMap, key) {
var returnValue = stateMap;
if (key) {
returnValue = stateMap['delete'](key);
}
return returnValue;
}
/**
* 获取需要存放在state中entity数据
* @param {Object} state 原状态中数据
* @param {Object} payload 负载中数据（本次加载数据）
* @return {Object} stateEntity数据
*/
function getEntityData(state, payload) {
var data = _extends({}, payload.defaultEntity, payload.result);
if (payload.page && payload.page.field && payload.page.field !== '') {
var preState = getValue(state, payload.defaultEntity, payload.key);
var canLoadMore = true;
if (payload.page.loadMore) {
var field = payload.page.field;
var preStateValue = getPropOfObjectByStr(preState, field);
var resultValue = getPropOfObjectByStr(payload.result, field);
if (preStateValue && preStateValue instanceof Array) {
//当前再次请求的数据不为Array或无数据时,需要将canLoadMore设置微false
if (!(resultValue instanceof Array) || resultValue.length === 0) {
canLoadMore = false;
resultValue = [];
}
setPropOfObjectByStr(data, field, preStateValue.concat(resultValue));
}
}
data = _extends({}, data, { canLoadMore: canLoadMore });
} else if (payload.result instanceof Blob) {
data.result = payload.result;
}
return data;
}