Function bodies 165 total

public class User implements UserDetails {

    @TableId(type = IdType.AUTO)
    private Long id;

    @TableField(value = "username", exist = true)
    private String username;

    @TableField(value = "password", exist = true)
    private String password;

    @TableField(value = "email", exist = true)
    private String email;

    @TableField(value = "phone", exist = true)
    private String phone;

    @TableField(value = "nickname", exist = true)
    private String nickname;

    @TableField(value = "avatar", exist = true)
    private String avatar;

    @TableField(value = "status", exist = true)
    private Integer status = 1;

    @TableField(value = "created_at", fill = FieldFill.INSERT)
    private LocalDateTime createdAt;

    @TableField(value = "updated_at", fill = FieldFill.INSERT_UPDATE)
    private LocalDateTime updatedAt;

    @TableField(value = "deleted", exist = true)
    private Integer deleted = 0;

    @TableField(exist = false)
    private List<Role> roles = ne

    public Collection<? extends GrantedAuthority> getAuthorities() {
        return roles.stream()
                .flatMap(role -> role.getPermissions().stream())
                .map(permission -> new SimpleGrantedAuthority(permission.getCode()))
                .collect(Collectors.toList());
    }

    public boolean isAccountNonExpired() {
        return true;
    }

    public boolean isAccountNonLocked() {
        return status == 1;
    }

    public boolean isCredentialsNonExpired() {
        return true;
    }

    public boolean isEnabled() {
        return status == 1 && deleted == 0;
    }

public class SaleSystemApplication {
    public static void main(String[] args) {
        SpringApplication.run(SaleSystemApplication.class, args);
    }
}

    public static void main(String[] args) {
        SpringApplication.run(SaleSystemApplication.class, args);
    }

public class JwtAuthenticationFilter extends OncePerRequestFilter {

    @Autowired
    private JwtUtil jwtUtil;

    @Autowired
    private AuthService authService;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,
                                    FilterChain filterChain) throws ServletException, IOException {
        try {
            String jwt = parseJwt(request);
            if (StringUtils.hasText(jwt) && jwtUtil.validateToken(jwt, authService.loadUserByUsername(jwtUtil.extractUsername(jwt)))) {
                UserDetails userDetails = authService.loadUserByUsername(jwtUtil.extractUsername(jwt));
                UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(
                        userDetails, null, userDetails.getAuthorities());
                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.ge

    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,
                                    FilterChain filterChain) throws ServletException, IOException {
        try {
            String jwt = parseJwt(request);
            if (StringUtils.hasText(jwt) && jwtUtil.validateToken(jwt, authService.loadUserByUsername(jwtUtil.extractUsername(jwt)))) {
                UserDetails userDetails = authService.loadUserByUsername(jwtUtil.extractUsername(jwt));
                UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(
                        userDetails, null, userDetails.getAuthorities());
                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
        } catch (Exception e) {
            logger.error("Cannot set user authentication: {}", e);
        }

        fil

    private String parseJwt(HttpServletRequest request) {
        String headerAuth = request.getHeader("Authorization");

        if (StringUtils.hasText(headerAuth) && headerAuth.startsWith("Bearer ")) {
            return headerAuth.substring(7);
        }

        return null;
    }

public class AuthService implements UserDetailsService {

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private PasswordEncoder passwordEncoder;

    @Autowired
    private AuthenticationManager authenticationManager;

    @Autowired
    private JwtUtil jwtUtil;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userMapper.findByUsername(username);
        if (user == null) {
            throw new UsernameNotFoundException("用户不存在：" + username);
        }
        if (user.getDeleted() == 1) {
            throw new UsernameNotFoundException("用户已被删除：" + username);
        }

        // Load roles and permissions for user
        loadUserRolesAndPermissions(user);

        return user;
    }

    private void loadUserRolesAndPermissions(User user) {
        List<Long> roleIds = userMapper.findRoleIdsByUserId(user.getId());
        if (roleIds != null && !roleIds.isEmpty()) {
            Li

    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userMapper.findByUsername(username);
        if (user == null) {
            throw new UsernameNotFoundException("用户不存在：" + username);
        }
        if (user.getDeleted() == 1) {
            throw new UsernameNotFoundException("用户已被删除：" + username);
        }

        // Load roles and permissions for user
        loadUserRolesAndPermissions(user);

        return user;
    }

    private void loadUserRolesAndPermissions(User user) {
        List<Long> roleIds = userMapper.findRoleIdsByUserId(user.getId());
        if (roleIds != null && !roleIds.isEmpty()) {
            List<Role> roles = userMapper.findRolesByRoleIds(roleIds);
            List<Long> permissionIds = new ArrayList<>();

            for (Role role : roles) {
                List<Long> rolePermissionIds = userMapper.findPermissionIdsByRoleIds(List.of(role.getId()));
                if (rolePermissionIds != null) {
                    permissionIds.addAll(rolePermissionIds);
                }
            }

            if (!permissionIds.isEmpty()) {
                List<Permission> permissions = userMapper.findPermissionsByPermissionIds(permissionIds);
                // Remove duplicates by code
                permissions = permissions.stream()
                        .distinct()
                        .collect(Collectors.toList());
                for (Role role : roles) {
                

    public LoginResponse login(LoginRequest request) {
        try {
            authenticationManager.authenticate(
                    new UsernamePasswordAuthenticationToken(request.getUsername(), request.getPassword())
            );
        } catch (DisabledException e) {
            throw new BadCredentialsException("用户已被禁用");
        } catch (BadCredentialsException e) {
            throw new BadCredentialsException("用户名或密码错误");
        }

        UserDetails userDetails = loadUserByUsername(request.getUsername());
        User user = (User) userDetails;
        String token = jwtUtil.generateToken(userDetails);

        List<String> roles = user.getRoles().stream()
                .map(role -> role.getCode())
                .collect(Collectors.toList());

        List<String> permissions = user.getAuthorities().stream()
                .map(authority -> authority.getAuthority())
                .collect(Collectors.toList());

        return LoginResponse.builder()
            

    public User register(User user, String rawPassword) {
        if (userMapper.existsByUsername(user.getUsername())) {
            throw new RuntimeException("用户名已存在");
        }
        user.setPassword(passwordEncoder.encode(rawPassword));
        user.setStatus(1);
        user.setDeleted(0);
        userMapper.insert(user);
        return user;
    }

public class FishService {

    @Autowired
    private FishMapper fishMapper;

    public List<Fish> findAll() {
        return fishMapper.selectList(null);
    }

    public Page<Fish> findPage(int page, int size, String name) {
        Page<Fish> pageParam = new Page<>(page, size);
        if (StringUtils.hasText(name)) {
            // 使用 QueryWrapper 进行模糊查询
            com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<Fish> wrapper =
                new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<>();
            wrapper.like("name", name);
            return fishMapper.selectPage(pageParam, wrapper);
        }
        return fishMapper.selectPage(pageParam, null);
    }

    public Fish findById(Long id) {
        return fishMapper.selectById(id);
    }

    public Fish save(Fish fish) {
        if (fish.getId() == null) {
            fishMapper.insert(fish);
        } else {
            fishMapper.updateById(fish);
        }
        return fish;
    }

 

    public List<Fish> findAll() {
        return fishMapper.selectList(null);
    }

    public Page<Fish> findPage(int page, int size, String name) {
        Page<Fish> pageParam = new Page<>(page, size);
        if (StringUtils.hasText(name)) {
            // 使用 QueryWrapper 进行模糊查询
            com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<Fish> wrapper =
                new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<>();
            wrapper.like("name", name);
            return fishMapper.selectPage(pageParam, wrapper);
        }
        return fishMapper.selectPage(pageParam, null);
    }

    public Fish findById(Long id) {
        return fishMapper.selectById(id);
    }

    public Fish save(Fish fish) {
        if (fish.getId() == null) {
            fishMapper.insert(fish);
        } else {
            fishMapper.updateById(fish);
        }
        return fish;
    }

    public void deleteById(Long id) {
        fishMapper.deleteById(id);
    }

    public List<Fish> searchByName(String name) {
        return fishMapper.findByNameContaining(name);
    }

public class PermissionService {

    @Autowired
    private PermissionMapper permissionMapper;

    public List<Permission> findAll() {
        return permissionMapper.selectList(null);
    }

    public List<Permission> findMenuTree() {
        return permissionMapper.findByStatus(1);
    }

    public Permission findById(Long id) {
        return permissionMapper.selectById(id);
    }

    public List<Permission> findByParentId(Long parentId) {
        return permissionMapper.findByParentId(parentId);
    }

    public Permission save(Permission permission) {
        if (permission.getId() == null) {
            permissionMapper.insert(permission);
        } else {
            permissionMapper.updateById(permission);
        }
        return permission;
    }

    public void deleteById(Long id) {
        permissionMapper.deleteById(id);
    }
}

    public List<Permission> findAll() {
        return permissionMapper.selectList(null);
    }

    public List<Permission> findMenuTree() {
        return permissionMapper.findByStatus(1);
    }

    public Permission findById(Long id) {
        return permissionMapper.selectById(id);
    }

    public List<Permission> findByParentId(Long parentId) {
        return permissionMapper.findByParentId(parentId);
    }

    public Permission save(Permission permission) {
        if (permission.getId() == null) {
            permissionMapper.insert(permission);
        } else {
            permissionMapper.updateById(permission);
        }
        return permission;
    }

    public void deleteById(Long id) {
        permissionMapper.deleteById(id);
    }

public class RoleService {

    @Autowired
    private RoleMapper roleMapper;

    public List<Role> findAll() {
        return roleMapper.selectList(null);
    }

    public Role findById(Long id) {
        return roleMapper.selectById(id);
    }

    public Role findByName(String name) {
        return roleMapper.findByName(name);
    }

    @Transactional
    public Role save(Role role) {
        role.setUpdatedAt(LocalDateTime.now());
        if (role.getId() == null) {
            roleMapper.insert(role);
        } else {
            roleMapper.updateById(role);
        }
        return role;
    }

    @Transactional
    public void deleteById(Long id) {
        roleMapper.deleteById(id);
    }
}

    public List<Role> findAll() {
        return roleMapper.selectList(null);
    }

    public Role findById(Long id) {
        return roleMapper.selectById(id);
    }

    public Role findByName(String name) {
        return roleMapper.findByName(name);
    }

    public Role save(Role role) {
        role.setUpdatedAt(LocalDateTime.now());
        if (role.getId() == null) {
            roleMapper.insert(role);
        } else {
            roleMapper.updateById(role);
        }
        return role;
    }

    public void deleteById(Long id) {
        roleMapper.deleteById(id);
    }

public class SaleService {

    @Autowired
    private SaleRecordMapper saleRecordMapper;

    @Autowired
    private FishMapper fishMapper;

    public List<SaleRecord> findAll() {
        return saleRecordMapper.selectList(null);
    }

    public Page<SaleRecord> findPage(int page, int size, Long fishId, LocalDate startDate, LocalDate endDate) {
        Page<SaleRecord> pageParam = new Page<>(page, size);
        com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<SaleRecord> wrapper =
            new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<>();

        if (fishId != null) {
            wrapper.eq("fish_id", fishId);
        }
        if (startDate != null) {
            wrapper.ge("sale_date", startDate);
        }
        if (endDate != null) {
            wrapper.le("sale_date", endDate);
        }

        Page<SaleRecord> pageResult = saleRecordMapper.selectPage(pageParam, wrapper);
        // 关联鱼类信息
        List<SaleRecord> records = pageResult.get

    public List<SaleRecord> findAll() {
        return saleRecordMapper.selectList(null);
    }

    public Page<SaleRecord> findPage(int page, int size, Long fishId, LocalDate startDate, LocalDate endDate) {
        Page<SaleRecord> pageParam = new Page<>(page, size);
        com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<SaleRecord> wrapper =
            new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<>();

        if (fishId != null) {
            wrapper.eq("fish_id", fishId);
        }
        if (startDate != null) {
            wrapper.ge("sale_date", startDate);
        }
        if (endDate != null) {
            wrapper.le("sale_date", endDate);
        }

        Page<SaleRecord> pageResult = saleRecordMapper.selectPage(pageParam, wrapper);
        // 关联鱼类信息
        List<SaleRecord> records = pageResult.getRecords();
        if (!records.isEmpty()) {
            List<Long> fishIds = records.stream().map(SaleRecord::getFishId).distinct().collect(Collectors.toList());
            List<Fish> fishList = fishMapper.selectBatchIds(fishIds);
      

    public SaleRecord save(SaleRecord record) {
        if (record.getId() == null) {
            saleRecordMapper.insert(record);
        } else {
            saleRecordMapper.updateById(record);
        }
        return record;
    }

    public void deleteById(Long id) {
        saleRecordMapper.deleteById(id);
    }

    public Map<String, Object> getDailyStats(LocalDate date) {
        LocalDateTime startOfDay = date.atStartOfDay();
        LocalDateTime endOfDay = startOfDay.plusDays(1).minusSeconds(1);
        List<SaleRecord> records = saleRecordMapper.findBySaleDateTimeBetween(startOfDay, endOfDay);
        return calculateStats(records);
    }

    public Map<String, Object> getWeeklyStats(LocalDate date) {
        LocalDateTime startOfWeek = date.minusDays(date.getDayOfWeek().getValue() - 1).atStartOfDay();
        LocalDateTime endOfWeek = startOfWeek.plusDays(7).minusSeconds(1);
        List<SaleRecord> records = saleRecordMapper.findBySaleDateTimeBetween(startOfWeek, endOfWeek);
        Map<String, Object> stats = calculateStats(records);
        stats.put("startDate", startOfWeek.toLocalDate());
        stats.put("endDate", endOfWeek.toLocalDate());
        return stats;
    }

    public Map<String, Object> getMonthlyStats(LocalDate date) {
        LocalDateTime startOfMonth = date.withDayOfMonth(1).atStartOfDay();
        LocalDateTime endOfMonth = startOfMonth.plusMonths(1).minusSeconds(1);
        List<SaleRecord> records = saleRecordMapper.findBySaleDateTimeBetween(startOfMonth, endOfMonth);
        Map<String, Object> stats = calculateStats(records);
        stats.put("startDate", startOfMonth.toLocalDate());
        stats.put("endDate", endOfMonth.toLocalDate());
        return stats;
    }

    public Map<String, Object> getQuarterlyStats(LocalDate date) {
        int month = date.getMonthValue();
        int quarter = (month - 1) / 3;
        int startMonth = quarter * 3 + 1;
        LocalDateTime startOfQuarter = date.withMonth(startMonth).withDayOfMonth(1).atStartOfDay();
        LocalDateTime endOfQuarter = startOfQuarter.plusMonths(3).minusSeconds(1);
        List<SaleRecord> records = saleRecordMapper.findBySaleDateTimeBetween(startOfQuarter, endOfQuarter);
        Map<String, Object> stats = calculateStats(records);
        stats.put("startDate", startOfQuarter.toLocalDate());
        stats.put("endDate", endOfQuarter.toLocalDate());
        stats.put("quarter", quarter + 1);
        return stats;
    }

    public Map<String, Object> getYearlyStats(int year) {
        LocalDateTime startOfYear = LocalDateTime.of(year, 1, 1, 0, 0, 0);
        LocalDateTime endOfYear = LocalDateTime.of(year, 12, 31, 23, 59, 59);
        List<SaleRecord> records = saleRecordMapper.findBySaleDateTimeBetween(startOfYear, endOfYear);
        Map<String, Object> stats = calculateStats(records);
        stats.put("year", year);
        return stats;
    }

    private Map<String, Object> calculateStats(List<SaleRecord> records) {
        Map<String, Object> stats = new HashMap<>();
        stats.put("records", records);
        stats.put("totalRecords", records.size());

        BigDecimal totalQuantity = records.stream()
                .map(SaleRecord::getQuantity)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
        BigDecimal totalAmount = records.stream()
                .map(SaleRecord::getTotalPrice)
                .reduce(BigDecimal.ZERO, BigDecimal::add);

        stats.put("totalQuantity", totalQuantity);
        stats.put("totalAmount", totalAmount);

        return stats;
    }

public class UserService {

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private PasswordEncoder passwordEncoder;

    public List<User> findAll() {
        return userMapper.selectList(null);
    }

    public User findById(Long id) {
        return userMapper.selectById(id);
    }

    public User findByUsername(String username) {
        return userMapper.findByUsername(username);
    }

    @Transactional
    public User save(User user) {
        if (user.getId() == null) {
            userMapper.insert(user);
        } else {
            userMapper.updateById(user);
        }
        return user;
    }

    @Transactional
    public void deleteById(Long id) {
        userMapper.deleteById(id);
    }

    @Transactional
    public void updatePassword(Long userId, String newPassword) {
        User user = userMapper.selectById(userId);
        if (user == null) {
            throw new RuntimeException("用户不存在");
        }
        user.setPassword(passwordEnco

    public List<User> findAll() {
        return userMapper.selectList(null);
    }

    public User findById(Long id) {
        return userMapper.selectById(id);
    }