func List(u *url.URL, h http.Header, _ interface{}) (int, http.Header, interface{}, error) {
messageId, err := request.GetURIInt64(u, "id")
if err != nil {
return response.NewBadRequest(err)
}
accountId, err := request.GetURIInt64(u, "accountId")
if err != nil {
return response.NewBadRequest(err)
}
reply := models.NewMessageReply()
reply.MessageId = messageId
messages, err := reply.List(request.GetQuery(u))
if err != nil {
return response.NewBadRequest(err)
}
return response.HandleResultAndError(
helpers.ConvertMessagesToMessageContainers(
messages,
accountId,
),
)
}
// calculateUnreadItemCount calculates the unread count for given participant in
// given channel
func (cue *channelUpdatedEvent) calculateUnreadItemCount() (int, error) {
if cue.Channel == nil {
return 0, models.ErrChannelIsNotSet
}
// channel type can only be
//
// PinnedActivity
// PrivateMessage
// Topic
if !cue.Channel.ShowUnreadCount() {
return 0, fmt.Errorf("not supported channel type for unread count calculation %+v", cue.Channel.TypeConstant)
}
// we need channel participant for their latest appearence in regarding channel
if cue.ChannelParticipant == nil {
return 0, models.ErrChannelParticipantIsNotSet
}
// Topic channels and private messages have the normal structure, one
// channel, many messages, many participants. For them unread count will be
// calculated from unread post count whithin a channel, base timestamp here
// is persisted in ChannelParticipant table as LastSeenAt timestamp.
//
// If one message is edited by another user with a new tag, this message
// will not be marked as read, because we are not looking to createdAt of
// the channel message list, we are taking AddedAt into consideration here
if cue.Channel.TypeConstant != models.Channel_TYPE_PINNED_ACTIVITY {
return models.NewChannelMessageList().UnreadCount(cue.ChannelParticipant)
}
// from this point we need parent message
if cue.ParentChannelMessage == nil {
return 0, models.ErrParentMessageIsNotSet
}
if cue.ParentChannelMessage.Id == 0 {
return 0, models.ErrParentMessageIdIsNotSet
}
cml, err := cue.Channel.FetchMessageList(cue.ParentChannelMessage.Id)
if err != nil {
return 0, err
}
// check if the participant is troll
isRecieverTroll := cue.ChannelParticipant.MetaBits.Is(models.Troll)
// for pinned posts we are calculating unread count from reviseddAt of the
// regarding channel message list, since only participant for the channel is
// the owner and we cant use channel_participant for unread counts on the
// other hand messages should have their own unread count we are
// specialcasing the pinned posts here
return models.NewMessageReply().UnreadCount(cml.MessageId, cml.RevisedAt, isRecieverTroll)
}
func Create(u *url.URL, h http.Header, reply *models.ChannelMessage, c *models.Context) (int, http.Header, interface{}, error) {
parentId, err := request.GetURIInt64(u, "id")
if err != nil {
return response.NewBadRequest(err)
}
// fetch the parent message
parent, err := models.Cache.Message.ById(parentId)
if err != nil {
return response.NewBadRequest(err)
}
parentChannel, err := models.Cache.Channel.ById(parent.InitialChannelId)
if err != nil {
return response.NewBadRequest(err)
}
canOpen, err := parentChannel.CanOpen(c.Client.Account.Id)
if err != nil {
return response.NewBadRequest(err)
}
if !canOpen {
return response.NewAccessDenied(models.ErrCannotOpenChannel)
}
// first create reply as a message
reply.TypeConstant = models.ChannelMessage_TYPE_REPLY
// set initial channel id for message creation
reply.InitialChannelId = parent.InitialChannelId
reply.AccountId = c.Client.Account.Id
if err := reply.Create(); err != nil {
// todo this should be internal server error
return response.NewBadRequest(err)
}
// then add this message as a reply to a parent message
mr := models.NewMessageReply()
mr.MessageId = parentId
mr.ReplyId = reply.Id
mr.CreatedAt = reply.CreatedAt
mr.ClientRequestId = reply.ClientRequestId
if err := mr.Create(); err != nil {
// todo this should be internal server error
return response.NewBadRequest(err)
}
return response.HandleResultAndError(
reply.BuildEmptyMessageContainer(),
)
}
func addRepliesToMessage(channelId, accountId, messageId int64) {
// add replies to the message
rply1 := models.NewChannelMessage()
rply1.AccountId = accountId
rply1.InitialChannelId = channelId
rply1.TypeConstant = models.ChannelMessage_TYPE_REPLY
rply1.Body = "hello reply all from test"
So(rply1.Create(), ShouldBeNil)
mr := models.NewMessageReply()
mr.ReplyId = rply1.Id
mr.MessageId = messageId
So(mr.Create(), ShouldBeNil)
}
func Delete(u *url.URL, h http.Header, _ interface{}) (int, http.Header, interface{}, error) {
parentId, err := request.GetURIInt64(u, "id")
if err != nil {
return response.NewBadRequest(err)
}
if parentId == 0 {
// todo add proper logging
return response.NewBadRequest(err)
}
replyId, err := request.GetURIInt64(u, "replyId")
if err != nil {
return response.NewBadRequest(err)
}
if replyId == 0 {
// todo add proper logging
return response.NewBadRequest(err)
}
// first delete the connection between message and the reply
mr := models.NewMessageReply()
mr.MessageId = parentId
mr.ReplyId = replyId
if err := mr.Delete(); err != nil {
return response.NewBadRequest(err)
}
// then delete the message itself
reply := models.NewChannelMessage()
reply.Id = replyId
if err := reply.Delete(); err != nil {
return response.NewBadRequest(err)
}
// yes it is deleted but not removed completely from our system
return response.NewDeleted()
}
// this is a TEMP function just for @usirin
func TempList(u *url.URL, h http.Header, _ interface{}, context *models.Context) (int, http.Header, interface{}, error) {
channelId, err := request.GetURIInt64(u, "id")
if err != nil {
return response.NewBadRequest(err)
}
query := request.GetQuery(u)
query = context.OverrideQuery(query)
c, err := models.Cache.Channel.ById(channelId)
if err != nil {
return response.NewBadRequest(err)
}
// if channel is exempt and user should see the
// content, return not found err
if !query.ShowExempt {
query.ShowExempt = context.Client.Account.IsTroll
}
if c.MetaBits.Is(models.Troll) && !query.ShowExempt {
return response.NewNotFound()
}
// check if channel is accessible by the requester
canOpen, err := c.CanOpen(query.AccountId)
if err != nil {
return response.NewBadRequest(err)
}
if !canOpen {
return response.NewAccessDenied(
fmt.Errorf(
"account (%d) tried to retrieve the unattended private channel (%d)",
query.AccountId,
c.Id,
))
}
bq := &bongo.Query{
Selector: map[string]interface{}{
"initial_channel_id": c.Id,
},
Pagination: *bongo.NewPagination(query.Limit, query.Skip),
Pluck: "id",
}
bq.AddScope(models.SortedByCreatedAt)
bq.AddScope(models.RemoveTrollContent(c, query.ShowExempt))
bq.AddScope(models.ExcludeFields(query.Exclude))
bq.AddScope(models.TillTo(query.From))
bqq := bongo.B.BuildQuery(models.NewChannelMessage(), bq)
var messages []int64
if err := bongo.CheckErr(
bqq.Pluck(bq.Pluck, &messages),
); err != nil {
return response.NewBadRequest(err)
}
// get the messages in regarding channel
cmcs, err := models.
NewChannelMessageList().
PopulateChannelMessages(
messages, query,
)
if err != nil {
return response.NewBadRequest(err)
}
// reduce replies
replyIds := make([]int64, 0)
for i := range cmcs {
cmc := cmcs[i]
if cmc.Message.TypeConstant == models.ChannelMessage_TYPE_REPLY {
replyIds = append(replyIds, cmc.Message.Id)
}
}
if len(replyIds) == 0 {
return response.NewOK(cmcs)
}
// select replies
var mrs []models.MessageReply
gerr := bongo.B.
BuildQuery(models.NewMessageReply(), &bongo.Query{}).
Where("reply_id in (?)", replyIds).
Find(&mrs)
if err := bongo.CheckErr(gerr); err != nil {
return response.NewBadRequest(err)
}
// set their parent ids
for j, mr := range mrs {
for i := range cmcs {
if mr.ReplyId == cmcs[i].Message.Id {
cmcs[i].ParentID = mrs[j].MessageId
}
}
}
// send response
return response.NewOK(cmcs)
}
func Delete(u *url.URL, h http.Header, _ interface{}, c *models.Context) (int, http.Header, interface{}, error) {
if !c.IsLoggedIn() {
return response.NewAccessDenied(models.ErrNotLoggedIn)
}
id, err := request.GetURIInt64(u, "id")
if err != nil {
return response.NewBadRequest(err)
}
if id == 0 {
return response.NewBadRequest(models.ErrMessageIdIsNotSet)
}
cm := models.NewChannelMessage()
cm.Id = id
if err := cm.ById(id); err != nil {
if err == bongo.RecordNotFound {
return response.NewNotFound()
}
return response.NewBadRequest(err)
}
// Add isAdmin checking
// is user is admin, then can delete another user's message
if cm.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 this is a reply no need to delete it's replies
if cm.TypeConstant == models.ChannelMessage_TYPE_REPLY {
mr := models.NewMessageReply()
mr.ReplyId = id
parent, err := mr.FetchParent()
if err != nil {
return response.NewBadRequest(err)
}
// delete the message here
err = cm.DeleteMessageAndDependencies(false)
// then invalidate the cache of the parent message
bongo.B.AddToCache(parent)
} else {
err = cm.DeleteMessageAndDependencies(true)
}
if err != nil {
return response.NewBadRequest(err)
}
// yes it is deleted but not removed completely from our system
return response.NewDeleted()
}