bonus-material-app/apis/apis.js

import Http from "./request";
import HttpConfig from "./http";

const login = {
    async codeLogin(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.authPath,
            HttpConfig.serviceUrl.login.code,
            data,
            header
        );
    },
    async getMessageCode(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.authPath,
            HttpConfig.serviceUrl.login.code,
            data,
            header
        );
    },
    async checkCode(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.authPath,
            HttpConfig.serviceUrl.login.checkCode,
            data,
            header
        );
    },
    async log(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.authPath,
            HttpConfig.serviceUrl.login.log,
            data,
            header
        );
    },
};

const user = {
    async logOut(data = {}, header = {}) {
        return await Http.delete(
            HttpConfig.authPath,
            HttpConfig.serviceUrl.user.logOut,
            data,
            header
        );
    },
};

const index = {
    async noticeCont(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.index.noticeCont,
            data,
            header
        );
    },
    async singleNotice(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.systemPath,
            HttpConfig.serviceUrl.index.singleNotice,
            data,
            header
        );
    },
    async waitDo(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.index.waitDo,
            data,
            header
        );
    },
    async keyData(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.index.keyData,
            data,
            header
        );
    },
    async getUserInfo(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.systemPath,
            HttpConfig.serviceUrl.index.getUserInfo,
            data,
            header
        );
    },
    async fetchCompanyName(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.systemPath,
            HttpConfig.serviceUrl.index.fetchCompanyName,
            data,
            header
        );
    },
};

const fetchMaterial = {
    async fetchMaterialList(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fetchMaterial.fetchMaterialList,
            data,
            header
        );
    },
    async getDeptList(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.materialPath,
            HttpConfig.serviceUrl.fetchMaterial.getDeptList,
            data,
            header
        );
    },
    async getProjList(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.materialPath,
            HttpConfig.serviceUrl.fetchMaterial.getProjList,
            data,
            header
        );
    },
    async subCart(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fetchMaterial.subCart,
            data,
            header
        );
    },
    async getDeviceDetail(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fetchMaterial.getDeviceDetail,
            data,
            header
        );
    },
    async addItemToCart(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fetchMaterial.addItemToCart,
            data,
            header
        );
    },
    async delCart(data = {}, header = {}) {
        return await Http.delete(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fetchMaterial.delCart,
            data,
            header
        );
    },
    async getCartDetail(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fetchMaterial.getCartDetail,
            data,
            header
        );
    },
    async itemNumChange(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fetchMaterial.itemNumChange,
            data,
            header
        );
    },
};

const fetchExam = {
    async fetchExamList(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fetchExam.fetchExamList,
            data,
            header
        );
    },
    async subExam(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fetchExam.subExam,
            data,
            header
        );
    },
    async subExamCq(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fetchExam.subExamCq,
            data,
            header
        );
    },
    async rejectExam(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fetchExam.rejectExam,
            data,
            header
        );
    },
    async rejectExamCq(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fetchExam.rejectExamCq,
            data,
            header
        );
    },
    async fetchExamListAll(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fetchExam.fetchExamListAll,
            data,
            header
        );
    },
    async fetchTrueExamList(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fetchExam.fetchTrueExamList,
            data,
            header
        );
    },
    async fetchTrueExamListCq(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fetchExam.fetchTrueExamListCq,
            data,
            header
        );
    },
    async fetchDetailList(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fetchExam.fetchDetailList,
            data,
            header
        );
    },
};

const newInStore = {
    async fetchNewInStoreList(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.materialPath,
            HttpConfig.serviceUrl.newInStore.fetchNewInStoreList,
            data,
            header
        );
    },
    async fetchNewBuyDetail(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.materialPath,
            HttpConfig.serviceUrl.newInStore.fetchNewBuyDetail,
            data,
            header
        );
    },
    async subNewBuy(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.newInStore.subNewBuy,
            data,
            header
        );
    },
};

const fetchMaterialOutStore = {
    async fetchInfoByCode(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fetchMaterialOutStore.fetchInfoByCode,
            data,
            header
        );
    },
    async subOutStore(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fetchMaterialOutStore.subOutStore,
            data,
            header
        );
    },
    async subOutStoreArr(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fetchMaterialOutStore.subOutStoreArr,
            data,
            header
        );
    },
    async fetchInfoByQrCode(data = {}) {
        return await Http.get(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fetchMaterialOutStore.fetchInfoByQrCode,
            data
        );
    },
    async fetchSingleDetail(data = {}) {
        return await Http.get(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fetchMaterialOutStore.fetchSingleDetail,
            data
        );
    },
    async searchRfid(data = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fetchMaterialOutStore.searchRfid,
            data
        );
    },
};

const exitMaterial = {
    async exitDeptList(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.exitMaterial.exitDeptList,
            data,
            header
        );
    },
    async exitMaterialList(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.exitMaterial.exitMaterialList,
            data,
            header
        );
    },
    async exitMaterialDetail(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.exitMaterial.exitMaterialDetail,
            data,
            header
        );
    },
    async subExitMaterial(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.exitMaterial.subExitMaterial,
            data,
            header
        );
    },
    async delMaterial(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.exitMaterial.delMaterial,
            data,
            header
        );
    },
    async newExitList(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.exitMaterial.newExitList,
            data,
            header
        );
    },
    async selectMaterial(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.exitMaterial.selectMaterial,
            data,
            header
        );
    },
    async ifAgreement(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.systemPath,
            HttpConfig.serviceUrl.exitMaterial.ifAgreement,
            data,
            header
        );
    },
    async ifAgreementNew(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.materialPath,
            HttpConfig.serviceUrl.exitMaterial.ifAgreement,
            data,
            header
        );
    },
};

const exitExam = {
    async exitExamList(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.exitExam.exitExamList,
            data,
            header
        );
    },
    async exitExamDetail(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.exitExam.exitExamDetail,
            data,
            header
        );
    },
    async subExitExam(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.exitExam.subExitExam,
            data,
            header
        );
    },
    async rejectExitExam(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.exitExam.rejectExitExam,
            data,
            header
        );
    },
};

const fix = {
    async fixList(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fix.fixList,
            data,
            header
        );
    },
    async fixDetail(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fix.fixDetail,
            data,
            header
        );
    },
    async fixExam(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fix.fixExam,
            data,
            header
        );
    },
    async completeFix(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fix.completeFix,
            data,
            header
        );
    },
    async submitFix(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fix.submitFix,
            data,
            header
        );
    },
    async fixCrew(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.systemPath,
            HttpConfig.serviceUrl.fix.fixCrew,
            data,
            header
        );
    },
    async maList(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fix.maList,
            data,
            header
        );
    },
    async fixFactory(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.fix.fixFactory,
            data,
            header
        );
    },
    async uploadPic(data = {}, header = {}) {
        return await Http.upload(
            HttpConfig.systemPath,
            HttpConfig.serviceUrl.fix.uploadPic,
            data,
            header
        );
    },
};

const repairTestInStore = {
    async repairTestInStoreList(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.materialPath,
            HttpConfig.serviceUrl.repairTestInStore.repairTestInStoreList,
            data,
            header
        );
    },
    async repairTestInStoreDetail(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.materialPath,
            HttpConfig.serviceUrl.repairTestInStore.repairTestInStoreDetail,
            data,
            header
        );
    },
    async processOrReject(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.materialPath,
            HttpConfig.serviceUrl.repairTestInStore.processOrReject,
            data,
            header
        );
    },
};

const backMaterialReceive = {
    async backMaterialReceiveList(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.backMaterialReceive.backMaterialReceiveList,
            data,
            header
        );
    },
    async backMaterialReceiveDetail(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.backMaterialReceive.backMaterialReceiveDetail,
            data,
            header
        );
    },
    async backMaterialSetNumBack(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.backMaterialReceive.backMaterialSetNumBack,
            data,
            header
        );
    },
    async backMaterialQrcodeQuery(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.backMaterialReceive.backMaterialQrcodeQuery,
            data,
            header
        );
    },
    async backMaterialSetCodeBack(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.backMaterialReceive.backMaterialSetCodeBack,
            data,
            header
        );
    },

    async backReceiveCodeQuery(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.backMaterialReceive.backReceiveCodeQuery,
            data,
            header
        );
    },
    async backReceiveEndBack(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.backMaterialReceive.backReceiveEndBack,
            data,
            header
        );
    },
    async seeBackMaterialDetail(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.backMaterialReceive.seeBackMaterialDetail,
            data,
            header
        );
    },
    async searchRfid(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.backMaterialReceive.searchRfid,
            data,
            header
        );
    },
    async subRfid(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.backMaterialReceive.subRfid,
            data,
            header
        );
    },
    // fetchMaterialOutStore
    async searchByCode(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.backMaterialReceive.searchByCode,
            data,
            header
        );
    },
    // fetchMaterialOutStore
    async searchCodeDevice(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.backMaterialReceive.searchCodeDevice,
            data,
            header
        );
    },
    // fetchMaterialOutStore
    async returnGetRecord(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.backMaterialReceive.returnGetRecord,
            data,
            header
        );
    },
};

const crashExam = {
    async crashExamList(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.materialPath,
            HttpConfig.serviceUrl.crashExam.crashExamList,
            data,
            header
        );
    },
    async crashExamDetails(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.materialPath,
            HttpConfig.serviceUrl.crashExam.crashExamDetails,
            data,
            header
        );
    },
    async crashExamAudit(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.materialPath,
            HttpConfig.serviceUrl.crashExam.crashExamAudit,
            data,
            header
        );
    },
};

const testExam = {
    async testExamList(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.materialPath,
            HttpConfig.serviceUrl.testExam.testExamList,
            data,
            header
        );
    },
    async testExamDetails(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.materialPath,
            HttpConfig.serviceUrl.testExam.testExamDetails,
            data,
            header
        );
    },
    async testExamAudit(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.materialPath,
            HttpConfig.serviceUrl.testExam.testExamAudit,
            data,
            header
        );
    },
};

const authManage = {
    async fetchAuthList(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.authManage.fetchAuthList,
            data,
            header
        );
    },
    async fetchIsUsing(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.authManage.fetchIsUsing,
            data,
            header
        );
    },
    async subAdd(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.authManage.subAdd,
            data,
            header
        );
    },
    async subDel(data = {}, header = {}) {
        return await Http.delete(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.authManage.subDel,
            data,
            header
        );
    },
};

const searchProjUsing = {
    async fetchProjUsingList(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.searchProjUsing.fetchProjUsingList,
            data,
            header
        );
    },
};

const searchFetchRecord = {
    async fetchRecordList(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.searchFetchRecord.fetchRecordList,
            data,
            header
        );
    },
};

const update = {
    async fetchAppVer(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.update.fetchAppVer,
            data,
            header
        );
    },
};

const rfidBinding = {
    async bindRfid(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.rfidBinding.bindRfid,
            data,
            header
        );
    },
};

const qrcodeBinding = {
    async bindQrcode(data = {}, header = {}) {
        return await Http.post(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.qrcodeBinding.bindQrcode,
            data,
            header
        );
    },
    async fetchDeviceType(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.materialPath,
            HttpConfig.serviceUrl.qrcodeBinding.fetchDeviceType,
            data,
            header
        );
    },
    async fetchDeviceSpec(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.materialPath,
            HttpConfig.serviceUrl.qrcodeBinding.fetchDeviceSpec,
            data,
            header
        );
    },
};

const indexScan = {
    async infoByCode(data = {}, header = {}) {
        return await Http.get(
            HttpConfig.basePath,
            HttpConfig.serviceUrl.indexScan.infoByCode,
            data,
            header
        );
    },
};

const url = HttpConfig.systemPath;

export default {
    login,
    index,
    user,
    fetchMaterial,
    fetchExam,
    newInStore,
    fetchMaterialOutStore,
    exitMaterial,
    fix,
    exitExam,
    repairTestInStore,
    backMaterialReceive,
    crashExam,
    testExam,
    authManage,
    searchProjUsing,
    searchFetchRecord,
    update,
    rfidBinding,
    qrcodeBinding,
    indexScan,
    url,
};