WZC2/fe/PDA/api/index.js

import request from '@/common/request.js'
import promise from '@/common/promise.js'
import VUE from 'vue'

let printUrl = VUE.prototype.$print_url; //打印
let devUrl = VUE.prototype.$dev_url; //数据请求

console.log('this', VUE.prototype)

export function getlogin(params) { // 
	return request(devUrl + "/api/pda/account/login", { //
		data: params,
		method: "post"
	})
}

export function getMenus(params) { //
	return promise(devUrl + "/api/pda/account/menus/"+params, { //
		data: {},
		method: "get"
	})
}

export function getUserInfo() {
	return request(devUrl + "/api/pda/account/workgroups", { //
		data: {},
		method: "get"
	})
}

export function getUserInfoAsync() {return promise(devUrl + "/api/pda/account/workgroups", { //
		data: {},
		method: "get"
	})
}


export function getWorkgroups() {
	return promise(devUrl + "/api/pda/account/workgroups", { //
		data: {},
		method: "get"
	})
}

//登出
export function logout() {
	return request(devUrl + "/api/pda/account/logout", {
		method: "post"
	});
}

// export function logout() {//
// 	return request("/prod/api/pda/account/logout", {
// 		data: {},
// 		method: "post"
// 	})
// }

//按用户查询菜单列表
export function menus() {
	return request(
		devUrl + "/api/pda/account/menus", {
			method: 'get',
			data: {}
		})
}

//获取任务数量
export function getJobCount() {
	return request(
		devUrl + "/api/pda/job/count", {
			method: 'get',
			data: {}
		})
}

//获取任务数量
export function getJobCountAsync(isToday,userId) {
	return promise(
		devUrl + "/api/pda/job/count/get-job-count/" + isToday+"?userId="+userId, {
			method: 'get',
			data: {}
		})
}

//按用户查询用户信息
export function profile(params) { //
	return request(devUrl + "/api/pda/account/profile", { //
		data: params,
		method: "get"
	})
}
//修改用户密码
export function changePassword(params) { //
	return request(devUrl + "/api/pda/account/change-password", { //
		data: params,
		method: "post"
	})
}

//kitting 推荐  isPackingCode=true 按箱，false 按数量
export const getRecommendBalance = (itemCode,productLine,isPackingCode) => request(
	devUrl + "/api/pda/inventory/balances/get-recommend-balance?itemCode="+itemCode+"&productLine="+productLine+"&isPackingCode="+isPackingCode,{ //
		data: {},
		method: "post"
	})

//获取库存 去除预计入和预计出
// {
//   "itemCode": "string",
//   "locationCode": "string",
//   "lot": "string",
//   "packingCode": "string",
//   "containerCode": "string",
//   "inventoryStatuses": [
//     0
//   ],
//   "locationTypes": [
//     0
//   ],
//   "pageSize": 0,
//   "pageIndex": 0,
//   "sortBy": "string"
// }
export const getBalanceRemoveInAndOutAsync = (params) => promise(
	devUrl + "/api/pda/inventory/balances/by-balances-request-many-parameter-not-in-expect-out",{ //
		data: params,
		method: "post"
	})
//获取库存信息去除预计出
export const getBalanceRemoveInAndOut = (params) => request(
	devUrl + "/api/pda/inventory/balances/by-balances-request-many-parameter-not-in-expect-out",{ //
		data: params,
		method: "post"
	})
//通过ERP料号和库位查询库存，去除预计出
export const getRecommendBalanceByLocationAsync = (params,itemCode,isPackingCode) => promise(
	devUrl + "/api/pda/inventory/balances/get-recommend-balance-by-locations?itemCode="+itemCode+"&isPackingCode="+isPackingCode,{ //
		data: params,
		method: "post"
	})


//通用
//查询库存明细
export const balances = (params) => request(
	devUrl + "/api/pda/inventory/balances", {
		method: 'get',
		data: params
	});

//通用
//查询库存明细
export const issueBalances = (params) => request(
	devUrl + "/api/pda/inventory/balances/by-issue", {
		method: 'post',
		data: params
	});

//异步的库存查询方法
export const issueBalancesAsync = (params) => promise(
	devUrl + "/api/pda/inventory/balances/by-issue", {
		method: 'post',
		data: params
	});


//通用
//查询库存明细
export const getBalances = (params) => request(
	devUrl + "/api/pda/inventory/balances/get-list-by-balance-list-input", {
		method: 'post',
		data: params
	});

//异步的库存查询方法
export const getBalancesAsync = (params) => promise(
	devUrl + "/api/pda/inventory/balances/get-list-by-balance-list-input", {
		method: 'post',
		data: params
	});


//根据零件、箱码、托码、批次、库位类型、库存状态查询库存
export const getBalancesByFilter = (params) => request(
	devUrl + "/api/pda/inventory/balances/by-balances-request-many-parameter", {
		method: 'post',
		data: params
	});

//根据零件、箱码、托码、批次、库位类型、库存状态查询库存
export const getBalancesByFilterAsync = (params) => promise(
	devUrl + "/api/pda/inventory/balances/by-balances-request-many-parameter", {
		method: 'post',
		data: params
	});

//查询是否有预计入和预计出的占用
export const getBalancesExpectByFilter = (params) => request(
	devUrl + "/api/pda/inventory/balances/by-balances-request-many-parameter-not-in-expect-out", {
		method: 'post',
		data: params
	});
// ERP料号模糊匹配查询库存
export const getBalancesByItemCode = (params) => promise(
	devUrl + "/api/pda/inventory/balances/get-fuzzy-by-balances-request-many-parameter", {
		method: 'post',
		data: params
	});

// ERP料号模糊匹配查询所有物料数据
export const getItemCodeByLike = (itemCode,pageIndex,pageSize) => promise(
	devUrl + "/api/pda/item/get-fuzzy?itemCode="+itemCode+"&pageIndex="+pageIndex+"&pageSize="+pageSize, {
		method: 'get',
		data: {}
	});
	

//根据库位查询库存
export const getBalancesByStatus = (params) => request(
	devUrl + "/api/pda/inventory/balances/get-by-location-type-and-inventory-status", {
		method: 'post',
		data: params
	});

//根据库位和ERP料号查询库存
export const getBalancesByLocationAndItem = (params) => request(
	devUrl + "/api/pda/inventory/balances/get-by-location-and-item?locationCode=" + params.locationCode +
	"&itemCode=" + params.itemCode, {
		method: 'get',
		data: params
	});


//根据库位和ERP料号查询库存
export const getBalancesByLocationAndItemAsync = (params) => promise(
	devUrl + "/api/pda/inventory/balances/get-by-location-and-item?locationCode=" + params.locationCode +
	"&itemCode=" + params.itemCode, {
		method: 'get',
		data: params
	});

//查询线边库存 
export const getWipListAsync = (params) => promise(
	devUrl + "/api/pda/inventory/balances/get-wip-list?itemCode=" + params.itemCode + "&locationCode=" + params
	.locationCode, {
		method: 'get',
		data: params
	});


//查询库存汇总
export const summary = (params) => request(
	devUrl + "/api/pda/inventory/balances/summary", {
		method: 'get',
		data: params
	});

//零件
//查询零件信息
export const getitems = (code) => request(
	devUrl + "/api/pda/item/" + code, {
		method: 'get',
		data: code
	});
	
//
//查询单件码 通过单件码查询ERP料号信息
export const getMesBarCode = (mesBarCode) => request(
	devUrl + "/api/pda/store/product-receipt/get-itemcode-by-mesbarcode?mesBarCode=" + mesBarCode, {
		method: 'post',
		data: {}
	});

//根据库位查询零件
export const getItemsByLocation = (params) => promise(
	devUrl + "/api/pda/inventory/balances/get-item-by-location", {
		method: 'get',
		data: params
	});

//查询已占用库存
export const expectIn = (params) => request(
	devUrl + "/api/pda/inventory/expect-in", {
		method: 'get',
		data: params
	});

//根据code获取生产线
export const getprodlineitem = (code) => request(
	devUrl + "/api/pda/production-line/by-code?code=" + code, {
		method: 'get',
		data: {}
	});

//异步查询生产线
export const getprodlineitemAsync = (code) => promise(
	devUrl + "/api/pda/production-line/by-code?code=" + code, {
		method: 'get',
		data: {}
	});

//查询收货任务列表
export const getReceiptJobList = (params) => request(
	devUrl + `/api/pda/job/purchase-receipt/list`, {
		method: 'get',
		data: params
	});

//根据Number 获取收货任务列表
export const getReceiptJobByNumber = (params) => request(
	devUrl + "/api/pda/job/purchase-receipt/by-number/" + params.number + "?isToday=" + params.isToday, {
		data: {},
		method: "get"
	});

//根据Asn Number 获取收货任务列表
export const getReceiptJobByAsnNumber = (params) => request(
	devUrl + "/api/pda/job/purchase-receipt/list/by-asn"
	, {
		data: params,
		method: "get"
	});

//查询收货任务明细
export const purchaseReceipts = (id) => request(
	devUrl + `/api/pda/job/purchase-receipt/${id}`, {
		method: 'get',
		data: {}
	});

//开始收货任务
export function takeReceiptJob(id) {
	return request(devUrl + `/api/pda/job/purchase-receipt/take/${id}`, { //
		data: {},
		method: "post"
	})
}
//取消承接任务
export function cancelTakeReceiptJob(id) {
	return request(devUrl + `/api/pda/job/purchase-receipt/cancel-take/${id}`, { //
		data: {},
		method: "post"
	})
}
//完成收货任务
export function finishReceiptJob(id, param) { //
	return request(devUrl + `/api/pda/job/purchase-receipt/finish/${id}`, { //
		data: param,
		method: "post"
	})
}

//保存目检结果
export function saveReceiptResult(id, param) {
	///api/pda/job/purchase-receipt/save-detail-inspect/{id}
	return request(devUrl + `/api/pda/job/purchase-receipt/save-detail-inspect/${id}`, { //
		data: param,
		method: "post"
	})
}

//重置多个目检结果
export function resetReceiptResult(id, param) {
	///api/pda/job/purchase-receipt/save-detail-inspect/{id}
	return request(devUrl + `/api/pda/job/purchase-receipt/reset-many-detail-inspect/${id}`, { //
		data: param,
		method: "post"
	})
}


//重置一个目检结果
export function resetReceiptDetailResult(id, detailId) {
	///api/pda/job/purchase-receipt/save-detail-inspect/{id}
	return request(devUrl + `/api/pda/job/purchase-receipt/reset-detail-inspect/${id}?detailId=${detailId}`, { //
		data: {},
		method: "post"
	})
}

//待检转合格
export function unInspectToQualified(id) { //
	return request(devUrl + `/api/pda/job/purchase-receipt/set-inspect-status-ok-by-inspect/${id}`, { //
		data: {},
		method: "post"
	})
}

//库存
//提交库存转移
export function inventoryTransfer(params) { //
	return request(devUrl + "/api/pda/store/transfer-note", { //
		data: params,
		method: "post"
	})
}
//提交计划外入库
export function unplannedReceipt(params) { //
	return request(devUrl + "/api/pda/store/unplanned-receipt", { //
		data: params,
		method: "post"
	})
}
//提交计划外出库
export function unplannedIssue(params) { //
	return request(devUrl + "/api/pda/store/unplanned-Issue", { //
		data: params,
		method: "post"
	})
}
//原料
//原料收货
export function purchaseReceipt(params) { //
	return request(devUrl + "/api/pda/store/purchase-receipt", { //
		data: params,
		method: "post"
	})
}
//提交FIFO指导发料
export function issue(params) { //
	return request(devUrl + "/api/pda/store/issue", { //
		data: params,
		method: "post"
	})
}
//生产
//提交叫料
export function materialRequest(params) { //
	return request(devUrl + "/api/pda/store/material-request", { //
		data: params,
		method: "post"
	})
}
//提交完工收货(无任务)
export function productreceipt(params) { //
	return request(devUrl + "/api/pda/store/product-receipt", { //
		data: params,
		method: "post"
	})
}

//完工收货(冲回)
export function productrecycle(params) { //
	return request(devUrl + "/api/pda/store/product-recycle", { //
		data: params,
		method: "post"
	})
}

//提交完工收货(天津)
export function tjproductreceipt(params) { //
	return request(devUrl + "/api/pda/store/l7/create-product-receipt-note-with-l7", { //
		data: params,
		method: "post"
	})
}

//完工收货(天津)
export function tjproductrecycle(params) { //
	return request(devUrl + "/api/pda/store/l7/create-product-recycle-note-with-l7", { //
		data: params,
		method: "post"
	})
}

//库位
//查询库位信息 根据code
export const locations = (code) => request(
	devUrl + "/api/pda/location/" + code, {
		method: 'get',
		data: code
	});

//库位
//查询库位信息 根据code
export const locationsAsync = (code) => promise(
	devUrl + "/api/pda/location/" + code, {
		method: 'get',
		data: code
	});

//库位
//查询库位信息 根据type
export const locationByType = (type) => request(
	devUrl + "/api/pda/location/by-type/" + type, {
		method: 'get',
		data: type
	});

//根据库位查询零件
export const getLocationByItem = (params) => promise(
	devUrl + "/api/pda/inventory/balances/get-location-by-item", {
		method: 'get',
		data: params
	});

//消息
//查询未读消息列表
export const messageList = (userId) => request(
	devUrl + "/api/pda/store/message/list/" + userId, {
		method: 'get',
		data: {}
	});
//消息
//查询未读消息列表
export const unreadList = () => request(
	devUrl + "/api/pda/store/message/unread-list", {
		method: 'get',
		data: {}
	});
//查询未读消息数量
export const unreadCount = (userId) => request(
	devUrl + "/api/pda/store/message/not-read-count/" + userId, {
		method: 'get',
		data: {}
	});
//变更消息状态
export function readMessage(id) { //
	return request(devUrl + "/api/pda/store/message/read/" + id, { //
		data: id,
		method: "post"
	})
};
//查询消息明细
export const messages = (id) => request(
	devUrl + "/api/pda/store/message/" + id, {
		method: 'get',
		data: id
	});
//器具
export function palletbind(id) { //
	return request(devUrl + "/api/pda/stock/pallet/bind", { //
		data: id,
		method: "post"
	})
}

//检验任务列表
export const getInspectList = (params) => request(
	devUrl + "/api/pda/job/inspect/list", {
		method: 'get',
		data: params
	});

//检验任务详情
export const getInspectDetail = (params) => request(
	//api/pda/job/inspect/{id}
	devUrl + "/api/pda/job/inspect/" + params.id, { //
		data: {},
		method: "get"
	});

//检验任务数量
export const getInspectCount = (params) => request(
	devUrl + "/api/pda/job/inspect/count", {
		data: params,
		method: "get"
	});

//承接检验任务
export const takeInspectJob = (params) => request(
	devUrl + "/api/pda/job/inspect/take/" + params.id, { //
		data: {},
		method: "post"
	});

//取消承接检验任务
export const cancelTakeInspectJob = (id) => request(
	devUrl + "/api/pda/job/inspect/cancel-take/" + id, { //
		data: {},
		method: "post"
	});

//开始检验任务
export const finshInspectJob = (id, params) => request(
	devUrl + "/api/pda/job/inspect/finish/" + id, { //
		data: params,
		method: "post"
	})

//上架任务列表
export const getPutawayJobList = (params) => request(
	devUrl + "/api/pda/job/put-away/list", {
		method: 'get',
		data: params
	});

//上架任务详情
export const getPutawayJobDetail = (params) => request(
	devUrl + "/api/pda/job/put-away/" + params.id, { //
		data: {},
		method: "get"
	});

//上架任务数量
export const getPutawayJobCount = (params) => request(
	devUrl + "/api/pda/job/put-away/count", {
		data: params,
		method: "get"
	});

//承接上架任务
export const takePutawayJob = (params) => request(
	devUrl + "/api/pda/job/put-away/take/" + params.id, { //
		data: {},
		method: "post"
	});

//承接上架任务
export const cancelTakePutawayJob = (id) => request(
	devUrl + "/api/pda/job/put-away/cancel-take/" + id, { //
		data: {},
		method: "post"
	});

//开始上架任务
export const finshPutawayJob = (id, params) => request(
	devUrl + "/api/pda/job/put-away/finish/" + id, { //
		data: params,
		method: "post"
	})

//根据托标签生成上架任务
export const byContainercode = (params) => request(
	devUrl + "/api/pda/job/put-away/by-containercode/", { //
		data: params,
		method: "post"
	})

//根据箱标签生成上架任务
export const byPackingcode = (params) => request(
	devUrl + "/api/pda/job/put-away/by-packingcode", { //
		data: params,
		method: "post"
	})

//检查此箱是否存在任务
export const checkjobbypacking = (params) => request(
	devUrl + "/api/pda/job/put-away/check-job-exist-by-packing", { //
		data: params,
		method: "get"
	})

//创建叫料申请
export const issueRequest = (params) => request(
	devUrl + "/api/pda/store/material-request", { //
		data: params,
		method: "post"
	})

//根据托标签检查是否存在任务
export const checkjobbycontainer = (params) => request(
	devUrl + "/api/pda/job/put-away/check-job-exist-by-container", { //
		data: params,
		method: "get"
	})

//发料任务列表
export const getIssueList = (params) => request(
	devUrl + "/api/pda/job/issue/list", {
		method: 'get',
		data: params
	});

//检查是否存在发料任务"​/prod/api/pda/job/issue/check-job-exist",
export const checkIssueJobExist = (params) => request(
	devUrl + "/api/pda/job/issue/check-job-exist", {
		method: 'get',
		data: params
	});

//检查是否存在发料任务"​/prod/api/pda/job/issue/check-job-exist",
export const checkIssueJobExistAsync = (params) => promise(
	devUrl + "/api/pda/job/issue/check-job-exist", {
		method: 'get',
		data: params
	});

//根据Number 获取发料任务列表
export const getIssueJobByNumber = (jobNumber) => request(
	devUrl + "/api/pda/job/issue/by-number/" + jobNumber, {
		data: {},
		method: "get"
	});


// 根据MaterialRequest Number获取收货任务列表
export const getIssueListByRequest = (requestNumber) => request(
	devUrl + "/api/pda/job/issue/list/by-request/" + requestNumber, { //
		data: {},
		method: "get"
	});

//发料任务数量
export const getIssueCount = (params) => request(
	devUrl + "/api/pda/job/issue/count", {
		data: params,
		method: "get"
	});

//发料任务详情
export const getIssueDetail = (params) => request(
	devUrl + "/api/pda/job/issue/" + params.id, { //
		data: {},
		method: "get"
	});

//承接发料任务
export const takeIssueJob = (params) => request(
	devUrl + "/api/pda/job/issue/take/" + params.id, { //
		data: {},
		method: "post"
	});

//取消承接发料任务
export const cancelTakeIssueJob = (id) => request(
	devUrl + "/api/pda/job/issue/cancel-take/" + id, { //
		data: {},
		method: "post"
	});
//完成发料任务
export const finshIssueJob = (id, params) => request(
	devUrl + "/api/pda/job/issue/finish/" + id, { //
		data: params,
		method: "post"
	})
	
	
//非生产领料任务
export const getUnProducePickList = (params) => request(
	devUrl + "/api/pda/job/unplanned-issue/list", {
		method: 'get',
		data: params
	});	
	
//非生产领料任务详情
export const getUnProducePickDetail = (params) => request(
	devUrl + "/api/pda/job/unplanned-issue/" + params.id, { //
		data: {},
		method: "get"
	});
	
//完成非生产领料任务
export const finshUnProducePickJob = (id, params) => request(
	devUrl + "/api/pda/job/unplanned-issue/finish/" + id, { //
		data: params,
		method: "post"
	})
	
//非生产退料任务
export const getUnProduceReturnList = (params) => request(
	devUrl + "/api/pda/job/unplanned-receipt/list", {
		method: 'get',
		data: params
	});	
	
//非生产退料 任务详情
export const getUnProduceReturnDetail = (params) => request(
	devUrl + "/api/pda/job/unplanned-receipt/" + params.id, { //
		data: {},
		method: "get"
	});
	
//完成非生产退料任务
export const finshUnProduceReturnJob = (id, params) => request(
	devUrl + "/api/pda/job/unplanned-receipt/finish/" + id, { //
		data: params,
		method: "post"
	})
	
//发货任务列表
export const getDeliverList = (params) => request(
	devUrl + "/api/pda/job/deliver/list", {
		method: 'get',
		data: params
	});

//根据Number 获取发货任务列表
export const getDeliverJobByNumber = (number) => request(
	devUrl + "/api/pda/job/deliver/by-number/" + number, {
		data: {},
		method: "get"
	});

//发货任务数量
export const getDeliverCount = (params) => request(
	devUrl + "/api/pda/job/deliver/count", {
		data: params,
		method: "get"
	});

//发货任务详情
export const getDeliverDetail = (params) => request(
	devUrl + "/api/pda/job/deliver/" + params.id, { //
		data: {},
		method: "get"
	});

//承接发货任务
export const takeDeliverJob = (params) => request(
	devUrl + "/api/pda/job/deliver/take/" + params.id, { //
		data: {},
		method: "post"
	});
//取消承接发货任务
export const cancelTakeDeliverJob = (id) => request(
	devUrl + "/api/pda/job/deliver/cancel-take/" + id, { //
		data: {},
		method: "post"
	});
//开始发货任务
export const finshDeliverJob = (id, params) => request(
	devUrl + "/api/pda/job/deliver/finish/" + id, { //
		data: params,
		method: "post"
	})

//盘点任务列表
export const getCountJobList = (params) => request(
	devUrl + "/api/pda/job/count/list", {
		method: 'get',
		data: params
	});

//根据Number获取盘点任务
export const getCountJobByNumber = (number) => request(
	devUrl + "/api/pda/job/count/by-number/" + number, {
		data: {},
		method: "get"
	});


//根据库位获取盘点任务
export const getCountJobByLocation = (locationCode) => request(
	devUrl + "/api/pda/job/count/list/by-location/" + locationCode, {
		data: {},
		method: "get"
	});

//根据库位获取盘点任务
export const getCountJobByLocationAsync = (locationCode) => promise(
	devUrl + "/api/pda/job/count/list/by-location/" + locationCode, {
		data: {},
		method: "get"
	});

//盘点任务数量
export const getCountJobCount = (params) => request(
	devUrl + "/api/pda/job/count/count", {
		data: params,
		method: "get"
	});
//盘点任务详情
export const getCountJobDetail = (params) => request(
	devUrl + "/api/pda/job/count/" + params.id, { //
		data: {
			params
		},
		method: "get"
	});

//承接上架任务
export const takeCountJob = (params) => request(
	devUrl + "/api/pda/job/count/take/" + params.id, { //
		data: {},
		method: "post"
	});

//取消承接发货任务
export const cancelTakeCountJob = (id) => request(
	devUrl + "/api/pda/job/count/cancel-take/" + id, { //
		data: {},
		method: "post"
	}); //取消承接发货任务
//提交盘点任务
export const finishCountJob = (id, params) => request(
	devUrl + "/api/pda/job/count/finish/" + id, { //
		data: params,
		method: "post"
	});

//根据条件新增盘点任务
export const createCountJob = (params) => request(
	devUrl + "/api/pda/job/count/create-with-condition/", { //
		data: params,
		method: "post"
	});

//退货任务列表
export const getReturnJobList = (params) => request(
	devUrl + "/api/pda/job/purchase-return/list", {
		method: 'get',
		data: params
	});

//上架后退货申请提交
export const purchaseReturnRequestSubmit = (params) => request(
	devUrl + "/api/pda/store/purchase-return-request/create-many", {
		method: 'post',
		data: params
	});
	
//上架后退货申请列表
export const getReturnRequestList = (params) => request(
	devUrl + "/api/wms/store/purchase-return-request/list", {
		method: 'post',
		data: params
	});	

//上架后退货申请列表详情
export const getReturnRequestDetail= (id) => request(
	devUrl + "/api/wms/store/purchase-return-request/"+id, {
		method: 'get',
		data: {}
	});	
//上架后退货申请同意
export const purchaseReturnRequestAgree= (id) => request(
	devUrl + "/api/wms/store/purchase-return-request/agree/"+id, {
		method: 'post',
		data: {}
	});	
	
//上架后退货申请驳回
export const purchaseReturnRequestReject= (id) => request(
	devUrl + "/api/wms/store/purchase-return-request/refuse/"+id, {
		method: 'post',
		data: {}
	});	
	
	
	

//根据Number 获取盘点任务列表
export const getReturnJobByNumber = (number) => request(
	devUrl + "/api/pda/job/purchase-return/by-number/" + number, {
		data: {},
		method: "get"
	});

//退货任务数量
export const getReturnJobCount = (params) => request(
	devUrl + "/api/pda/job/purchase-return/count", {
		data: params,
		method: "get"
	});

//退货任务详情
export const getReturnJobDetail = (id) => request(
	devUrl + "/api/pda/job/purchase-return/" + id, { //
		data: {},
		method: "get"
	});

//承接退货任务
export const takePurchaseReturnJob = (id) => request(
	devUrl + "/api/pda/job/purchase-return/take/" + id, { //
		data: {},
		method: "post"
	});

//取消承接退货任务
export const cancelTakePutchaseReturnJob = (id) => request(
	devUrl + "/api/pda/job/purchase-return/cancel-take/" + id, { //
		data: {},
		method: "post"
	});

//完成退货任务
export const finishReturnJob = (id, returnReason) => request(
	devUrl + "/api/pda/job/purchase-return/finish/" + id + "?returnReason=" + returnReason, { //
		data: {},
		method: "post"
	});

//完工收货任务
export const getProductReceiptList = (params) => request(
	devUrl + "/api/pda/job/product-receipt/list", {
		method: 'get',
		data: params
	});

//完工收货任务详情
export const getProductReceiptDetail = (params) => request(
	//api/pda/job/inspect/{id}
	devUrl + "/api/pda/job/product-receipt/" + params.id, { //
		data: {},
		method: "get"
	});

//承接完工收货任务
export const takeProductReceiptJob = (params) => request(
	devUrl + "/api/pda/job/product-receipt/take/" + params.id, { //
		data: {},
		method: "post"
	});
//取消承接完工收货任务
export const cancelTakeProductReceiptJob = (id) => request(
	devUrl + "/api/pda/job/product-receipt/cancel-take/" + id, { //
		data: {},
		method: "post"
	});

//开始完工收货任务
export const finshProductReceiptJob = (id, params) => request(
	devUrl + "/api/pda/job/product-receipt/finish/" + id, { //
		data: params,
		method: "post"
	});

//无任务的完工收货
export const finshProductReceiptNoJob = (id, params) => request(
	devUrl + "/api/pda/store/product-receipt", { //
		data: params,
		method: "post"
	});

//获取箱标签
export const getContainerCode = (qty) => request(
	devUrl + "/api/pda/stock/pack/add-pallet-code-number?qty=" + qty, { //
		data: {},
		method: "post"
	});

//获取生产线
export const getProductionLine = (params) => request(
	devUrl + "/api/pda/production-line/list", { //
		data: params,
		method: "get"
	});

//获取班次
export const getShift = (params) => request(
	devUrl + "/api/pda/shift/list", { //
		data: params,
		method: "get"
	});

//获取客户地址
export const getCustomerAddressByCode = (code) => request(
	devUrl + "/api/pda/customer-address/" + code, { //
		data: {},
		method: "get"
	});

//获取客户地址
export const getCustomerAddressByCodeAsync = (code) => promise(
	devUrl + "/api/pda/customer-address/" + code, { //
		data: {},
		method: "get"
	});

//按客户代码获取客户地址
export const getCustomerAddressBycustomerCode = (customerCode) => request(
	devUrl + "/api/pda/customer-address/by-customer?customerCode=" + customerCode, { //
		data: {},
		method: "get"
	});

//按客户代码获取客户地址
export const getCustomerAddressBycustomerCodeAsync = (customerCode) => promise(
	devUrl + "/api/pda/customer-address/by-customer?customerCode=" + customerCode, { //
		data: {},
		method: "get"
	});

export const getItemAsync = (code) => promise(
	devUrl + '/api/pda/item/' + code, { //
		data: {},
		method: "get"
	});


//直接发货
export const finshDeliver = (params) => request(
	devUrl + "/api/pda/store/deliver", { //
		data: params,
		method: "post"
	});

//原料直发
export const rawDeliver = (params) => request(
	devUrl + "/api/pda/store/deliver", { //
		data: params,
		method: "post"
	});


//调拨发货
export const warehouseTransfer = (params) => request(
	devUrl + "/api/pda/store/warehouse-transfer", { //
		data: params,
		method: "post"
	});

//发货任务列表
export const getJisDeliverList = (params) => request(
	devUrl + "/api/pda/job/jis-deliver/list", {
		method: 'get',
		data: params
	});
//发货任务数量
export const getJisDeliverCount = (params) => request(
	devUrl + "/api/pda/job/jis-deliver/count", {
		data: params,
		method: "get"
	});

// //发货任务详情
// export const getJisDeliverDetail = (params) => request(
// 	"/prod/api/pda/job/jis-deliver" , { //
// 		data: params,
// 		method: "get"
// 	});

//发货任务详情
export const getJisDeliverDetail = (params) => request(
	devUrl + "/api/pda/job/jis-deliver", { //
		data: {},
		method: "get"
	});

//承接发货任务
export const takeJisDeliverJob = (params) => request(
	devUrl + "/api/pda/job/jis-deliver/take/" + params.id, { //
		data: {},
		method: "post"
	});
//取消承接发货任务
export const cancelTakeJisDeliverJob = (id) => request(
	devUrl + "/api/pda/job/jis-deliver/cancel-take/" + id, { //
		data: {},
		method: "post"
	});
//开始发货任务
///api/pda/job/jis-deliver/finish/{id}
export const finshJisDeliverJob = (id, params) => request(
	devUrl + "/api/pda/job/jis-deliver/finish/" + id, { //
		data: params,
		method: "post"
	})

//查询器具是否存在
export const getContainer = (code) => request(
	devUrl + "/api/pda/inventory/container/" + code, { //
		data: {},
		method: "get"
	});

//查询器具是否存在
export const getContainerAsync = (code) => promise(
	devUrl + "/api/pda/inventory/container/" + code, { //
		data: {},
		method: "get"
	});

//查询器具是否按序
export const checkContainerOrder = (code) => request(
	devUrl + "/api/pda/inventory/container/check-by-code/" + code, { //
		data: {},
		method: "get"
	});

//查询器具是否按序
export const checkContainerOrderAsync = (code) => promise(
	devUrl + "/api/pda/inventory/container/check-by-code/" + code, { //
		data: {},
		method: "get"
	});


export const PrintServices = (data) => {
	return uni.request({
		url: printUrl + '/api/print/PrintServices',
		method: 'post',
		header: {
			'content-type': 'application/x-www-form-urlencoded'
		},
		data
	}).then(res => {
		if (res != null && res[1] != null) {
			if (res[1].statusCode != null) {
				//状态码类型 2开头的全是成功
				let code = res[1].statusCode.toString().substring(0, 1);
				if (code === '2') {

					return res[1].data;
				} else {
					let message = res[1].data.error.message;
					if (message != null) {
						throw res[1].data.error.message;
					} else {
						throw res[1].statusCode + "错误";
					}

				}
			} else {
				throw url + "返回的状态码类型为空"
			}
		} else {
			throw url + "返回的res为空"
		}
	})
}
// 获取版本号
export const isNewVersion = () => {
	return uni.request({
		url: devUrl + `/static/version.json?t=${new Date().getTime()}`,
		method: 'post'
	}).then(res => {
		console.log(res)
	})
}

// 东阳新接口
//报废
export const scrap = (params) => request(
	devUrl + "/api/pda/store/scrap", { //
		data: params,
		method: "post"
	});

//上架前退货
export const returnBeforePutaway = (params) => request(
	devUrl + "/api/pda/store/purchase-return-note/before-puton", { //
		data: params,
		method: "post"
	});

//获取采购标签信息
// export const getPurchaseLabel = (code) => request(
// 	devUrl + "/api/pda/label/purchaselabel/by-code?code=" + code, { //
// 		data: {},
// 		method: "get"
// 	});


// //获取采购标签信息
// export const getPurchaseLabelAsync = (code) => promise(
// 	devUrl + "/api/pda/label/purchaselabel/by-code?code=" + code, { //
// 		data: {},
// 		method: "get"
// 	});

// //获取产品标签信息
// export const getProductionLabel = (code) => request(
// 	devUrl + "/api/pda/label/productionlabel/by-code?code=" + code, { //
// 		data: {},
// 		method: "get"
// 	});

// //获取产品标签信息
// export const getProductionLabelAsync = (code) => promise(
// 	devUrl + "/api/pda/label/productionlabel/by-code?code=" + code, { //
// 		data: {},
// 		method: "get"
// 	});
export const getContainerCodeInfo = (code) => request(
	devUrl + "/api/pda/position-code/" + code, { //
		data: {},
		method: "get"
	});
//获取位置码信息
export const getPositionCodeInfo = (code) => request(
	devUrl + "/api/pda/position-code/" + code, { //
		data: {},
		method: "get"
	});


//获取产品标签信息inventorylabel
export const getInventoryLabel = (code) => request(
	devUrl + "/api/pda/label/inventorylabel/by-code?code=" + code, { //
		data: {},
		method: "get"
	});

//获取产品标签信息
export const getInventoryLabelAsync = (code) => promise(
	devUrl + "/api/pda/label/inventorylabel/by-code?code=" + code, { //
		data: {},
		method: "get"
	});

//回收料收货
export const recycledMaterialReceipt = (param) => request(
	devUrl + "/api/pda/store/recycled-material-receipt-note", { //
		data: param,
		method: "post"
	});

//生产退库列表
export const getProductionReturnJobList = (params) => request(
	devUrl + "/api/pda/job/production-return/list", {
		method: 'get',
		data: params
	});

//生产退库数量
export const getProductionReturnJobCount = (params) => request(
	devUrl + "/api/pda/job/production-return/count", {
		data: params,
		method: "get"
	});

//生产退库详情
export const getProductionReturnJobDetail = (id) => request(
	devUrl + "/api/pda/job/production-return/" + id, { //
		data: {},
		method: "get"
	});

//承接生产退库
export const takeProductionReturnJob = (id) => request(
	devUrl + "/api/pda/job/production-return/take/" + id, { //
		data: {},
		method: "post"
	});

//取消承接生产退库
export const cancelTakeProductionReturnJob = (id) => request(
	devUrl + "/api/pda/job/production-return/cancel-take/" + id, { //
		data: {},
		method: "post"
	});

//完成生产退库
export const finishProductionReturnJob = (id, params) => request(
	devUrl + "/api/pda/job/production-return/finish/" + id, { //
		data: params,
		method: "post"
	});

//直接退库
export const returnToWarehouse = (params) => request(
	devUrl + "/api/pda/store/return-to-warehouse", { //
		data: params,
		method: "post"
	});

//采购上架
export const purchasePutaway = (params) => request(
	devUrl + "/api/pda/note/put-away/by-purchase", { //
		data: params,
		method: "post"
	});

//采购上架 ，通过采购订单号获取详细

export const getPurchasePutawayAsyncDetail = (poNumber) => promise(
	devUrl + "/api/pda/store/purchase-receipt/get-packing-by-purchase-recepit-note?poNumber="+poNumber, { //
		data: {},
		method: "post"
	});
	

//半成品上架
export const semiPutaway = (params) => request(
	devUrl + "/api/pda/note/put-away/by-semi", { //
		data: params,
		method: "post"
	});
//通过箱码获取采购订单详细箱码
export const getPurchaseDetailAsyncNew = (toPackingCode) => promise(
	devUrl + "/api/pda/split-packing-rec/get-same-ponumber-list-by-topackingcode?toPackingCode=" + toPackingCode, { //
		data: {},
		method: "get"
	});
	
	

//获取采购订单信息
export const getPurchaseDetailAsync = (itemCode, packingCode) => promise(
	devUrl + "/api/pda/store/purchase-receipt-request/detail-by-item-and-packing?itemCode=" + itemCode + '&packingCode=' +
	packingCode, { //
		data: {},
		method: "get"
	});

export const getPurchaseDetailNewAsync = (itemCode, packingCode) => promise(
	devUrl + "/api/pda/store/purchase-receipt-request/detail-by-item-and-rootpacking?itemCode=" + itemCode + '&packingCode=' +
	packingCode, { //
		data: {},
		method: "get"
	});

export const getPurchaseDetailAsync_old = (itemCode, packingCode) => promise(
	devUrl + "/api/pda/store/purchase-receipt/detail-by-item-and-packing?itemCode=" + itemCode + '&packingCode=' +
	packingCode, { //
		data: {},
		method: "get"
	});
	
	

export const getFileByCode = (fileCode) => request(
	devUrl + "/api/pda/file/filestore/by-code/" + fileCode, { //
		data: {},
		method: "post"
	});

// 根据 code 获取配置字典
export const getDictByCode = (code) => request(
	devUrl + "/api/pda/dict/by-code?code=" + code, { //
		data: {},
		method: "get"
	});
//生成新的箱码
export const generateNewPacking = (count,params) => request(
	devUrl + "/api/pda/label/inventorylabel/generate-and-create/many/" + count, { //
		data: params,
		method: "post"
	})
	
//拆箱码
export const unPacking = (params) => request(
	devUrl + "/api/pda/store/transfer-note/split-packing", { //
		data: params,
		method: "post"
	})
	
export const unPackingByPurchase = (params,number,fromPackingCode,fromQty,toPackingCode,toQty) => request(
	devUrl + "/api/pda/store/transfer-note/split-packing-purchase-receipt?Number="+number+"&FromPackingCode="+fromPackingCode+"&FromQty="+fromQty+"&ToPackingCode="+toPackingCode+"&ToQty="+toQty, { //
		data: params,
		method: "post"
	})
	
export const unPackingByIssue = (params,number,fromPackingCode,fromQty,toPackingCode,toQty) => request(
	devUrl + "/api/pda/store/transfer-note/split-packing-issue?Number="+number+"&FromPackingCode="+fromPackingCode+"&FromQty="+fromQty+"&ToPackingCode="+toPackingCode+"&ToQty="+toQty, { //
		data: params,
		method: "post"
	})

//直接发料
export const issueDirect = (params) => request(
	devUrl + "/api/pda/store/issue", { //
		data: params,
		method: "post"
	});
	
//看板件发运
export const getDeliverBoardList = (params) => request(
	devUrl + "/api/pda/job/issue/list", {
		method: 'get',
		data: params
	});

//承接发运任务
export const takeDeliverBoardJob = (params) => request(
	devUrl + "/api/pda/job/issue/take/" + params.id, { //
		data: {},
		method: "post"
	});

//取消承接发运任务
export const cancelTakeDeliverBoardJob = (id) => request(
	devUrl + "/api/pda/job/issue/cancel-take/" + id, { //
		data: {},
		method: "post"
	});
	
//发运任务详情
export const getDeliverJobDetail = (params) => request(
	devUrl + "/api/pda/job/issue/" + params.id, { //
		data: {},
		method: "get"
	});
//完成发运任务
export const finshDeliverBoardJob = (id, params) => request(
	devUrl + "/api/pda/job/issue/finish/" + id, { //
		data: params,
		method: "post"
	})
	
//高往低库存转移任务列表
export const getPlasticsList = (params) => request(
		devUrl + "/api/pda/job/deliver/list", {
			method: 'get',
			data: params
		});

//空器具呼叫
export const containerRequest = (params) => request(
	devUrl + "/api/pda/store/container-request", { //
		data: params,
		method: "post"
	})
//空器具库移列表
export const getContainerList = (params) => request(
		devUrl + "/api/pda/job/container/list", {
			method: 'get',
			data: params
		});

//空器具库移完成
export const finshContainerJob = (id, params) => request(
	devUrl + "/api/pda/job/container/finish/" + id, { //
		data: params,
		method: "post"
	})
	
//生产退库详情
export const customerReturnCommit = (params) => request(
	devUrl + "/api/pda/job/production-return", { //
		method: "post",
		data: params,
	});

//三方库发货申请
export const thirdLocationRequest = (params) => request(
	devUrl + "/api/pda/store/third-location-request", { //
		method: "post",
		data: params,
	});

//三方库申请列表
export const getThirdLocationRequestList = (pageIndex,pageSize) => request(
	devUrl + "/api/pda/store/third-location-request/list?pageIndex="+pageIndex+"&pageSize="+pageSize, {
		method: 'get',
		data: {}
	})

//三方库申请详情
export const getThirdLocationRequestDetail = (id) => request(
	devUrl + "/api/pda/store/third-location-request/" + id, { //
		data: {},
		method: "get"
	});

//三方库发料申请 完成
export const thirdLocationRequestFinish = (id) => request(
	devUrl + "/api/pda/store/third-location-request/complete/"+id, {
		method: 'post',
		data: {}
	})


//三方库发料申请 取消
export const thirdLocationRequestCancel = (id) => request(
	devUrl + "/api/pda/store/third-location-request/cancel/"+id, {
		method: 'post',
		data: {}
	})
//三方库发料任务 终止
export const thirdLocationRequestComplete = (id) => request(
	devUrl + "/api/pda/job/third-location/Complete/"+id, {
		method: 'post',
		data: {}
	})

//三方库收货任务列表
export const getThirdLocationList = (params) => request(
	devUrl + "/api/pda/job/third-location/list", {
		method: 'get',
		data: params
	});
	
	
//根据Number 获取三方库收货任务
export const getThirdLocationJobByNumber = (number) => request(
	devUrl + "/api/pda/job/third-location/by-number/" + number, {
		data: {},
		method: "get"
	});

//承接三方库收货任务
export const takeThirdLocationJob = (params) => request(
	devUrl + "/api/pda/job/third-location/take/" + params.id, { //
		data: {},
		method: "post"
	});
	
//取消承接三方库收货任务
export const cancelTakeThirdLocationJob = (id) => request(
	devUrl + "/api/pda/job/third-location/cancel-take/" + id, { //
		data: {},
		method: "post"
	});

//提交三方库收货任务
export const finshThirdLocationJob = (params) => request(
	devUrl + "/api/pda/job/third-location/ExecuteDetail", { //
		data: params,
		method: "post"
	})
//三方库收货任务详情
export const getThirdLocationDetail = (params) => request(
	devUrl + "/api/pda/job/third-location/" + params.id, { //
		data: {},
		method: "get"
	});
	
//完工转储 注塑type ="Transfer_Injection"
// 喷涂 Transfer_Coating 装配  Transfer_Assemble
export const completeTransfer = (params) => request(
	devUrl + "/api/pda/store/transfer-note/", { //
		data: params,
		method: "post"
	});

//库移任务列表
export const getInventoryMoveList = (params) => request(
	devUrl + "/api/pda/store/transferlib-job/list", {
		method: 'get',
		data: params
	});

//库移任务详情
export const getInventoryMoveDetail = (params) => request(
	devUrl + "/api/pda/store/transferlib-job/" + params.id, { //
		data: {},
		method: "get"
	});
	
//承接库移任务
export const takeInventoryMoveJob = (params) => request(
	devUrl + "/api/pda/store/transferlib-job/accept/" + params.id, { //
		data: {},
		method: "post"
	});
	
//取消承接库移任务
export const cancelTakeInventoryMoveJob = (id) => request(
	devUrl + "/api/pda/store/transferlib-job/cancel-accept/" + id, { //
		data: {},
		method: "post"
	});

//提交库移任务
export const finshInventoryMoveJob = (id, params) => request(
	devUrl + "/api/pda/store/transferlib-job/complete/" + id, { //
		data: params,
		method: "post"
	})
//完工库移
export const completeInvenTransfer = (params) => request(
	devUrl + "/api/pda/store/transfer-note/", { //
		data: params,
		method: "post"
	});
	
//创建 注塑发料申请
export const injectionIssueRequest = (params) => request(
	devUrl + "/api/pda/store/injection-request", { //
		data: params,
		method: "post"
	})

//注塑 发料申请列表
export const getInjectionRequestList = (pageIndex,pageSize,isFinished) => request(
	devUrl + "/api/pda/store/injection-request/list?pageIndex="+pageIndex+"&pageSize="+pageSize+"&isFinished="+isFinished, {
		method: 'post',
		data: {}
	})

//注塑 发料申请 执行
export const injectionRequestHandle = (id) => promise(
	devUrl + "/api/pda/store/injection-request/handle/"+id, {
		method: 'post',
		data: {}
	})

//注塑发料申请 获取任务号
export const getInjectionRequestJobByRequest = (requestNumber) => promise(
	devUrl + "/api/pda/job/injection-issue/by-request-number/"+requestNumber, {
		method: 'post',
		data: {}
	})

//注塑发料 是否有新任务
export const isInjectionHasNewJob = (requestNumber,data) => promise(
	devUrl + "/api/pda/store/injection-request/isHasNewJob?requestNumber="+requestNumber, {
		method: 'post',
		data: data
	})
	
//注塑发料申请详情
export const injectionRequestDetail = (id) => promise(
	devUrl + "/api/pda/store/injection-request/"+id, {
		method: 'get',
		data: {}
	})



//注塑计划 申请
export const injectionIssuePlanRequest = (params) => request(
	devUrl + "/api/pda/store/injection-plan-request/", { //
		data: params,
		method: "post"
	})
	
//注塑计划 申请 类别获取详情
export const injectionIssuePlanRequestItemCategory = (categoryName) => request(
	devUrl + "/api/pda/store/injection-plan-request/list/item-category?categoryName="+categoryName, { //
		data: {},
		method: "get"
	})

//注塑计划 申请分类
export const injectionIssuePlanRequestItemCategoryName = () => request(
	devUrl + "/api/pda/store/injection-plan-request/item-category-name", { //
		data: {},
		method: "get"
	})

//注塑计划任务列表
export const getInjectionPlanJobList = (params) => request(
	devUrl + "/api/pda/job/injection-plan/list", {
		method: 'get',
		data: params
	})
//注塑发料任务详情
export const getInjectionPlanDetail = (params) => request(
	devUrl + "/api/pda/job/injection-plan/" + params.id, { //
		data: {},
		method: "get"
	});

//承接注塑计划任务
export const takeInjectionPlanJob = (params) => request(
	devUrl + "/api/pda/job/injection-plan/take/" + params.id, { //
		data: {},
		method: "post"
	});

//取消承接注塑计划 任务
export const cancelTakeInjectionPlanJob = (id) => request(
	devUrl + "/api/pda/job/injection-plan/cancel-take/" + id, { //
		data: {},
		method: "post"
	});
//提交注塑计划 任务
export const finshInjectionPlanJob = (id, params) => request(
	devUrl + "/api/pda/job/injection-plan/finish/" + id, { //
		data: params,
		method: "post"
	})
//注塑发料获取物料配置信息
export const getItemCategoryList = () => request(
	devUrl + "/api/pda/store/injection-plan-request/list/item-category", { //
		data: {},
		method: "get"
	})
	
//注塑发料 任务列表
export const getInjectionIssueList = (pageIndex,pageSize,jobStatus) => request(
	devUrl + "/api/pda/job/injection-issue/list?pageIndex="+pageIndex+"&pageSize="+pageSize+"&jobStatus="+jobStatus, {
		method: 'post',
		data: {}
	});	

//根据Number 获取注塑发料 任务列表
export const getInjectionIssueJobByNumber = (jobNumber) => request(
	devUrl + "/api/pda/job/injection-issue/by-number/" + jobNumber, {
		data: {},
		method: "get"
	});

// 根据MaterialRequest Number获取注塑发料任务列表
export const getInjectionIssueListByRequest = (requestNumber) => request(
	devUrl + "/api/pda/job/injection-request/list/by-request/" + requestNumber, { //
		data: {},
		method: "get"
	});

//注塑发料任务详情
export const getInjectionIssueDetail = (params) => request(
	devUrl + "/api/pda/job/injection-issue/" + params.id, { //
		data: {},
		method: "get"
	});

//承接注塑发料任务
export const takeInjectionIssueJob = (params) => request(
	devUrl + "/api/pda/job/injection-issue/take/" + params.id, { //
		data: {},
		method: "post"
	});

//取消承接 注塑发料任务
export const cancelTakeInjectionIssueJob = (id) => request(
	devUrl + "/api/pda/job/injection-issue/cancel-take/" + id, { //
		data: {},
		method: "post"
	});
//完成注塑发料任务
export const finshInjectionIssueJob = (masterId,detailId, params) => request(
	devUrl + "/api/pda/job/injection-issue/ExecuteDetail/" + masterId+"?detailId="+detailId, { //
		data: params,
		method: "post"
	})
	
//喷涂发料任务列表
export const getCoatingIssueList = (pageIndex,pageSize,jobStatus) => request(
	devUrl + "/api/pda/job/coating-issue/list?pageIndex="+pageIndex+"&pageSize="+pageSize+"&jobStatus="+jobStatus, {
		method: 'post',
		data: {}
	});	

//根据Number 获取喷涂发料任务列表
export const getCoatingIssueJobByNumber = (jobNumber) => request(
	devUrl + "/api/pda/job/coating-issue/by-number/" + jobNumber, {
		data: {},
		method: "get"
	});

// 根据MaterialRequest Number获取喷涂发料任务列表
export const getCoatingIssueListByRequest = (requestNumber) => request(
	devUrl + "/api/pda/job/coating-issue/list/by-request/" + requestNumber, { //
		data: {},
		method: "get"
	});

//喷涂发料任务详情
export const getCoatingIssueDetail = (params) => request(
	devUrl + "/api/pda/job/coating-issue/" + params.id, { //
		data: {},
		method: "get"
	});

//承接喷涂发料任务
export const takeCoatingIssueJob = (params) => request(
	devUrl + "/api/pda/job/coating-issue/take/" + params.id, { //
		data: {},
		method: "post"
	});	
	
//取消承接喷涂发料任务
export const cancelTakeCoatingIssueJob = (id) => request(
	devUrl + "/api/pda/job/coating-issue/cancel-take/" + id, { //
		data: {},
		method: "post"
	});	

//完成喷涂发料任务
export const finshCoatingIssueJob = (masterId,detailId, params) => request(
	devUrl + "/api/pda/job/coating-issue/ExecuteDetail/" + masterId+"?detailId="+detailId, { //
		data: params,
		method: "post"
	})
	
//创建 喷涂叫料申请
export const coatingIssueRequest = (params) => request(
	devUrl + "/api/pda/store/coating-request", { //
		data: params,
		method: "post"
	})

//喷涂发料申请列表
export const getCoatingRequestList = (pageIndex,pageSize,isFinished) => request(
	devUrl + "/api/pda/store/coating-request/list?pageIndex="+pageIndex+"&pageSize="+pageSize+"&isFinished="+isFinished, {
		method: 'post',
		data: {}
	})
	
//喷涂发料申请 执行
export const coatingRequestHandle = (id) => promise(
	devUrl + "/api/pda/store/coating-request/handle/"+id, {
		method: 'post',
		data: {}
	})

//喷涂发料申请 获取任务号
export const getCoatingRequestJobByRequest = (requestNumber) => promise(
	devUrl + "/api/pda/job/coating-issue/by-request-number/"+requestNumber, {
		method: 'post',
		data: {}
	})

//喷涂发料 是否有新任务
export const isCoatingHasNewJob = (requestNumber,data) => promise(
	devUrl + "/api/pda/store/coating-request/isHasNewJob?requestNumber="+requestNumber, {
		method: 'post',
		data: data
	})

//喷涂发料申请 详情
export const getCoatingRequestDetail = (id) => request(
	devUrl + "/api/pda/store/coating-request/" + id, { //
		data: {},
		method: "get"
	});

	
//装配发料任务列表
export const getAssembleIssueList = (pageIndex,pageSize,jobStatus) => request(
	devUrl + "/api/pda/job/assemble-issue/list?pageIndex="+pageIndex+"&pageSize="+pageSize+"&jobStatus="+jobStatus, {
		method: 'post',
		data: {}
	});	

//根据Number 获取装配发料任务列表
export const getAssembleIssueJobByNumber = (jobNumber) => request(
	devUrl + "/api/pda/job/assemble-issue/by-number/" + jobNumber, {
		data: {},
		method: "get"
	});

// 根据MaterialRequest Number获取装配发料任务列表
export const getAssembleIssueListByRequest = (requestNumber) => request(
	devUrl + "/api/pda/job/assemble-issue/list/by-request/" + requestNumber, { //
		data: {},
		method: "get"
	});

//装配发料任务详情
export const getAssembleIssueDetail = (params) => request(
	devUrl + "/api/pda/job/assemble-issue/" + params.id, { //
		data: {},
		method: "get"
	});
	
//承接装配发料任务
export const takeAssembleIssueJob = (params) => request(
	devUrl + "/api/pda/job/assemble-issue/take/" + params.id, { //
		data: {},
		method: "post"
	});

//取消承接装配发料任务
export const cancelTakeAssembleIssueJob = (id) => request(
	devUrl + "/api/pda/job/assemble-issue/cancel-take/" + id, { //
		data: {},
		method: "post"
	});

//完成装配发料任务
export const finshAssembleIssueJob = (masterId,detailId, params) => request(
	devUrl + "/api/pda/job/assemble-issue/ExecuteDetail/" + masterId+"?detailId="+detailId, { //
		data: params,
		method: "post"
	})

//创建 装配叫料申请
export const assembleIssueRequest = (params) => request(
	devUrl + "/api/pda/store/assemble-request", { //
		data: params,
		method: "post"
	})
	
//装配 发料申请列表
export const getAssembleRequestList = (pageIndex,pageSize,isFinished) => request(
	devUrl + "/api/pda/store/assemble-request/list?pageIndex="+pageIndex+"&pageSize="+pageSize+"&isFinished="+isFinished, {
		method: 'post',
		data: {}
	})

//装配 发料申请 执行
export const assembleRequestHandle = (id) => promise(
	devUrl + "/api/pda/store/assemble-request/handle/"+id, {
		method: 'post',
		data: {}
	})

//装配 发料申请 详情
export const getAssembleRequestDetail = (id) => request(
	devUrl + "/api/pda/store/assemble-request/" + id, { //
		data: {},
		method: "get"
	});

//装配 发料申请 获取任务号
export const getAssembleRequestJobByRequest = (requestNumber) => promise(
	devUrl + "/api/pda/job/assemble-issue/by-request-number/"+requestNumber, {
		method: 'post',
		data: {}
	})

//装配 发料 是否有新任务
export const isAssembleHasNewJob = (requestNumber,data) => promise(
	devUrl + "/api/pda/store/assemble-request/isHasNewJob?requestNumber="+requestNumber, {
		method: 'post',
		data: data
	})
	
//kiting发料任务列表
export const getKittingIssueList = (pageIndex,pageSize,jobStatus) => request(
	devUrl + "/api/pda/job/kitting-issue/list?pageIndex="+pageIndex+"&pageSize="+pageSize+"&jobStatus="+jobStatus, {
		method: 'post',
		data: {}
	});	

//根据Number 获取kiting发料任务列表
export const getKitingIssueJobByNumber = (jobNumber) => request(
	devUrl + "/api/pda/job/kitting-issue/by-number/" + jobNumber, {
		data: {},
		method: "get"
	});

// 根据MaterialRequest Number获取kiting发料任务列表
export const getKitingIssueListByRequest = (requestNumber) => request(
	devUrl + "/api/pda/job/kitting-request/list/by-request/" + requestNumber, { //
		data: {},
		method: "get"
	});
		
//kiting发料申请列表
export const getKittingRequestList = (pageIndex,pageSize,isFinished) => request(
	devUrl + "/api/pda/store/kitting-request/list?pageIndex="+pageIndex+"&pageSize="+pageSize+"&isFinished="+isFinished, {
		method: 'post',
		data: {}
	})

//kiting发料申请 执行
export const kittingRequestHandle = (id) => promise(
	devUrl + "/api/pda/store/kitting-request/handle/"+id, {
		method: 'post',
		data: {}
	})
//kiting发料申请 获取任务号
export const getkittingRequestJobByRequest = (requestNumber) => promise(
	devUrl + "/api/pda/job/kitting-issue/by-request-number/"+requestNumber, {
		method: 'post',
		data: {}
	})

//kiting发料 是否有新任务
export const iskittingHasNewJob = (requestNumber,data) => promise(
	devUrl + "/api/pda/store/kitting-request/isHasNewJob?requestNumber="+requestNumber, {
		method: 'post',
		data: data
	})
//kiting发料申请 详情
export const getKittingRequestDetail = (id) => request(
	devUrl + "/api/pda/store/kitting-request/" + id, { //
		data: {},
		method: "get"
	});
	
//kiting发料任务详情
export const getKittingIssueDetail = (params) => request(
	devUrl + "/api/pda/job/kitting-issue/" + params.id, { //
		data: {},
		method: "get"
	});

//承接kiting发料任务
export const takeKittingIssueJob = (params) => request(
	devUrl + "/api/pda/job/kitting-issue/take/" + params.id, { //
		data: {},
		method: "post"
	});

//取消承接kiting发料任务
export const cancelTakeKittingIssueJob = (id) => request(
	devUrl + "/api/pda/job/kitting-issue/cancel-take/" + id, { //
		data: {},
		method: "post"
	});
//完成kiting发料任务
export const finshKittingIssueJob = (masterId,detailId, params) => request(
	devUrl + "/api/pda/job/kitting-issue/ExecuteDetail/" + masterId+"?detailId="+detailId, { //
		data: params,
		method: "post"
	})
//创建 kiting叫料申请
export const kittingIssueRequest = (params) => request(
	devUrl + "/api/pda/store/kitting-request", { //
		data: params,
		method: "post"
	})
//通过ERP料号查询收容数
export const getCountByItemCode = (itemCode) => request(
	devUrl + "/api/pda/item-container/by-item?itemCode="+itemCode, { //
		data: {},
		method: "get"
	})
	
//备件发料任务列表
export const getSparePartIssueList = (pageIndex,pageSize,jobStatus) => request(
	devUrl + "/api/pda/job/spare-part-issue/list?pageIndex="+pageIndex+"&pageSize="+pageSize+"&jobStatus="+jobStatus, {
		method: 'post',
		data: {}
	});	

//根据Number 获取备件发料任务列表
export const getSparePartIssueJobByNumber = (jobNumber) => request(
	devUrl + "/api/pda/job/spare-part-issue/by-number/" + jobNumber, {
		data: {},
		method: "get"
	});

// 根据MaterialRequest Number获取备件发料任务列表
export const getSparePartIssueListByRequest = (requestNumber) => request(
	devUrl + "/api/pda/job/spare-part-request/list/by-request/" + requestNumber, { //
		data: {},
		method: "get"
	});
		
//备件发料申请列表
export const getSparePartRequestList = (pageIndex,pageSize,isFinished) => request(
	devUrl + "/api/pda/store/spare-part-request/list?pageIndex="+pageIndex+"&pageSize="+pageSize+"&isFinished="+isFinished, {
		method: 'post',
		data: {}
	})

//备件发料申请 执行
export const sparePartRequestHandle = (id) => promise(
	devUrl + "/api/pda/store/spare-part-request/handle/"+id, {
		method: 'post',
		data: {}
	})
//备件发料申请 获取任务号
export const getSparePartRequestJobByRequest = (requestNumber) => promise(
	devUrl + "/api/pda/job/spare-part-issue/by-request-number/"+requestNumber, {
		method: 'post',
		data: {}
	})

//备件发料 是否有新任务
export const isSparePartHasNewJob = (requestNumber,data) => promise(
	devUrl + "/api/pda/store/spare-part-request/isHasNewJob?requestNumber="+requestNumber, {
		method: 'post',
		data: data
	})
//备件发料申请 详情
export const getSparePartRequestDetail = (id) => request(
	devUrl + "/api/pda/store/spare-part-request/" + id, { //
		data: {},
		method: "get"
	});
	
//备件发料任务详情
export const getSparePartIssueDetail = (params) => request(
	devUrl + "/api/pda/job/spare-part-issue/" + params.id, { //
		data: {},
		method: "get"
	});

//承接备件发料任务
export const takeSparePartIssueJob = (params) => request(
	devUrl + "/api/pda/job/spare-part-issue/take/" + params.id, { //
		data: {},
		method: "post"
	});

//取消承接备件发料任务
export const cancelTakeSparePartIssueJob = (id) => request(
	devUrl + "/api/pda/job/spare-part-issue/cancel-take/" + id, { //
		data: {},
		method: "post"
	});
//完成备件发料任务
export const finshSparePartIssueJob = (masterId,detailId, params) => request(
	devUrl + "/api/pda/job/spare-part-issue/ExecuteDetail/" + masterId+"?detailId="+detailId, { //
		data: params,
		method: "post"
	})
//创建 备件叫料申请
export const sparePartIssueRequest = (params) => request(
	devUrl + "/api/pda/store/spare-part-request", { //
		data: params,
		method: "post"
	})
//拆箱的时候，通过箱码获取原箱码采购订单信息
export const getPoNumberByPackingCode = (toPackingCode) => promise(
	devUrl + "/api/pda/split-packing-rec/get-split-packing-code?toPackingCode="+toPackingCode, { //
		data: {},
		method: "get"
	})