func TestChannelStoreGet(t *testing.T) { Setup() o1 := model.Channel{} o1.TeamId = model.NewId() o1.DisplayName = "Name" o1.Name = "a" + model.NewId() + "b" o1.Type = model.CHANNEL_OPEN Must(store.Channel().Save(&o1)) if r1 := <-store.Channel().Get(o1.Id); r1.Err != nil { t.Fatal(r1.Err) } else { if r1.Data.(*model.Channel).ToJson() != o1.ToJson() { t.Fatal("invalid returned channel") } } if err := (<-store.Channel().Get("")).Err; err == nil { t.Fatal("Missing id should have failed") } u1 := model.User{} u1.TeamId = model.NewId() u1.Email = model.NewId() u1.Nickname = model.NewId() Must(store.User().Save(&u1)) u2 := model.User{} u2.TeamId = model.NewId() u2.Email = model.NewId() u2.Nickname = model.NewId() Must(store.User().Save(&u2)) o2 := model.Channel{} o2.TeamId = model.NewId() o2.DisplayName = "Direct Name" o2.Name = "a" + model.NewId() + "b" o2.Type = model.CHANNEL_DIRECT m1 := model.ChannelMember{} m1.ChannelId = o2.Id m1.UserId = u1.Id m1.NotifyProps = model.GetDefaultChannelNotifyProps() m2 := model.ChannelMember{} m2.ChannelId = o2.Id m2.UserId = u2.Id m2.NotifyProps = model.GetDefaultChannelNotifyProps() Must(store.Channel().SaveDirectChannel(&o2, &m1, &m2)) if r2 := <-store.Channel().Get(o2.Id); r2.Err != nil { t.Fatal(r2.Err) } else { if r2.Data.(*model.Channel).ToJson() != o2.ToJson() { t.Fatal("invalid returned channel") } } }
func JoinDefaultChannels(user *model.User, channelRole string) *model.AppError { // We don't call JoinChannel here since c.Session is not populated on user creation var err *model.AppError = nil if result := <-Srv.Store.Channel().GetByName(user.TeamId, "town-square"); result.Err != nil { err = result.Err } else { cm := &model.ChannelMember{ChannelId: result.Data.(*model.Channel).Id, UserId: user.Id, Roles: channelRole, NotifyProps: model.GetDefaultChannelNotifyProps()} if cmResult := <-Srv.Store.Channel().SaveMember(cm); cmResult.Err != nil { err = cmResult.Err } } if result := <-Srv.Store.Channel().GetByName(user.TeamId, "off-topic"); result.Err != nil { err = result.Err } else { cm := &model.ChannelMember{ChannelId: result.Data.(*model.Channel).Id, UserId: user.Id, Roles: channelRole, NotifyProps: model.GetDefaultChannelNotifyProps()} if cmResult := <-Srv.Store.Channel().SaveMember(cm); cmResult.Err != nil { err = cmResult.Err } } return err }
func CreateDirectChannel(userId string, otherUserId string) (*model.Channel, *model.AppError) { uc := Srv.Store.User().Get(otherUserId) channel := new(model.Channel) channel.DisplayName = "" channel.Name = model.GetDMNameFromIds(otherUserId, userId) channel.Header = "" channel.Type = model.CHANNEL_DIRECT if uresult := <-uc; uresult.Err != nil { return nil, model.NewLocAppError("CreateDirectChannel", "api.channel.create_direct_channel.invalid_user.app_error", nil, otherUserId) } cm1 := &model.ChannelMember{ UserId: userId, NotifyProps: model.GetDefaultChannelNotifyProps(), } cm2 := &model.ChannelMember{ UserId: otherUserId, NotifyProps: model.GetDefaultChannelNotifyProps(), } if result := <-Srv.Store.Channel().SaveDirectChannel(channel, cm1, cm2); result.Err != nil { if result.Err.Id == store.CHANNEL_EXISTS_ERROR { return result.Data.(*model.Channel), nil } else { return nil, result.Err } } else { return result.Data.(*model.Channel), nil } }
func TestMyTeamMembersUnread(t *testing.T) { Setup() teamId1 := model.NewId() teamId2 := model.NewId() uid := model.NewId() m1 := &model.TeamMember{TeamId: teamId1, UserId: uid} m2 := &model.TeamMember{TeamId: teamId2, UserId: uid} Must(store.Team().SaveMember(m1)) Must(store.Team().SaveMember(m2)) c1 := &model.Channel{TeamId: m1.TeamId, Name: model.NewId(), DisplayName: "Town Square", Type: model.CHANNEL_OPEN} Must(store.Channel().Save(c1)) c2 := &model.Channel{TeamId: m2.TeamId, Name: model.NewId(), DisplayName: "Town Square", Type: model.CHANNEL_OPEN} Must(store.Channel().Save(c2)) cm1 := &model.ChannelMember{ChannelId: c1.Id, UserId: m1.UserId, NotifyProps: model.GetDefaultChannelNotifyProps()} Must(store.Channel().SaveMember(cm1)) cm2 := &model.ChannelMember{ChannelId: c2.Id, UserId: m2.UserId, NotifyProps: model.GetDefaultChannelNotifyProps()} Must(store.Channel().SaveMember(cm2)) if r1 := <-store.Team().GetTeamsUnreadForUser("", uid); r1.Err != nil { t.Fatal(r1.Err) } else { ms := r1.Data.([]*model.ChannelUnread) membersMap := make(map[string]bool) for i := range ms { id := ms[i].TeamId if _, ok := membersMap[id]; !ok { membersMap[id] = true } } if len(membersMap) != 2 { t.Fatal("Should be the unreads for all the teams") } } if r2 := <-store.Team().GetTeamsUnreadForUser(teamId1, uid); r2.Err != nil { t.Fatal(r2.Err) } else { ms := r2.Data.([]*model.ChannelUnread) membersMap := make(map[string]bool) for i := range ms { id := ms[i].TeamId if _, ok := membersMap[id]; !ok { membersMap[id] = true } } if len(membersMap) != 1 { t.Fatal("Should be the unreads for just one team") } } if r1 := <-store.Team().RemoveAllMembersByUser(uid); r1.Err != nil { t.Fatal(r1.Err) } }
func TestGetMember(t *testing.T) { Setup() userId := model.NewId() c1 := &model.Channel{ TeamId: model.NewId(), DisplayName: model.NewId(), Name: model.NewId(), Type: model.CHANNEL_OPEN, } Must(store.Channel().Save(c1)) c2 := &model.Channel{ TeamId: c1.TeamId, DisplayName: model.NewId(), Name: model.NewId(), Type: model.CHANNEL_OPEN, } Must(store.Channel().Save(c2)) m1 := &model.ChannelMember{ ChannelId: c1.Id, UserId: userId, NotifyProps: model.GetDefaultChannelNotifyProps(), } Must(store.Channel().SaveMember(m1)) m2 := &model.ChannelMember{ ChannelId: c2.Id, UserId: userId, NotifyProps: model.GetDefaultChannelNotifyProps(), } Must(store.Channel().SaveMember(m2)) if result := <-store.Channel().GetMember(model.NewId(), userId); result.Err == nil { t.Fatal("should've failed to get member for non-existant channel") } if result := <-store.Channel().GetMember(c1.Id, model.NewId()); result.Err == nil { t.Fatal("should've failed to get member for non-existant user") } if result := <-store.Channel().GetMember(c1.Id, userId); result.Err != nil { t.Fatal("shouldn't have errored when getting member", result.Err) } else if member := result.Data.(model.ChannelMember); member.ChannelId != c1.Id { t.Fatal("should've gotten member of channel 1") } else if member.UserId != userId { t.Fatal("should've gotten member for user") } if result := <-store.Channel().GetMember(c2.Id, userId); result.Err != nil { t.Fatal("shouldn't have errored when getting member", result.Err) } else if member := result.Data.(model.ChannelMember); member.ChannelId != c2.Id { t.Fatal("should've gotten member of channel 2") } else if member.UserId != userId { t.Fatal("should've gotten member for user") } }
func JoinDefaultChannels(teamId string, user *model.User, channelRole string) *model.AppError { // We don't call JoinChannel here since c.Session is not populated on user creation var err *model.AppError = nil fakeContext := &Context{ Session: model.Session{ UserId: user.Id, }, TeamId: teamId, T: utils.TfuncWithFallback(user.Locale), } if result := <-Srv.Store.Channel().GetByName(teamId, "town-square"); result.Err != nil { err = result.Err } else { cm := &model.ChannelMember{ChannelId: result.Data.(*model.Channel).Id, UserId: user.Id, Roles: channelRole, NotifyProps: model.GetDefaultChannelNotifyProps()} if cmResult := <-Srv.Store.Channel().SaveMember(cm); cmResult.Err != nil { err = cmResult.Err } post := &model.Post{ ChannelId: result.Data.(*model.Channel).Id, Message: fmt.Sprintf(utils.T("api.channel.join_channel.post_and_forget"), user.Username), Type: model.POST_JOIN_LEAVE, UserId: user.Id, } if _, err := CreatePost(fakeContext, post, false); err != nil { l4g.Error(utils.T("api.channel.post_user_add_remove_message_and_forget.error"), err) } } if result := <-Srv.Store.Channel().GetByName(teamId, "off-topic"); result.Err != nil { err = result.Err } else { cm := &model.ChannelMember{ChannelId: result.Data.(*model.Channel).Id, UserId: user.Id, Roles: channelRole, NotifyProps: model.GetDefaultChannelNotifyProps()} if cmResult := <-Srv.Store.Channel().SaveMember(cm); cmResult.Err != nil { err = cmResult.Err } post := &model.Post{ ChannelId: result.Data.(*model.Channel).Id, Message: fmt.Sprintf(utils.T("api.channel.join_channel.post_and_forget"), user.Username), Type: model.POST_JOIN_LEAVE, UserId: user.Id, } if _, err := CreatePost(fakeContext, post, false); err != nil { l4g.Error(utils.T("api.channel.post_user_add_remove_message_and_forget.error"), err) } } return err }
func TestChannelDeleteMemberStore(t *testing.T) { Setup() c1 := model.Channel{} c1.TeamId = model.NewId() c1.DisplayName = "NameName" c1.Name = "a" + model.NewId() + "b" c1.Type = model.CHANNEL_OPEN c1 = *Must(store.Channel().Save(&c1)).(*model.Channel) c1t1 := (<-store.Channel().Get(c1.Id)).Data.(*model.Channel) t1 := c1t1.ExtraUpdateAt u1 := model.User{} u1.Email = model.NewId() u1.Nickname = model.NewId() Must(store.User().Save(&u1)) Must(store.Team().SaveMember(&model.TeamMember{TeamId: model.NewId(), UserId: u1.Id})) u2 := model.User{} u2.Email = model.NewId() u2.Nickname = model.NewId() Must(store.User().Save(&u2)) Must(store.Team().SaveMember(&model.TeamMember{TeamId: model.NewId(), UserId: u2.Id})) o1 := model.ChannelMember{} o1.ChannelId = c1.Id o1.UserId = u1.Id o1.NotifyProps = model.GetDefaultChannelNotifyProps() Must(store.Channel().SaveMember(&o1)) o2 := model.ChannelMember{} o2.ChannelId = c1.Id o2.UserId = u2.Id o2.NotifyProps = model.GetDefaultChannelNotifyProps() Must(store.Channel().SaveMember(&o2)) c1t2 := (<-store.Channel().Get(c1.Id)).Data.(*model.Channel) t2 := c1t2.ExtraUpdateAt if t2 <= t1 { t.Fatal("Member update time incorrect") } count := (<-store.Channel().GetMemberCount(o1.ChannelId)).Data.(int64) if count != 2 { t.Fatal("should have saved 2 members") } Must(store.Channel().PermanentDeleteMembersByUser(o2.UserId)) count = (<-store.Channel().GetMemberCount(o1.ChannelId)).Data.(int64) if count != 1 { t.Fatal("should have removed 1 member") } }
func TestChannelStoreSaveDirectChannel(t *testing.T) { Setup() teamId := model.NewId() o1 := model.Channel{} o1.TeamId = teamId o1.DisplayName = "Name" o1.Name = "a" + model.NewId() + "b" o1.Type = model.CHANNEL_DIRECT u1 := &model.User{} u1.Email = model.NewId() u1.Nickname = model.NewId() Must(store.User().Save(u1)) Must(store.Team().SaveMember(&model.TeamMember{TeamId: model.NewId(), UserId: u1.Id})) u2 := &model.User{} u2.Email = model.NewId() u2.Nickname = model.NewId() Must(store.User().Save(u2)) Must(store.Team().SaveMember(&model.TeamMember{TeamId: model.NewId(), UserId: u2.Id})) m1 := model.ChannelMember{} m1.ChannelId = o1.Id m1.UserId = u1.Id m1.NotifyProps = model.GetDefaultChannelNotifyProps() m2 := model.ChannelMember{} m2.ChannelId = o1.Id m2.UserId = u2.Id m2.NotifyProps = model.GetDefaultChannelNotifyProps() if err := (<-store.Channel().SaveDirectChannel(&o1, &m1, &m2)).Err; err != nil { t.Fatal("couldn't save direct channel", err) } members := (<-store.Channel().GetMembers(o1.Id)).Data.([]model.ChannelMember) if len(members) != 2 { t.Fatal("should have saved 2 members") } if err := (<-store.Channel().SaveDirectChannel(&o1, &m1, &m2)).Err; err == nil { t.Fatal("shouldn't be able to update from save") } o1.Id = "" o1.Name = "a" + model.NewId() + "b" o1.Type = model.CHANNEL_OPEN if err := (<-store.Channel().SaveDirectChannel(&o1, &m1, &m2)).Err; err == nil { t.Fatal("Should not be able to save non-direct channel") } }
func JoinDefaultChannels(teamId string, user *model.User, channelRole string) *model.AppError { var err *model.AppError = nil if result := <-Srv.Store.Channel().GetByName(teamId, "town-square"); result.Err != nil { err = result.Err } else { cm := &model.ChannelMember{ChannelId: result.Data.(*model.Channel).Id, UserId: user.Id, Roles: channelRole, NotifyProps: model.GetDefaultChannelNotifyProps()} if cmResult := <-Srv.Store.Channel().SaveMember(cm); cmResult.Err != nil { err = cmResult.Err } post := &model.Post{ ChannelId: result.Data.(*model.Channel).Id, Message: fmt.Sprintf(utils.T("api.channel.join_channel.post_and_forget"), user.Username), Type: model.POST_JOIN_LEAVE, UserId: user.Id, } InvalidateCacheForChannel(result.Data.(*model.Channel).Id) if _, err := CreatePost(post, teamId, false); err != nil { l4g.Error(utils.T("api.channel.post_user_add_remove_message_and_forget.error"), err) } } if result := <-Srv.Store.Channel().GetByName(teamId, "off-topic"); result.Err != nil { err = result.Err } else { cm := &model.ChannelMember{ChannelId: result.Data.(*model.Channel).Id, UserId: user.Id, Roles: channelRole, NotifyProps: model.GetDefaultChannelNotifyProps()} if cmResult := <-Srv.Store.Channel().SaveMember(cm); cmResult.Err != nil { err = cmResult.Err } post := &model.Post{ ChannelId: result.Data.(*model.Channel).Id, Message: fmt.Sprintf(utils.T("api.channel.join_channel.post_and_forget"), user.Username), Type: model.POST_JOIN_LEAVE, UserId: user.Id, } InvalidateCacheForChannel(result.Data.(*model.Channel).Id) if _, err := CreatePost(post, teamId, false); err != nil { l4g.Error(utils.T("api.channel.post_user_add_remove_message_and_forget.error"), err) } } return err }
func TestChannelStoreUpdateLastViewedAt(t *testing.T) { Setup() o1 := model.Channel{} o1.TeamId = model.NewId() o1.DisplayName = "Channel1" o1.Name = "a" + model.NewId() + "b" o1.Type = model.CHANNEL_OPEN o1.TotalMsgCount = 25 Must(store.Channel().Save(&o1)) m1 := model.ChannelMember{} m1.ChannelId = o1.Id m1.UserId = model.NewId() m1.NotifyProps = model.GetDefaultChannelNotifyProps() Must(store.Channel().SaveMember(&m1)) err := (<-store.Channel().UpdateLastViewedAt(m1.ChannelId, m1.UserId)).Err if err != nil { t.Fatal("failed to update", err) } err = (<-store.Channel().UpdateLastViewedAt(m1.ChannelId, "missing id")).Err if err != nil { t.Fatal("failed to update") } }
func TestChannelStoreGetMemberForPost(t *testing.T) { Setup() o1 := Must(store.Channel().Save(&model.Channel{ TeamId: model.NewId(), DisplayName: "Name", Name: "a" + model.NewId() + "b", Type: model.CHANNEL_OPEN, })).(*model.Channel) m1 := Must(store.Channel().SaveMember(&model.ChannelMember{ ChannelId: o1.Id, UserId: model.NewId(), NotifyProps: model.GetDefaultChannelNotifyProps(), })).(*model.ChannelMember) p1 := Must(store.Post().Save(&model.Post{ UserId: model.NewId(), ChannelId: o1.Id, Message: "test", })).(*model.Post) if r1 := <-store.Channel().GetMemberForPost(p1.Id, m1.UserId); r1.Err != nil { t.Fatal(r1.Err) } else if r1.Data.(*model.ChannelMember).ToJson() != m1.ToJson() { t.Fatal("invalid returned channel member") } if r2 := <-store.Channel().GetMemberForPost(p1.Id, model.NewId()); r2.Err == nil { t.Fatal("shouldn't have returned a member") } }
func CreateChannel(c *Context, channel *model.Channel, addMember bool) (*model.Channel, *model.AppError) { if result := <-Srv.Store.Channel().Save(channel); result.Err != nil { return nil, result.Err } else { sc := result.Data.(*model.Channel) if addMember { cm := &model.ChannelMember{ ChannelId: sc.Id, UserId: c.Session.UserId, Roles: model.ROLE_CHANNEL_USER.Id + " " + model.ROLE_CHANNEL_ADMIN.Id, NotifyProps: model.GetDefaultChannelNotifyProps(), } if cmresult := <-Srv.Store.Channel().SaveMember(cm); cmresult.Err != nil { return nil, cmresult.Err } InvalidateCacheForUser(c.Session.UserId) } c.LogAudit("name=" + channel.Name) return sc, nil } }
func TestChannelStoreGetChannelCounts(t *testing.T) { Setup() o2 := model.Channel{} o2.TeamId = model.NewId() o2.DisplayName = "Channel2" o2.Name = "a" + model.NewId() + "b" o2.Type = model.CHANNEL_OPEN Must(store.Channel().Save(&o2)) o1 := model.Channel{} o1.TeamId = model.NewId() o1.DisplayName = "Channel1" o1.Name = "a" + model.NewId() + "b" o1.Type = model.CHANNEL_OPEN Must(store.Channel().Save(&o1)) m1 := model.ChannelMember{} m1.ChannelId = o1.Id m1.UserId = model.NewId() m1.NotifyProps = model.GetDefaultChannelNotifyProps() Must(store.Channel().SaveMember(&m1)) m2 := model.ChannelMember{} m2.ChannelId = o1.Id m2.UserId = model.NewId() m2.NotifyProps = model.GetDefaultChannelNotifyProps() Must(store.Channel().SaveMember(&m2)) m3 := model.ChannelMember{} m3.ChannelId = o2.Id m3.UserId = model.NewId() m3.NotifyProps = model.GetDefaultChannelNotifyProps() Must(store.Channel().SaveMember(&m3)) cresult := <-store.Channel().GetChannelCounts(o1.TeamId, m1.UserId) counts := cresult.Data.(*model.ChannelCounts) if len(counts.Counts) != 1 { t.Fatal("wrong number of counts") } if len(counts.UpdateTimes) != 1 { t.Fatal("wrong number of update times") } }
func TestChannelStoreGetMembersForUser(t *testing.T) { Setup() t1 := model.Team{} t1.DisplayName = "Name" t1.Name = model.NewId() t1.Email = model.NewId() + "@nowhere.com" t1.Type = model.TEAM_OPEN Must(store.Team().Save(&t1)) o1 := model.Channel{} o1.TeamId = t1.Id o1.DisplayName = "Channel1" o1.Name = "a" + model.NewId() + "b" o1.Type = model.CHANNEL_OPEN Must(store.Channel().Save(&o1)) o2 := model.Channel{} o2.TeamId = o1.TeamId o2.DisplayName = "Channel2" o2.Name = "a" + model.NewId() + "b" o2.Type = model.CHANNEL_OPEN Must(store.Channel().Save(&o2)) m1 := model.ChannelMember{} m1.ChannelId = o1.Id m1.UserId = model.NewId() m1.NotifyProps = model.GetDefaultChannelNotifyProps() Must(store.Channel().SaveMember(&m1)) m2 := model.ChannelMember{} m2.ChannelId = o2.Id m2.UserId = m1.UserId m2.NotifyProps = model.GetDefaultChannelNotifyProps() Must(store.Channel().SaveMember(&m2)) cresult := <-store.Channel().GetMembersForUser(o1.TeamId, m1.UserId) members := cresult.Data.(*model.ChannelMembers) // no unread messages if len(*members) != 2 { t.Fatal("wrong number of members") } }
func TestChannelStoreGetMembersByIds(t *testing.T) { Setup() o1 := model.Channel{} o1.TeamId = model.NewId() o1.DisplayName = "ChannelA" o1.Name = "a" + model.NewId() + "b" o1.Type = model.CHANNEL_OPEN Must(store.Channel().Save(&o1)) m1 := &model.ChannelMember{ChannelId: o1.Id, UserId: model.NewId(), NotifyProps: model.GetDefaultChannelNotifyProps()} Must(store.Channel().SaveMember(m1)) if r := <-store.Channel().GetMembersByIds(m1.ChannelId, []string{m1.UserId}); r.Err != nil { t.Fatal(r.Err) } else { rm1 := r.Data.(model.ChannelMembers)[0] if rm1.ChannelId != m1.ChannelId { t.Fatal("bad team id") } if rm1.UserId != m1.UserId { t.Fatal("bad user id") } } m2 := &model.ChannelMember{ChannelId: o1.Id, UserId: model.NewId(), NotifyProps: model.GetDefaultChannelNotifyProps()} Must(store.Channel().SaveMember(m2)) if r := <-store.Channel().GetMembersByIds(m1.ChannelId, []string{m1.UserId, m2.UserId, model.NewId()}); r.Err != nil { t.Fatal(r.Err) } else { rm := r.Data.(model.ChannelMembers) if len(rm) != 2 { t.Fatal("return wrong number of results") } } if r := <-store.Channel().GetMembersByIds(m1.ChannelId, []string{}); r.Err == nil { t.Fatal("empty user ids - should have failed") } }
func TestChannelStoreGetChannels(t *testing.T) { Setup() o2 := model.Channel{} o2.TeamId = model.NewId() o2.DisplayName = "Channel2" o2.Name = "a" + model.NewId() + "b" o2.Type = model.CHANNEL_OPEN Must(store.Channel().Save(&o2)) o1 := model.Channel{} o1.TeamId = model.NewId() o1.DisplayName = "Channel1" o1.Name = "a" + model.NewId() + "b" o1.Type = model.CHANNEL_OPEN Must(store.Channel().Save(&o1)) m1 := model.ChannelMember{} m1.ChannelId = o1.Id m1.UserId = model.NewId() m1.NotifyProps = model.GetDefaultChannelNotifyProps() Must(store.Channel().SaveMember(&m1)) m2 := model.ChannelMember{} m2.ChannelId = o1.Id m2.UserId = model.NewId() m2.NotifyProps = model.GetDefaultChannelNotifyProps() Must(store.Channel().SaveMember(&m2)) m3 := model.ChannelMember{} m3.ChannelId = o2.Id m3.UserId = model.NewId() m3.NotifyProps = model.GetDefaultChannelNotifyProps() Must(store.Channel().SaveMember(&m3)) cresult := <-store.Channel().GetChannels(o1.TeamId, m1.UserId) list := cresult.Data.(*model.ChannelList) if list.Channels[0].Id != o1.Id { t.Fatal("missing channel") } }
func AddUserToChannel(user *model.User, channel *model.Channel) (*model.ChannelMember, *model.AppError) { if channel.DeleteAt > 0 { return nil, model.NewLocAppError("AddUserToChannel", "api.channel.add_user_to_channel.deleted.app_error", nil, "") } if channel.Type != model.CHANNEL_OPEN && channel.Type != model.CHANNEL_PRIVATE { return nil, model.NewLocAppError("AddUserToChannel", "api.channel.add_user_to_channel.type.app_error", nil, "") } tmchan := Srv.Store.Team().GetMember(channel.TeamId, user.Id) cmchan := Srv.Store.Channel().GetMember(channel.Id, user.Id) if result := <-tmchan; result.Err != nil { return nil, result.Err } else { teamMember := result.Data.(model.TeamMember) if teamMember.DeleteAt > 0 { return nil, model.NewLocAppError("AddUserToChannel", "api.channel.add_user.to.channel.failed.deleted.app_error", nil, "") } } if result := <-cmchan; result.Err != nil { if result.Err.Id != store.MISSING_CHANNEL_MEMBER_ERROR { return nil, result.Err } } else { channelMember := result.Data.(model.ChannelMember) return &channelMember, nil } newMember := &model.ChannelMember{ ChannelId: channel.Id, UserId: user.Id, NotifyProps: model.GetDefaultChannelNotifyProps(), Roles: model.ROLE_CHANNEL_USER.Id, } if result := <-Srv.Store.Channel().SaveMember(newMember); result.Err != nil { l4g.Error("Failed to add member user_id=%v channel_id=%v err=%v", user.Id, channel.Id, result.Err) return nil, model.NewLocAppError("AddUserToChannel", "api.channel.add_user.to.channel.failed.app_error", nil, "") } go func() { InvalidateCacheForUser(user.Id) Srv.Store.User().InvalidateProfilesInChannelCache(channel.Id) message := model.NewWebSocketEvent(model.WEBSOCKET_EVENT_USER_ADDED, "", channel.Id, "", nil) message.Add("user_id", user.Id) message.Add("team_id", channel.TeamId) go Publish(message) }() return newMember, nil }
func CreateDirectChannel(userId string, otherUserId string) (*model.Channel, *model.AppError) { uc := Srv.Store.User().Get(otherUserId) channel := new(model.Channel) channel.DisplayName = "" channel.Name = model.GetDMNameFromIds(otherUserId, userId) channel.Header = "" channel.Type = model.CHANNEL_DIRECT if uresult := <-uc; uresult.Err != nil { return nil, model.NewLocAppError("CreateDirectChannel", "api.channel.create_direct_channel.invalid_user.app_error", nil, otherUserId) } cm1 := &model.ChannelMember{ UserId: userId, NotifyProps: model.GetDefaultChannelNotifyProps(), Roles: model.ROLE_CHANNEL_USER.Id, } cm2 := &model.ChannelMember{ UserId: otherUserId, NotifyProps: model.GetDefaultChannelNotifyProps(), Roles: model.ROLE_CHANNEL_USER.Id, } if result := <-Srv.Store.Channel().SaveDirectChannel(channel, cm1, cm2); result.Err != nil { if result.Err.Id == store.CHANNEL_EXISTS_ERROR { return result.Data.(*model.Channel), nil } else { return nil, result.Err } } else { message := model.NewWebSocketEvent(model.WEBSOCKET_EVENT_DIRECT_ADDED, "", channel.Id, "", nil) message.Add("teammate_id", otherUserId) go Publish(message) return result.Data.(*model.Channel), nil } }
func (s SqlChannelStore) CreateDirectChannel(userId string, otherUserId string) StoreChannel { channel := new(model.Channel) channel.DisplayName = "" channel.Name = model.GetDMNameFromIds(otherUserId, userId) channel.Header = "" channel.Type = model.CHANNEL_DIRECT cm1 := &model.ChannelMember{ UserId: userId, NotifyProps: model.GetDefaultChannelNotifyProps(), Roles: model.ROLE_CHANNEL_USER.Id, } cm2 := &model.ChannelMember{ UserId: otherUserId, NotifyProps: model.GetDefaultChannelNotifyProps(), Roles: model.ROLE_CHANNEL_USER.Id, } return s.SaveDirectChannel(channel, cm1, cm2) }
func JoinChannel(c *Context, channelId string, role string) { sc := Srv.Store.Channel().Get(channelId) uc := Srv.Store.User().Get(c.Session.UserId) if cresult := <-sc; cresult.Err != nil { c.Err = cresult.Err return } else if uresult := <-uc; uresult.Err != nil { c.Err = uresult.Err return } else { channel := cresult.Data.(*model.Channel) user := uresult.Data.(*model.User) if !c.HasPermissionsToTeam(channel.TeamId, "joinChannel") { return } if channel.DeleteAt > 0 { c.Err = model.NewAppError("joinChannel", "The channel has been archived or deleted", "") c.Err.StatusCode = http.StatusBadRequest return } if channel.Type == model.CHANNEL_OPEN { cm := &model.ChannelMember{ChannelId: channel.Id, UserId: c.Session.UserId, Roles: role, NotifyProps: model.GetDefaultChannelNotifyProps()} if cmresult := <-Srv.Store.Channel().SaveMember(cm); cmresult.Err != nil { c.Err = cmresult.Err return } post := &model.Post{ChannelId: channel.Id, Message: fmt.Sprintf( `User %v has joined this channel.`, user.Username), Type: model.POST_JOIN_LEAVE} if _, err := CreatePost(c, post, false); err != nil { l4g.Error("Failed to post join message %v", err) c.Err = model.NewAppError("joinChannel", "Failed to send join request", "") return } UpdateChannelAccessCacheAndForget(c.Session.TeamId, c.Session.UserId, channel.Id) } else { c.Err = model.NewAppError("joinChannel", "You do not have the appropriate permissions", "") c.Err.StatusCode = http.StatusForbidden return } } }
func CreateDirectChannel(c *Context, otherUserId string) (*model.Channel, *model.AppError) { if len(otherUserId) != 26 { return nil, model.NewAppError("CreateDirectChannel", "Invalid other user id ", otherUserId) } uc := Srv.Store.User().Get(otherUserId) channel := new(model.Channel) channel.DisplayName = "" channel.Name = model.GetDMNameFromIds(otherUserId, c.Session.UserId) channel.TeamId = c.Session.TeamId channel.Header = "" channel.Type = model.CHANNEL_DIRECT if uresult := <-uc; uresult.Err != nil { return nil, model.NewAppError("CreateDirectChannel", "Invalid other user id ", otherUserId) } cm1 := &model.ChannelMember{ UserId: c.Session.UserId, Roles: model.CHANNEL_ROLE_ADMIN, NotifyProps: model.GetDefaultChannelNotifyProps(), } cm2 := &model.ChannelMember{ UserId: otherUserId, Roles: "", NotifyProps: model.GetDefaultChannelNotifyProps(), } if result := <-Srv.Store.Channel().SaveDirectChannel(channel, cm1, cm2); result.Err != nil { return nil, result.Err } else { return result.Data.(*model.Channel), nil } }
func TestUpdateExtrasByUser(t *testing.T) { Setup() teamId := model.NewId() c1 := model.Channel{ TeamId: teamId, DisplayName: "Channel1", Name: "a" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } Must(store.Channel().Save(&c1)) c2 := model.Channel{ TeamId: teamId, DisplayName: "Channel2", Name: "a" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } Must(store.Channel().Save(&c2)) u1 := &model.User{ Email: model.NewId(), DeleteAt: 0, } Must(store.User().Save(u1)) Must(store.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u1.Id})) m1 := model.ChannelMember{ ChannelId: c1.Id, UserId: u1.Id, NotifyProps: model.GetDefaultChannelNotifyProps(), } Must(store.Channel().SaveMember(&m1)) u1.DeleteAt = model.GetMillis() Must(store.User().Update(u1, true)) if result := <-store.Channel().ExtraUpdateByUser(u1.Id, u1.DeleteAt); result.Err != nil { t.Fatal("failed to update extras by user: %v", result.Err) } u1.DeleteAt = 0 Must(store.User().Update(u1, true)) if result := <-store.Channel().ExtraUpdateByUser(u1.Id, u1.DeleteAt); result.Err != nil { t.Fatal("failed to update extras by user: %v", result.Err) } }
func TestChannelStorePermissionsTo(t *testing.T) { Setup() o1 := model.Channel{} o1.TeamId = model.NewId() o1.DisplayName = "Channel1" o1.Name = "a" + model.NewId() + "b" o1.Type = model.CHANNEL_OPEN Must(store.Channel().Save(&o1)) m1 := model.ChannelMember{} m1.ChannelId = o1.Id m1.UserId = model.NewId() m1.NotifyProps = model.GetDefaultChannelNotifyProps() Must(store.Channel().SaveMember(&m1)) count := (<-store.Channel().CheckPermissionsTo(o1.TeamId, o1.Id, m1.UserId)).Data.(int64) if count != 1 { t.Fatal("should have permissions") } count = (<-store.Channel().CheckPermissionsTo("junk", o1.Id, m1.UserId)).Data.(int64) if count != 0 { t.Fatal("shouldn't have permissions") } count = (<-store.Channel().CheckPermissionsTo(o1.TeamId, "junk", m1.UserId)).Data.(int64) if count != 0 { t.Fatal("shouldn't have permissions") } count = (<-store.Channel().CheckPermissionsTo(o1.TeamId, o1.Id, "junk")).Data.(int64) if count != 0 { t.Fatal("shouldn't have permissions") } channelId := (<-store.Channel().CheckPermissionsToByName(o1.TeamId, o1.Name, m1.UserId)).Data.(string) if channelId != o1.Id { t.Fatal("should have permissions") } channelId = (<-store.Channel().CheckPermissionsToByName(o1.TeamId, "missing", m1.UserId)).Data.(string) if channelId != "" { t.Fatal("should not have permissions") } }
func TestPostStoreSearch(t *testing.T) { Setup() teamId := model.NewId() userId := model.NewId() c1 := &model.Channel{} c1.TeamId = teamId c1.DisplayName = "Channel1" c1.Name = "a" + model.NewId() + "b" c1.Type = model.CHANNEL_OPEN c1 = (<-store.Channel().Save(c1)).Data.(*model.Channel) m1 := model.ChannelMember{} m1.ChannelId = c1.Id m1.UserId = userId m1.NotifyProps = model.GetDefaultChannelNotifyProps() Must(store.Channel().SaveMember(&m1)) c2 := &model.Channel{} c2.TeamId = teamId c2.DisplayName = "Channel1" c2.Name = "a" + model.NewId() + "b" c2.Type = model.CHANNEL_OPEN c2 = (<-store.Channel().Save(c2)).Data.(*model.Channel) o1 := &model.Post{} o1.ChannelId = c1.Id o1.UserId = model.NewId() o1.Message = "corey mattermost new york" o1 = (<-store.Post().Save(o1)).Data.(*model.Post) o1a := &model.Post{} o1a.ChannelId = c1.Id o1a.UserId = model.NewId() o1a.Message = "corey mattermost new york" o1a.Type = model.POST_JOIN_LEAVE o1a = (<-store.Post().Save(o1a)).Data.(*model.Post) o2 := &model.Post{} o2.ChannelId = c1.Id o2.UserId = model.NewId() o2.Message = "New Jersey is where John is from" o2 = (<-store.Post().Save(o2)).Data.(*model.Post) o3 := &model.Post{} o3.ChannelId = c2.Id o3.UserId = model.NewId() o3.Message = "New Jersey is where John is from corey new york" o3 = (<-store.Post().Save(o3)).Data.(*model.Post) o4 := &model.Post{} o4.ChannelId = c1.Id o4.UserId = model.NewId() o4.Hashtags = "#hashtag" o4.Message = "(message)blargh" o4 = (<-store.Post().Save(o4)).Data.(*model.Post) o5 := &model.Post{} o5.ChannelId = c1.Id o5.UserId = model.NewId() o5.Hashtags = "#secret #howdy" o5 = (<-store.Post().Save(o5)).Data.(*model.Post) r1 := (<-store.Post().Search(teamId, userId, &model.SearchParams{Terms: "corey", IsHashtag: false})).Data.(*model.PostList) if len(r1.Order) != 1 || r1.Order[0] != o1.Id { t.Fatal("returned wrong search result") } r3 := (<-store.Post().Search(teamId, userId, &model.SearchParams{Terms: "new", IsHashtag: false})).Data.(*model.PostList) if len(r3.Order) != 2 || (r3.Order[0] != o1.Id && r3.Order[1] != o1.Id) { t.Fatal("returned wrong search result") } r4 := (<-store.Post().Search(teamId, userId, &model.SearchParams{Terms: "john", IsHashtag: false})).Data.(*model.PostList) if len(r4.Order) != 1 || r4.Order[0] != o2.Id { t.Fatal("returned wrong search result") } r5 := (<-store.Post().Search(teamId, userId, &model.SearchParams{Terms: "matter*", IsHashtag: false})).Data.(*model.PostList) if len(r5.Order) != 1 || r5.Order[0] != o1.Id { t.Fatal("returned wrong search result") } r6 := (<-store.Post().Search(teamId, userId, &model.SearchParams{Terms: "#hashtag", IsHashtag: true})).Data.(*model.PostList) if len(r6.Order) != 1 || r6.Order[0] != o4.Id { t.Fatal("returned wrong search result") } r7 := (<-store.Post().Search(teamId, userId, &model.SearchParams{Terms: "#secret", IsHashtag: true})).Data.(*model.PostList) if len(r7.Order) != 1 || r7.Order[0] != o5.Id { t.Fatal("returned wrong search result") } r8 := (<-store.Post().Search(teamId, userId, &model.SearchParams{Terms: "@thisshouldmatchnothing", IsHashtag: true})).Data.(*model.PostList) if len(r8.Order) != 0 { t.Fatal("returned wrong search result") } r9 := (<-store.Post().Search(teamId, userId, &model.SearchParams{Terms: "mattermost jersey", IsHashtag: false})).Data.(*model.PostList) if len(r9.Order) != 2 { t.Fatal("returned wrong search result") } r10 := (<-store.Post().Search(teamId, userId, &model.SearchParams{Terms: "matter* jer*", IsHashtag: false})).Data.(*model.PostList) if len(r10.Order) != 2 { t.Fatal("returned wrong search result") } r11 := (<-store.Post().Search(teamId, userId, &model.SearchParams{Terms: "message blargh", IsHashtag: false})).Data.(*model.PostList) if len(r11.Order) != 1 { t.Fatal("returned wrong search result") } r12 := (<-store.Post().Search(teamId, userId, &model.SearchParams{Terms: "blargh>", IsHashtag: false})).Data.(*model.PostList) if len(r12.Order) != 1 { t.Fatal("returned wrong search result") } }
func AddUserToChannel(user *model.User, channel *model.Channel) (*model.ChannelMember, *model.AppError) { if channel.DeleteAt > 0 { return nil, model.NewAppError("AddUserToChannel", "The channel has been archived or deleted", "") } if channel.Type != model.CHANNEL_OPEN && channel.Type != model.CHANNEL_PRIVATE { return nil, model.NewAppError("AddUserToChannel", "Can not add user to this channel type", "") } newMember := &model.ChannelMember{ChannelId: channel.Id, UserId: user.Id, NotifyProps: model.GetDefaultChannelNotifyProps()} if cmresult := <-Srv.Store.Channel().SaveMember(newMember); cmresult.Err != nil { l4g.Error("Failed to add member user_id=%v channel_id=%v err=%v", user.Id, channel.Id, cmresult.Err) return nil, model.NewAppError("AddUserToChannel", "Failed to add user to channel", "") } go func() { UpdateChannelAccessCache(channel.TeamId, user.Id, channel.Id) message := model.NewMessage(channel.TeamId, channel.Id, user.Id, model.ACTION_USER_ADDED) PublishAndForget(message) }() return newMember, nil }
func AddUserToChannel(user *model.User, channel *model.Channel) (*model.ChannelMember, *model.AppError) { if channel.DeleteAt > 0 { return nil, model.NewLocAppError("AddUserToChannel", "api.channel.add_user_to_channel.deleted.app_error", nil, "") } if channel.Type != model.CHANNEL_OPEN && channel.Type != model.CHANNEL_PRIVATE { return nil, model.NewLocAppError("AddUserToChannel", "api.channel.add_user_to_channel.type.app_error", nil, "") } newMember := &model.ChannelMember{ChannelId: channel.Id, UserId: user.Id, NotifyProps: model.GetDefaultChannelNotifyProps()} if cmresult := <-Srv.Store.Channel().SaveMember(newMember); cmresult.Err != nil { l4g.Error("Failed to add member user_id=%v channel_id=%v err=%v", user.Id, channel.Id, cmresult.Err) return nil, model.NewLocAppError("AddUserToChannel", "api.channel.add_user.to.channel.failed.app_error", nil, "") } go func() { UpdateChannelAccessCache(channel.TeamId, user.Id, channel.Id) message := model.NewMessage(channel.TeamId, channel.Id, user.Id, model.ACTION_USER_ADDED) PublishAndForget(message) }() return newMember, nil }
func TestUserStoreSearch(t *testing.T) { Setup() u1 := &model.User{} u1.Username = "******" + model.NewId() u1.FirstName = "Tim" u1.LastName = "Bill" u1.Nickname = "Rob" u1.Email = "harold" + model.NewId() Must(store.User().Save(u1)) u2 := &model.User{} u2.Username = "******" + model.NewId() u2.Email = model.NewId() Must(store.User().Save(u2)) u3 := &model.User{} u3.Username = "******" + model.NewId() u3.Email = model.NewId() u3.DeleteAt = 1 Must(store.User().Save(u3)) tid := model.NewId() Must(store.Team().SaveMember(&model.TeamMember{TeamId: tid, UserId: u1.Id})) Must(store.Team().SaveMember(&model.TeamMember{TeamId: tid, UserId: u2.Id})) Must(store.Team().SaveMember(&model.TeamMember{TeamId: tid, UserId: u3.Id})) searchOptions := map[string]bool{} searchOptions[USER_SEARCH_OPTION_NAMES_ONLY] = true if r1 := <-store.User().Search(tid, "jimb", searchOptions); r1.Err != nil { t.Fatal(r1.Err) } else { profiles := r1.Data.([]*model.User) found1 := false found2 := false for _, profile := range profiles { if profile.Id == u1.Id { found1 = true } if profile.Id == u3.Id { found2 = true } } if !found1 { t.Fatal("should have found user") } if found2 { t.Fatal("should not have found inactive user") } } if r1 := <-store.User().Search(tid, "harol", searchOptions); r1.Err != nil { t.Fatal(r1.Err) } else { profiles := r1.Data.([]*model.User) found1 := false for _, profile := range profiles { if profile.Id == u1.Id { found1 = true } } if found1 { t.Fatal("should not have found user") } } searchOptions[USER_SEARCH_OPTION_ALLOW_INACTIVE] = true if r1 := <-store.User().Search(tid, "jimb", searchOptions); r1.Err != nil { t.Fatal(r1.Err) } else { profiles := r1.Data.([]*model.User) found1 := false found2 := false for _, profile := range profiles { if profile.Id == u1.Id { found1 = true } if profile.Id == u3.Id { found2 = true } } if !found1 { t.Fatal("should have found user") } if !found2 { t.Fatal("should have found inactive user") } } searchOptions[USER_SEARCH_OPTION_ALLOW_INACTIVE] = false if r1 := <-store.User().Search(tid, "jimb", searchOptions); r1.Err != nil { t.Fatal(r1.Err) } else { profiles := r1.Data.([]*model.User) found := false for _, profile := range profiles { if profile.Id == u1.Id { found = true break } } if !found { t.Fatal("should have found user") } } if r1 := <-store.User().Search("", "jimb", searchOptions); r1.Err != nil { t.Fatal(r1.Err) } else { profiles := r1.Data.([]*model.User) found := false for _, profile := range profiles { if profile.Id == u1.Id { found = true break } } if !found { t.Fatal("should have found user") } } if r1 := <-store.User().Search("", "jim-bobb", searchOptions); r1.Err != nil { t.Fatal(r1.Err) } else { profiles := r1.Data.([]*model.User) found := false for _, profile := range profiles { t.Log(profile.Username) if profile.Id == u2.Id { found = true break } } if !found { t.Fatal("should have found user") } } if r1 := <-store.User().Search(tid, "", searchOptions); r1.Err != nil { t.Fatal(r1.Err) } c1 := model.Channel{} c1.TeamId = tid c1.DisplayName = "NameName" c1.Name = "a" + model.NewId() + "b" c1.Type = model.CHANNEL_OPEN c1 = *Must(store.Channel().Save(&c1)).(*model.Channel) if r1 := <-store.User().SearchNotInChannel(tid, c1.Id, "jimb", searchOptions); r1.Err != nil { t.Fatal(r1.Err) } else { profiles := r1.Data.([]*model.User) found := false for _, profile := range profiles { if profile.Id == u1.Id { found = true break } } if !found { t.Fatal("should have found user") } } if r1 := <-store.User().SearchNotInChannel("", c1.Id, "jimb", searchOptions); r1.Err != nil { t.Fatal(r1.Err) } else { profiles := r1.Data.([]*model.User) found := false for _, profile := range profiles { if profile.Id == u1.Id { found = true break } } if !found { t.Fatal("should have found user") } } if r1 := <-store.User().SearchNotInChannel("junk", c1.Id, "jimb", searchOptions); r1.Err != nil { t.Fatal(r1.Err) } else { profiles := r1.Data.([]*model.User) found := false for _, profile := range profiles { if profile.Id == u1.Id { found = true break } } if found { t.Fatal("should not have found user") } } if r1 := <-store.User().SearchInChannel(c1.Id, "jimb", searchOptions); r1.Err != nil { t.Fatal(r1.Err) } else { profiles := r1.Data.([]*model.User) found := false for _, profile := range profiles { if profile.Id == u1.Id { found = true break } } if found { t.Fatal("should not have found user") } } Must(store.Channel().SaveMember(&model.ChannelMember{ChannelId: c1.Id, UserId: u1.Id, NotifyProps: model.GetDefaultChannelNotifyProps()})) if r1 := <-store.User().SearchInChannel(c1.Id, "jimb", searchOptions); r1.Err != nil { t.Fatal(r1.Err) } else { profiles := r1.Data.([]*model.User) found := false for _, profile := range profiles { if profile.Id == u1.Id { found = true break } } if !found { t.Fatal("should have found user") } } searchOptions = map[string]bool{} if r1 := <-store.User().Search(tid, "harol", searchOptions); r1.Err != nil { t.Fatal(r1.Err) } else { profiles := r1.Data.([]*model.User) found1 := false for _, profile := range profiles { if profile.Id == u1.Id { found1 = true } } if !found1 { t.Fatal("should have found user") } } if r1 := <-store.User().Search(tid, "Tim", searchOptions); r1.Err != nil { t.Fatal(r1.Err) } else { profiles := r1.Data.([]*model.User) found := false for _, profile := range profiles { if profile.Id == u1.Id { found = true break } } if !found { t.Fatal("should have found user") } } if r1 := <-store.User().Search(tid, "Bill", searchOptions); r1.Err != nil { t.Fatal(r1.Err) } else { profiles := r1.Data.([]*model.User) found := false for _, profile := range profiles { if profile.Id == u1.Id { found = true break } } if !found { t.Fatal("should have found user") } } if r1 := <-store.User().Search(tid, "Rob", searchOptions); r1.Err != nil { t.Fatal(r1.Err) } else { profiles := r1.Data.([]*model.User) found := false for _, profile := range profiles { if profile.Id == u1.Id { found = true break } } if !found { t.Fatal("should have found user") } } }
func TestUserUnreadCount(t *testing.T) { Setup() teamId := model.NewId() c1 := model.Channel{} c1.TeamId = teamId c1.DisplayName = "Unread Messages" c1.Name = "unread-messages-" + model.NewId() c1.Type = model.CHANNEL_OPEN c2 := model.Channel{} c2.TeamId = teamId c2.DisplayName = "Unread Direct" c2.Name = "unread-direct-" + model.NewId() c2.Type = model.CHANNEL_DIRECT u1 := &model.User{} u1.Username = "******" + model.NewId() u1.Email = model.NewId() Must(store.User().Save(u1)) Must(store.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u1.Id})) u2 := &model.User{} u2.Email = model.NewId() u2.Username = "******" + model.NewId() Must(store.User().Save(u2)) Must(store.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u2.Id})) if err := (<-store.Channel().Save(&c1)).Err; err != nil { t.Fatal("couldn't save item", err) } m1 := model.ChannelMember{} m1.ChannelId = c1.Id m1.UserId = u1.Id m1.NotifyProps = model.GetDefaultChannelNotifyProps() m2 := model.ChannelMember{} m2.ChannelId = c1.Id m2.UserId = u2.Id m2.NotifyProps = model.GetDefaultChannelNotifyProps() Must(store.Channel().SaveMember(&m1)) Must(store.Channel().SaveMember(&m2)) m1.ChannelId = c2.Id m2.ChannelId = c2.Id if err := (<-store.Channel().SaveDirectChannel(&c2, &m1, &m2)).Err; err != nil { t.Fatal("couldn't save direct channel", err) } p1 := model.Post{} p1.ChannelId = c1.Id p1.UserId = u1.Id p1.Message = "this is a message for @" + u2.Username // Post one message with mention to open channel Must(store.Post().Save(&p1)) Must(store.Channel().IncrementMentionCount(c1.Id, u2.Id)) // Post 2 messages without mention to direct channel p2 := model.Post{} p2.ChannelId = c2.Id p2.UserId = u1.Id p2.Message = "first message" Must(store.Post().Save(&p2)) Must(store.Channel().IncrementMentionCount(c2.Id, u2.Id)) p3 := model.Post{} p3.ChannelId = c2.Id p3.UserId = u1.Id p3.Message = "second message" Must(store.Post().Save(&p3)) Must(store.Channel().IncrementMentionCount(c2.Id, u2.Id)) badge := (<-store.User().GetUnreadCount(u2.Id)).Data.(int64) if badge != 3 { t.Fatal("should have 3 unread messages") } badge = (<-store.User().GetUnreadCountForChannel(u2.Id, c1.Id)).Data.(int64) if badge != 1 { t.Fatal("should have 1 unread messages for that channel") } badge = (<-store.User().GetUnreadCountForChannel(u2.Id, c2.Id)).Data.(int64) if badge != 2 { t.Fatal("should have 2 unread messages for that channel") } }
func TestUserStoreGetProfilesNotInChannel(t *testing.T) { Setup() teamId := model.NewId() u1 := &model.User{} u1.Email = model.NewId() Must(store.User().Save(u1)) Must(store.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u1.Id})) u2 := &model.User{} u2.Email = model.NewId() Must(store.User().Save(u2)) Must(store.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u2.Id})) c1 := model.Channel{} c1.TeamId = teamId c1.DisplayName = "Profiles in channel" c1.Name = "profiles-" + model.NewId() c1.Type = model.CHANNEL_OPEN c2 := model.Channel{} c2.TeamId = teamId c2.DisplayName = "Profiles in private" c2.Name = "profiles-" + model.NewId() c2.Type = model.CHANNEL_PRIVATE Must(store.Channel().Save(&c1)) Must(store.Channel().Save(&c2)) if r1 := <-store.User().GetProfilesNotInChannel(teamId, c1.Id, 0, 100); r1.Err != nil { t.Fatal(r1.Err) } else { users := r1.Data.(map[string]*model.User) if len(users) != 2 { t.Fatal("invalid returned users") } if users[u1.Id].Id != u1.Id { t.Fatal("invalid returned user") } } if r2 := <-store.User().GetProfilesNotInChannel(teamId, c2.Id, 0, 100); r2.Err != nil { t.Fatal(r2.Err) } else { if len(r2.Data.(map[string]*model.User)) != 2 { t.Fatal("invalid returned users") } } m1 := model.ChannelMember{} m1.ChannelId = c1.Id m1.UserId = u1.Id m1.NotifyProps = model.GetDefaultChannelNotifyProps() m2 := model.ChannelMember{} m2.ChannelId = c1.Id m2.UserId = u2.Id m2.NotifyProps = model.GetDefaultChannelNotifyProps() m3 := model.ChannelMember{} m3.ChannelId = c2.Id m3.UserId = u1.Id m3.NotifyProps = model.GetDefaultChannelNotifyProps() Must(store.Channel().SaveMember(&m1)) Must(store.Channel().SaveMember(&m2)) Must(store.Channel().SaveMember(&m3)) if r1 := <-store.User().GetProfilesNotInChannel(teamId, c1.Id, 0, 100); r1.Err != nil { t.Fatal(r1.Err) } else { users := r1.Data.(map[string]*model.User) if len(users) != 0 { t.Fatal("invalid returned users") } } if r2 := <-store.User().GetProfilesNotInChannel(teamId, c2.Id, 0, 100); r2.Err != nil { t.Fatal(r2.Err) } else { if len(r2.Data.(map[string]*model.User)) != 1 { t.Fatal("should have had 1 user not in channel") } } }
func TestGetMemberCount(t *testing.T) { Setup() teamId := model.NewId() c1 := model.Channel{ TeamId: teamId, DisplayName: "Channel1", Name: "a" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } Must(store.Channel().Save(&c1)) c2 := model.Channel{ TeamId: teamId, DisplayName: "Channel2", Name: "a" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } Must(store.Channel().Save(&c2)) u1 := &model.User{ Email: model.NewId(), DeleteAt: 0, } Must(store.User().Save(u1)) Must(store.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u1.Id})) m1 := model.ChannelMember{ ChannelId: c1.Id, UserId: u1.Id, NotifyProps: model.GetDefaultChannelNotifyProps(), } Must(store.Channel().SaveMember(&m1)) if result := <-store.Channel().GetMemberCount(c1.Id); result.Err != nil { t.Fatal("failed to get member count: %v", result.Err) } else if result.Data.(int64) != 1 { t.Fatal("got incorrect member count %v", result.Data) } u2 := model.User{ Email: model.NewId(), DeleteAt: 0, } Must(store.User().Save(&u2)) Must(store.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u2.Id})) m2 := model.ChannelMember{ ChannelId: c1.Id, UserId: u2.Id, NotifyProps: model.GetDefaultChannelNotifyProps(), } Must(store.Channel().SaveMember(&m2)) if result := <-store.Channel().GetMemberCount(c1.Id); result.Err != nil { t.Fatal("failed to get member count: %v", result.Err) } else if result.Data.(int64) != 2 { t.Fatal("got incorrect member count %v", result.Data) } // make sure members of other channels aren't counted u3 := model.User{ Email: model.NewId(), DeleteAt: 0, } Must(store.User().Save(&u3)) Must(store.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u3.Id})) m3 := model.ChannelMember{ ChannelId: c2.Id, UserId: u3.Id, NotifyProps: model.GetDefaultChannelNotifyProps(), } Must(store.Channel().SaveMember(&m3)) if result := <-store.Channel().GetMemberCount(c1.Id); result.Err != nil { t.Fatal("failed to get member count: %v", result.Err) } else if result.Data.(int64) != 2 { t.Fatal("got incorrect member count %v", result.Data) } // make sure inactive users aren't counted u4 := &model.User{ Email: model.NewId(), DeleteAt: 10000, } Must(store.User().Save(u4)) Must(store.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u4.Id})) m4 := model.ChannelMember{ ChannelId: c1.Id, UserId: u4.Id, NotifyProps: model.GetDefaultChannelNotifyProps(), } Must(store.Channel().SaveMember(&m4)) if result := <-store.Channel().GetMemberCount(c1.Id); result.Err != nil { t.Fatal("failed to get member count: %v", result.Err) } else if result.Data.(int64) != 2 { t.Fatal("got incorrect member count %v", result.Data) } }