From 40d8683ba154b8c07ccc1f75e8928b776cef8d8c Mon Sep 17 00:00:00 2001 From: Mitja Zivkovic Date: Sat, 22 Dec 2018 21:54:08 +0100 Subject: [PATCH] Rename content to record on crm/service --- crm/service/content_util.go | 46 --------- crm/service/module_test.go | 2 +- crm/service/{content.go => record.go} | 48 +++++----- .../{content_test.go => record_test.go} | 96 +++++++++---------- crm/service/record_util.go | 46 +++++++++ crm/service/service.go | 4 +- 6 files changed, 121 insertions(+), 121 deletions(-) delete mode 100644 crm/service/content_util.go rename crm/service/{content.go => record.go} (58%) rename crm/service/{content_test.go => record_test.go} (70%) create mode 100644 crm/service/record_util.go diff --git a/crm/service/content_util.go b/crm/service/content_util.go deleted file mode 100644 index 6019b099d..000000000 --- a/crm/service/content_util.go +++ /dev/null @@ -1,46 +0,0 @@ -package service - -import ( - "encoding/json" - - "github.com/crusttech/crust/crm/types" -) - -func (r *content) preloadAll(contents []*types.Record, fields ...string) error { - for _, content := range contents { - if err := r.preload(content, fields...); err != nil { - return err - } - } - return nil -} - -func (r *content) preload(content *types.Record, fields ...string) (err error) { - for _, field := range fields { - switch field { - case "fields": - fields, err := r.Fields(content) - if err != nil { - return err - } - json, err := json.Marshal(fields) - if err != nil { - return err - } - if err := (&content.Fields).Scan(json); err != nil { - return err - } - case "page": - if content.Page, err = r.pageRepo.FindByModuleID(content.ModuleID); err != nil { - return - } - case "user": - if content.UserID > 0 { - if content.User, err = r.userSvc.FindByID(content.UserID); err != nil { - return - } - } - } - } - return -} diff --git a/crm/service/module_test.go b/crm/service/module_test.go index a79780e6f..21cb792dc 100644 --- a/crm/service/module_test.go +++ b/crm/service/module_test.go @@ -38,7 +38,7 @@ func TestModule(t *testing.T) { { { m, err := repository.Update(module) - assert(t, m == nil, "Expected empty return for ivalid update, got %#v", m) + assert(t, m == nil, "Expected empty return for invalid update, got %#v", m) assert(t, err != nil, "Expected error when updating invalid content") } diff --git a/crm/service/content.go b/crm/service/record.go similarity index 58% rename from crm/service/content.go rename to crm/service/record.go index bc070562a..2d4bacdfd 100644 --- a/crm/service/content.go +++ b/crm/service/record.go @@ -13,7 +13,7 @@ import ( ) type ( - content struct { + record struct { db *factory.DB ctx context.Context @@ -23,31 +23,31 @@ type ( userSvc systemService.UserService } - ContentService interface { - With(ctx context.Context) ContentService + RecordService interface { + With(ctx context.Context) RecordService - FindByID(contentID uint64) (*types.Record, error) + FindByID(recordID uint64) (*types.Record, error) Report(moduleID uint64, params *types.RecordReport) (interface{}, error) Find(moduleID uint64, query string, page int, perPage int, sort string) (*repository.FindResponse, error) - Create(content *types.Record) (*types.Record, error) - Update(content *types.Record) (*types.Record, error) - DeleteByID(contentID uint64) error + Create(record *types.Record) (*types.Record, error) + Update(record *types.Record) (*types.Record, error) + DeleteByID(recordID uint64) error Fields(mod *types.Record) ([]*types.RecordColumn, error) } ) -func Content() ContentService { - return (&content{ +func Record() RecordService { + return (&record{ userSvc: systemService.DefaultUser, }).With(context.Background()) } -func (s *content) With(ctx context.Context) ContentService { +func (s *record) With(ctx context.Context) RecordService { db := repository.DB(ctx) - return &content{ + return &record{ db: db, ctx: ctx, repository: repository.Content(ctx, db), @@ -56,7 +56,7 @@ func (s *content) With(ctx context.Context) ContentService { } } -func (s *content) FindByID(id uint64) (*types.Record, error) { +func (s *record) FindByID(id uint64) (*types.Record, error) { response, err := s.repository.FindByID(id) if err != nil { return nil, err @@ -64,11 +64,11 @@ func (s *content) FindByID(id uint64) (*types.Record, error) { return response, s.preload(response, "page", "user", "fields") } -func (s *content) Report(moduleID uint64, params *types.RecordReport) (interface{}, error) { +func (s *record) Report(moduleID uint64, params *types.RecordReport) (interface{}, error) { return s.repository.Report(moduleID, params) } -func (s *content) Find(moduleID uint64, query string, page int, perPage int, sort string) (*repository.FindResponse, error) { +func (s *record) Find(moduleID uint64, query string, page int, perPage int, sort string) (*repository.FindResponse, error) { response, err := s.repository.Find(moduleID, query, page, perPage, sort) if err != nil { return nil, err @@ -79,7 +79,7 @@ func (s *content) Find(moduleID uint64, query string, page int, perPage int, sor return response, nil } -func (s *content) Create(mod *types.Record) (*types.Record, error) { +func (s *record) Create(mod *types.Record) (*types.Record, error) { response, err := s.repository.Create(mod) if err != nil { return nil, err @@ -87,14 +87,14 @@ func (s *content) Create(mod *types.Record) (*types.Record, error) { return response, s.preload(response, "user", "fields") } -func (s *content) Update(content *types.Record) (c *types.Record, err error) { +func (s *record) Update(record *types.Record) (c *types.Record, err error) { validate := func() error { - if content.ID == 0 { - return errors.New("Error updating content: invalid ID") - } else if c, err = s.repository.FindByID(content.ID); err != nil { - return errors.Wrap(err, "Error while loading content for update") + if record.ID == 0 { + return errors.New("Error updating record: invalid ID") + } else if c, err = s.repository.FindByID(record.ID); err != nil { + return errors.Wrap(err, "Error while loading record for update") } else { - content.CreatedAt = c.CreatedAt + record.CreatedAt = c.CreatedAt } return nil @@ -105,15 +105,15 @@ func (s *content) Update(content *types.Record) (c *types.Record, err error) { } return c, s.db.Transaction(func() (err error) { - c, err = s.repository.Update(content) + c, err = s.repository.Update(record) return }) } -func (s *content) Fields(mod *types.Record) ([]*types.RecordColumn, error) { +func (s *record) Fields(mod *types.Record) ([]*types.RecordColumn, error) { return s.repository.Fields(mod) } -func (s *content) DeleteByID(id uint64) error { +func (s *record) DeleteByID(id uint64) error { return s.repository.DeleteByID(id) } diff --git a/crm/service/content_test.go b/crm/service/record_test.go similarity index 70% rename from crm/service/content_test.go rename to crm/service/record_test.go index 9cb250107..bd1b1eaf9 100644 --- a/crm/service/content_test.go +++ b/crm/service/record_test.go @@ -14,7 +14,7 @@ import ( systemTypes "github.com/crusttech/crust/system/types" ) -func TestContent(t *testing.T) { +func TestRecord(t *testing.T) { user := &systemTypes.User{ ID: 1337, Username: "TestUser", @@ -31,7 +31,7 @@ func TestContent(t *testing.T) { } ctx := auth.SetIdentityToContext(context.Background(), auth.NewIdentity(user.Identity())) - repository := Content().With(ctx) + repository := Record().With(ctx) module := &types.Module{ Name: "Test", @@ -81,10 +81,10 @@ func TestContent(t *testing.T) { }, } - content1 := &types.Record{ + record1 := &types.Record{ ModuleID: module.ID, } - (&content1.Fields).Scan(func() []byte { + (&record1.Fields).Scan(func() []byte { b, _ := json.Marshal(columns) return b }()) @@ -108,46 +108,46 @@ func TestContent(t *testing.T) { }, } - content2 := &types.Record{ + record2 := &types.Record{ ModuleID: module.ID, } - (&content2.Fields).Scan(func() []byte { + (&record2.Fields).Scan(func() []byte { b, _ := json.Marshal(columns2) return b }()) - // now work with content + // now work with records { { - m, err := repository.Update(content1) + m, err := repository.Update(record1) assert(t, m == nil, "Expected empty return for invalid update, got %#v", m) - assert(t, err != nil, "Expected error when updating invalid content") + assert(t, err != nil, "Expected error when updating invalid record") } - // create content - m1, err := repository.Create(content1) - assert(t, err == nil, "Error when creating content: %+v", err) + // create record + m1, err := repository.Create(record1) + assert(t, err == nil, "Error when creating record: %+v", err) assert(t, m1.ID > 0, "Expected auto generated ID") - assert(t, m1.User != nil, "Expected non-nil user when creating content") + assert(t, m1.User != nil, "Expected non-nil user when creating record") assert(t, m1.User.Username == "TestUser", "Expected 'TestUser' as username, got '%s'", m1.User.Username) - // create content - m2, err := repository.Create(content2) - assert(t, err == nil, "Error when creating content: %+v", err) + // create record + m2, err := repository.Create(record2) + assert(t, err == nil, "Error when creating record: %+v", err) assert(t, m2.ID > 0, "Expected auto generated ID") - assert(t, m2.User != nil, "Expected non-nil user when creating content") + assert(t, m2.User != nil, "Expected non-nil user when creating record") assert(t, m2.User.Username == "TestUser", "Expected 'TestUser' as username, got '%s'", m2.User.Username) - // fetch created content + // fetch created record { ms, err := repository.FindByID(m1.ID) - assert(t, err == nil, "Error when retrieving content by id: %+v", err) + assert(t, err == nil, "Error when retrieving record by id: %+v", err) assert(t, ms.ID == m1.ID, "Expected ID from database to match, %d != %d", m1.ID, ms.ID) assert(t, ms.ModuleID == m1.ModuleID, "Expected Module ID from database to match, %d != %d", m1.ModuleID, ms.ModuleID) { fields, err := repository.Fields(ms) - // fields := make([]testContentRow, 0) + // fields := make([]testRecordRow, 0) // err = json.Unmarshal(ms.Fields, &fields) assert(t, err == nil, "%+v", errors.Wrap(err, "Didn't expect error when unmarshalling")) assert(t, len(fields) == len(columns), "Expected different field count: %d != %d", 2, len(fields)) @@ -166,58 +166,58 @@ func TestContent(t *testing.T) { } } - // update created content + // update created record { _, err := repository.Update(m1) - assert(t, err == nil, "Error when updating content, %+v", err) + assert(t, err == nil, "Error when updating record, %+v", err) } - // re-fetch content + // re-fetch record { ms, err := repository.FindByID(m1.ID) - assert(t, err == nil, "Error when retrieving content by id: %+v", err) + assert(t, err == nil, "Error when retrieving record by id: %+v", err) assert(t, ms.ID == m1.ID, "Expected ID from database to match, %d != %d", m1.ID, ms.ID) assert(t, ms.ModuleID == m1.ModuleID, "Expected ID from database to match, %d != %d", m1.ModuleID, ms.ModuleID) } - // fetch all contents + // fetch all records { mr, err := repository.Find(module.ID, "", 0, 20, "id desc") - assert(t, err == nil, "Error when retrieving contents: %+v", err) - assert(t, len(mr.Contents) == 2, "Expected two content, got %d", len(mr.Contents)) + assert(t, err == nil, "Error when retrieving records: %+v", err) + assert(t, len(mr.Contents) == 2, "Expected two record, got %d", len(mr.Contents)) assert(t, mr.Meta.Count == 2, "Expected Meta.Count == 2, got %d", mr.Meta.Count) assert(t, mr.Meta.Sort == "id desc", "Expected Meta.Sort == id desc, got '%s'", mr.Meta.Sort) - assert(t, mr.Contents[0].ModuleID == m1.ModuleID, "Expected content module to match, %d != %d", m1.ModuleID, mr.Contents[0].ModuleID) + assert(t, mr.Contents[0].ModuleID == m1.ModuleID, "Expected record module to match, %d != %d", m1.ModuleID, mr.Contents[0].ModuleID) assert(t, mr.Contents[0].ID > mr.Contents[1].ID, "Expected order to be descending") } - // fetch all contents + // fetch all records { mr, err := repository.Find(module.ID, "", 0, 20, "name asc, email desc") - assert(t, err == nil, "Error when retrieving contents: %+v", err) - assert(t, len(mr.Contents) == 2, "Expected two content, got %d", len(mr.Contents)) + assert(t, err == nil, "Error when retrieving records: %+v", err) + assert(t, len(mr.Contents) == 2, "Expected two record, got %d", len(mr.Contents)) assert(t, mr.Meta.Count == 2, "Expected Meta.Count == 2, got %d", mr.Meta.Count) assert(t, mr.Meta.Sort == "name asc, email desc", "Expected Meta.Sort == 'name asc, email desc' '%s'", mr.Meta.Sort) - assert(t, mr.Contents[0].ModuleID == m1.ModuleID, "Expected content module to match, %d != %d", m1.ModuleID, mr.Contents[0].ModuleID) + assert(t, mr.Contents[0].ModuleID == m1.ModuleID, "Expected record module to match, %d != %d", m1.ModuleID, mr.Contents[0].ModuleID) assert(t, mr.Contents[0].ID > mr.Contents[1].ID, "Expected order to be ascending") } - // fetch all contents + // fetch all records { mr, err := repository.Find(module.ID, "", 0, 20, "created_at desc") - assert(t, err == nil, "Error when retrieving contents: %+v", err) - assert(t, len(mr.Contents) == 2, "Expected two content, got %d", len(mr.Contents)) + assert(t, err == nil, "Error when retrieving records: %+v", err) + assert(t, len(mr.Contents) == 2, "Expected two record, got %d", len(mr.Contents)) assert(t, mr.Meta.Count == 2, "Expected Meta.Count == 2, got %d", mr.Meta.Count) assert(t, mr.Meta.Sort == "created_at desc", "Expected Meta.Sort == created_at desc, got '%s'", mr.Meta.Sort) - assert(t, mr.Contents[0].ModuleID == m1.ModuleID, "Expected content module to match, %d != %d", m1.ModuleID, mr.Contents[0].ModuleID) + assert(t, mr.Contents[0].ModuleID == m1.ModuleID, "Expected record module to match, %d != %d", m1.ModuleID, mr.Contents[0].ModuleID) assert(t, mr.Contents[0].ID > mr.Contents[1].ID, "Expected order to be ascending") } - // fetch all contents by query + // fetch all records by query { mr, err := repository.Find(module.ID, "petric", 0, 20, "id desc") - assert(t, err == nil, "Error when retrieving contents: %+v", err) - assert(t, len(mr.Contents) == 1, "Expected one content, got %d", len(mr.Contents)) + assert(t, err == nil, "Error when retrieving records: %+v", err) + assert(t, len(mr.Contents) == 1, "Expected one record, got %d", len(mr.Contents)) assert(t, mr.Meta.Count == 1, "Expected Meta.Count == 1, got %d", mr.Meta.Count) assert(t, mr.Meta.Page == 0, "Expected Meta.Page == 0, got %d", mr.Meta.Page) assert(t, mr.Meta.PerPage == 20, "Expected Meta.PerPage == 20, got %d", mr.Meta.PerPage) @@ -225,27 +225,27 @@ func TestContent(t *testing.T) { assert(t, mr.Meta.Sort == "id desc", "Expected Meta.Sort == id desc, got '%s'", mr.Meta.Sort) } - // fetch all contents by query + // fetch all records by query { mr, err := repository.Find(module.ID, "niall", 0, 20, "id asc") - assert(t, err == nil, "Error when retrieving contents: %+v", err) - assert(t, len(mr.Contents) == 0, "Expected no contents, got %d", len(mr.Contents)) + assert(t, err == nil, "Error when retrieving records: %+v", err) + assert(t, len(mr.Contents) == 0, "Expected no records, got %d", len(mr.Contents)) } - // delete content + // delete record { err := repository.DeleteByID(m1.ID) - assert(t, err == nil, "Error when retrieving content by id: %+v", err) + assert(t, err == nil, "Error when retrieving record by id: %+v", err) err = repository.DeleteByID(m2.ID) - assert(t, err == nil, "Error when retrieving content by id: %+v", err) + assert(t, err == nil, "Error when retrieving record by id: %+v", err) } - // fetch all contents + // fetch all records { mr, err := repository.Find(module.ID, "", 0, 20, "") - assert(t, err == nil, "Error when retrieving contents: %+v", err) - assert(t, len(mr.Contents) == 0, "Expected no content, got %d", len(mr.Contents)) + assert(t, err == nil, "Error when retrieving records: %+v", err) + assert(t, len(mr.Contents) == 0, "Expected no record, got %d", len(mr.Contents)) } } } diff --git a/crm/service/record_util.go b/crm/service/record_util.go new file mode 100644 index 000000000..944115d3d --- /dev/null +++ b/crm/service/record_util.go @@ -0,0 +1,46 @@ +package service + +import ( + "encoding/json" + + "github.com/crusttech/crust/crm/types" +) + +func (r *record) preloadAll(records []*types.Record, fields ...string) error { + for _, record := range records { + if err := r.preload(record, fields...); err != nil { + return err + } + } + return nil +} + +func (r *record) preload(record *types.Record, fields ...string) (err error) { + for _, field := range fields { + switch field { + case "fields": + fields, err := r.Fields(record) + if err != nil { + return err + } + json, err := json.Marshal(fields) + if err != nil { + return err + } + if err := (&record.Fields).Scan(json); err != nil { + return err + } + case "page": + if record.Page, err = r.pageRepo.FindByModuleID(record.ModuleID); err != nil { + return + } + case "user": + if record.UserID > 0 { + if record.User, err = r.userSvc.FindByID(record.UserID); err != nil { + return + } + } + } + } + return +} diff --git a/crm/service/service.go b/crm/service/service.go index 49754d3bd..5e8899d88 100644 --- a/crm/service/service.go +++ b/crm/service/service.go @@ -6,7 +6,7 @@ import ( var ( o sync.Once - DefaultContent ContentService + DefaultRecord RecordService DefaultField FieldService DefaultModule ModuleService DefaultChart ChartService @@ -17,7 +17,7 @@ var ( func Init() { o.Do(func() { - DefaultContent = Content() + DefaultRecord = Record() DefaultField = Field() DefaultModule = Module() DefaultPage = Page()