From f721b32e016e6d8a09939f06c97bad2e0f67d134 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E2=98=99=E2=97=A6=20The=20Tablet=20=E2=9D=80=20GamerGirla?= =?UTF-8?q?ndCo=20=E2=97=A6=E2=9D=A7?= Date: Tue, 3 Sep 2024 00:14:12 -0400 Subject: [PATCH] refactor some things, add Delete method, improve Save method --- go.work | 1 + model.go | 121 ++++++++++++++++++++++++++++++++++++-------------- model_test.go | 55 ++++++++++++----------- testing.go | 43 ++++++++++++++---- util.go | 10 +---- 5 files changed, 152 insertions(+), 78 deletions(-) diff --git a/go.work b/go.work index 784f04a..1bcb465 100644 --- a/go.work +++ b/go.work @@ -1,3 +1,4 @@ go 1.23.0 use . +use muck \ No newline at end of file diff --git a/model.go b/model.go index 3a28c95..d304d07 100644 --- a/model.go +++ b/model.go @@ -24,6 +24,22 @@ type Model struct { exists bool `bson:"-"` } +func (m *Model) getCreated() time.Time { + return m.Created +} + +func (m *Model) setCreated(Created time.Time) { + m.Created = Created +} + +func (m *Model) getModified() time.Time { + return m.Modified +} + +func (m *Model) setModified(Modified time.Time) { + m.Modified = Modified +} + // HasID is a simple interface that you must implement // in your models, using a pointer receiver. // This allows for more flexibility in cases where @@ -34,9 +50,11 @@ type HasID interface { Id() any SetId(id any) } + type HasIDSlice []HasID type IModel interface { + Append(field string, a ...interface{}) error Find(query interface{}, opts ...*options.FindOptions) (*mongo.Cursor, error) FindAll(query interface{}, opts ...*options.FindOptions) (*Query, error) FindByID(id interface{}) (*Query, error) @@ -50,12 +68,21 @@ type IModel interface { setTypeName(str string) getExists() bool setExists(n bool) + setModified(Modified time.Time) + setCreated(Modified time.Time) + getModified() time.Time + getCreated() time.Time + setSelf(arg interface{}) } func (m *Model) setTypeName(str string) { m.typeName = str } +func (m *Model) setSelf(arg interface{}) { + m.self = arg +} + func (m *Model) getExists() bool { return m.exists } @@ -169,22 +196,32 @@ func (m *Model) FindOne(query interface{}, options ...*options.FindOneOptions) ( m.self = qq.doc return qq, err } +func doDelete(m *Model, arg interface{}) error { + self, ok := arg.(HasID) -func (m *Model) DeleteOne() error { - c := m.getColl() - if valueOf(m.self).Kind() == reflect.Slice { - } - id, ok := m.self.(HasID) if !ok { - id2, ok2 := m.self.(HasIDSlice) - if !ok2 { - return fmt.Errorf("model '%s' is not registered", m.typeName) + return fmt.Errorf("Object '%s' does not implement HasID", nameOf(arg)) + } + c := m.getColl() + _, err := c.DeleteOne(context.TODO(), bson.M{"_id": self.Id()}) + if err == nil { + m.exists = false + } + return err +} +func (m *Model) Delete() error { + var err error + val := valueOf(m.self) + if val.Kind() == reflect.Slice { + for i := 0; i < val.Len(); i++ { + cur := val.Index(i) + if err = doDelete(m, cur.Interface()); err != nil { + return err + } } - _, err := c.DeleteOne(context.TODO(), bson.M{"_id": id2[0].Id()}) - return err + return nil } else { - _, err := c.DeleteOne(context.TODO(), bson.M{"_id": id.Id()}) - return err + return doDelete(m, m.self) } } @@ -194,24 +231,24 @@ func (m *Model) DeleteOne() error { // slice. func (m *Model) Append(field string, a ...interface{}) error { rv := reflect.ValueOf(m.self) - ref := rv + selfRef := rv rt := reflect.TypeOf(m.self) - if ref.Kind() == reflect.Pointer { - ref = ref.Elem() + if selfRef.Kind() == reflect.Pointer { + selfRef = selfRef.Elem() rt = rt.Elem() } - if ref.Kind() == reflect.Slice { + if selfRef.Kind() == reflect.Slice { return fmt.Errorf("Cannot append to multiple documents!") } - if ref.Kind() != reflect.Struct { + if selfRef.Kind() != reflect.Struct { return fmt.Errorf("Current object is not a struct!") } - _, ofv, err := getNested(field, ref) + _, origV, err := getNested(field, selfRef) if err != nil { return err } - oofv := makeSettable(*ofv, (*ofv).Interface()) - fv := oofv + origRef := makeSettable(*origV, (*origV).Interface()) + fv := origRef if fv.Kind() == reflect.Pointer { fv = fv.Elem() } @@ -220,29 +257,31 @@ func (m *Model) Append(field string, a ...interface{}) error { } for _, b := range a { - va := reflect.ValueOf(b) - fv.Set(reflect.Append(fv, va)) + val := reflect.ValueOf(b) + fv.Set(reflect.Append(fv, val)) } return nil } -func (m *Model) Save() error { +func doSave(c *mongo.Collection, isNew bool, arg interface{}) error { var err error - c := m.getColl() + m, ok := arg.(IModel) + if !ok { + return fmt.Errorf("type '%s' is not a model", nameOf(arg)) + } + m.setSelf(m) now := time.Now() - selfo := reflect.ValueOf(m.self) + selfo := reflect.ValueOf(m) vp := selfo if vp.Kind() != reflect.Ptr { vp = reflect.New(selfo.Type()) vp.Elem().Set(selfo) } var asHasId = vp.Interface().(HasID) - (asHasId).Id() - isNew := reflect.ValueOf(asHasId.Id()).IsZero() && !m.exists - if isNew || !m.exists { - m.Created = now + if isNew { + m.setCreated(now) } - m.Modified = now + m.setModified(now) idxs := m.getIdxs() for _, i := range idxs { _, err = c.Indexes().CreateOne(context.TODO(), *i) @@ -250,7 +289,7 @@ func (m *Model) Save() error { return err } } - if isNew || !m.exists { + if isNew { nid := getLastInColl(c.Name(), asHasId.Id()) switch pnid := nid.(type) { case uint: @@ -276,17 +315,31 @@ func (m *Model) Save() error { (asHasId).SetId(nid) } - m.self = asHasId _, err = c.InsertOne(context.TODO(), m.serializeToStore()) if err == nil { - m.exists = true + m.setExists(true) } } else { - _, err = c.ReplaceOne(context.TODO(), bson.D{{Key: "_id", Value: m.self.(HasID).Id()}}, m.serializeToStore()) + _, err = c.ReplaceOne(context.TODO(), bson.D{{Key: "_id", Value: m.(HasID).Id()}}, m.serializeToStore()) } return err } +func (m *Model) Save() error { + val := valueOf(m.self) + if val.Kind() == reflect.Slice { + for i := 0; i < val.Len(); i++ { + cur := val.Index(i) + if err := doSave(m.getColl(), !m.exists, cur.Interface()); err != nil { + return err + } + } + return nil + } else { + return doSave(m.getColl(), !m.exists, m.self) + } +} + func (m *Model) serializeToStore() bson.M { return serializeIDs((*m).self) } diff --git a/model_test.go b/model_test.go index 328ff62..4611b68 100644 --- a/model_test.go +++ b/model_test.go @@ -36,13 +36,11 @@ func TestPopulate(t *testing.T) { bandDoc := Create(iti_single.Chapters[0].Bands[0]).(*band) storyDoc := Create(iti_single).(*story) - author := Create(author).(*user) - - err := bandDoc.Save() - assert.Equal(t, nil, err) - storyDoc.Author = author - err = storyDoc.Save() - assert.Equal(t, nil, err) + mauthor := Create(author).(*user) + saveDoc(t, mauthor) + saveDoc(t, bandDoc) + storyDoc.Author = mauthor + saveDoc(t, storyDoc) assert.Greater(t, storyDoc.ID, int64(0)) smodel := Create(story{}).(*story) @@ -54,32 +52,21 @@ func TestPopulate(t *testing.T) { j, _ := q.JSON() fmt.Printf("%s\n", j) }) + assert.NotZero(t, storyDoc.Chapters[0].Bands[0].Name) } func TestUpdate(t *testing.T) { initTest() - nb := Create(band{ - ID: 1, - Name: "Metallica", - Characters: []string{ - "James Hetfield", - "Lars Ulrich", - "Kirk Hammett", - "Cliff Burton", - }, - Locked: false, - }).(*band) - err := nb.Save() - assert.Equal(t, nil, err) + nb := Create(metallica).(*band) + saveDoc(t, nb) nb.Locked = true - err = nb.Save() - assert.Equal(t, nil, err) + saveDoc(t, nb) foundM := Create(band{}).(*band) q, err := foundM.FindByID(int64(1)) + assert.Equal(t, nil, err) found := &band{} q.Exec(found) - assert.Equal(t, nil, err) assert.Equal(t, int64(1), found.ID) assert.Equal(t, nil, err) assert.Equal(t, true, found.Locked) @@ -87,6 +74,7 @@ func TestUpdate(t *testing.T) { func TestModel_FindAll(t *testing.T) { initTest() + createAndSave(t, &iti_multi) smodel := Create(story{}).(*story) query, err := smodel.FindAll(bson.M{}, options.Find()) assert.Equal(t, nil, err) @@ -97,30 +85,43 @@ func TestModel_FindAll(t *testing.T) { func TestModel_PopulateMulti(t *testing.T) { initTest() + bandDoc := Create(iti_single.Chapters[0].Bands[0]).(*band) + saveDoc(t, bandDoc) + createAndSave(t, &iti_multi) smodel := Create(story{}).(*story) query, err := smodel.FindAll(bson.M{}, options.Find()) assert.Equal(t, nil, err) final := make([]story, 0) query.Populate("Author", "Chapters.Bands").Exec(&final) assert.Greater(t, len(final), 0) + for _, s := range final { + assert.NotZero(t, s.Chapters[0].Bands[0].Name) + } } func TestModel_Append(t *testing.T) { initTest() + bandDoc := Create(metallica).(*band) + saveDoc(t, bandDoc) bmodel := Create(band{}).(*band) query, err := bmodel.FindByID(int64(1)) assert.Equal(t, nil, err) fin := &band{} query.Exec(fin) assert.Greater(t, fin.ID, int64(0)) - err = bmodel.Append("Characters", "Robert Trujillo") assert.Equal(t, nil, err) - err = bmodel.Save() - assert.Equal(t, nil, err) + saveDoc(t, bmodel) fin = &band{} query, _ = bmodel.FindByID(int64(1)) query.Exec(fin) assert.Greater(t, len(fin.Characters), 4) - +} + +func TestModel_Delete(t *testing.T) { + initTest() + bandDoc := Create(metallica).(*band) + saveDoc(t, bandDoc) + err := bandDoc.Delete() + assert.Nil(t, err) } diff --git a/testing.go b/testing.go index ef8f83e..818c4da 100644 --- a/testing.go +++ b/testing.go @@ -3,6 +3,8 @@ package orm import ( "context" "fmt" + "github.com/stretchr/testify/assert" + "testing" "time" "github.com/go-loremipsum/loremipsum" @@ -15,7 +17,7 @@ import ( type chapter struct { ID primitive.ObjectID `bson:"_id" json:"_id"` Title string `bson:"chapterTitle" json:"chapterTitle" form:"chapterTitle"` - ChapterID int `bson:"id" json:"chapterID"` + ChapterID int `bson:"id" json:"chapterID" autoinc:"chapters"` Index int `bson:"index" json:"index" form:"index"` Words int `bson:"words" json:"words"` Notes string `bson:"notes" json:"notes" form:"notes"` @@ -112,12 +114,7 @@ func genChaps(single bool) []chapter { {"Sean Harris", "Colin Kimberley", "Brian Tatler"}, }, } - var b band = band{ - Name: "Diamond Head", - Locked: false, - Characters: []string{"Brian Tatler", "Sean Harris", "Duncan Scott", "Colin Kimberley"}, - } - b.ID = 503 + for i := 0; i < ceil; i++ { spf := fmt.Sprintf("%d.md", i+1) ret = append(ret, chapter{ @@ -126,7 +123,7 @@ func genChaps(single bool) []chapter { Words: 50, Notes: "notenotenote !!!", Genre: []string{"Slash"}, - Bands: []band{b}, + Bands: []band{dh}, Characters: []string{"Sean Harris", "Brian Tatler", "Duncan Scott", "Colin Kimberley"}, Relationships: relMap[i], Adult: true, @@ -156,6 +153,7 @@ func initTest() { uri := "mongodb://127.0.0.1:27017" db := "rockfic_ormTest" ic, _ := mongo.Connect(context.TODO(), options.Client().ApplyURI(uri)) + ic.Database(db).Drop(context.TODO()) colls, _ := ic.Database(db).ListCollectionNames(context.TODO(), bson.M{}) if len(colls) < 1 { mdb := ic.Database(db) @@ -172,3 +170,32 @@ func after() { err := DBClient.Disconnect(context.TODO()) panik(err) } + +var metallica = band{ + ID: 1, + Name: "Metallica", + Characters: []string{ + "James Hetfield", + "Lars Ulrich", + "Kirk Hammett", + "Cliff Burton", + }, + Locked: false, +} + +var dh = band{ + ID: 503, + Name: "Diamond Head", + Locked: false, + Characters: []string{"Brian Tatler", "Sean Harris", "Duncan Scott", "Colin Kimberley"}, +} + +func saveDoc(t *testing.T, doc IModel) { + err := doc.Save() + assert.Nil(t, err) +} + +func createAndSave(t *testing.T, doc IModel) { + mdl := Create(doc).(IModel) + saveDoc(t, mdl) +} diff --git a/util.go b/util.go index 9b9804f..6e77761 100644 --- a/util.go +++ b/util.go @@ -30,15 +30,7 @@ func nameOf(i interface{}) string { func valueOf(i interface{}) reflect.Value { v := reflect.ValueOf(i) - if v.Type().Kind() == reflect.Slice || v.Type().Kind() == reflect.Map { - in := v.Type().Elem() - switch in.Kind() { - case reflect.Pointer: - v = reflect.New(in.Elem()).Elem() - default: - v = reflect.New(in).Elem() - } - } else if v.Type().Kind() == reflect.Pointer { + if v.Type().Kind() == reflect.Pointer { v = valueOf(reflect.Indirect(v).Interface()) } return v