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.systemPath,
			HttpConfig.serviceUrl.fetchMaterial.getDeptList,
			data,
			header
		)
	},
	async getProjList(data = {}, header = {}) {
		return await Http.post(
			HttpConfig.systemPath,
			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
		)
	},
}

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.basePath,
			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
		)
	},
}

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
}