func TestChannelStoreOpenChannelPermissionsTo(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)) count := (<-store.Channel().CheckOpenChannelPermissions(o1.TeamId, o1.Id)).Data.(int64) if count != 1 { t.Fatal("should have permissions") } count = (<-store.Channel().CheckOpenChannelPermissions("junk", o1.Id)).Data.(int64) if count != 0 { t.Fatal("shouldn't have permissions") } count = (<-store.Channel().CheckOpenChannelPermissions(o1.TeamId, "junk")).Data.(int64) if count != 0 { t.Fatal("shouldn't have permissions") } }
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 join(c *Context, w http.ResponseWriter, r *http.Request) { params := mux.Vars(r) channelId := params["channel_id"] channelName := params["channel_name"] var channel *model.Channel var err *model.AppError if channelId != "" { channel, err = app.GetChannel(channelId) } else if channelName != "" { channel, err = app.GetChannelByName(channelName, c.TeamId) } else { c.SetInvalidParam("join", "channel_id, channel_name") return } if err != nil { c.Err = err return } if channel.Type == model.CHANNEL_OPEN { if !HasPermissionToTeamContext(c, channel.TeamId, model.PERMISSION_JOIN_PUBLIC_CHANNELS) { return } } if err = app.JoinChannel(channel, c.Session.UserId); err != nil { c.Err = err return } w.Write([]byte(channel.ToJson())) }
func (s SqlChannelStore) extraUpdated(channel *model.Channel) StoreChannel { storeChannel := make(StoreChannel) go func() { result := StoreResult{} channel.ExtraUpdated() _, err := s.GetMaster().Exec( `UPDATE Channels SET ExtraUpdateAt = :Time WHERE Id = :Id`, map[string]interface{}{"Id": channel.Id, "Time": channel.ExtraUpdateAt}) if err != nil { result.Err = model.NewLocAppError("SqlChannelStore.extraUpdated", "store.sql_channel.extra_updated.app_error", nil, "id="+channel.Id+", "+err.Error()) } storeChannel <- result close(storeChannel) }() return storeChannel }
func (s SqlChannelStore) Update(channel *model.Channel) StoreChannel { storeChannel := make(StoreChannel) go func() { result := StoreResult{} channel.PreUpdate() if result.Err = channel.IsValid(); result.Err != nil { storeChannel <- result close(storeChannel) return } if count, err := s.GetMaster().Update(channel); err != nil { if strings.Contains(err.Error(), "Duplicate entry") && strings.Contains(err.Error(), "for key 'Name'") { result.Err = model.NewAppError("SqlChannelStore.Update", "A channel with that name already exists", "id="+channel.Id+", "+err.Error()) } else { result.Err = model.NewAppError("SqlChannelStore.Update", "We encounted an error updating the channel", "id="+channel.Id+", "+err.Error()) } } else if count != 1 { result.Err = model.NewAppError("SqlChannelStore.Update", "We couldn't update the channel", "id="+channel.Id) } else { result.Data = channel } storeChannel <- result close(storeChannel) }() return storeChannel }
func join(c *Context, w http.ResponseWriter, r *http.Request) { params := mux.Vars(r) channelId := params["channel_id"] channelName := params["channel_name"] var outChannel *model.Channel = nil if channelId != "" { if err, channel := JoinChannelById(c, c.Session.UserId, channelId); err != nil { c.Err = err c.Err.StatusCode = http.StatusForbidden return } else { outChannel = channel } } else if channelName != "" { if err, channel := JoinChannelByName(c, c.Session.UserId, c.TeamId, channelName); err != nil { c.Err = err c.Err.StatusCode = http.StatusForbidden return } else { outChannel = channel } } else { c.SetInvalidParam("join", "channel_id, channel_name") return } w.Write([]byte(outChannel.ToJson())) }
func getChannelExtraInfo(c *Context, w http.ResponseWriter, r *http.Request) { params := mux.Vars(r) id := params["id"] sc := Srv.Store.Channel().Get(id) var channel *model.Channel if cresult := <-sc; cresult.Err != nil { c.Err = cresult.Err return } else { channel = cresult.Data.(*model.Channel) } extraEtag := channel.ExtraEtag() if HandleEtag(extraEtag, w, r) { return } scm := Srv.Store.Channel().GetMember(id, c.Session.UserId) ecm := Srv.Store.Channel().GetExtraMembers(id, 20) ccm := Srv.Store.Channel().GetMemberCount(id) if cmresult := <-scm; cmresult.Err != nil { c.Err = cmresult.Err return } else if ecmresult := <-ecm; ecmresult.Err != nil { c.Err = ecmresult.Err return } else if ccmresult := <-ccm; ccmresult.Err != nil { c.Err = ccmresult.Err return } else { member := cmresult.Data.(model.ChannelMember) extraMembers := ecmresult.Data.([]model.ExtraMember) memberCount := ccmresult.Data.(int64) if !c.HasPermissionsToTeam(channel.TeamId, "getChannelExtraInfo") { return } if !c.HasPermissionsToUser(member.UserId, "getChannelExtraInfo") { return } if channel.DeleteAt > 0 { c.Err = model.NewAppError("getChannelExtraInfo", "The channel has been archived or deleted", "") c.Err.StatusCode = http.StatusBadRequest return } data := model.ChannelExtra{Id: channel.Id, Members: extraMembers, MemberCount: memberCount} w.Header().Set(model.HEADER_ETAG_SERVER, extraEtag) w.Header().Set("Expires", "-1") w.Write([]byte(data.ToJson())) } }
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 TestChannelStoreSave(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_OPEN if err := (<-store.Channel().Save(&o1)).Err; err != nil { t.Fatal("couldn't save item", err) } if err := (<-store.Channel().Save(&o1)).Err; err == nil { t.Fatal("shouldn't be able to update from save") } o1.Id = "" if err := (<-store.Channel().Save(&o1)).Err; err == nil { t.Fatal("should be unique name") } o1.Id = "" o1.Name = "a" + model.NewId() + "b" o1.Type = model.CHANNEL_DIRECT if err := (<-store.Channel().Save(&o1)).Err; err == nil { t.Fatal("Should not be able to save direct channel") } }
func (s SqlChannelStore) Save(channel *model.Channel) StoreChannel { storeChannel := make(StoreChannel) go func() { result := StoreResult{} if len(channel.Id) > 0 { result.Err = model.NewAppError("SqlChannelStore.Save", "Must call update for exisiting channel", "id="+channel.Id) storeChannel <- result close(storeChannel) return } channel.PreSave() if result.Err = channel.IsValid(); result.Err != nil { storeChannel <- result close(storeChannel) return } if count, err := s.GetMaster().SelectInt("SELECT COUNT(0) FROM Channels WHERE TeamId = :TeamId AND DeleteAt = 0 AND (Type = 'O' OR Type = 'P')", map[string]interface{}{"TeamId": channel.TeamId}); err != nil { result.Err = model.NewAppError("SqlChannelStore.Save", "Failed to get current channel count", "teamId="+channel.TeamId+", "+err.Error()) storeChannel <- result close(storeChannel) return } else if count > 150 { result.Err = model.NewAppError("SqlChannelStore.Save", "You've reached the limit of the number of allowed channels.", "teamId="+channel.TeamId) storeChannel <- result close(storeChannel) return } if err := s.GetMaster().Insert(channel); err != nil { if IsUniqueConstraintError(err.Error(), "Name", "channels_name_teamid_key") { dupChannel := model.Channel{} s.GetReplica().SelectOne(&dupChannel, "SELECT * FROM Channels WHERE TeamId = :TeamId AND Name = :Name AND DeleteAt > 0", map[string]interface{}{"TeamId": channel.TeamId, "Name": channel.Name}) if dupChannel.DeleteAt > 0 { result.Err = model.NewAppError("SqlChannelStore.Update", "A channel with that name was previously created", "id="+channel.Id+", "+err.Error()) } else { result.Err = model.NewAppError("SqlChannelStore.Update", "A channel with that name already exists", "id="+channel.Id+", "+err.Error()) } } else { result.Err = model.NewAppError("SqlChannelStore.Save", "We couldn't save the channel", "id="+channel.Id+", "+err.Error()) } } else { result.Data = channel } storeChannel <- result close(storeChannel) }() return storeChannel }
func (s SqlChannelStore) Save(channel *model.Channel) StoreChannel { storeChannel := make(StoreChannel) go func() { result := StoreResult{} if len(channel.Id) > 0 { result.Err = model.NewAppError("SqlChannelStore.Save", "Must call update for exisiting channel", "id="+channel.Id) storeChannel <- result close(storeChannel) return } channel.PreSave() if result.Err = channel.IsValid(); result.Err != nil { storeChannel <- result close(storeChannel) return } if count, err := s.GetMaster().SelectInt("SELECT COUNT(0) FROM Channels WHERE TeamId = ? AND DeleteAt = 0 AND (Type ='O' || Type ='P')", channel.TeamId); err != nil { result.Err = model.NewAppError("SqlChannelStore.Save", "Failed to get current channel count", "teamId="+channel.TeamId+", "+err.Error()) storeChannel <- result close(storeChannel) return } else if count > 150 { result.Err = model.NewAppError("SqlChannelStore.Save", "You've reached the limit of the number of allowed channels.", "teamId="+channel.TeamId) storeChannel <- result close(storeChannel) return } if err := s.GetMaster().Insert(channel); err != nil { if strings.Contains(err.Error(), "Duplicate entry") && strings.Contains(err.Error(), "for key 'Name'") { result.Err = model.NewAppError("SqlChannelStore.Save", "A channel with that name already exists", "id="+channel.Id+", "+err.Error()) } else { result.Err = model.NewAppError("SqlChannelStore.Save", "We couldn't save the channel", "id="+channel.Id+", "+err.Error()) } } else { result.Data = channel } storeChannel <- result close(storeChannel) }() return storeChannel }
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 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 TestChannelStoreUpdate(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 if err := (<-store.Channel().Save(&o1)).Err; err != nil { t.Fatal(err) } time.Sleep(100 * time.Millisecond) if err := (<-store.Channel().Update(&o1)).Err; err != nil { t.Fatal(err) } o1.Id = "missing" if err := (<-store.Channel().Update(&o1)).Err; err == nil { t.Fatal("Update should have failed because of missing key") } o1.Id = model.NewId() if err := (<-store.Channel().Update(&o1)).Err; err == nil { t.Fatal("Update should have faile because id change") } }
func (s SqlChannelStore) extraUpdated(channel *model.Channel) StoreChannel { storeChannel := make(StoreChannel) go func() { result := StoreResult{} channel.ExtraUpdated() if count, err := s.GetMaster().Update(channel); err != nil || count != 1 { result.Err = model.NewAppError("SqlChannelStore.extraUpdated", "Problem updating members last updated time", "id="+channel.Id+", "+err.Error()) } storeChannel <- result close(storeChannel) }() return storeChannel }
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 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 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 (s SqlChannelStore) SaveDirectChannel(directchannel *model.Channel, member1 *model.ChannelMember, member2 *model.ChannelMember) StoreChannel { storeChannel := make(StoreChannel) go func() { var result StoreResult if directchannel.Type != model.CHANNEL_DIRECT { result.Err = model.NewLocAppError("SqlChannelStore.SaveDirectChannel", "store.sql_channel.save_direct_channel.not_direct.app_error", nil, "") } else { if transaction, err := s.GetMaster().Begin(); err != nil { result.Err = model.NewLocAppError("SqlChannelStore.SaveDirectChannel", "store.sql_channel.save_direct_channel.open_transaction.app_error", nil, err.Error()) } else { directchannel.TeamId = "" channelResult := s.saveChannelT(transaction, directchannel) if channelResult.Err != nil { transaction.Rollback() result.Err = channelResult.Err result.Data = channelResult.Data } else { newChannel := channelResult.Data.(*model.Channel) // Members need new channel ID member1.ChannelId = newChannel.Id member2.ChannelId = newChannel.Id member1Result := s.saveMemberT(transaction, member1, newChannel) member2Result := s.saveMemberT(transaction, member2, newChannel) if member1Result.Err != nil || member2Result.Err != nil { transaction.Rollback() details := "" if member1Result.Err != nil { details += "Member1Err: " + member1Result.Err.Message } if member2Result.Err != nil { details += "Member2Err: " + member2Result.Err.Message } result.Err = model.NewLocAppError("SqlChannelStore.SaveDirectChannel", "store.sql_channel.save_direct_channel.add_members.app_error", nil, details) } else { if err := transaction.Commit(); err != nil { result.Err = model.NewLocAppError("SqlChannelStore.SaveDirectChannel", "store.sql_channel.save_direct_channel.commit.app_error", nil, err.Error()) } else { result = channelResult } } } } } storeChannel <- result close(storeChannel) }() return storeChannel }
func (s SqlChannelStore) saveChannelT(transaction *gorp.Transaction, channel *model.Channel) StoreResult { result := StoreResult{} if len(channel.Id) > 0 { result.Err = model.NewLocAppError("SqlChannelStore.Save", "store.sql_channel.save_channel.existing.app_error", nil, "id="+channel.Id) return result } channel.PreSave() if result.Err = channel.IsValid(); result.Err != nil { return result } if channel.Type != model.CHANNEL_DIRECT { if count, err := transaction.SelectInt("SELECT COUNT(0) FROM Channels WHERE TeamId = :TeamId AND DeleteAt = 0 AND (Type = 'O' OR Type = 'P')", map[string]interface{}{"TeamId": channel.TeamId}); err != nil { result.Err = model.NewLocAppError("SqlChannelStore.Save", "store.sql_channel.save_channel.current_count.app_error", nil, "teamId="+channel.TeamId+", "+err.Error()) return result } else if count > 1000 { result.Err = model.NewLocAppError("SqlChannelStore.Save", "store.sql_channel.save_channel.limit.app_error", nil, "teamId="+channel.TeamId) return result } } if err := transaction.Insert(channel); err != nil { if IsUniqueConstraintError(err.Error(), []string{"Name", "channels_name_teamid_key"}) { dupChannel := model.Channel{} s.GetMaster().SelectOne(&dupChannel, "SELECT * FROM Channels WHERE TeamId = :TeamId AND Name = :Name AND DeleteAt > 0", map[string]interface{}{"TeamId": channel.TeamId, "Name": channel.Name}) if dupChannel.DeleteAt > 0 { result.Err = model.NewLocAppError("SqlChannelStore.Save", "store.sql_channel.save_channel.previously.app_error", nil, "id="+channel.Id+", "+err.Error()) } else { result.Err = model.NewLocAppError("SqlChannelStore.Save", CHANNEL_EXISTS_ERROR, nil, "id="+channel.Id+", "+err.Error()) result.Data = &dupChannel } } else { result.Err = model.NewLocAppError("SqlChannelStore.Save", "store.sql_channel.save_channel.save.app_error", nil, "id="+channel.Id+", "+err.Error()) } } else { result.Data = channel } return result }
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 (s SqlChannelStore) saveChannelT(transaction *gorp.Transaction, channel *model.Channel) StoreResult { result := StoreResult{} if len(channel.Id) > 0 { result.Err = model.NewAppError("SqlChannelStore.Save", "Must call update for exisiting channel", "id="+channel.Id) return result } channel.PreSave() if result.Err = channel.IsValid(); result.Err != nil { return result } if channel.Type != model.CHANNEL_DIRECT { if count, err := transaction.SelectInt("SELECT COUNT(0) FROM Channels WHERE TeamId = :TeamId AND DeleteAt = 0 AND (Type = 'O' OR Type = 'P')", map[string]interface{}{"TeamId": channel.TeamId}); err != nil { result.Err = model.NewAppError("SqlChannelStore.Save", "Failed to get current channel count", "teamId="+channel.TeamId+", "+err.Error()) return result } else if count > 1000 { result.Err = model.NewAppError("SqlChannelStore.Save", "You've reached the limit of the number of allowed channels.", "teamId="+channel.TeamId) return result } } if err := transaction.Insert(channel); err != nil { if IsUniqueConstraintError(err.Error(), "Name", "channels_name_teamid_key") { dupChannel := model.Channel{} s.GetMaster().SelectOne(&dupChannel, "SELECT * FROM Channels WHERE TeamId = :TeamId AND Name = :Name AND DeleteAt > 0", map[string]interface{}{"TeamId": channel.TeamId, "Name": channel.Name}) if dupChannel.DeleteAt > 0 { result.Err = model.NewAppError("SqlChannelStore.Update", "A channel with that URL was previously created", "id="+channel.Id+", "+err.Error()) } else { result.Err = model.NewAppError("SqlChannelStore.Update", "A channel with that URL already exists", "id="+channel.Id+", "+err.Error()) } } else { result.Err = model.NewAppError("SqlChannelStore.Save", "We couldn't save the channel", "id="+channel.Id+", "+err.Error()) } } else { result.Data = channel } return result }
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 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 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.Description = "" channel.Type = model.CHANNEL_DIRECT if uresult := <-uc; uresult.Err != nil { return nil, model.NewAppError("CreateDirectChannel", "Invalid other user id ", otherUserId) } if sc, err := CreateChannel(c, channel, true); err != nil { return nil, err } else { cm := &model.ChannelMember{ChannelId: sc.Id, UserId: otherUserId, Roles: "", NotifyLevel: model.CHANNEL_NOTIFY_ALL} if cmresult := <-Srv.Store.Channel().SaveMember(cm); cmresult.Err != nil { return nil, cmresult.Err } return sc, nil } }
func (s SqlChannelStore) Update(channel *model.Channel) StoreChannel { storeChannel := make(StoreChannel) go func() { result := StoreResult{} channel.PreUpdate() if result.Err = channel.IsValid(); result.Err != nil { storeChannel <- result close(storeChannel) return } if count, err := s.GetMaster().Update(channel); err != nil { if strings.Contains(err.Error(), "Duplicate entry") && strings.Contains(err.Error(), "for key 'Name'") { dupChannel := model.Channel{} s.GetReplica().SelectOne(&dupChannel, "SELECT * FROM Channels WHERE TeamId=? AND Name=? AND DeleteAt > 0", channel.TeamId, channel.Name) if dupChannel.DeleteAt > 0 { result.Err = model.NewAppError("SqlChannelStore.Update", "A channel with that name was previously created", "id="+channel.Id+", "+err.Error()) } else { result.Err = model.NewAppError("SqlChannelStore.Update", "A channel with that name already exists", "id="+channel.Id+", "+err.Error()) } } else { result.Err = model.NewAppError("SqlChannelStore.Update", "We encounted an error updating the channel", "id="+channel.Id+", "+err.Error()) } } else if count != 1 { result.Err = model.NewAppError("SqlChannelStore.Update", "We couldn't update the channel", "id="+channel.Id) } else { result.Data = channel } storeChannel <- result close(storeChannel) }() return storeChannel }
func (s SqlChannelStore) Update(channel *model.Channel) StoreChannel { storeChannel := make(StoreChannel) go func() { result := StoreResult{} channel.PreUpdate() if result.Err = channel.IsValid(); result.Err != nil { storeChannel <- result close(storeChannel) return } if count, err := s.GetMaster().Update(channel); err != nil { if IsUniqueConstraintError(err.Error(), []string{"Name", "channels_name_teamid_key"}) { dupChannel := model.Channel{} s.GetReplica().SelectOne(&dupChannel, "SELECT * FROM Channels WHERE TeamId = :TeamId AND Name= :Name AND DeleteAt > 0", map[string]interface{}{"TeamId": channel.TeamId, "Name": channel.Name}) if dupChannel.DeleteAt > 0 { result.Err = model.NewLocAppError("SqlChannelStore.Update", "store.sql_channel.update.previously.app_error", nil, "id="+channel.Id+", "+err.Error()) } else { result.Err = model.NewLocAppError("SqlChannelStore.Update", "store.sql_channel.update.exists.app_error", nil, "id="+channel.Id+", "+err.Error()) } } else { result.Err = model.NewLocAppError("SqlChannelStore.Update", "store.sql_channel.update.updating.app_error", nil, "id="+channel.Id+", "+err.Error()) } } else if count != 1 { result.Err = model.NewLocAppError("SqlChannelStore.Update", "store.sql_channel.update.app_error", nil, "id="+channel.Id) } else { result.Data = channel } storeChannel <- result close(storeChannel) }() return storeChannel }
func (s SqlChannelStore) Update(channel *model.Channel) StoreChannel { storeChannel := make(StoreChannel) go func() { result := StoreResult{} channel.PreUpdate() if result.Err = channel.IsValid(); result.Err != nil { storeChannel <- result close(storeChannel) return } if count, err := s.GetMaster().Update(channel); err != nil { if IsUniqueConstraintError(err.Error(), "Name", "channels_name_teamid_key") { dupChannel := model.Channel{} s.GetReplica().SelectOne(&dupChannel, "SELECT * FROM Channels WHERE TeamId = :TeamId AND Name= :Name AND DeleteAt > 0", map[string]interface{}{"TeamId": channel.TeamId, "Name": channel.Name}) if dupChannel.DeleteAt > 0 { result.Err = model.NewAppError("SqlChannelStore.Update", "A channel with that name was previously created", "id="+channel.Id+", "+err.Error()) } else { result.Err = model.NewAppError("SqlChannelStore.Update", "A channel with that name already exists", "id="+channel.Id+", "+err.Error()) } } else { result.Err = model.NewAppError("SqlChannelStore.Update", "We encounted an error updating the channel", "id="+channel.Id+", "+err.Error()) } } else if count != 1 { result.Err = model.NewAppError("SqlChannelStore.Update", "We couldn't update the channel", "id="+channel.Id) } else { result.Data = channel } storeChannel <- result close(storeChannel) }() return storeChannel }
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 SlackSanitiseChannelProperties(channel model.Channel) model.Channel { if utf8.RuneCountInString(channel.DisplayName) > model.CHANNEL_DISPLAY_NAME_MAX_RUNES { l4g.Warn("api.slackimport.slack_sanitise_channel_properties.display_name_too_long.warn", map[string]interface{}{"ChannelName": channel.DisplayName}) channel.DisplayName = truncateRunes(channel.DisplayName, model.CHANNEL_DISPLAY_NAME_MAX_RUNES) } if len(channel.Name) > model.CHANNEL_NAME_MAX_LENGTH { l4g.Warn("api.slackimport.slack_sanitise_channel_properties.name_too_long.warn", map[string]interface{}{"ChannelName": channel.DisplayName}) channel.Name = channel.Name[0:model.CHANNEL_NAME_MAX_LENGTH] } if utf8.RuneCountInString(channel.Purpose) > model.CHANNEL_PURPOSE_MAX_RUNES { l4g.Warn("api.slackimport.slack_sanitise_channel_properties.purpose_too_long.warn", map[string]interface{}{"ChannelName": channel.DisplayName}) channel.Purpose = truncateRunes(channel.Purpose, model.CHANNEL_PURPOSE_MAX_RUNES) } if utf8.RuneCountInString(channel.Header) > model.CHANNEL_HEADER_MAX_RUNES { l4g.Warn("api.slackimport.slack_sanitise_channel_properties.header_too_long.warn", map[string]interface{}{"ChannelName": channel.DisplayName}) channel.Header = truncateRunes(channel.Header, model.CHANNEL_HEADER_MAX_RUNES) } return channel }