package com.happlay.ks.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2WebMvc;


@Configuration
@EnableSwagger2WebMvc
public class Knife4jConfig {
    @Bean
    public Docket api() {
        return new Docket(DocumentationType.SWAGGER_2) // 使用 OAS 3.0 文档类型
                .apiInfo(new ApiInfoBuilder()
                            .title("接口文档")
                            .description("KnowledgeSpace")
                            .version("1.0")
                            .build())
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.happlay.ks.controller")) // 与对应的Controller层一致
                .paths(PathSelectors.any())
                .build();
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.stereotype.Service;

@Service
public class EmailService {

    @Resource
    private JavaMailSender mailSender;

    public void sendVerificationCode(String fromEmail, String to, String subject, String text) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom(fromEmail);  // 直接设置完整的发件人邮箱地址
        message.setTo(to);
        message.setSubject(subject);
        message.setText(text);
        mailSender.send(message);
    }
}

import org.springframework.stereotype.Service;

import java.util.Random;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

@Service
public class VerificationService {

    private final ConcurrentHashMap<String, String> emailCodeMap = new ConcurrentHashMap<>();
    private final ConcurrentHashMap<String, Long> emailCodeTimeMap = new ConcurrentHashMap<>();

    @Autowired
    private EmailService emailService;

    public void sendVerificationEmail(String email) {
        String code = generateVerificationCode();
        emailCodeMap.put(email, code);
        emailCodeTimeMap.put(email, System.currentTimeMillis());

        String subject = "Your Verification Code";
        String text = "Your verification code is: " + code;
        emailService.sendVerificationCode(email, subject, text);
    }

    public boolean verifyCode(String email, String code) {
        if (!emailCodeMap.containsKey(email)) {
            return false;
        }
        long currentTime = System.currentTimeMillis();
        long sentTime = emailCodeTimeMap.get(email);
        if (currentTime - sentTime > TimeUnit.MINUTES.toMillis(5)) {
            emailCodeMap.remove(email);
            emailCodeTimeMap.remove(email);
            return false;
        }
        return emailCodeMap.get(email).equals(code);
    }

    private String generateVerificationCode() {
        Random random = new Random();
        int code = random.nextInt(999999);
        return String.format("%06d", code);
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api")
public class VerificationController {

    @Autowired
    private VerificationService verificationService;

    @PostMapping("/sendVerificationEmail")
    public void sendVerificationEmail(@RequestParam String email) {
        verificationService.sendVerificationEmail(email);
    }

    @PostMapping("/verifyCode")
    public boolean verifyCode(@RequestParam String email, @RequestParam String code) {
        return verificationService.verifyCode(email, code);
    }
}

@Aspect
@Component
@Slf4j
public class RoleInterceptor {
    @Resource
    private UserService userService;

    @Around("@annotation(loginCheck)")
    public Object doInterceptor(ProceedingJoinPoint joinPoint, LoginCheck loginCheck) throws Throwable {
        // 获取必须的权限数组,有其中之一即可继续执行
        String[] mustRole = loginCheck.mustRole();
        System.out.println(Arrays.deepToString(mustRole));
        // 获取当前请求的上下文
        RequestAttributes requestAttributes = RequestContextHolder.currentRequestAttributes( );
        HttpServletRequest request = ((ServletRequestAttributes) requestAttributes).getRequest( );
        // 获取请求头中的token
        String token = request.getHeader("token");
        // token为空
        if(StringUtils.isBlank(token)){
            throw new CommonException(ErrorCode.NOT_LOGIN_ERROR);
        }
        // 解析token
        Integer userId = JwtUtils.getUserIdFromToken(token);
        // 获取当前登录的用户
        User userById = userService.getById(userId);
        if(userById == null){
            throw new CommonException(ErrorCode.NOT_LOGIN_ERROR);
        }
        // 仅登录
        if(mustRole.length == 0) return joinPoint.proceed();
        // 需要的权限放入set
        HashSet<String> set = new HashSet<>(Arrays.asList(mustRole));
        // 遍历当前具有的权限,当前具有的权限在set中说明可以通过
        for (String role : userById.getRole()) {
            if(set.contains(role)) return joinPoint.proceed();
        }
        throw new CommonException(ErrorCode.NO_AUTH_ERROR, "无权限");
    }
}

@Configuration
@MapperScan("com.ynn.rent.mapper")
public class MybatisPlusConfig {

@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
    MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
    interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
    return interceptor;
}

@Configuration
@MapperScan("com.ynn.rent.mapper")
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
public class PageRequest {
    /**
     * 当前页数
     */
    private long current;

    /**
     * 每页数据数量
     */
    private long pageSize;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
public class UserVo {
    /**
     * 主键
     */
    private Integer id;

    /**
     * 用户名
     */
    private String username;

    /**
     * 职务
     */
    private String role;

    /**
     * 头像
     */
    private String avatarUrl;

    /**
     * 创建时间
     */
    private LocalDateTime createTime;

    /**
     * 更新时间
     */
    private LocalDateTime updateTime;

    /**
     * 是否激活
     */
    private Boolean isDelete;
}

@Override
    public UserVo getVo(User user) {
        if (user == null) throw new CommonException(ErrorCode.NOT_FOUND_ERROR);
        UserVo userVo = new UserVo();
        BeanUtil.copyProperties(user, userVo);
        return userVo;
    }

    @Override
    public List<UserVo> getVos(List<User> users) {
        ArrayList<UserVo> userVos = new ArrayList<>();
        for (User user : users) {
            userVos.add(getVo(user));
        }
        return userVos;
    }

    @Override
    public Page<UserVo> selectPage(PageRequest pageRequest) {
        Page<User> userPage = new Page<>(pageRequest.getCurrent(), pageRequest.getPageSize());
        this.page(userPage);
        Page<UserVo> userVoPage = new Page<>(userPage.getCurrent(), userPage.getSize(), userPage.getTotal());
        userVoPage.setRecords(this.getVos(userPage.getRecords()));
        return userVoPage;
    }

public enum FileTypeEnum {
    AVATAR("avatar"),  // 头像文件
    FILE("file");  // 文档文件，例如包含文字的文件

    private final String type;

    FileTypeEnum(String type) {
        this.type = type;
    }

    public String getType() {
        return type;
    }
}

@Data
@Component
@ConfigurationProperties(prefix = "file")
public class FileConfig {
    private long maxMb;
    private String avatarPath; // 设置头像路径
    private String filePath;   // 设置笔记文件路径
}

@Component
public class FileUtils {

    @Autowired
    private FileConfig fileConfig;

    private final ResourceLoader resourceLoader;

    @Autowired
    public FileUtils(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
    }

    public String storeTemp(byte[] data, FileTypeEnum fileTypeEnum, int id) {
        if (data == null) {
            throw new CommonException(ErrorCode.NOT_FOUND_ERROR, "不存在临时文件");
        }

        String folderPath = getFolderPath(fileTypeEnum, id);
        File folder = new File(folderPath);
        if (!folder.isDirectory()) {
            if (!folder.mkdirs()) {
                throw new CommonException(ErrorCode.SYSTEM_ERROR, "创建文件夹失败");
            }
        }

        String fileName = UUID.randomUUID().toString();
        File file = new File(folderPath, fileName);
        try (FileOutputStream fileOutputStream = new FileOutputStream(file)) {
            fileOutputStream.write(data);
        } catch (IOException e) {
            e.printStackTrace();
            throw new CommonException(ErrorCode.SYSTEM_ERROR, "创建文件失败");
        }
        return getRelativePath(fileTypeEnum, id, fileName);
    }

    public String saveFile(MultipartFile file, FileTypeEnum fileTypeEnum, int id) {
        if (file.isEmpty()) {
            throw new CommonException(ErrorCode.PARAMS_ERROR, "文件为空");
        }
        String originalFilename = file.getOriginalFilename();
        if (originalFilename == null) {
            throw new CommonException(ErrorCode.PARAMS_ERROR, "文件名为空");
        }

        String fileExtension = originalFilename.substring(originalFilename.lastIndexOf("."));
//        String folderPath = getFolderPath(fileTypeEnum, id);

        String folderPath = getFolderPath(fileTypeEnum, id);
        System.out.println("Folder path: " + folderPath);
        File folder = new File(folderPath);
        if (!folder.isDirectory()) {
            if (!folder.mkdirs()) {
                throw new CommonException(ErrorCode.SYSTEM_ERROR, "创建文件夹失败");
            }
        }

        String fileName = UUID.randomUUID().toString() + fileExtension;
        File destFile = new File(folderPath, fileName);
        try {
            file.transferTo(destFile);
        } catch (IOException e) {
            e.printStackTrace();
            throw new CommonException(ErrorCode.SYSTEM_ERROR, "保存文件失败");
        }
        return getRelativePath(fileTypeEnum, id, fileName);
    }

    private String getFolderPath(FileTypeEnum fileTypeEnum, int id) {
        String basePath;
        //获取jar包所在目录
        ApplicationHome h = new ApplicationHome(getClass());
        File jarF = h.getSource();
        //在jar包所在目录下生成一个upload文件夹用来存储上传的图片
        switch (fileTypeEnum) {
            case AVATAR:
                basePath = resolveResourcePath(jarF.getParentFile().toString(), fileConfig.getAvatarPath());
                break;
            case FILE:
                basePath = resolveResourcePath(jarF.getParentFile().toString(), fileConfig.getFilePath());
                break;
            default:
                throw new CommonException(ErrorCode.PARAMS_ERROR, "不支持的文件类型");
        }
        return Paths.get(basePath, String.valueOf(id)).toString();
    }

    private String getRelativePath(FileTypeEnum fileTypeEnum, int id, String fileName) {
        return Paths.get("/", fileTypeEnum.getType(), String.valueOf(id), fileName).toString();
    }

    private String resolveResourcePath(String basePath, String resourcePath) {
        try {
            Resource resource = resourceLoader.getResource("file:" + basePath + resourcePath);
            if (!resource.exists()) {
                throw new CommonException(ErrorCode.SYSTEM_ERROR, "资源路径不存在: " + resourcePath);
            }
            File file = resource.getFile();
            Path path = file.toPath();
            if (!Files.exists(path)) {
                Files.createDirectories(path);
            }
            return path.toString();
        } catch (IOException e) {
            throw new CommonException(ErrorCode.SYSTEM_ERROR, "解析资源路径失败: " + e.getMessage());
        }
    }

import com.happlay.ks.common.ErrorCode;
import com.happlay.ks.config.FileConfig;
import com.happlay.ks.emums.FileTypeEnum;
import com.happlay.ks.exception.CommonException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.io.ResourceLoader;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Paths;
import java.util.*;

@Component
public class FileUtils {

    @Autowired
    private FileConfig fileConfig;

    private final ResourceLoader resourceLoader;

    @Value("${file.storage.root.path}")
    private String storageRootPath;

    @Autowired
    public FileUtils(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
    }

    // 保存文件
    public String saveFile(MultipartFile file, FileTypeEnum fileTypeEnum, int id) {
        if (file.isEmpty()) {
            throw new CommonException(ErrorCode.PARAMS_ERROR, "文件为空");
        }
        String originalFilename = file.getOriginalFilename();
        if (originalFilename == null) {
            throw new CommonException(ErrorCode.PARAMS_ERROR, "文件名为空");
        }

        String fileExtension = originalFilename.substring(originalFilename.lastIndexOf("."));
        String folderPath = getFolderPath(fileTypeEnum, id);
        createDirectoryIfNotExists(folderPath);

        String fileName = UUID.randomUUID().toString() + fileExtension;
        File destFile = new File(folderPath, fileName);
        try {
            file.transferTo(destFile);
            System.out.println("文件保存成功，路径：" + destFile.getAbsolutePath());
        } catch (IOException e) {
            e.printStackTrace();
            throw new CommonException(ErrorCode.SYSTEM_ERROR, "保存文件失败");
        }
        return getRelativePath(fileTypeEnum, id, fileName);
    }

    public String saveMarkdownFile(String content, FileTypeEnum fileTypeEnum, int id) {
        String folderPath = getFolderPath(fileTypeEnum, id);
        createDirectoryIfNotExists(folderPath);

        String fileName = UUID.randomUUID().toString() + ".md";
        File file = new File(folderPath, fileName);
        try (FileOutputStream fileOutputStream = new FileOutputStream(file)) {
            fileOutputStream.write(content.getBytes(StandardCharsets.UTF_8));
            System.out.println("Markdown 文件保存成功，路径：" + file.getAbsolutePath());
        } catch (IOException e) {
            e.printStackTrace();
            throw new CommonException(ErrorCode.SYSTEM_ERROR, "保存文件失败");
        }
        return getRelativePath(fileTypeEnum, id, fileName);
    }

    public String saveImage(byte[] imageBytes, int id) {
        String folderPath = getFolderPath(FileTypeEnum.PHOTO, id);
        createDirectoryIfNotExists(folderPath);

        String fileName = UUID.randomUUID().toString() + ".png";
        File imageFile = new File(folderPath, fileName);
        try (FileOutputStream fos = new FileOutputStream(imageFile)) {
            fos.write(imageBytes);
            System.out.println("图片保存成功，路径：" + imageFile.getAbsolutePath());
        } catch (IOException e) {
            e.printStackTrace();
            throw new CommonException(ErrorCode.SYSTEM_ERROR, "保存图片失败");
        }
        return getRelativePath(FileTypeEnum.PHOTO, id, fileName);
    }

    private String getFolderPath(FileTypeEnum fileTypeEnum, int id) {
        String basePath = new File(storageRootPath).getAbsolutePath();
        switch (fileTypeEnum) {
            case AVATAR:
                return Paths.get(basePath, "avatar", String.valueOf(id)).toString();
            case PHOTO:
                return Paths.get(basePath, "document", "photo", String.valueOf(id)).toString();
            case DOCUMENT:
                return Paths.get(basePath, "document", String.valueOf(id)).toString();
            default:
                throw new CommonException(ErrorCode.PARAMS_ERROR, "不支持的文件类型");
        }
    }

    private String getRelativePath(FileTypeEnum fileTypeEnum, int id, String fileName) {
        return Paths.get(fileTypeEnum.getType(), String.valueOf(id), fileName).toString();
    }

    private void createDirectoryIfNotExists(String folderPath) {
        File folder = new File(folderPath);
        if (!folder.exists() && !folder.mkdirs()) {
            throw new CommonException(ErrorCode.SYSTEM_ERROR, "创建文件夹失败");
        }
    }
}

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.io.File;
import java.nio.charset.StandardCharsets;
import java.nio.file.Paths;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

@Component
public class FileImageUtils {

    @Value("${file.storage.root.path}")
    private String storageRootPath;

    // 替换MD里的图片
    public String replacePathsInMD(byte[] fileBytes, Map<String, String> imagePathMap) {
        String content = new String(fileBytes, StandardCharsets.UTF_8);
        String basePath = new File(storageRootPath).getAbsolutePath();
        System.out.println(basePath);

        for (Map.Entry<String, String> entry : imagePathMap.entrySet()) {
            String originalPath = entry.getKey();
            String serverPath = entry.getValue();
            String path = Paths.get(basePath, serverPath).normalize().toString();
            content = content.replace(originalPath, path);
        }

        return content;
    }

    // 提取MD文件中的图片路径
    public List<String> extractImagePathsFromMD(byte[] fileBytes) {
        String content = new String(fileBytes, StandardCharsets.UTF_8);
        List<String> imagePaths = new ArrayList<>();
        Pattern pattern = Pattern.compile("!\\[[^\\]]*\\]\\(([^)]+)\\)");
        Matcher matcher = pattern.matcher(content);
        while (matcher.find()) {
            imagePaths.add(matcher.group(1));
        }
        return imagePaths;
    }

    public byte[] readImage(String imagePath) throws IOException {
        if (imagePath.startsWith("http://") || imagePath.startsWith("https://")) {
            // 处理 URL 情况
            URL url = new URL(imagePath);
            try (InputStream in = url.openStream(); ByteArrayOutputStream buffer = new ByteArrayOutputStream()) {
                byte[] data = new byte[1024];
                int nRead;
                while ((nRead = in.read(data, 0, data.length)) != -1) {
                    buffer.write(data, 0, nRead);
                }
                return buffer.toByteArray();
            }
        } else {
            // 处理本地文件路径情况
            Path path = Paths.get(imagePath);
            return Files.readAllBytes(path);
        }
    }
}

public enum FileTypeEnum {
    AVATAR("avatar"),  // 头像文件
    PHOTO("document/photo"),  // 图片文件
    DOCUMENT("document");  // 文档文件
    private final String type;

    FileTypeEnum(String type) {
        this.type = type;
    }

    public String getType() {
        return type;
    }

    public static FileTypeEnum fromFileName(String fileName) {
        String extension = fileName.substring(fileName.lastIndexOf(".") + 1).toLowerCase();
        switch (extension) {
            case "jpg":
            case "jpeg":
            case "png":
            case "gif":
                return PHOTO;  // 图片文件类型
            case "md":
            case "pdf":
            case "doc":
            case "docx":
                return DOCUMENT;  // 文档文件类型
            default:
                throw new IllegalArgumentException("Unsupported file type: " + extension);
        }
    }
}

@Override
    public String uploadFile(UploadFileRequest uploadFileRequest, Integer userId) {
        MultipartFile file = uploadFileRequest.getFile();
        String originalFilename = file.getOriginalFilename();

        if (file.isEmpty()) {
            throw new CommonException(ErrorCode.PARAMS_ERROR, "文件内容不能为空");
        }

        if (originalFilename == null || originalFilename.isEmpty()) {
            throw new CommonException(ErrorCode.PARAMS_ERROR, "不支持该文件类型");
        }

        FileTypeEnum fileType = FileTypeEnum.fromFileName(originalFilename);

        if (fileType != FileTypeEnum.DOCUMENT) {
            throw new CommonException(ErrorCode.PARAMS_ERROR, "仅支持文档文件类型");
        }

        String name = uploadFileRequest.getName();
        Integer folderId = uploadFileRequest.getFolderId();

        if (name.isEmpty()) {
            throw new CommonException(ErrorCode.PARAMS_ERROR, "文件名不能为空");
        }

        LambdaQueryWrapper<File> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(File::getName, name);
        if (this.getOne(queryWrapper) != null) {
            throw new CommonException(ErrorCode.PARAMS_ERROR, "文件名不能重复");
        }

        String relativePath = null;
        try {
            if (originalFilename.endsWith(".md")) {
                byte[] fileBytes = file.getBytes();
                System.out.println("开始处理 Markdown 文件");
                // 提取图片路径
                List<String> imagePaths = fileImageUtils.extractImagePathsFromMD(fileBytes);
                System.out.println("提取的图片路径：" + imagePaths);

                // 保存文件记录到数据库
                File newFile = new File();
                newFile.setFolderId(folderId);
                newFile.setUserId(userId);
                newFile.setName(name);
                newFile.setFileType(fileType.getType());
                newFile.setCreateUser(userId);
                newFile.setUpdateUser(userId);
                this.save(newFile);

                // 获取文件ID
                Integer fileId = newFile.getId();

                // 保存图片路径到数据库并更新图片路径映射
                Map<String, String> imagePathMap = new HashMap<>();
                for (String imagePath : imagePaths) {
                    byte[] imageBytes = readImage(imagePath);
                    String serverPath = fileUtils.saveImage(imageBytes, fileId);
                    System.out.println("serverPath: " + serverPath);
                    iImagepathsService.saveImageDate(fileId, serverPath);
                    imagePathMap.put(imagePath, serverPath);
                }

                // 更新Markdown内容并保存
                System.out.println("fileBytes: " + fileBytes);
                System.out.println(imagePathMap);
                String updatedContent = fileImageUtils.replacePathsInMD(fileBytes, imagePathMap);
                System.out.println("updatedContent: " +updatedContent);
                relativePath = fileUtils.saveMarkdownFile(updatedContent, fileType, folderId);
                newFile.setPath(relativePath);
                this.updateById(newFile); // 更新文件路径
                System.out.println("Markdown 文件处理完成，路径：" + relativePath);
            } else {
                relativePath = fileUtils.saveFile(file, fileType, folderId);
                System.out.println("普通文件保存完成，路径：" + relativePath);

                // 保存文件记录到数据库
                File newFile = new File();
                newFile.setFolderId(folderId);
                newFile.setUserId(userId);
                newFile.setName(name);
                newFile.setPath(relativePath);
                newFile.setFileType(fileType.getType());
                newFile.setCreateUser(userId);
                newFile.setUpdateUser(userId);
                this.save(newFile);
                System.out.println("文件信息保存到数据库，路径：" + relativePath);
            }
        } catch (IOException e) {
            e.printStackTrace();
            throw new CommonException(ErrorCode.SYSTEM_ERROR, "处理文件失败");
        }

        return relativePath;
    }
}

package com.happlay.ks.config;

import com.happlay.ks.service.IUserService;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

@Component
public class UserCleanupTask {

    @Resource
    IUserService iUserService;

    // 定时清理
    @Scheduled(cron = "0 0 2 * * ?")
    public void cleanDeletedUsers() {
        iUserService.cleanDeletedUsers();
    }
}

void cleanDeletedUsers();
----------------------------------------
@Override
public void cleanDeletedUsers() {
    // 查找isDelete为1的用户
    LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
    queryWrapper.eq(User::getIsDelete, 1);
    this.remove(queryWrapper);

}