Marko Tikvić / webutility

Browse Code »

Commit 07daaf4e563562e18240031d27d8936d45d0af2d

Authored by Marko Tikvić 2020-04-15 12:56:19 +0200

1 parent 6a5c6931eb

Exists in master

separate nullable time, date and timedate structs

Showing 2 changed files with 224 additions and 13 deletions Show diff stats

nullables.go

Diff comments View file @07daaf4

 package webutility
 import (
 	"database/sql"
 	"database/sql/driver"
 	"encoding/json"
 	"fmt"
 	"time"
 )
 // NullBool is a wrapper for sql.NullBool with added JSON (un)marshalling
 type NullBool sql.NullBool
 // Scan ...
 func (nb *NullBool) Scan(value interface{}) error {
 	var b sql.NullBool
 	if err := b.Scan(value); err != nil {
 		nb.Bool, nb.Valid = false, false
 		return err
 	}
 	nb.Bool, nb.Valid = b.Bool, b.Valid
 	return nil
 }
 // Value ...
 func (nb *NullBool) Value() (driver.Value, error) {
 	if !nb.Valid {
 		return nil, nil
 	}
 	return nb.Bool, nil
 }
 // MarshalJSON ...
 func (nb NullBool) MarshalJSON() ([]byte, error) {
 	if nb.Valid {
 		return json.Marshal(nb.Bool)
 	}
 	return json.Marshal(nil)
 }
 // UnmarshalJSON ...
 func (nb *NullBool) UnmarshalJSON(b []byte) error {
 	var temp *bool
 	if err := json.Unmarshal(b, &temp); err != nil {
 		return err
 	}
 	if temp != nil {
 		nb.Valid = true
 		nb.Bool = *temp
 	} else {
 		nb.Valid = false
 	}
 	return nil
 }
-// SQLCast ...
+// CastToSQL ...
-func (nb *NullBool) SQLCast() sql.NullBool {
+func (nb *NullBool) CastToSQL() sql.NullBool {
 	return sql.NullBool(*nb)
 }
 // NullString is a wrapper for sql.NullString with added JSON (un)marshalling
 type NullString sql.NullString
 // Scan ...
 func (ns *NullString) Scan(value interface{}) error {
 	var s sql.NullString
 	if err := s.Scan(value); err != nil {
 		ns.String, ns.Valid = "", false
 		return err
 	}
 	ns.String, ns.Valid = s.String, s.Valid
 	return nil
 }
 // Value ...
 func (ns *NullString) Value() (driver.Value, error) {
 	if !ns.Valid {
 		return nil, nil
 	}
 	return ns.String, nil
 }
 // MarshalJSON ...
 func (ns NullString) MarshalJSON() ([]byte, error) {
 	if ns.Valid {
 		return json.Marshal(ns.String)
 	}
 	return json.Marshal(nil)
 }
 // UnmarshalJSON ...
 func (ns *NullString) UnmarshalJSON(b []byte) error {
 	var temp *string
 	if err := json.Unmarshal(b, &temp); err != nil {
 		return err
 	}
 	if temp != nil {
 		ns.Valid = true
 		ns.String = *temp
 	} else {
 		ns.Valid = false
 	}
 	return nil
 }
-// SQLCast ...
+// CastToSQL ...
-func (ns *NullString) SQLCast() sql.NullString {
+func (ns *NullString) CastToSQL() sql.NullString {
 	return sql.NullString(*ns)
 }
 // NullInt64 is a wrapper for sql.NullInt64 with added JSON (un)marshalling
 type NullInt64 sql.NullInt64
 // Scan ...
 func (ni *NullInt64) Scan(value interface{}) error {
 	var i sql.NullInt64
 	if err := i.Scan(value); err != nil {
 		ni.Int64, ni.Valid = 0, false
 		return err
 	}
 	ni.Int64, ni.Valid = i.Int64, i.Valid
 	return nil
 }
 // ScanPtr ...
 func (ni *NullInt64) ScanPtr(v interface{}) error {
 	if ip, ok := v.(*int64); ok && ip != nil {
 		return ni.Scan(*ip)
 	}
 	return nil
 }
 // Value ...
 func (ni *NullInt64) Value() (driver.Value, error) {
 	if !ni.Valid {
 		return nil, nil
 	}
 	return ni.Int64, nil
 }
 func (ni *NullInt64) Val() int64 {
 	return ni.Int64
 }
 // Add
 func (ni *NullInt64) Add(i NullInt64) {
 	ni.Valid = true
 	ni.Int64 += i.Int64
 }
 func (ni *NullInt64) Set(i int64) {
 	ni.Valid = true
 	ni.Int64 = i
 }
 // MarshalJSON ...
 func (ni NullInt64) MarshalJSON() ([]byte, error) {
 	if ni.Valid {
 		return json.Marshal(ni.Int64)
 	}
 	return json.Marshal(nil)
 }
 // UnmarshalJSON ...
 func (ni *NullInt64) UnmarshalJSON(b []byte) error {
 	var temp *int64
 	if err := json.Unmarshal(b, &temp); err != nil {
 		return err
 	}
 	if temp != nil {
 		ni.Valid = true
 		ni.Int64 = *temp
 	} else {
 		ni.Valid = false
 	}
 	return nil
 }
-// SQLCast ...
+// CastToSQL ...
-func (ni *NullInt64) SQLCast() sql.NullInt64 {
+func (ni *NullInt64) CastToSQL() sql.NullInt64 {
 	return sql.NullInt64(*ni)
 }
 // NullFloat64 is a wrapper for sql.NullFloat64 with added JSON (un)marshalling
 type NullFloat64 sql.NullFloat64
 // Scan ...
 func (nf *NullFloat64) Scan(value interface{}) error {
 	var f sql.NullFloat64
 	if err := f.Scan(value); err != nil {
 		nf.Float64, nf.Valid = 0.0, false
 		return err
 	}
 	nf.Float64, nf.Valid = f.Float64, f.Valid
 	return nil
 }
 // ScanPtr ...
 func (nf *NullFloat64) ScanPtr(v interface{}) error {
 	if fp, ok := v.(*float64); ok && fp != nil {
 		return nf.Scan(*fp)
 	}
 	return nil
 }
 // Value ...
 func (nf *NullFloat64) Value() (driver.Value, error) {
 	if !nf.Valid {
 		return nil, nil
 	}
 	return nf.Float64, nil
 }
 // Val ...
 func (nf *NullFloat64) Val() float64 {
 	return nf.Float64
 }
 // Add ...
 func (nf *NullFloat64) Add(f NullFloat64) {
 	nf.Valid = true
 	nf.Float64 += f.Float64
 }
 func (nf *NullFloat64) Set(f float64) {
 	nf.Valid = true
 	nf.Float64 = f
 }
 // MarshalJSON ...
 func (nf NullFloat64) MarshalJSON() ([]byte, error) {
 	if nf.Valid {
 		return json.Marshal(nf.Float64)
 	}
 	return json.Marshal(nil)
 }
 // UnmarshalJSON ...
 func (nf *NullFloat64) UnmarshalJSON(b []byte) error {
 	var temp *float64
 	if err := json.Unmarshal(b, &temp); err != nil {
 		return err
 	}
 	if temp != nil {
 		nf.Valid = true
 		nf.Float64 = *temp
 	} else {
 		nf.Valid = false
 	}
 	return nil
 }
-// SQLCast ...
+// CastToSQL ...
-func (nf *NullFloat64) SQLCast() sql.NullFloat64 {
+func (nf *NullFloat64) CastToSQL() sql.NullFloat64 {
 	return sql.NullFloat64(*nf)
 }
+// NullDateTime ...
+type NullDateTime struct {
+	Time  time.Time
+	Valid bool // Valid is true if Time is not NULL
+}
+// Scan ...
+func (nt *NullDateTime) Scan(value interface{}) (err error) {
+	if value == nil {
+		nt.Time, nt.Valid = time.Time{}, false
+		return
+	}
+	switch v := value.(type) {
+	case time.Time:
+		nt.Time, nt.Valid = v, true
+		return
+	case []byte:
+		nt.Time, err = parseSQLDateTime(string(v), time.UTC)
+		nt.Valid = (err == nil)
+		return
+	case string:
+		nt.Time, err = parseSQLDateTime(v, time.UTC)
+		nt.Valid = (err == nil)
+		return
+	}
+	nt.Valid = false
+	return fmt.Errorf("Can't convert %T to time.Time", value)
+}
+// Value implements the driver Valuer interface.
+func (nt NullDateTime) Value() (driver.Value, error) {
+	if !nt.Valid {
+		return nil, nil
+	}
+	return nt.Time, nil
+}
+// MarshalJSON ...
+func (nt NullDateTime) MarshalJSON() ([]byte, error) {
+	if nt.Valid {
+		format := nt.Time.Format("2006-01-02 15:04:05")
+		return json.Marshal(format)
+	}
+	return json.Marshal(nil)
+}
+// UnmarshalJSON ...
+func (nt *NullDateTime) UnmarshalJSON(b []byte) error {
+	var temp *time.Time
+	var t1 time.Time
+	var err error
+	s1 := string(b)
+	s2 := s1[1 : len(s1)-1]
+	if s1 == "null" {
+		temp = nil
+	} else {
+		t1, err = time.Parse("2006-01-02 15:04:05", s2)
+		if err != nil {
+			return err
+		}
+		temp = &t1
+	}
+	if temp != nil {
+		nt.Valid = true
+		nt.Time = *temp
+	} else {
+		nt.Valid = false
+	}
+	return nil
+}
+func (nt *NullDateTime) CastToSQL() NullDateTime {
+	return *nt
+}
+// NullDate ...
+type NullDate struct {
+	Time  time.Time
+	Valid bool // Valid is true if Time is not NULL
+}
+// Scan ...
+func (nt *NullDate) Scan(value interface{}) (err error) {
+	if value == nil {
+		nt.Time, nt.Valid = time.Time{}, false
+		return
+	}
+	switch v := value.(type) {
+	case time.Time:
+		nt.Time, nt.Valid = v, true
+		return
+	case []byte:
+		nt.Time, err = parseSQLDate(string(v), time.UTC)
+		nt.Valid = (err == nil)
+		return
+	case string:
+		nt.Time, err = parseSQLDate(v, time.UTC)
+		nt.Valid = (err == nil)
+		return
+	}
+	nt.Valid = false
+	return fmt.Errorf("Can't convert %T to time.Time", value)
+}
+// Value implements the driver Valuer interface.
+func (nt NullDate) Value() (driver.Value, error) {
+	if !nt.Valid {
+		return nil, nil
+	}
+	return nt.Time, nil
+}
+// MarshalJSON ...
+func (nt NullDate) MarshalJSON() ([]byte, error) {
+	if nt.Valid {
+		format := nt.Time.Format("2006-01-02")
+		return json.Marshal(format)
+	}
+	return json.Marshal(nil)
+}
+// UnmarshalJSON ...
+func (nt *NullDate) UnmarshalJSON(b []byte) error {
+	var temp *time.Time
+	var t1 time.Time
+	var err error
+	s1 := string(b)
+	s2 := s1[1 : len(s1)-1]
+	if s1 == "null" {
+		temp = nil
+	} else {
+		t1, err = time.Parse("2006-01-02", s2)
+		if err != nil {
+			return err
+		}
+		temp = &t1
+	}
+	if temp != nil {
+		nt.Valid = true
+		nt.Time = *temp
+	} else {
+		nt.Valid = false
+	}
+	return nil
+}
+func (nt *NullDate) CastToSQL() NullDate {
+	return *nt
+}
 // NullTime ...
 type NullTime struct {
 	Time  time.Time
 	Valid bool // Valid is true if Time is not NULL
 }
 // Scan ...
 func (nt *NullTime) Scan(value interface{}) (err error) {
 	if value == nil {
 		nt.Time, nt.Valid = time.Time{}, false
 		return
 	}
 	switch v := value.(type) {
 	case time.Time:
 		nt.Time, nt.Valid = v, true
 		return
 	case []byte:
-		nt.Time, err = parseDateTime(string(v), time.UTC)
+		nt.Time, err = parseSQLTime(string(v), time.UTC)
 		nt.Valid = (err == nil)
 		return
 	case string:
-		nt.Time, err = parseDateTime(v, time.UTC)
+		nt.Time, err = parseSQLTime(v, time.UTC)
 		nt.Valid = (err == nil)
 		return
 	}
 	nt.Valid = false
 	return fmt.Errorf("Can't convert %T to time.Time", value)
 }
 // Value implements the driver Valuer interface.
 func (nt NullTime) Value() (driver.Value, error) {
 	if !nt.Valid {
 		return nil, nil
 	}
 	return nt.Time, nil
 }
 // MarshalJSON ...
 func (nt NullTime) MarshalJSON() ([]byte, error) {
 	if nt.Valid {
-		format := nt.Time.Format("2006-01-02 15:04:05")
+		format := nt.Time.Format("15:04:05")
 		return json.Marshal(format)
 	}
 	return json.Marshal(nil)
 }
 // UnmarshalJSON ...
 func (nt *NullTime) UnmarshalJSON(b []byte) error {
 	var temp *time.Time
 	var t1 time.Time
 	var err error
 	s1 := string(b)
 	s2 := s1[1 : len(s1)-1]
 	if s1 == "null" {
 		temp = nil
 	} else {
-		t1, err = time.Parse("2006-01-02 15:04:05", s2)
+		t1, err = time.Parse("15:04:05", s2)
 		if err != nil {
 			return err
 		}
 		temp = &t1
 	}
 	if temp != nil {
 		nt.Valid = true
 		nt.Time = *temp
 	} else {
 		nt.Valid = false
 	}
 	return nil
 }
-func parseDateTime(str string, loc *time.Location) (t time.Time, err error) {
+func (nt *NullTime) CastToSQL() NullTime {
+	return *nt
+}
+func parseSQLDateTime(str string, loc *time.Location) (t time.Time, err error) {
 	base := "0000-00-00 00:00:00.0000000"
 	timeFormat := "2006-01-02 15:04:05.999999"
 	switch len(str) {
 	case 10, 19, 21, 22, 23, 24, 25, 26: // up to "YYYY-MM-DD HH:MM:SS.MMMMMM"
 		if str == base[:len(str)] {
 			return
 		}
 		t, err = time.Parse(timeFormat[:len(str)], str)
 	default:
 		err = fmt.Errorf("invalid time string: %s", str)
 		return
 	}
 	// Adjust location
 	if err == nil && loc != time.UTC {
 		y, mo, d := t.Date()
 		h, mi, s := t.Clock()
 		t, err = time.Date(y, mo, d, h, mi, s, t.Nanosecond(), loc), nil
 	}
 	return
 }
+func parseSQLDate(str string, loc *time.Location) (t time.Time, err error) {
+	base := "0000-00-00"
+	timeFormat := "2006-01-02"
+	switch len(str) {
+	case 10: // up to "YYYY-MM-DD HH:MM:SS.MMMMMM"
+		if str == base[:len(str)] {
+			return
+		}
+		t, err = time.Parse(timeFormat[:len(str)], str)
+	default:
+		err = fmt.Errorf("invalid time string: %s", str)
+		return
+	}
+	// Adjust location
+	if err == nil && loc != time.UTC {
+		y, mo, d := t.Date()
+		h, mi, s := t.Clock()
+		t, err = time.Date(y, mo, d, h, mi, s, t.Nanosecond(), loc), nil
+	}
+	return
+}
+func parseSQLTime(str string, loc *time.Location) (t time.Time, err error) {
+	base := "00:00:00.0000000"
+	timeFormat := "15:04:05.999999"
+	switch len(str) {
+	case 12, 15: // up to "YYYY-MM-DD HH:MM:SS.MMMMMM"
+		if str == base[:len(str)] {
+			return
+		}
+		t, err = time.Parse(timeFormat[:len(str)], str)
+	default:
+		err = fmt.Errorf("invalid time string: %s", str)
+		return
+	}
+	// Adjust location
+	if err == nil && loc != time.UTC {
+		y, mo, d := t.Date()
+		h, mi, s := t.Clock()
+		t, err = time.Date(y, mo, d, h, mi, s, t.Nanosecond(), loc), nil
+	}
+	return
+}

pdfhelper/pdf.go

Diff comments View file @07daaf4

 package pdfhelper
 import (
 	"fmt"
 	"strings"
 	"git.to-net.rs/marko.tikvic/gofpdf"
 )
 // Block ...
 const (
 	CENTER   = "C"
+	MIDDLE   = "M"
 	LEFT     = "L"
 	RIGHT    = "R"
 	TOP      = "T"
 	BOTTOM   = "B"
 	FULL     = "1"
 	NOBORDER = ""
 )
 const (
 	CONTINUE = 0
 	NEWLINE  = 1
 	BELLOW   = 2
 )
 const (
 	cyrillicEncoding = "cp1251"
 	latinEncoding    = "cp1250"
 )
 const threeDots = "\u2056\u2056\u2056"
 type TableCell struct {
 	W, H            float64
 	Text            string
 	Font, FontStyle string
 	FontSize        float64
 	Border          string
 	Alignment       string
 }
 // Helper ...
 type Helper struct {
 	*gofpdf.Fpdf
 	translators map[string]func(string) string
 }
 // New ...
 func New(ori, unit, size string) *Helper {
 	helper := &Helper{
 		Fpdf: gofpdf.New(ori, unit, size, ""),
 	}
 	return helper
 }
 func (pdf *Helper) LoadTranslators() {
 	pdf.translators = make(map[string]func(string) string)
 	pdf.translators[latinEncoding] = pdf.UnicodeTranslatorFromDescriptor(latinEncoding)
 	pdf.translators[cyrillicEncoding] = pdf.UnicodeTranslatorFromDescriptor(cyrillicEncoding)
 }
 func (pdf *Helper) DrawCell(x, y float64, c TableCell) {
 	pdf.SetXY(x, y)
 	pdf.SetFont(c.Font, c.FontStyle, c.FontSize)
 	pdf.CellFormat(c.W, c.H, pdf.toUTF8(c.Text), c.Border, BELLOW, c.Alignment, false, 0, "")
 }
 func (pdf *Helper) DrawColumn(x, y float64, cells []TableCell) {
 	pdf.SetXY(x, y)
 	for _, c := range cells {
 		pdf.SetFont(c.Font, c.FontStyle, c.FontSize)
 		pdf.CellFormat(c.W, c.H, pdf.toUTF8(c.Text), c.Border, BELLOW, c.Alignment, false, 0, "")
 	}
 }
 func (pdf *Helper) DrawRow(x, y float64, cells []TableCell) {
 	pdf.SetXY(x, y)
 	for _, c := range cells {
 		pdf.SetFont(c.Font, c.FontStyle, c.FontSize)
 		pdf.CellFormat(c.W, c.H, pdf.toUTF8(c.Text), c.Border, CONTINUE, c.Alignment, false, 0, "")
 	}
 }
 func (pdf *Helper) TextLength(txt, family, style string, size float64) float64 {
 	family, _, _, _ = pdf.setCorrectFontFamily(textEncoding(txt))
 	return pdf.Fpdf.TextLength(txt, family, style, size)
 }
 func (pdf *Helper) LimitText(text, limiter string, maxWidth float64) string {
 	parts := pdf.Fpdf.SplitText(text, maxWidth)
 	if len(parts) > 1 {
 		return parts[0] + limiter
 	}
 	return text
 }
 // InsertImage ...
 func (pdf *Helper) InsertImage(img string, x, y, w, h float64) {
 	imgType := ""
 	if parts := strings.Split(img, "."); len(parts) >= 2 {
 		imgType = parts[len(parts)-1]
 	}
 	opt := gofpdf.ImageOptions{
 		ImageType:             imgType,
 		ReadDpi:               false,
 		AllowNegativePosition: false,
 	}
 	autoBreak := false // if it's not false then you can't draw the image at an arbitrary height (y position)
 	pdf.ImageOptions(img, x, y, w, h, autoBreak, opt, 0, "")
 }
 func (pdf *Helper) PageHasSpace(requiredHeight float64) bool {
 	_, h := pdf.GetPageSize()
 	_, _, _, bot := pdf.GetMargins()
 	return (h - bot - pdf.GetY()) > requiredHeight
 }
 // DrawBox ...
 func (pdf Helper) DrawBox(x0, y0, w, h float64) {
 	pdf.Line(x0, y0, x0+w, y0)
 	pdf.Line(x0+w, y0, x0+w, y0+h)
 	pdf.Line(x0+w, y0+h, x0, y0+h)
 	pdf.Line(x0, y0+h, x0, y0)
 }
 // Strana %d/{TotalPages}
 func (pdf *Helper) InsertPageNumber(x, y float64, format string) {
 	num := fmt.Sprintf(format, pdf.PageNo())
 	pdf.DrawColumn(x, y, []TableCell{{10, 1, num, "DejaVuSans", "", 8, NOBORDER, LEFT}})
 }
 func (pdf *Helper) SuperscriptText(x, y, cw, ch float64, text, script string) {
 	family, style, size, sizeU := pdf.setCorrectFontFamily(textEncoding(text))
 	pdf.DrawCell(x, y, TableCell{cw, ch, text, family, style, size, NOBORDER, LEFT})
 	sx := x + pdf.TextLength(text, family, style, size)
 	sy := y - sizeU*0.2
 	pdf.DrawCell(sx, sy, TableCell{cw, ch, script, family, style, size - 2, NOBORDER, LEFT})
 }
 // toUTF8 ...
 func (pdf *Helper) toUTF8(s string) string {
 	encoding := textEncoding(s)
 	pdf.setCorrectFontFamily(encoding)
 	translator, ok := pdf.translators[encoding]
 	if !ok {
 		return ""
 	}
 	return translator(s)
 }
 func textEncoding(s string) string {
 	encoding := latinEncoding
 	runes := []rune(s)
 	for _, r := range runes {
 		if uint64(r) >= 0x0402 && uint64(r) <= 0x044f {
 			encoding = cyrillicEncoding
 			break
 		}
 	}
 	return encoding
 }
 func (pdf *Helper) setCorrectFontFamily(enc string) (family, style string, ptSize, unitSize float64) {
 	family, style, ptSize, unitSize = pdf.GetFontInfo()
 	if enc == cyrillicEncoding {
 		if !strings.HasSuffix(family, "cyrillic") {
 			family += "cyrillic"
 		}
 	} else {
 		if strings.HasSuffix(family, "cyrillic") {
 			family = strings.TrimSuffix(family, "cyrillic")
 		}
 	}
 	pdf.SetFont(family, style, ptSize)
 	return family, style, ptSize, unitSize
 }