DeforaNetworks/corteza
3
0
Fork 0
Code Activity

Add support for timezone export

Browse Source
This commit is contained in:
Tomaž Jerman
2020-06-23 10:12:51 +02:00
parent 3b15dbc350
commit e0b0944921
7 changed files with 172 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
api/compose/spec.json
View File

@@ -860,6 +860,12 @@
"type": "[]string",
"required": true,
"title": "Fields to export"
},
{
"name": "timezone",
"type": "string",
"required": false,
"title": "Convert times to this timezone"
}
]
}

6
api/compose/spec/record.json
View File

@@ -190,6 +190,12 @@
"required": true,
"title": "Fields to export",
"type": "[]string"
},
{
"name": "timezone",
"required": false,
"title": "Convert times to this timezone",
"type": "string"
}
],
"path": [

37
compose/encoder/encoder.go
View File

@@ -27,12 +27,14 @@ type (
w FlatWriter
ff []field
u userFinder
tz string
}
structuredEncoder struct {
w StructuredEncoder
ff []field
u userFinder
tz string
}
)
@@ -49,15 +51,40 @@ func MakeFields(nn ...string) []field {
return ff
}
func preprocessHeader(hh []field, tz string) []field {
nhh := make([]field, 0)
// We need to prepare additional header fields for exporting
if tz != "" && tz != "UTC" {
for _, f := range hh {
switch f.name {
case "createdAt",
"updatedAt",
"deletedAt":
nhh = append(nhh, f, field{name: f.name + "_date"}, field{name: f.name + "_time"})
break
default:
nhh = append(nhh, f)
break
}
}
} else {
return hh
}
return nhh
}
func MultiValueField(name string) field {
return field{name: name, encodeAllMulti: true}
}
func NewFlatWriter(w FlatWriter, header bool, u userFinder, ff ...field) *flatWriter {
func NewFlatWriter(w FlatWriter, header bool, u userFinder, tz string, ff ...field) *flatWriter {
f := &flatWriter{
w: w,
ff: ff,
ff: preprocessHeader(ff, tz),
u: u,
tz: tz,
}
if header {
@@ -80,11 +107,13 @@ func (enc flatWriter) writeHeader() {
_ = enc.w.Write(ss)
}
func NewStructuredEncoder(w StructuredEncoder, u userFinder, ff ...field) *structuredEncoder {
func NewStructuredEncoder(w StructuredEncoder, u userFinder, tz string, ff ...field) *structuredEncoder {
return &structuredEncoder{
w: w,
w: w,
// No need for additional timezone headers, since the output is structured
ff: ff,
u: u,
tz: tz,
}
}

6
compose/encoder/encoder_xlsx.go
View File

@@ -13,15 +13,17 @@ type (
w io.Writer
ff []field
u userFinder
tz string
}
)
func NewExcelizeEncoder(w io.Writer, header bool, u userFinder, ff ...field) *excelizeEncoder {
func NewExcelizeEncoder(w io.Writer, header bool, u userFinder, tz string, ff ...field) *excelizeEncoder {
enc := &excelizeEncoder{
f: excelize.NewFile(),
w: w,
ff: ff,
ff: preprocessHeader(ff, tz),
u: u,
tz: tz,
}
if header {

107
compose/encoder/record.go
View File

@@ -8,15 +8,44 @@ import (
"github.com/cortezaproject/corteza-server/compose/types"
)
type (
parsedTime struct {
field string
value string
}
)
// Time formatter
//
// Takes ptr to time.Time so we can conver both cases (value + ptr)
func fmtTime(tp *time.Time) string {
// The function also generates additional fields with included timezone.
func fmtTime(field string, tp *time.Time, tz string) (pt []*parsedTime, err error) {
if tp == nil {
return ""
return pt, nil
}
return tp.UTC().Format(time.RFC3339)
pt = append(pt, &parsedTime{
field: field,
value: tp.UTC().Format(time.RFC3339),
})
if tz == "" || tz == "UTC" {
return
}
loc, err := time.LoadLocation(tz)
if err != nil {
return pt, err
}
tt := tp.In(loc)
pt = append(pt,
&parsedTime{
field: field + "_date",
value: tt.Format("2006-01-02"),
}, &parsedTime{
field: field + "_time",
value: tt.Format("15:04:05"),
})
return
}
func fmtUint64(u uint64) string {
@@ -49,6 +78,12 @@ func fmtSysUser(u uint64, finder userFinder) (string, error) {
func (enc flatWriter) Record(r *types.Record) (err error) {
var out = make([]string, len(enc.ff))
procTime := func(d []string, pts []*parsedTime, base int) {
for i, p := range pts {
d[base+i] = p.value
}
}
for f, field := range enc.ff {
switch field.name {
case "recordID", "ID":
@@ -68,21 +103,33 @@ func (enc flatWriter) Record(r *types.Record) (err error) {
return err
}
case "createdAt":
out[f] = fmtTime(&r.CreatedAt)
tt, err := fmtTime("createdAt", &r.CreatedAt, enc.tz)
if err != nil {
return err
}
procTime(out, tt, f)
case "updatedBy":
out[f], err = fmtSysUser(r.UpdatedBy, enc.u)
if err != nil {
return err
}
case "updatedAt":
out[f] = fmtTime(r.UpdatedAt)
tt, err := fmtTime("updatedAt", r.UpdatedAt, enc.tz)
if err != nil {
return err
}
procTime(out, tt, f)
case "deletedBy":
out[f], err = fmtSysUser(r.DeletedBy, enc.u)
if err != nil {
return err
}
case "deletedAt":
out[f] = fmtTime(r.DeletedAt)
tt, err := fmtTime("deletedAt", r.DeletedAt, enc.tz)
if err != nil {
return err
}
procTime(out, tt, f)
default:
vv := r.Values.FilterByName(field.name)
// @todo support for field.encodeAllMulti
@@ -106,6 +153,12 @@ func (enc structuredEncoder) Record(r *types.Record) (err error) {
c int
)
procTime := func(d map[string]interface{}, pts []*parsedTime) {
for _, p := range pts {
d[p.field] = p.value
}
}
for _, f := range enc.ff {
switch f.name {
case "recordID", "ID":
@@ -128,7 +181,11 @@ func (enc structuredEncoder) Record(r *types.Record) (err error) {
return err
}
case "createdAt":
out[f.name] = fmtTime(&r.CreatedAt)
tt, err := fmtTime("createdAt", &r.CreatedAt, enc.tz)
if err != nil {
return err
}
procTime(out, tt)
case "updatedBy":
out[f.name], err = fmtSysUser(r.UpdatedBy, enc.u)
if err != nil {
@@ -138,7 +195,11 @@ func (enc structuredEncoder) Record(r *types.Record) (err error) {
if r.UpdatedAt == nil {
out[f.name] = nil
} else {
out[f.name] = fmtTime(r.UpdatedAt)
tt, err := fmtTime("updatedAt", r.UpdatedAt, enc.tz)
if err != nil {
return err
}
procTime(out, tt)
}
case "deletedBy":
@@ -150,7 +211,11 @@ func (enc structuredEncoder) Record(r *types.Record) (err error) {
if r.DeletedAt == nil {
out[f.name] = nil
} else {
out[f.name] = fmtTime(r.DeletedAt)
tt, err := fmtTime("deletedAt", r.DeletedAt, enc.tz)
if err != nil {
return err
}
procTime(out, tt)
}
default:
@@ -182,6 +247,12 @@ func (enc *excelizeEncoder) Record(r *types.Record) (err error) {
enc.row++
var u string
procTime := func(pts []*parsedTime, base int) {
for i, p := range pts {
_ = enc.f.SetCellStr(enc.sheet(), enc.pos(base+i), p.value)
}
}
for p, f := range enc.ff {
p++
switch f.name {
@@ -204,7 +275,11 @@ func (enc *excelizeEncoder) Record(r *types.Record) (err error) {
}
_ = enc.f.SetCellStr(enc.sheet(), enc.pos(p), u)
case "createdAt":
_ = enc.f.SetCellStr(enc.sheet(), enc.pos(p), fmtTime(&r.CreatedAt))
tt, err := fmtTime("createdAt", &r.CreatedAt, enc.tz)
if err != nil {
return err
}
procTime(tt, p)
case "updatedBy":
u, err = fmtSysUser(r.UpdatedBy, enc.u)
if err != nil {
@@ -212,7 +287,11 @@ func (enc *excelizeEncoder) Record(r *types.Record) (err error) {
}
_ = enc.f.SetCellStr(enc.sheet(), enc.pos(p), u)
case "updatedAt":
_ = enc.f.SetCellStr(enc.sheet(), enc.pos(p), fmtTime(r.UpdatedAt))
tt, err := fmtTime("updatedAt", r.UpdatedAt, enc.tz)
if err != nil {
return err
}
procTime(tt, p)
case "deletedBy":
u, err = fmtSysUser(r.DeletedBy, enc.u)
if err != nil {
@@ -220,7 +299,11 @@ func (enc *excelizeEncoder) Record(r *types.Record) (err error) {
}
_ = enc.f.SetCellStr(enc.sheet(), enc.pos(p), u)
case "deletedAt":
_ = enc.f.SetCellStr(enc.sheet(), enc.pos(p), fmtTime(r.DeletedAt))
tt, err := fmtTime("deletedAt", r.DeletedAt, enc.tz)
if err != nil {
return err
}
procTime(tt, p)
default:
vv := r.Values.FilterByName(f.name)
if len(vv) > 0 {

6
compose/rest/record.go
View File

@@ -441,15 +441,15 @@ func (ctrl *Record) Export(ctx context.Context, r *request.RecordExport) (interf
switch strings.ToLower(r.Ext) {
case "json", "jsonl", "ldjson", "ndjson":
contentType = "application/jsonl"
recordEncoder = encoder.NewStructuredEncoder(json.NewEncoder(w), uf, ff...)
recordEncoder = encoder.NewStructuredEncoder(json.NewEncoder(w), uf, r.Timezone, ff...)
case "csv":
contentType = "text/csv"
recordEncoder = encoder.NewFlatWriter(csv.NewWriter(w), true, uf, ff...)
recordEncoder = encoder.NewFlatWriter(csv.NewWriter(w), true, uf, r.Timezone, ff...)
case "xlsx":
contentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
recordEncoder = encoder.NewExcelizeEncoder(w, true, uf, ff...)
recordEncoder = encoder.NewExcelizeEncoder(w, true, uf, r.Timezone, ff...)
default:
http.Error(w, "unsupported format ("+r.Ext+")", http.StatusBadRequest)

25
compose/rest/request/record.go
View File

@@ -529,6 +529,10 @@ type RecordExport struct {
rawFields []string
Fields []string
hasTimezone bool
rawTimezone string
Timezone string
hasFilename bool
rawFilename string
Filename string
@@ -557,6 +561,7 @@ func (r RecordExport) Auditable() map[string]interface{} {
out["filter"] = r.Filter
out["fields"] = r.Fields
out["timezone"] = r.Timezone
out["filename"] = r.Filename
out["ext"] = r.Ext
out["namespaceID"] = r.NamespaceID
@@ -609,6 +614,11 @@ func (r *RecordExport) Fill(req *http.Request) (err error) {
r.Fields = parseStrings(val)
}
if val, ok := get["timezone"]; ok {
r.hasTimezone = true
r.rawTimezone = val
r.Timezone = val
}
r.hasFilename = true
r.rawFilename = chi.URLParam(req, "filename")
r.Filename = chi.URLParam(req, "filename")
@@ -1783,6 +1793,21 @@ func (r *RecordExport) GetFields() []string {
return r.Fields
}
// HasTimezone returns true if timezone was set
func (r *RecordExport) HasTimezone() bool {
return r.hasTimezone
}
// RawTimezone returns raw value of timezone parameter
func (r *RecordExport) RawTimezone() string {
return r.rawTimezone
}
// GetTimezone returns casted value of timezone parameter
func (r *RecordExport) GetTimezone() string {
return r.Timezone
}
// HasFilename returns true if filename was set
func (r *RecordExport) HasFilename() bool {
return r.hasFilename