fileHelper.go

package filehelper

import (
	"archive/zip"
	"io"
	"io/ioutil"
	"os"
	"path/filepath"
	"strings"
)

var searchResult []string
var searchFileName string

// ReadFile reads contents from provided file path
func ReadFile(filePath string) ([]byte, error) {
	return ioutil.ReadFile(filePath)

}

//CreateFile creates a new file
func CreateFile(filePath string) (*os.File, error) {
	return os.Create(filePath)
}

// WriteFile writes provided  bytes to file
func WriteFile(filePath string, data []byte) error {
	return ioutil.WriteFile(filePath, data, 0644)
}

//AppendFile appends prvided data/text to file
func AppendFile(filename string, text string) (int, error) {

	f, err := os.OpenFile(filename, os.O_APPEND|os.O_WRONLY, 0600)
	if err != nil {
		return 0, err
	}

	defer f.Close()

	return f.WriteString(text)
}

//DeleteFile deletes provided file path
func DeleteFile(filePath string) error {
	return os.Remove(filePath)
}

// RenameFile renames/moves file from old path to new path
func RenameFile(oldFilePath, newFilePath string) error {
	return os.Rename(oldFilePath, newFilePath)
}

// CreateDirectory creates directory using provided path
func CreateDirectory(directoryPath string) error {
	return os.Mkdir(directoryPath, 0777)
}

// DeleteDirectory creates directory using provided path
func DeleteDirectory(directoryPath string) error {
	return os.RemoveAll(directoryPath)
}

//ListDirectory returns list of all available components of directory
func ListDirectory(directoryPath string) ([]os.FileInfo, error) {
	return ioutil.ReadDir(directoryPath)
}

//Zip Zip
func Zip(source, target string) error {

	source = filepath.Clean(source)
	target = filepath.Clean(target)

	zipfile, err := os.Create(target)
	if err != nil {
		return err
	}
	defer zipfile.Close()

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

	info, err := os.Stat(source)
	if err != nil {
		return err
	}

	var baseDir string
	if info.IsDir() {
		baseDir = filepath.Base(source)
	}

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

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

		if baseDir != "" {
			header.Name = filepath.Join(baseDir, strings.TrimPrefix(path, source))
		}

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

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

		if info.IsDir() {
			return nil
		}

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

	return err
}

//Unzip Unzip
func Unzip(archive, target string) error {
	reader, err := zip.OpenReader(archive)
	if err != nil {
		return err
	}

	err = os.MkdirAll(target, 0755)
	if err != nil {
		return err
	}

	for _, file := range reader.File {
		path := filepath.Join(target, file.Name)
		if file.FileInfo().IsDir() {
			os.MkdirAll(path, file.Mode())
			continue
		}

		fileReader, err := file.Open()
		if err != nil {
			return err
		}
		defer fileReader.Close()

		targetFile, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, file.Mode())
		if err != nil {
			return err
		}
		defer targetFile.Close()

		_, err = io.Copy(targetFile, fileReader)
		if err != nil {
			return err
		}
	}

	return nil
}

//MoveDirectory MoveDirectory
func MoveDirectory(source, destination string) error {
	return os.Rename(source, destination)
}

//MoveFile MoveFile
func MoveFile(source, destination string) error {
	return os.Rename(source, destination)
}

//CopyFile CopyFile
func CopyFile(source, destination string) error {
	// return os.Rename(source, destination)

	data, err := ioutil.ReadFile(source)
	if err != nil {
		return err
	}
	err = ioutil.WriteFile(destination, data, 0644)
	if err != nil {
	}
	return err
}

//ReplaceFile ReplaceFile
func ReplaceFile(data []byte, destination string) error {

	err := ioutil.WriteFile(destination, data, 0644)
	if err != nil {
	}
	return err
}

//TruncateFile TruncateFile
func TruncateFile(path string, size int64) error {
	return os.Truncate(path, size)
}

//SeekFile SeekFile
// func SeekFile(path string, offset int64) error {
// 	file, err := os.OpenFile(path, os.O_RDWR, 0600)
// 	if err != nil {
// 		return err
// 	}

// 	defer file.Close()

// 	_, err = file.Seek(offset, 0)

// 	return err
// }

//FileInfo FileInfo
func FileInfo(path string) (os.FileInfo, error) {
	return os.Stat(path)
}

//FileSearch FileSearch
func FileSearch(fileName, path string) ([]string, error) {
	searchFileName = fileName
	searchDirectory, err := os.Open(path)
	if err != nil {
		return searchResult, err
	}
	defer searchDirectory.Close()

	testFileInfo, _ := searchDirectory.Stat()
	if !testFileInfo.IsDir() {
		return searchResult, err
	}

	err = filepath.Walk(path, findFile)
	if err != nil {
		return searchResult, err
	}

	return searchResult, nil

}

func findFile(path string, fileInfo os.FileInfo, err error) error {

	if err != nil {
		return err
	}

	// get absolute path of the folder that we are searching
	absolute, err := filepath.Abs(path)
	if err != nil {
		return err
	}

	if fileInfo.IsDir() {
		testDir, err := os.Open(absolute)
		if err != nil {
			return err
		}
		testDir.Close()
		return nil
	}

	matched, err := filepath.Match(searchFileName, fileInfo.Name())
	if err != nil {
		return err
	}

	if matched {
		add := absolute
		searchResult = append(searchResult, add)
	}

	return nil
}