Marko Tikvić / webutility

Browse Code »

Commit 62a0d7a8a772705b98713e3be1dde7af2e928856

Authored by Marko Tikvić 2020-08-27 11:18:27 +0200

1 parent 0c71c54873

Exists in master

minor changes

Showing 3 changed files with 14 additions and 17 deletions Show diff stats

document/document.go

Diff comments View file @62a0d7a

 package document
 import (
 	"errors"
 	"fmt"
 	"io"
 	"mime"
 	"net/http"
 	"os"
 	"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 = web.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
 }
 // 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 := web.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
 }
 // SaveToFile ...
 func (d *Document) SaveToFile(path string) (f *os.File, err error) {
 	d.Path = path
 	if web.FileExists(path) {
 		err = fmt.Errorf("file %s alredy exists", path)
 		return nil, err
 	}
 	if parentDir := web.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 DeleteDocuments(docs []*Document) error {
 	for _, d := range docs {
+		if d == nil {
+			continue
+		}
 		if err := d.DeleteFile(); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 // DeleteFile ...
 func (d *Document) DeleteFile() error {
 	return os.Remove(d.Path)
 }

quicksort.go

Diff comments View file @62a0d7a

 package webutility
 type QSortDirection int
 const (
 	QSortAscending QSortDirection = iota
 	QSortDescending
 )
 // QuickSortable is an interface for quicksorting slices.
 type QuickSortable interface {
 	Swap(i, j int)
 	Compare(i, j int) int
 	Len() int
 }
 // Quicksort quicksorts que.
 func Quicksort(que QuickSortable, low, high int, dir QSortDirection) {
 	if low >= high {
 		return
 	}
 	if dir != QSortAscending && dir != QSortDescending {
 		return
 	}
 	index := partition(que, low, high, dir)
 	Quicksort(que, low, index-1, dir)
 	Quicksort(que, index+1, high, dir)
 }
 func partition(que QuickSortable, low, high int, dir QSortDirection) int {
 	swap := 0
 	// -1 -> i > j
 	//  1 -> i < j
 	if dir == QSortDescending {
 		swap = -1
 	} else {
 		swap = 1
 	}
 	i := low - 1
 	for j := low; j <= high-1; j++ {
 		if que.Compare(j, high) == swap {
 			i++
 			que.Swap(i, j)
 		}
 		continue
 	}
 	que.Swap(i+1, high)
 	return i + 1
 }
+func BubbleSort(arr []int64) {
+	for i := 0; i < len(arr)-1; i++ {
+		for j := i; j < len(arr); j++ {
+			if arr[i] > arr[j] {
+				arr[i], arr[j] = arr[j], arr[i]
+			}
+		}
+	}
+}

server.go

Diff comments View file @62a0d7a

 package webutility
 import (
 	"database/sql"
 	"fmt"
 	"net/http"
-	"time"
 	"git.to-net.rs/marko.tikvic/gologger"
 	"github.com/gorilla/mux"
 )
 type Server struct {
 	DB     *sql.DB
 	Router *mux.Router
 	Logger *gologger.Logger
 	Port   string
 	DBs    map[string]*sql.DB
 	dsn    map[string]string
 }
 func NewODBCServer(dsn, port, logDir string) (s *Server, err error) {
 	s = new(Server)
 	s.Port = port
 	if s.DB, err = sql.Open("odbc", fmt.Sprintf("DSN=%s;", dsn)); err != nil {
 		return nil, err
 	}
 	s.Router = mux.NewRouter()
 	if s.Logger, err = gologger.New("err", logDir, gologger.MaxLogSize1MB); err != nil {
 		return nil, fmt.Errorf("can't create logger: %s", err.Error())
 	}
 	s.DBs = make(map[string]*sql.DB)
 	s.DBs["default"] = s.DB
 	s.dsn = make(map[string]string)
-	s.DBs["default"] = s.DB
+	s.dsn["default"] = dsn
 	return s, nil
 }
 func (s *Server) Run() {
 	s.Logger.Print("Server listening on %s", s.Port)
 	s.Logger.PrintAndTrace(http.ListenAndServe(s.Port, s.Router).Error())
 }
 func (s *Server) Cleanup() {
 	if s.DB != nil {
 		s.DB.Close()
 	}
 	if s.Logger != nil {
 		s.Logger.Close()
 	}
 }
 func (s *Server) StartTransaction() (*sql.Tx, error) {
 	return s.DB.Begin()
 }
 func CommitChanges(tx *sql.Tx, err *error, opt ...error) {
 	if *err != nil {
 		tx.Rollback()
 		return
 	}
 	for _, e := range opt {
 		if e != nil {
 			tx.Rollback()
 			return
 		}
 	}
 	if *err = tx.Commit(); *err != nil {
 		tx.Rollback()
 	}
 }
-func (s *Server) RefreshDatabaseConnections(period time.Duration) {
-	for {
-		for k, db := range s.DBs {
-			if err := db.Ping(); err != nil {
-				if s.Logger != nil {
-					s.Logger.PrintAndTrace("failed to ping database (%s): %s", s.dsn[k], err.Error())
-				} else {
-					fmt.Println("failed to ping database (%s): %s", s.dsn[k], err.Error())
-				}
-			}
-		}
-		time.Sleep(period)
-	}
-}