package com.zy.asrs.wms.apis.wcs.services.Impl;
|
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
|
import com.fasterxml.jackson.core.JsonProcessingException;
|
import com.zy.asrs.framework.common.R;
|
import com.zy.asrs.framework.exception.CoolException;
|
import com.zy.asrs.wms.apis.wcs.entity.domain.SystemProperties;
|
import com.zy.asrs.wms.apis.wcs.entity.enums.EssTaskStatus;
|
import com.zy.asrs.wms.apis.wcs.entity.request.*;
|
import com.zy.asrs.wms.apis.wcs.entity.response.CommonReponse;
|
import com.zy.asrs.wms.apis.wcs.services.WcsApiService;
|
import com.zy.asrs.wms.apis.wcs.utils.HttpEssUtils;
|
import com.zy.asrs.wms.asrs.entity.*;
|
import com.zy.asrs.wms.asrs.entity.enums.CacheSiteStatusType;
|
import com.zy.asrs.wms.asrs.entity.enums.OrderPickStatus;
|
import com.zy.asrs.wms.asrs.entity.enums.TaskStsType;
|
import com.zy.asrs.wms.asrs.service.*;
|
import io.jsonwebtoken.lang.Collections;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.http.HttpEntity;
|
import org.springframework.http.HttpHeaders;
|
import org.springframework.http.HttpMethod;
|
import org.springframework.http.ResponseEntity;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.LinkedMultiValueMap;
|
import org.springframework.util.MultiValueMap;
|
import org.springframework.web.client.RestTemplate;
|
|
import javax.annotation.Resource;
|
import java.math.BigDecimal;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
@Slf4j
|
@Service
|
public class WcsApiServiceImpl implements WcsApiService {
|
|
@Autowired
|
private WaitPakinService waitPakinService;
|
@Autowired
|
private WorkService workService;
|
@Autowired
|
private TaskService taskService;
|
@Autowired
|
private TaskDetlService taskDetlService;
|
@Autowired
|
private CacheSiteService cacheSiteService;
|
@Autowired
|
private OrderService orderService;
|
@Autowired
|
private OrderDetlService orderDetlService;
|
@Autowired
|
private WaveSeedService waveSeedService;
|
|
@Autowired
|
private RestTemplate restTemplate;
|
|
@Autowired
|
private PlatformService platformService;
|
|
@Resource
|
private SystemProperties systemProperties;
|
|
|
/**
|
* 容器到达接收
|
* 根据ESS返回的容器编码修改任务档中的输送线起始位置节点，及任务档执行状态
|
* * 当前问题：
|
* * //TODO 1. 目前任务下发接口沟通下来，是需要目标位置的，这里我们只是刚组拖完成，并不是通知流动，没有目标位置
|
* * //TODO 2. 文档上的搬运任务下发指的都是多任务，多容器搬运，而不是我们需要物料信息同步功能
|
* * //TODO 3. 流程走不通暂时先跳过，确认是否需要WMS触发料箱滚动至扫码区
|
*
|
* @param arrivedParam
|
* @param hostId
|
* @return
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R containerArrivedNotify(ContainerArrivedParam arrivedParam, String taskType, Long hostId){
|
Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, arrivedParam.getContainerCode()));
|
if (task == null) {
|
return R.error("任务不存在！！");
|
}
|
log.info("容器到达接收，任务号：{}，当前状态：{}，上报状态：{}",task.getTaskNo(),task.getTaskSts$(),TaskStsType.WCS_CONTAINER_RECEIVE.desc);
|
|
taskType = task.getTaskType() > 100 ? "outStock":"inStock";
|
|
if (taskType.equals("inStock")) {
|
if (task.getTaskSts() == 198) {
|
return R.error("播种中！！");
|
}
|
if (task.getTaskSts() == TaskStsType.WCS_EXECUTE_IN.id ) {
|
//DONE 根据ESS返回的容器编码修改任务档中的输送线起始位置节点，及任务档容器到达状态
|
taskService.update(new LambdaUpdateWrapper<Task>()
|
.set(Task::getTaskSts, TaskStsType.WCS_CONTAINER_RECEIVE.id)
|
//输送线节点编码，不是源库位
|
.set(Task::getOriginSite, arrivedParam.getSlotCode())
|
.eq(Task::getBarcode, arrivedParam.getContainerCode()));
|
} else {
|
log.warn("{}没有下发任务",task.getTaskNo());
|
R.error(task.getTaskNo()+"没有下发任务");
|
}
|
} else {
|
if (task.getTaskSts() == TaskStsType.WCS_EXECUTE_OUT_ARRIVED.id
|
|| task.getTaskSts() == TaskStsType.WCS_EXECUTE_OUT_TASK_DONE.id ) {
|
// 到达拣选位，控制播种墙亮灯
|
List<CacheSite> cacheSites = cacheSiteService.list(new LambdaQueryWrapper<CacheSite>().eq(CacheSite::getBarcode, task.getBarcode()));
|
if(cacheSites.size() == 0) {
|
log.error("条码：{}，未找到播种墙亮灯",task.getBarcode());
|
throw new CoolException("未找到播种墙");
|
}
|
for (CacheSite cacheSite:cacheSites) {
|
// 获取任务明细数量
|
List<TaskDetl> taskDetlByTaskId = taskDetlService.getTaskDetlByTaskId(task.getId());
|
double sum = taskDetlByTaskId.stream().mapToDouble(TaskDetl::getAnfme).sum();
|
SlapLightControlParam slapLightControlParam = new SlapLightControlParam();
|
slapLightControlParam.setControllerCode(cacheSite.getMemo()).setTagCode(cacheSite.getSiteNo())
|
.setColor("GREEN").setMode("LIGHT").setDisplay(String.valueOf(sum));
|
// 发起亮灯请求
|
CommonReponse response = HttpEssUtils.post("到达拣选位，播种墙亮灯", HttpEssUtils.PLT_SEND_COMMAND, slapLightControlParam);
|
if (response.getCode().equals(0)) {
|
log.info("任务{}到达拣选位，播种墙{}亮灯成功",task.getTaskNo(),cacheSite.getSiteNo());
|
} else {
|
log.info("任务{}到达拣选位，播种墙{}亮灯失败",task.getTaskNo(),cacheSite.getSiteNo());
|
}
|
}
|
boolean update = taskService.update(new LambdaUpdateWrapper<Task>()
|
.set(Task::getTaskSts, TaskStsType.WAVE_SEED.id)
|
.set(Task::getOriginSite, arrivedParam.getSlotCode())
|
.eq(Task::getBarcode, arrivedParam.getContainerCode()));
|
if (!update) {
|
throw new CoolException("容器到达任务更新失败！！");
|
}
|
|
} else if(task.getTaskSts().equals(TaskStsType.UPDATED_OUT.id)) {
|
ConveyorStarParam conveyorStarParam = new ConveyorStarParam();
|
conveyorStarParam.setSlotCode(task.getOriginSite())
|
.setContainerCode(task.getBarcode())
|
.setDirection("200");
|
// 出库完成，清除输送线条码，取下箱子
|
CommonReponse response = HttpEssUtils.post("清除输送线条码", HttpEssUtils.CONVEYOR_START, conveyorStarParam);
|
if (response.getCode().equals(200)) {
|
log.info("{}出库完成，清除{}输送线条码{}成功",task.getTaskNo(),task.getOriginSite(),task.getBarcode());
|
}
|
}
|
}
|
|
return R.success("success");
|
}
|
|
/**
|
* 容器执行状态上报
|
*
|
* @param callbackParam
|
* @param stockType
|
* @param hostId
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void receiveTaskStatus(TasksStatusCallbackParam callbackParam, String stockType, Long hostId) {
|
List<Task> list = taskService.list(new LambdaQueryWrapper<Task>()
|
.eq(Task::getBarcode, callbackParam.getContainerCode())
|
.eq(Task::getTaskNo, callbackParam.getTaskCode()));
|
if (!Collections.isEmpty(list)) {
|
list.forEach(task -> {
|
log.info("容器执行状态上报，任务号：{}，当前状态：{}，上报状态：{}",task.getTaskNo(),task.getTaskSts$(),callbackParam.getEventType());
|
if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_ALLOCATED.event)) {
|
return;
|
}
|
// ESS只能配置一个状态上报接口，根据任务号判断是入库任务或出库任务
|
String taskType = task.getTaskType() > 100 ? "outStock":"inStock";
|
TaskStsType taskStsType = null;
|
if (taskType.equals("inStock")) { //入库任务
|
if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_TOTE_LOAD.event)) { //上报取箱状态
|
// if (task.getTaskSts() == TaskStsType.WCS_CONVEYOR_START.id) {
|
taskStsType = TaskStsType.WCS_TOTE_LOAD;
|
// } else {
|
// String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_TOTE_LOAD.desc + "任务";
|
// log.error(errMsg);
|
// throw new CoolException(errMsg);
|
// }
|
} else if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_TOTE_UNLOAD.event)) { //上报放箱状态
|
// if (task.getTaskSts() == TaskStsType.WCS_TOTE_LOAD.id) {
|
taskStsType = TaskStsType.WCS_TOTE_UNLOAD;
|
// } else {
|
// String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_TOTE_UNLOAD.desc + "任务";
|
// log.error(errMsg);
|
// throw new CoolException(errMsg);
|
// }
|
} else if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_STATUS.event)) { //TODO 需确认上报任务中，任务完成是哪个事件，目前暂定task事件
|
// if (task.getTaskSts() == TaskStsType.WCS_TOTE_UNLOAD.id) {
|
taskStsType = TaskStsType.WCS_PUTAWAY_SUCESS;
|
// } else {
|
// String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_PUTAWAY_SUCESS.desc + "任务";
|
// log.error(errMsg);
|
// throw new CoolException(errMsg);
|
// }
|
}
|
boolean result = taskService.update(new LambdaUpdateWrapper<Task>()
|
.set(Task::getRobotCode, callbackParam.getRobotCode())
|
// .set(Task::getSysTaskCode, callbackParam.getSysTaskCode())
|
.set(Task::getTaskSts, taskStsType != null ? taskStsType.id : task.getTaskType())
|
.set(Task::getExcudeStatus, callbackParam.getStatus())
|
.set(Task::getTaskDesc, callbackParam.getMessage())
|
.eq(Task::getBarcode, callbackParam.getContainerCode())
|
.eq(Task::getTaskNo, callbackParam.getTaskCode()));
|
|
//event事件为task，表明任务上报完成状态
|
if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_STATUS.event) && result) {
|
//任务状态修改为 99 入库完成
|
workService.completeTask(task.getId());
|
}
|
} else { //出库任务
|
if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_TOTE_LOAD.event)) { //上报取箱状态
|
// if (task.getTaskSts() == TaskStsType.WCS_EXECUTE_OUT.id ) {
|
taskStsType = TaskStsType.WCS_EXECUTE_OUT_TOTE_LOAD;
|
// } else {
|
// String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_EXECUTE_OUT_TOTE_LOAD.desc + "任务";
|
// log.error(errMsg);
|
// throw new CoolException(errMsg);
|
// }
|
} else if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_TOTE_UNLOAD.event)) { //上报放箱状态
|
// if (task.getTaskSts() == TaskStsType.WCS_EXECUTE_OUT_TOTE_LOAD.id) {
|
taskStsType = TaskStsType.WCS_EXECUTE_OUT_TOTE_UNLOAD;
|
// } else {
|
// String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_EXECUTE_OUT_TOTE_UNLOAD.desc + "任务";
|
// log.error(errMsg);
|
// throw new CoolException(errMsg);
|
// }
|
} else if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_STATUS.event)) { //上报完成状态
|
// if (task.getTaskSts() == TaskStsType.WCS_EXECUTE_OUT_TOTE_UNLOAD.id || task.getTaskSts() == TaskStsType.WCS_EXECUTE_OUT_TASK_DONE.id) {
|
//出库任务完成，修改状态为容器到达，定时任务生成播种波次
|
taskStsType = TaskStsType.WCS_EXECUTE_OUT_TASK_DONE;
|
// } else {
|
// String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_EXECUTE_OUT_TASK_DONE.desc + "任务";
|
// log.error(errMsg);
|
// throw new CoolException(errMsg);
|
// }
|
}
|
//更新出库状态及相关字段
|
boolean update = taskService.update(new LambdaUpdateWrapper<Task>()
|
.set(Task::getRobotCode, callbackParam.getRobotCode())
|
.set(Task::getSysTaskCode, callbackParam.getSysTaskCode())
|
.set(Task::getTaskSts, taskStsType != null ? taskStsType.id : task.getTaskType())
|
.set(Task::getExcudeStatus, callbackParam.getStatus())
|
.set(Task::getTaskDesc, callbackParam.getMessage())
|
.eq(Task::getBarcode, callbackParam.getContainerCode())
|
.eq(Task::getTaskNo, callbackParam.getTaskCode()));
|
|
if (!update) {
|
throw new CoolException("任务更新失败！！");
|
}
|
|
}
|
|
});
|
} else {
|
throw new CoolException("更新内容不存在！！");
|
}
|
}
|
|
/**
|
* 容器流动通知
|
*
|
* @param code
|
* @return
|
*/
|
@Override
|
public synchronized R containerConveryor(String code) {
|
List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, code));
|
if (tasks.isEmpty()) {
|
return R.error("容器码任务不存在！！");
|
} else if (tasks.size() > 1) {
|
return R.error("容器码任务错误！！");
|
}
|
tasks.forEach(task -> {
|
// try {
|
// ConveyorStarParam conveyorStarParam = new ConveyorStarParam();
|
// conveyorStarParam.setSlotCode(task.getOriginLoc())
|
// .setContainerCode(task.getBarcode());
|
// if (task.getTaskType() == 101) { //任务类型为101全盘出库，直接取下容器，传200
|
// conveyorStarParam.setDirection("200");
|
// } else if (task.getTaskType() == 103) { //如果为任务类型为103，需走回库操作，传100
|
// conveyorStarParam.setDirection("100");
|
// }
|
// //调用三方接口，将任务推送至ESS平台
|
// MultiValueMap<String, Object> params = new LinkedMultiValueMap<>();
|
// // 设置请求参数
|
// params.add("params", JSONObject.toJSONString(conveyorStarParam));
|
// log.info("请求地址：{}，请求参数：{}", Constant.CONVEYOR_START, JSONObject.toJSONString(conveyorStarParam));
|
// HttpHeaders headers = new HttpHeaders();
|
// headers.add("Content-Type", "application/json");
|
// HttpEntity httpEntity = new HttpEntity<>(params, headers);
|
// // 请求
|
// ResponseEntity<String> exchange = restTemplate.exchange(Constant.CONVEYOR_START, HttpMethod.POST, httpEntity, String.class);
|
// log.info("下发流动通知 返回结果：{}", exchange);
|
// if (exchange.getBody() == null) {
|
// throw new CoolException("下发流动通知失败！！");
|
// } else {
|
// CommonReponse commonReponse = JSON.toJavaObject(JSON.parseObject(exchange.getBody()), CommonReponse.class);
|
// if (commonReponse.getCode() == 0) {
|
//流动通知下发完成后，修改任务状态为输送线流动中。。
|
//TODO 判断任务是否为103拣料出库，103拣料流动后修改为4（RCS容器流动任务已下发）
|
if (task.getTaskType() == 103) {
|
//TODO 需找海柔确认是否需要重新调用入库接口
|
//更新库存信息,修改任务状态为4 （RCS容器流动任务已下发）
|
workService.pickTask(task.getId());
|
// taskService.update(new LambdaUpdateWrapper<Task>().eq(Task::getId, task.getId()).set(Task::getTaskSts, TaskStsType.WCS_CONVEYOR_START))
|
} else {
|
taskService.update(new LambdaUpdateWrapper<Task>()
|
.eq(Task::getId, task.getId())
|
.set(Task::getTaskSts, TaskStsType.COMPLETE_OUT.id));
|
}
|
// log.info(task.getTaskNo() + "下发流动通知" + commonReponse.getMsg());
|
// } else {
|
// throw new CoolException("下发流动通知失败！！");
|
// }
|
// }
|
// } catch (Exception ex) {
|
// log.error(ex.getMessage());
|
// } finally {
|
// //如果异常修改禁用状态
|
// taskService.update(new LambdaUpdateWrapper<Task>().set(Task::getStatus, 0)
|
// .set(Task::getUpdateTime, new Date())
|
// .eq(Task::getId, task.getId()));
|
// }
|
});
|
return R.ok();
|
}
|
|
|
@Override
|
public R rfidCallback(RfidSingalRequest request) {
|
return null;
|
}
|
|
@Override
|
public R getPlatforms() {
|
return R.ok(platformService.list(new LambdaQueryWrapper<>()));
|
}
|
|
/**
|
* 拍灯拣料逻辑，详细说明见接口调用说明
|
*
|
* @param request
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void slapLightLogic(Map<String, Object> request) {
|
String taskNo = request.get("taskNo").toString();
|
String orderNo = request.get("orderNo").toString();
|
|
List<CacheSite> performs = cacheSiteService.list(new LambdaQueryWrapper<CacheSite>().eq(CacheSite::getOrderNo, orderNo));
|
if (Objects.isNull(performs.stream().findFirst().get().getPlatformId())) {
|
throw new CoolException("请打印明细，并绑定目标集货区");
|
}
|
|
//* 1. 判断当前容器是否还有物料未拣，未拣完闪灯，拣完通知容器流动，并灭灯
|
SlapLightControlParam slapParam = new SlapLightControlParam();
|
MultiValueMap<String, Object> params = new LinkedMultiValueMap<>();
|
//默认流动
|
boolean converyor = false;
|
//判断当前任务是否还有物料未拣
|
if (!checked(orderNo, taskNo)) {
|
//调用三方接口,闪灯不做操作
|
// 设置请求参数
|
params.add("params", JSONObject.toJSONString(slapParam));
|
log.info("未完成闪灯请求地址：{}，请求参数：{}", SystemProperties.SLAP_LIGHT, JSONObject.toJSONString(slapParam));
|
} else {
|
//调用三方接口,灭灯通知容器流动， 传灭灯参数
|
//todo 判断当前订单是否完成，完成灭灯，未完成保持拣货状态亮灯
|
Order one = orderService.getOne(new LambdaQueryWrapper<Order>().eq(Order::getOrderNo, orderNo));
|
|
if (Objects.isNull(one)) {
|
throw new CoolException("当前订单明细不存在！！");
|
}
|
// //获取播种已完成的订单明细
|
// List<OrderDetl> detlList = orderDetls.stream().filter(detl -> {
|
// return detl.getPickStatus() == OrderPickStatus.ORDER_PICK_STATUS_DONE.val;
|
// }).collect(Collectors.toList());
|
|
//判断数量是否与订单明细的需求量相同，相同则订单完成
|
if (one.getPickStatus() == OrderPickStatus.ORDER_PICK_STATUS_DONE.val) {
|
//播种完成，释放绑定站点
|
List<CacheSite> cacheSites = cacheSiteService.list(new LambdaQueryWrapper<CacheSite>().eq(CacheSite::getOrderNo, orderNo));
|
for (CacheSite cacheSite : cacheSites) {
|
if (!cacheSite.getSiteStatus().equals(CacheSiteStatusType.O.id)) {
|
cacheSite.setSiteStatus(CacheSiteStatusType.O.id);
|
cacheSite.setOrderId(null);
|
cacheSite.setBarcode(null);
|
cacheSite.setOrderNo(null);
|
cacheSite.setPlatformId(null);
|
cacheSite.setPlatformNo(null);
|
cacheSite.setUpdateTime(new Date());
|
if (!cacheSiteService.updateById(cacheSite)) {
|
throw new CoolException("播种站点更新失败");
|
}
|
}
|
}
|
}
|
converyor = true;
|
params.add("params", JSONObject.toJSONString(slapParam));
|
log.info("完成灭灯请求地址：{}，请求参数：{}", SystemProperties.SLAP_LIGHT, JSONObject.toJSONString(slapParam));
|
}
|
|
if (converyor) {
|
Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getTaskNo, request.get("taskNo")));
|
if (Objects.isNull(task)) {
|
throw new CoolException("任务不存在！！");
|
}
|
containerConveryor(task.getBarcode());
|
}
|
|
// HttpHeaders headers = new HttpHeaders();
|
// headers.add("Content-Type", "application/json");
|
// HttpEntity httpEntity = new HttpEntity<>(params, headers);
|
// // 请求
|
// ResponseEntity<CommonReponse> exchange = restTemplate.exchange(SystemProperties.CONVEYOR_START, HttpMethod.POST, httpEntity, CommonReponse.class);
|
// log.info("下发流动通知 返回结果：{}", exchange);
|
// if (exchange.getBody() == null) {
|
// throw new CoolException("下发流动通知失败！！");
|
// } else {
|
// CommonReponse response = exchange.getBody();
|
// if (response.getCode() == 0) {
|
// if (!converyor) {
|
// //* 2. 容器流动判断，如果料箱没有物料 code传200， 有物料传100 执行回库任务,修改任务状态为 调用containerConveryor（taskNo）方法
|
// containerConveryor(request.get("taskNo").toString());
|
// }
|
// }
|
// }
|
}
|
|
/**
|
* 判断当前任务下，订单是否已完成拣货
|
*
|
* @param orderNo
|
* @param taskNo
|
* @return
|
*/
|
public synchronized boolean checked(String orderNo, String taskNo) {
|
if (Objects.isNull(orderNo)) {
|
throw new CoolException("订单编码不能为空！！");
|
}
|
if (Objects.isNull(taskNo)) {
|
throw new CoolException("任务编码不能为空！！");
|
}
|
|
List<TaskDetl> taskDetls = taskDetlService.list(new LambdaQueryWrapper<TaskDetl>().eq(TaskDetl::getTaskNo, taskNo));
|
if (taskDetls.isEmpty()) {
|
throw new CoolException("订单明细不存在！！");
|
}
|
|
List<Long> detlIds = taskDetls.stream().map(TaskDetl::getId).collect(Collectors.toList());
|
|
double taskNum = taskDetls.stream().mapToDouble(TaskDetl::getAnfme).sum();
|
|
List<WaveSeed> seeds = waveSeedService.list(new LambdaQueryWrapper<WaveSeed>().in(WaveSeed::getTaskDetlId, detlIds));
|
if (seeds.isEmpty()) {
|
throw new CoolException("播种信息不存在！！！");
|
}
|
double seedNum = seeds.stream().mapToDouble(WaveSeed::getWorkQty).sum();
|
//判断任务需求总量是否等播种总数量
|
if (taskNum == seedNum) {
|
return true;
|
} else {
|
return false;
|
}
|
}
|
|
}
|
