xntalk / xntalk-rnapp

// 获取门店的地址信息
import {Dimensions, NativeModules, Platform, StatusBar} from "react-native";
import Toast from 'react-native-root-toast';
import {zoomH} from './ScreenUtil';
import moment from 'moment';
import {observable} from "mobx";

export function getShopAddressInfo(shop) {
    if (!!shop && !!shop.shopLocation) {
        let shopLocation = shop.shopLocation;
        return shopLocation.cityName + shopLocation.districtName + shopLocation.street + shopLocation.number;
    }
    return "";
}

// 往门店打电话
export function callShop(shop) {
    if (!!shop.shopPhone) {
        NativeModules.system.call(shop.shopPhone);
    } else {
        xnToast('暂无该门店联系电话!');
    }
}

// 重设预约模型
export function resetRevervationrModel(shop) {
    global.revervationModel = {
        'shopId': shop.id,
        'dinnerTypeId': '',
        'reservationDate': '',
        'timeType': '',
        'name': '',
        'phone': '',
        'planTables': '',
        'planTableIds': '',
        'arrivalTime': '',
        'status': '',
        'sex': '',
        'peoples': '',
        'description': '',
    }
}

// 提交新预约
export function submitNewRevervation() {
    var result = revervationModelNecessaryCheck();
    if (result != 'OK') {
        xnToast(result);
        return 'NG';
    }
    // 手机check
    var result = phoneCheck(global.revervationModel['phone']);
    if (result != 'OK') {
        xnToast(result);
        return 'NG';
    }
    // 预约时间业务check，不能预约"当前时间以前的市"
    // 1.是否是当天预约
    // 2.预约时间是否已经过了当前时间
    let now = new Date();
    let bookDate = timeStringToDate(global.revervationModel['reservationDate']);
    if (bookDate == '') {
        xnToast('【订座日期】异常，请重新预约');
        return NG;
    }

    if (bookDate.format('yyyy-MM-dd') == now.format('yyyy-MM-dd')) {
        // 是当天
        let arriveTimeDate = timeStringToDate(global.revervationModel['arrivalTime']);
        if (arriveTimeDate == '') {
            xnToast('【到店时间】异常，请重新预约');
            return NG;
        }
        let arriveTime = arriveTimeDate.format('hh:mm');
        let current = now.format('hh:mm');
        if (current >= arriveTime) {
            xnToast('预约时间已过，请重新预约');
            return 'NG';
        }
    }

    // 人数check???


    return 'OK';

}

export function phoneCheck(phone) {
    if (phone.length != 11) {
        return '【手机】位数必须为11位';
    }
    return 'OK';
    // if(/^[0-9]+$/.test(phone)){
    //     return 'OK';
    // }else{
    //     return '【手机】必须为纯数字'
    // }
}

// 预约模型必须入力项目check
export function revervationModelNecessaryCheck() {
    if (global.revervationModel['shopId'] == '') {
        return '请选择【门店】';
    }
    // 订座日期
    if (global.revervationModel['reservationDate'] == '') {
        return '请选择【订座日期】';
    }
    // 订座时段
    if (global.revervationModel['timeType'] == '') {
        return '请选择【订座时段】';
    }
    // 姓名
    if (global.revervationModel['name'] == '') {
        result = '请填写【姓名】';
        return result;
    }
    // 手机
    if (global.revervationModel['phone'] == '') {
        return '请填写【手机】';
    }
    // 人数
    if (global.revervationModel['peoples'] == '') {
        return '请填写【人数】';
    }
    // 到店时间
    if (global.revervationModel['arrivalTime'] == '') {
        return '请选择【到店时间】';
    }
    // 根据桌数作为触发是否选择了桌型的判断
    if (global.revervationModel['planTables'] == '') {
        return '请选择【桌台】';
    }
    return 'OK';
}

// 全局时段模型初始化
export function resetDateTimeSection() {
    global.dateTimeSectionString = ['早市', '午市', '晚市'];
    global.dateTimeSectionIndex = ['MORNING', 'NOONING', 'EVENING'];
}

export function setDateTimeSection(reservationRule) {
    if (!!reservationRule) {
        global.dateTimeSectionString = [];
        global.dateTimeSectionIndex = [];
        global.arrivalTimeSectionByTimeType = [];
        if (!!reservationRule.isOpenMorning == true) {
            global.dateTimeSectionString.push('早市');
            global.dateTimeSectionIndex.push('MORNING');
            global.arrivalTimeSectionByTimeType.push(global.arrivalTimeSectionMoning);
        }
        if (!!reservationRule.isOpenNooning == true) {
            global.dateTimeSectionString.push('午市');
            global.dateTimeSectionIndex.push('NOONING');
            global.arrivalTimeSectionByTimeType.push(global.arrivalTimeSectionAfternoon);
        }
        if (!!reservationRule.isOpenEveing == true) {
            global.dateTimeSectionString.push('晚市');
            global.dateTimeSectionIndex.push('EVENING');
            global.arrivalTimeSectionByTimeType.push(global.arrivalTimeSectionEvening);
        }
    }
}

// 全局性别模型初始化
export function resetGenderSection() {
    global.genderTypeSectionString = ['先生', '女士'];
    global.genderTypeSectionIndex = [1, 0];
}

// 全局性别模型初始化
export function getGenderString(key) {
    var gender = '';
    if (global.genderTypeSectionIndex.indexOf(key) != -1) {
        gender = global.genderTypeSectionString[global.genderTypeSectionIndex.indexOf(key)];
    }
    return gender;
}

// 初始化全局业务模型
export function resetGlobalBusinessModel() {
    resetDateTimeSection();
    resetGenderSection();
    resetArrailTimeSection();
    resetDinnerTypeSection();
    resetRevervationStatus();
}

// 初始化订餐类型
export function resetDinnerTypeSection() {
    global.dinnerTypeSectionString = ['普通预约', '宴会预约'];
    global.dinnerTypeSectionIndex = ['CASUAL', 'PARTY'];
}

// 初始化预约状态
export function resetRevervationStatus() {
    global.revervationStatusString = ['待确认', '已确认', '已退订', '已入座', '已取消', '空闲'];
    global.revervationStatusIndex = ['TO_CONFIRM', 'CONFIRMED', 'UNSUBCRIBED', 'SEATED', 'CANCELLED', 'FREE'];
}

// 初始化可选预计到达时间
export function resetArrailTimeSection() {
    /*
    到达时间根据市别来判断（每15分钟一个时间）

早市时间：09:00-11:30

午市时间：11:31-16:30

晚市时间：16:31-22:30
     */
    global.arrivalTimeSectionMoning = createTimeListBy15Minute('09', '00', '11', '30');
    global.arrivalTimeSectionAfternoon = createTimeListBy15Minute('11', '30', '16', '30');
    global.arrivalTimeSectionEvening = createTimeListBy15Minute(16, 30, 22, 30);
    global.arrivalTimeSectionByTimeType = [];
    global.arrivalTimeSectionByTimeType.push(global.arrivalTimeSectionMoning);
    global.arrivalTimeSectionByTimeType.push(global.arrivalTimeSectionAfternoon);
    global.arrivalTimeSectionByTimeType.push(global.arrivalTimeSectionEvening);
}

// 根据订座时段计算可选的到达时间
function createTimeListBy15Minute(begingHH, beginMM, endHH, endMM) {
    let output = [];
    let myDate = new Date();
    let maxDate = new Date();
    myDate.setHours(begingHH);
    myDate.setMinutes(beginMM);
    maxDate.setHours(endHH);
    maxDate.setMinutes(endMM);
    let loop = true;
    output.push(myDate.format('hh:mm'));
    // console.log(myDate.format('hh:mm'));
    while (loop) {
        myDate = new Date(myDate.getTime() + 15 * 60 * 1000);
        if (myDate.getTime() <= maxDate.getTime()) {
            output.push(myDate.format('hh:mm'));
            // console.log(myDate.format('hh:mm'));
        } else {
            loop = false;
        }
    }
    return output;
}

// 根据传入的天数N创建从当前日期到离当前日期+天数N之间的天数
export function createDaySection(dayDelta, dateFormat) {
    let output = [];
    // let myDate = new Date();
    let cursorDate = new Date();
    output.push(cursorDate.format(dateFormat));
    for (let loop = 0; loop < dayDelta; loop++) {
        cursorDate = new Date(cursorDate.getTime() + 24 * 60 * 60 * 1000);
        output.push(cursorDate.format(dateFormat));
    }
    return output;
}

// 左右trim
export function trim(str) { //删除左右两端的空格
    return str.toString().replace(/(^\s*)|(\s*$)/g, "");
}

// 左trim
export function ltrim(str) { //删除左边的空格
    return str.toString().replace(/(^\s*)/g, "");
}

// 右trim
export function rtrim(str) { //删除右边的空格
    return str.toString().replace(/(\s*$)/g, "");
}

// 预约人姓名check 必填+最多20字
export function checkBookingName(content, itemTitle) {
    let test = trim(content);
    if (test.length == 0) {
        xnToast('请填写【' + itemTitle + '】');
        return false;
    }
    if (test.length > 20) {
        xnToast('【姓名】最多只允许20个字');
        return false;
    }
    return true;
}

// 预约人联系方式check 必填+纯数字+11位
export function checkBookingPhone(content, itemTitle) {
    let test = trim(content);
    if (test.length == 0) {
        xnToast('请填写【' + itemTitle + '】');
        return false;
    }
    if (/^[0-9]+$/.test(test)) {

    } else {
        xnToast('【' + itemTitle + '】必须为纯数字');
        return false
    }
    if (test.length != 11) {
        xnToast('【' + itemTitle + '】位数必须为11位');
        return false;
    }
    return true;

}

// 预约就餐人数check 必填+纯数字+最多9999
export function checkBookingPeoples(content, itemTitle) {
    let test = trim(content);
    if (test.length == 0) {
        xnToast('请填写【' + itemTitle + '】');
        return false;
    }
    if (test.length > 9999) {
        xnToast('【' + itemTitle + '】最多只允许9999位');
        return false;
    }
    return true;
}

// 预约备注信息check 最多300字
export function checkBookingDescription(content, itemTitle) {
    let test = trim(content);
    if (test.length > 300) {
        xnToast('【' + content + '】最多只允许300个字');
        return false;
    }
    return true;
}

// 退订原因信息check 必填+最多100字
export function checkBookingReturnReason(content, itemTitle) {
    let test = trim(content);
    if (test.length == 0) {
        xnToast('*请输入【' + itemTitle + '】');
        return false;
    }
    if (test.length > 100) {
        xnToast('*【' + itemTitle + '】最多只允许输入100字');
        return false;
    }
    return true;
}

export function timeStampToDateString(timestamp, needTime) {
    if (/^[0-9]+$/.test(timestamp)) {
        timestamp = parseInt(timestamp);
        if (timestamp.length == 10) {
            timestamp = timestamp * 1000;
        }
        var d = new Date(timestamp);    //根据时间戳生成的时间对象
        var date = d.format('yyyy-MM-dd');
        if (needTime) {
            date = date + ' ' + d.format('hh:mm').toString();
        }
        return date;
    } else {
        return '';
    }
}

export function timeStampToFullString(timestamp) {
    if (/^[0-9]+$/.test(timestamp)) {
        timestamp = parseInt(timestamp);
        if (timestamp.length == 10) {
            timestamp = timestamp * 1000;
        }
        var d = new Date(timestamp);    //根据时间戳生成的时间对象
        var date = d.format('yyyy-MM-dd');
        date = date + ' ' + d.format('hh:mm:ss').toString();
        return date;
    } else {
        return '';
    }
}

export function timeStringToDate(timeString) {
    // 只支持yyyy-MM-dd hh:mm:ss格式
    let date = '';
    if (!!!timeString) {
        return date;
    }
    let arr1 = timeString.split(" ");
    if (arr1.length != 2) {
        return date;
    }
    let sdate = arr1[0].split('-');
    if (sdate.length != 3) {
        return date;
    }
    let stime = arr1[1].split(':');
    if (stime.length != 3) {
        return date;
    }
    date = new Date(sdate[0], sdate[1] - 1, sdate[2], stime[0], stime[1], stime[2]);
    return date;
}

export function showLocation(inputLatitude, inputLongitude, inputAddress) {
    let latitude = inputLatitude;
    let longitude = inputLongitude;
    if (typeof (inputLatitude) == 'string') {
        latitude = parseFloat(inputLatitude);
    }
    if (typeof (inputLongitude) == 'string') {
        longitude = parseFloat(inputLongitude);
    }
    NativeModules.system.AMap_ShowLoacationByInput(latitude, longitude, inputAddress).then(data => {
        // 无返回
    });
}

//是否 isIphoneX
export function isIphoneX() {
    let dimen = Dimensions.get('window');
    return (
        Platform.OS === 'ios' &&
        !Platform.isPad &&
        !Platform.isTVOS &&
        (dimen.height >= 812 || dimen.width >= 812)
    );
}

// textAlignVerti在ios下是无效的，需要使用lineHeight
export function getTextAlignVerticalStyle(iosLineHeight) {
    return (Platform.OS == 'android') ? ({textAlignVertical: 'center'}) : ({lineHeight: iosLineHeight});
}

//设置头部填充高度
export function getHeaderHeight() {
    if (Platform.OS === 'android') {
        return (48 / zoomH);
    } else if (Platform.OS === 'ios') {
        if (isIphoneX()) {
            // return (88);
            return (64);
        } else {
            return (64);
        }
    }
}

//设置头部上边距
export function getHeaderPadding() {
    return 0;
    // if( Platform.OS === 'android'){
    //     return 0;
    // }else if(Platform.OS === 'ios'){
    //     if(isIphoneX()){
    //         return (44);
    //     }else {
    //         return (20);
    //     }
    // }
}

//设置底部填充高度
export function getFooterBottom() {
    if (Platform.OS === 'android') {
        return 0;
    } else if (Platform.OS === 'ios') {
        if (isIphoneX()) {
            return 34;
        } else {
            return 0;
        }
    }
}

/*获取头部整体高度*/
export function getTopHeight() {
    if (Platform.OS === 'android') {
        return (48 / zoomH);
    } else if (Platform.OS === 'ios') {
        if (isIphoneX()) {
            return 88;
        } else {
            return 64;
        }
    }
}

/*获取状态栏高度*/
export function getStatusBarHeight() {
    if (Platform.OS === 'android') {
        return StatusBar.currentHeight;
    } else if (Platform.OS === 'ios') {
        if (isIphoneX()) {
            return 88;
        } else {
            return 64;
        }
    }
}

//Toast
export const xnToast = (content) => {

    setTimeout(() => {
        if (global.toast !== undefined) {
            Toast.hide(toast);
        }
        global.toast = Toast.show(content.toString(), {
            duration: Toast.durations.LONG,
            position: Toast.positions.CENTER,
            shadow: true,
            animation: true,
            hideOnPress: true,
            delay: 0
        });
    }, 500);
};

//剩余时间计算
export function spareTime(endTime) {
    let leaveTime = '';
    let distanceTime = endTime - Number(new Date());
    let days = parseInt(distanceTime / (1000 * 60 * 60 * 24));
    let hours = parseInt((distanceTime % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
    let minutes = Math.round((distanceTime % (1000 * 60 * 60)) / (1000 * 60));
    if (days > 0) {
        leaveTime = leaveTime + days + '天';
    }
    if (hours > 0) {
        leaveTime = leaveTime + hours + '小时';
    }
    if (minutes > 0) {
        leaveTime = leaveTime + minutes + '分';
    }
    if (leaveTime.length == 0) {
        leaveTime = '0分'
    }
    return leaveTime;
}

//录音时间装换
export function formatTime(seconds) {
    let second = [
        parseInt(seconds / 60 % 60),
        parseInt(seconds % 60)
    ].join(":").replace(/\b(\d)\b/g, "0$1");
    console.log(second);
    return second;
}
//防止按钮多次触发
export const NoDoublePress = {
    lastPressTime: 1,
    onPress(callback) {
        let curTime = new Date().getTime();
        if (curTime - this.lastPressTime > 500) {
            this.lastPressTime = curTime;
            callback();
        }
    },
};

//时间转换 ：1小时内，展示N分钟前；1小时外还在当天，展示N小时前；超过当天，展示月-日
export function changeTime(time) {
    let result = '';
    let arr = time.split(':');
    if (arr[0] == moment(Number(new Date())).format('YYYY-MM-DD')) {
        result = result + '今天';
    } else {
        result = result + arr[0].substring(5)
    }
    switch (arr[1]) {
        case 'Monday':
            result = result + '  星期一';
            break;
        case 'Tuesday':
            result = result + '  星期二';
            break;
        case 'Wednesday':
            result = result + '  星期三';
            break;
        case 'Thursday':
            result = result + '  星期四';
            break;
        case 'Friday':
            result = result + '  星期五';
            break;
        case 'Saturday':
            result = result + '  星期六';
            break;
        case 'Sunday':
            result = result + '  星期日';
            break;
    }
    return result;
}

/**
 * 时间转换 ：1小时内，展示N分钟前；1小时外还在当天，展示N小时前；超过当天，展示月-日
 * @param dataMill :毫秒数
 */

export function dateToMsgTime(dataMill) {

    const dataString = moment(Number(dataMill)).format('YYYY-MM-DD HH:mm:ss');
    const now = new Date();
    const nowTimeSpan = now.getTime();
    const oldTimeSpan = dataMill;
    let result = '';
    const milliseconds = nowTimeSpan - oldTimeSpan;
    if (milliseconds <= 1000 * 60 * 1) {
        result = '刚刚';
    } else if (1000 * 60 * 1 < milliseconds && milliseconds <= 1000 * 60 * 60) {
        result = `${Math.round((milliseconds / (1000 * 60)))}分钟前`;
    } else if (1000 * 60 * 60 * 1 < milliseconds && milliseconds <= 1000 * 60 * 60 * 24) {
        result = `${Math.round(milliseconds / (1000 * 60 * 60))}小时前`;
    }
        // else if(1000 * 60 * 60 * 24 < milliseconds && milliseconds <= 1000 * 60 * 60 * 24 * 2) {
        //     result = `一天前${dataString.substr(11,5)}`;
        // }else if(1000 * 60 * 60 * 24*2 < milliseconds && milliseconds <= 1000 * 60 * 60 * 24 * 3) {
        //     result = `两天前${dataString.substr(11,5)}`;
    // }
    else {
        result = dataString.substr(5, 5);
    }
    return result;
}

//粉丝数目转化文本
export function conversionNumber(number) {
    let result = '';
    if (number == undefined) {
        result = '0粉丝';
    } else if (number < 1000) {
        result = number + '粉丝';
    } else if (1000 < number < 9999) {
        result = number / 1000 + '千粉丝';
    } else if (9999 < number) {
        result = number / 10000 + '万粉丝';
    }

    return result;
}

//类型转化文本
export function memberTypeConversion(type) {

    let result = '';

    switch (type) {
        case 'EMPLOYEE':
            result = '';
            break;
        case 'CUSTOMER':
            result = '游客';
            break;
        case 'PARNER':
            result = '伙伴';
            break;
        case 'MEMBER':
            result = '会员';
            break;
        case 'NONE':
            result = '';
            break;
        case 'SUPPLIER':
            result = '';
            break;
        case 'ISV':
            result = '';
            break;
    }

    return result;
}

// 获取主题色
export function getHomeColor() {
    if (global.homeColor == undefined) {
        // #8A0886 紫色测试
        global.homeColor = "#3399ff";
        return String(global.homeColor);
    } else {
        return String(global.homeColor);
    }
}

// 获取app传入的配置参数，这个方法只需要调用一次
export async function getConfigTheme() {
    try {
        var result = await NativeModules.system.configTheme();
        global.isNew = true;
        global.role = (JSON.parse(result).role || "").toString();
        global.homeColor = (JSON.parse(result).themeColor || "#3399ff").toString();
        global.weChatBySmallProgramAppId = (JSON.parse(result).WeChatBySmallProgramAppId || "").toString();
        if (Platform.OS === 'ios') {
            global.showWchatShare = JSON.parse(result).showWchatShare || false;
        } else {
            global.showWchatShare = JSON.parse(result).showWchatShare || false;
        }
        // 是否是导航进入
        global.navigateMode = JSON.parse(result).navigateMode || false;
        if (global.navigateMode === 'true' || global.navigateMode == true) {
            global.navigateMode = true;
        } else {
            global.navigateMode = false;
        }
        // app分支，默认配置为测试环境
        global.appTarget = (JSON.parse(result).appTarget || "xntalkTest").toString();

    } catch (e) {
        global.isNew = false;
        // #8A0886 紫色测试
        global.homeColor = "#3399ff";
        global.showWchatShare = false;
        global.navigateMode = false;
    } finally {
        console.log('getConfigTheme 完成！！！');
        console.log(global.appTarget);
        console.log('-----------------------');
        console.log(global);
    }
}

// 获取角色
export function getRole() {
    if (global.role == undefined || global.role == "") {
        return null;
    } else {
        return String(global.role);
    }
}

// 字符串排序,不传rev默认升序
export function sortBy(attr, rev) {
    //第二个参数没有传递 默认升序排列
    if (rev == undefined) {
        rev = 1;
    } else {
        rev = (rev) ? 1 : -1;
    }

    return function (a, b) {
        a = a[attr];
        b = b[attr];
        if (a < b) {
            return rev * -1;
        }
        if (a > b) {
            return rev * 1;
        }
        return 0;
    }
}

//获取当天时间并格式化
export const getDate = () => {
    let d = new Date();
    let m = d.getMonth() + 1;
    if (m < 10) {
        m = '0' + m.toString()
    }
    let str = d.getFullYear().toString() + m + d.getDate().toString();
    return str
};

//格式化时间
export const subString = str => {
    let _y = '', _m = '', _d = '';
    _y = str.substring(0, 4);
    _m = str.substring(4, 6);
    _d = str.substring(6, 8);
    return (_y + '/' + _m + '/' + _d)

};
//格式化时间
export const timeClear = str => {
    let _t = '';
    str.split('-').forEach((i) => {
        _t = _t + i.toString()
    });
    return _t
};

export const getLocalDate = (timestamp) => {
    "use strict";
    let now = new Date();
    // 东8区时区偏差
    let date = new Date(Number(timestamp) + 8 * 3600000);

    if (now.getYear() === date.getYear()) {
        if (now.getMonth() === date.getMonth()) {
            if (now.getDate() === date.getDate()) {
                return "今天" + date.getHours() + ":" + date.getMinutes();
            } else if (now.getDate() - 1 === date.getDate()) {
                return "昨天" + date.getHours() + ":" + date.getMinutes();
            } else if (now.getDate() - 2 === date.getDate()) {
                return "前天" + date.getHours() + ":" + date.getMinutes();
            }
        }
        return (date.getMonth() + 1) + "月" + date.getDate() + "日";
    }
    return date.getFullYear() + "年" + (date.getMonth() + 1) + "月" + date.getDate() + "日";
};

//获取周几
export const getWeek = str => {
    let week = new Date(str).getDay();
    console.log(week);
    switch (week) {
        case 1:
            week = "周一";
            break;
        case 2:
            week = "周二";
            break;
        case 3:
            week = "三";
            break;
        case 4:
            week = "周四";
            break;
        case 5:
            week = "周五";
            break;
        case 6:
            week = "周六";
            break;
        case 7:
            week = "周日";
            break;
    }
    return week;
}
export const musicData = observable({
    uri: null,
    music: null,
    currentTime: null
});

export async function setValue(x) {
    musicData.uri = x.pictureUrl;
    musicData.music = x.radioUrl;
    // musicData.currentTime = x.currentTime;
    // const musicData1 = JSON.stringify(musicData);
    // await AsyncStorage.setItem('musicData', musicData1)

}

// 用于调试时打印当前时间
export function logCurrentTime(tag) {
    let date = new Date();
    console.log("【LOG】当前时间,TAG=" + '<' + tag + '>:' + date.format('yyyy-MM-dd hh:mm:ss') + ":" + date.getMilliseconds().toString());
}

export function openTicketRNByUrl(url) {
    let params = url.split('&');
    for (let index = 0; index < params.length; index++) {
        let param = params[index];
        if (param.indexOf('businessId') != -1) {
            let ticketId = param.replace('businessId=', '');
            if (!!ticketId) {
                let url = "xntalk://rnapp.open/TicketRN?ticketId=" + ticketId + "&target=TicketDetail&tenantId=" + global.tenantId;
                // 按照首页消息的方式来跳转
                NativeModules.system.openRnAppByParseUrl(url);
            }
        }
    }
    // if(!!params('businessId')){
    //     NativeModules.system.openRnApp1("xntalk://rnapp.open/TicketRN?ticketId=1236915174452105216&target=TicketDetail&tenantId=1074866838477082624");
    // NativeModules.system.loadOntherRN('TicketRN','?');
    // }
}

export function openTicketRNByBusinessId(businessId) {
    let ticketId = businessId;
    if (!!ticketId) {
        let url = "xntalk://rnapp.open/TicketRN?ticketId=" + ticketId + "&target=TicketDetail&tenantId=" + global.tenantId;
        // 按照首页消息的方式来跳转
        NativeModules.system.openRnAppByParseUrl(url);
    }
    // if(!!params('businessId')){
    //     NativeModules.system.openRnApp1("xntalk://rnapp.open/TicketRN?ticketId=1236915174452105216&target=TicketDetail&tenantId=1074866838477082624");
    // NativeModules.system.loadOntherRN('TicketRN','?');
    // }
}


// 统一判断请求是否存在业务错误,支持统一显示错误
export function onResponseError(data, needShowError) {
    if (!!data.message) {
        needShowError && xnToast(data.message);
        return true;
    }
    if (!!data.errors && data.errors.length > 0) {
        if (needShowError) {
            if (!!data.errors[0] && !!data.errors[0].message) {
                xnToast(data.errors[0].message);
                return true;
            }
            xnToast("请求出错");
        }
        return true;
    }
    // 正常的请求，会返回一个空的erros,这里我们判断如果没有errors，也作为错误来处理
    if (!!!data.errors) {
        xnToast("请求出错了");
    }
    return false;
}