func setLastViewedAt(c *Context, w http.ResponseWriter, r *http.Request) {
params := mux.Vars(r)
id := params["channel_id"]
data := model.StringInterfaceFromJson(r.Body)
newLastViewedAt := int64(data["last_viewed_at"].(float64))
Srv.Store.Channel().SetLastViewedAt(id, c.Session.UserId, newLastViewedAt)
preference := model.Preference{
UserId: c.Session.UserId,
Category: model.PREFERENCE_CATEGORY_LAST,
Name: model.PREFERENCE_NAME_LAST_CHANNEL,
Value: id,
}
Srv.Store.Preference().Save(&model.Preferences{preference})
message := model.NewWebSocketEvent(model.WEBSOCKET_EVENT_CHANNEL_VIEWED, c.TeamId, "", c.Session.UserId, nil)
message.Add("channel_id", id)
go Publish(message)
result := make(map[string]string)
result["id"] = id
w.Write([]byte(model.MapToJson(result)))
}
func updateLastViewedAt(c *Context, w http.ResponseWriter, r *http.Request) {
params := mux.Vars(r)
id := params["channel_id"]
data := model.StringInterfaceFromJson(r.Body)
var active bool
var ok bool
if active, ok = data["active"].(bool); !ok {
active = true
}
doClearPush := false
if *utils.Cfg.EmailSettings.SendPushNotifications && !c.Session.IsMobileApp() && active {
if result := <-Srv.Store.User().GetUnreadCountForChannel(c.Session.UserId, id); result.Err != nil {
l4g.Error(utils.T("api.channel.update_last_viewed_at.get_unread_count_for_channel.error"), c.Session.UserId, id, result.Err.Error())
} else {
if result.Data.(int64) > 0 {
doClearPush = true
}
}
}
go func() {
if err := SetActiveChannel(c.Session.UserId, id); err != nil {
l4g.Error(err.Error())
}
}()
Srv.Store.Channel().UpdateLastViewedAt(id, c.Session.UserId)
// Must be after update so that unread count is correct
if doClearPush {
go clearPushNotification(c.Session.UserId, id)
}
preference := model.Preference{
UserId: c.Session.UserId,
Category: model.PREFERENCE_CATEGORY_LAST,
Name: model.PREFERENCE_NAME_LAST_CHANNEL,
Value: id,
}
Srv.Store.Preference().Save(&model.Preferences{preference})
message := model.NewWebSocketEvent(model.WEBSOCKET_EVENT_CHANNEL_VIEWED, c.TeamId, "", c.Session.UserId, nil)
message.Add("channel_id", id)
go Publish(message)
result := make(map[string]string)
result["id"] = id
w.Write([]byte(model.MapToJson(result)))
}
func searchPosts(c *Context, w http.ResponseWriter, r *http.Request) {
props := model.StringInterfaceFromJson(r.Body)
terms := props["terms"].(string)
if len(terms) == 0 {
c.SetInvalidParam("search", "terms")
return
}
isOrSearch := false
if val, ok := props["is_or_search"]; ok && val != nil {
isOrSearch = val.(bool)
}
paramsList := model.ParseSearchParams(terms)
channels := []store.StoreChannel{}
for _, params := range paramsList {
params.OrTerms = isOrSearch
// don't allow users to search for everything
if params.Terms != "*" {
channels = append(channels, Srv.Store.Post().Search(c.TeamId, c.Session.UserId, params))
}
}
posts := &model.PostList{}
for _, channel := range channels {
if result := <-channel; result.Err != nil {
c.Err = result.Err
return
} else {
data := result.Data.(*model.PostList)
posts.Extend(data)
}
}
w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
w.Write([]byte(posts.ToJson()))
}
func (u *User) handleWsActionPost(rmsg *model.WebSocketEvent) {
var ch Channel
data := model.PostFromJson(strings.NewReader(rmsg.Data["post"].(string)))
props := rmsg.Data
extraProps := model.StringInterfaceFromJson(strings.NewReader(rmsg.Data["post"].(string)))["props"].(map[string]interface{})
logger.Debugf("handleWsActionPost() receiving userid %s", data.UserId)
if data.UserId == u.mc.User.Id {
// space + ZWSP
if strings.Contains(data.Message, " ") {
logger.Debugf("message is sent from IRC, contains unicode, not relaying %#v", data.Message)
return
}
if data.Type == "system_join_leave" {
logger.Debugf("our own join/leave message. not relaying %#v", data.Message)
return
}
}
// create new "ghost" user
ghost := u.createMMUser(u.mc.GetUser(data.UserId))
// our own message, set our IRC self as user, not our mattermost self
if data.UserId == u.mc.User.Id {
ghost = u
}
spoofUsername := ghost.Nick
// check if we have a override_username (from webhooks) and use it
overrideUsername, _ := extraProps["override_username"].(string)
if overrideUsername != "" {
// only allow valid irc nicks
re := regexp.MustCompile("^[a-zA-Z0-9_]*$")
if re.MatchString(overrideUsername) {
spoofUsername = overrideUsername
}
}
msgs := strings.Split(data.Message, "\n")
// direct message
if props["channel_type"] == "D" {
// our own message, ignore because we can't handle/fake those on IRC
if data.UserId == u.mc.User.Id {
return
}
}
// not a private message so do channel stuff
if props["channel_type"] != "D" {
ch = u.Srv.Channel(data.ChannelId)
// join if not in channel
if !ch.HasUser(ghost) {
ch.Join(ghost)
}
}
// check if we have a override_username (from webhooks) and use it
for _, m := range msgs {
if m == "" {
continue
}
if props["channel_type"] == "D" {
u.MsgSpoofUser(spoofUsername, m)
} else {
ch.SpoofMessage(spoofUsername, m)
}
}
if len(data.Filenames) > 0 {
logger.Debugf("files detected")
for _, fname := range u.mc.GetPublicLinks(data.Filenames) {
if props["channel_type"] == "D" {
u.MsgSpoofUser(spoofUsername, "download file - "+fname)
} else {
ch.SpoofMessage(spoofUsername, "download file - "+fname)
}
}
}
logger.Debugf("handleWsActionPost() user %s sent %s", u.mc.GetUser(data.UserId).Username, data.Message)
logger.Debugf("%#v", data)
// updatelastviewed
u.mc.UpdateLastViewed(data.ChannelId)
}