Open platform to collect and prioritize feedback
API to manage/assign/unassign tags (#186)
Guilherme Oenning617a1fc60a75
diff --git a/app/actions/tag.go b/app/actions/tag.gonew file mode 100644index 000000000..7d62a1556--- /dev/null+++ b/app/actions/tag.go@@ -0,0 +1,127 @@+package actions++import (+ "regexp"++ "github.com/getfider/fider/app"+ "github.com/getfider/fider/app/models"+ "github.com/getfider/fider/app/pkg/validate"+ "github.com/gosimple/slug"+)++var colorRegex = regexp.MustCompile(`^([A-Fa-f0-9]{6})$`)++// CreateEditTag is used to create a new tag or edit existing+type CreateEditTag struct {+ Tag *models.Tag+ Model *models.CreateEditTag+}++// Initialize the model+func (input *CreateEditTag) Initialize() interface{} {+ input.Model = new(models.CreateEditTag)+ return input.Model+}++// IsAuthorized returns true if current user is authorized to perform this action+func (input *CreateEditTag) IsAuthorized(user *models.User) bool {+ return user != nil && user.IsAdministrator()+}++// Validate is current model is valid+func (input *CreateEditTag) Validate(services *app.Services) *validate.Result {+ result := validate.Success()+ if input.Model.Slug != "" {+ tag, err := services.Tags.GetBySlug(input.Model.Slug)+ if err != nil {+ return validate.Error(err)+ }+ input.Tag = tag+ }++ if input.Model.Name == "" {+ result.AddFieldFailure("name", "Name is required.")+ } else if len(input.Model.Name) > 30 {+ result.AddFieldFailure("name", "Name must be less than 30 characters.")+ } else {+ duplicateTag, err := services.Tags.GetBySlug(slug.Make(input.Model.Name))+ if err != nil && err != app.ErrNotFound {+ return validate.Error(err)+ } else if err == nil && (input.Tag == nil || input.Tag.ID != duplicateTag.ID) {+ result.AddFieldFailure("name", "This tag name is already in use.")+ }+ }++ if input.Model.Color == "" {+ result.AddFieldFailure("color", "Color is required.")+ } else if len(input.Model.Color) != 6 {+ result.AddFieldFailure("color", "Color must be exactly 6 characters.")+ } else if !colorRegex.MatchString(input.Model.Color) {+ result.AddFieldFailure("color", "Color is invalid.")+ }++ return result+}++// RemoveTag is used to delete an existing tag+type RemoveTag struct {+ Tag *models.Tag+ Model *models.RemoveTag+}++// Initialize the model+func (input *RemoveTag) Initialize() interface{} {+ input.Model = new(models.RemoveTag)+ return input.Model+}++// IsAuthorized returns true if current user is authorized to perform this action+func (input *RemoveTag) IsAuthorized(user *models.User) bool {+ return user != nil && user.IsAdministrator()+}++// Validate is current model is valid+func (input *RemoveTag) Validate(services *app.Services) *validate.Result {+ tag, err := services.Tags.GetBySlug(input.Model.Slug)+ if err != nil {+ return validate.Error(err)+ }++ input.Tag = tag+ return validate.Success()+}++// AssignUnassignTag is used to assign or remove a tag to/from an idea+type AssignUnassignTag struct {+ Tag *models.Tag+ Idea *models.Idea+ Model *models.AssignUnassignTag+}++// Initialize the model+func (input *AssignUnassignTag) Initialize() interface{} {+ input.Model = new(models.AssignUnassignTag)+ return input.Model+}++// IsAuthorized returns true if current user is authorized to perform this action+func (input *AssignUnassignTag) IsAuthorized(user *models.User) bool {+ return user != nil && user.IsCollaborator()+}++// Validate is current model is valid+func (input *AssignUnassignTag) Validate(services *app.Services) *validate.Result {+ idea, err := services.Ideas.GetByNumber(input.Model.Number)+ if err != nil {+ return validate.Error(err)+ }++ tag, err := services.Tags.GetBySlug(input.Model.Slug)+ if err != nil {+ return validate.Error(err)+ }++ input.Tag = tag+ input.Idea = idea+ return validate.Success()+}diff --git a/app/handlers/tag.go b/app/handlers/tag.gonew file mode 100644index 000000000..08fc4c4cb--- /dev/null+++ b/app/handlers/tag.go@@ -0,0 +1,85 @@+package handlers++import (+ "github.com/getfider/fider/app/actions"+ "github.com/getfider/fider/app/models"+ "github.com/getfider/fider/app/pkg/web"+)++// CreateEditTag creates a new tag on current tenant+func CreateEditTag() web.HandlerFunc {+ return func(c web.Context) error {+ input := new(actions.CreateEditTag)+ if result := c.BindTo(input); !result.Ok {+ return c.HandleValidation(result)+ }++ var (+ tag *models.Tag+ err error+ )++ if input.Model.Slug != "" {+ tag, err = c.Services().Tags.Update(input.Tag.ID, input.Model.Name, input.Model.Color, input.Model.IsPublic)+ } else {+ tag, err = c.Services().Tags.Add(input.Model.Name, input.Model.Color, input.Model.IsPublic)+ }++ if err != nil {+ return c.Failure(err)+ }++ return c.Ok(tag)+ }+}++// RemoveTag deletes anexisting tag+func RemoveTag() web.HandlerFunc {+ return func(c web.Context) error {+ input := new(actions.RemoveTag)+ if result := c.BindTo(input); !result.Ok {+ return c.HandleValidation(result)+ }++ err := c.Services().Tags.Remove(input.Tag.ID)+ if err != nil {+ return c.Failure(err)+ }++ return c.Ok(web.Map{})+ }+}++// AssignTag to existing dea+func AssignTag() web.HandlerFunc {+ return func(c web.Context) error {+ input := new(actions.AssignUnassignTag)+ if result := c.BindTo(input); !result.Ok {+ return c.HandleValidation(result)+ }++ err := c.Services().Tags.AssignTag(input.Tag.ID, input.Idea.ID, c.User().ID)+ if err != nil {+ return c.Failure(err)+ }++ return c.Ok(web.Map{})+ }+}++// UnassignTag from existing dea+func UnassignTag() web.HandlerFunc {+ return func(c web.Context) error {+ input := new(actions.AssignUnassignTag)+ if result := c.BindTo(input); !result.Ok {+ return c.HandleValidation(result)+ }++ err := c.Services().Tags.UnassignTag(input.Tag.ID, input.Idea.ID)+ if err != nil {+ return c.Failure(err)+ }++ return c.Ok(web.Map{})+ }+}diff --git a/app/handlers/tag_test.go b/app/handlers/tag_test.gonew file mode 100644index 000000000..96746d1e2--- /dev/null+++ b/app/handlers/tag_test.go@@ -0,0 +1,255 @@+package handlers_test++import (+ "net/http"+ "testing"++ "github.com/getfider/fider/app"+ "github.com/getfider/fider/app/handlers"+ "github.com/getfider/fider/app/pkg/mock"+ "github.com/getfider/fider/app/pkg/web"+ . "github.com/onsi/gomega"+)++func TestCreateTagHandler_ValidRequests(t *testing.T) {+ RegisterTestingT(t)++ server, services := mock.NewServer()+ status, _ := server.+ AsUser(mock.JonSnow).+ ExecutePost(+ handlers.CreateEditTag(),+ `{ "name": "Feature Request", "color": "00FF00", "isPublic": true }`,+ )++ Expect(status).To(Equal(http.StatusOK))++ tag, err := services.Tags.GetBySlug("feature-request")+ Expect(err).To(BeNil())+ Expect(tag.Name).To(Equal("Feature Request"))+ Expect(tag.Slug).To(Equal("feature-request"))+ Expect(tag.Color).To(Equal("00FF00"))+ Expect(tag.IsPublic).To(BeTrue())+}++func TestCreateTagHandler_InvalidRequests(t *testing.T) {+ RegisterTestingT(t)++ var testCases = []struct {+ input string+ failures []string+ }{+ {`{ }`, []string{"failures.name", "failures.color"}},+ {`{ "name": "" }`, []string{"failures.name", "failures.color"}},+ {`{ "name": "Bug" }`, []string{"failures.color"}},+ {`{ "name": "Bug", "color": "ABC" }`, []string{"failures.color"}},+ {`{ "name": "Bug", "color": "00000X" }`, []string{"failures.color"}},+ {`{ "name": "123456789012345678901234567890A", "color": "000000" }`, []string{"failures.name"}},+ }++ for _, testCase := range testCases {+ server, _ := mock.NewServer()+ status, query := server.+ AsUser(mock.JonSnow).+ ExecutePostAsJSON(handlers.CreateEditTag(), testCase.input)++ Expect(status).To(Equal(http.StatusBadRequest))+ for _, failure := range testCase.failures {+ Expect(query.Contains(failure)).To(BeTrue())+ }+ }++}++func TestCreateTagHandler_AlreadyInUse(t *testing.T) {+ RegisterTestingT(t)++ server, services := mock.NewServer()+ services.Tags.Add("Bug", "0000FF", true)++ status, query := server.+ AsUser(mock.JonSnow).+ ExecutePostAsJSON(+ handlers.CreateEditTag(),+ `{ "name": "Bug", "color": "0000FF", "isPublic": true }`,+ )++ Expect(status).To(Equal(http.StatusBadRequest))+ Expect(query.Contains("failures.name")).To(BeTrue())+}++func TestCreateTagHandler_Collaborator(t *testing.T) {+ RegisterTestingT(t)++ server, _ := mock.NewServer()+ status, _ := server.+ AsUser(mock.AryaStark).+ ExecutePost(+ handlers.CreateEditTag(),+ `{ "name": "Feature Request", "color": "000000", "isPublic": true }`,+ )++ Expect(status).To(Equal(http.StatusForbidden))+}++func TestEditInvalidTagHandler(t *testing.T) {+ RegisterTestingT(t)++ server, _ := mock.NewServer()+ status, _ := server.+ AsUser(mock.JonSnow).+ AddParam("slug", "bug").+ ExecutePost(+ handlers.CreateEditTag(),+ `{ "name": "Feature Request", "color": "000000", "isPublic": true }`,+ )++ Expect(status).To(Equal(http.StatusNotFound))+}++func TestEditExistingTagHandler(t *testing.T) {+ RegisterTestingT(t)++ server, services := mock.NewServer()+ services.Tags.Add("Bug", "0000FF", true)++ status, _ := server.+ AsUser(mock.JonSnow).+ AddParam("slug", "bug").+ ExecutePost(+ handlers.CreateEditTag(),+ `{ "name": "Feature Request", "color": "000000", "isPublic": true }`,+ )++ Expect(status).To(Equal(http.StatusOK))+ tag, err := services.Tags.GetBySlug("bug")+ Expect(tag).To(BeNil())+ Expect(err).To(Equal(app.ErrNotFound))++ tag, err = services.Tags.GetBySlug("feature-request")+ Expect(tag).ToNot(BeNil())+ Expect(err).To(BeNil())+}++func TestRemoveInvalidTagHandler(t *testing.T) {+ RegisterTestingT(t)++ server, _ := mock.NewServer()+ status, _ := server.+ AsUser(mock.JonSnow).+ AddParam("slug", "bug").+ Execute(handlers.RemoveTag())++ Expect(status).To(Equal(http.StatusNotFound))+}++func TestRemoveExistingTagHandler(t *testing.T) {+ RegisterTestingT(t)++ server, services := mock.NewServer()+ services.Tags.Add("Bug", "0000FF", true)++ status, _ := server.+ AsUser(mock.JonSnow).+ AddParam("slug", "bug").+ Execute(handlers.RemoveTag())++ tag, err := services.Tags.GetBySlug("bug")+ Expect(status).To(Equal(http.StatusOK))+ Expect(err).To(Equal(app.ErrNotFound))+ Expect(tag).To(BeNil())+}++func TestRemoveExistingTagHandler_Collaborator(t *testing.T) {+ RegisterTestingT(t)++ server, services := mock.NewServer()+ services.Tags.Add("Bug", "0000FF", true)++ status, _ := server.+ AsUser(mock.AryaStark).+ AddParam("slug", "bug").+ Execute(handlers.RemoveTag())++ tag, err := services.Tags.GetBySlug("bug")+ Expect(status).To(Equal(http.StatusForbidden))+ Expect(tag).ToNot(BeNil())+ Expect(err).To(BeNil())++}++func TestAssignTagHandler_Success(t *testing.T) {+ RegisterTestingT(t)++ server, services := mock.NewServer()+ tag, _ := services.Tags.Add("Bug", "0000FF", true)+ idea, _ := services.Ideas.Add("Idea Title", "Idea Description", mock.JonSnow.ID)++ status, _ := server.+ AsUser(mock.JonSnow).+ AddParam("slug", tag.Slug).+ AddParam("number", idea.Number).+ Execute(handlers.AssignTag())++ tags, err := services.Tags.GetAssigned(idea.ID)+ Expect(status).To(Equal(http.StatusOK))+ Expect(err).To(BeNil())+ Expect(tags[0]).To(Equal(tag))+}++func TestAssignTagHandler_UnknownTag(t *testing.T) {+ RegisterTestingT(t)++ server, _ := mock.NewServer()++ status, _ := server.+ AsUser(mock.JonSnow).+ AddParam("slug", "bug").+ AddParam("number", 1).+ Execute(handlers.AssignTag())++ Expect(status).To(Equal(http.StatusNotFound))+}++func TestAssignOrUnassignTagHandler_Unauthorized(t *testing.T) {+ RegisterTestingT(t)++ var testCases = []web.HandlerFunc{+ handlers.AssignTag(),+ handlers.UnassignTag(),+ }++ for _, handler := range testCases {+ server, services := mock.NewServer()+ tag, _ := services.Tags.Add("Bug", "0000FF", true)+ idea, _ := services.Ideas.Add("Idea Title", "Idea Description", mock.JonSnow.ID)++ status, _ := server.+ AsUser(mock.AryaStark).+ AddParam("slug", tag.Slug).+ AddParam("number", idea.Number).+ Execute(handler)++ Expect(status).To(Equal(http.StatusForbidden))+ }+}++func TestUnassignTagHandler_Success(t *testing.T) {+ RegisterTestingT(t)++ server, services := mock.NewServer()+ tag, _ := services.Tags.Add("Bug", "0000FF", true)+ idea, _ := services.Ideas.Add("Idea Title", "Idea Description", mock.JonSnow.ID)+ services.Tags.AssignTag(tag.ID, idea.ID, mock.JonSnow.ID)++ status, _ := server.+ AsUser(mock.JonSnow).+ AddParam("slug", tag.Slug).+ AddParam("number", idea.Number).+ Execute(handlers.UnassignTag())++ tags, err := services.Tags.GetAssigned(idea.ID)+ Expect(status).To(Equal(http.StatusOK))+ Expect(err).To(BeNil())+ Expect(len(tags)).To(Equal(0))+}diff --git a/app/middlewares/setup.go b/app/middlewares/setup.goindex b40dcc831..bf506a1a9 100644--- a/app/middlewares/setup.go+++ b/app/middlewares/setup.go@@ -79,6 +79,7 @@ func AddServices() web.MiddlewareFunc {services.OAuth = &oauth.HTTPService{}services.Ideas = postgres.NewIdeaStorage(tenant, trx)services.Users = postgres.NewUserStorage(tenant, trx)+ services.Tags = postgres.NewTagStorage(tenant, trx)return next(c)}}diff --git a/app/models/feedback.go b/app/models/feedback.goindex 0f608f0ff..9e751a1dc 100644--- a/app/models/feedback.go+++ b/app/models/feedback.go@@ -60,6 +60,34 @@ type Comment struct {User *User `json:"user"`}+//Tag represents a simple tag+type Tag struct {+ ID int `json:"id"`+ Name string `json:"name"`+ Slug string `json:"slug"`+ Color string `json:"color"`+ IsPublic bool `json:"isPublic"`+}++//CreateEditTag is used to create a new tag or edit existing+type CreateEditTag struct {+ Slug string `route:"slug"`+ Name string `json:"name"`+ Color string `json:"color" format:"upper"`+ IsPublic bool `json:"isPublic"`+}++// RemoveTag is used to delete an existing tag+type RemoveTag struct {+ Slug string `route:"slug"`+}++// AssignUnassignTag is used to assign or remove a tag to/from an idea+type AssignUnassignTag struct {+ Slug string `route:"slug"`+ Number int `route:"number"`+}+var (//IdeaNew is the default statusIdeaNew = 0diff --git a/app/pkg/jsonq/jsonq.go b/app/pkg/jsonq/jsonq.goindex 1518483a2..3afabeefd 100644--- a/app/pkg/jsonq/jsonq.go+++ b/app/pkg/jsonq/jsonq.go@@ -2,6 +2,7 @@ package jsonqimport ("encoding/json"+ "strings")type Query struct {@@ -18,11 +19,39 @@ func New(content string) *Query {}func (q *Query) String(key string) (string, error) {- var str string- err := json.Unmarshal(*q.m[key], &str)- return str, err+ data := q.get(key)+ if data != nil {+ var str string+ err := json.Unmarshal(*data, &str)+ return str, err+ }+ return "", nil}func (q *Query) Contains(key string) bool {- return q.m[key] != nil+ return q.get(key) != nil+}++func (q *Query) get(key string) *json.RawMessage {+ keys := strings.Split(key, ".")++ var message *json.RawMessage+ var m map[string]*json.RawMessage++ for _, key := range keys {+ if m != nil {+ message = m[key]+ } else {+ message = q.m[key]+ }++ if message != nil {+ bytes, _ := message.MarshalJSON()+ json.Unmarshal(bytes, &m)+ } else {+ return nil+ }+ }++ return message}diff --git a/app/pkg/jsonq/jsonq_test.go b/app/pkg/jsonq/jsonq_test.goindex ed5f61b80..5ba2dafc9 100644--- a/app/pkg/jsonq/jsonq_test.go+++ b/app/pkg/jsonq/jsonq_test.go@@ -14,9 +14,29 @@ func TestGetString(t *testing.T) {Expect(query.String("name")).To(Equal("Jon Snow"))}+func TestGetStringNested(t *testing.T) {+ RegisterTestingT(t)++ query := jsonq.New(`{ "failures": { "name": "Jon Snow" } }`)+ Expect(query.String("failures.name")).To(Equal("Jon Snow"))+}+func TestContains(t *testing.T) {RegisterTestingT(t)query := jsonq.New(`{ "name": "Jon Snow" }`)+ Expect(query.Contains("name")).To(BeTrue())Expect(query.Contains("what")).To(BeFalse())+ Expect(query.Contains("feature.name")).To(BeFalse())+}++func TestContainsNested(t *testing.T) {+ RegisterTestingT(t)++ query := jsonq.New(`{ "failures": { "name": "Name is required" } }`)+ Expect(query.Contains("failures")).To(BeTrue())+ Expect(query.Contains("failures.name")).To(BeTrue())++ Expect(query.Contains("name")).To(BeFalse())+ Expect(query.Contains("failures.what")).To(BeFalse())}diff --git a/app/pkg/mock/setup.go b/app/pkg/mock/setup.goindex 577594121..b29a1d8f1 100644--- a/app/pkg/mock/setup.go+++ b/app/pkg/mock/setup.go@@ -42,6 +42,7 @@ func createServices(seed bool) *app.Services {services := &app.Services{Tenants: &inmemory.TenantStorage{},Users: &inmemory.UserStorage{},+ Tags: inmemory.NewTagStorage(),Ideas: inmemory.NewIdeaStorage(),OAuth: &OAuthService{},Emailer: email.NewNoopSender(),diff --git a/app/pkg/web/binder.go b/app/pkg/web/binder.goindex 339faca6b..3df6e57a0 100644--- a/app/pkg/web/binder.go+++ b/app/pkg/web/binder.go@@ -67,6 +67,8 @@ func (b *DefaultBinder) format(idx int, target reflect.Value, targetType reflectstr = strings.TrimSpace(str)if format == "lower" {str = strings.ToLower(str)+ } else if format == "upper" {+ str = strings.ToUpper(str)}field.SetString(str)}diff --git a/app/pkg/web/binder_test.go b/app/pkg/web/binder_test.goindex b8d451360..e4fe57b1a 100644--- a/app/pkg/web/binder_test.go+++ b/app/pkg/web/binder_test.go@@ -53,14 +53,16 @@ func TestDefaultBinder_TrimSpaces(t *testing.T) {type user struct {Name string `json:"name"`Email string `json:"email" format:"lower"`+ Color string `json:"color" format:"upper"`Other string}- ctx := newPostContext(make(web.StringMap, 0), `{ "name": " Jon Snow ", "email": " [email protected] " }`)+ ctx := newPostContext(make(web.StringMap, 0), `{ "name": " Jon Snow ", "email": " [email protected] ", "color": "ff00ad" }`)u := new(user)err := binder.Bind(u, ctx)Expect(err).To(BeNil())Expect(u.Name).To(Equal("Jon Snow"))Expect(u.Email).To(Equal("[email protected]"))+ Expect(u.Color).To(Equal("FF00AD"))Expect(u.Other).To(Equal(""))}diff --git a/app/services.go b/app/services.goindex 1db386483..b24ef730a 100644--- a/app/services.go+++ b/app/services.go@@ -10,6 +10,7 @@ import (type Services struct {OAuth oauth.ServiceUsers storage.User+ Tags storage.TagTenants storage.TenantIdeas storage.IdeaEmailer email.Senderdiff --git a/app/storage/inmemory/tag.go b/app/storage/inmemory/tag.gonew file mode 100644index 000000000..fb266fc5d--- /dev/null+++ b/app/storage/inmemory/tag.go@@ -0,0 +1,121 @@+package inmemory++import (+ "github.com/getfider/fider/app"+ "github.com/getfider/fider/app/models"+ "github.com/gosimple/slug"+)++// TagStorage contains read and write operations for tags+type TagStorage struct {+ lastID int+ tags []*models.Tag+ assigned map[int][]*models.Tag+}++// NewTagStorage creates a new TagStorage+func NewTagStorage() *TagStorage {+ return &TagStorage{+ tags: make([]*models.Tag, 0),+ assigned: make(map[int][]*models.Tag),+ }+}++// Add creates a new tag with given input+func (s *TagStorage) Add(name, color string, isPublic bool) (*models.Tag, error) {+ s.lastID = s.lastID + 1+ tag := &models.Tag{+ ID: s.lastID,+ Name: name,+ Slug: slug.Make(name),+ Color: color,+ IsPublic: isPublic,+ }+ s.tags = append(s.tags, tag)+ return tag, nil+}++// GetBySlug returns tag by given slug+func (s *TagStorage) GetBySlug(slug string) (*models.Tag, error) {+ for _, tag := range s.tags {+ if tag.Slug == slug {+ return tag, nil+ }+ }+ return nil, app.ErrNotFound+}++// Update a tag with given input+func (s *TagStorage) Update(tagID int, name, color string, isPublic bool) (*models.Tag, error) {+ for _, tag := range s.tags {+ if tag.ID == tagID {+ tag.Name = name+ tag.Slug = slug.Make(name)+ tag.Color = color+ tag.IsPublic = isPublic+ return tag, nil+ }+ }+ return nil, app.ErrNotFound+}++// Remove a tag by its id+func (s *TagStorage) Remove(tagID int) error {+ for i, tag := range s.tags {+ if tag.ID == tagID {+ s.tags = append(s.tags[:i], s.tags[i+1:]...)+ break+ }+ }+ return nil+}++// AssignTag adds a tag to an idea+func (s *TagStorage) AssignTag(tagID, ideaID, userID int) error {+ var tagToAssign *models.Tag+ for _, tag := range s.tags {+ if tag.ID == tagID {+ tagToAssign = tag+ break+ }+ }++ if tagToAssign == nil {+ return app.ErrNotFound+ }++ assigned := s.assigned[ideaID]+ if assigned != nil {+ for _, tag := range assigned {+ if tag.ID == tagID {+ return nil+ }+ }+ }++ s.assigned[ideaID] = append(s.assigned[ideaID], tagToAssign)+ return nil+}++// UnassignTag removes a tag from an idea+func (s *TagStorage) UnassignTag(tagID, ideaID int) error {+ assigned := s.assigned[ideaID]+ if assigned != nil {+ for i, tag := range assigned {+ if tag.ID == tagID {+ s.assigned[ideaID] = append(s.assigned[ideaID][:i], s.assigned[ideaID][i+1:]...)+ return nil+ }+ }+ }+ return nil+}++// GetAssigned returns all tags assigned to given idea+func (s *TagStorage) GetAssigned(ideaID int) ([]*models.Tag, error) {+ assigned := s.assigned[ideaID]+ if assigned != nil {+ return assigned, nil+ }+ return make([]*models.Tag, 0), nil+}diff --git a/app/storage/postgres/tag.go b/app/storage/postgres/tag.gonew file mode 100644index 000000000..98e621f42--- /dev/null+++ b/app/storage/postgres/tag.go@@ -0,0 +1,145 @@+package postgres++import (+ "database/sql"+ "time"++ "github.com/getfider/fider/app"+ "github.com/getfider/fider/app/models"+ "github.com/getfider/fider/app/pkg/dbx"+ "github.com/gosimple/slug"+)++type dbTag struct {+ ID int `db:"id"`+ Name string `db:"name"`+ Slug string `db:"slug"`+ Color string `db:"color"`+ IsPublic bool `db:"is_public"`+}++func (t *dbTag) toModel() *models.Tag {+ return &models.Tag{+ ID: t.ID,+ Name: t.Name,+ Slug: t.Slug,+ Color: t.Color,+ IsPublic: t.IsPublic,+ }+}++// TagStorage contains read and write operations for tags+type TagStorage struct {+ trx *dbx.Trx+ tenant *models.Tenant+}++// NewTagStorage creates a new TagStorage+func NewTagStorage(tenant *models.Tenant, trx *dbx.Trx) *TagStorage {+ return &TagStorage{+ trx: trx,+ tenant: tenant,+ }+}++// Add creates a new tag with given input+func (s *TagStorage) Add(name, color string, isPublic bool) (*models.Tag, error) {+ tagSlug := slug.Make(name)++ var id int+ row := s.trx.QueryRow(`+ INSERT INTO tags (name, slug, color, is_public, created_on, tenant_id)+ VALUES ($1, $2, $3, $4, $5, $6) RETURNING id+ `, name, tagSlug, color, isPublic, time.Now(), s.tenant.ID)+ if err := row.Scan(&id); err != nil {+ return nil, err+ }++ return s.GetBySlug(tagSlug)+}++// GetBySlug returns tag by given slug+func (s *TagStorage) GetBySlug(slug string) (*models.Tag, error) {+ tag := dbTag{}++ err := s.trx.Get(&tag, "SELECT id, name, slug, color, is_public FROM tags WHERE tenant_id = $1 AND slug = $2", s.tenant.ID, slug)+ if err == sql.ErrNoRows {+ return nil, app.ErrNotFound+ } else if err != nil {+ return nil, err+ }++ return tag.toModel(), nil+}++// Update a tag with given input+func (s *TagStorage) Update(tagID int, name, color string, isPublic bool) (*models.Tag, error) {+ tagSlug := slug.Make(name)++ err := s.trx.Execute(`UPDATE tags SET name = $1, slug = $2, color = $3, is_public = $4+ WHERE id = $5 AND tenant_id = $6`, name, tagSlug, color, isPublic, tagID, s.tenant.ID)+ if err != nil {+ return nil, err+ }++ return s.GetBySlug(tagSlug)+}++// Remove a tag by its id+func (s *TagStorage) Remove(tagID int) error {+ err := s.trx.Execute(`DELETE FROM idea_tags WHERE tag_id = $1`, tagID)+ if err != nil {+ return err+ }+ return s.trx.Execute(`DELETE FROM tags WHERE id = $1 AND tenant_id = $2;`, tagID, s.tenant.ID)+}++// AssignTag adds a tag to an idea+func (s *TagStorage) AssignTag(tagID, ideaID, userID int) error {+ alreadyAssigned, err := s.trx.Exists("SELECT 1 FROM idea_tags WHERE idea_id = $1", ideaID)+ if err != nil {+ return err+ }++ if alreadyAssigned {+ return nil+ }++ if err := s.trx.Execute(+ `INSERT INTO idea_tags (tag_id, idea_id, created_on, created_by_id) VALUES ($1, $2, $3, $4)`,+ tagID, ideaID, time.Now(), userID,+ ); err != nil {+ return err+ }++ return nil+}++// UnassignTag removes a tag from an idea+func (s *TagStorage) UnassignTag(tagID, ideaID int) error {+ return s.trx.Execute(+ `DELETE FROM idea_tags WHERE tag_id = $1 AND idea_id = $2`,+ tagID, ideaID,+ )+}++// GetAssigned returns all tags assigned to given idea+func (s *TagStorage) GetAssigned(ideaID int) ([]*models.Tag, error) {+ tags := []*dbTag{}+ err := s.trx.Select(&tags, `+ SELECT t.id, t.name, t.slug, t.color, t.is_public+ FROM tags t+ INNER JOIN idea_tags it+ ON it.tag_id = t.id+ WHERE it.idea_id = $1 AND t.tenant_id = $2+ `, ideaID, s.tenant.ID)+ if err != nil {+ return nil, err+ }++ var result = make([]*models.Tag, len(tags))+ for i, tag := range tags {+ result[i] = tag.toModel()+ }+ return result, nil+}diff --git a/app/storage/postgres/tag_test.go b/app/storage/postgres/tag_test.gonew file mode 100644index 000000000..a7fa7d3e5--- /dev/null+++ b/app/storage/postgres/tag_test.go@@ -0,0 +1,142 @@+package postgres_test++import (+ "testing"++ "github.com/getfider/fider/app"+ "github.com/getfider/fider/app/pkg/dbx"+ "github.com/getfider/fider/app/storage/postgres"+ . "github.com/onsi/gomega"+)++func TestTagStorage_AddAndGet(t *testing.T) {+ RegisterTestingT(t)+ db, _ := dbx.New()+ db.Seed()+ defer db.Close()++ trx, _ := db.Begin()+ defer trx.Rollback()++ tenants := postgres.NewTenantStorage(trx)+ tags := postgres.NewTagStorage(demoTenant(tenants), trx)+ tag, err := tags.Add("Feature Request", "FF0000", true)+ Expect(err).To(BeNil())+ Expect(tag.ID).To(Equal(1))++ dbTag, err := tags.GetBySlug("feature-request")++ Expect(err).To(BeNil())+ Expect(dbTag.ID).To(Equal(1))+ Expect(dbTag.Name).To(Equal("Feature Request"))+ Expect(dbTag.Slug).To(Equal("feature-request"))+ Expect(dbTag.Color).To(Equal("FF0000"))+ Expect(dbTag.IsPublic).To(BeTrue())+}++func TestTagStorage_AddUpdateAndGet(t *testing.T) {+ RegisterTestingT(t)+ db, _ := dbx.New()+ db.Seed()+ defer db.Close()++ trx, _ := db.Begin()+ defer trx.Rollback()++ tenants := postgres.NewTenantStorage(trx)+ tags := postgres.NewTagStorage(demoTenant(tenants), trx)+ tag, err := tags.Add("Feature Request", "FF0000", true)+ tag, err = tags.Update(tag.ID, "Bug", "000000", false)++ dbTag, err := tags.GetBySlug("bug")++ Expect(err).To(BeNil())+ Expect(dbTag.ID).To(Equal(1))+ Expect(dbTag.Name).To(Equal("Bug"))+ Expect(dbTag.Slug).To(Equal("bug"))+ Expect(dbTag.Color).To(Equal("000000"))+ Expect(dbTag.IsPublic).To(BeFalse())+}++func TestTagStorage_AddRemoveAndGet(t *testing.T) {+ RegisterTestingT(t)+ db, _ := dbx.New()+ db.Seed()+ defer db.Close()++ trx, _ := db.Begin()+ defer trx.Rollback()++ tenants := postgres.NewTenantStorage(trx)+ tags := postgres.NewTagStorage(demoTenant(tenants), trx)+ tag, err := tags.Add("Bug", "FFFFFF", true)++ err = tags.Remove(tag.ID)+ Expect(err).To(BeNil())++ dbTag, err := tags.GetBySlug("bug")++ Expect(err).To(Equal(app.ErrNotFound))+ Expect(dbTag).To(BeNil())+}++func TestTagStorage_Assign_Unassign(t *testing.T) {+ RegisterTestingT(t)+ db, _ := dbx.New()+ db.Seed()+ defer db.Close()++ trx, _ := db.Begin()+ defer trx.Rollback()++ tenants := postgres.NewTenantStorage(trx)+ ideas := postgres.NewIdeaStorage(demoTenant(tenants), trx)+ tags := postgres.NewTagStorage(demoTenant(tenants), trx)+ idea, _ := ideas.Add("My great idea", "with a great description", 2)+ tag, _ := tags.Add("Bug", "FFFFFF", true)++ err := tags.AssignTag(tag.ID, idea.ID, 2)+ Expect(err).To(BeNil())++ assigned, err := tags.GetAssigned(idea.ID)+ Expect(err).To(BeNil())+ Expect(len(assigned)).To(Equal(1))+ Expect(assigned[0].ID).To(Equal(tag.ID))+ Expect(assigned[0].Name).To(Equal("Bug"))+ Expect(assigned[0].Slug).To(Equal("bug"))+ Expect(assigned[0].Color).To(Equal("FFFFFF"))+ Expect(assigned[0].IsPublic).To(BeTrue())++ err = tags.UnassignTag(tag.ID, idea.ID)+ Expect(err).To(BeNil())++ assigned, err = tags.GetAssigned(idea.ID)+ Expect(err).To(BeNil())+ Expect(len(assigned)).To(Equal(0))+}++func TestTagStorage_Assign_RemoveTag(t *testing.T) {+ RegisterTestingT(t)+ db, _ := dbx.New()+ db.Seed()+ defer db.Close()++ trx, _ := db.Begin()+ defer trx.Rollback()++ tenants := postgres.NewTenantStorage(trx)+ ideas := postgres.NewIdeaStorage(demoTenant(tenants), trx)+ tags := postgres.NewTagStorage(demoTenant(tenants), trx)+ idea, _ := ideas.Add("My great idea", "with a great description", 2)+ tag, _ := tags.Add("Bug", "FFFFFF", true)++ err := tags.AssignTag(tag.ID, idea.ID, 2)+ Expect(err).To(BeNil())++ err = tags.Remove(tag.ID)+ Expect(err).To(BeNil())++ assigned, err := tags.GetAssigned(idea.ID)+ Expect(err).To(BeNil())+ Expect(len(assigned)).To(Equal(0))+}diff --git a/app/storage/storage.go b/app/storage/storage.goindex dc9ebaf09..0ff26d6d0 100644--- a/app/storage/storage.go+++ b/app/storage/storage.go@@ -47,3 +47,14 @@ type Tenant interface {SetKeyAsVerified(key string) errorSetCurrentTenant(*models.Tenant)}++// Tag contains read and write operations for tags+type Tag interface {+ Add(name, color string, isPublic bool) (*models.Tag, error)+ GetBySlug(slug string) (*models.Tag, error)+ Update(tagID int, name, color string, isPublic bool) (*models.Tag, error)+ Remove(tagID int) error+ GetAssigned(ideaID int) ([]*models.Tag, error)+ AssignTag(tagID, ideaID, userID int) error+ UnassignTag(tagID, ideaID int) error+}diff --git a/migrations/201711152138_create_tags.up.sql b/migrations/201711152138_create_tags.up.sqlnew file mode 100644index 000000000..2c78929fb--- /dev/null+++ b/migrations/201711152138_create_tags.up.sql@@ -0,0 +1,21 @@+create table if not exists tags (+ id serial primary key,+ tenant_id int not null,+ name varchar(30) not null,+ slug varchar(30) not null,+ color varchar(6) not null,+ is_public boolean not null,+ created_on timestamptz not null,+ foreign key (tenant_id) references tenants(id)+);++create table if not exists idea_tags (+ tag_id int not null,+ idea_id int not null,+ created_on timestamptz not null,+ created_by_id int not null,+ primary key (tag_id, idea_id),+ foreign key (idea_id) references ideas(id),+ foreign key (tag_id) references tags(id),+ foreign key (created_by_id) references users(id)+);\ No newline at end of filediff --git a/migrations/201711181740_create_uniq_indexes.up.sql b/migrations/201711181740_create_uniq_indexes.up.sqlnew file mode 100644index 000000000..8ef7331b6--- /dev/null+++ b/migrations/201711181740_create_uniq_indexes.up.sql@@ -0,0 +1,2 @@+CREATE UNIQUE INDEX idea_number_tenant_key ON ideas (tenant_id, number);+CREATE UNIQUE INDEX tag_slug_tenant_key ON tags (tenant_id, slug);\ No newline at end of file