aiot-app/pages/warehouse/enterHouse/addStock.vue

<template>
	<view class="mainBox">
		<uni-nav-bar fixed="true" statusBar="true" left-icon="back" title="新增入库单" @clickLeft="back">
			<!-- @clickRight="handleScan"
      right-icon="scan"
    > -->
			<!--右菜单-->
			<template slot="float">
				<!-- <view class="nav-icon-caozuo rightNav" @click="getsure">
					<u-button type="success" size="small" class="u-reset-button" text="确定"></u-button>
				</view> -->
			</template>
		</uni-nav-bar>

		<u-form labelPosition="left" :model="formData" :rules="rules" ref="formRef" labelWidth="240" labelAlign="right"
			class="baseForm">
			<u-form-item label="物品类型" class="required-form" borderBottom prop="assetTypeName">
				<view :style="{ color: assetTypeName ? 'black' : '#c0c4cc' }" class="assetType_box" @click="openPicker">
					{{ assetTypeName ? assetTypeName : '请选择产品类型' }}
				</view>
			</u-form-item>
			<u-form-item label="来源单据" prop="documentSource" borderBottom>
				<u-input type="text" placeholder="请输入" v-model="formData.sourceBizNo" @click.native="goToRequisition" />
			</u-form-item>
			<u-form-item label="入库类型" class="required-form" prop="bizType" borderBottom>
				<uni-data-select v-model="formData.bizType" :localdata="sceneState"
					@change="changeType"></uni-data-select>
				<!-- <picker :disabled="!!(productList && productList.length)"
					@change="handlePicker(e, sceneState, 'bizType')" :value="pickerIndex" :range="sceneState"
					range-key="text">
					<u-input :value="sceneStateFilter(formData.bizType)"
						:disableColor="!!(productList && productList.length) ? '#F5F7FA' : '#fff'" placeholder="请选择"
						disabled type="select" />
				</picker> -->
				<!-- <u-icon slot="right" name="arrow-right"></u-icon> -->
			</u-form-item>
			<u-form-item label="入库时间" prop="storageTime" borderBottom>
				<view class="assetType_box" @click="timeShow = true">{{ storageTime ? formatter(storageTime) : '请选择' }}
				</view>
			</u-form-item>
			<u-form-item label="入库登记人" prop="createUserName" borderBottom>
				<u-input disableColor="#ffffff" :value="formData.extInfo.createUserName" placeholder="请选择" disabled
					type="text" />
			</u-form-item>
			<!-- <u-form-item label="客户名称" prop="clientName" borderBottom>
				<u-input type="text" placeholder="请输入" v-model="formData.clientName" />
			</u-form-item> -->
			<u-form-item label="供应商" prop="supplierName" borderBottom v-if="formData.bizType == 2">
				<u-input type="text" placeholder="请输入" v-model="formData.extInfo.supplierName" />
			</u-form-item>
			<u-form-item label="送货人" prop="deliveryName" borderBottom>
				<u-input type="text" placeholder="请输入" v-model="formData.fromUser" />
			</u-form-item>
			<u-form-item label="送货人联系方式" prop="deliveryPhone" borderBottom>
				<u-input type="text" placeholder="请输入" v-model="formData.extInfo.deliveryPhone" />
			</u-form-item>
			<u-form-item label="备注" prop="remark" borderBottom>
				<u-input disableColor="#ffffff" v-model="formData.remark" placeholder="请输入内容" type="text" />
			</u-form-item>
		</u-form>

		<uni-collapse ref="collapse" v-model="collapseOpen">
			<uni-collapse-item :typeOpen="1" title="" name="collapse1" :open="true" :key="detailOpen"
				:show-animation="true">
				<template v-slot:title>
					<view class="detail-box flex_between">
						<view data-v-41027c34="" class="uni-collapse-item__title-wrap">
							<view data-v-41027c34=""
								class="uni-collapse-item__title-box uni-collapse-item__title-box-base">
								<text data-v-41027c34="" class="tag tag-base"><text></text></text>
								<text data-v-41027c34="" class="uni-collapse-item__title-text"><text>入库明细</text></text>
							</view>
						</view>
					<u-button type="primary" size="small" text="扫码添加"
						@click.native.stop="goToScanCodeList"></u-button>
						<u-button type="success" size="small" class="selectEnterType" text="手动添加"
							@click.native.stop="selectType"></u-button>
					</view>
				</template>
				<view>
					<u-button type="warning" size="small" text="批量保存"
							@click.native.stop="batchSave" v-if="productList.length"></u-button>
				</view>
				<u-form labelPosition="left" :model="{ productList: productList }" ref="lisrFormRef" labelWidth="160"
					:rules="listRules" errorType="none" labelAlign="right" :labelStyle="{
						fontSize: '28rpx'
					}">
					<view class="listContent">
						<view class="listBox" v-for="(item, index) in productList" :key="index">
							<view class="listTit flex_between">
								<view class="name">{{ item.categoryName }}</view>
								<view class="btn">
									<u-button v-if="item.isSave" type="primary" size="small" :hairline="true" text="编辑"
										@click="listEdit(item, index)"></u-button>
									<u-button v-else type="primary" size="small" :hairline="true" text="保存"
										@click="listSave(item, index)"></u-button>
									<u-button type="error" size="small" :hairline="true" text="删除"
										@click="getDelete(index)"></u-button>
								</view>
							</view>
							<view class="listCont" :class="{ save: item.isSave }">
								<view class="item w100">
									<u-form-item :label="`物品编码`">
										{{ item.categoryCode }}
									</u-form-item>
								</view>
								<view class="item w100">
									<u-form-item :label="`型号`">
										{{ item.categoryModel || '-' }}
									</u-form-item>
								</view>
								<view class="item w100">
									<u-form-item :label="`规格`">
										{{ item.specification || '-' }}
									</u-form-item>
								</view>
								<view class="item w100">
									<u-form-item :label="`牌号`">
										{{ item.brandNum || '-' }}
									</u-form-item>
								</view>
								<view class="item w100">
									<u-form-item label="包装规格" prop="packingSpecificationLabel">
										<u-tag style="margin-right: 5rpx" v-for="ite in item.packingSpecificationLabel"
											:text="ite"></u-tag>
									</u-form-item>
								</view>
								<view class="item">
									<u-form-item label="批次号" :prop="`productList.${index}.batchNo`"
										class="required-form">
										<u-input :disabled="item.isSave" placeholder="请输入" style="height: 30px;"
											v-model="item.batchNo" />
									</u-form-item>
								</view>
								<view class="flex_between w100">
									<view class="item">
										<u-form-item label="数量" :prop="`productList.${index}.quantity`"
											class="aa required-form">
											<u--input :disabled="item.isSave" placeholder="请输入" border="surround"
												v-model="item.quantity"
												@change="computeNum(item, index, true)"></u--input>
										</u-form-item>
									</view>
									<view class="item">
										<u-form-item label="单位" :prop="`productList.${index}.unit`"
											class="dd required-form">
											<view
												:style="{ color: item.unit ? 'black' : '#c0c4cc',marginLeft:'9px' }"
												class="assetType_box" :disabled="item.isSave"
												@click="showPackingUnitPicker(item, index)">
												{{ item.unit ? item.unit : '请选择' }}
											</view>
										</u-form-item>
									</view>
								</view>
								<view class="item">
									<u-form-item label="仓库" :prop="`productList.${index}.warehouseId`"
										class="dd required-form">
										<view
											:style="{ color: item.warehouseName ? 'black' : '#c0c4cc',marginLeft:'9px' }"
											class="assetType_box" :disabled="item.isSave"
											@click="showWarehousePicker( index)">
											{{ item.warehouseName ? item.warehouseName : '请选择' }}
										</view>
									</u-form-item>
								</view>
								<view class="item w100">
									<u-form-item label="供应商" :prop="`productList.${index}.supplierName`" class="dd">
										<view
											:style="{ color: item.supplierName ? 'black' : '#c0c4cc',marginLeft:'9px' }"
											class="assetType_box" :disabled="item.isSave"
											@click="showSupplierPicker(item, index)">
											{{ item.supplierName ? item.supplierName : '请选择' }}
										</view>
									</u-form-item>
								</view>
								<view class="item">
									<u-form-item label="颜色" :prop="`productList.${index}.colorKey`"
										class="dd">
										<!-- <u--input :disabled="item.isSave" placeholder="请输入" border="surround"
											v-model="item.batchNo"></u--input> -->
										<u-input placeholder="请输入" style="height: 30px;"
											v-model="item.colorKey" />
									</u-form-item>
								</view>
								<view class="item">
									<u-form-item label="盘具" :prop="`productList.${index}.reelSpecification`"
										class="dd">
										<u-input placeholder="请输入" style="height: 30px;"
											v-model="item.reelSpecification" />
									</u-form-item>
								</view>
								<view class="item">
									<u-form-item label="采购原因" :prop="`productList.${index}.purpose`"
										class="dd">
										<u-input :disabled="item.isSave" placeholder="请输入" style="height: 30px;"
											v-model="item.purpose" />
									</u-form-item>
								</view>
								<view class="item">
									<u-form-item label="生产日期" :prop="`productList.${index}.detailProductionDate`"
										class="dd">
										<view :style="{ color: item.detailProductionDate ? 'black' : '#c0c4cc' }"
											class="assetType_box" @click="datePickerOpen(index, 'detailProductionDate')">
											{{ item.detailProductionDate || '请选择' }}
										</view>
									</u-form-item>
								</view>
								<view class="item">
									<u-form-item label="采购日期" :prop="`productList.${index}.detailPurchaseDate`"
										class="dd">
										<view :style="{ color: item.detailPurchaseDate ? 'black' : '#c0c4cc' }"
											class="assetType_box" @click="datePickerOpen(index, 'detailPurchaseDate')">
											{{ item.detailPurchaseDate || '请选择' }}
										</view>
									</u-form-item>
								</view>
								<view class="item">
									<u-form-item label="失效日期" :prop="`productList.${index}.detailExpireDate`"
										class="dd">
										<view :style="{ color: item.detailExpireDate ? 'black' : '#c0c4cc' }"
											class="assetType_box" @click="datePickerOpen(index, 'detailExpireDate')">
											{{ item.detailExpireDate || '请选择' }}
										</view>
									</u-form-item>
								</view>
								
								<view class="flex_between w100">
									<view class="item">
										<u-form-item label="包装数量"
											prop="measureQuantity">{{ item.packingQuantity }}</u-form-item>
									</view>
									<view class="item">
										<u-form-item label="包装单位"
											prop="measureUnit">{{ item.packingUnit }}</u-form-item>
									</view>
								</view>
								<view class="flex_between w100">
									<view class="item">
										<u-form-item label="计量数量"
											prop="measureQuantity">{{ item.measureQuantity }}</u-form-item>
									</view>
									<view class="item">
										<u-form-item label="计量单位"
											prop="measureUnit">{{ item.measureUnit }}</u-form-item>
									</view>
								</view>
								<view class="flex_between w100">
									<view class="item">
										<u-form-item label="单重" :prop="`productList.${index}.singleWeight`"
										class="required-form">
										<u-input :disabled="item.isSave" placeholder="请输入" style="height: 30px;"
											v-model="item.singleWeight" />
									</u-form-item>
									</view>
									<view class="item">
										<u-form-item label="总重" :prop="`productList.${index}.weight`">
											<u-input :disabled="item.isSave" placeholder="请输入" style="height: 30px;"
											v-model="item.weight" />
										</u-form-item>
									</view>
								</view>
								<view class="item">
									<u-form-item label="重量单位" prop="weightUnit">{{ item.weightUnit }}</u-form-item>
								</view>
								<view class="item">
									<u-form-item label="是否拆包"
										prop="isUnpack">{{ item.isUnpack ? '是' : '否' }}</u-form-item>
								</view>
							</view>
							<view class="selectTime" v-if="item.outInDetailRecordRequestList.length > 0">
								<view class="title">包装列表</view>
								<view class="timeBox">
									<u-button class="firstBtn" size="small" type="primary" text="选择时间类型"
										@click="timeTypeShow = true"></u-button>
									<u-button type="warning" size="small"
										:text="`批量设置${currentDateType?curDateTypeLabel[currentDateType]:''}`"
										@click="typeTimeClick(index)"></u-button>
								</view>
							</view>
							<u-list @scrolltolower="scrolltolower" class="z_list" style="height: 100% !important">
								<view class="material rx-ss" v-for="(ite, idx) in item.outInDetailRecordRequestList"
									:key="idx">
									<!-- <view class="left rx-ss" @click="deletePacking(index, idx)">
										<uni-icons custom-prefix="iconfont" type="icon-shanchu" size="20" color="#fa3534"></uni-icons>
									</view> -->
									<view class="content_table">
										<view class="item">
											<view class="lable rx-cc">序号</view>
											<view class="content">{{ idx + 1 }}</view>
										</view>
										<view class="item">
											<view class="lable rx-cc">批次号</view>
											<view class="content">{{ ite.batchNo }}</view>
										</view>
										<view class="item">
											<view class="lable rx-cc">包装编码</view>
											<view class="content">{{ ite.packageNo }}</view>
										</view>
										<view class="item">
											<view class="lable rx-cc">名称/编码</view>
											<view class="content">{{ ite.categoryName }} / {{ ite.categoryCode }}</view>
										</view>
										<view class="item">
											<view class="lable rx-cc">型号/规格</view>
											<view class="content">{{ ite.categoryModel || '-' }} / {{ ite.specification || '-' }}</view>
										</view>
										<view class="item">
											<view class="lable rx-cc">牌号</view>
											<view class="content">{{ ite.brandNum || '-' }}</view>
										</view>
										<view class="item">
											<view class="lable rx-cc">包装数量({{ ite.packingUnit }})</view>
											<view class="content">{{ ite.packingQuantity }}</view>
										</view>
										<view class="item">
											<view class="lable rx-cc">计量数量({{ ite.measureUnit }})</view>
											<view class="content">{{ ite.measureQuantity }}</view>
										</view>
										<view class="item">
											<view class="lable rx-cc">仓库</view>
											<view class="content">{{ ite.warehouseName || '-' }}</view>
										</view>
										<view class="item">
											<view class="lable rx-cc">供应商</view>
											<view class="content">{{ ite.supplierName || '-' }}</view>
										</view>
										<view class="item">
											<view class="lable rx-cc">供应商代号</view>
											<view class="content">{{ ite.supplierCode || '-' }}</view>
										</view>
										<view class="item">
											<view class="lable rx-cc">机型</view>
											<view class="content">{{ ite.modelKey || '-' }}</view>
										</view>
										<view class="item">
											<view class="lable rx-cc">颜色</view>
											<view class="content">{{ ite.colorKey || '-' }}</view>
										</view>
										<view class="item">
											<view class="lable rx-cc">物料代号</view>
											<view class="content input_box"><u--input clearable placeholder="请输入"
													border="surround" v-model="ite.materielDesignation"></u--input>
											</view>
										</view>
										<view class="item">
											<view class="lable rx-cc">客户代号</view>
											<view class="content input_box"><u--input clearable placeholder="请输入"
													border="surround" v-model="ite.clientCode"></u--input></view>
										</view>
										<view class="item">
											<view class="lable rx-cc">刻码</view>
											<view class="content input_box"><u--input clearable placeholder="请输入"
													border="surround" v-model="ite.engrave"></u--input></view>
										</view>
										<view class="item">
											<view class="lable rx-cc">重量({{ ite.weightUnit }})</view>
											<view class="content input_box">
												<u--input clearable placeholder="请输入" border="surround"
													v-model="ite.weight"
													@change="weightInput($event, ite, index)"></u--input>
											</view>
										</view>
										<view class="item">
											<view class="lable rx-cc">重量单位</view>
											<view class="content">{{ ite.weightUnit || '-' }}</view>
										</view>
										<view class="item">
											<view class="lable rx-cc">质检结果</view>
											<view class="content" @click="statusClick(index, idx)">
												{{ qualityResults[ite.result] || qualityResults[ite.status] }}
											</view>
										</view>
										<view class="item">
											<view class="lable rx-cc">生产日期</view>
											<view class="content">{{ ite.productionDate || '-' }}</view>
										</view>
										<view class="item">
											<view class="lable rx-cc">采购日期</view>
											<view class="content">{{ ite.purchaseDate || '-' }}</view>
										</view>
										<view class="item">
											<view class="lable rx-cc">失效日期</view>
											<view class="content">{{ ite.expireDate || '-' }}</view>
										</view>
										
									</view>
								</view>
							</u-list>
						</view>
					</view>
				</u-form>
			</uni-collapse-item>
		</uni-collapse>
		<view class="footBox">
			<view class="reg" @click="submit">
				<uni-icons custom-prefix="iconfont" size="20" color="#fff"></uni-icons>
				提交
			</view>
		</view>
		<!-- 选择物品类型 -->
		<ba-tree-picker ref="treePicker" :multiple="true" @select-change="confirm" title="选择物品类型"
			:localdata="goodsLists" valueKey="id" textKey="name" childrenKey="child" />
		<!-- 选择入库时间 -->
		<u-datetime-picker @confirm="timeConfirm" @cancel="timeCancel" :show="timeShow" v-model="storageTime"
			mode="datetime"></u-datetime-picker>
		<!-- 选择包装单位 -->
		<u-picker :show="packingUnitsShow" visibleItemCount="10" :columns="currentPackingSpecificationOption"
			keyName="conversionUnit" @confirm="selectPackingUnitInfo" @cancel="packingUnitsShow = false"
			title="选择包装单位"></u-picker>
		<!-- 选择供应商单位 -->
		<u-picker :show="suppliersShow" visibleItemCount="10" :columns="currentSupplierListOption" keyName="name"
			@confirm="selectSuppliersInfo" @cancel="suppliersShow = false" title="选择供应商"></u-picker>
		<!-- 选择仓库 -->
		<u-picker :show="warehouseShow" visibleItemCount="10" :columns="warehouseListOption" keyName="name"
			@confirm="selectWarehouseInfo" @cancel="warehouseShow = false" title="选择仓库"></u-picker>
		<!-- 选择时间类型 -->
		<u-picker :show="timeTypeShow" visibleItemCount="10" :columns="timeTypeOption" keyName="name"
			@confirm="selectTimeTypeInfo" @cancel="timeTypeShow = false" title="选择时间类型"></u-picker>
		<!-- 选择生产/采购日期 -->
		<u-datetime-picker @confirm="typeTimeConfirm" @cancel="typeTimeShow = false" :show="typeTimeShow"
			v-model="currentTypeTime" mode="datetime"></u-datetime-picker>
		<!-- 选择质检状态 -->
		<u-picker :show="statusShow" visibleItemCount="10" :columns="qualityResultsOption" keyName="label"
			@confirm="selectStautsInfo" @cancel="statusShow = false" title="选择质检状态"></u-picker>
		<!-- 产品日期选择 -->
		<u-datetime-picker @confirm="itemDateConfirm" @cancel="itemDateShow = false" :show="itemDateShow"
			v-model="currentItemDate" mode="date"></u-datetime-picker>
	</view>
</template>

<script>
	// import ScanCode from '@/components/ScanCode.vue'
	import {
		getTreeByGroup,
		contactQueryByCategoryIdsAPI,
		getCode,
		getCategoryPackageDisposition,
		getWarehouseList,
		getAssetNum,
		storage,
		qualityInspectionTwo,
		submitTwo,
		warehouseDefinitionList,
		isVerifyRepeatIsStock
	} from '@/api/warehouseManagement'
	import {
		getGroupList
	} from '@/api/wt'
	import {
		getByCode
	} from '@/api/pda/common'
	import dayjs from 'dayjs'
	import {
		sceneState
	} from '../common'
	import {
		post,
		postJ,
		get,
		getJ
	} from '@/utils/api.js'
	import WarehouseChoose from '@/components/WarehouseChoose'
	import {
		warehousingType,
		inputStatus,
		emergencyState,
		warehousingMaterialListTable,
		getDictName,
		materialType
	} from '../enum.js'
	import baTreePicker from '@/components/ba-tree-picker/ba-tree-picker.vue'
	// import addDetails from '@/components/addDetails'
	import UploadFileNew from '@/components/UploadFileNew'
	// import { getRuleNo } from '@/utils/utils.js'
	import {
		tableHeader
	} from '../common'
	// import dictMixins from '@/mixins/dictMixins.js'
	export default {
		components: {
			WarehouseChoose,
			baTreePicker,
			UploadFileNew
		},
		// mixins: [dictMixins],
		data() {
			return {
				goodsLists: [], // 物品类型
				assetTypeName: '', // 物品类型名称
				timeShow: false,
				packingSpecificationOption: [], // 包装规格
				currentPackingSpecificationOption: [], // 当前包装规格
				currentSupplierListOption: [], // 当前供货商
				warehouseListOption: [], // 仓库列表
				currentTypeTime: Number(new Date()), // 当前时间类型的时间
				storageTime: '', // 入库时间
				currentProductIndex: null, // 当前产品索引
				currentPackingIndex: null, // 当前包装索引
				packingUnitsShow: false,
				typeTimeShow: false,
				suppliersShow: false,
				warehouseShow: false,
				timeTypeShow: false,
				statusShow: false,
				itemDateShow: false, // 产品日期选择弹窗
				itemDateTarget: '', // 产品日期目标字段
				currentEditIndex: null, // 当前编辑的产品索引
				currentItemDate: Number(new Date()), // 产品日期选择值
				dictCodeList: [], // 字典列表
				curDateType: 'purchaseDate',
				currentDateType: 'purchaseDate',
				qualityResultsOption: [
					[{
							label: '合格',
							value: 1
						},
						{
							label: '不合格',
							value: 2
						}
					]
				], // 质检状态 0未检 1已检
				qualityResults: {
					1: '合格',
					2: '不合格'
				}, // 质检结果 1合格 2不合格
				curDateTypeLabel: {
					purchaseDate: '采购日期',
					productionDate: '生产日期',
					expireDate: '失效日期'
				},
				timeTypeOption: [
					[{
							name: '采购日期',
							prop: 'purchaseDate'
						},
						{
							name: '生产日期',
							prop: 'productionDate'
						},
						{
							name: '失效日期',
							prop: 'expireDate'
						}
					]
				], // 时间类型
				collapseOpen: 'collapse1',
				emergencyState,
				warehousingType,
				materialType,
				sceneState,
				inputStatus,
				getDictName,
				detailOpen: false,
				codeOpen: false,
				deptList: [], //部门
				supplierList: [], //供应商
				formData: {
					type: 1, // 入库
					bizType: '', // 入库场景
					storageTime: '', // 入库时间
					extInfo: {}, // 扩展信息
					sourceBizNo: '', // 来源单据编号
					clientName: '', // 客户名称
					fromUser: '', // 送货人
					remark: '' // 备注
				},
				statusList: [{
						id: 1,
						name: '紧急'
					},
					{
						id: 2,
						name: '中等'
					},
					{
						id: 1,
						name: '普通'
					}
				], //紧急状态
				pickerIndex: 0,
				productList: [],
				userList: [],
				rules: {
					assetType: {
						type: 'number',
						required: true,
						message: '请选择入库产品类型',
						trigger: ['blur', 'change']
					},
					bizType: {
						type: 'number',
						required: true,
						message: '请选择入库场景',
						trigger: ['blur', 'change']
					}
					// contentImage: {
					//   type: 'array',
					//   required: true,
					//   message: '请上传附件',
					//   trigger: ['blur', 'change']
					// }
				},
				settingIndex: 0
			}
		},
		onShow() {
			// const _this = this
			// uni.$off('scancode') // 每次进来先 移除全局自定义事件监听器
			// uni.$on('scancode', function (data) {
			//   uni.navigateBack({
			//     delta: 1
			//   })
			//   _this.qrContent = data.code.trim()
			//   _this.handleScan()
			// })
			this.collapseOpen = 'collapse1'
		},
		beforeDestroy() {
			uni.$off('setSelectList')
			uni.$off('requisitionSelect')
		},
		async onLoad(options) {
			await this.getListItems() // 物品类型
			// await this.getwarehouseList() // 仓库列表
			await this.requireDictCode() // 字典列表
			// this.requestDict('物品类型')
			// this.getDept()
			// this.getSupplier()
			// const userInfo = uni.getStorageSync('userInfo')
			// console.log('userInfo~~~', userInfo)
			// this.formData.extInfo.createUserName = userInfo.name
			// this.formData.createUserId = userInfo.userId
			this.initUserInfo()
			this.storageTime = Number(new Date())
			this.formData.storageTime = this.formatter(this.storageTime)
			// this.formData.registerId = userInfo.id
			uni.$on('setSelectList', async data => {
				if (data?.length) {
					this.formData.sourceBizNo = ''
					// 获取批次号
					const batchNo = await getCode('lot_number_code')
					// 获取供应商
					const supplierList = await contactQueryByCategoryIdsAPI({
						categoryIds: data.map(item => item.id)
					})
					// 获取包装规格
					let packingSpecification = await getCategoryPackageDisposition({
						categoryIds: data.map(item => item.id)
					})
					this.packingSpecificationOption = data.map(item => {
						return packingSpecification.filter(ite => item.id == ite.categoryId).sort((
							a, b) => a.sort - b.sort)
					})
					let productList = data.map((item, index) => {
						// 显示规格
						let packingSpecificationLabel = this.packingSpecificationOption[index]
							.map(item => {
								if (item.sort > 0) {
									return `${item.packageCell}${item.packageUnit}/${item.conversionUnit}`
								}
							})
							.filter(item => !!item)
						// 默认单位取第一层
						const defaultPackingUnitId = this.packingSpecificationOption[index]?.[0]?.id || ''
						const defaultPackingUnit = this.packingSpecificationOption[index]?.[0]?.conversionUnit || ''
						return {
							index: this.productList.length - 1 > -1 ? this.productList[this
									.productList.length - 1].index + index + 1 : this.productList
								.length + index,
							isSave: false,
							categoryId: item.id, // 物品id
							categoryName: item.name, // 物品名称
							categoryCode: item.code, // 物品编码
							categoryLevelPathIdParent: item.categoryLevelPathIdParent || '', // 物品类型父级ID（仓库过滤用）
							categoryModel: item.modelType || '', // 物品型号
							specification: item.specification || '', // 规格
							brandNum: item.brandNum || '', // 牌号
							batchNo: batchNo, // 批次号
							supplierListOptions: supplierList[item.id] || [], // 供应商列表
							supplierId: '', // 供应商id
							supplierName: '', // 供应商名称
							supplierCode: '', // 供应商代号
							approvalNumber: item.approvalNumber || '', // 批准文号
							packingSpecification: item.packingSpecification, // 包装规格
							packingSpecificationOption: this.packingSpecificationOption[
								index], // 包装规格选项
							packingSpecificationLabel: packingSpecificationLabel, // 包装规格显示
							minPackingQuantity: '', // 最小包装单元数量
							quantity: '', // 数量
							unitId: defaultPackingUnitId, // 默认单位ID
							unit: defaultPackingUnit, // 默认单位
							packingQuantity: '', // 包装数量(兼容)
							packingUnit: item.packingUnit || '', // 包装单位
							measureQuantity: 0, // 计量数量
							measureUnit: item.measuringUnit || '', // 计量单位
							netWeight: item.netWeight > 0 ? item.netWeight : 0, // 净重
							weight: 0, // 重量
							weightUnit: item.weightUnit || '', // 重量单位
							totalMoney: '', // 总价
							price: item.price || '', // 单价
							purpose: '', // 采购原因
							isUnpack: item.isUnpack, // 是否允许拆包
							reelSpecification: '', // 盘具
							modelKey: item.modelKey ? item.modelKey?.split(',')?.[0] || '' : '', // 机型
							colorKey: item.colorKey ? item.colorKey?.split(',')?.[0] || '' : '', // 颜色
							materielDesignation: '', // 物料代号
							clientCode: '', // 客户代号
							engrave: '', // 刻码
							detailProductionDate: '', // 生产日期
							detailPurchaseDate: '', // 采购日期
							detailExpireDate: '', // 失效日期
							singleWeight: 0, // 单重
							warehouseId: '', // 仓库ID
							warehouseName: '', // 仓库名称
							warehouseIds: [], // 仓库ID列表
							warehouseNames: [], // 仓库名称列表
							filteredWarehouseList: [], // 按产品类型过滤的仓库列表
							outInDetailRecordRequestList: [],
							extField: item.extField,
						}
					})

					this.productList = this.productList.concat(productList)
					console.log(this.productList, '------------------this.productList----111-----')
					setTimeout(() => {
						this.detailOpen = !this.detailOpen
						this.$refs.collapse && this.$refs.collapse.resize()
					}, 0)
				}
			})
			uni.$on('requisitionSelect', async (data, query) => {
				console.log(data)

				this.formData.sourceBizNo = query.sourceBizNo
				this.formData.bizType = parseInt(query.bizType)
				this.formData.extInfo.assetType = query.assetType.split(',')
				let filterArray = this.formData.extInfo.assetType.map(item => {
					return this.goodsLists.find(ite => ite.id == item).name
				})
				this.assetTypeName = Array.from(new Set(filterArray)).join('/')
				const batchNo = await getCode('lot_number_code')
				// 获取包装规格
				let packingSpecification = await getCategoryPackageDisposition({
					categoryIds: data.map(item => item.categoryId)
				})
				this.packingSpecificationOption = data.map(item => {
					return packingSpecification.filter(ite => item.categoryId == ite.categoryId)
						.sort((a, b) => a.sort - b.sort)
				})
				this.productList = data.map((productItem, productIndex) => {
						// 显示规格
						let packingSpecificationLabel = this.packingSpecificationOption[productIndex]
							.map(item => {
								if (item.sort > 0) {
									return `${item.packageCell}${item.packageUnit}/${item.conversionUnit}`
								}
							})
							.filter(item => !!item)
						return {
							...productItem,
							index: this.productList.length + productIndex,
							isSave: productItem.outInDetailRecordRequestList?.length > 0 ? true :
								false,
							// 默认字段（兼容来源数据可能缺失）
							categoryModel: productItem.categoryModel || productItem.modelType || '',
							netWeight: productItem.netWeight > 0 ? productItem.netWeight : 0,
							weight: productItem.weight ? Number(productItem.weight) : 0,
							reelSpecification: productItem.reelSpecification || '',
							modelKey: productItem.modelKey || '',
							colorKey: productItem.colorKey || '',
							materielDesignation: productItem.materielDesignation || '',
							clientCode: productItem.clientCode || '',
							engrave: productItem.engrave || '',
							supplierCode: productItem.supplierCode || '',
							// 数量和单位映射
							quantity: productItem.quantity || productItem.packingQuantity || '',
							unit: productItem.unit || productItem.measuringUnit || '',
							unitId: productItem.unitId || '',
							measureUnit: productItem.measureUnit || productItem.measuringUnit || '',
							batchNo: productItem.batchNo || batchNo, // 批次号
							warehouseIds: [productItem.warehouseId], // 仓库Id
							warehouseNames: [productItem.warehouseName], // 仓库名称
							packingSpecificationOption: this.packingSpecificationOption[
								productIndex], // 包装规格选项
							packingSpecificationLabel: packingSpecificationLabel, // 包装规格显示
							outInDetailRecordRequestList: productItem.outInDetailRecordRequestList
								?.length > 0 ?
								productItem.outInDetailRecordRequestList.map((packingItem,
									packingIndex) => {
									return {
										...packingItem,
										index: this.productList.length + productIndex + '-' +
											packingIndex, // 包装索引
										batchNo: batchNo, // 批次号
										parentIndex: this.productList.length +
											productIndex, // 物品索引
										categoryName: productItem.categoryName,
										categoryCode: productItem.categoryCode,
										reelSpecification: productItem.reelSpecification || '',
										materialDetailList: packingItem.materialDetailList.map((
											materialItem, materialIndex) => {
											return {
												...materialItem,
												index: this.productList.length +
													productIndex + '-' + packingIndex +
													'——' + materialIndex, // 包装索引
												parentIndex: this.productList.length +
													productIndex + '-' +
													packingIndex, // 物品索引
												batchNo: batchNo, // 批次号
												categoryName: productItem.categoryName,
												categoryCode: productItem.categoryCode
											}
										})
									}
								}) : []
						}
					})
				setTimeout(() => {
					this.detailOpen = !this.detailOpen
					this.$refs.collapse && this.$refs.collapse.resize()
				}, 0)
			})
			// 明细信息填写
			uni.$on('batchNumBack', productList => {
				if (productList?.length) {
					this.productList = productList
				}
			})
		},
		mounted() {
			// this.getAddDetails();
		},
		computed: {
			tableHeader() {
				return tableHeader(this.formData.assetType)
			},
			materialCodeReqList() {
				return this.productList.map(i => i.warehouseLedgerDetails || []).flat()
			},
			isMaterial() {
				return this.formData.assetType == 3
			},
			warehousingName() {
				return []
				this.productList = []
				return this.getDictValue('物品类型', this.formData.assetType)
			},
			listRules() {
				return this.productList.reduce((cur, pre, index) => {
					return {
						...cur,
						[`productList.${index}.batchNo`]: {
							type: 'string',
							required: true,
							trigger: ['blur', 'change']
						},
						[`productList.${index}.quantity`]: {
							type: 'number',
							required: true,
							trigger: ['blur', 'change']
						},
						[`productList.${index}.unit`]: {
							type: 'string',
							required: true,
							trigger: ['blur', 'change']
						},
						[`productList.${index}.warehouseId`]: {
							type: 'string',
							required: true,
							trigger: ['blur', 'change']
						}
					}
				}, {})
			},
			factoryId() {
				return uni.getStorageSync('userInfo').factoryId;
			},
		},
		methods: {
			// 初始化当前用户信息
			async initUserInfo() {
				const res = await getGroupList();
				let info = uni.getStorageSync('userInfo');
				console.log(info, 'infoinfoinfo');
				let obj = res.find(
				(item) => item.id === info.deptIds[info.deptIds.length - 1]
				);
				// if (!obj) return;

				if (obj) {
				console.log(
					obj,
					'objobjobjobjobjobjobjobjobjobjobjobjobjobjobjobjobj'
				);

				this.formData.extInfo.deptCode = obj?.id;
				this.formData.extInfo.deptName = obj?.name;
				} else {
				this.formData.extInfo.deptName = info.deptName
					? info.deptName
					: info.groupName
					? info.groupName
					: '';
				}

				this.formData.extInfo.createUserName = info.name;
				this.formData.createUserId = info.userId;
			},
			goToScanCodeList() {
				uni.navigateTo({
					url: '/pages/warehouse/enterHouse/components/scanCodeList'
				})
			},
			goToRequisition() {
				uni.navigateTo({
					url: '/pages/warehouse/components/requisitionList?type=' + 1
				})
			},
			async isVerifyRepeatIsStock() {
				const isVerifyData = await isVerifyRepeatIsStock({
					categoryCodes: this.productList.map((item) => item.categoryCode),
					batchNos: this.productList.map((item) => item.batchNo)
				});

				return new Promise((resolve) => {
					if (isVerifyData?.length) {
						uni.showModal({
							title: '提示',
							content: `当前批次：${isVerifyData[0].batchNo},物品${isVerifyData
								.map((item) => item.categoryName)
								.join(',')}已有入库记录，是否继续入库！`,
							success: (res) => {
								resolve(res.confirm);
							}
						});
					} else {
						resolve(true);
					}
				});
			},
			// 入库
			async submit() {
				if (this.productList.length <= 0) {
					uni.showToast({
						icon: 'none',
						title: '请添加产品！'
					})
					return
				}
				let boolen = this.productList.every(item => item.isSave)
				if (!boolen) {
					uni.showToast({
						icon: 'none',
						title: '请先保存所有产品信息！'
					})
					return
				}
				uni.showLoading({
					title: '保存中...'
				})
				this.formData.outInDetailList = this.productList
				let obj = uni.$u.deepClone(this.formData)
				// 处理物品类型assetType
				obj.extInfo.assetType = obj.extInfo.assetType?.join(',')
				// 处理仓库id
				let warehouseId = []
				let warehouseName = []
				let warehouseIds = this.productList.map(item => item.warehouseIds).flat()
				let warehouseNames = this.productList.map(item => item.warehouseNames).flat()
				warehouseIds.forEach((item, index) => {
					if (!warehouseId.includes(item)) {
						warehouseId.push(item)
						warehouseName.push(warehouseNames[index])
					}
				})
				obj.warehouseIds = warehouseId
				obj.warehouseNames = warehouseName
				// 是否需要审核(0审核 1跳过审核)
				if (obj.bizType == '12') {
					obj.isSkip = 1
				} else {
					obj.isSkip = 0
				}

				if (!(await this.isVerifyRepeatIsStock())) {
					uni.hideLoading()
					return;
				}

				// obj.isSkip = 1;
				console.log(obj, '提交')
				storage(obj)
					.then(async res => {
						console.log('入库成功', res)
						if (res.code == 0) {
							try {
								// 委外入库（非采购）
								if (obj.bizType == '12') {
									await qualityInspectionTwo({
										outInId: res.data[0]
									})
								} else {
									await submitTwo({
										outInId: res.data[0]
									})
								}
								uni.hideLoading()
								uni.showToast({
									icon: 'none',
									title: '入库成功',
									duration: 1500
								})
								uni.navigateBack({
									delta: 1
								})
							} catch (error) {
								uni.hideLoading()
								console.log('提交流程失败', error)
							}
						}
					})
					.catch(err => {
						console.log('入库失败', err)
						uni.hideLoading()
						uni.showToast({
							icon: 'none',
							title: '入库失败',
							duration: 2000
						})
					})
			},
			// 重量限制
			weightInput(value, row, productIndex) {
				const newValue = value.replace(/[^\d.]/g, '') // 保留数字和小数点
				const decimalCount = (newValue.match(/\./g) || []).length // 计算小数点的个数
				if (row.weight < 0) {
					row.weight = 0
				} else if (row.weight > 9999) {
					row.weight = 9999
				} else {
					if (decimalCount > 1) {
						// 如果小数点个数大于1，移除多余的小数点
						const lastIndex = newValue.lastIndexOf('.')
						row.weight = newValue.slice(0, lastIndex) + newValue.slice(lastIndex + 1)
					} else if (decimalCount === 1) {
						// 如果小数点个数等于1，允许小数点的输入
						row.weight = newValue
					} else {
						row.weight = newValue === '' ? 0 : parseFloat(newValue) // 如果输入为空，则设为0
					}
				}
				this.packingWeightCahnge(productIndex)
			},
			// 包装重量修改
			packingWeightCahnge(productIndex) {
				// 修改物品重量
				let totalWeight = this.productList[productIndex].outInDetailRecordRequestList.reduce((accumulator,
					currentValue) => {
					return Number(accumulator) + Number(currentValue.weight)
				}, 0)
				this.$set(this.productList[productIndex], 'weight', totalWeight)
			},
			scrolltolower() {
				console.log('滑动了~~~')
			},
			typeTimeClick(index, idx) {
				console.log('index-----', index)
				console.log('idx----', idx)
				this.currentProductIndex = index
				this.currentPackingIndex = idx > -1 ? idx : -1
				this.typeTimeShow = true
			},
			statusClick(index, idx) {
				this.currentProductIndex = index
				this.currentPackingIndex = idx > -1 ? idx : -1
				this.statusShow = true
			},
			selectStautsInfo(e) {
				this.productList[this.currentProductIndex].outInDetailRecordRequestList[this.currentPackingIndex].status =
					e.value[0]?.value
				this.statusShow = false
			},
			// 产品列表日期选择
			datePickerOpen(index, field) {
				this.currentEditIndex = index
				this.itemDateTarget = field
				const val = this.productList[index][field]
				this.currentItemDate = val ? this.formatter(val) : Number(new Date())
				this.itemDateShow = true
			},
			itemDateConfirm() {
				this.itemDateShow = false
				if (this.currentEditIndex != null && this.itemDateTarget) {
					const formatted = dayjs(this.currentItemDate).format('YYYY-MM-DD')
					this.$set(this.productList[this.currentEditIndex], this.itemDateTarget, formatted)
				}
			},
			// 批量保存
			// 批量保存（参照 target）
			async batchSave() {
				try {
					// 验证所有未保存的表单
					await this.validateForm();

					// 遍历所有产品进行保存
					for (let i = 0; i < this.productList.length; i++) {
						const row = this.productList[i];
						if (!row.isSave) {
							await this.listSave(row, i);
						}
					}
				} catch (error) {
					uni.showToast({ icon: 'none', title: '批量保存失败，请检查必填项' })
				}
			},
			typeTimeConfirm() {
				this.typeTimeShow = false
				this.$nextTick(() => {
					console.log(this.currentPackingIndex)
					if (this.currentPackingIndex > -1) {
						// 单独
						this.productList[this.currentProductIndex].outInDetailRecordRequestList[this
							.currentPackingIndex][this.currentDateType] = this.formatter(this.currentTypeTime)
					} else {
						// 批量
						this.productList[this.currentProductIndex].outInDetailRecordRequestList = this.productList[
							this.currentProductIndex].outInDetailRecordRequestList.map(item => {
							console.log(this.currentTypeTime)
							console.log(this.formatter(this.currentTypeTime))
							return {
								...item,
								[this.currentDateType]: this.formatter(this.currentTypeTime)
							}
						})
					}
				})
			},
			// 物品保存验证表单（单独）
			validateFormIndividually(index) {
				return new Promise((resolve, reject) => {
					console.log('index----------------', index)
					let fileds = [`productList.${index}.batchNo`, `productList.${index}.quantity`,
						`productList.${index}.unit`, `productList.${index}.warehouseId`
					]
					console.log('fileds----------------', this.productList[index])
					Promise.all(
							fileds.map(
								item =>
								new Promise((res, rej) => {
									this.$refs.lisrFormRef.validateField(item, err => {
										console.log('err--', err)
										if (err?.length) {
											rej(err)
										} else {
											res(true)
										}
									})
								})
							)
						)
						.then(() => {
							resolve()
						})
						.catch(err => {
							uni.showToast({
								icon: 'none',
								title: '请填入必填项！'
							})
							reject(err)
						})
				})
			},
		// 物品保存验证表单（批量）- 参照 target
			validateForm() {
				return new Promise(async (resolve, reject) => {
					let list = this.productList.map(async (row, index) => {
						if (row.isSave) {
							return Promise.resolve(true);
						}
						return await this.validateFormIndividually(index).then(
							() => true,
							() => { throw new Error('验证失败'); }
						);
					});
					Promise.all(list)
						.then(() => {
							resolve();
						})
						.catch((err) => {
							uni.showToast({ icon: 'none', title: '请填入必填项！' });
							reject(err);
						});
				});
			},
			// 产品编辑
			listEdit(row, index) {
				this.currentProductIndex = index
				this.productList[index].isSave = false
				this.deletePackingAndMaterial(row);
			},
			// 根据产品信息删除包装和物料
			deletePackingAndMaterial(row) {
				console.log('row--------', row);
				console.log('packingList------', row.outInDetailRecordRequestList);
				// 删除包装(去掉不相同的包装)
				row.outInDetailRecordRequestList = row.outInDetailRecordRequestList.filter(
				(item) => item.parentIndex !== row.index
				);
				// this.showPackingList = this.showPackingList.filter(
				// (item) => item.parentIndex !== row.index
				// );
				// this.pickingPageNum = Math.ceil(
				// this.showPackingList.length / this.pageSize
				// );
				// console.log('包装当前页数');
				// console.log(this.pickingPageNum);
			},
			// 产品保存（返回 Promise，参照 target）
			listSave(row, index) {
				console.log('index------', index)
				return new Promise(async (resolve, reject) => {
					try {
						await this.validateFormIndividually(index)
						console.log('通过了！！！')

						// 检查包装规格是否存在
						if (row.packingSpecificationLabel?.length < 1) {
							uni.showToast({ icon: 'none', title: '请到主数据维护包装组信息！' })
							return reject(new Error('包装规格缺失'))
						}

						// 不拆包
						if (!row.isUnpack) {
							if (row.packingUnit != row.measureUnit) {
								let pNum = row.quantity;
								let splitIndex = row.packingSpecificationOption.findIndex(
								(item) =>
									item.conversionUnit == row.unit &&
									item.packageUnit != item.conversionUnit
								);
							for (; splitIndex > 1; splitIndex--) {
										pNum = Math.round(pNum *
											row.packingSpecificationOption[splitIndex].packageCell *
											1e4) / 1e4;
									}
								console.log(pNum, 'pNum12');
								const { data } = await getAssetNum([
								{
									assetCode: row.categoryCode + row.index,
									batchNum: row.batchNo,
									num: Math.ceil(pNum)
								}
								]);
								// this.generateWrappers(row, index, data)
							} else {
								let pNum = 0;
								const { data } = await getAssetNum([
								{
									assetCode: row.categoryCode + row.index,
									batchNum: row.batchNo,
									num: Math.ceil(pNum)
								}
								]);
							}
						} else {
						let pNum = this.setPNum(row);

						// row.packingQuantity;
						// console.log(row.packingQuantity,'row.packingQuantity')
						// return
						//拆包
						const { data } = await getAssetNum([
							{
							assetCode: row.categoryCode + row.index,
							batchNum: row.batchNo,
							num: Math.ceil(pNum)
							}
						]);
						console.log(data, 'data');

						this.generateWrappers(row, index, data);
						this.$set(
							this.productList[index],
							'packingQuantity',
							data.length
						);
						}

					this.$set(this.productList[index], 'isSave', true);
					this.$set(this.productList[index], 'warehouseId', row.warehouseId);
					this.$set(this.productList[index], 'warehouseName', row.warehouseName);
					this.$set(this.productList[index], 'warehouseIds', [row.warehouseId]);
					this.$set(this.productList[index], 'warehouseNames', [row.warehouseName]);

					resolve();
				} catch (error) {
					reject(error);
				}
			})
			},
			// 获取当前时间函数
			getNowDate() {
				let date = new Date(),
					obj = {
						year: date.getFullYear(), //获取完整的年份(4位)
						month: date.getMonth() + 1, //获取当前月份(0-11,0代表1月)
						strDate: date.getDate(), // 获取当前日(1-31)
						hour: date.getHours(), //获取当前小时(0 ~ 23)
						minute: date.getMinutes(), //获取当前分钟(0 ~ 59)
						second: date.getSeconds() //获取当前秒数(0 ~ 59)
					}
				Object.keys(obj).forEach(key => {
					if (obj[key] < 10) obj[key] = `0${obj[key]}`
				})
				return obj
			},
			// 生成包装（参照 target）
			generateWrappers(row, productIndex, packingCodeList) {
				// 不拆包 + 计量类型不是数量 + 计量单位=包装单位，直接赋值，不生成包装层
				if (!row.isUnpack && row.measureUnit == row.unit) {
					this.productList[productIndex].measureQuantity = row.measureQuantity;
					this.productList[productIndex].weight = row.weight;
					return;
				}

				let obj = this.getNowDate()
				let productionDate = row.detailProductionDate || ''
				let purchaseDate = row.detailPurchaseDate || ''
				let expireDate = row.detailExpireDate || ''
				if (this.formData.bizType == '1') {
					productionDate = `${obj.year}-${obj.month}-${obj.strDate} ${obj.hour}:${obj.minute}:${obj.second}`
				} else if (this.formData.bizType == '2') {
					purchaseDate = `${obj.year}-${obj.month}-${obj.strDate} ${obj.hour}:${obj.minute}:${obj.second}`
				}

				// 判断单位和计量单位是否为不拆物料层规格
				let packingBoolen = !!this.getDict(row.unit).dictValue
				let measureBoolen = !!this.getDict(row.measureUnit).dictValue
				let num = row.packingQuantity
				let filterArr = []

				console.log('row.packingSpecificationOption~~~', row.packingSpecificationOption);

				if (packingBoolen) {
					filterArr = row.packingSpecificationOption.filter(item =>
						item.packageUnit == row.unit && item.packageUnit != item.conversionUnit
					)

					console.log('filterArr~~~!!!', filterArr, row.unit);
					if (filterArr.length) {
						num = Math.ceil(row.quantity / filterArr[0].packageCell)
					}
				} else {
					if (row.isUnpack || measureBoolen) {
						let splitIndex = row.packingSpecificationOption.findIndex(item =>
							item.conversionUnit == row.unit && item.packageUnit != item.conversionUnit)
						for (; splitIndex > 1; splitIndex--) {
							num = num * row.packingSpecificationOption[splitIndex].packageCell
						}
					} else {
						num = row.quantity
					}
				}

				console.log('filterArr~~~', filterArr);

				// 不拆包：按 packingCodeList 生成单个包装
				if (!row.isUnpack) {
					let unit = row.packingSpecificationOption[1]?.conversionUnit || row.unit
					let totalCalc = Number(row.quantity)
					let calcStart = row.packingSpecificationOption.findIndex(ite =>
						row.measureUnit == ite.packageUnit && ite.packageUnit != ite.conversionUnit
					)
					let calcEnd = row.packingSpecificationOption.findIndex(ite =>
						row.unit == ite.conversionUnit
					)
					for (; calcStart < calcEnd; calcEnd--) {
						totalCalc = Math.round(row.packingSpecificationOption[calcEnd].packageCell * totalCalc * 1e4) / 1e4
					}
					let packingQuantity = row.measureQuantity / totalCalc
					let measureQuantity = row.measureQuantity / packingCodeList.length
					let measureUnit = row.measureUnit

					for (let i = 0; i < packingCodeList.length; i++) {
						let item = this.buildPackingItem(row, i, packingCodeList, packingQuantity, unit, measureQuantity, measureUnit, productionDate, purchaseDate, expireDate, packingBoolen, measureBoolen, filterArr)
						row.outInDetailRecordRequestList.push(item)
					}
				} else {
					// 拆包：按 num 生成
					for (let i = 0; i < packingCodeList.length; i++) {
						let measureQuantity = 1
						if (packingBoolen) {
							measureQuantity = Number(row.quantity) > filterArr[0].packageCell * (i + 1)
								? filterArr[0].packageCell
								: Number(row.quantity) - filterArr[0].packageCell * i
						} else {
							//计量单位等于重量单位并且有总重 计量数量=总重/包装数
							if (row.weightUnit == row.measureUnit && row.weight) {
								measureQuantity =
								Math.trunc((row.weight / packingCodeList.length) * 10000) /
								10000;
							} else {
								measureQuantity = row.packingSpecificationOption[1].packageCell;
							}
						}
						// let packingUnit = packingBoolen ? filterArr[0].conversionUnit
						// 	: measureBoolen ? row.packingSpecificationOption[1]?.conversionUnit || row.measureUnit
						// 	: row.measureUnit
						if (row.isUnpack) {
							row.packingUnit =
								row.packingSpecificationOption[1].conversionUnit;
						}
						let measureUnit = row.isUnpack
							? measureBoolen
							? row.packingSpecificationOption[1]
								? row.packingSpecificationOption[1].packageUnit
								: row.packingSpecificationOption[0].packageUnit
							: row.measureUnit
							: row.measureUnit // 计量单位
						let item = this.buildPackingItem(row, i, packingCodeList, 1, row.packingUnit, measureQuantity, measureUnit, productionDate, purchaseDate, expireDate, packingBoolen, measureBoolen, filterArr)
						row.outInDetailRecordRequestList.push(item)
					}
				}
			},
			// 构建单个包装项
			buildPackingItem(row, i, packingCodeList, packingQuantity, packingUnit, measureQuantity, measureUnit,
				productionDate, purchaseDate, expireDate, packingBoolen, measureBoolen, filterArr) {
				let item = {
					index: row.index + '-' + i,
					warehouseId: row.warehouseId,
					warehouseName: row.warehouseName,
					categoryName: row.categoryName,
					categoryCode: row.categoryCode,
					categoryModel: row.categoryModel,
					specification: row.specification,
					brandNum: row.brandNum,
					parentIndex: row.index,
					batchNo: row.batchNo,
					packageNo: packingCodeList[i]?.onlyCode,
					packingQuantity: packingQuantity,
					packingUnit: packingUnit,
					measureQuantity: measureQuantity,
					measureUnit: measureUnit,
					weight: row.weight / row.packingQuantity,
					packingSpecificationOption: row.packingSpecificationOption,
					weightUnit: row.weightUnit,
					netWeight: row.netWeight,
					barcodes: '',
					clientCode: row.clientCode || '',
					materielDesignation: row.materielDesignation || '',
					engrave: row.engrave || '',
					supplierName: row.supplierName || '',
					supplierCode: row.supplierCode || '',
					modelKey: row.modelKey || '',
					colorKey: row.colorKey || '',
					reelSpecification: row.reelSpecification || '',
					isUnpack: row.isUnpack,
					productionDate: productionDate,
					purchaseDate: purchaseDate,
					expireDate: expireDate,
					result: 1,
					status: 2
				}
				// 重量计算
				let outBoolen = !!this.getDict(item.measureUnit).dictValue
				if (outBoolen) {
					item.weight = item.measureQuantity ? Number(item.measureQuantity) : 0
				} else {
					let inBoolen = !!this.getDict(item.packingSpecificationOption[0]?.packageUnit).dictValue
					let si = item.packingSpecificationOption.findIndex(ite =>
						item.measureUnit == ite.packingUnit && ite.packingUnit != ite.conversionUnit)
					let ei = item.packingSpecificationOption.findIndex(ite =>
						item.packingUnit == ite.conversionUnit)
					let total = item.packingQuantity ? Number(item.packingQuantity) : 0
					for (; si < ei; ei--) {
						total = Math.round(item.packingSpecificationOption[ei].packageCell * total * 1e4) / 1e4
					}
					if (inBoolen) {
						item.weight = total || 0
					} else {
						item.weight = total * item.netWeight || 0
					}
				}
				return item
			},
			async requireDictCode() {
				// 不拆物料层规格列表
				const res = await getByCode('material_layer')
				this.dictCodeList = res.map(item => {
					const arr = Object.entries(item)
					return {
						dictCode: arr[0][0],
						dictValue: arr[0][1]
					}
				})
			},
			getDict(dictCode) {
				// 不拆物料层规格列表
				if (this.dictCodeList.length > 0) {
					return this.dictCodeList.find(item => item.dictCode == dictCode) || {}
				} else {
					return {}
				}
			},
			// 小数处理，最大3位
			format3(str) {
				let value = str;
				value = value.toString().replace(/[^0-9.]/g, '');
				const parts = value.split('.');
				if (parts.length > 2) {
				value = parts[0] + '.' + parts.slice(1).join('');
				}
				if (parts.length === 2) {
				value = parts[0] + '.' + parts[1].slice(0, 3);
				}
				console.log(value);

				return value;
			},
			async computeNum(row, index, isClear) {
				console.log(row)
				console.log(row.quantity)
				console.log(row.unit)

				if (row.quantity) {
					let value = row.quantity.toString().replace(/[^0-9.]/g, '')
					const parts = value.split('.')
					if (parts.length > 2) value = parts[0] + '.' + parts.slice(1).join('')
					if (parts.length === 2) value = parts[0] + '.' + parts[1].slice(0, 3)
					row.quantity = value
				}
				// 根据 unitId 匹配 unit
				if (row.unitId && row.packingSpecificationOption) {
					let data = row.packingSpecificationOption.find(item => item.id == row.unitId)
					if (data) row.unit = data.conversionUnit
				}
				// 清空仓库(数量输入)
				if (isClear) {
					if (row.quantity < 1) {
						this.$set(this.productList[index], 'quantity', 1)
					}
				}
				// 同步 packingQuantity 供 listSave/generateWrappers 使用
				// row.packingQuantity = row.quantity
				// row.packingUnit = row.unit
				if (row.quantity && row.unit) {

					const res = await warehouseDefinitionList({
						inventoryType: row?.categoryLevelPathIdParent,
						factoryId: this.factoryId
					})

					if(res.length == 1) {
						this.$set(this.productList[index], 'warehouseId', res[0].id);
            			this.$set(this.productList[index], 'warehouseName', res[0]?.name);
						let table1 = [];
						table1.push({
							measureQuantity: row.measureQuantity,
							packingQuantity: row.quantity,
							warehouseName: res[0]?.name,
							warehouseId: res[0].id
						});
					} else {
						this.$set(this.productList[index], 'warehouseId', '');
            			this.$set(this.productList[index], 'warehouseName', '');
					}
					// 保存过滤后的仓库列表到产品行，供 showWarehousePicker 使用
					this.$set(this.productList[index], 'filteredWarehouseList', res || [])
					let data = row.packingSpecificationOption.find(item => item.id == row.unitId)
					let endIndex = row.packingSpecificationOption.findIndex(ite => data && data.id == ite.id)
					let total = Number(row.quantity)
					for (; 0 < endIndex; endIndex--) {
						total = row.packingSpecificationOption[endIndex].packageCell * total
					}
					row.measureQuantity = total

					//计量单位不是数量时，配置了单重的重量计算
					// row.measureType != 1 &&
					let weight = 0;
					if (row.measureUnit == row.weightUnit) {
						weight = row.measureQuantity;
						//包装单位与重量单位相等时，单重重量为0
						if (row.unit == row.weightUnit) {
						row.singleWeight = 0;
						} else {
						row.singleWeight =
							Math.trunc((row.measureQuantity / row.quantity) * 10000) /
							10000;
						}
					} else if (row.singleWeight) {
						weight = row.measureQuantity * Number(row.singleWeight);
					}
					this.$set(this.productList[index], 'weight', weight);
					this.$set(
						this.productList[index],
						'packingQuantity',
						this.setPNum(row)
					);


					// 判断包装单位和计量单位是否为不拆物料层规格
					// console.log(this.getDict(row.unit))
					// let packingBoolen = !!this.getDict(row.unit).dictValue
					// let measureBoolen = !!this.getDict(row.measureUnit).dictValue
					// if (packingBoolen || measureBoolen) {
					// 	row.weight = total
					// } else {
					// 	row.weight = total * row.netWeight
					// }
				}
			},
			setPNum(row) {
				let pNum = 0;
				if (row.unitId) {
				let splitIndex = row.packingSpecificationOption.findIndex(
					(item) => item.id == row.unitId
				);
				if (splitIndex == 0) {
					pNum = Math.ceil(
					row.measureQuantity /
						row.packingSpecificationOption[1]?.packageCell
					);
				}
				if (splitIndex == 1) {
					pNum = row.quantity;
				}

				for (; splitIndex > 1; splitIndex--) {
					pNum = Math.ceil(
					row.quantity *
						row.packingSpecificationOption[splitIndex].packageCell
					);
				}
				} else {
				pNum = Math.ceil(
					row.measureQuantity / row.packingSpecificationOption[1]?.packageCell
				);
				}
				return pNum;
			},
			//获取仓库（按产品类型和工厂过滤）
			async getFilteredWarehouseList(row) {
				const res = await warehouseDefinitionList({
					inventoryType: row?.categoryLevelPathIdParent,
					factoryId: this.factoryId
				})
				this.warehouseListOption = [res || []]
			},
			showWarehousePicker(index) {
				this.currentProductIndex = index
				const row = this.productList[index]
				// 按产品类型过滤仓库列表
				this.getFilteredWarehouseList(row).then(() => {
					this.warehouseShow = true
				})
			},
			showPackingUnitPicker(data, index) {
				this.currentProductIndex = index
				this.currentPackingSpecificationOption = [data.packingSpecificationOption]
				this.packingUnitsShow = true
			},
			showSupplierPicker(data, index) {
				this.currentProductIndex = index
				this.currentSupplierListOption = [data.supplierListOptions]
				this.suppliersShow = true
			},
			selectPackingUnitInfo(e) {
				const selected = e.value[0]
				const row = this.productList[this.currentProductIndex]
				row.unitId = selected?.id || ''
				row.unit = selected?.conversionUnit || ''
				row.packingUnit = selected?.conversionUnit || '' // 兼容旧逻辑
				this.computeNum(row, this.currentProductIndex)
				this.packingUnitsShow = false
			},
			selectSuppliersInfo(e) {
				this.productList[this.currentProductIndex].supplierName = e.value[0]?.name
				this.productList[this.currentProductIndex].supplierId = e.value[0]?.id
				this.suppliersShow = false
			},
			selectWarehouseInfo(e) {
				this.productList[this.currentProductIndex].warehouseName = e.value[0]?.name
				this.productList[this.currentProductIndex].warehouseId = e.value[0]?.id
				this.productList[this.currentProductIndex].warehouseNames = [e.value[0]?.name]
				this.productList[this.currentProductIndex].warehouseIds = [e.value[0]?.id]
				this.warehouseShow = false
			},
			selectTimeTypeInfo(e) {
				this.currentDateType = e.value[0]?.prop
				this.timeTypeShow = false
			},
			sceneStateFilter(bizType) {
				if (bizType) {
					return this.sceneState.filter(item => item.value == bizType)[0].text
				}
			},
			formatter(dataTime) {
				return dayjs(dataTime).format('YYYY-MM-DD HH:mm:ss')
			},
			timeConfirm() {
				this.timeShow = false
				this.$nextTick(() => {
					console.log(this.storageTime)
					console.log(this.formatter(this.storageTime))
					this.formData.storageTime = this.formatter(this.storageTime)
					console.log(this.formData)
				})
			},
			timeCancel() {
				this.timeShow = false
			},
			openPicker() {
				this.$refs.treePicker._show()
			},
			// 获取物品列表
			async getListItems() {
				this.goodsLists = await getTreeByGroup({
					type: 2
				})
			},
			confirm(data, name, allList) {
				console.log('name-------', name)
				this.assetTypeName = name
				this.formData.extInfo.assetType = allList.map(item => item.id)
			},
			handleScan() {
				if (this.formData.bizType !== '' && this.formData.bizType != 5) {
					uni.showModal({
						title: '提示',
						content: '仅退还入库支持扫码,是否清除已选明细并切换至退还入库?',
						success: async res => {
							if (res.confirm) {
								this.productList = []
								this.formData.bizType = 5
								this.getData()
							}
						}
					})
					return
				}
				this.getData()
			},
			// goScan () {
			//   uni.navigateTo({
			//     url: '/pages/ScanCode/ScanCode'
			//   })
			// },
			// 根据条码请求设备数据 @_@
			getData() {
				let par = {
					barType: this.qrContent.split('@_@')[1] || 0,
					qrContent: this.qrContent
				}
				// uni.showLoading({
				// 	title: '加载中',
				// 	mask: true
				// })
				// postJ(this.apiUrl + '/scan/getAssetInfo', par)
				// 	.then(res => {
				// 		let data = res.data
				// 		console.log(data, 'qrContent')
				// 		if (data.assetType === undefined) {
				// 			uni.showToast({
				// 				title: '请扫码物品码',
				// 				icon: 'none'
				// 			})
				// 			return
				// 		} else if (data.source == 2) {
				// 			uni.showModal({
				// 				title: '提示',
				// 				content: '当前物品已在库',
				// 				success: async res => {}
				// 			})

				// 			return
				// 		} else if (this.warehousingName && this.formData.assetType != data.assetType) {
				// 			uni.showToast({
				// 				title: `当前物品不属于${this.warehousingName}分类`,
				// 				icon: 'none'
				// 			})
				// 			return
				// 		}

				// 		this.setScanMaterial(data)
				// 	})
				// 	.finally(() => {
				// 		uni.hideLoading()
				// 	})
			},
			async setScanMaterial(data) {
				this.formData.assetType = data.assetType
				this.formData.bizType = 5

				const curMap = {
					assetId: 'id',
					assetCode: 'informationCode', //编码
					assetName: 'informationName', //名称
					materialId: 'id',
					materialName: 'informationName',
					batchNo: '', //批次号
					unit: 'measuringUnit', //单位
					minPackUnit: 'packingUnit' //最小包装单位
				}
				let obj = {}

				for (const key in curMap) {
					obj[key] = (curMap[key] && data.information[curMap[key]]) || ''
				}

				let detailObj = uni.$u.deepClone(obj)

				detailObj.onlyCode = data.assetCode

				obj = {
					...data.information,
					...obj,
					...{
						cargoSpaceCode: '', //货位编码
						cargoSpaceId: '', //货位id
						shelfId: '', //货架id
						shelfCode: '', //货架名称
						areaId: '', //库区id
						areaName: '', //库区名称
						warehouseId: '', //仓库id
						warehouseName: '', //仓库名称
						measurementUnit: '',
						bizStatus: 1,
						contentImage: []
					}
				}
				let warehouseLedgerDetails = [detailObj]

				this.productList.push(obj)

				this.$set(this.productList[this.productList.length - 1], 'warehouseLedgerDetails',
					warehouseLedgerDetails)
				this.$set(this.productList[this.productList.length - 1], 'selfWarehouseLedgerDetails', uni.$u
					.deepClone(warehouseLedgerDetails))

				this.handleBatchSetting(obj, this.productList.length - 1, true)
			},
			calcSum(a, b, c, row) {
				if ((Number.isNaN(+a) && a !== '') || (Number.isNaN(+b) && b !== '') || (Number.isNaN(+c) && c !== '')) {
					return ''
				}

				return a * b * c + {
					yuan: '元',
					wanyuan: '万元'
				} [row.univalenceUnit]
			},
			handleBatchSetting(item, index, isScan = false) {
				this.settingIndex = index
				uni.setStorageSync('inputData', item)
				uni.setStorageSync('productList', this.productList || [])

				uni.navigateTo({
					url: '/pages/warehouse/enterHouse/batchNumEdit?bizType=' + this.formData.bizType +
						'&assetType=' + this.formData.assetType + '&index=' + index + '&isScan=' + isScan
				})
			},
			chooseFile(file) {
				console.log(file)
				this.$refs.lFile.upload({
					//替换为你的上传接口地址
					url: this.apiUrl + '/data/doc/add',
					// 服务端接收附件的key
					name: 'file',
					//根据你接口需求自定义 (优先不传content-type,安卓端无法收到参数再传)
					header: {
						Authorization: 'bearer eyJhbGciO',
						uid: '27682',
						client: 'app'
					}

					// 限制选择附件的大小上限，默认10M
					// maxSize: 20,

					// 若需要在body单独添加附件名或附件大小如下方式传入组件：
					// addName: '后端要的附件名称字段key,此处请勿写name的同值如(file)，会覆盖name',
					// addSize: '后端要的附件大小字段key'

					// body参数直接写key,value,如：
					// date: '2020-1-1',
					// key2: 'value2',
				})
			},
			changeType(e) {
				this.formData.bizType = e
			},
			// 抬头下拉信息保存
			handlePicker(e, list, idKey, nameKey) {
				console.log('e?.detail--------------', e)
				if (idKey) {
					this.formData[idKey] = list[e?.detail.value]?.value
				}
				if (nameKey) {
					this.formData[nameKey] = list[e?.detail.value]?.text
				}
				this.$nextTick(() => {
					if (idKey === 'assetType' || idKey === 'bizType') {
						this.$refs.formRef.validateField(idKey)
					}
					console.log('this.formData.bizType---', this.formData.bizType)
				})
			},
			// 抬头下拉信息保存
			handleDictPicker(e, list, idKey, nameKey) {
				if (idKey) {
					this.formData[idKey] = list[e?.detail.value]?.dictCode
				}
				if (nameKey) {
					this.formData[nameKey] = list[e?.detail.value]?.dictValue
				}
				this.$nextTick(() => {
					if (idKey === 'assetType' || idKey === 'bizType') {
						this.$refs.formRef.validateField(idKey)
					}
				})
			},
			// 明细下拉信息保存
			handleListPicker(e, list, item, idKey, nameKey) {
				if (idKey) {
					item[idKey] = list[e.detail.value].id
				}
				if (nameKey) {
					item[nameKey] = list[e.detail.value].name
				}
			},
			//获取仓库信息
			handleWarehouseChoose(item) {
				this.$refs.warehouseChooseRef.openDefault(item, res => {
					Object.assign(item, res)
				})
			},
			//状态
			getstatus(e) {
				this.formData.houseType = this.statusList[e.detail.value].name
			},
			//上传附件
			getUpFlie(res) {
				console.log(res)
				let arr = []
				res.forEach(item => {
					let obj = {
						accessUrl: item.accessUrl,
						docId: item.docId,
						name: item.name,
						size: item.size,
						url: item.url,
						type: 1
					}
					// obj.type.id = item.type.id;
					// obj.type.value = item.type.name;
					arr.push(obj)
				})
				this.formData.attaments = arr
			},
			//选择入库类别跳转
			selectType() {
				if (!this.formData.extInfo.assetType) {
					uni.showToast({
						title: '请选择物品类型',
						icon: 'none'
					})
					return
				}
				if (!this.formData.bizType) {
					uni.showToast({
						title: '请选择入库场景',
						icon: 'none'
					})
					return
				}
				uni.navigateTo({
					url: '/pages/warehouse/enterHouse/selectEnterType?assetType=' + this.formData.extInfo.assetType
				})
			},
			//删除
			getDelete(index) {
				uni.showModal({
					title: '提示',
					content: '是否删除当前物品',
					success: res => {
						if (res.confirm) {
							this.productList.splice(index, 1)
						}
					}
				})
			},
			deletePacking(index, idx) {
				uni.showModal({
					title: '提示',
					content: '是否删除当前包装',
					success: res => {
						if (res.confirm) {
							this.productList[index].outInDetailRecordRequestList.splice(idx, 1)
							this.productList[index].packingQuantity = this.productList[index].packingQuantity -
								1
						}
					}
				})
			},
			// 入库操作
			// listEdit(row) {
			// 	this.$set(row, 'isSave', false)
			// },
			// listSave(row, index) {
			// 	const fileds = [`productList.${index}.cargoSpaceCode`, `productList.${index}.batchNum`]

			// 	if (this.formData.bizType != 5) {
			// 		fileds.push(...[`productList.${index}.outInNum`, `productList.${index}.measurementUnit`])
			// 	} else if (this.productList.some(i => !i.selfWarehouseLedgerDetails?.length)) {
			// 		uni.showToast({
			// 			title: '请选择资产编号！',
			// 			icon: 'none'
			// 		})
			// 		return
			// 	}
			// 	Promise.all(
			// 		fileds.map(
			// 			item =>
			// 				new Promise(async (resolve, rej) => {
			// 					this.$refs.lisrFormRef.validateField(item, err => {
			// 						if (err?.length) {
			// 							rej(err)
			// 						} else {
			// 							resolve()
			// 						}
			// 					})
			// 				})
			// 		)
			// 	)
			// 		.then(res => {
			// 			this.$set(row, 'isSave', true)
			// 			if (this.formData.bizType != 5) {
			// 				this.createMaterialCode(row)
			// 			} else {
			// 				// 退还
			// 				this.createMaterialCodeReturn(row)
			// 			}
			// 		})
			// 		.catch(err => {
			// 			uni.showToast({
			// 				icon: 'error',
			// 				title: '请填入必填项！'
			// 			})
			// 		})
			// },
			//入库明细删除
			listDel(row, index) {
				this.productList.splice(index, 1)
				this.deletePackingAndMaterial(row);
			},
			// 入库明细生成条码信息
			async createMaterialCode(row) {
				return
				// 添加相同物品重新更新明细 原料编码
				const list = this.productList.filter(i => i.assetCode === row.assetCode && i.batchNum === row
					.batchNum && i.isSave)

				const num = list.reduce((num, pre) => {
					num += row.isUnpack ? pre.outInNum * pre.measurementUnit : pre.outInNum
					return num
				}, 0)

				const res = await postJ(this.apiUrl + '/outInWarehouse/getAssetNum', {
					batchNum: row.batchNum,
					assetCode: row.assetCode,
					num
				})
				if (res?.success) {
					list.forEach(item => {
						if (item.warehouseLedgerDetails?.length) {
							item.warehouseLedgerDetails.forEach(i => {
								i.onlyCode = res.data.shift().onlyCode
							})
						} else {
							this.$set(
								item,
								'warehouseLedgerDetails',
								Array.from(new Array(item.isUnpack ? item.outInNum * item.measurementUnit :
									+item.outInNum), (val, idx) => {
									return {
										...item,
										onlyCode: res.data.shift().onlyCode,
										bizStatus: 1,
										contentImage: []
									}
								})
							)
						}
					})
				}

				// 添加相同物品，重复批次号 重新更新明细 包装编码
				const batchList = this.productList.filter(i => i.batchNum === row.batchNum && i.isSave)
				if (batchList.length) {
					const num = batchList.reduce((num, pre) => {
						num += +pre.outInNum
						return num
					}, 0)
					const res1 = await postJ(this.apiUrl + '/outInWarehouse/getAssetNum', {
						batchNum: row.batchNum,
						num
					})
					if (res1?.success) {
						batchList.forEach(item => {
							let num = res1.data.shift()?.num
							let measurementUnit = item.measurementUnit

							if (item.warehouseLedgerDetails?.length) {
								item.warehouseLedgerDetails.forEach((i, index) => {
									this.$set(i, 'num', num)
									if (!item.isUnpack) {
										if (index < item.warehouseLedgerDetails.length - 1) {
											num = res1.data.shift()?.num
										}
									} else {
										// 拆包的包装编码一致
										measurementUnit--
										if (measurementUnit === 0 && index < item
											.warehouseLedgerDetails.length - 1) {
											measurementUnit = item.measurementUnit
											num = res1.data.shift()?.num
										}
									}
								})
							}
						})
					}
				}
			},
			// 入库明细生成条码信息 退还
			async createMaterialCodeReturn(row) {
				return
				// 添加相同物品重新更新明细 原料编码
				const list = this.productList.filter(i => i.batchNum === row.batchNum && i.isSave)
				// 退还
				const res = await postJ(this.apiUrl + '/outInWarehouse/getAssetNum', {
					batchNum: row.batchNum,
					num: list.reduce((num, pre) => {
						num += pre.selfWarehouseLedgerDetails.length
						return num
					}, 0)
				})
				if (res?.success) {
					list.forEach(item => {
						const num = res.data.shift().num
						if (item.warehouseLedgerDetails?.length) {
							item.warehouseLedgerDetails.forEach(i => {
								i.num = num

								if (!item.isUnpack) {
									// 拆包的包装编码一致
									num = res.data.shift()?.num
								}
							})
						} else {
							this.$set(
								item,
								'warehouseLedgerDetails',
								item.selfWarehouseLedgerDetails.map((val, idx) => {
									let obj = {
										...val,
										bizStatus: 1,
										batchNum: item.batchNum,
										cargoSpaceCode: item.cargoSpaceCode, //货位编码
										cargoSpaceId: item.cargoSpaceId, //货位id
										shelfId: item.shelfId, //货架id
										shelfCode: item.shelfCode, //货架名称
										areaId: item.areaId, //库区id
										areaName: item.areaName, //库区名称
										warehouseId: item.warehouseId, //仓库id
										warehouseName: item.warehouseName, //仓库名称
										num
									}
									if (!item.isUnpack) {
										// 拆包的包装编码一致
										num = res.data.shift()?.num
									}
									return obj
								})
							)
						}
					})
				}
			},
			//确定提交
			getsure() {
				return
				this.$refs.formRef.validate().then(res => {
					if (!this.productList?.length) {
						uni.showToast({
							icon: 'error',
							title: '请添加明细！'
						})
						return
					} else if (this.productList.some(item => !item.warehouseLedgerDetails?.length)) {
						uni.showToast({
							icon: 'error',
							title: '请完善明细信息！'
						})
						return
					}

					const params = {
						outInWarehouse: {
							...this.formData,
							bizStatus: 1
						},
						warehouseLedgerInfos: this.productList
					}
					postJ(this.apiUrl + '/outInWarehouse/add', params).then(res => {
						if (res?.success) {
							uni.showToast({
								icon: 'success',
								title: '保存成功'
							})
							setTimeout(() => {
								uni.navigateBack({
									delta: 1
								})
							}, 1500)
						}
					})
				})
			},
			// 部门确认
			deptConfirm(data, name) {
				this.formData.deptName = name
				this.formData.deptCode = data[0]
			},
			// 部门确认
			verifyDeptConfirm(data, name) {
				this.formData.verifyDeptCode = data[0]
				this.formData.verifyDeptName = name
				this.formData.verifyId = ''
				this.formData.verifyName = ''

				this.getUser(data[0])
			},
			// 获取部门
			getDept() {
				return
				get(this.apiUrl + '/main/org/dept/effectiveTree').then(res => {
					if (res?.success) {
						this.deptList = res.data
					}
				})
			},
			// 获取供应商
			getSupplier() {
				// post(this.apiUrl + `/main/supplier/list?page=1&size=999`, {
				// 	page: 1,
				// 	size: 999
				// }).then(res => {
				// 	if (res?.success) {
				// 		this.supplierList = res.data.items
				// 	}
				// })
			},

			// 获取人员
			getUser(deptCode) {
				// post(this.apiUrl + '/main/user/list', {
				// 	deptCode,
				// 	page: 1,
				// 	size: 9999
				// }).then(res => {
				// 	if (res?.success) {
				// 		this.userList = res.data.items.map(item => {
				// 			item.name = item.trueName
				// 			item.id = item.userId
				// 			return item
				// 		})
				// 	}
				// })
			},
		}
	}
</script>

<style lang="scss" scoped>
	.mainBox {
		padding-bottom: 120rpx;
	}

	/deep/.required-form .u-form-item__body__left__content__label::before {
		content: '*';
		color: red;
	}

	.required-form-text {
		/deep/ .u-form-item__body__right {
			overflow: hidden;
			// background-color: red;


			.u-form-item__body__right__content {
				width: 100%;
				display: inline-block !important;
			}
		}
	}

	// ::v-deep .listCont .u-input {
	// 	height: 60rpx !important;
	// }

	::v-deep .dd .u-form-item__body__right {
		border: 1px solid #e5e5e5 !important;
		border-radius: 4px;
		line-height: 60rpx;
	}

	.ellipsis {
		max-width: 100%;
		overflow: hidden;
		white-space: nowrap;
		text-overflow: ellipsis;
	}


	.picList {
		display: flex;
		align-items: center;
		justify-items: flex-start;
		flex-wrap: wrap;
	}

	/deep/.baseForm {
		.u-form-item__body {
			padding: 4px !important;
		}

		.assetType_box {
			padding: 12rpx 18rpx;
			width: 100%;
			overflow: hidden;
			white-space: nowrap;
			text-overflow: ellipsis;
			font-size: 30rpx;
		}
	}

	/deep/ .picList .u-image {
		margin-right: 10rpx;
		margin-bottom: 10rpx;
	}

	/deep/.cLine .u-line:nth-child(1) {
		border-bottom: none !important;
	}

	.detail-box {
		position: relative;
		align-items: center;

		/deep/uni-button {
			margin: 0 !important;
			width: 180rpx;
		}

		.selectEnterType {
			margin-left: 10rpx !important;
		}
	}

	.footBox {
		position: fixed;
		left: 0px;
		bottom: 0px;
		height: 100rpx;
		width: 100%;
		display: flex;
		align-items: center;
		justify-content: space-between;

		view {
			width: 100%;
			height: 100%;
			text-align: center;
			color: #fff;
			display: flex;
			align-items: center;
			justify-content: center;
		}

		.reg {
			background: $u-success-dark;
		}

		.add {
			background: $uni-color-primary;
		}

		.uni-icons {
			margin-right: 8rpx !important;
		}
	}

	.listBox {
		padding: 20rpx 10rpx;
		border-bottom: 1px #f2f2f2 solid;
		position: relative;

		&.code {
			.label {
				width: 120rpx !important;
			}
		}

		.listTit {
			width: 100%;
			align-items: center;

			/deep/uni-button {
				margin-right: 20rpx;
				width: 100rpx;

				&.assets {
					width: 180rpx;
				}
			}

			.name {
				width: 50%;
				margin-left: 10px;
				overflow: hidden;
				white-space: nowrap;
				-o-text-overflow: ellipsis;
				text-overflow: ellipsis;
				font-size: 28rpx;
				font-weight: bold;
			}

			.btn {
				display: flex;
				justify-content: flex-end;
			}

			.weight {
				width: 30%;
				font-size: 24rpx;
				margin-left: auto;
				margin-right: 60rpx;
				position: relative;
				display: flex;

				input {
					margin-right: 10rpx;
					border: 1px solid black;
					width: 40%;
					height: 20rpx;
				}
			}

			.weight::after {
				position: absolute;
				right: -30rpx;
				top: 50%;
				content: '';
				background: #eee;
				width: 1px;
				height: 28rpx;
				margin-top: -14rpx;
			}
		}

		.z_list {
			height: 100% !important;
			max-height: 500rpx;

			.material {
				margin-top: 10rpx;

				.left {
					width: 40rpx;
				}

				.zdy_check {
					width: 30rpx;
					height: 30rpx;
					border: 2rpx solid #c8c9cc;
					border-radius: 4rpx;
				}

				.check_active {
					background: $theme-color;
					border: 2rpx solid $theme-color;

					/deep/ .u-icon__icon {
						color: #fff !important;
					}
				}

				.content_table {
					width: 670rpx;
					border: 2rpx solid $border-color;

					.item {
						display: flex;
						border-bottom: 2rpx solid $border-color;

						.lable {
							width: 200rpx;
							text-align: center;
							background-color: #f7f9fa;
							font-size: 26rpx;
							border-right: 2rpx solid $border-color;
							flex-shrink: 0;
						}

						.ww80 {
							width: 80rpx;
						}

						.content {
							width: 500rpx;
							min-height: 64rpx;
							font-size: 28rpx;
							line-height: 28rpx;
							font-style: normal;
							font-weight: 400;
							padding: 18rpx 8rpx;
							box-sizing: border-box;
							word-wrap: break-word;
							flex-grow: 1 !important;
						}

						.input_box {
							padding: 0 !important;
						}

						.content_num {
							display: flex;
							align-items: center;
							padding: 0 4rpx;

							/deep/ .uni-input-input {
								width: 200rpx;
								border: 2rpx solid #f0f8f2;
								background: #f0f8f2;
								color: $theme-color;
							}

							.unit {
								padding: 0 4rpx;
								font-size: 24rpx;
								color: #404446;
							}
						}

						.ww400 {
							/deep/ .uni-input-input {
								width: 400rpx;
							}
						}

						.pd4 {
							padding: 4rpx 8rpx;
						}

						&:last-child {
							border-bottom: none;
						}
					}

					.ww55 {
						width: 55%;
					}

					.ww45 {
						width: 45%;
					}

					.ww50 {
						width: 50%;
					}

					.ww30 {
						width: 30%;
					}

					.ww70 {
						width: 70%;
					}

					.ww80 {
						width: 80%;
					}

					.ww20 {
						width: 20%;
					}

					.check {
						width: 30rpx;
						height: 30rpx;
					}

					.tag_box {
						padding: 2rpx 10rpx;
						margin-right: 12rpx;
						background: #e6a23c;
						font-size: 22rpx;
						color: #fff;
						border-radius: 4rpx;
					}
				}
			}
		}

		.more {
			position: absolute;
			bottom: 26rpx;
			right: 30rpx;
			font-size: 28rpx;
			color: #666;
		}
	}

	.listCont {
		display: flex;
		align-items: center;
		flex-wrap: wrap;
		margin-top: 20rpx;
		margin-left: 10rpx;

		&.save {
			.u-input {
				border: none;
			}
		}

		.u-input {
			border: 1px solid rgb(229, 229, 229);
			height: 60rpx !important;
			padding: 0 0 0 9px !important;
		}

		.item {
			width: 100%;
			font-size: 28rpx;
			margin-bottom: 10rpx;
			margin-right: 3%;

			/deep/.u-form-item__body {
				padding: 0 !important;
			}

			/deep/.u-input__content__field-wrapper__field,
			/deep/.u-form-item {
				font-size: 28rpx !important;
			}

			text.label {
				width: 120rpx;
				display: inline-block;
				text-align: right;
				margin-right: 20rpx;
				margin-bottom: 20rpx;
			}

			/deep/.uni-date__x-input {
				height: 40rpx;
				font-size: 28rpx;
			}

			/deep/.uni-date {
				width: 48%;
				display: inline-block;

				.uni-icons {
					display: none !important;
				}

				.uni-date-x {
					padding: 0 !important;
				}
			}
		}

		.item text {
			color: #666;
		}
	}

	.selectTime {
		display: flex;
		justify-content: flex-end;
		align-items: center;
		margin-bottom: 10rpx;

		.title {
			flex: 1;
			font-size: 30rpx;
		}

		.timeBox {
			display: flex;
			width: 500rpx;

			.firstBtn {
				margin-right: 10rpx;
			}
		}
	}

	.listBox:last-child {
		border: none !important;
	}

	.textBox {
		border: 1px #f2f2f2 solid;
		height: 160px;
		display: block;
		width: auto !important;
	}

	.saveBtn {
		width: 50%;
		margin: 40rpx auto;
	}

	.top-css {
		border-bottom: 1px solid rgb(207, 204, 204);
	}

	.flex_between {
		display: flex;
		justify-content: space-between;
	}
</style>