// Pm handles the request and returns the specified Private Message
func Pm() echo.HandlerFunc {
// swagger:route GET /me/pms/{other}/{pmid} user pms GetUserPm
//
// Update the speficied post on the specified user board
//
// Consumes:
// - application/json
//
// Produces:
// - application/json
//
// Security:
// oauth: pms:read
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("pms:read", c) {
return rest.InvalidScopeResponse("pms:read", c)
}
pm := c.Get("pm").(*nerdz.Pm)
me := c.Get("me").(*nerdz.User)
return rest.SelectFields(pm.GetTO(me), c)
}
}
// Whitelist handles the request and returns the user whitelist
func Whitelist() echo.HandlerFunc {
// swagger:route GET /users/{id}/whitelist user whitelist GetWhitelist
//
// Show the whitelist of the specified user
//
// You can personalize the request via query string parameters
//
// Produces:
// - application/json
//
// Security:
// oauth: profile:read
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("profile:read", c) {
return rest.InvalidScopeResponse("profile:read", c)
}
whitelist := c.Get("other").(*nerdz.User).Whitelist()
return rest.SelectFields(rest.GetUsersInfo(whitelist), c)
}
}
// PostComment handles the request and returns the single comment required
func PostComment() echo.HandlerFunc {
// swagger:route GET /projects/{id}/posts/{pid}/comments/{cid} project post comment GetProjectPostComment
//
// Shows selected comment on specified post, filtered by some parameters.
//
// You can personalize the request via query string parameters
//
// Produces:
// - application/json
//
// Security:
// oauth: project_comments:read
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("project_comments:read", c) {
return rest.InvalidScopeResponse("project_comments:read", c)
}
comment := c.Get("comment").(*nerdz.ProjectPostComment)
me := c.Get("me").(*nerdz.User)
return rest.SelectFields(comment.GetTO(me), c)
}
}
// Followers handles the request and returns the project followers
func Followers() echo.HandlerFunc {
// swagger:route GET /projects/{id}/followers project info followers getProjectFollowers
//
// Shows the followers informations for the specified project
//
// You can personalize the request via query string parameters
//
// Produces:
// - application/json
//
// Security:
// oauth: projects:read
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("projects:read", c) {
return rest.InvalidScopeResponse("projects:read", c)
}
followers := c.Get("project").(*nerdz.Project).Followers()
return rest.SelectFields(rest.GetUsersInfo(followers), c)
}
}
// Post handles the request and returns the single post required
func Post() echo.HandlerFunc {
// swagger:route GET /projects/{id}/posts/{pid} project post getProjectPost
//
// Shows selected posts with id pid on specified project board
//
// This will show the last comments on the post by default.
// You can personalize the request via query string parameters
//
// Produces:
// - application/json
//
// Security:
// oauth: project_messages:read
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("project_messages:read", c) {
return rest.InvalidScopeResponse("project_messages:read", c)
}
me := c.Get("me").(*nerdz.User)
postTO := c.Get("post").(*nerdz.ProjectPost).GetTO(me)
return rest.SelectFields(postTO, c)
}
}
// UserFollowing handles the request and returns the user following
func UserFollowing() echo.HandlerFunc {
// swagger:route GET /users/{id}/following/users user info following GetUserFollowing
//
// Shows the following informations for the specified user
//
// You can personalize the request via query string parameters
//
// Produces:
// - application/json
//
// Security:
// oauth: profile:read
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("profile:read", c) {
return rest.InvalidScopeResponse("profile:read", c)
}
following := c.Get("other").(*nerdz.User).UserFollowing()
return rest.SelectFields(rest.GetUsersInfo(following), c)
}
}
// Blacklisting handles the request and returns the user blacklisting
func Blacklisting() echo.HandlerFunc {
// swagger:route GET /users/{id}/blacklisting user blacklisting GetWhitelisting
//
// Show the user that placed the specified user in their blacklist
//
// You can personalize the request via query string parameters
//
// Produces:
// - application/json
//
// Security:
// oauth: profile:read
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("profile:read", c) {
return rest.InvalidScopeResponse("profile:read", c)
}
blacklisting := c.Get("other").(*nerdz.User).Blacklisting()
return rest.SelectFields(rest.GetUsersInfo(blacklisting), c)
}
}
// NewBlacklisted handles the request and creates and adds target user to current user whitelist
func NewBlacklisted() echo.HandlerFunc {
// swagger:route POST /me/whitelist/{target} user whitelist NewBlacklisted
//
// Adds target to the whitelist of the current user
//
// Produces:
// - application/json
//
// Consumes:
// - application/json
//
// Security:
// oauth: profile:write
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("profile:write", c) {
return rest.InvalidScopeResponse("profile:write", c)
}
var target *nerdz.User
var err error
if target, err = rest.User("target", c); err != nil {
return err
}
// Read a rest.NewMessage from the body request.
message := rest.NewMessage{}
if err := c.Bind(&message); err != nil {
errstr := err.Error()
c.JSON(http.StatusBadRequest, &rest.Response{
Data: nil,
HumanMessage: errstr,
Message: errstr,
Status: http.StatusBadRequest,
Success: false,
})
return errors.New(errstr)
}
me := c.Get("me").(*nerdz.User)
if err = me.BlacklistUser(target, message.Message); err != nil {
errstr := err.Error()
c.JSON(http.StatusBadRequest, &rest.Response{
Data: nil,
HumanMessage: errstr,
Message: errstr,
Status: http.StatusBadRequest,
Success: false,
})
return errors.New(errstr)
}
// Return selected field from the followed User
return rest.SelectFields(target.GetTO(me), c)
}
}
// NewPostCommentVote handles the request and creates a new vote on the user comment post
func NewPostCommentVote() echo.HandlerFunc {
// swagger:route POST /projects/{id}/posts/{pid}/comments/{cid}votes project post comment vote NewProjectPostCommentVote
//
// Adds a new vote on the current project post comment
//
// Consumes:
// - application/json
//
// Produces:
// - application/json
//
// Security:
// oauth: project_comments:write
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("project_comments:write", c) {
return rest.InvalidScopeResponse("project_comments:write", c)
}
// Read a rest.NewVote from the body request.
body := rest.NewVote{}
if err := c.Bind(&body); err != nil {
errstr := err.Error()
c.JSON(http.StatusBadRequest, &rest.Response{
Data: nil,
HumanMessage: errstr,
Message: errstr,
Status: http.StatusBadRequest,
Success: false,
})
return errors.New(errstr)
}
// Send it
me := c.Get("me").(*nerdz.User)
comment := c.Get("comment").(*nerdz.ProjectPostComment)
vote, err := me.Vote(comment, body.Vote)
if err != nil {
errstr := err.Error()
c.JSON(http.StatusBadRequest, &rest.Response{
Data: nil,
HumanMessage: errstr,
Message: errstr,
Status: http.StatusBadRequest,
Success: false,
})
return errors.New(errstr)
}
// Extract the TO from the new post and return
// selected fields.
return rest.SelectFields(vote.(*nerdz.ProjectPostCommentVote).GetTO(me), c)
}
}
// DeletePostUserLock handles the request and deletes the lock for the notification of the target user
// on the specified post
func DeletePostUserLock() echo.HandlerFunc {
// swagger:route DELETE /projects/{id}/posts/{pid}/locks/{target} project post vote DeleteProjectPostUserLock
//
// Deletes the lock for the notification of the target user on the specified post
//
// Consumes:
// - application/json
//
// Produces:
// - application/json
//
// Security:
// oauth: project_messages:write
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("project_messages:write", c) {
return rest.InvalidScopeResponse("project_messages:write", c)
}
var target *nerdz.User
var err error
if target, err = rest.User("target", c); err != nil {
return err
}
me := c.Get("me").(*nerdz.User)
post := c.Get("post").(*nerdz.ProjectPost)
err = me.Unlock(post, target)
if err != nil {
errstr := err.Error()
c.JSON(http.StatusBadRequest, &rest.Response{
Data: nil,
HumanMessage: errstr,
Message: errstr,
Status: http.StatusBadRequest,
Success: false,
})
return errors.New(errstr)
}
errstr := "Success"
c.JSON(http.StatusOK, &rest.Response{
Data: nil,
HumanMessage: errstr,
Message: errstr,
Status: http.StatusOK,
Success: true,
})
return nil
}
}
// DeleteConversation handles the request and deletes the conversation
func DeleteConversation() echo.HandlerFunc {
// swagger:route DELETE /me/pms/{other} user pms DeleteUserPms
//
// Delete the conversation beteen the current user and other
//
// Consumes:
// - application/json
//
// Produces:
// - application/json
//
// Security:
// oauth: pms:write
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("pms:write", c) {
return rest.InvalidScopeResponse("pms:write", c)
}
var other *nerdz.User
var err error
if other, err = rest.User("other", c); err != nil {
return err
}
me := c.Get("me").(*nerdz.User)
if err = me.DeleteConversation(other.ID()); err != nil {
errstr := err.Error()
c.JSON(http.StatusBadRequest, &rest.Response{
Data: nil,
HumanMessage: errstr,
Message: errstr,
Status: http.StatusBadRequest,
Success: false,
})
return errors.New(errstr)
}
message := "Success"
c.JSON(http.StatusOK, &rest.Response{
Data: nil,
HumanMessage: message,
Message: message,
Status: http.StatusOK,
Success: true,
})
return nil
}
}
// Posts handles the request and returns the required posts written by the specified project
func Posts() echo.HandlerFunc {
// swagger:route GET /projects/{id}/posts project posts getProjectPosts
//
// List posts on project board, filtered by some parameters.
//
// This will show the last posts on the project board by default.
// You can personalize the request via query string parameters
//
// Produces:
// - application/json
//
// Security:
// oauth: project_messages:read
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("project_messages:read", c) {
return rest.InvalidScopeResponse("project_messages:read", c)
}
project := c.Get("project").(*nerdz.Project)
options := c.Get("postlistOptions").(*nerdz.PostlistOptions)
options.Model = nerdz.ProjectPost{}
posts := project.Postlist(*options)
if posts == nil {
errstr := "Unable to fetch post list for the specified project"
c.JSON(http.StatusBadRequest, &rest.Response{
HumanMessage: errstr,
Message: "project.Postlist error",
Status: http.StatusBadRequest,
Success: false,
})
return errors.New(errstr)
}
me := c.Get("me").(*nerdz.User)
var postsAPI []*nerdz.PostTO
for _, p := range *posts {
// posts contains ExistingPost elements
// we need to convert back to a ProjectPost in order to get a correct PostTO
if projectPost := p.(*nerdz.ProjectPost); projectPost != nil {
postsAPI = append(postsAPI, projectPost.GetTO(me))
}
}
return rest.SelectFields(postsAPI, c)
}
}
// Conversation handles the request and returns the user private conversation with the other user
func Conversation() echo.HandlerFunc {
// swagger:route GET /me/pms/{other} user post pms getUserConversation
//
// Returns the private conversation of the current user with the other user
//
// You can personalize the request via query string parameters
//
// Produces:
// - application/json
//
// Security:
// oauth: profile:read
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("pms:read", c) {
return rest.InvalidScopeResponse("pms:read", c)
}
var other *nerdz.User
var err error
if other, err = rest.User("other", c); err != nil {
return err
}
// fetch conversation between me and other
var conversation *[]nerdz.Pm
options := c.Get("pmsOptions").(*nerdz.PmsOptions)
me := c.Get("me").(*nerdz.User)
conversation, err = me.Pms(other.ID(), *options)
if err != nil {
errstr := "Unable to fetch conversation with the specified user"
c.JSON(http.StatusBadRequest, &rest.Response{
HumanMessage: errstr,
Message: "me.Conversation error",
Status: http.StatusBadRequest,
Success: false,
})
return errors.New(errstr)
}
var conversationTO []*nerdz.PmTO
for _, pm := range *conversation {
conversationTO = append(conversationTO, pm.GetTO(me))
}
return rest.SelectFields(conversationTO, c)
}
}
// DeletePostLurk handles the request and deletes the lurk to the post
func DeletePostLurk() echo.HandlerFunc {
// swagger:route DELETE /projects/{id}/posts/{pid}/lurks project post vote DeleteProjectPostLurk
//
// Deletes the lurk on the current post
//
// Consumes:
// - application/json
//
// Produces:
// - application/json
//
// Security:
// oauth: project_messages:write
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("project_messages:write", c) {
return rest.InvalidScopeResponse("project_messages:write", c)
}
// Send it
me := c.Get("me").(*nerdz.User)
post := c.Get("post").(*nerdz.ProjectPost)
err := me.Unlurk(post)
if err != nil {
errstr := err.Error()
c.JSON(http.StatusBadRequest, &rest.Response{
Data: nil,
HumanMessage: errstr,
Message: errstr,
Status: http.StatusBadRequest,
Success: false,
})
return errors.New(errstr)
}
errstr := "Success"
c.JSON(http.StatusOK, &rest.Response{
Data: nil,
HumanMessage: errstr,
Message: errstr,
Status: http.StatusOK,
Success: true,
})
return nil
}
}
// DeleteBlacklisted handles the request and deletes the target user from the current user whitelist
func DeleteBlacklisted() echo.HandlerFunc {
// swagger:route DELETE /me/following/users/{target} user blacklist DeleteBlacklisted
//
// Deletes target user from the current user blacklist
//
// Consumes:
// - application/json
//
// Security:
// oauth: profile:write
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("profile:write", c) {
return rest.InvalidScopeResponse("profile:write", c)
}
var target *nerdz.User
var err error
if target, err = rest.User("target", c); err != nil {
return err
}
me := c.Get("me").(*nerdz.User)
if err = me.UnblacklistUser(target); err != nil {
errstr := err.Error()
c.JSON(http.StatusBadRequest, &rest.Response{
Data: nil,
HumanMessage: errstr,
Message: errstr,
Status: http.StatusBadRequest,
Success: false,
})
return errors.New(errstr)
}
message := "Success"
c.JSON(http.StatusOK, &rest.Response{
Data: nil,
HumanMessage: message,
Message: message,
Status: http.StatusOK,
Success: true,
})
return nil
}
}
// NewPostComment handles the request and creates a new post
func NewPostComment() echo.HandlerFunc {
// swagger:route POST /projects/{id}/posts/{pid}/comments project post comment NewProjectPostComment
//
// Creates a new post on the specified project board
//
// Consumes:
// - application/json
//
// Produces:
// - application/json
//
// Security:
// oauth: project_comments:write
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("project_comments:write", c) {
return rest.InvalidScopeResponse("project_comments:write", c)
}
// Read a rest.Message from the body request.
message := rest.NewMessage{}
if err := c.Bind(&message); err != nil {
return err
}
// Create a nerdz.ProjectPostComment from the message
// and current context.
comment := nerdz.ProjectPostComment{}
comment.Message = message.Message
comment.Lang = message.Lang
comment.To = c.Get("project").(*nerdz.Project).ID()
comment.Hpid = c.Get("post").(*nerdz.ProjectPost).ID()
// Send it
me := c.Get("me").(*nerdz.User)
if err := me.Add(&comment); err != nil {
return err
}
// Extract the TO from the new post and return
// selected fields.
return rest.SelectFields(comment.GetTO(me), c)
}
}
// NewPostUserLock handles the request and creates a new lock for the notification
// caused by the target user
func NewPostUserLock() echo.HandlerFunc {
// swagger:route POST /projects/{id}/posts/{pid}/locks/{target} project post vote NewUserNewPostUserLock
//
// Locks the notification from the target user to the current logged user, on the specified post
//
// Consumes:
// - application/json
//
// Produces:
// - application/json
//
// Security:
// oauth: project_messages:write
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("project_messages:write", c) {
return rest.InvalidScopeResponse("project_messages:write", c)
}
var target *nerdz.User
var err error
if target, err = rest.User("target", c); err != nil {
return err
}
me := c.Get("me").(*nerdz.User)
post := c.Get("post").(*nerdz.ProjectPost)
var lock *[]nerdz.Lock
lock, err = me.Lock(post, target)
if err != nil {
errstr := err.Error()
c.JSON(http.StatusBadRequest, &rest.Response{
Data: nil,
HumanMessage: errstr,
Message: errstr,
Status: http.StatusBadRequest,
Success: false,
})
return errors.New(errstr)
}
// Extract the TO from the new lock and return selected fields.
return rest.SelectFields((*lock)[0].(*nerdz.ProjectPostUserLock).GetTO(me), c)
}
}
// DeletePm handles the request and deletes the pm
func DeletePm() echo.HandlerFunc {
// swagger:route DELETE /me/pms/{other}/{pmid} user pm DeleteUserPm
//
// Delete the speficied pm in the conversation with the other user
//
// Consumes:
// - application/json
//
// Produces:
// - application/json
//
// Security:
// oauth: pms:write
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("pms:write", c) {
return rest.InvalidScopeResponse("pms:write", c)
}
pm := c.Get("pm").(*nerdz.Pm)
me := c.Get("me").(*nerdz.User)
if err := me.Delete(pm); err != nil {
errstr := err.Error()
c.JSON(http.StatusBadRequest, &rest.Response{
Data: nil,
HumanMessage: errstr,
Message: errstr,
Status: http.StatusBadRequest,
Success: false,
})
return errors.New(errstr)
}
message := "Success"
c.JSON(http.StatusOK, &rest.Response{
Data: nil,
HumanMessage: message,
Message: message,
Status: http.StatusOK,
Success: true,
})
return nil
}
}
// EditPostComment handles the request and edits the post comment
func EditPostComment() echo.HandlerFunc {
// swagger:route PUT /projects/{id}/posts/{pid}/comments/{cid} project post comment EditProjectPost
//
// Update the speficied post on the specified project board
//
// Consumes:
// - application/json
//
// Produces:
// - application/json
//
// Security:
// oauth: project_comments:write
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("project_comments:write", c) {
return rest.InvalidScopeResponse("project_comments:write", c)
}
// Read a rest.Message from the body request.
message := rest.NewMessage{}
if err := c.Bind(&message); err != nil {
return err
}
comment := c.Get("comment").(*nerdz.ProjectPostComment)
// Update filds
comment.Message = message.Message
if comment.Lang != "" {
comment.Lang = message.Lang
}
// Edit
me := c.Get("me").(*nerdz.User)
if err := me.Edit(comment); err != nil {
return err
}
// Extract the TO from the comment and return selected fields.
return rest.SelectFields(comment.GetTO(me), c)
}
}
// PostComments handles the request and returns the specified list of comments
func PostComments() echo.HandlerFunc {
// swagger:route GET /users/{id}/posts/{pid}/comments user post comments GetUserPostComments
//
// List comments on specified post, filtered by some parameters.
//
// This will show the last posts on the user board by default.
// You can personalize the request via query string parameters
//
// Produces:
// - application/json
//
// Security:
// oauth: profile_comments:read
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("profile_comments:read", c) {
return rest.InvalidScopeResponse("profile_comments:read", c)
}
comments := c.Get("post").(*nerdz.UserPost).Comments(*(c.Get("commentlistOptions").(*nerdz.CommentlistOptions)))
if comments == nil {
errstr := "Unable to fetch comment list for the specified post"
c.JSON(http.StatusBadRequest, &rest.Response{
HumanMessage: errstr,
Message: "UserPost.Comments(options) error",
Status: http.StatusBadRequest,
Success: false,
})
return errors.New(errstr)
}
var commentsAPI []*nerdz.UserPostCommentTO
me := c.Get("me").(*nerdz.User)
for _, p := range *comments {
// comments contains ExistingPost elements
// we need to convert back to a UserPostComment in order to get a correct UserPostCommentTO
if userPostComment := p.(*nerdz.UserPostComment); userPostComment != nil {
commentsAPI = append(commentsAPI, userPostComment.GetTO(me))
}
}
return rest.SelectFields(commentsAPI, c)
}
}
// Home handles the request and returns the user home
func Home() echo.HandlerFunc {
// swagger:route GET /me/home user post home getUserHome
//
// Shows the homepage of the current user, mixing projects and users posts
//
// You can personalize the request via query string parameters
//
// Produces:
// - application/json
//
// Security:
// oauth: profile:read
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("messages:read", c) {
return rest.InvalidScopeResponse("messages:read", c)
}
me := c.Get("me").(*nerdz.User)
options := c.Get("postlistOptions").(*nerdz.PostlistOptions)
posts := me.Home(*options)
if posts == nil {
errstr := "Unable to fetch home page for the specified user"
c.JSON(http.StatusBadRequest, &rest.Response{
HumanMessage: errstr,
Message: "me.Home error",
Status: http.StatusBadRequest,
Success: false,
})
return errors.New(errstr)
}
var postsAPI []*nerdz.PostTO
for _, p := range *posts {
postsAPI = append(postsAPI, p.GetTO(me))
}
return rest.SelectFields(postsAPI, c)
}
}
// DeletePostComment handles the request and deletes the specified
// comment on the speficied post
func DeletePostComment() echo.HandlerFunc {
// swagger:route DELETE /users/{id}/posts/{pid}/comments/{cid} user post DeleteUserPostComment
//
// Delete the specified comment on the speficied user post
//
// Produces:
// - application/json
//
// Security:
// oauth: profile_comments:write
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("profile_comments:write", c) {
return rest.InvalidScopeResponse("profile_comments:write", c)
}
comment := c.Get("comment").(*nerdz.UserPostComment)
me := c.Get("me").(*nerdz.User)
if err := me.Delete(comment); err != nil {
errstr := err.Error()
c.JSON(http.StatusBadRequest, &rest.Response{
Data: nil,
HumanMessage: errstr,
Message: errstr,
Status: http.StatusBadRequest,
Success: false,
})
return errors.New(errstr)
}
errstr := "Success"
c.JSON(http.StatusOK, &rest.Response{
Data: nil,
HumanMessage: errstr,
Message: errstr,
Status: http.StatusOK,
Success: true,
})
return nil
}
}
// PostLurks handles the request and returns the post lurks
func PostLurks() echo.HandlerFunc {
// swagger:route GET /projects/{id}/posts/{pid}/lurks project post bookmarks GetProjectPostLurks
//
// List the lurks of the post
//
//
// Produces:
// - application/json
//
// Security:
// oauth: project_messages:read
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("project_messages:read", c) {
return rest.InvalidScopeResponse("project_messages:read", c)
}
lurks := c.Get("post").(*nerdz.ProjectPost).Lurks()
if lurks == nil {
errstr := "Unable to fetch lurks for the specified post"
c.JSON(http.StatusBadRequest, &rest.Response{
HumanMessage: errstr,
Message: "ProjectPost.Lurks() error",
Status: http.StatusBadRequest,
Success: false,
})
return errors.New(errstr)
}
var lurksTO []*nerdz.ProjectPostLurkTO
me := c.Get("me").(*nerdz.User)
for _, v := range *lurks {
// lurks contains Lurk elements
// we need to convert back to a ProjectPostLurk in order to get a correct ProjectPostLurkTO
if userPostLurk := v.(*nerdz.ProjectPostLurk); userPostLurk != nil {
lurksTO = append(lurksTO, userPostLurk.GetTO(me))
}
}
return rest.SelectFields(lurksTO, c)
}
}
// NewPostLurk handles the request and creates a new lurk for the post
func NewPostLurk() echo.HandlerFunc {
// swagger:route POST /projects/{id}/posts/{pid}/lurks project post vote NewProjectPostLurk
//
// Adds a new lurk on the current post
//
// Consumes:
// - application/json
//
// Produces:
// - application/json
//
// Security:
// oauth: project_messages:write
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("project_messages:write", c) {
return rest.InvalidScopeResponse("project_messages:write", c)
}
// Send it
me := c.Get("me").(*nerdz.User)
post := c.Get("post").(*nerdz.ProjectPost)
lurk, err := me.Lurk(post)
if err != nil {
errstr := err.Error()
c.JSON(http.StatusBadRequest, &rest.Response{
Data: nil,
HumanMessage: errstr,
Message: errstr,
Status: http.StatusBadRequest,
Success: false,
})
return errors.New(errstr)
}
// Extract the TO from the new post and return
// selected fields.
return rest.SelectFields(lurk.(*nerdz.ProjectPostLurk).GetTO(me), c)
}
}
// PostCommentVotes handles the request and returns the comment votes
func PostCommentVotes() echo.HandlerFunc {
// swagger:route GET /projects/{id}/posts/{pid}/comments/{cid}/votes project post comments votes GetProjectPostCommentsVotes
//
// List the votes on the comment
//
// Produces:
// - application/json
//
// Security:
// oauth: project_comments:read
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("project_comments:read", c) {
return rest.InvalidScopeResponse("project_comments:read", c)
}
votes := c.Get("comment").(*nerdz.ProjectPostComment).Votes()
if votes == nil {
errstr := "Unable to fetch votes for the specified post"
c.JSON(http.StatusBadRequest, &rest.Response{
HumanMessage: errstr,
Message: "ProjectPostComment.Votes() error",
Status: http.StatusBadRequest,
Success: false,
})
return errors.New(errstr)
}
var votesTO []*nerdz.ProjectPostCommentVoteTO
me := c.Get("me").(*nerdz.User)
for _, v := range *votes {
// votes contains Vote elements
// we need to convert back to a ProjectPostCommentVote in order to get a correct ProjectPostCommentVoteTO
if userPostCommentVote := v.(*nerdz.ProjectPostCommentVote); userPostCommentVote != nil {
votesTO = append(votesTO, userPostCommentVote.GetTO(me))
}
}
return rest.SelectFields(votesTO, c)
}
}
// Conversations handles the request and returns the user private conversations
func Conversations() echo.HandlerFunc {
// swagger:route GET /me/pms user post pms getUserPms
//
// Shows the list of the private conversation of the current user
//
// You can personalize the request via query string parameters
//
// Produces:
// - application/json
//
// Security:
// oauth: profile:read
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("pms:read", c) {
return rest.InvalidScopeResponse("pms:read", c)
}
me := c.Get("me").(*nerdz.User)
conversations, e := me.Conversations()
if e != nil {
errstr := "Unable to fetch conversations for the specified user"
c.JSON(http.StatusBadRequest, &rest.Response{
HumanMessage: errstr,
Message: "me.Conversations error",
Status: http.StatusBadRequest,
Success: false,
})
return errors.New(errstr)
}
var conversationsTO []*nerdz.ConversationTO
for _, c := range *conversations {
conversationsTO = append(conversationsTO, c.GetTO(me))
}
return rest.SelectFields(conversationsTO, c)
}
}
// NewProjectFollowing handles the request and creates and adds target to the following list of the current user
func NewProjectFollowing() echo.HandlerFunc {
// swagger:route POST /me/following/projects/{target} project following NewProjectFollowing
//
// Adds target project to the following list of the current user
//
// Produces:
// - application/json
//
// Security:
// oauth: following:write
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("following:write", c) {
return rest.InvalidScopeResponse("following:write", c)
}
var target *nerdz.Project
var err error
if target, err = rest.Project("target", c); err != nil {
return err
}
me := c.Get("me").(*nerdz.User)
if err = me.Follow(target); err != nil {
errstr := err.Error()
c.JSON(http.StatusBadRequest, &rest.Response{
Data: nil,
HumanMessage: errstr,
Message: errstr,
Status: http.StatusBadRequest,
Success: false,
})
return errors.New(errstr)
}
// Return selected field from the followed Project
return rest.SelectFields(target.GetTO(me), c)
}
}
// DeletePost handles the request and deletes the specified post
func DeletePost() echo.HandlerFunc {
// swagger:route DELETE /projects/{id}/posts/{pid} project post DeleteProjectPost
//
// Delete the post on the specified project board
//
// Consumes:
// - application/json
//
// Produces:
// - application/json
//
// Security:
// oauth: project_messages:write
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("project_messages:write", c) {
return rest.InvalidScopeResponse("project_messages:write", c)
}
post := c.Get("post").(*nerdz.ProjectPost)
me := c.Get("me").(*nerdz.User)
if err := me.Delete(post); err != nil {
return err
}
errstr := "Success"
c.JSON(http.StatusOK, &rest.Response{
Data: nil,
HumanMessage: errstr,
Message: errstr,
Status: http.StatusOK,
Success: true,
})
return nil
}
}
// NewPostComment handles the request and creates a new post
func NewPostComment() echo.HandlerFunc {
// swagger:route POST /users/{id}/posts/{pid}/comments user post comment NewUserPostComment
//
// Creates a new post on the specified user board
//
// Consumes:
// - application/json
//
// Produces:
// - application/json
//
// Security:
// oauth: profile_comments:write
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("profile_comments:write", c) {
return rest.InvalidScopeResponse("profile_comments:write", c)
}
// Read a rest.NewMessage from the body request.
message := rest.NewMessage{}
if err := c.Bind(&message); err != nil {
errstr := err.Error()
c.JSON(http.StatusBadRequest, &rest.Response{
Data: nil,
HumanMessage: errstr,
Message: errstr,
Status: http.StatusBadRequest,
Success: false,
})
return errors.New(errstr)
}
// Create a nerdz.UserPostComment from the message
// and current context.
comment := nerdz.UserPostComment{}
comment.Message = message.Message
comment.Lang = message.Lang
comment.To = c.Get("other").(*nerdz.User).ID()
comment.Hpid = c.Get("post").(*nerdz.UserPost).ID()
// Send it
me := c.Get("me").(*nerdz.User)
if err := me.Add(&comment); err != nil {
errstr := err.Error()
c.JSON(http.StatusBadRequest, &rest.Response{
Data: nil,
HumanMessage: errstr,
Message: errstr,
Status: http.StatusBadRequest,
Success: false,
})
return errors.New(errstr)
}
// Extract the TO from the new post and return
// selected fields.
return rest.SelectFields(comment.GetTO(me), c)
}
}
// EditPostComment handles the request and edits the post comment
func EditPostComment() echo.HandlerFunc {
// swagger:route PUT /users/{id}/posts/{pid}/comments/{cid} user post comment EditUserPost
//
// Update the speficied post on the specified user board
//
// Consumes:
// - application/json
//
// Produces:
// - application/json
//
// Security:
// oauth: profile_comments:write
//
// Responses:
// default: apiResponse
return func(c echo.Context) error {
if !rest.IsGranted("profile_comments:write", c) {
return rest.InvalidScopeResponse("profile_comments:write", c)
}
// Read a rest.NewMessage from the body request.
message := rest.NewMessage{}
if err := c.Bind(&message); err != nil {
errstr := err.Error()
c.JSON(http.StatusBadRequest, &rest.Response{
Data: nil,
HumanMessage: errstr,
Message: errstr,
Status: http.StatusBadRequest,
Success: false,
})
return errors.New(errstr)
}
comment := c.Get("comment").(*nerdz.UserPostComment)
// Update filds
comment.Message = message.Message
if comment.Lang != "" {
comment.Lang = message.Lang
}
// Edit
me := c.Get("me").(*nerdz.User)
if err := me.Edit(comment); err != nil {
errstr := err.Error()
c.JSON(http.StatusBadRequest, &rest.Response{
Data: nil,
HumanMessage: errstr,
Message: errstr,
Status: http.StatusBadRequest,
Success: false,
})
return errors.New(errstr)
}
// Extract the TO from the comment and return selected fields.
return rest.SelectFields(comment.GetTO(me), c)
}
}