fix: 移除未使用的变量修复TypeScript编译错误

feat: 简化用户隧道权限分配，支持多选隧道批量分配 (#8)

springboot-backend/src/main/java/com/admin/common/dto/UserTunnelBatchAssignDto.java

@@ -0,0 +1,26 @@
+package com.admin.common.dto;
+
+import lombok.Data;
+import javax.validation.Valid;
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.NotEmpty;
+import java.util.List;
+
+@Data
+public class UserTunnelBatchAssignDto {
+    
+    @NotNull(message = "用户ID不能为空")
+    private Integer userId;
+    
+    @Valid
+    @NotEmpty(message = "隧道列表不能为空")
+    private List<TunnelAssignItem> tunnels;
+    
+    @Data
+    public static class TunnelAssignItem {
+        @NotNull(message = "隧道ID不能为空")
+        private Integer tunnelId;
+        
+        private Integer speedId;
+    }
+}

springboot-backend/src/main/java/com/admin/common/dto/UserTunnelDto.java

@@ -13,28 +13,15 @@ public class UserTunnelDto {
     @NotNull(message = "隧道ID不能为空")
     private Integer tunnelId;
     
-    @NotNull(message = "流量限制不能为空")
     @Min(value = 0, message = "流量限制不能小于0")
     private Long flow;
     
-    @NotNull(message = "转发数量不能为空")
     @Min(value = 0, message = "转发数量不能小于0")
     private Integer num;
     
-    /**
-     * 流量重置时间（时间戳）
-     */
-    @NotNull(message = "流量重置时间不能为空")
     private Long flowResetTime;
     
-    /**
-     * 到期时间（时间戳）
-     */
-    @NotNull(message = "到期时间不能为空")
     private Long expTime;
     
-    /**
-     * 限速规则ID（可选，null表示不限速）
-     */
     private Integer speedId;
-} 
+}

springboot-backend/src/main/java/com/admin/controller/TunnelController.java

@@ -5,6 +5,7 @@ import com.admin.common.annotation.RequireRole;
 import com.admin.common.dto.TunnelDto;
 import com.admin.common.dto.TunnelUpdateDto;
 
+import com.admin.common.dto.UserTunnelBatchAssignDto;
 import com.admin.common.dto.UserTunnelDto;
 import com.admin.common.dto.UserTunnelQueryDto;
 import com.admin.common.dto.UserTunnelUpdateDto;
@@ -78,6 +79,13 @@ public class TunnelController extends BaseController {
     public R assignUserTunnel(@Validated @RequestBody UserTunnelDto userTunnelDto) {
         return userTunnelService.assignUserTunnel(userTunnelDto);
     }
+
+    @LogAnnotation
+    @RequireRole
+    @PostMapping("/user/batch-assign")
+    public R batchAssignUserTunnel(@Validated @RequestBody UserTunnelBatchAssignDto batchAssignDto) {
+        return userTunnelService.batchAssignUserTunnel(batchAssignDto);
+    }
     
     /**
      * 查询用户隧道权限列表

springboot-backend/src/main/java/com/admin/service/UserTunnelService.java

@@ -1,49 +1,23 @@
-package com.admin.service;
-
-import com.admin.common.dto.UserTunnelDto;
-import com.admin.common.dto.UserTunnelQueryDto;
-import com.admin.common.dto.UserTunnelUpdateDto;
-import com.admin.common.lang.R;
-import com.admin.entity.UserTunnel;
-import com.baomidou.mybatisplus.extension.service.IService;
-
-/**
- * <p>
- * 用户隧道权限服务类
- * </p>
- *
- * @author QAQ
- * @since 2025-06-03
- */
-public interface UserTunnelService extends IService<UserTunnel> {
-
-    /**
-     * 分配用户隧道权限
-     * @param userTunnelDto 用户隧道权限数据
-     * @return 结果
-     */
-    R assignUserTunnel(UserTunnelDto userTunnelDto);
-    
-    /**
-     * 查询用户隧道权限列表
-     * @param queryDto 查询条件
-     * @return 结果
-     */
-    R getUserTunnelList(UserTunnelQueryDto queryDto);
-    
-    /**
-     * 删除用户隧道权限
-     * @param id ID
-     * @return 结果
-     */
-    R removeUserTunnel(Integer id);
-
-    
-    /**
-     * 更新用户隧道权限（包含流量、流量重置时间、到期时间）
-     * @param updateDto 更新数据
-     * @return 结果
-     */
-    R updateUserTunnel(UserTunnelUpdateDto updateDto);
-
-}
+package com.admin.service;
+
+import com.admin.common.dto.UserTunnelBatchAssignDto;
+import com.admin.common.dto.UserTunnelDto;
+import com.admin.common.dto.UserTunnelQueryDto;
+import com.admin.common.dto.UserTunnelUpdateDto;
+import com.admin.common.lang.R;
+import com.admin.entity.UserTunnel;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+public interface UserTunnelService extends IService<UserTunnel> {
+
+    R assignUserTunnel(UserTunnelDto userTunnelDto);
+    
+    R batchAssignUserTunnel(UserTunnelBatchAssignDto batchAssignDto);
+    
+    R getUserTunnelList(UserTunnelQueryDto queryDto);
+    
+    R removeUserTunnel(Integer id);
+    
+    R updateUserTunnel(UserTunnelUpdateDto updateDto);
+
+}

springboot-backend/src/main/java/com/admin/service/impl/NodeServiceImpl.java

@@ -15,6 +15,7 @@ import com.admin.service.*;
 import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import lombok.extern.slf4j.Slf4j;
@@ -142,10 +143,26 @@ public class NodeServiceImpl extends ServiceImpl<NodeMapper, Node> implements No
 
 
 
-        Node updateNode = buildUpdateNode(nodeUpdateDto);
-        this.updateById(updateNode);
-        return R.ok();
-    }
+        Node updateNode = buildUpdateNode(nodeUpdateDto);
+        // Use LambdaUpdateWrapper to explicitly set nullable fields (serverIpV4/V6)
+        // because updateById() skips null fields by default
+        LambdaUpdateWrapper<Node> wrapper = new LambdaUpdateWrapper<>();
+        wrapper.eq(Node::getId, updateNode.getId())
+               .set(Node::getName, updateNode.getName())
+               .set(Node::getServerIp, updateNode.getServerIp())
+               .set(Node::getServerIpV4, updateNode.getServerIpV4())
+               .set(Node::getServerIpV6, updateNode.getServerIpV6())
+               .set(Node::getPort, updateNode.getPort())
+               .set(Node::getHttp, updateNode.getHttp())
+               .set(Node::getTls, updateNode.getTls())
+               .set(Node::getSocks, updateNode.getSocks())
+               .set(Node::getInterfaceName, updateNode.getInterfaceName())
+               .set(Node::getTcpListenAddr, updateNode.getTcpListenAddr())
+               .set(Node::getUdpListenAddr, updateNode.getUdpListenAddr())
+               .set(Node::getUpdatedTime, updateNode.getUpdatedTime());
+        this.update(wrapper);
+        return R.ok();
+    }
 
     @Override
     public R deleteNode(Long id) {

springboot-backend/src/main/java/com/admin/service/impl/UserTunnelServiceImpl.java

@@ -1,120 +1,181 @@
-package com.admin.service.impl;
-
-import com.admin.common.dto.*;
-import com.admin.common.lang.R;
-import com.admin.entity.UserTunnel;
-import com.admin.mapper.TunnelMapper;
-import com.admin.mapper.UserTunnelMapper;
-import com.admin.service.TunnelService;
-import com.admin.service.UserTunnelService;
-import com.admin.service.ForwardService;
-import com.admin.service.NodeService;
-import com.admin.common.utils.GostUtil;
-import com.admin.entity.Forward;
-import com.admin.entity.Tunnel;
-import com.admin.entity.Node;
-import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
-import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import org.springframework.beans.BeanUtils;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.annotation.Lazy;
-import org.springframework.stereotype.Service;
-
-import javax.annotation.Resource;
-import java.util.List;
-import java.util.Map;
-
-/**
- * <p>
- * 用户隧道权限服务实现类
- * 提供用户隧道权限的分配、查询、更新和删除功能
- * 支持流量限制、数量限制、过期时间和限速规则的管理
- * </p>
- *
- * @author QAQ
- * @since 2025-06-03
- */
-@Service
-public class UserTunnelServiceImpl extends ServiceImpl<UserTunnelMapper, UserTunnel> implements UserTunnelService {
-
-
-    @Resource
-    @Lazy
-    private ForwardService forwardService;
-
-    @Override
-    public R assignUserTunnel(UserTunnelDto userTunnelDto) {
-        int count = this.count(new QueryWrapper<UserTunnel>().eq("user_id", userTunnelDto.getUserId()).eq("tunnel_id", userTunnelDto.getTunnelId()));
-        if (count > 0) return R.err("该用户已拥有此隧道权限");
-        UserTunnel userTunnel = new UserTunnel();
-        BeanUtils.copyProperties(userTunnelDto, userTunnel);
-        userTunnel.setStatus(1);
-        this.save(userTunnel);
-        return R.ok();
-    }
-
-    @Override
-    public R getUserTunnelList(UserTunnelQueryDto queryDto) {
-        List<UserTunnelWithDetailDto> userTunnelWithDetails = this.baseMapper.getUserTunnelWithDetails(queryDto.getUserId());
-        return R.ok(userTunnelWithDetails);
-    }
-
-    @Override
-    public R removeUserTunnel(Integer id) {
-        UserTunnel userTunnel = this.getById(id);
-        if (userTunnel == null) return R.err("未找到对应的用户隧道权限记录");
-
-        List<Forward> forwardList = forwardService.list(new QueryWrapper<Forward>().eq("user_id", userTunnel.getUserId()).eq("tunnel_id", userTunnel.getTunnelId()));
-        for (Forward forward : forwardList) {
-            forwardService.deleteForward(forward.getId());
-        }
-        this.removeById(id);
-        return R.ok();
-    }
-
-    @Override
-    public R updateUserTunnel(UserTunnelUpdateDto updateDto) {
-        UserTunnel userTunnel = this.getById(updateDto.getId());
-        if (userTunnel == null) return R.err("隧道不存在");
-        boolean speedChanged = hasSpeedChanged(userTunnel.getSpeedId(), updateDto.getSpeedId());
-        userTunnel.setFlow(updateDto.getFlow());
-        userTunnel.setNum(updateDto.getNum());
-        updateOptionalProperty(userTunnel::setFlowResetTime, updateDto.getFlowResetTime());
-        updateOptionalProperty(userTunnel::setExpTime, updateDto.getExpTime());
-        updateOptionalProperty(userTunnel::setStatus, updateDto.getStatus());
-        userTunnel.setSpeedId(updateDto.getSpeedId());
-        this.updateById(userTunnel);
-        if (speedChanged) {
-            List<Forward> forwardList = forwardService.list(new QueryWrapper<Forward>().eq("user_id", userTunnel.getUserId()).eq("tunnel_id", userTunnel.getTunnelId()));
-            for (Forward forward : forwardList) {
-                ForwardUpdateDto forwardUpdateDto = new ForwardUpdateDto();
-                forwardUpdateDto.setId(forward.getId());
-                forwardUpdateDto.setUserId(forward.getUserId());
-                forwardUpdateDto.setName(forward.getName());
-                forwardUpdateDto.setRemoteAddr(forward.getRemoteAddr());
-                forwardUpdateDto.setStrategy(forward.getStrategy());
-                forwardService.updateForward(forwardUpdateDto);
-            }
-        }
-        return R.err("用户隧道权限更新失败");
-    }
-
-    private <T> void updateOptionalProperty(java.util.function.Consumer<T> setter, T value) {
-        if (value != null) {
-            setter.accept(value);
-        }
-    }
-
-    private boolean hasSpeedChanged(Integer oldSpeedId, Integer newSpeedId) {
-        if (oldSpeedId == null && newSpeedId == null) {
-            return false;
-        }
-        if (oldSpeedId == null || newSpeedId == null) {
-            return true;
-        }
-        return !oldSpeedId.equals(newSpeedId);
-    }
-
-}
+package com.admin.service.impl;
+
+import com.admin.common.dto.*;
+import com.admin.common.lang.R;
+import com.admin.entity.User;
+import com.admin.entity.UserTunnel;
+import com.admin.mapper.UserTunnelMapper;
+import com.admin.service.UserService;
+import com.admin.service.UserTunnelService;
+import com.admin.service.ForwardService;
+import com.admin.entity.Forward;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.beans.BeanUtils;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+@Service
+public class UserTunnelServiceImpl extends ServiceImpl<UserTunnelMapper, UserTunnel> implements UserTunnelService {
+
+    @Resource
+    @Lazy
+    private ForwardService forwardService;
+
+    @Resource
+    @Lazy
+    private UserService userService;
+
+    @Override
+    public R assignUserTunnel(UserTunnelDto userTunnelDto) {
+        int count = this.count(new QueryWrapper<UserTunnel>()
+                .eq("user_id", userTunnelDto.getUserId())
+                .eq("tunnel_id", userTunnelDto.getTunnelId()));
+        if (count > 0) return R.err("该用户已拥有此隧道权限");
+
+        User user = userService.getById(userTunnelDto.getUserId());
+        if (user == null) return R.err("用户不存在");
+
+        UserTunnel userTunnel = new UserTunnel();
+        userTunnel.setUserId(userTunnelDto.getUserId());
+        userTunnel.setTunnelId(userTunnelDto.getTunnelId());
+        userTunnel.setSpeedId(userTunnelDto.getSpeedId());
+        userTunnel.setStatus(1);
+        userTunnel.setInFlow(0L);
+        userTunnel.setOutFlow(0L);
+
+        userTunnel.setFlow(userTunnelDto.getFlow() != null ? userTunnelDto.getFlow() : user.getFlow());
+        userTunnel.setNum(userTunnelDto.getNum() != null ? userTunnelDto.getNum() : user.getNum());
+        userTunnel.setFlowResetTime(userTunnelDto.getFlowResetTime() != null ? userTunnelDto.getFlowResetTime() : user.getFlowResetTime());
+        userTunnel.setExpTime(userTunnelDto.getExpTime() != null ? userTunnelDto.getExpTime() : user.getExpTime());
+
+        this.save(userTunnel);
+        return R.ok();
+    }
+
+    @Override
+    public R batchAssignUserTunnel(UserTunnelBatchAssignDto batchAssignDto) {
+        User user = userService.getById(batchAssignDto.getUserId());
+        if (user == null) return R.err("用户不存在");
+
+        Map<Integer, UserTunnelBatchAssignDto.TunnelAssignItem> uniqueTunnels = new LinkedHashMap<>();
+        for (UserTunnelBatchAssignDto.TunnelAssignItem item : batchAssignDto.getTunnels()) {
+            uniqueTunnels.putIfAbsent(item.getTunnelId(), item);
+        }
+
+        Set<Integer> existingTunnelIds = this.list(
+                new QueryWrapper<UserTunnel>()
+                        .eq("user_id", batchAssignDto.getUserId())
+                        .in("tunnel_id", uniqueTunnels.keySet())
+        ).stream().map(UserTunnel::getTunnelId).collect(Collectors.toSet());
+
+        List<UserTunnel> toSave = new ArrayList<>();
+        List<Integer> skippedIds = new ArrayList<>();
+
+        for (UserTunnelBatchAssignDto.TunnelAssignItem item : uniqueTunnels.values()) {
+            if (existingTunnelIds.contains(item.getTunnelId())) {
+                skippedIds.add(item.getTunnelId());
+                continue;
+            }
+
+            UserTunnel ut = new UserTunnel();
+            ut.setUserId(batchAssignDto.getUserId());
+            ut.setTunnelId(item.getTunnelId());
+            ut.setSpeedId(item.getSpeedId());
+            ut.setStatus(1);
+            ut.setInFlow(0L);
+            ut.setOutFlow(0L);
+            ut.setFlow(user.getFlow());
+            ut.setNum(user.getNum());
+            ut.setFlowResetTime(user.getFlowResetTime());
+            ut.setExpTime(user.getExpTime());
+            toSave.add(ut);
+        }
+
+        if (toSave.isEmpty()) {
+            return R.err("所选隧道用户均已拥有权限");
+        }
+
+        this.saveBatch(toSave);
+
+        if (!skippedIds.isEmpty()) {
+            return R.ok("成功分配 " + toSave.size() + " 个隧道，跳过 " + skippedIds.size() + " 个已有权限的隧道");
+        }
+        return R.ok();
+    }
+
+    @Override
+    public R getUserTunnelList(UserTunnelQueryDto queryDto) {
+        List<UserTunnelWithDetailDto> userTunnelWithDetails = this.baseMapper.getUserTunnelWithDetails(queryDto.getUserId());
+        return R.ok(userTunnelWithDetails);
+    }
+
+    @Override
+    public R removeUserTunnel(Integer id) {
+        UserTunnel userTunnel = this.getById(id);
+        if (userTunnel == null) return R.err("未找到对应的用户隧道权限记录");
+
+        List<Forward> forwardList = forwardService.list(new QueryWrapper<Forward>()
+                .eq("user_id", userTunnel.getUserId())
+                .eq("tunnel_id", userTunnel.getTunnelId()));
+        for (Forward forward : forwardList) {
+            forwardService.deleteForward(forward.getId());
+        }
+        this.removeById(id);
+        return R.ok();
+    }
+
+    @Override
+    public R updateUserTunnel(UserTunnelUpdateDto updateDto) {
+        UserTunnel userTunnel = this.getById(updateDto.getId());
+        if (userTunnel == null) return R.err("隧道不存在");
+        boolean speedChanged = hasSpeedChanged(userTunnel.getSpeedId(), updateDto.getSpeedId());
+        userTunnel.setFlow(updateDto.getFlow());
+        userTunnel.setNum(updateDto.getNum());
+        updateOptionalProperty(userTunnel::setFlowResetTime, updateDto.getFlowResetTime());
+        updateOptionalProperty(userTunnel::setExpTime, updateDto.getExpTime());
+        updateOptionalProperty(userTunnel::setStatus, updateDto.getStatus());
+        userTunnel.setSpeedId(updateDto.getSpeedId());
+        this.updateById(userTunnel);
+        if (speedChanged) {
+            List<Forward> forwardList = forwardService.list(new QueryWrapper<Forward>()
+                    .eq("user_id", userTunnel.getUserId())
+                    .eq("tunnel_id", userTunnel.getTunnelId()));
+            for (Forward forward : forwardList) {
+                ForwardUpdateDto forwardUpdateDto = new ForwardUpdateDto();
+                forwardUpdateDto.setId(forward.getId());
+                forwardUpdateDto.setUserId(forward.getUserId());
+                forwardUpdateDto.setName(forward.getName());
+                forwardUpdateDto.setRemoteAddr(forward.getRemoteAddr());
+                forwardUpdateDto.setStrategy(forward.getStrategy());
+                forwardService.updateForward(forwardUpdateDto);
+            }
+        }
+        return R.ok();
+    }
+
+    private <T> void updateOptionalProperty(java.util.function.Consumer<T> setter, T value) {
+        if (value != null) {
+            setter.accept(value);
+        }
+    }
+
+    private boolean hasSpeedChanged(Integer oldSpeedId, Integer newSpeedId) {
+        if (oldSpeedId == null && newSpeedId == null) {
+            return false;
+        }
+        if (oldSpeedId == null || newSpeedId == null) {
+            return true;
+        }
+        return !oldSpeedId.equals(newSpeedId);
+    }
+
+}

vite-frontend/src/api/index.ts

@@ -46,6 +46,8 @@ export const updateTunnelOrder = (data: { tunnels: Array<{ id: number; inx: numb
 
 // 用户隧道权限管理操作 - 全部使用POST请求
 export const assignUserTunnel = (data: any) => Network.post("/tunnel/user/assign", data);
+export const batchAssignUserTunnel = (data: { userId: number; tunnels: Array<{ tunnelId: number; speedId?: number | null }> }) => 
+  Network.post("/tunnel/user/batch-assign", data);
 export const getUserTunnelList = (queryData: any = {}) => Network.post("/tunnel/user/list", queryData);
 export const removeUserTunnel = (params: any) => Network.post("/tunnel/user/remove", params);
 export const updateUserTunnel = (data: any) => Network.post("/tunnel/user/update", data);

vite-frontend/src/pages/user.tsx

@@ -30,7 +30,7 @@ import {
   User, 
   UserForm, 
   UserTunnel, 
-  UserTunnelForm, 
+  TunnelAssignItem,
   Tunnel, 
   SpeedLimit, 
   Pagination as PaginationType 
@@ -41,7 +41,7 @@ import {
   updateUser,
   deleteUser,
   getTunnelList,
-  assignUserTunnel,
+  batchAssignUserTunnel,
   getUserTunnelList,
   removeUserTunnel,
   updateUserTunnel,
@@ -134,15 +134,8 @@ export default function UserPage() {
   const [tunnelListLoading, setTunnelListLoading] = useState(false);  
   
   // 分配新隧道权限相关状态
-  const [tunnelForm, setTunnelForm] = useState<UserTunnelForm>({
-    tunnelId: null,
-    flow: 100,
-    num: 10,
-    expTime: null,
-    flowResetTime: 0,
-    speedId: null
-  });
   const [assignLoading, setAssignLoading] = useState(false);
+  const [batchTunnelSelections, setBatchTunnelSelections] = useState<Map<number, number | null>>(new Map());
 
   // 编辑隧道权限相关状态
   const { isOpen: isEditTunnelModalOpen, onOpen: onEditTunnelModalOpen, onClose: onEditTunnelModalClose } = useDisclosure();
@@ -334,46 +327,31 @@ export default function UserPage() {
   // 隧道权限管理操作
   const handleManageTunnels = (user: User) => {
     setCurrentUser(user);
-    setTunnelForm({
-      tunnelId: null,
-      flow: 100,
-      num: 10,
-      expTime: null,
-      flowResetTime: 0,
-      speedId: null
-    });
+    setBatchTunnelSelections(new Map());
     onTunnelModalOpen();
     loadUserTunnels(user.id);
   };
 
-  const handleAssignTunnel = async () => {
-    if (!tunnelForm.tunnelId || !tunnelForm.expTime || !currentUser) {
-      toast.error('请填写完整信息');
+  const handleBatchAssignTunnel = async () => {
+    if (batchTunnelSelections.size === 0 || !currentUser) {
+      toast.error('请选择至少一个隧道');
       return;
     }
 
     setAssignLoading(true);
     try {
-      const response = await assignUserTunnel({
+      const tunnelsToAssign: TunnelAssignItem[] = Array.from(batchTunnelSelections.entries()).map(
+        ([tunnelId, speedId]) => ({ tunnelId, speedId })
+      );
+      
+      const response = await batchAssignUserTunnel({
         userId: currentUser.id,
-        tunnelId: tunnelForm.tunnelId,
-        flow: tunnelForm.flow,
-        num: tunnelForm.num,
-        expTime: tunnelForm.expTime.getTime(),
-        flowResetTime: tunnelForm.flowResetTime,
-        speedId: tunnelForm.speedId
+        tunnels: tunnelsToAssign
       });
 
       if (response.code === 0) {
-        toast.success('分配成功');
-        setTunnelForm({
-          tunnelId: null,
-          flow: 100,
-          num: 10,
-          expTime: null,
-          flowResetTime: 0,
-          speedId: null
-        });
+        toast.success(response.msg || '分配成功');
+        setBatchTunnelSelections(new Map());
         loadUserTunnels(currentUser.id);
       } else {
         toast.error(response.msg || '分配失败');
@@ -513,19 +491,38 @@ export default function UserPage() {
     }
   };
 
-  // 过滤数据
-  const availableTunnels = tunnels.filter(
-    tunnel => !userTunnels.some(ut => ut.tunnelId === tunnel.id)
-  );
-
-  const availableSpeedLimits = speedLimits.filter(
-    speedLimit => speedLimit.tunnelId === tunnelForm.tunnelId
-  );
-
   const editAvailableSpeedLimits = speedLimits.filter(
     speedLimit => speedLimit.tunnelId === editTunnelForm?.tunnelId
   );
 
+  const getSpeedLimitsForTunnel = (tunnelId: number) => {
+    return speedLimits.filter(sl => sl.tunnelId === tunnelId);
+  };
+
+  const toggleTunnelSelection = (tunnelId: number) => {
+    setBatchTunnelSelections(prev => {
+      const newMap = new Map(prev);
+      if (newMap.has(tunnelId)) {
+        newMap.delete(tunnelId);
+      } else {
+        newMap.set(tunnelId, null);
+      }
+      return newMap;
+    });
+  };
+
+  const updateTunnelSpeedLimit = (tunnelId: number, speedId: number | null) => {
+    setBatchTunnelSelections(prev => {
+      const newMap = new Map(prev);
+      newMap.set(tunnelId, speedId);
+      return newMap;
+    });
+  };
+
+  const isTunnelAssigned = (tunnelId: number) => {
+    return userTunnels.some(ut => ut.tunnelId === tunnelId);
+  };
+
   return (
     
       <div className="px-3 lg:px-6 py-8">
@@ -878,107 +875,73 @@ export default function UserPage() {
               <div>
                 <h3 className="text-lg font-semibold mb-4">分配新权限</h3>
                 <div className="space-y-4">
-                  <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
-                    <Select
-                      label="选择隧道"
-                      selectedKeys={tunnelForm.tunnelId ? [tunnelForm.tunnelId.toString()] : []}
-                      onSelectionChange={(keys) => {
-                        const value = Array.from(keys)[0] as string;
-                        setTunnelForm(prev => ({ ...prev, tunnelId: Number(value) || null, speedId: null }));
-                      }}
-                    >
-                      {availableTunnels.map(tunnel => (
-                        <SelectItem key={tunnel.id.toString()} textValue={tunnel.name}>
-                          {tunnel.name}
-                        </SelectItem>
-                      ))}
-                    </Select>
-                    
-                    <Select
-                      label="限速规则"
-                      selectedKeys={tunnelForm.speedId ? [tunnelForm.speedId.toString()] : ["null"]}
-                      onSelectionChange={(keys) => {
-                        const value = Array.from(keys)[0] as string;
-                        setTunnelForm(prev => ({ ...prev, speedId: value === "null" ? null : Number(value) }));
-                      }}
-                      isDisabled={!tunnelForm.tunnelId}
-                    >
-                      {[
-                        <SelectItem key="null" textValue="不限速">不限速</SelectItem>,
-                        ...availableSpeedLimits.map(speedLimit => (
-                          <SelectItem key={speedLimit.id.toString()} textValue={speedLimit.name}>
-                            {speedLimit.name}
-                          </SelectItem>
-                        ))
-                      ]}
-                    </Select>
-                    
-                    <Input
-                      label="流量限制(GB)"
-                      type="number"
-                      value={tunnelForm.flow.toString()}
-                      onChange={(e) => {
-                        const value = Math.min(Math.max(Number(e.target.value) || 0, 1), 99999);
-                        setTunnelForm(prev => ({ ...prev, flow: value }));
-                      }}
-                      min="1"
-                      max="99999"
-                    />
-                    
-                    <Input
-                      label="转发数量"
-                      type="number"
-                      value={tunnelForm.num.toString()}
-                      onChange={(e) => {
-                        const value = Math.min(Math.max(Number(e.target.value) || 0, 1), 99999);
-                        setTunnelForm(prev => ({ ...prev, num: value }));
-                      }}
-                      min="1"
-                      max="99999"
-                    />
-                    
-                    <Select
-                      label="流量重置日期"
-                      selectedKeys={[tunnelForm.flowResetTime.toString()]}
-                      onSelectionChange={(keys) => {
-                        const value = Array.from(keys)[0] as string;
-                        setTunnelForm(prev => ({ ...prev, flowResetTime: Number(value) }));
-                      }}
-                    >
-                      <>
-                        <SelectItem key="0" textValue="不重置">
-                          不重置
-                        </SelectItem>
-                      {Array.from({ length: 31 }, (_, i) => i + 1).map(day => (
-                        <SelectItem key={day.toString()} textValue={`每月${day}号（0点重置）`}>
-                          每月{day}号（0点重置）
-                        </SelectItem>
-                      ))}
-                      </>
-                    </Select>
-                    
-                    <DatePicker
-                      label="到期时间"
-                      value={tunnelForm.expTime ? parseDate(tunnelForm.expTime.toISOString().split('T')[0]) as any : null}
-                      onChange={(date) => {
-                        if (date) {
-                          const jsDate = new Date(date.year, date.month - 1, date.day, 23, 59, 59);
-                          setTunnelForm(prev => ({ ...prev, expTime: jsDate }));
-                        } else {
-                          setTunnelForm(prev => ({ ...prev, expTime: null }));
-                        }
-                      }}
-                      showMonthAndYearPickers
-                      className="cursor-pointer"
-                    />
+                  <div className="text-sm text-gray-500 bg-gray-50 dark:bg-gray-800 p-3 rounded-lg">
+                    流量限制、转发数量、到期时间、流量重置时间将自动继承用户设置
+                  </div>
+                  
+                  <div className="border rounded-lg divide-y dark:divide-gray-700 max-h-64 overflow-y-auto">
+                    {tunnels.map(tunnel => {
+                      const isAssigned = isTunnelAssigned(tunnel.id);
+                      const isSelected = batchTunnelSelections.has(tunnel.id);
+                      const tunnelSpeedLimits = getSpeedLimitsForTunnel(tunnel.id);
+                      
+                      return (
+                        <div 
+                          key={tunnel.id} 
+                          className={`p-3 flex items-center justify-between gap-4 ${isAssigned ? 'bg-gray-100 dark:bg-gray-800' : ''}`}
+                        >
+                          <div className="flex items-center gap-3 flex-1">
+                            <input
+                              type="checkbox"
+                              checked={isSelected}
+                              disabled={isAssigned}
+                              onChange={() => toggleTunnelSelection(tunnel.id)}
+                              className="w-4 h-4 rounded border-gray-300 text-primary focus:ring-primary disabled:opacity-50"
+                            />
+                            <span className={isAssigned ? 'text-gray-400' : ''}>
+                              {tunnel.name}
+                            </span>
+                            {isAssigned && (
+                              <Chip size="sm" variant="flat" color="default">已分配</Chip>
+                            )}
+                          </div>
+                          
+                          {isSelected && !isAssigned && (
+                            <Select
+                              size="sm"
+                              label="限速规则"
+                              className="w-40"
+                              selectedKeys={batchTunnelSelections.get(tunnel.id) !== null && batchTunnelSelections.get(tunnel.id) !== undefined ? [batchTunnelSelections.get(tunnel.id)!.toString()] : ["null"]}
+                              onSelectionChange={(keys) => {
+                                const value = Array.from(keys)[0] as string;
+                                updateTunnelSpeedLimit(tunnel.id, value === "null" ? null : Number(value));
+                              }}
+                            >
+                              {[
+                                <SelectItem key="null" textValue="不限速">不限速</SelectItem>,
+                                ...tunnelSpeedLimits.map(sl => (
+                                  <SelectItem key={sl.id.toString()} textValue={sl.name}>
+                                    {sl.name}
+                                  </SelectItem>
+                                ))
+                              ]}
+                            </Select>
+                          )}
+                        </div>
+                      );
+                    })}
+                    {tunnels.length === 0 && (
+                      <div className="p-4 text-center text-gray-500">暂无可用隧道</div>
+                    )}
                   </div>
                   
                   <Button
                     color="primary"
-                    onPress={handleAssignTunnel}
+                    onPress={handleBatchAssignTunnel}
                     isLoading={assignLoading}
+                    isDisabled={batchTunnelSelections.size === 0}
                   >
-                    分配权限
+                    分配权限 {batchTunnelSelections.size > 0 && `(${batchTunnelSelections.size}个隧道)`}
                   </Button>
                 </div>
               </div>

vite-frontend/src/types/index.ts

@@ -58,6 +58,15 @@ export interface UserTunnelForm {
   speedId: number | null;
 }
 
+export interface TunnelAssignItem {
+  tunnelId: number;
+  speedId: number | null;
+}
+
+export interface UserTunnelBatchAssignForm {
+  tunnels: TunnelAssignItem[];
+}
+
 export interface Tunnel {
   id: number;
   name: string;