Marko Tikvić / webutility

Browse Code »

Commit 2c237577d349dea55b20fab5275e82438839b5a6

Authored by Marko Tikvić 2020-03-25 11:26:36 +0100

1 parent a7bf420dd5

Exists in master

fixed int formating bug

Showing 3 changed files with 26 additions and 1 deletions Show diff stats

date_util.go

Diff comments View file @2c23757

 package webutility
 import (
 	"fmt"
 	"strings"
 	"time"
 )
 const (
 	YYYYMMDD_sl = "2006/01/02"
 	YYYYMMDD_ds = "2006-01-02"
 	YYYYMMDD_dt = "2006.01.02."
 	DDMMYYYY_sl = "02/01/2006"
 	DDMMYYYY_ds = "02-01-2006"
 	DDMMYYYY_dt = "02.01.2006."
 	YYYYMMDD_HHMMSS_sl = "2006/01/02 15:04:05"
 	YYYYMMDD_HHMMSS_ds = "2006-01-02 15:04:05"
 	YYYYMMDD_HHMMSS_dt = "2006.01.02. 15:04:05"
 	DDMMYYYY_HHMMSS_sl = "02/01/2006 15:04:05"
 	DDMMYYYY_HHMMSS_ds = "02-01-2006 15:04:05"
 	DDMMYYYY_HHMMSS_dt = "02.01.2006. 15:04:05"
 )
 var (
 	regularYear = [12]int64{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
 	leapYear    = [12]int64{31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
 )
 func Systime() int64 {
 	return time.Now().Unix()
 }
 func DateToEpoch(date, format string) int64 {
 	t, err := time.Parse(format, date)
 	if err != nil {
 		fmt.Println(err.Error())
 		return 0
 	}
 	return t.Unix()
 }
 func EpochToDate(e int64, format string) string {
 	return time.Unix(e, 0).Format(format)
 }
 func EpochToDayMonthYear(timestamp int64) (d, m, y int64) {
 	datestring := EpochToDate(timestamp, DDMMYYYY_sl)
 	parts := strings.Split(datestring, "/")
 	d = StringToInt64(parts[0])
 	m = StringToInt64(parts[1])
 	y = StringToInt64(parts[2])
 	return d, m, y
 }
 func DaysInMonth(year, month int64) int64 {
 	if month < 1 || month > 12 {
 		return 0
 	}
 	if IsLeapYear(year) {
 		return leapYear[month-1]
 	}
 	return regularYear[month-1]
 }
 func IsLeapYear(year int64) bool {
 	return year%4 == 0 && !((year%100 == 0) && (year%400 != 0))
 }
+// FirstDayOfNextMonthEpoch ...
+func FirstDayOfNextMonthEpoch(e int64) int64 {
+	d, m, y := EpochToDayMonthYear(e)
+	m++
+	if m > 12 {
+		m = 1
+		y++
+	}
+	d = 1
+	date := fmt.Sprintf("%02d/%02d/%d", d, m, y)
+	return DateToEpoch(date, DDMMYYYY_sl)
+}

document/document.go

Diff comments View file @2c23757

 package document
 import (
 	"errors"
 	"fmt"
 	"io"
 	"mime"
 	"net/http"
 	"os"
 	"strings"
 	"time"
 	web "git.to-net.rs/marko.tikvic/webutility"
 )
 // Document ...
 type Document struct {
 	ID               int64         `json:"id"`
 	FileName         string        `json:"fileName"`
 	Extension        string        `json:"extension"`
 	ContentType      string        `json:"contentType"`
 	Size             int64         `json:"fileSize"`
 	UploadedBy       string        `json:"uploadedBy"`
 	LastModifiedBy   string        `json:"lastModifiedBy"`
 	TimeUploaded     int64         `json:"timeUploaded"`
 	TimeLastModified int64         `json:"timeLastModified"`
 	RoleAccessLevel  int64         `json:"accessLevel"`
 	Description      string        `json:"description"`
 	Download         *DownloadLink `json:"download"`
 	Path             string        `json:"-"`
 	directory        string
 	data             []byte
 }
 // OpenFileAsDocument ...
 func OpenFileAsDocument(path string) (*Document, error) {
 	d := &Document{Path: path}
 	f, err := os.Open(d.Path)
 	if err != nil {
 		return nil, err
 	}
 	defer f.Close()
 	stats, err := f.Stat()
 	if err != nil {
 		return nil, err
 	}
 	d.FileName = stats.Name()
 	d.Size = stats.Size()
 	d.Extension = FileExtension(d.FileName)
 	d.data = make([]byte, d.Size)
 	if _, err = f.Read(d.data); err != nil {
 		return nil, err
 	}
 	return d, err
 }
 // DownloadLink ...
 type DownloadLink struct {
 	Method string `json:"method"`
 	URL    string `json:"url"`
 }
 // SetDownloadInfo ...
 func (d *Document) SetDownloadInfo(method, url string) {
 	d.Download = &DownloadLink{
 		Method: method,
 		URL:    url,
 	}
 }
 // ServeDocument writes d's buffer to w and sets appropriate headers according to d's content type
 // and downloadPrompt.
 func ServeDocument(w http.ResponseWriter, d *Document, downloadPrompt bool) error {
 	f, err := os.Open(d.Path)
 	if err != nil {
 		return err
 	}
 	defer f.Close()
 	web.SetContentType(w, mime.TypeByExtension(d.Extension))
 	web.SetResponseStatus(w, http.StatusOK)
 	if downloadPrompt {
 		w.Header().Set("Content-Disposition", "attachment; filename="+d.FileName)
 	}
 	buf := make([]byte, d.Size)
 	if _, err := f.Read(buf); err != nil {
 		return err
 	}
 	w.Header().Set("Content-Length", fmt.Sprintf("%d", d.Size))
 	web.WriteResponse(w, buf)
 	return nil
 }
 // FileExists ...
 func FileExists(path string) bool {
 	temp, err := os.Open(path)
 	defer temp.Close()
 	if err != nil {
 		return false
 	}
 	return true
 }
 // ParseDocument ...
 func ParseDocument(req *http.Request) (doc *Document, err error) {
 	req.ParseMultipartForm(32 << 20)
 	file, fheader, err := req.FormFile("document")
 	if err != nil {
 		return doc, err
 	}
 	claims, _ := web.GetTokenClaims(req)
 	owner := claims.Username
 	fname := fheader.Filename
 	fsize := fheader.Size
 	ftype := fmt.Sprintf("%v", fheader.Header["Content-Type"][0])
 	fextn := FileExtension(fname)
 	if fextn == "" {
 		return doc, errors.New("invalid extension")
 	}
 	doc = new(Document)
 	doc.FileName = fname
 	doc.Size = fsize
 	doc.ContentType = ftype
 	doc.Extension = "." + fextn
 	t := time.Now().Unix()
 	doc.TimeUploaded = t
 	doc.TimeLastModified = t
 	doc.UploadedBy = owner
 	doc.LastModifiedBy = owner
 	doc.RoleAccessLevel = 0
 	doc.data = make([]byte, doc.Size)
 	if _, err = io.ReadFull(file, doc.data); err != nil {
 		return doc, err
 	}
 	return doc, nil
 }
 // DirectoryFromPath ...
 func DirectoryFromPath(path string) (dir string) {
 	parts := strings.Split(path, "/")
 	if len(parts) == 1 {
 		return ""
 	}
 	dir = parts[0]
 	for _, p := range parts[1 : len(parts)-1] {
 		dir += "/" + p
 	}
 	return dir
 }
 // SaveToFile ...
 func (d *Document) SaveToFile(path string) (f *os.File, err error) {
 	d.Path = path
 	if FileExists(path) {
 		err = fmt.Errorf("file %s alredy exists", path)
 		return nil, err
 	}
 	if parentDir := DirectoryFromPath(path); parentDir != "" {
 		if err = os.MkdirAll(parentDir, os.ModePerm); err != nil {
 			if !os.IsExist(err) {
 				return nil, err
 			}
 		}
 	}
 	if f, err = os.Create(path); err != nil {
 		return nil, err
 	}
 	if _, err = f.Write(d.data); err != nil {
 		f.Close()
 		d.DeleteFile()
 		return nil, err
 	}
 	f.Close()
 	return f, nil
 }
 func DeleteFile(path string) error {
 	return os.Remove(path)
 }
+func DeleteDocuments(docs []*Document) error {
+	for _, d := range docs {
+		if err := d.DeleteFile(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
 // DeleteFile ...
 func (d *Document) DeleteFile() error {
 	return os.Remove(d.Path)
 }
 func FileExtension(path string) string {
 	parts := strings.Split(path, ".") // because name can contain dots
 	if len(parts) < 2 {
 		return ""
 	}
 	return "." + parts[len(parts)-1]
 }

int_util.go

Diff comments View file @2c23757

 package webutility
 import (
 	"fmt"
 )
 // ClampInt64 ...
 func ClampInt64(v, min, max int64) int64 {
 	if v < min {
 		return min
 	} else if v > max {
 		return max
 	}
 	return v
 }
 // InRangeInt64 ...
 func InRangeInt64(v, min, max int64) bool {
 	return (v >= min && v <= max)
 }
 // Int64ToString ...
 func Int64ToString(i int64) string {
 	return fmt.Sprintf("%d", i)
 }
 // Int64PtrToString ...
 func Int64PtrToString(i *int64) string {
 	if i == nil {
 		return ""
 	}
 	return fmt.Sprintf("%d", *i)
 }
 // BoolToInt64 ...
 func BoolToInt64(b bool) int64 {
 	if b {
 		return 1
 	}
 	return 0
 }
 // Int64ToBool ...
 func Int64ToBool(i int64) bool {
 	return i != 0
 }
 func MaxInt(vars ...int) (max int) {
 	max = vars[0]
 	for _, v := range vars {
 		if v > max {
 			max = v
 		}
 	}
 	return max
 }
 func MinInt64(vars ...int64) (min int64) {
 	min = vars[0]
 	for _, v := range vars {
 		if v < min {
 			min = v
 		}
 	}
 	return min
 }
 func FormatInt64Number(i int64) string {
 	res := ""
 	for i >= 1000 {
 		rem := i % 1000
 		i = i / 1000
-		res = res + fmt.Sprintf(".%03d", rem)
+		//res = res + fmt.Sprintf(".%03d", rem)
+		res = fmt.Sprintf(".%03d", rem) + res
 	}
 	res = fmt.Sprintf("%d", i) + res
 	return res
 }