package utils
import (
"bytes"
"crypto/sha1"
"encoding/json"
"encoding/xml"
"errors"
"fmt"
"io"
"io/ioutil"
"log"
"net/url"
"os"
"os/exec"
"path/filepath"
"runtime"
"strings"
"time"
)
const (
EXT_HTML = ".html"
EXT_XML = ".xml"
EXT_JSON = ".json"
EXT_ZIP = ".zip"
EXT_IDOC = ".idoc"
EXT_ZED = ".zed"
EXT_PDF = ".pdf"
)
func GetFilelist(path string, pattern string) []string {
fileList := make([]string, 0, 1000)
filepath.Walk(path, func(path string, f os.FileInfo, err error) error {
if ok, _ := filepath.Match(pattern, f.Name()); ok {
fileList = append(fileList, path)
}
return nil
})
return fileList
}
func ForeachFile(path string, pattern string, onFindFile func(fileName string) error) error {
return filepath.Walk(path, func(path string, f os.FileInfo, err error) error {
if ok, _ := filepath.Match(pattern, f.Name()); ok {
err := onFindFile(path)
if err != nil {
return err
}
}
return nil
})
}
func ReadFileContext(path string) string {
fi, err := os.Open(path)
NoneError(err)
defer fi.Close()
fd, err := ioutil.ReadAll(fi)
NoneError(err)
return string(fd)
}
func SaveFile(file string, content string) {
f := ForceCreateFile(file)
defer f.Close()
_, err := f.WriteString(content)
NoneError(err)
}
func SaveUtf8BomFile(file string, content string) {
fs := ForceCreateFile(file)
defer fs.Close()
fs.WriteString("\xEF\xBB\xBF") // 写入UTF-8 BOM
fs.WriteString(content)
}
func ForceCreateFile(filename string) *os.File {
dir := filepath.Dir(filename)
dir = UNCPath(dir)
err := os.MkdirAll(dir, 0755)
ShowError(err)
filename = UNCPath(filename)
fs, err := os.Create(filename)
ShowError(err)
return fs
}
func SetLastModified(file string, time time.Time) {
os.Chtimes(file, time, time)
}
func GetlastModified(file string) time.Time {
fileInfo, err := os.Stat(file)
if err != nil {
return time.Time{}
}
return fileInfo.ModTime()
}
func CopyFile(dst, src string) error {
if !FileExists(src) {
return errors.New("file not exist `" + src + "`")
}
in, err := os.Open(src)
if err != nil {
return err
}
defer in.Close()
out := ForceCreateFile(dst)
if err != nil {
fmt.Println("copy ", src)
fmt.Println("to ", dst)
fmt.Println("Failed")
return nil
}
defer out.Close()
_, err = io.Copy(out, in)
cerr := out.Close()
if err != nil {
return err
}
return cerr
}
func CopyDir(dst, src string) error {
dst = UNCPath(dst)
src = UNCPath(src)
return filepath.Walk(src,
func(path string, f os.FileInfo, err error) error {
if err != nil {
NoneError(err)
}
if !f.IsDir() {
rel, err := filepath.Rel(src, path)
NoneError(err)
return CopyFile(filepath.Join(dst, rel), path)
}
return nil
})
}
func PathExists(path string) bool {
finfo, err := os.Stat(path)
if err != nil {
return false
}
return finfo.IsDir()
}
func FileExists(filename string) bool {
finfo, err := os.Stat(filename)
if err == nil && !finfo.IsDir() {
return true
}
return false
}
func WriteFile(file string, data []byte) {
fs := ForceCreateFile(file)
defer fs.Close()
fs.Write(data)
}
func ReadJson(obj interface{}, filename string) error {
data, err := ioutil.ReadFile(filename)
if err != nil {
return err
}
err = json.Unmarshal(data, obj)
if err != nil {
return err
}
return nil
}
func SaveJson(filename string, obj interface{}) error {
fs := ForceCreateFile(filename)
defer fs.Close()
data, err := json.MarshalIndent(obj, "", " ")
if err != nil {
return err
}
_, err = fs.Write(data)
if err != nil {
return err
}
return nil
}
func ReadXml(obj interface{}, filename string) error {
data, err := ioutil.ReadFile(filename)
if err != nil {
return err
}
err = xml.Unmarshal(data, obj)
if err != nil {
return err
}
return nil
}
func SaveXml(filename string, obj interface{}) error {
fs := ForceCreateFile(filename)
defer fs.Close()
data, err := xml.MarshalIndent(obj, "", " ")
if err != nil {
return err
}
_, err = fs.Write(data)
if err != nil {
return err
}
return nil
}
func GetFileInfo(filename string) (name, ext string, en bool) {
file := filepath.Base(filename)
ext = filepath.Ext(file)
name = strings.TrimSuffix(file, ext)
if strings.ToLower(filepath.Ext(name)) == ".en" {
en = true
ext = filepath.Ext(name) + ext
name = strings.TrimSuffix(file, ext)
}
return name, ext, en
}
func FileToUrlPath(file string) string {
xUrl, err := url.Parse(file)
NoneError(err)
return xUrl.EscapedPath()
}
func UrlToLocalFile(Url string) string {
xUrl, err := url.Parse(Url)
NoneError(err)
return SHA1EncodeFileName(xUrl.Path)
}
func SHA1EncodeFileName(filename string) string {
//for en picture: xxx.en.png
dir := filepath.Dir(filename)
filenameOnly, ext, _ := GetFileInfo(filename)
t := sha1.New()
_, err := io.WriteString(t, filenameOnly)
NoneError(err)
return dir + "/" + fmt.Sprintf("%x", t.Sum(nil)) + ext
}
func RemoveFile(file string) {
if !FileExists(file) {
return
}
err := os.Remove(file)
if err != nil {
log.Println(file, " file remove Error!\n")
log.Printf("%s", err)
} else {
log.Print(file, " file remove OK!\n")
}
}
func FileOpen(file_name string) ([]byte, error) {
var (
open *os.File
file_data []byte
open_err, read_err error
)
open, open_err = os.Open(file_name)
if open_err != nil {
return nil, open_err
}
defer open.Close()
file_data, read_err = ioutil.ReadAll(open)
if read_err != nil {
return nil, read_err
}
return file_data, nil
}
func CurDir() string {
_, file, _, _ := runtime.Caller(1)
return filepath.Dir(file)
}
func IsFileSame(left, right string) bool {
sFile, err := os.Open(left)
if err != nil {
return false
}
defer sFile.Close()
dFile, err := os.Open(right)
if err != nil {
return false
}
defer dFile.Close()
sBuffer := make([]byte, 512)
dBuffer := make([]byte, 512)
for {
_, sErr := sFile.Read(sBuffer)
_, dErr := dFile.Read(dBuffer)
if sErr != nil || dErr != nil {
if sErr != dErr {
return false
}
if sErr == io.EOF {
break
}
}
if bytes.Equal(sBuffer, dBuffer) {
continue
}
return false
}
return true
}
func DiffFile(left, right string) (diff string, same bool, err error) {
_, err = exec.LookPath("diff")
if err != nil {
return "", false, err
}
cmdName, _ := exec.LookPath("diff")
cmd := exec.Command(cmdName, left, right)
output, errOfCmd := cmd.CombinedOutput()
if errOfCmd != nil {
return string(output), false, nil
}
return "", true, nil
}
