feature: 自助报到服务完善

1.自助报到时没有安排房间也更新客房系统中的报到状态

ruoyi-api/ruoyi-api-hotel/src/main/java/org/dromara/hotel/api/service/RemoteOrderService.java

@@ -58,4 +58,12 @@ public interface RemoteOrderService {
      *
      */
     List<RemoteOrderVo> getOrderAndGuestByRoomCodes(List<String> roomCode);
+
+    /**
+     * 更新培训班团客的报到状态
+     * @param guestId 客人Id
+     * @param TeamId 团客Id
+     * @return 更新结果
+     */
+    Boolean updateCheckInStatus(Long guestId, Long TeamId);
 }

ruoyi-modules/ruoyi-backstage/src/main/java/org/dromara/backstage/business/self/TraineeBusiness.java

@@ -30,8 +30,6 @@ import org.dromara.backstage.payment.domain.vo.PtBagVo;
 import org.dromara.backstage.payment.service.IPtBagService;
 import org.dromara.backstage.payment.service.IPtUserAccountService;
 import org.dromara.common.core.constant.CacheNames;
-import org.dromara.common.core.constant.CloudMqTopicConstants;
-import org.dromara.common.core.constant.DefaultConstants;
 import org.dromara.common.core.constant.HotelBusinessConstants;
 import org.dromara.common.core.domain.R;
 import org.dromara.common.core.domain.model.ErrorInfo;
@@ -317,7 +315,6 @@ public class TraineeBusiness {
      * @return 入住 信息
      */
     private RemoteOrderVo checkInTeamByBo(YcTraineeBo bo) {
-
         RemoteOrderBo remoteBo = new RemoteOrderBo();
         remoteBo.setGuestId(bo.getGuestId());
         remoteBo.setGuestName(bo.getUserXm());
@@ -368,6 +365,9 @@ public class TraineeBusiness {
             ycTraineeVo.setCheckinState(1);
             ycTraineeVo.setCheckinDate(DateUtil.date());
         }
+        // 设置团客的报到状态
+        kfOrderService.updateCheckInStatus(bo.getGuestId(), bo.getTeamId());
+
     }
 
     /**

ruoyi-modules/ruoyi-hotel/src/main/java/org/dromara/hotel/dubbo/RemoteOrderServiceImpl.java

@@ -89,4 +89,14 @@ public class RemoteOrderServiceImpl implements RemoteOrderService {
     public List<RemoteOrderVo> getOrderAndGuestByRoomCodes(List<String> roomCode) {
         return kfOrderService.queryByRoomCodes(roomCode);
     }
+    /**
+     * 更新培训班团客的报到状态
+     * @param guestId 客人Id
+     * @param TeamId 团客Id
+     * @return 更新结果
+     */
+    @Override
+    public Boolean updateCheckInStatus(Long guestId, Long TeamId) {
+        return kfOrderService.updateCheckInStatus(guestId, TeamId);
+    }
 }

ruoyi-modules/ruoyi-hotel/src/main/java/org/dromara/hotel/service/IKfOrderService.java

@@ -1,6 +1,5 @@
 package org.dromara.hotel.service;
 
-import org.checkerframework.checker.units.qual.C;
 import org.dromara.common.core.domain.R;
 import org.dromara.common.mybatis.core.page.PageQuery;
 import org.dromara.common.mybatis.core.page.TableDataInfo;
@@ -144,4 +143,11 @@ public interface IKfOrderService {
      * @return 订单信息
      */
     List<RemoteOrderVo> queryByRoomCodes(List<String> roomCodes);
+    /**
+     * 更新培训班团客的报到状态
+     * @param guestId 客人Id
+     * @param TeamId 团客Id
+     * @return 更新结果
+     */
+    Boolean updateCheckInStatus(Long guestId, Long TeamId);
 }

ruoyi-modules/ruoyi-hotel/src/main/java/org/dromara/hotel/service/impl/KfOrderServiceImpl.java

@@ -98,6 +98,7 @@ public class KfOrderServiceImpl implements IKfOrderService {
 
     /**
      * 根据订单状态查询 订单列表
+     *
      * @param orderStatus 订单状态
      * @return 订单列表
      */
@@ -125,16 +126,16 @@ public class KfOrderServiceImpl implements IKfOrderService {
 
     @Override
     public R<KfTeamGuestVo> getTeamGuestCheckInfo(KfGuestBo bo) {
-        //1.查询团客信息
+        // 1.查询团客信息
         KfTeamGuestVo teamGuest = baseMapper.getTeamGuestCheckInfo(bo);
-        if(ObjectUtil.isEmpty(teamGuest)) {
+        if (ObjectUtil.isEmpty(teamGuest)) {
             return R.fail("未找到对应的团客人员信息,请确认身份证号或手机号是否正确!");
         }
-        //2.查询团客入住信息
+        // 2.查询团客入住信息
         KfOrder order = baseMapper.selectOne(Wrappers.<KfOrder>lambdaQuery()
-            .eq(KfOrder::getGuestId, teamGuest.getId())
-            .eq(KfOrder::getTeamId, teamGuest.getTeamId()));
-        if(ObjectUtil.isNotEmpty(order)) {
+                                                 .eq(KfOrder::getGuestId, teamGuest.getId())
+                                                 .eq(KfOrder::getTeamId, teamGuest.getTeamId()));
+        if (ObjectUtil.isNotEmpty(order)) {
             teamGuest.setRoomCode(order.getRoomCode());
             teamGuest.setRoomName(order.getRoomName());
             teamGuest.setOrderId(order.getId());
@@ -155,7 +156,7 @@ public class KfOrderServiceImpl implements IKfOrderService {
             lqw.in(KfOrder::getOrderStatus, orderStatusList);
         }
         lqw.eq(StringUtils.isNotBlank(bo.getOrderType()), KfOrder::getOrderType, bo.getOrderType());
-        lqw.eq(bo.getTeamId()!= null, KfOrder::getTeamId, bo.getTeamId());
+        lqw.eq(bo.getTeamId() != null, KfOrder::getTeamId, bo.getTeamId());
         lqw.orderByAsc(KfOrder::getOrderIndex);
         return lqw;
     }
@@ -204,22 +205,23 @@ public class KfOrderServiceImpl implements IKfOrderService {
     @Override
     @Transactional
     public Boolean roomAssign(KfOrderBo bo) {
-        //校验该团客是否已经有预定或者入住状态的订单
+        // 校验该团客是否已经有预定或者入住状态的订单
         if (baseMapper.selectCount(new LambdaQueryWrapper<KfOrder>()
-            .eq(KfOrder::getGuestId, bo.getGuestId())
-            .in(KfOrder::getOrderStatus, HotelBusinessConstants.ORDER_STATUS_YD, HotelBusinessConstants.ORDER_STATUS_RZ)) > 0) {
+                                       .eq(KfOrder::getGuestId, bo.getGuestId())
+                                       .in(KfOrder::getOrderStatus, HotelBusinessConstants.ORDER_STATUS_YD,
+                                           HotelBusinessConstants.ORDER_STATUS_RZ)) > 0) {
             throw new ServiceException("该团客已有预定或者入住状态的订单，请先取消或修改订单");
         }
-        //根据团客ID查询客团信息
+        // 根据团客ID查询客团信息
         KfTeamVo teamVo = teamService.queryById(bo.getTeamId());
         bo.setTeamName(teamVo.getName());
         bo.setStartTime(teamVo.getStartTime());
         bo.setEndTime(teamVo.getEndTime());
         bo.setOrderStatus(HotelBusinessConstants.ORDER_STATUS_YD);
         bo.setOrderType(HotelBusinessConstants.ORDER_TYPE_TK);
-        //插入订单
+        // 插入订单
         boolean flag = insertByBo(bo);
-        //修改房间状态为预定
+        // 修改房间状态为预定
         baseMapper.updateRoomStatus(bo.getRoomCode(), HotelRoomStatusEnum.YD.code());
         return flag;
     }
@@ -228,29 +230,29 @@ public class KfOrderServiceImpl implements IKfOrderService {
     @Transactional
     public Boolean lockRoom(List<KfOrderBo> bos) {
 
-        if(ObjectUtil.isNotEmpty(bos)){
+        if (ObjectUtil.isNotEmpty(bos)) {
             List<KfOrder> orders = MapstructUtils.convert(bos, KfOrder.class);
             Long teamId = bos.get(0).getTeamId();
-            for(int i = 0; i < orders.size(); i++){
+            for (int i = 0; i < orders.size(); i++) {
                 orders.get(i).setOrderStatus(HotelBusinessConstants.ORDER_STATUS_SF);
                 orders.get(i).setOrderType(HotelBusinessConstants.ORDER_TYPE_TK);
                 orders.get(i).setOrderIndex(i);
             }
-            //根据teamId 删除历史锁房
+            // 根据teamId 删除历史锁房
             baseMapper.delete(new LambdaQueryWrapper<KfOrder>()
-                .eq(KfOrder::getTeamId, teamId)
-                .eq(KfOrder::getOrderStatus, HotelBusinessConstants.ORDER_STATUS_SF));
-            //新增锁房订单
+                                  .eq(KfOrder::getTeamId, teamId)
+                                  .eq(KfOrder::getOrderStatus, HotelBusinessConstants.ORDER_STATUS_SF));
+            // 新增锁房订单
             baseMapper.insertBatch(orders);
-            //重设缓存
+            // 重设缓存
             String key = CacheNames.CLASS_ROOM + "_" + teamId;
-            if(RedisUtils.isExistsObject(key)){
+            if (RedisUtils.isExistsObject(key)) {
                 RedisUtils.deleteObject(key);
             }
             LinkedBlockingQueue<String> concurrentLinkedQueue = new LinkedBlockingQueue<>();
             orders.forEach(k -> concurrentLinkedQueue.add(k.getRoomCode()));
             RedisUtils.setCacheObject(key, concurrentLinkedQueue);
-            //刷新房间状态
+            // 刷新房间状态
             orders.forEach(k -> {
                 baseMapper.updateRoomStatus(k.getRoomCode(), HotelRoomStatusEnum.SF.code());
             });
@@ -278,80 +280,80 @@ public class KfOrderServiceImpl implements IKfOrderService {
     @Override
     public Boolean teamGuestCheckIn(KfTeamGuestVo bo) {
         boolean flag = false;
-        //1.根据客人ID和客团ID修改客人客团关系表的报到状态，并发送kafka消息
+        // 1.根据客人ID和客团ID修改客人客团关系表的报到状态，并发送kafka消息
         flag = guestTeamService.setGuestCheckInStatus(bo.getId(), bo.getTeamId());
         String roomCode = bo.getRoomCode();
-        //2.修改订单信息
+        // 2.修改订单信息
         if (bo.getOrderId() != null) {
             // 参数里面有OrderId，设置订单状态为入住
             KfOrderBo orderBo = new KfOrderBo();
             orderBo.setId(bo.getOrderId());
             orderBo.setOrderStatus(HotelBusinessConstants.ORDER_STATUS_RZ);
-            //3.删除锁房缓存，根据roomCode修改房间状态
+            // 3.删除锁房缓存，根据roomCode修改房间状态
             updateOrderAndRoomStatus(orderBo);
         } else {
             // 参数里面没有OrderId，根据团客ID查询锁房订单信息，设置订单状态为入住
             LambdaQueryWrapper<KfOrder> queryWrapper = new LambdaQueryWrapper<KfOrder>()
-                .eq(KfOrder::getTeamId, bo.getTeamId())
-                .eq(KfOrder::getOrderStatus, HotelBusinessConstants.ORDER_STATUS_SF)
-                .orderByAsc(KfOrder::getOrderIndex);
+                                                           .eq(KfOrder::getTeamId, bo.getTeamId())
+                                                           .eq(KfOrder::getOrderStatus, HotelBusinessConstants.ORDER_STATUS_SF)
+                                                           .orderByAsc(KfOrder::getOrderIndex);
 
             List<KfOrderVo> list = baseMapper.selectVoList(queryWrapper);
-            if(ObjectUtil.isNotEmpty(list)){
+            if (ObjectUtil.isNotEmpty(list)) {
                 KfOrderVo orderVo = list.get(0);
                 KfOrderBo orderBo = new KfOrderBo();
                 orderBo.setId(orderVo.getId());
                 orderBo.setGuestId(bo.getId());
                 orderBo.setGuestName(bo.getName());
                 orderBo.setOrderStatus(HotelBusinessConstants.ORDER_STATUS_RZ);
-                //3.删除锁房缓存，根据roomCode修改房间状态
+                // 3.删除锁房缓存，根据roomCode修改房间状态
                 updateOrderAndRoomStatus(orderBo);
             }
         }
         return flag;
-        }
+    }
 
     @Override
     public R<Void> phoneCheckIn(String phone, String phoneCode) {
-        //1.校验验证码
-        if(RedisUtils.isExistsObject(SmsUtils.PHONE_CODE_PREFIX + phone)){
-            if(RedisUtils.getCacheObject(SmsUtils.PHONE_CODE_PREFIX + phone).equals(phoneCode)){
-                //2.根据手机号查询团客信息
+        // 1.校验验证码
+        if (RedisUtils.isExistsObject(SmsUtils.PHONE_CODE_PREFIX + phone)) {
+            if (RedisUtils.getCacheObject(SmsUtils.PHONE_CODE_PREFIX + phone).equals(phoneCode)) {
+                // 2.根据手机号查询团客信息
                 KfGuestBo guestBo = new KfGuestBo();
                 guestBo.setPhone(phone);
                 R<KfTeamGuestVo> teamGuestVoR = getTeamGuestCheckInfo(guestBo);
-                if(R.isError(teamGuestVoR)){
+                if (R.isError(teamGuestVoR)) {
                     return R.fail(teamGuestVoR.getMsg());
                 }
-                if("已报到".equals(teamGuestVoR.getData().getCheckInStatus())){
+                if ("已报到".equals(teamGuestVoR.getData().getCheckInStatus())) {
                     return R.ok("该团客已报到");
                 }
-                //3.报到
-                if(teamGuestCheckIn(teamGuestVoR.getData())){
+                // 3.报到
+                if (teamGuestCheckIn(teamGuestVoR.getData())) {
                     return R.ok("报到成功");
-                }else {
+                } else {
                     return R.fail("报到失败");
                 }
             } else {
                 return R.fail("验证码错误");
             }
-        }else {
+        } else {
             return R.fail("验证码错误");
         }
     }
 
     @Override
     public Boolean updateOrderAndRoomStatus(KfOrderBo bo) {
-        if(ObjectUtil.isNotEmpty(bo)){
-            //更新订单
+        if (ObjectUtil.isNotEmpty(bo)) {
+            // 更新订单
             boolean flag = updateByBo(bo);
-            if(flag){
+            if (flag) {
                 String roomStatus = HotelBusinessConstants.orderStatusRoomStatusMap.get(bo.getOrderStatus());
-                //更新房间状态
+                // 更新房间状态
                 baseMapper.updateRoomStatus(bo.getRoomCode(), roomStatus);
-                //清除缓存
+                // 清除缓存
                 String key = CacheNames.CLASS_ROOM + "_" + bo.getTeamId();
-                if(RedisUtils.isExistsObject(key)){
+                if (RedisUtils.isExistsObject(key)) {
                     LinkedBlockingQueue<String> concurrentLinkedQueue = RedisUtils.getCacheObject(key);
                     concurrentLinkedQueue.poll();
                     RedisUtils.setCacheObject(key, concurrentLinkedQueue);
@@ -383,52 +385,53 @@ public class KfOrderServiceImpl implements IKfOrderService {
 
     /**
      * 批量取消订单
+     *
      * @param bo 预定和入住的订单
      * @return
      */
     @Transactional
     public Boolean distributeForRoomStatus(List<KfOrderBo> bo) {
         boolean flag = false;
-        if(CollectionUtil.isEmpty(bo)){
+        if (CollectionUtil.isEmpty(bo)) {
             return flag;
         }
         // 1. 修改订单状态 只有预定和入住的可以退房
         List<String> orderStatusYd = List.of(HotelBusinessConstants.ORDER_STATUS_YD, HotelBusinessConstants.ORDER_STATUS_RZ);
         List<KfOrderBo> kfOrderBos = bo.stream().filter(item -> orderStatusYd.contains(item.getOrderStatus())).toList();
-        if(CollectionUtil.isEmpty(kfOrderBos)){
+        if (CollectionUtil.isEmpty(kfOrderBos)) {
             return flag;
         }
         List<KfOrder> convert = new ArrayList<>();
         kfOrderBos.forEach(item -> {
             KfOrder kfOrder = new KfOrder();
             kfOrder.setId(item.getId());
-            if(HotelBusinessConstants.ORDER_STATUS_YD.equals(item.getOrderStatus())){
+            if (HotelBusinessConstants.ORDER_STATUS_YD.equals(item.getOrderStatus())) {
                 kfOrder.setOrderStatus(HotelBusinessConstants.ORDER_STATUS_QX);
-            }else{
+            } else {
                 kfOrder.setOrderStatus(HotelBusinessConstants.ORDER_STATUS_TF);
             }
             convert.add(kfOrder);
         });
 
-        if(CollectionUtil.isEmpty(convert)){
+        if (CollectionUtil.isEmpty(convert)) {
             return flag;
         }
         boolean b = baseMapper.updateBatchById(convert);
-        if(!b){
+        if (!b) {
             return flag;
         }
         // 2. 修改房间状态 updateRoomStatusBatch
         List<KfOrderBo> oks = kfOrderBos.stream().filter(item -> HotelBusinessConstants.ORDER_STATUS_YD.equals(item.getOrderStatus())).toList();
-        //ok房
+        // ok房
         List<String> okRoomCodes = oks.stream().map(KfOrderBo::getRoomCode).toList();
-        if(CollectionUtil.isNotEmpty(okRoomCodes)){
+        if (CollectionUtil.isNotEmpty(okRoomCodes)) {
             int i = baseMapper.updateRoomStatusBatch(okRoomCodes, HotelRoomStatusEnum.OK.code());
         }
 
         List<KfOrderBo> zfs = kfOrderBos.stream().filter(item -> HotelBusinessConstants.ORDER_STATUS_RZ.equals(item.getOrderStatus())).toList();
-        //脏房
+        // 脏房
         List<String> zfRoomCodes = zfs.stream().map(KfOrderBo::getRoomCode).toList();
-        if(CollectionUtil.isNotEmpty(zfRoomCodes)){
+        if (CollectionUtil.isNotEmpty(zfRoomCodes)) {
             int j = baseMapper.updateRoomStatusBatch(zfRoomCodes, HotelRoomStatusEnum.ZF.code());
         }
 
@@ -470,7 +473,7 @@ public class KfOrderServiceImpl implements IKfOrderService {
     }
 
     @Override
-//    @Transactional
+    //    @Transactional
     public boolean checkInTeamFromRoomStatus(KfOrderBo bo) {
         // 查询 客人信息 是否有存在的订单
         LambdaQueryWrapper<KfOrder> queryWrapper = Wrappers.lambdaQuery();
@@ -479,11 +482,11 @@ public class KfOrderServiceImpl implements IKfOrderService {
         queryWrapper.and(e -> e.eq(KfOrder::getRoomCode, bo.getRoomCode()).or().eq(KfOrder::getGuestId, bo.getGuestId()));
         // 已入住、已预定 不能再入住
         // 房间状态是否为ok房 其他房不能入住
-        if(baseMapper.selectCount(queryWrapper) > 0){
+        if (baseMapper.selectCount(queryWrapper) > 0) {
             throw new ServiceException("不能办理入住,原因：1.已入住或已预定，2.房间不是OK房");
         }
 
-        //办理入住
+        // 办理入住
         bo.setOrderStatus(HotelBusinessConstants.ORDER_STATUS_RZ); // 入住
         bo.setOrderType(HotelBusinessConstants.ORDER_TYPE_TK); // 客团
         RemoteOrderVo remoteOrderVo = checkInTeamByBoPrivate(bo);
@@ -495,11 +498,11 @@ public class KfOrderServiceImpl implements IKfOrderService {
     @Transactional
     public boolean changeRoom(ChangeRoomBo bo) {
         List<KfOrderBo> oldOrderList = bo.getOldOrderList();
-        if(CollectionUtil.isEmpty(oldOrderList)){
+        if (CollectionUtil.isEmpty(oldOrderList)) {
             throw new ServiceException("无原始订单信息，无需办理换房");
         }
-        //处理原始订单信息
-        //1.修改订单状态为退房
+        // 处理原始订单信息
+        // 1.修改订单状态为退房
         List<KfOrder> oldOrders = new ArrayList<>();
         for (KfOrderBo kfOrderBo : oldOrderList) {
             KfOrder kfOrder = new KfOrder();
@@ -508,26 +511,26 @@ public class KfOrderServiceImpl implements IKfOrderService {
             oldOrders.add(kfOrder);
         }
         baseMapper.updateBatchById(oldOrders);
-        //2.修改房间状态为脏房
+        // 2.修改房间状态为脏房
         String oldRoomCode = oldOrderList.get(0).getRoomCode();
         baseMapper.updateRoomStatus(oldRoomCode, HotelRoomStatusEnum.ZF.code());
 
-        //新增新订单
-        //1.根据原始订单进行新增订单
+        // 新增新订单
+        // 1.根据原始订单进行新增订单
         List<KfOrder> newOrders = new ArrayList<>();
         oldOrderList.forEach(item -> {
             KfOrder kfOrder = baseMapper.selectById(item.getId());
-            if(kfOrder != null){
+            if (kfOrder != null) {
                 // 复制订单到convert
                 KfOrder convert = BeanUtil.copyProperties(kfOrder, KfOrder.class);
-//                assert convert != null;
+                //                assert convert != null;
                 convert.setId(null);
                 convert.setOrderStatus(HotelBusinessConstants.ORDER_STATUS_RZ);
                 convert.setStartTime(bo.getStartTime());
                 convert.setEndTime(bo.getEndTime());
                 convert.setRoomCode(bo.getNewRoomCode());
                 convert.setRoomName(bo.getNewRoomCode());
-                String defaultRemark = "由"+oldRoomCode+"换到"+bo.getNewRoomCode();
+                String defaultRemark = "由" + oldRoomCode + "换到" + bo.getNewRoomCode();
                 String remark = StringUtils.isNotBlank(item.getRemark()) ? item.getRemark() + ";" + defaultRemark : defaultRemark;
                 convert.setRemark(remark);
                 newOrders.add(convert);
@@ -535,7 +538,7 @@ public class KfOrderServiceImpl implements IKfOrderService {
         });
 
         baseMapper.insertBatch(newOrders);
-        //2.修改房间状态为入住
+        // 2.修改房间状态为入住
         baseMapper.updateRoomStatus(bo.getNewRoomCode(), HotelRoomStatusEnum.YZ.code());
 
 
@@ -560,11 +563,11 @@ public class KfOrderServiceImpl implements IKfOrderService {
      * @return 入住信息
      */
     @Override
-//    @Transactional
+    //    @Transactional
     public RemoteOrderVo checkInTeamByBo(RemoteOrderBo remoteBo) {
         KfOrderBo bo = MapstructUtils.convert(remoteBo, KfOrderBo.class);
-        //KfTeamGuestVo
-        //teamGuestCheckIn()
+        // KfTeamGuestVo
+        // teamGuestCheckIn()
         return checkInTeamByBoPrivate(bo);
     }
 
@@ -582,9 +585,9 @@ public class KfOrderServiceImpl implements IKfOrderService {
             } else {
                 this.insertByBo(bo);
             }
-            //设置团客报到状态
+            // 设置团客报到状态
             guestTeamService.setGuestCheckInStatus(bo.getGuestId(), bo.getTeamId());
-            //设置房间状态
+            // 设置房间状态
             roomService.updateGuestRoomStatus(bo.getRoomCode(), defaultConfig.getTenantId(), HotelRoomStatusEnum.YZ.code());
             KfOrderBo queryBo = new KfOrderBo();
             queryBo.setId(bo.getId());
@@ -618,7 +621,9 @@ public class KfOrderServiceImpl implements IKfOrderService {
     @Override
     public List<KfOrderVo> queryOrderAndGuestByNameOrPhone(String nameOrPhone) {
         List<KfOrderVo> kfOrderVos = baseMapper.queryListByGuestNameOrPhone(nameOrPhone,
-            List.of(HotelBusinessConstants.ORDER_STATUS_RZ, HotelBusinessConstants.ORDER_STATUS_YD, HotelBusinessConstants.ORDER_STATUS_SF));
+                                                                            List.of(HotelBusinessConstants.ORDER_STATUS_RZ,
+                                                                                    HotelBusinessConstants.ORDER_STATUS_YD,
+                                                                                    HotelBusinessConstants.ORDER_STATUS_SF));
         if (CollectionUtil.isEmpty(kfOrderVos)) {
             return ListUtil.empty();
         }
@@ -636,4 +641,16 @@ public class KfOrderServiceImpl implements IKfOrderService {
         return baseMapper.queryByRoomCodes(roomCodes);
     }
 
+    /**
+     * 更新培训班团客的报到状态
+     *
+     * @param guestId 客人Id
+     * @param TeamId  团客Id
+     * @return 更新结果
+     */
+    @Override
+    public Boolean updateCheckInStatus(Long guestId, Long TeamId) {
+        // 设置团客报到状态
+        return guestTeamService.setGuestCheckInStatus(guestId, TeamId);
+    }
 }