Marko Tikvić / webutility

Browse Code »

Commit 6a5c6931ebe949e22aada7d63497bcff1ac6c402

Authored by Marko Tikvić 2020-04-01 14:13:19 +0200

1 parent 2c237577d3

Exists in master

added database map to server

Showing 4 changed files with 62 additions and 45 deletions Show diff stats

document/document.go

Diff comments View file @6a5c693

 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.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
 }
-// 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)
+	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
 }
-// 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) {
+	if web.FileExists(path) {
 		err = fmt.Errorf("file %s alredy exists", path)
 		return nil, err
 	}
-	if parentDir := DirectoryFromPath(path); parentDir != "" {
+	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 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]
-}

file_util.go

Diff comments View file @6a5c693

 package webutility
 import (
 	"bytes"
+	"fmt"
 	"io"
 	"io/ioutil"
 	"os"
 	"strings"
 )
 // ReadFileContent ...
 func ReadFileContent(path string) ([]byte, error) {
 	f, err := os.Open(path)
 	if err != nil {
 		return nil, err
 	}
 	defer f.Close()
 	buf := &bytes.Buffer{}
 	if _, err = io.Copy(buf, f); err != nil {
 		return nil, err
 	}
 	return buf.Bytes(), nil
 }
 // ReadFileLines ...
 func ReadFileLines(path string) ([]string, error) {
 	f, err := os.Open(path)
 	if err != nil {
 		return nil, err
 	}
 	defer f.Close()
 	var s strings.Builder
 	if _, err = io.Copy(&s, f); err != nil {
 		return nil, err
 	}
 	lines := strings.Split(s.String(), "\n")
 	for i := range lines {
 		lines[i] = strings.TrimRight(lines[i], "\r\n")
 	}
 	return lines, nil
 }
 // LinesToFile ...
 func LinesToFile(path string, lines []string) error {
 	content := ""
 	for _, l := range lines {
 		content += l + "\n"
 	}
 	return ioutil.WriteFile(path, []byte(content), 0644) // drw-r--r--
 }
 // InsertLine ...
 func InsertLine(lines *[]string, pos int64, l string) {
 	tail := append([]string{l}, (*lines)[pos:]...)
 	*lines = append((*lines)[:pos], tail...)
 }
 func WriteFile(path string, content []byte) error {
 	return ioutil.WriteFile(path, content, 0644) // drw-r--r--
 }
 func ListDir(path string) (fnames []string, err error) {
 	finfo, err := ioutil.ReadDir(path)
 	if err != nil {
 		return nil, err
 	}
 	for _, f := range finfo {
 		fnames = append(fnames, f.Name())
 	}
 	return fnames, nil
 }
 func WorkingDir() string {
-	dir, _ := os.Getwd()
+	path, err := os.Getwd()
+	if err != nil {
+		fmt.Printf("couldn't get working directory: %s\n", err.Error())
+	}
+	return 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]
+}
+func DeleteFile(path string) error {
+	return os.Remove(path)
+}
+// 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
 }
+// FileExists ...
+func FileExists(path string) bool {
+	temp, err := os.Open(path)
+	defer temp.Close()
+	if err != nil {
+		return false
+	}
+	return true
+}

float_util.go

Diff comments View file @6a5c693

 package webutility
 import (
 	"fmt"
 	"math"
 	"math/big"
 	"strings"
 )
 func RoundFloat64(f float64, dec int) float64 {
 	p := math.Pow(10, float64(dec))
 	return math.Round(f*p) / p
 }
 func NewBF(f float64, prec uint) *big.Float {
 	x := big.NewFloat(f)
 	x.SetPrec(prec)
 	return x
 }
 func AddBF(x, y *big.Float) *big.Float {
 	z := big.NewFloat(0.0)
 	z.SetPrec(x.Prec())
 	z.Add(x, y)
 	return z
 }
 func SubBF(x, y *big.Float) *big.Float {
 	z := big.NewFloat(0.0)
 	z.SetPrec(x.Prec())
 	yneg := big.NewFloat(0.0)
 	yneg.Neg(y)
 	z.Add(x, yneg)
 	return z
 }
 func MulBF(x, y *big.Float) *big.Float {
 	z := big.NewFloat(0.0)
 	z.SetPrec(x.Prec())
 	z.Mul(x, y)
 	return z
 }
 func DivBF(x, y *big.Float) *big.Float {
 	z := big.NewFloat(0.0)
 	z.SetPrec(x.Prec())
 	z.Quo(x, y)
 	return z
 }
 func BFtoFloat(f *big.Float) float64 {
 	v, _ := f.Float64()
 	return v
 }
 func Float64ToString(f float64) string {
 	return fmt.Sprintf("%.2f", f)
 }
 func Float64PtrToString(f *float64) string {
 	if f == nil {
 		return ""
 	}
 	return fmt.Sprintf("%.2f", *f)
 }
 func FormatFloat64Number(f float64, dec int) string {
 	res := ""
 	f = RoundFloat64(f, dec)
 	i := int64(f)
 	format := fmt.Sprintf("%%.%df", dec)
 	parts := strings.Split(fmt.Sprintf(format, f-float64(i)), ".")
 	decimals := parts[1]
 	res = FormatInt64Number(i) + "," + decimals
 	return res
 }
+func MaxFlaot64(vars ...float64) (max float64) {
+	max = vars[0]
+	for _, v := range vars {
+		if v > max {
+			max = v
+		}
+	}
+	return max
+}

server.go

Diff comments View file @6a5c693

 package webutility
 import (
 	"database/sql"
 	"fmt"
 	"net/http"
 	"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
 	UTCOffset int64
+	DBs       map[string]*sql.DB
 }
 func NewODBCServer(dsn, port, logDir string, utcOffset int64) (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.UTCOffset = utcOffset
+	s.DBs = make(map[string]*sql.DB)
+	s.DBs["default"] = s.DB
 	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()
 	}
 }