// Count all comments related to a single item
func (m *GormCommentRepository) Count(ctx context.Context, parent string) (int, error) {
defer goa.MeasureSince([]string{"goa", "db", "comment", "query"}, time.Now())
var count int
m.db.Model(&Comment{}).Where("parent_id = ?", parent).Count(&count)
return count, nil
}
// List all Areas related to a single item
func (m *GormAreaRepository) List(ctx context.Context, spaceID uuid.UUID) ([]*Area, error) {
defer goa.MeasureSince([]string{"goa", "db", "Area", "query"}, time.Now())
var objs []*Area
err := m.db.Where("space_id = ?", spaceID).Find(&objs).Error
if err != nil && err != gorm.ErrRecordNotFound {
return nil, err
}
return objs, nil
}
// List return all users
func (m *GormUserRepository) List(ctx context.Context) ([]*User, error) {
defer goa.MeasureSince([]string{"goa", "db", "user", "list"}, time.Now())
var rows []*User
err := m.db.Model(&User{}).Order("email").Find(&rows).Error
if err != nil && err != gorm.ErrRecordNotFound {
return nil, errors.WithStack(err)
}
return rows, nil
}
// Load returns a single Identity as a Database Model
// This is more for use internally, and probably not what you want in your controllers
func (m *GormIdentityRepository) Load(ctx context.Context, id uuid.UUID) (*Identity, error) {
defer goa.MeasureSince([]string{"goa", "db", "identity", "load"}, time.Now())
var native Identity
err := m.db.Table(m.TableName()).Where("id = ?", id).Find(&native).Error
if err == gorm.ErrRecordNotFound {
return nil, errors.WithStack(err)
}
return &native, errors.WithStack(err)
}
// Create creates a new record.
func (m *GormAreaRepository) Create(ctx context.Context, u *Area) error {
defer goa.MeasureSince([]string{"goa", "db", "area", "create"}, time.Now())
u.ID = uuid.NewV4()
err := m.db.Create(u).Error
if err != nil {
goa.LogError(ctx, "error adding Area", "error", err.Error())
return err
}
return nil
}
// Load a single Area regardless of parent
func (m *GormAreaRepository) Load(ctx context.Context, id uuid.UUID) (*Area, error) {
defer goa.MeasureSince([]string{"goa", "db", "Area", "get"}, time.Now())
var obj Area
tx := m.db.Where("id = ?", id).First(&obj)
if tx.RecordNotFound() {
return nil, errors.NewNotFoundError("Area", id.String())
}
if tx.Error != nil {
return nil, errors.NewInternalError(tx.Error.Error())
}
return &obj, nil
}
// Load multiple areas
func (m *GormAreaRepository) LoadMultiple(ctx context.Context, ids []uuid.UUID) ([]*Area, error) {
defer goa.MeasureSince([]string{"goa", "db", "Area", "getmultiple"}, time.Now())
var objs []*Area
for i := 0; i < len(ids); i++ {
m.db = m.db.Or("id = ?", ids[i])
}
tx := m.db.Find(&objs)
if tx.Error != nil {
return nil, errors.NewInternalError(tx.Error.Error())
}
return objs, nil
}
// List all Iterations related to a single item
func (m *GormIterationRepository) List(ctx context.Context, spaceID uuid.UUID) ([]*Iteration, error) {
defer goa.MeasureSince([]string{"goa", "db", "iteration", "query"}, time.Now())
var objs []*Iteration
err := m.db.Where("space_id = ?", spaceID).Find(&objs).Error
if err != nil && err != gorm.ErrRecordNotFound {
log.Error(ctx, map[string]interface{}{
"spaceID": spaceID,
"err": err,
}, "unable to list the iterations")
return nil, errs.WithStack(err)
}
return objs, nil
}
// Query expose an open ended Query model
func (m *GormIdentityRepository) Query(funcs ...func(*gorm.DB) *gorm.DB) ([]*Identity, error) {
defer goa.MeasureSince([]string{"goa", "db", "identity", "query"}, time.Now())
var objs []*Identity
err := m.db.Scopes(funcs...).Table(m.TableName()).Find(&objs).Error
if err != nil && err != gorm.ErrRecordNotFound {
return nil, errors.WithStack(err)
}
log.Debug(nil, map[string]interface{}{
"pkg": "identity",
"identityList": objs,
}, "Identity query executed successfully!")
return objs, nil
}
// Create creates a new record.
func (m *GormIterationRepository) Create(ctx context.Context, u *Iteration) error {
defer goa.MeasureSince([]string{"goa", "db", "iteration", "create"}, time.Now())
u.ID = uuid.NewV4()
u.State = IterationStateNew
err := m.db.Create(u).Error
if err != nil {
log.Error(ctx, map[string]interface{}{
"iterationID": u.ID,
"err": err,
}, "unable to create the iteration")
return errs.WithStack(err)
}
return nil
}
// ListChildren fetches all Areas belonging to a parent - list all child areas.
func (m *GormAreaRepository) ListChildren(ctx context.Context, parentArea *Area) ([]*Area, error) {
defer goa.MeasureSince([]string{"goa", "db", "Area", "querychild"}, time.Now())
var objs []*Area
predicateString := (parentArea.ID).String()
if parentArea.Path != "" {
predicateString = parentArea.Path + "." + predicateString
}
tx := m.db.Where("path ~ ?", ConvertToLtreeFormat(predicateString)).Find(&objs)
if tx.RecordNotFound() {
return nil, errors.NewNotFoundError("Area", parentArea.ID.String())
}
if tx.Error != nil {
return nil, errors.NewInternalError(tx.Error.Error())
}
return objs, nil
}
// Load a single Iteration regardless of parent
func (m *GormIterationRepository) Load(ctx context.Context, id uuid.UUID) (*Iteration, error) {
defer goa.MeasureSince([]string{"goa", "db", "iteration", "get"}, time.Now())
var obj Iteration
tx := m.db.Where("id = ?", id).First(&obj)
if tx.RecordNotFound() {
log.Error(ctx, map[string]interface{}{
"iterationID": id.String(),
}, "iteration cannot be found")
return nil, errors.NewNotFoundError("Iteration", id.String())
}
if tx.Error != nil {
log.Error(ctx, map[string]interface{}{
"iterationID": id.String(),
"err": tx.Error,
}, "unable to load the iteration")
return nil, errors.NewInternalError(tx.Error.Error())
}
return &obj, nil
}
// Create creates a new record.
func (m *GormUserRepository) Create(ctx context.Context, u *User) error {
defer goa.MeasureSince([]string{"goa", "db", "user", "create"}, time.Now())
u.ID = uuid.NewV4()
err := m.db.Create(u).Error
if err != nil {
log.Error(ctx, map[string]interface{}{
"userID": u.ID,
"err": err,
}, "unable to create the user")
return errors.WithStack(err)
}
log.Debug(ctx, map[string]interface{}{
"pkg": "user",
"userID": u.ID,
}, "User created!")
return nil
}
// Save modifies a single record.
func (m *GormIdentityRepository) Save(ctx context.Context, model *Identity) error {
defer goa.MeasureSince([]string{"goa", "db", "identity", "save"}, time.Now())
obj, err := m.Load(ctx, model.ID)
if err != nil {
log.Error(ctx, map[string]interface{}{
"identityID": model.ID,
"ctx": ctx,
"err": err,
}, "unable to update the identity")
return errors.WithStack(err)
}
err = m.db.Model(obj).Updates(model).Error
log.Debug(ctx, map[string]interface{}{
"pkg": "identity",
"identityID": model.ID,
}, "Identity saved!")
return errors.WithStack(err)
}
// Save modifies a single record
func (m *GormUserRepository) Save(ctx context.Context, model *User) error {
defer goa.MeasureSince([]string{"goa", "db", "user", "save"}, time.Now())
obj, err := m.Load(ctx, model.ID)
if err != nil {
log.Error(ctx, map[string]interface{}{
"userID": model.ID,
"err": err,
}, "unable to update user")
return errors.WithStack(err)
}
err = m.db.Model(obj).Updates(model).Error
if err != nil {
return errors.WithStack(err)
}
log.Debug(ctx, map[string]interface{}{
"pkg": "user",
"userID": model.ID,
}, "User saved!")
return nil
}
// Create creates a new record.
func (m *GormIdentityRepository) Create(ctx context.Context, model *Identity) error {
defer goa.MeasureSince([]string{"goa", "db", "identity", "create"}, time.Now())
if model.ID == uuid.Nil {
model.ID = uuid.NewV4()
}
err := m.db.Create(model).Error
if err != nil {
log.Error(ctx, map[string]interface{}{
"identityID": model.ID,
"err": err,
}, "unable to create the identity")
return errors.WithStack(err)
}
log.Debug(ctx, map[string]interface{}{
"pkg": "identity",
"identityID": model.ID,
}, "Identity created!")
return nil
}
// Delete removes a single record.
func (m *GormIdentityRepository) Delete(ctx context.Context, id uuid.UUID) error {
defer goa.MeasureSince([]string{"goa", "db", "identity", "delete"}, time.Now())
var obj Identity
err := m.db.Delete(&obj, id).Error
if err != nil {
log.Error(ctx, map[string]interface{}{
"identityID": id,
"err": err,
}, "unable to delete the identity")
return errors.WithStack(err)
}
log.Debug(ctx, map[string]interface{}{
"pkg": "identity",
"identityID": id,
}, "Identity deleted!")
return nil
}
// List return all user identities
func (m *GormIdentityRepository) List(ctx context.Context) (*app.IdentityArray, error) {
defer goa.MeasureSince([]string{"goa", "db", "identity", "list"}, time.Now())
var rows []Identity
err := m.db.Model(&Identity{}).Order("username").Find(&rows).Error
if err != nil && err != gorm.ErrRecordNotFound {
return nil, errors.WithStack(err)
}
res := app.IdentityArray{}
res.Data = make([]*app.IdentityData, len(rows))
for index, value := range rows {
ident := value.ConvertIdentityFromModel()
res.Data[index] = ident.Data
}
log.Debug(ctx, map[string]interface{}{
"pkg": "identity",
"identityList": &res,
}, "Identity List executed successfully!")
return &res, nil
}
// Create creates a new record.
func (m *GormCommentRepository) Create(ctx context.Context, comment *Comment) error {
defer goa.MeasureSince([]string{"goa", "db", "comment", "create"}, time.Now())
comment.ID = uuid.NewV4()
// make sure no comment is created with an empty 'markup' value
if comment.Markup == "" {
comment.Markup = rendering.SystemMarkupDefault
}
if err := m.db.Create(comment).Error; err != nil {
log.Error(ctx, map[string]interface{}{
"commentID": comment.ID,
"err": err,
}, "unable to create the comment")
return errs.WithStack(err)
}
log.Debug(ctx, map[string]interface{}{
"pkg": "comment",
"commentID": comment.ID,
}, "Comment created!")
return nil
}
// Load a single comment regardless of parent
func (m *GormCommentRepository) Load(ctx context.Context, id uuid.UUID) (*Comment, error) {
defer goa.MeasureSince([]string{"goa", "db", "comment", "get"}, time.Now())
var obj Comment
tx := m.db.Where("id=?", id).First(&obj)
if tx.RecordNotFound() {
log.Error(ctx, map[string]interface{}{
"commentID": id.String(),
}, "comment search operation failed!")
return nil, errors.NewNotFoundError("comment", id.String())
}
if tx.Error != nil {
log.Error(ctx, map[string]interface{}{
"commentID": id.String(),
"err": tx.Error,
}, "unable to load the comment")
return nil, errors.NewInternalError(tx.Error.Error())
}
return &obj, nil
}
"foo_bar_all",
"foo___baz",
"foo_baz",
"foo_bar_baz",
"foo_bar__all",
"__foo_bar_",
}))
})
})
})
Describe("Measure since", func() {
Context("With invalid characters in key", func() {
It("should replace invalid characters with normalized characters", func() {
goa.SetMetrics(metriks)
goa.MeasureSince(keys[:], time.Time{})
Ω(keys).Should(ConsistOf([]string{
"foo_bar_all",
"foo___baz",
"foo_baz",
"foo_bar_baz",
"foo_bar__all",
"__foo_bar_",
}))
})
})
})
Describe("Set gauge", func() {
Context("With invalid characters in key", func() {
It("should replace invalid characters with normalized characters", func() {
// List all comments related to a single item
func (m *GormCommentRepository) List(ctx context.Context, parent string, start *int, limit *int) ([]*Comment, uint64, error) {
defer goa.MeasureSince([]string{"goa", "db", "comment", "query"}, time.Now())
db := m.db.Model(&Comment{}).Where("parent_id = ?", parent)
orgDB := db
if start != nil {
if *start < 0 {
return nil, 0, errors.NewBadParameterError("start", *start)
}
db = db.Offset(*start)
}
if limit != nil {
if *limit <= 0 {
return nil, 0, errors.NewBadParameterError("limit", *limit)
}
db = db.Limit(*limit)
}
db = db.Select("count(*) over () as cnt2 , *").Order("created_at desc")
rows, err := db.Rows()
if err != nil {
return nil, 0, err
}
defer rows.Close()
result := []*Comment{}
columns, err := rows.Columns()
if err != nil {
return nil, 0, errors.NewInternalError(err.Error())
}
// need to set up a result for Scan() in order to extract total count.
var count uint64
var ignore interface{}
columnValues := make([]interface{}, len(columns))
for index := range columnValues {
columnValues[index] = &ignore
}
columnValues[0] = &count
first := true
for rows.Next() {
value := &Comment{}
db.ScanRows(rows, value)
if first {
first = false
if err = rows.Scan(columnValues...); err != nil {
return nil, 0, errors.NewInternalError(err.Error())
}
}
result = append(result, value)
}
if first {
// means 0 rows were returned from the first query (maybe becaus of offset outside of total count),
// need to do a count(*) to find out total
orgDB := orgDB.Select("count(*)")
rows2, err := orgDB.Rows()
defer rows2.Close()
if err != nil {
return nil, 0, err
}
rows2.Next() // count(*) will always return a row
rows2.Scan(&count)
}
return result, count, nil
}
