Skip to content

armgit / fider

Public Imported from GitHub
0

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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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.go
index 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 status
IdeaNew = 0
diff --git a/app/pkg/jsonq/jsonq.go b/app/pkg/jsonq/jsonq.go
index 1518483a2..3afabeefd 100644
--- a/app/pkg/jsonq/jsonq.go
+++ b/app/pkg/jsonq/jsonq.go
@@ -2,6 +2,7 @@ package jsonq
import (
"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.go
index 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.go
index 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.go
index 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 reflect
str = 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.go
index 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.go
index 1db386483..b24ef730a 100644
--- a/app/services.go
+++ b/app/services.go
@@ -10,6 +10,7 @@ import (
type Services struct {
OAuth oauth.Service
Users storage.User
+ Tags storage.Tag
Tenants storage.Tenant
Ideas storage.Idea
Emailer email.Sender
diff --git a/app/storage/inmemory/tag.go b/app/storage/inmemory/tag.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index dc9ebaf09..0ff26d6d0 100644
--- a/app/storage/storage.go
+++ b/app/storage/storage.go
@@ -47,3 +47,14 @@ type Tenant interface {
SetKeyAsVerified(key string) error
SetCurrentTenant(*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.sql
new file mode 100644
index 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 file
diff --git a/migrations/201711181740_create_uniq_indexes.up.sql b/migrations/201711181740_create_uniq_indexes.up.sql
new file mode 100644
index 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