func Get(u *url.URL, h http.Header, _ interface{}, ctx *models.Context) (int, http.Header, interface{}, error) {
cm, err := getMessageByUrl(u)
if err != nil {
return response.NewBadRequest(err)
}
if cm.Id == 0 {
return response.NewNotFound()
}
ch, err := models.Cache.Channel.ById(cm.InitialChannelId)
if err != nil {
response.NewBadRequest(err)
}
canOpen, err := ch.CanOpen(ctx.Client.Account.Id)
if err != nil {
return response.NewBadRequest(err)
}
if !canOpen {
return response.NewAccessDenied(models.ErrCannotOpenChannel)
}
cmc := models.NewChannelMessageContainer()
return response.HandleResultAndError(cmc, cmc.Fetch(cm.Id, request.GetQuery(u)))
}
func GetWithRelated(u *url.URL, h http.Header, _ interface{}, ctx *models.Context) (int, http.Header, interface{}, error) {
cm, err := getMessageByUrl(u)
if err != nil {
return response.NewBadRequest(err)
}
if cm.Id == 0 {
return response.NewNotFound()
}
ch, err := models.Cache.Channel.ById(cm.InitialChannelId)
if err != nil {
return response.NewBadRequest(err)
}
q := request.GetQuery(u)
query := ctx.OverrideQuery(q)
canOpen, err := ch.CanOpen(query.AccountId)
if err != nil {
return response.NewBadRequest(err)
}
if !canOpen {
return response.NewBadRequest(models.ErrCannotOpenChannel)
}
cmc := models.NewChannelMessageContainer()
if err := cmc.Fetch(cm.Id, query); err != nil {
return response.NewBadRequest(err)
}
return response.HandleResultAndError(cmc, cmc.Err)
}
func GetPostBySlug(slug string, accountId int64) (*models.ChannelMessageContainer, error) {
url := fmt.Sprintf("/message/slug/%s?accountId=%d", slug, accountId)
cmc := models.NewChannelMessageContainer()
cmI, err := sendModel("GET", url, cmc)
if err != nil {
return nil, err
}
return cmI.(*models.ChannelMessageContainer), nil
}
func createPostRequest(channelId int64, model interface{}, h http.Header) (*models.ChannelMessage, error) {
url := fmt.Sprintf("/channel/%d/message", channelId)
res, err := marshallAndSendRequestWithHeader("POST", url, model, h)
if err != nil {
return nil, err
}
container := models.NewChannelMessageContainer()
err = json.Unmarshal(res, container)
if err != nil {
return nil, err
}
return container.Message, nil
}
func Update(u *url.URL, h http.Header, req *models.ChannelMessage, c *models.Context) (int, http.Header, interface{}, error) {
if !c.IsLoggedIn() {
return response.NewBadRequest(models.ErrAccessDenied)
}
id, err := request.GetURIInt64(u, "id")
if err != nil {
return response.NewBadRequest(err)
}
body := req.Body
payload := req.Payload
if err := req.ById(id); err != nil {
if err == bongo.RecordNotFound {
return response.NewNotFound()
}
return response.NewBadRequest(err)
}
if req.AccountId != c.Client.Account.Id {
isAdmin, err := modelhelper.IsAdmin(c.Client.Account.Nick, c.GroupName)
if err != nil {
return response.NewBadRequest(err)
}
if !isAdmin {
return response.NewBadRequest(models.ErrAccessDenied)
}
}
if req.Id == 0 {
return response.NewBadRequest(err)
}
req.Body = body
req.Payload = payload
if err := req.Update(); err != nil {
return response.NewBadRequest(err)
}
cmc := models.NewChannelMessageContainer()
return response.HandleResultAndError(cmc, cmc.Fetch(id, request.GetQuery(u)))
}
func CreatePostWithBodyAndAuth(channelId int64, body, token string) (*models.ChannelMessage, error) {
url := fmt.Sprintf("/channel/%d/message", channelId)
cm := models.NewChannelMessage()
cm.Body = body
res, err := marshallAndSendRequestWithAuth("POST", url, cm, token)
if err != nil {
return nil, err
}
container := models.NewChannelMessageContainer()
err = json.Unmarshal(res, container)
if err != nil {
return nil, err
}
return container.Message, nil
}
func GetBySlug(u *url.URL, h http.Header, _ interface{}, ctx *models.Context) (int, http.Header, interface{}, error) {
q := request.GetQuery(u)
if q.Slug == "" {
return response.NewBadRequest(errors.New("slug is not set"))
}
cm := models.NewChannelMessage()
if err := cm.BySlug(q); err != nil {
if err == bongo.RecordNotFound {
return response.NewNotFound()
}
return response.NewBadRequest(err)
}
ch := models.NewChannel()
if err := ch.ById(cm.InitialChannelId); err != nil {
return response.NewBadRequest(err)
}
query := ctx.OverrideQuery(q)
// check if user can open
canOpen, err := ch.CanOpen(query.AccountId)
if err != nil {
return response.NewBadRequest(err)
}
if !canOpen {
return response.NewBadRequest(models.ErrCannotOpenChannel)
}
cmc := models.NewChannelMessageContainer()
if err := cmc.Fetch(cm.Id, query); err != nil {
return response.NewBadRequest(err)
}
return response.HandleResultAndError(cmc, cmc.Err)
}
func Create(u *url.URL, h http.Header, req *models.ChannelMessage, c *models.Context) (int, http.Header, interface{}, error) {
if !c.IsLoggedIn() {
return response.NewBadRequest(models.ErrAccessDenied)
}
channelId, err := fetchInitialChannelId(u, c)
if err != nil {
return response.NewBadRequest(err)
}
ch := models.NewChannel()
if err := ch.ById(channelId); err != nil {
return response.NewBadRequest(models.ErrChannelNotFound)
}
canOpen, err := ch.CanOpen(c.Client.Account.Id)
if err != nil {
return response.NewBadRequest(err)
}
if !canOpen {
return response.NewBadRequest(models.ErrCannotOpenChannel)
}
// override message type
// all of the messages coming from client-side
// should be marked as POST
req.TypeConstant = models.ChannelMessage_TYPE_POST
req.InitialChannelId = channelId
req.AccountId = c.Client.Account.Id
if req.Payload == nil {
req.Payload = gorm.Hstore{}
}
if c.Client.Account.IsShareLocationEnabled() {
// gets the IP of the Client
// and adds it to the payload of the ChannelMessage
location := parseLocation(c)
req.Payload["location"] = location
}
if err := checkThrottle(channelId, req.AccountId); err != nil {
return response.NewBadRequest(err)
}
if err := req.Create(); err != nil {
// todo this should be internal server error
return response.NewBadRequest(err)
}
cml := models.NewChannelMessageList()
// override channel id
cml.ChannelId = channelId
cml.MessageId = req.Id
cml.ClientRequestId = req.ClientRequestId
if err := cml.Create(); err != nil && !models.IsUniqueConstraintError(err) {
// todo this should be internal server error
return response.NewBadRequest(err)
}
cmc := models.NewChannelMessageContainer()
err = cmc.Fetch(req.Id, request.GetQuery(u))
if err != nil {
return response.NewBadRequest(err)
}
// assign client request id back to message response because
// client uses it for latency compansation
cmc.Message.ClientRequestId = req.ClientRequestId
return response.HandleResultAndError(cmc, err)
}