martin/dash
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add Plan page with day planner

Browse Source
This commit is contained in:
Martin Pander
2022-11-26 18:41:39 +01:00
parent d9b92ab4e9
commit 32346e0aa9
48 changed files with 2400 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
backend/mapping/mapper.go
View File

@ -2,13 +2,20 @@ package mapping
import (
"time"
// api "github.com/moustachioed/dash/backend/dashapi"
// db "github.com/moustachioed/dash/backend/database/models"
)
type Mapper interface {
JournalApiToDb(api interface{}) (db interface{})
JournalDbToApi(db interface{}) (api interface{})
JournalApiToDs(api interface{}) (db interface{})
JournalDsToApi(db interface{}) (api interface{})
PlanDayApiToDs(api interface{}) (db interface{})
PlanDayDsToApi(db interface{}) (api interface{})
PlanWeekApiToDs(api interface{}) (db interface{})
PlanWeekDsToApi(db interface{}) (api interface{})
PlanMonthApiToDs(api interface{}) (db interface{})
PlanMonthDsToApi(db interface{}) (api interface{})
StringToDate(string) (time.Time, error)
DateToString(time.Time) string

139
backend/mapping/mapperImpl.go
View File

@ -17,9 +17,9 @@ func NewMapperImpl() Mapper {
return MapperImpl{}
}
func (mapper MapperImpl) JournalApiToDb(am interface{}) interface{} {
func (mapper MapperImpl) JournalApiToDs(am interface{}) interface{} {
apimodel := am.(api.JournalEntry)
date, err := time.Parse("2006-01-02", apimodel.Date)
date, err := mapper.StringToDate(apimodel.Date)
if err != nil {
log.Printf("[ERROR] Could not parse date `%s`", apimodel.Date)
}
@ -54,7 +54,7 @@ func (mapper MapperImpl) JournalApiToDb(am interface{}) interface{} {
}
}
func (mapper MapperImpl) JournalDbToApi(dm interface{}) interface{} {
func (mapper MapperImpl) JournalDsToApi(dm interface{}) interface{} {
dbmodel := dm.(db.Journal)
dateValue, err := dbmodel.Date.Value()
@ -62,7 +62,8 @@ func (mapper MapperImpl) JournalDbToApi(dm interface{}) interface{} {
if err != nil {
date = ""
} else {
date = dateValue.(time.Time).Format("2006-01-02")
// date = dateValue.(time.Time).Format("2006-01-02")
date = mapper.DateToString(dateValue.(time.Time))
}
var thankful []string
@ -74,19 +75,19 @@ func (mapper MapperImpl) JournalDbToApi(dm interface{}) interface{} {
var lookingForward []string
err = json.Unmarshal(dbmodel.LookingForward, &lookingForward)
if err != nil {
thankful = nil
lookingForward = nil
}
var beenGreat []string
err = json.Unmarshal(dbmodel.BeenGreat, &beenGreat)
if err != nil {
thankful = nil
beenGreat = nil
}
var doBetter []string
err = json.Unmarshal(dbmodel.DoBetter, &doBetter)
if err != nil {
thankful = nil
doBetter = nil
}
return api.JournalEntry{
@ -99,11 +100,133 @@ func (mapper MapperImpl) JournalDbToApi(dm interface{}) interface{} {
}
}
func (mapper MapperImpl) PlanDayApiToDs(am interface{}) interface{} {
apimodel := am.(api.PlanDay)
date, err := mapper.StringToDate(apimodel.Date)
if err != nil {
log.Printf("[ERROR] Could not parse date `%s`", apimodel.Date)
}
morning, err := json.Marshal(apimodel.Morning)
if err != nil {
morning = nil
}
midday, err := json.Marshal(apimodel.Midday)
if err != nil {
midday = nil
}
afternoon, err := json.Marshal(apimodel.Afternoon)
if err != nil {
afternoon = nil
}
evening, err := json.Marshal(apimodel.Evening)
if err != nil {
evening = nil
}
pleasant, err := json.Marshal(apimodel.Pleasant)
if err != nil {
pleasant = nil
}
reminders, err := json.Marshal(apimodel.Reminders)
if err != nil {
reminders = nil
}
return db.PlanDay{
Date: datatypes.Date(date),
Morning: datatypes.JSON(morning),
Midday: datatypes.JSON(midday),
Afternoon: datatypes.JSON(afternoon),
Evening: datatypes.JSON(evening),
Pleasant: datatypes.JSON(pleasant),
Reminders: datatypes.JSON(reminders),
}
}
func (mapper MapperImpl) PlanDayDsToApi(dm interface{}) interface{} {
dbmodel := dm.(db.PlanDay)
dateValue, err := dbmodel.Date.Value()
var date string
if err != nil {
date = ""
} else {
date = mapper.DateToString(dateValue.(time.Time))
}
var morning []string
err = json.Unmarshal(dbmodel.Morning, &morning)
if err != nil {
morning = nil
}
var midday []string
err = json.Unmarshal(dbmodel.Midday, &midday)
if err != nil {
midday = nil
}
var afternoon []string
err = json.Unmarshal(dbmodel.Afternoon, &afternoon)
if err != nil {
afternoon = nil
}
var evening []string
err = json.Unmarshal(dbmodel.Evening, &evening)
if err != nil {
evening = nil
}
var pleasant []string
err = json.Unmarshal(dbmodel.Pleasant, &pleasant)
if err != nil {
pleasant = nil
}
var reminders []string
err = json.Unmarshal(dbmodel.Reminders, &reminders)
if err != nil {
reminders = nil
}
return api.PlanDay{
Date: date,
Morning: morning,
Midday: midday,
Afternoon: afternoon,
Evening: evening,
Pleasant: pleasant,
Reminders: reminders,
}
}
func (mapper MapperImpl) PlanWeekApiToDs(api interface{}) (db interface{}) {
return new(interface{})
}
func (mapper MapperImpl) PlanWeekDsToApi(api interface{}) (db interface{}) {
return new(interface{})
}
func (mapper MapperImpl) PlanMonthApiToDs(api interface{}) (db interface{}) {
return new(interface{})
}
func (mapper MapperImpl) PlanMonthDsToApi(api interface{}) (db interface{}) {
return new(interface{})
}
func (mapper MapperImpl) StringToDate(dateString string) (time.Time, error) {
date, err := time.Parse("2006-01-02", dateString)
if err != nil {
log.Printf("[ERROR] Could not parse date string %s", dateString)
return time.Now(), err
return time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC), err
}
return date, nil
}

235
backend/mapping/mapperImpl_test.go
View File

@ -2,6 +2,7 @@ package mapping
import (
"encoding/json"
"reflect"
"testing"
"time"
@ -22,7 +23,7 @@ func TestJournalApiToDbFullObject(t *testing.T) {
Journal: "jtest",
}
db := mapper.JournalApiToDb(api).(models.Journal)
db := mapper.JournalApiToDs(api).(models.Journal)
gotDate, _ := db.Date.Value()
got := gotDate.(time.Time).Format("2006-01-02")
@ -80,7 +81,7 @@ func TestJournalApiToDbPartialObject(t *testing.T) {
Journal: "",
}
db := mapper.JournalApiToDb(api).(models.Journal)
db := mapper.JournalApiToDs(api).(models.Journal)
gotDate, _ := db.Date.Value()
got := gotDate.(time.Time).Format("2006-01-02")
@ -145,7 +146,7 @@ func TestJournalDbToApiFullObject(t *testing.T) {
Journal: journal,
}
api := mapper.JournalDbToApi(db).(dashapi.JournalEntry)
api := mapper.JournalDsToApi(db).(dashapi.JournalEntry)
got, _ := json.Marshal(api.Date)
wantDate := "\"2022-02-18\""
@ -209,7 +210,7 @@ func TestJournalDbToApiPartialObject(t *testing.T) {
Journal: journal,
}
api := mapper.JournalDbToApi(db).(dashapi.JournalEntry)
api := mapper.JournalDsToApi(db).(dashapi.JournalEntry)
got, _ := json.Marshal(api.Date)
wantDate := "\"2022-02-18\""
@ -253,3 +254,229 @@ func TestJournalDbToApiPartialObject(t *testing.T) {
t.Errorf("Mapped string %s not equal want string %s", gotJournal, wantJournal)
}
}
func TestMapperImpl_PlanDayApiToDs(t *testing.T) {
date, _ := time.Parse("2006-01-02", "2022-02-18")
morning, _ := json.Marshal([]string{"motest1", "motest2", "motest3"})
midday, _ := json.Marshal([]string{"mitest1", "mitest2", "mitest3"})
afternoon, _ := json.Marshal([]string{"antest1", "antest2", "antest3"})
evening, _ := json.Marshal([]string{"etest1", "etest2", "etest3"})
pleasant, _ := json.Marshal([]string{"ptest1", "ptest2", "ptest3"})
reminders, _ := json.Marshal([]string{"rtest1", "rtest2", "rtest3"})
empty, _ := json.Marshal(nil)
type args struct {
am interface{}
}
tests := []struct {
name string
mapper MapperImpl
args args
want interface{}
}{
{
name: "Full Object",
mapper: MapperImpl{},
args: args{
am: dashapi.PlanDay{
Date: "2022-02-18",
Morning: []string{"motest1", "motest2", "motest3"},
Midday: []string{"mitest1", "mitest2", "mitest3"},
Afternoon: []string{"antest1", "antest2", "antest3"},
Evening: []string{"etest1", "etest2", "etest3"},
Pleasant: []string{"ptest1", "ptest2", "ptest3"},
Reminders: []string{"rtest1", "rtest2", "rtest3"},
}},
want: models.PlanDay{
Date: datatypes.Date(date),
Morning: datatypes.JSON(morning),
Midday: datatypes.JSON(midday),
Afternoon: datatypes.JSON(afternoon),
Evening: datatypes.JSON(evening),
Pleasant: datatypes.JSON(pleasant),
Reminders: datatypes.JSON(reminders),
},
},
{
name: "Partial Object",
mapper: MapperImpl{},
args: args{
am: dashapi.PlanDay{
Date: "2022-02-18",
Morning: []string{"motest1", "motest2", "motest3"},
Midday: nil,
Afternoon: nil,
Evening: nil,
Pleasant: []string{"ptest1", "ptest2", "ptest3"},
Reminders: nil,
}},
want: models.PlanDay{
Date: datatypes.Date(date),
Morning: datatypes.JSON(morning),
Midday: datatypes.JSON(empty),
Afternoon: datatypes.JSON(empty),
Evening: datatypes.JSON(empty),
Pleasant: datatypes.JSON(pleasant),
Reminders: datatypes.JSON(empty),
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
mapper := MapperImpl{}
if got := mapper.PlanDayApiToDs(tt.args.am); !reflect.DeepEqual(got, tt.want) {
t.Errorf("MapperImpl.PlanDayApiToDs() = %v, want %v", got, tt.want)
}
})
}
}
func TestMapperImpl_PlanDayDsToApi(t *testing.T) {
date, _ := time.Parse("2006-01-02", "2022-02-18")
morning, _ := json.Marshal([]string{"motest1", "motest2", "motest3"})
midday, _ := json.Marshal([]string{"mitest1", "mitest2", "mitest3"})
afternoon, _ := json.Marshal([]string{"antest1", "antest2", "antest3"})
evening, _ := json.Marshal([]string{"etest1", "etest2", "etest3"})
pleasant, _ := json.Marshal([]string{"ptest1", "ptest2", "ptest3"})
reminders, _ := json.Marshal([]string{"rtest1", "rtest2", "rtest3"})
empty, _ := json.Marshal(nil)
type args struct {
dm interface{}
}
tests := []struct {
name string
mapper MapperImpl
args args
want interface{}
}{
{
name: "Full Object",
mapper: MapperImpl{},
args: args{
dm: models.PlanDay{
Date: datatypes.Date(date),
Morning: datatypes.JSON(morning),
Midday: datatypes.JSON(midday),
Afternoon: datatypes.JSON(afternoon),
Evening: datatypes.JSON(evening),
Pleasant: datatypes.JSON(pleasant),
Reminders: datatypes.JSON(reminders),
}},
want: dashapi.PlanDay{
Date: "2022-02-18",
Morning: []string{"motest1", "motest2", "motest3"},
Midday: []string{"mitest1", "mitest2", "mitest3"},
Afternoon: []string{"antest1", "antest2", "antest3"},
Evening: []string{"etest1", "etest2", "etest3"},
Pleasant: []string{"ptest1", "ptest2", "ptest3"},
Reminders: []string{"rtest1", "rtest2", "rtest3"},
},
},
{
name: "Partial Object",
mapper: MapperImpl{},
args: args{
dm: models.PlanDay{
Date: datatypes.Date(date),
Morning: datatypes.JSON(morning),
Midday: datatypes.JSON(empty),
Afternoon: datatypes.JSON(afternoon),
Evening: datatypes.JSON(empty),
Pleasant: datatypes.JSON(pleasant),
Reminders: datatypes.JSON(empty),
}},
want: dashapi.PlanDay{
Date: "2022-02-18",
Morning: []string{"motest1", "motest2", "motest3"},
Midday: nil,
Afternoon: []string{"antest1", "antest2", "antest3"},
Evening: nil,
Pleasant: []string{"ptest1", "ptest2", "ptest3"},
Reminders: nil,
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
mapper := MapperImpl{}
if got := mapper.PlanDayDsToApi(tt.args.dm); !reflect.DeepEqual(got, tt.want) {
t.Errorf("MapperImpl.PlanDayDsToApi() = %v, want %v", got, tt.want)
}
})
}
}
func TestMapperImpl_StringToDate(t *testing.T) {
type args struct {
dateString string
}
tests := []struct {
name string
mapper MapperImpl
args args
want time.Time
wantErr bool
}{
{
name: "Well-formed date",
mapper: MapperImpl{},
args: args{
dateString: "1987-02-18",
},
want: time.Date(1987, 2, 18, 0, 0, 0, 0, time.UTC),
wantErr: false,
},
{
name: "False string",
mapper: MapperImpl{},
args: args{
dateString: "1987-02-18'T'13:02:18",
},
want: time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC),
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
mapper := MapperImpl{}
got, err := mapper.StringToDate(tt.args.dateString)
if (err != nil) != tt.wantErr {
t.Errorf("MapperImpl.StringToDate() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("MapperImpl.StringToDate() = %v, want %v", got, tt.want)
}
})
}
}
func TestMapperImpl_DateToString(t *testing.T) {
type args struct {
date time.Time
}
tests := []struct {
name string
mapper MapperImpl
args args
want string
}{
{
name: "Well-formed date",
mapper: MapperImpl{},
args: args{
date: time.Date(1987, 2, 18, 0, 0, 0, 0, time.UTC),
},
want: "1987-02-18",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
mapper := MapperImpl{}
if got := mapper.DateToString(tt.args.date); got != tt.want {
t.Errorf("MapperImpl.DateToString() = %v, want %v", got, tt.want)
}
})
}
}