zy-asrs.git - Gitblit

			@@ -322,14 +322,14 @@
			return null;
			}

			// 排除有正在搬运任务的站点（状态8：已呼叫AGV，正在搬运）
			List<BasDevp> availableDevList = new ArrayList<>();
			Integer taskIoType = task.getIoType();
			// 先按规则排序（入库任务数排序）
			devList.sort(Comparator.comparing(BasDevp::getInQty));

			// 根据任务类型确定要检查的io_type列表
			Integer taskIoType = task.getIoType();
			List<Integer> checkIoTypes = null;
			String taskTypeName = "";
			if (taskIoType != null) {
			// 根据任务类型确定要检查的io_type列表
			List<Integer> checkIoTypes;
			String taskTypeName;
			if (taskIoType < 100) {
			// 入库任务：只检查入库类型（1, 10, 53, 57）
			checkIoTypes = Arrays.asList(1, 10, 53, 57);
			@@ -339,11 +339,54 @@
			checkIoTypes = Arrays.asList(101, 110, 103, 107);
			taskTypeName = "出库";
			}
			}

			// 筛选出任务数最少的站点列表（按规则排序后的候选站点）
			int minInQty = devList.get(0).getInQty();
			List<BasDevp> minTaskSites = devList.stream()
			.filter(dev -> dev.getInQty() == minInQty)
			.collect(Collectors.toList());

			// 根据配置选择分配策略，确定优先分配的站点顺序
			List<BasDevp> orderedSites = new ArrayList<>();
			String strategy = agvProperties.getSiteAllocation().getStrategy();
			boolean enableRoundRobin = agvProperties.getSiteAllocation().isEnableRoundRobin();

			if (minTaskSites.size() > 1 && enableRoundRobin && "round-robin".equals(strategy)) {
			// 轮询分配：先按轮询策略排序
			AtomicInteger counter = siteRoundRobinCounters.computeIfAbsent(groupKey, k -> new AtomicInteger(0));
			int startIndex = counter.get() % minTaskSites.size();
			// 将轮询选中的站点放在最前面
			orderedSites.addAll(minTaskSites.subList(startIndex, minTaskSites.size()));
			orderedSites.addAll(minTaskSites.subList(0, startIndex));
			// 添加其他站点（任务数更多的）
			orderedSites.addAll(devList.stream()
			.filter(dev -> dev.getInQty() > minInQty)
			.collect(Collectors.toList()));
			log.debug("使用轮询分配策略，站点组：{}，轮询起始索引：{}", groupKey, startIndex);
			} else if (minTaskSites.size() > 1 && enableRoundRobin && "random".equals(strategy)) {
			// 随机分配：先随机排序任务数最少的站点
			List<BasDevp> shuffledMinSites = new ArrayList<>(minTaskSites);
			Collections.shuffle(shuffledMinSites);
			orderedSites.addAll(shuffledMinSites);
			// 添加其他站点（任务数更多的）
			orderedSites.addAll(devList.stream()
			.filter(dev -> dev.getInQty() > minInQty)
			.collect(Collectors.toList()));
			log.debug("使用随机分配策略");
			} else {
			// 默认：按入库任务数排序（已经排序好了）
			orderedSites = devList;
			}

			// 依次检查每个站点是否在搬运，找到第一个空闲站点就分配
			BasDevp selectedSite = null;
			for (BasDevp dev : orderedSites) {
			String staNo = String.valueOf(dev.getDevNo());

			// 检查每个站点是否有正在搬运的同类型任务
			for (BasDevp dev : devList) {
			String staNo = String.valueOf(dev.getDevNo());
			// 查询该站点是否有状态8（正在搬运）的同类型任务
			// 如果任务类型不为空，检查该站点是否有正在搬运的同类型任务
			boolean isTransporting = false;
			if (checkIoTypes != null && !checkIoTypes.isEmpty()) {
			List<Task> transportingTasks = taskService.selectList(
			new EntityWrapper<Task>()
			.eq("sta_no", staNo)
			@@ -351,61 +394,29 @@
			.eq("wrk_sts", 8L) // 只检查正在搬运状态的任务
			.in("io_type", checkIoTypes)
			);
			isTransporting = !transportingTasks.isEmpty();

			if (transportingTasks.isEmpty()) {
			// 该站点没有正在搬运的任务，可以分配
			availableDevList.add(dev);
			} else {
			log.debug("站点{}有{}个正在搬运的{}AGV任务，跳过分配",
			if (isTransporting) {
			log.debug("站点{}有{}个正在搬运的{}AGV任务，检查下一个站点",
			staNo, transportingTasks.size(), taskTypeName);
			continue; // 该站点正在搬运，检查下一个站点
			}
			}
			} else {
			// 如果ioType为空，不进行过滤（保持原有逻辑）
			availableDevList = devList;

			// 找到第一个空闲站点，分配
			selectedSite = dev;
			log.info("任务ID：{}按规则应分配到站点{}，该站点空闲，分配成功", task.getId(), staNo);
			break;
			}

			// 如果所有站点都在搬运，则不分配站点
			if (availableDevList.isEmpty()) {
			log.warn("任务ID：{}的所有候选站点都有正在搬运的{}任务，暂不分配站点",
			if (selectedSite == null) {
			log.warn("任务ID：{}的所有候选站点都有正在搬运的{}任务，暂不分配站点，等待空闲",
			task.getId(), taskIoType != null && taskIoType < 100 ? "入库" : "出库");
			return null;
			}

			// 入库任务数排序
			availableDevList.sort(Comparator.comparing(BasDevp::getInQty));

			// 选择站点
			BasDevp basDevp;
			int minInQty = availableDevList.get(0).getInQty();

			// 筛选出任务数最少的站点列表
			List<BasDevp> minTaskSites = availableDevList.stream()
			.filter(dev -> dev.getInQty() == minInQty)
			.collect(Collectors.toList());

			// 根据配置选择分配策略
			String strategy = agvProperties.getSiteAllocation().getStrategy();
			boolean enableRoundRobin = agvProperties.getSiteAllocation().isEnableRoundRobin();

			if (minTaskSites.size() > 1 && enableRoundRobin && "round-robin".equals(strategy)) {
			// 轮询分配
			AtomicInteger counter = siteRoundRobinCounters.computeIfAbsent(groupKey, k -> new AtomicInteger(0));
			int index = counter.getAndIncrement() % minTaskSites.size();
			basDevp = minTaskSites.get(index);
			log.info("使用轮询分配策略，站点组：{}，轮询索引：{}，选中站点：{}", groupKey, index, basDevp.getDevNo());
			} else if (minTaskSites.size() > 1 && enableRoundRobin && "random".equals(strategy)) {
			// 随机分配
			Random random = new Random();
			int index = random.nextInt(minTaskSites.size());
			basDevp = minTaskSites.get(index);
			log.info("使用随机分配策略，选中站点：{}", basDevp.getDevNo());
			} else {
			// 默认：选择第一个（任务最少的）
			basDevp = devList.get(0);
			}

			Integer endSite = basDevp.getDevNo();
			Integer endSite = selectedSite.getDevNo();

			// 入库暂存+1
			basDevpMapper.incrementInQty(endSite);
			@@ -445,10 +456,11 @@
			@Transactional(rollbackFor = Exception.class)
			public void moveTaskToHistory(List<Task> taskList) {

			// 写入历史表
			// 写入历史表，保持ID一致
			for (Task task : taskList) {
			TaskLog log = new TaskLog();
			BeanUtils.copyProperties(task, log);
			// 保持ID一致，不设置为null
			taskLogService.insert(log);
			}