cicv_data_closed_loop/common/util/u_io.go

package util

import (
	"archive/zip"
	"fmt"
	"io"
	"io/fs"
	"os"
	"path/filepath"
	"sort"
	"strings"
)

// 压缩指定目录到ZIP文件，并排除一个指定的子目录
func ZipDir(src, dest, excludeDir string) error {
	zipf, err := os.Create(dest)
	if err != nil {
		return err
	}
	defer zipf.Close()

	archive := zip.NewWriter(zipf)
	defer archive.Close()

	filepath.Walk(src, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}

		header, err := zip.FileInfoHeader(info)
		if err != nil {
			return err
		}

		// 修正文件路径，使其相对于src
		header.Name, err = filepath.Rel(src, path)
		if err != nil {
			return err
		}

		// 如果路径包含要排除的目录，则跳过
		if strings.Contains(header.Name, excludeDir) {
			if info.IsDir() {
				return filepath.SkipDir // 如果是目录，则跳过整个目录
			}
			return nil // 如果是文件，则忽略该文件
		}

		if info.IsDir() {
			header.Name += "/"
		} else {
			header.Method = zip.Deflate
		}

		writer, err := archive.CreateHeader(header)
		if err != nil {
			return err
		}

		if !info.IsDir() {
			file, err := os.Open(path)
			if err != nil {
				return err
			}
			defer file.Close()
			_, err = io.Copy(writer, file)
			return err
		}
		return nil
	})

	return nil
}

func GetFileSize(filePath string) (int, error) {
	fileInfo, err := os.Stat(filePath)
	if err != nil {
		return 0, err
	}
	return int(fileInfo.Size()), nil
}

func CheckSoFilesInDirectory(dirPath string) (bool, []string) {
	hasSoFile := false
	soFilePaths := make([]string, 0)
	if _, err := os.Stat(dirPath); os.IsNotExist(err) {
		fmt.Println("Directory does not exist:", dirPath)
		return false, soFilePaths
	}

	err := filepath.Walk(dirPath, func(path string, info fs.FileInfo, err error) error {
		if err != nil {
			return err
		}

		if info.IsDir() {
			return nil
		}

		if filepath.Ext(path) == ".so" {
			hasSoFile = true
			soFilePaths = append(soFilePaths, path)
		}
		return nil
	})

	if err != nil {
		fmt.Println("Error walking the directory:", err)
		os.Exit(1)
	}

	return hasSoFile, soFilePaths
}

func GetFirstLevelSubdirectories(dirPath string) []string {
	dirEntries, _ := os.ReadDir(dirPath)
	subdirectories := make([]string, 0)
	for _, entry := range dirEntries {
		if entry.IsDir() {
			subdirectories = append(subdirectories, entry.Name())
		}
	}
	return subdirectories
}

func GetFileNameWithoutExtension(absPath string) string {
	file := filepath.Base(absPath)
	ext := filepath.Ext(file)
	return strings.TrimSuffix(file, ext)
}

func GetSoFilePaths(dir string) []string {
	var paths []string
	err := filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
		if err == nil && !info.IsDir() && filepath.Ext(path) == ".so" {
			absPath, _ := filepath.Abs(path)
			paths = append(paths, absPath)
		}
		return nil
	})
	if err != nil {
		fmt.Println("Error:", err)
		return nil
	}
	return paths
}

// CreateDir 创建目录
func CreateDir(directory string) {
	if _, err := os.Stat(directory); os.IsNotExist(err) {
		_ = os.MkdirAll(directory, os.ModePerm)
	}
}

// CreateParentDir 存在不创建，不存在则创建父目录
func CreateParentDir(filePath string) error {
	if err := os.MkdirAll(filepath.Dir(filePath), os.ModePerm); err != nil {
		return err
	}
	return nil
}

// RemoveDir 递归删除目录及其下的所有文件和子目录
func RemoveDir(dirPath string) error {
	// 打开目录
	dir, err := os.Open(dirPath)
	if err != nil {
		return err
	}
	defer dir.Close()
	// 读取目录下的文件和子目录
	fileInfos, err := dir.Readdir(-1)
	if err != nil {
		return err
	}
	// 遍历文件和子目录
	for _, fileInfo := range fileInfos {
		path := filepath.Join(dirPath, fileInfo.Name())

		if fileInfo.IsDir() {
			// 如果是子目录，递归调用removeDir删除子目录及其下的文件和子目录
			if err = RemoveDir(path); err != nil {
				return err
			}
		} else {
			// 如果是文件，直接删除文件
			if err = os.Remove(path); err != nil {
				return err
			}
		}
	}
	// 删除目录本身
	if err = os.Remove(dirPath); err != nil {
		return err
	}
	return nil
}

// RemoveSubFiles 递归删除目录及其下的所有文件和子目录
func RemoveSubFiles(dirPath string) error {
	// 打开目录
	dir, err := os.Open(dirPath)
	if err != nil {
		return err
	}
	defer dir.Close()
	// 读取目录下的文件和子目录
	fileInfos, err := dir.Readdir(-1)
	if err != nil {
		return err
	}
	// 遍历文件和子目录
	for _, fileInfo := range fileInfos {
		path := filepath.Join(dirPath, fileInfo.Name())

		if fileInfo.IsDir() {
			// 如果是子目录，递归调用removeDir删除子目录及其下的文件和子目录
			if err = RemoveDir(path); err != nil {
				return err
			}
		} else {
			// 如果是文件，直接删除文件
			if err = os.Remove(path); err != nil {
				return err
			}
		}
	}
	return nil
}

func WriteFile(sourceContent string, targetFilePath string) error {
	if err := CreateFile(targetFilePath); err != nil {
		return err
	}
	if err := os.WriteFile(targetFilePath, []byte(sourceContent), 0644); err != nil {
		return err
	}
	return nil
}

// CreateFile 存在则覆盖，不存在则创建文件
func CreateFile(filePath string) error {
	if err := CreateParentDir(filePath); err != nil {
		return err
	}
	// 创建文件，如果文件已存在则覆盖
	file, err := os.Create(filePath)
	if err != nil {
		return err
	}
	defer func(file *os.File) {
		err := file.Close()
		if err != nil {

		}
	}(file)
	return nil
}
func ReadFile(filePath string) (string, error) {
	// 1 打开文件
	file, err := os.Open(filePath)
	if err != nil {
		return "", err
	}
	defer file.Close()

	// 2 读取文件内容
	content, err := io.ReadAll(file)
	if err != nil {
		return "", err
	}
	return string(content), err
}

func ListAbsolutePathWithSuffixAndSort(dir string, suffix string) ([]string, error) {
	var result []string
	if !strings.HasSuffix(dir, "/") {
		dir = dir + "/"
	}
	files, err := os.ReadDir(dir)
	if err != nil {
		return nil, err
	}
	for _, file := range files {
		if strings.HasSuffix(file.Name(), suffix) {
			result = append(result, dir+file.Name())
		}
	}
	// 根据文件名进行升序排序
	sort.Slice(result, func(i, j int) bool {
		return filepath.Base(result[i]) < filepath.Base(result[j])
	})
	return result, nil
}

func DeleteFile(path string) error {
	// 检查文件是否存在
	if _, err := os.Stat(path); err == nil {
		// 文件存在，执行删除操作
		err = os.Remove(path)
		if err != nil {
			return err
		}
	}
	return nil
}

// WriteStringToFile 将字符串写入指定的文件路径
func WriteStringToFile(content string, filePath string) {
	// 方法一：使用os包
	file, err := os.Create(filePath)
	if err != nil {
		fmt.Println("创建文件失败:", err)
		return
	}
	defer file.Close()

	_, err = file.WriteString(content)
	if err != nil {
		fmt.Println("写入文件失败:", err)
		return
	}
	fmt.Println("字符串成功写入文件（os包）")
}