miue-ui
Version:
ali miniProgram UI components for vehicle.
288 lines (271 loc) • 7.74 kB
JavaScript
/**
* author:dansion@163.com
* data:2022-04-25
* version:V1.0.0
*
* updata: 2024-05-09: 添加 request task 机制，添加 abort的操作；
*/
const _caches_url=new Map();
const _request_task=new Map();
const _indate= 8640000 * 30; // 缓存7天
//const caches={};
// 将json转化URL格式方
let errorInfo=(code)=>{
switch(code){
case 0:
return {'code':'0','message':'网络数据无效，请稍后重试。'}
break;
case 9:
return {'code':'9','message':'网络请求被取消。'}
break;
case 13:
return {'code':'13','message':'请求网络超时，请检查网络后重试。'}
break;
case 11:
return {'code':'11','message':'请求网络失败，请检查网络后重试。'}
break;
case 12:
return {'code':'12','message':'似乎已断开网络连接，请检查网络后重试。'}
break;
case 14:
return {'code':'14','message':'JSON 解析错误或证书异常。'}
break;
case 404:
return {'code':'404','message':'获取服务器数据错误，请稍后重试。'}
break;
case 500:
return {'code':'500','message':'服务器内部错误，请稍后重试。'}
break;
case 307:
return {'code':'307','message':'网络被重定向，请检查网络后重试。'}
break;
case 3:
return {'code':'20','message':'接口权限鉴权或证书更新失败。'}
break;
case 4:
return {'code':'21','message':'未配置域名白名单'}
break;
case 5:
return {'code':'23','message':'本地RSA加密无效'}
break;
default:
return {'code':'-1','message':'末知错误'}
break;
}
};
// 将URL进行拼接
let jsonToUrlParam=(json)=>{
return Object.keys(json).map(key => key + '=' + json[key]).join('&');
};
// 存置要缓存的URL，
let setUrl=(url)=>{
_caches_url.set(url,true);
return this;
}
//判读url是不是要缓存
let isCaches=(url)=>{
return _caches_url.get(url);
}
// 将URL转化成 本地存储的KEY。
let url2key=(obj)=>{
let {url,method,data,headers}=obj;
let key='';
// 本地存储功能，以URL 作为KEY，POST则在原URL后添加对应 data数据
if(method=='POST'){
key = `${url}?${ jsonToUrlParam(data)}`;
}else{
// get 需要对其它DATA进行处理；
key= `${url}_${ jsonToUrlParam(data)}`;
}
/* 可能loccaStroge 的 key 不支持 冒号的情况。*/
key=key.replace(':','_');
//key=key.replace('http://','http_');
return key;
}
// 以 URL 为作 key，写入数据
let save=(key,data)=>{
let _expired=Date.now()+_indate;
my.setStorage(
{
key:key,
data:{data:data,expired:_expired},
success:()=>{ /** 写入成功 */},
fail:()=>{/** 写入失败 */},
}
)
}
// 读取本地存的数据
let read=(key)=>{
return new Promise((resolve, reject) => {
my.getStorage({
key: key,
success: (res)=> {
let _data=res.data || false; // res.data 不为null,undefined,空
if(_data){
let now=Date.now();
let _expired=_data.expired || false; // _data.expired 不为null,undefined,空
if(_expired && now < _data.expired){
resolve(_data.data);
}else{
reject({code:33,message:'当前URL缓存数据已过期。'});
}
}else{
reject({code:31,message:'本地数据已格式已损坏。'});
}
},
fail: (res)=>{
//读取失败
reject({code:34,message:'当前URL无缓存数据。'});
}
});
})
}
// 获取
let caches= (obj)=>{
let {url,method='POST',data,headers,isSave=true}=obj;
_request(obj)
.then((res)=>{
_caches_url.set(url,true);
})
.catch((error)=>{
_caches_url.set(url,false);
})
return this;
}
// 生成指定长度的随机字符串
let _randomString=(length)=>{
let t='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefhijklmnopqrstuvwxyz1234567890',n=t.length,s='';
for(var i=0;i<length;i++){
s+=t.charAt(Math.floor(Math.random()*n));
}
return s;
}
// 对Obj的进行排序
let _sort2Arr = (data) => {
let arr = []
for(let obj in data) {
arr.push({key : obj, value : data[obj]? data[obj] : ""})
}
arr.sort((o1, o2)=>{
//return o1.key.charCodeAt() - o2.key.charCodeAt();
return String(o1.key).localeCompare(String(o2.key))
})
return arr;
}
//对数组件进行拼序
let _arr2URL = (arr) => {
let _str = "";
for (let idx in arr) {
let interval = _str == "" ? "" : "&";
_str += `${interval}${arr[idx].key}=${arr[idx].value}`
}
return _str;
}
let _queryString=(data)=>{
return _arr2URL(_sort2Arr(data));
}
let _arrToJSON = (arr) => {
let json = {};
for (let idx in arr) {
json[arr[idx].key] = arr[idx].value ;
}
return json;
}
// 发布请求，
let _request = (obj) => {
let {url,method='POST',data,headers,isSave=false,dataType='json',timeout=5000,task=null}=obj;
var _returnPromise = new Promise((resolve, reject) => {
// 如果task存在，则取消task的请求
if(_request_task.has(task) && task!=null){
let temp=_request_task.get(task);
if(temp.abort){
temp.abort();
}
}
var _requestTask = my.request({
url: url,
method: method,
data: data,
timeout: timeout, /* 车机性偏差，弱网处理时间可以放长至5秒 */
dataType: dataType,
headers: headers,
success: (result) => {
try {
if(result.status==307){ // console.warn('网络被重定向，请检侧网络问题！');
reject(errorInfo(307))
}else{
if(isSave){ // 是否写存储
let _key=url2key(obj);
save(_key,result);
}
resolve(result);
}
} catch(e) {
reject(errorInfo(0))
}
},
fail: (err) => {
//console.warn(err.status);
let {error,status}=err;
let code= status || error;
//console.warn('网络返回格式错误，请检查headers是否正确！');
//console.warn(code);
reject(errorInfo(code))
}
});
if(task!=null){
_request_task.set(task,_requestTask);
}
//console.log(_request_task)
});
return _returnPromise;
}
let abort=(task)=>{
if(task){ // 取消指定任务；
let _tempReques=_request_task.get(task);
if(_tempReques.abort){
_tempReques.abort();
}
}else{ // 对所有请求任务都取消操作；
_request_task.forEach((ele,v) => {
if(ele.abort){
ele.abort();
}
});
}
}
// 发起网络请求
let request = (obj) => {
// 默认 enableCache 缓存不开启
// 定义任务
let {enableCache=false}=obj;
let _key=url2key(obj);
var _returnPromise= new Promise((resolve, reject) => {
if(enableCache){ // 开启动本地缓存功能的情况下
read(_key)
.then((res)=>{
resolve(res); // 返回本地存储数据
})
.catch((error)=>{ // 本地存诸读取失败的情况
obj.isSave=true; // 激活本次请求写入逻辑
_request(obj)
.then((res)=>{
resolve(res);
})
.catch((error)=>{
reject(error);
})
}) // 正常返回本地存储数据
}else{ // 不启动本地缓存的情况下。
_request(obj)
.then((res)=>{
resolve(res);
})
.catch((error)=>{
reject(error);
})
}
})
return _returnPromise;
};
export default {request:request,caches:caches,randomString:_randomString,sortToArray:_sort2Arr,arrayToUrl:_arr2URL,queryString:_queryString,arrayToJSON:_arrToJSON,abort:abort}