claude/mattermost-community-enterprise
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
0c9610520e
mattermost-community-enterp.../channels/store/sqlstore/channel_store.go
Claude ec1f89217a Merge: Complete Mattermost Server with Community Enterprise 
Full Mattermost server source with integrated Community Enterprise features.
Includes vendor directory for offline/air-gapped builds.

Structure:
- enterprise-impl/: Enterprise feature implementations
- enterprise-community/: Init files that register implementations
- enterprise/: Bridge imports (community_imports.go)
- vendor/: All dependencies for offline builds

Build (online):
  go build ./cmd/mattermost

Build (offline/air-gapped):
  go build -mod=vendor ./cmd/mattermost

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
2025-12-17 23:59:07 +09:00

4415 lines
136 KiB
Go
Raw Blame History

// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
// See LICENSE.txt for license information.
package sqlstore
import (
"database/sql"
"fmt"
"slices"
"sort"
"strconv"
"strings"
"unicode/utf8"
sq "github.com/mattermost/squirrel"
"github.com/pkg/errors"
"github.com/mattermost/mattermost/server/public/model"
"github.com/mattermost/mattermost/server/public/shared/mlog"
"github.com/mattermost/mattermost/server/public/shared/request"
"github.com/mattermost/mattermost/server/v8/channels/store"
"github.com/mattermost/mattermost/server/v8/einterfaces"
)
type SqlChannelStore struct {
*SqlStore
metrics einterfaces.MetricsInterface
tableSelectQuery sq.SelectBuilder
sidebarCategorySelectQuery sq.SelectBuilder
// prepared query builders for use in multiple methods
channelMembersForTeamWithSchemeSelectQuery sq.SelectBuilder
}
type channelMember struct {
ChannelId string
UserId string
Roles string
LastViewedAt int64
MsgCount int64
MentionCount int64
UrgentMentionCount int64
NotifyProps model.StringMap
LastUpdateAt int64
SchemeUser sql.NullBool
SchemeAdmin sql.NullBool
SchemeGuest sql.NullBool
MentionCountRoot int64
MsgCountRoot int64
}
func NewMapFromChannelMemberModel(cm *model.ChannelMember) map[string]any {
return map[string]any{
"ChannelId": cm.ChannelId,
"UserId": cm.UserId,
"Roles": cm.ExplicitRoles,
"LastViewedAt": cm.LastViewedAt,
"MsgCount": cm.MsgCount,
"MentionCount": cm.MentionCount,
"MentionCountRoot": cm.MentionCountRoot,
"UrgentMentionCount": cm.UrgentMentionCount,
"MsgCountRoot": cm.MsgCountRoot,
"NotifyProps": cm.NotifyProps,
"LastUpdateAt": cm.LastUpdateAt,
"SchemeGuest": sql.NullBool{Valid: true, Bool: cm.SchemeGuest},
"SchemeUser": sql.NullBool{Valid: true, Bool: cm.SchemeUser},
"SchemeAdmin": sql.NullBool{Valid: true, Bool: cm.SchemeAdmin},
}
}
type channelMemberWithSchemeRoles struct {
ChannelId string
UserId string
Roles string
LastViewedAt int64
MsgCount int64
MentionCount int64
MentionCountRoot int64
UrgentMentionCount int64
NotifyProps model.StringMap
LastUpdateAt int64
SchemeGuest sql.NullBool
SchemeUser sql.NullBool
SchemeAdmin sql.NullBool
TeamSchemeDefaultGuestRole sql.NullString
TeamSchemeDefaultUserRole sql.NullString
TeamSchemeDefaultAdminRole sql.NullString
ChannelSchemeDefaultGuestRole sql.NullString
ChannelSchemeDefaultUserRole sql.NullString
ChannelSchemeDefaultAdminRole sql.NullString
MsgCountRoot int64
}
type channelMemberWithTeamWithSchemeRoles struct {
channelMemberWithSchemeRoles
TeamDisplayName string
TeamName string
TeamUpdateAt int64
}
type channelMemberWithTeamWithSchemeRolesList []channelMemberWithTeamWithSchemeRoles
func channelMemberSliceColumns() []string {
return []string{"ChannelId", "UserId", "Roles", "LastViewedAt", "MsgCount", "MsgCountRoot", "MentionCount", "MentionCountRoot", "UrgentMentionCount", "NotifyProps", "LastUpdateAt", "SchemeUser", "SchemeAdmin", "SchemeGuest"}
}
// channelSliceColumns returns fields of the channel as a string slice.
// Optionally, you can add a prefix (accepts only 1 value) to the fields.
func channelSliceColumns(isSelect bool, prefix ...string) []string {
var p string
if len(prefix) == 1 {
p = prefix[0] + "."
} else if len(prefix) > 1 {
panic("cannot accept multiple prefixes")
}
columns := []string{
p + "Id",
p + "CreateAt",
p + "UpdateAt",
p + "DeleteAt",
p + "TeamId",
p + "Type",
p + "DisplayName",
p + "Name",
p + "Header",
p + "Purpose",
p + "LastPostAt",
p + "TotalMsgCount",
p + "ExtraUpdateAt",
p + "CreatorId",
p + "SchemeId",
p + "GroupConstrained",
p + "Shared",
p + "TotalMsgCountRoot",
p + "LastRootPostAt",
p + "BannerInfo",
p + "DefaultCategoryName",
}
if isSelect {
if p == "" {
p = "Channels."
}
columns = append(columns, fmt.Sprintf("EXISTS (SELECT 1 FROM AccessControlPolicies acp WHERE acp.ID = %sId) AS PolicyEnforced", p))
}
return columns
}
func channelToSlice(channel *model.Channel) []any {
return []any{
channel.Id,
channel.CreateAt,
channel.UpdateAt,
channel.DeleteAt,
channel.TeamId,
channel.Type,
channel.DisplayName,
channel.Name,
channel.Header,
channel.Purpose,
channel.LastPostAt,
channel.TotalMsgCount,
channel.ExtraUpdateAt,
channel.CreatorId,
channel.SchemeId,
channel.GroupConstrained,
channel.Shared,
channel.TotalMsgCountRoot,
channel.LastRootPostAt,
channel.BannerInfo,
channel.DefaultCategoryName,
}
}
func channelMemberToSlice(member *model.ChannelMember) []any {
resultSlice := []any{}
resultSlice = append(resultSlice, member.ChannelId)
resultSlice = append(resultSlice, member.UserId)
resultSlice = append(resultSlice, member.ExplicitRoles)
resultSlice = append(resultSlice, member.LastViewedAt)
resultSlice = append(resultSlice, member.MsgCount)
resultSlice = append(resultSlice, member.MsgCountRoot)
resultSlice = append(resultSlice, member.MentionCount)
resultSlice = append(resultSlice, member.MentionCountRoot)
resultSlice = append(resultSlice, member.UrgentMentionCount)
resultSlice = append(resultSlice, model.MapToJSON(member.NotifyProps))
resultSlice = append(resultSlice, member.LastUpdateAt)
resultSlice = append(resultSlice, member.SchemeUser)
resultSlice = append(resultSlice, member.SchemeAdmin)
resultSlice = append(resultSlice, member.SchemeGuest)
return resultSlice
}
type channelMemberWithSchemeRolesList []channelMemberWithSchemeRoles
func getChannelRoles(schemeGuest, schemeUser, schemeAdmin bool, defaultTeamGuestRole, defaultTeamUserRole, defaultTeamAdminRole, defaultChannelGuestRole, defaultChannelUserRole, defaultChannelAdminRole string,
roles []string,
) rolesInfo {
result := rolesInfo{
roles: []string{},
explicitRoles: []string{},
schemeGuest: schemeGuest,
schemeUser: schemeUser,
schemeAdmin: schemeAdmin,
}
// Identify any scheme derived roles that are in "Roles" field due to not yet being migrated, and exclude
// them from ExplicitRoles field.
for _, role := range roles {
switch role {
case model.ChannelGuestRoleId:
result.schemeGuest = true
case model.ChannelUserRoleId:
result.schemeUser = true
case model.ChannelAdminRoleId:
result.schemeAdmin = true
default:
result.explicitRoles = append(result.explicitRoles, role)
result.roles = append(result.roles, role)
}
}
// Add any scheme derived roles that are not in the Roles field due to being Implicit from the Scheme, and add
// them to the Roles field for backwards compatibility reasons.
var schemeImpliedRoles []string
if result.schemeGuest {
if defaultChannelGuestRole != "" {
schemeImpliedRoles = append(schemeImpliedRoles, defaultChannelGuestRole)
} else if defaultTeamGuestRole != "" {
schemeImpliedRoles = append(schemeImpliedRoles, defaultTeamGuestRole)
} else {
schemeImpliedRoles = append(schemeImpliedRoles, model.ChannelGuestRoleId)
}
}
if result.schemeUser {
if defaultChannelUserRole != "" {
schemeImpliedRoles = append(schemeImpliedRoles, defaultChannelUserRole)
} else if defaultTeamUserRole != "" {
schemeImpliedRoles = append(schemeImpliedRoles, defaultTeamUserRole)
} else {
schemeImpliedRoles = append(schemeImpliedRoles, model.ChannelUserRoleId)
}
}
if result.schemeAdmin {
if defaultChannelAdminRole != "" {
schemeImpliedRoles = append(schemeImpliedRoles, defaultChannelAdminRole)
} else if defaultTeamAdminRole != "" {
schemeImpliedRoles = append(schemeImpliedRoles, defaultTeamAdminRole)
} else {
schemeImpliedRoles = append(schemeImpliedRoles, model.ChannelAdminRoleId)
}
}
for _, impliedRole := range schemeImpliedRoles {
alreadyThere := slices.Contains(result.roles, impliedRole)
if !alreadyThere {
result.roles = append(result.roles, impliedRole)
}
}
return result
}
func (db channelMemberWithSchemeRoles) ToModel() *model.ChannelMember {
// Identify any system-wide scheme derived roles that are in "Roles" field due to not yet being migrated,
// and exclude them from ExplicitRoles field.
schemeGuest := db.SchemeGuest.Valid && db.SchemeGuest.Bool
schemeUser := db.SchemeUser.Valid && db.SchemeUser.Bool
schemeAdmin := db.SchemeAdmin.Valid && db.SchemeAdmin.Bool
defaultTeamGuestRole := ""
if db.TeamSchemeDefaultGuestRole.Valid {
defaultTeamGuestRole = db.TeamSchemeDefaultGuestRole.String
}
defaultTeamUserRole := ""
if db.TeamSchemeDefaultUserRole.Valid {
defaultTeamUserRole = db.TeamSchemeDefaultUserRole.String
}
defaultTeamAdminRole := ""
if db.TeamSchemeDefaultAdminRole.Valid {
defaultTeamAdminRole = db.TeamSchemeDefaultAdminRole.String
}
defaultChannelGuestRole := ""
if db.ChannelSchemeDefaultGuestRole.Valid {
defaultChannelGuestRole = db.ChannelSchemeDefaultGuestRole.String
}
defaultChannelUserRole := ""
if db.ChannelSchemeDefaultUserRole.Valid {
defaultChannelUserRole = db.ChannelSchemeDefaultUserRole.String
}
defaultChannelAdminRole := ""
if db.ChannelSchemeDefaultAdminRole.Valid {
defaultChannelAdminRole = db.ChannelSchemeDefaultAdminRole.String
}
rolesResult := getChannelRoles(
schemeGuest, schemeUser, schemeAdmin,
defaultTeamGuestRole, defaultTeamUserRole, defaultTeamAdminRole,
defaultChannelGuestRole, defaultChannelUserRole, defaultChannelAdminRole,
strings.Fields(db.Roles),
)
return &model.ChannelMember{
ChannelId: db.ChannelId,
UserId: db.UserId,
Roles: strings.Join(rolesResult.roles, " "),
LastViewedAt: db.LastViewedAt,
MsgCount: db.MsgCount,
MsgCountRoot: db.MsgCountRoot,
MentionCount: db.MentionCount,
MentionCountRoot: db.MentionCountRoot,
UrgentMentionCount: db.UrgentMentionCount,
NotifyProps: db.NotifyProps,
LastUpdateAt: db.LastUpdateAt,
SchemeAdmin: rolesResult.schemeAdmin,
SchemeUser: rolesResult.schemeUser,
SchemeGuest: rolesResult.schemeGuest,
ExplicitRoles: strings.Join(rolesResult.explicitRoles, " "),
}
}
// This is almost an entire copy of the above method with team information added.
func (db channelMemberWithTeamWithSchemeRoles) ToModel() *model.ChannelMemberWithTeamData {
// Identify any system-wide scheme derived roles that are in "Roles" field due to not yet being migrated,
// and exclude them from ExplicitRoles field.
schemeGuest := db.SchemeGuest.Valid && db.SchemeGuest.Bool
schemeUser := db.SchemeUser.Valid && db.SchemeUser.Bool
schemeAdmin := db.SchemeAdmin.Valid && db.SchemeAdmin.Bool
defaultTeamGuestRole := ""
if db.TeamSchemeDefaultGuestRole.Valid {
defaultTeamGuestRole = db.TeamSchemeDefaultGuestRole.String
}
defaultTeamUserRole := ""
if db.TeamSchemeDefaultUserRole.Valid {
defaultTeamUserRole = db.TeamSchemeDefaultUserRole.String
}
defaultTeamAdminRole := ""
if db.TeamSchemeDefaultAdminRole.Valid {
defaultTeamAdminRole = db.TeamSchemeDefaultAdminRole.String
}
defaultChannelGuestRole := ""
if db.ChannelSchemeDefaultGuestRole.Valid {
defaultChannelGuestRole = db.ChannelSchemeDefaultGuestRole.String
}
defaultChannelUserRole := ""
if db.ChannelSchemeDefaultUserRole.Valid {
defaultChannelUserRole = db.ChannelSchemeDefaultUserRole.String
}
defaultChannelAdminRole := ""
if db.ChannelSchemeDefaultAdminRole.Valid {
defaultChannelAdminRole = db.ChannelSchemeDefaultAdminRole.String
}
rolesResult := getChannelRoles(
schemeGuest, schemeUser, schemeAdmin,
defaultTeamGuestRole, defaultTeamUserRole, defaultTeamAdminRole,
defaultChannelGuestRole, defaultChannelUserRole, defaultChannelAdminRole,
strings.Fields(db.Roles),
)
return &model.ChannelMemberWithTeamData{
ChannelMember: model.ChannelMember{
ChannelId: db.ChannelId,
UserId: db.UserId,
Roles: strings.Join(rolesResult.roles, " "),
LastViewedAt: db.LastViewedAt,
MsgCount: db.MsgCount,
MsgCountRoot: db.MsgCountRoot,
MentionCount: db.MentionCount,
MentionCountRoot: db.MentionCountRoot,
UrgentMentionCount: db.UrgentMentionCount,
NotifyProps: db.NotifyProps,
LastUpdateAt: db.LastUpdateAt,
SchemeAdmin: rolesResult.schemeAdmin,
SchemeUser: rolesResult.schemeUser,
SchemeGuest: rolesResult.schemeGuest,
ExplicitRoles: strings.Join(rolesResult.explicitRoles, " "),
},
TeamName: db.TeamName,
TeamDisplayName: db.TeamDisplayName,
TeamUpdateAt: db.TeamUpdateAt,
}
}
func (db channelMemberWithSchemeRolesList) ToModel() model.ChannelMembers {
cms := model.ChannelMembers{}
for _, cm := range db {
cms = append(cms, *cm.ToModel())
}
return cms
}
func (db channelMemberWithTeamWithSchemeRolesList) ToModel() model.ChannelMembersWithTeamData {
cms := model.ChannelMembersWithTeamData{}
for _, cm := range db {
cms = append(cms, *cm.ToModel())
}
return cms
}
type allChannelMember struct {
ChannelId string
Roles string
SchemeGuest sql.NullBool
SchemeUser sql.NullBool
SchemeAdmin sql.NullBool
TeamSchemeDefaultGuestRole sql.NullString
TeamSchemeDefaultUserRole sql.NullString
TeamSchemeDefaultAdminRole sql.NullString
ChannelSchemeDefaultGuestRole sql.NullString
ChannelSchemeDefaultUserRole sql.NullString
ChannelSchemeDefaultAdminRole sql.NullString
}
func (db allChannelMember) Process() (string, string) {
roles := strings.Fields(db.Roles)
// Add any scheme derived roles that are not in the Roles field due to being Implicit from the Scheme, and add
// them to the Roles field for backwards compatibility reasons.
var schemeImpliedRoles []string
if db.SchemeGuest.Valid && db.SchemeGuest.Bool {
if db.ChannelSchemeDefaultGuestRole.Valid && db.ChannelSchemeDefaultGuestRole.String != "" {
schemeImpliedRoles = append(schemeImpliedRoles, db.ChannelSchemeDefaultGuestRole.String)
} else if db.TeamSchemeDefaultGuestRole.Valid && db.TeamSchemeDefaultGuestRole.String != "" {
schemeImpliedRoles = append(schemeImpliedRoles, db.TeamSchemeDefaultGuestRole.String)
} else {
schemeImpliedRoles = append(schemeImpliedRoles, model.ChannelGuestRoleId)
}
}
if db.SchemeUser.Valid && db.SchemeUser.Bool {
if db.ChannelSchemeDefaultUserRole.Valid && db.ChannelSchemeDefaultUserRole.String != "" {
schemeImpliedRoles = append(schemeImpliedRoles, db.ChannelSchemeDefaultUserRole.String)
} else if db.TeamSchemeDefaultUserRole.Valid && db.TeamSchemeDefaultUserRole.String != "" {
schemeImpliedRoles = append(schemeImpliedRoles, db.TeamSchemeDefaultUserRole.String)
} else {
schemeImpliedRoles = append(schemeImpliedRoles, model.ChannelUserRoleId)
}
}
if db.SchemeAdmin.Valid && db.SchemeAdmin.Bool {
if db.ChannelSchemeDefaultAdminRole.Valid && db.ChannelSchemeDefaultAdminRole.String != "" {
schemeImpliedRoles = append(schemeImpliedRoles, db.ChannelSchemeDefaultAdminRole.String)
} else if db.TeamSchemeDefaultAdminRole.Valid && db.TeamSchemeDefaultAdminRole.String != "" {
schemeImpliedRoles = append(schemeImpliedRoles, db.TeamSchemeDefaultAdminRole.String)
} else {
schemeImpliedRoles = append(schemeImpliedRoles, model.ChannelAdminRoleId)
}
}
for _, impliedRole := range schemeImpliedRoles {
alreadyThere := slices.Contains(roles, impliedRole)
if !alreadyThere {
roles = append(roles, impliedRole)
}
}
return db.ChannelId, strings.Join(roles, " ")
}
// publicChannel is a subset of the metadata corresponding to public channels only.
type publicChannel struct {
Id string `json:"id"`
DeleteAt int64 `json:"delete_at"`
TeamId string `json:"team_id"`
DisplayName string `json:"display_name"`
Name string `json:"name"`
Header string `json:"header"`
Purpose string `json:"purpose"`
}
func (s SqlChannelStore) ClearMembersForUserCache() {
}
func (s SqlChannelStore) ClearCaches() {
}
func newSqlChannelStore(sqlStore *SqlStore, metrics einterfaces.MetricsInterface) store.ChannelStore {
s := SqlChannelStore{
SqlStore: sqlStore,
metrics: metrics,
}
s.tableSelectQuery = s.getQueryBuilder().Select(channelSliceColumns(true)...).From("Channels")
s.sidebarCategorySelectQuery = s.getQueryBuilder().
Select("SidebarCategories.Id", "SidebarCategories.UserId", "SidebarCategories.TeamId", "SidebarCategories.SortOrder", "SidebarCategories.Sorting", "SidebarCategories.Type", "SidebarCategories.DisplayName", "SidebarCategories.Muted", "SidebarCategories.Collapsed").
From("SidebarCategories")
s.initializeQueries()
return &s
}
func (s *SqlChannelStore) initializeQueries() {
s.channelMembersForTeamWithSchemeSelectQuery = s.getQueryBuilder().
Select(
"ChannelMembers.ChannelId",
"ChannelMembers.UserId",
"ChannelMembers.Roles",
"ChannelMembers.LastViewedAt",
"ChannelMembers.MsgCount",
"ChannelMembers.MentionCount",
"ChannelMembers.MentionCountRoot",
"COALESCE(ChannelMembers.UrgentMentionCount, 0) AS UrgentMentionCount",
"ChannelMembers.MsgCountRoot",
"ChannelMembers.NotifyProps",
"ChannelMembers.LastUpdateAt",
"ChannelMembers.SchemeUser",
"ChannelMembers.SchemeAdmin",
"ChannelMembers.SchemeGuest",
"TeamScheme.DefaultChannelGuestRole TeamSchemeDefaultGuestRole",
"TeamScheme.DefaultChannelUserRole TeamSchemeDefaultUserRole",
"TeamScheme.DefaultChannelAdminRole TeamSchemeDefaultAdminRole",
"ChannelScheme.DefaultChannelGuestRole ChannelSchemeDefaultGuestRole",
"ChannelScheme.DefaultChannelUserRole ChannelSchemeDefaultUserRole",
"ChannelScheme.DefaultChannelAdminRole ChannelSchemeDefaultAdminRole",
).
From("ChannelMembers").
InnerJoin("Channels ON ChannelMembers.ChannelId = Channels.Id").
LeftJoin("Schemes ChannelScheme ON Channels.SchemeId = ChannelScheme.Id").
LeftJoin("Teams ON Channels.TeamId = Teams.Id").
LeftJoin("Schemes TeamScheme ON Teams.SchemeId = TeamScheme.Id")
}
func (s SqlChannelStore) upsertPublicChannelT(transaction *sqlxTxWrapper, channel *model.Channel) error {
publicChannel := &publicChannel{
Id: channel.Id,
DeleteAt: channel.DeleteAt,
TeamId: channel.TeamId,
DisplayName: channel.DisplayName,
Name: channel.Name,
Header: channel.Header,
Purpose: channel.Purpose,
}
if channel.Type != model.ChannelTypeOpen {
if _, err := transaction.Exec(`DELETE FROM PublicChannels WHERE Id=?`, publicChannel.Id); err != nil {
return errors.Wrap(err, "failed to delete public channel")
}
return nil
}
vals := map[string]any{
"id": publicChannel.Id,
"deleteat": publicChannel.DeleteAt,
"teamid": publicChannel.TeamId,
"displayname": publicChannel.DisplayName,
"name": publicChannel.Name,
"header": publicChannel.Header,
"purpose": publicChannel.Purpose,
}
var err error
_, err = transaction.NamedExec(`
INSERT INTO
PublicChannels(Id, DeleteAt, TeamId, DisplayName, Name, Header, Purpose)
VALUES
(:id, :deleteat, :teamid, :displayname, :name, :header, :purpose)
ON CONFLICT (id) DO UPDATE
SET DeleteAt = :deleteat,
TeamId = :teamid,
DisplayName = :displayname,
Name = :name,
Header = :header,
Purpose = :purpose;
`, vals)
if err != nil {
return errors.Wrap(err, "failed to insert public channel")
}
return nil
}
// Save writes the (non-direct) channel to the database.
func (s SqlChannelStore) Save(rctx request.CTX, channel *model.Channel, maxChannelsPerTeam int64, channelOptions ...model.ChannelOption) (_ *model.Channel, err error) {
for _, option := range channelOptions {
option(channel)
}
if channel.DeleteAt != 0 {
return nil, store.NewErrInvalidInput("Channel", "DeleteAt", channel.DeleteAt)
}
if channel.Type == model.ChannelTypeDirect {
return nil, store.NewErrInvalidInput("Channel", "Type", channel.Type)
}
var newChannel *model.Channel
transaction, err := s.GetMaster().Beginx()
if err != nil {
return nil, errors.Wrap(err, "begin_transaction")
}
defer finalizeTransactionX(transaction, &err)
newChannel, err = s.saveChannelT(transaction, channel, maxChannelsPerTeam)
if err != nil {
return newChannel, err
}
// Additionally propagate the write to the PublicChannels table.
if err = s.upsertPublicChannelT(transaction, newChannel); err != nil {
return nil, errors.Wrap(err, "upsert_public_channel")
}
if err = transaction.Commit(); err != nil {
return nil, errors.Wrap(err, "commit_transaction")
}
// There are cases when in case of conflict, the original channel value is returned.
// So we return both and let the caller do the checks.
return newChannel, err
}
func (s SqlChannelStore) CreateDirectChannel(rctx request.CTX, user *model.User, otherUser *model.User, channelOptions ...model.ChannelOption) (*model.Channel, error) {
channel := new(model.Channel)
for _, option := range channelOptions {
option(channel)
}
channel.DisplayName = ""
channel.Name = model.GetDMNameFromIds(otherUser.Id, user.Id)
channel.Header = ""
channel.Type = model.ChannelTypeDirect
channel.Shared = model.NewPointer(user.IsRemote() || otherUser.IsRemote())
channel.CreatorId = user.Id
cm1 := &model.ChannelMember{
UserId: user.Id,
NotifyProps: model.GetDefaultChannelNotifyProps(),
SchemeGuest: user.IsGuest(),
SchemeUser: !user.IsGuest(),
}
cm2 := &model.ChannelMember{
UserId: otherUser.Id,
NotifyProps: model.GetDefaultChannelNotifyProps(),
SchemeGuest: otherUser.IsGuest(),
SchemeUser: !otherUser.IsGuest(),
}
return s.SaveDirectChannel(rctx, channel, cm1, cm2)
}
func (s SqlChannelStore) SaveDirectChannel(rctx request.CTX, directChannel *model.Channel, member1 *model.ChannelMember, member2 *model.ChannelMember) (_ *model.Channel, err error) {
if directChannel.DeleteAt != 0 {
return nil, store.NewErrInvalidInput("Channel", "DeleteAt", directChannel.DeleteAt)
}
if directChannel.Type != model.ChannelTypeDirect {
return nil, store.NewErrInvalidInput("Channel", "Type", directChannel.Type)
}
transaction, err := s.GetMaster().Beginx()
if err != nil {
return nil, errors.Wrap(err, "begin_transaction")
}
defer finalizeTransactionX(transaction, &err)
directChannel.TeamId = ""
newChannel, err := s.saveChannelT(transaction, directChannel, 0)
if err != nil {
return newChannel, err
}
// Members need new channel ID
member1.ChannelId = newChannel.Id
member2.ChannelId = newChannel.Id
if member1.UserId != member2.UserId {
_, err = s.saveMultipleMembers([]*model.ChannelMember{member1, member2})
} else {
_, err = s.saveMemberT(member2)
}
if err != nil {
return nil, err
}
if err := transaction.Commit(); err != nil {
return nil, errors.Wrap(err, "commit_transaction")
}
return newChannel, nil
}
func (s SqlChannelStore) saveChannelT(transaction *sqlxTxWrapper, channel *model.Channel, maxChannelsPerTeam int64) (*model.Channel, error) {
if channel.Id != "" && !channel.IsShared() {
return nil, store.NewErrInvalidInput("Channel", "Id", channel.Id)
}
channel.PreSave()
if err := channel.IsValid(); err != nil { // TODO: this needs to return plain error in v6.
return nil, err // we just pass through the error as-is for now.
}
if channel.Type != model.ChannelTypeDirect && channel.Type != model.ChannelTypeGroup && maxChannelsPerTeam >= 0 {
var count int64
if err := transaction.Get(&count, "SELECT COUNT(0) FROM Channels WHERE TeamId = ? AND DeleteAt = 0 AND (Type = ? OR Type = ?)", channel.TeamId, model.ChannelTypeOpen, model.ChannelTypePrivate); err != nil {
return nil, errors.Wrapf(err, "save_channel_count: teamId=%s", channel.TeamId)
} else if count >= maxChannelsPerTeam {
return nil, store.NewErrLimitExceeded("channels_per_team", int(count), "teamId="+channel.TeamId)
}
}
insert := s.getQueryBuilder().
Insert("Channels").
Columns(channelSliceColumns(false)...).
Values(channelToSlice(channel)...).
SuffixExpr(sq.Expr("ON CONFLICT (TeamId, Name) DO NOTHING"))
query, params, err := insert.ToSql()
if err != nil {
return nil, errors.Wrapf(err, "save_channel: id=%s", channel.Id)
}
insertResult, err := transaction.Exec(query, params...)
if err != nil {
return nil, errors.Wrapf(err, "save_channel: id=%s", channel.Id)
}
rowAffected, err := insertResult.RowsAffected()
if err != nil {
return nil, errors.Wrapf(err, "save_channel: id=%s", channel.Id)
}
if rowAffected == 0 {
dupChannel := model.Channel{}
query := s.tableSelectQuery.Where(sq.Eq{"TeamId": channel.TeamId, "Name": channel.Name})
err := s.GetMaster().GetBuilder(&dupChannel, query)
if err != nil {
return nil, errors.Wrapf(err, "error while retrieving existing channel %s", channel.Name) // do not return this as a *store.ErrConflict as it would be treated as a recoverable error
}
return &dupChannel, store.NewErrConflict("Channel", err, "id="+channel.Id)
}
return channel, nil
}
// Update writes the updated channel to the database.
func (s SqlChannelStore) Update(rctx request.CTX, channel *model.Channel) (_ *model.Channel, err error) {
transaction, err := s.GetMaster().Beginx()
if err != nil {
return nil, errors.Wrap(err, "begin_transaction")
}
defer finalizeTransactionX(transaction, &err)
updatedChannel, err := s.updateChannelT(transaction, channel)
if err != nil {
return nil, err
}
// Additionally propagate the write to the PublicChannels table.
if err := s.upsertPublicChannelT(transaction, updatedChannel); err != nil {
return nil, errors.Wrap(err, "upsertPublicChannelT: failed to upsert channel")
}
if err := transaction.Commit(); err != nil {
return nil, errors.Wrap(err, "commit_transaction")
}
return updatedChannel, nil
}
func (s SqlChannelStore) updateChannelT(transaction *sqlxTxWrapper, channel *model.Channel) (*model.Channel, error) {
channel.PreUpdate()
if channel.DeleteAt != 0 {
return nil, store.NewErrInvalidInput("Channel", "DeleteAt", channel.DeleteAt)
}
if err := channel.IsValid(); err != nil {
return nil, err
}
res, err := transaction.NamedExec(`UPDATE Channels
SET CreateAt=:CreateAt,
UpdateAt=:UpdateAt,
DeleteAt=:DeleteAt,
TeamId=:TeamId,
Type=:Type,
DisplayName=:DisplayName,
Name=:Name,
Header=:Header,
Purpose=:Purpose,
LastPostAt=:LastPostAt,
TotalMsgCount=:TotalMsgCount,
ExtraUpdateAt=:ExtraUpdateAt,
CreatorId=:CreatorId,
SchemeId=:SchemeId,
GroupConstrained=:GroupConstrained,
Shared=:Shared,
TotalMsgCountRoot=:TotalMsgCountRoot,
LastRootPostAt=:LastRootPostAt,
BannerInfo=:BannerInfo,
DefaultCategoryName=:DefaultCategoryName
WHERE Id=:Id`, channel)
if err != nil {
if IsUniqueConstraintError(err, []string{"Name", "channels_name_teamid_key"}) {
return nil, store.NewErrUniqueConstraint("Name")
}
return nil, errors.Wrapf(err, "failed to update channel with id=%s", channel.Id)
}
count, err := res.RowsAffected()
if err != nil {
return nil, errors.Wrap(err, "error while getting rowsAffected in updateChannelT")
}
if count > 1 {
return nil, fmt.Errorf("the expected number of channels to be updated is <=1 but was %d", count)
}
return channel, nil
}
func (s SqlChannelStore) GetChannelUnread(channelId, userId string) (*model.ChannelUnread, error) {
var unreadChannel model.ChannelUnread
err := s.GetReplica().Get(&unreadChannel,
`SELECT
Channels.TeamId TeamId, Channels.Id ChannelId, (Channels.TotalMsgCount - ChannelMembers.MsgCount) MsgCount, (Channels.TotalMsgCountRoot - ChannelMembers.MsgCountRoot) MsgCountRoot, ChannelMembers.MentionCount MentionCount, ChannelMembers.MentionCountRoot MentionCountRoot, COALESCE(ChannelMembers.UrgentMentionCount, 0) UrgentMentionCount, ChannelMembers.NotifyProps NotifyProps
FROM
Channels, ChannelMembers
WHERE
Id = ChannelId
AND Id = ?
AND UserId = ?
AND DeleteAt = 0`,
channelId, userId)
if err != nil {
if err == sql.ErrNoRows {
return nil, store.NewErrNotFound("Channel", fmt.Sprintf("channelId=%s,userId=%s", channelId, userId))
}
return nil, errors.Wrapf(err, "failed to get Channel with channelId=%s and userId=%s", channelId, userId)
}
return &unreadChannel, nil
}
//nolint:unparam
func (s SqlChannelStore) InvalidateChannel(id string) {
}
//nolint:unparam
func (s SqlChannelStore) InvalidateChannelByName(teamId, name string) {
}
func (s SqlChannelStore) GetPinnedPosts(channelId string) (*model.PostList, error) {
pl := model.NewPostList()
query := s.getQueryBuilder().
Select(postSliceColumns()...).
Column("(SELECT count(Posts.Id) FROM Posts WHERE Posts.RootId = (CASE WHEN p.RootId = '' THEN p.Id ELSE p.RootId END) AND Posts.DeleteAt = 0) as ReplyCount").
From("Posts p").
Where(sq.Eq{
"IsPinned": true,
"ChannelId": channelId,
"DeleteAt": 0,
}).
OrderBy("CreateAt ASC")
posts := []*model.Post{}
if err := s.GetReplica().SelectBuilder(&posts, query); err != nil {
return nil, errors.Wrap(err, "failed to find Posts")
}
for _, post := range posts {
pl.AddPost(post)
pl.AddOrder(post.Id)
}
return pl, nil
}
//nolint:unparam
func (s SqlChannelStore) Get(id string, allowFromCache bool) (*model.Channel, error) {
ch := model.Channel{}
query := s.tableSelectQuery.Where(sq.Eq{"Id": id})
err := s.GetReplica().GetBuilder(&ch, query)
if err != nil {
if err == sql.ErrNoRows {
return nil, store.NewErrNotFound("Channel", id)
}
return nil, errors.Wrapf(err, "failed to find channel with id = %s", id)
}
return &ch, nil
}
//nolint:unparam
func (s SqlChannelStore) GetMany(ids []string, allowFromCache bool) (model.ChannelList, error) {
query := s.getQueryBuilder().
Select(channelSliceColumns(true)...).
From("Channels").
Where(sq.Eq{"Id": ids})
sql, args, err := query.ToSql()
if err != nil {
return nil, errors.Wrapf(err, "getmany_tosql")
}
channels := model.ChannelList{}
err = s.GetReplica().Select(&channels, sql, args...)
if err != nil {
return nil, errors.Wrapf(err, "failed to get channels with ids %v", ids)
}
if len(channels) == 0 {
return nil, store.NewErrNotFound("Channel", fmt.Sprintf("ids=%v", ids))
}
return channels, nil
}
// Delete records the given deleted timestamp to the channel in question.
func (s SqlChannelStore) Delete(channelId string, time int64) error {
return s.SetDeleteAt(channelId, time, time)
}
// Restore reverts a previous deleted timestamp from the channel in question.
func (s SqlChannelStore) Restore(channelId string, time int64) error {
return s.SetDeleteAt(channelId, 0, time)
}
// SetDeleteAt records the given deleted and updated timestamp to the channel in question.
func (s SqlChannelStore) SetDeleteAt(channelId string, deleteAt, updateAt int64) (err error) {
defer s.InvalidateChannel(channelId)
transaction, err := s.GetMaster().Beginx()
if err != nil {
return errors.Wrap(err, "SetDeleteAt: begin_transaction")
}
defer finalizeTransactionX(transaction, &err)
err = s.setDeleteAtT(transaction, channelId, deleteAt, updateAt)
if err != nil {
return errors.Wrap(err, "setDeleteAtT")
}
// Additionally propagate the write to the PublicChannels table.
if _, err := transaction.Exec(`
UPDATE
PublicChannels
SET
DeleteAt = ?
WHERE
Id = ?
`, deleteAt, channelId); err != nil {
return errors.Wrapf(err, "failed to delete public channels with id=%s", channelId)
}
if err := transaction.Commit(); err != nil {
return errors.Wrapf(err, "SetDeleteAt: commit_transaction")
}
return nil
}
func (s SqlChannelStore) setDeleteAtT(transaction *sqlxTxWrapper, channelId string, deleteAt, updateAt int64) error {
_, err := transaction.Exec(`UPDATE Channels
SET DeleteAt = ?,
UpdateAt = ?
WHERE Id = ?`, deleteAt, updateAt, channelId)
if err != nil {
return errors.Wrapf(err, "failed to delete channel with id=%s", channelId)
}
return nil
}
// PermanentDeleteByTeam removes all channels for the given team from the database.
func (s SqlChannelStore) PermanentDeleteByTeam(teamId string) (err error) {
transaction, err := s.GetMaster().Beginx()
if err != nil {
return errors.Wrap(err, "PermanentDeleteByTeam: begin_transaction")
}
defer finalizeTransactionX(transaction, &err)
if err := s.permanentDeleteByTeamtT(transaction, teamId); err != nil {
return errors.Wrap(err, "permanentDeleteByTeamtT")
}
// Additionally propagate the deletions to the PublicChannels table.
if _, err := transaction.Exec(`
DELETE FROM
PublicChannels
WHERE
TeamId = ?
`, teamId); err != nil {
return errors.Wrapf(err, "failed to delete public channels by team with teamId=%s", teamId)
}
if err := transaction.Commit(); err != nil {
return errors.Wrap(err, "PermanentDeleteByTeam: commit_transaction")
}
return nil
}
func (s SqlChannelStore) permanentDeleteByTeamtT(transaction *sqlxTxWrapper, teamId string) error {
if _, err := transaction.Exec("DELETE FROM Channels WHERE TeamId = ?", teamId); err != nil {
return errors.Wrapf(err, "failed to delete channel by team with teamId=%s", teamId)
}
return nil
}
// PermanentDelete removes the given channel from the database.
func (s SqlChannelStore) PermanentDelete(rctx request.CTX, channelId string) (err error) {
transaction, err := s.GetMaster().Beginx()
if err != nil {
return errors.Wrap(err, "PermanentDelete: begin_transaction")
}
defer finalizeTransactionX(transaction, &err)
if err := s.permanentDeleteT(transaction, channelId); err != nil {
return errors.Wrap(err, "permanentDeleteT")
}
// Additionally propagate the deletion to the PublicChannels table.
if _, err := transaction.Exec(`
DELETE FROM
PublicChannels
WHERE
Id = ?
`, channelId); err != nil {
return errors.Wrapf(err, "failed to delete public channels with id=%s", channelId)
}
if err := transaction.Commit(); err != nil {
return errors.Wrap(err, "PermanentDelete: commit_transaction")
}
return nil
}
func (s SqlChannelStore) permanentDeleteT(transaction *sqlxTxWrapper, channelId string) error {
if _, err := transaction.Exec("DELETE FROM Channels WHERE Id = ?", channelId); err != nil {
return errors.Wrapf(err, "failed to delete channel with id=%s", channelId)
}
return nil
}
func (s SqlChannelStore) PermanentDeleteMembersByChannel(rctx request.CTX, channelId string) error {
_, err := s.GetMaster().Exec("DELETE FROM ChannelMembers WHERE ChannelId = ?", channelId)
if err != nil {
return errors.Wrapf(err, "failed to delete Channel with channelId=%s", channelId)
}
return nil
}
func (s SqlChannelStore) GetChannels(teamId string, userId string, opts *model.ChannelSearchOpts) (model.ChannelList, error) {
query := s.getQueryBuilder().
Select(channelSliceColumns(true, "ch")...).
From("Channels ch, ChannelMembers cm").
Where(
sq.And{
sq.Expr("ch.Id = cm.ChannelId"),
sq.Eq{"cm.UserId": userId},
},
).
OrderBy("ch.DisplayName")
if teamId != "" {
query = query.Where(sq.Or{
sq.Eq{"ch.TeamId": teamId},
sq.Eq{"ch.TeamId": ""},
})
}
if opts.IncludeDeleted {
if opts.LastDeleteAt != 0 {
// We filter by non-archived, and archived >= a timestamp.
query = query.Where(sq.Or{
sq.Eq{"ch.DeleteAt": 0},
sq.GtOrEq{"ch.DeleteAt": opts.LastDeleteAt},
})
}
// If opts.LastDeleteAt is not set, we include everything. That means no filter is needed.
} else {
// Don't include archived channels.
query = query.Where(sq.Eq{"ch.DeleteAt": 0})
}
if opts.LastUpdateAt > 0 {
query = query.Where(sq.GtOrEq{"ch.UpdateAt": opts.LastUpdateAt})
}
channels := model.ChannelList{}
sql, args, err := query.ToSql()
if err != nil {
return nil, errors.Wrapf(err, "getchannels_tosql")
}
err = s.GetReplica().Select(&channels, sql, args...)
if err != nil {
return nil, errors.Wrapf(err, "failed to get channels with TeamId=%s and UserId=%s", teamId, userId)
}
if len(channels) == 0 {
return nil, store.NewErrNotFound("Channel", "userId="+userId)
}
return channels, nil
}
func (s SqlChannelStore) GetChannelsByUser(userId string, includeDeleted bool, lastDeleteAt, pageSize int, fromChannelID string) (model.ChannelList, error) {
query := s.getQueryBuilder().
Select(channelSliceColumns(true, "Channels")...).
From("Channels").
InnerJoin("ChannelMembers ON (Channels.Id = ChannelMembers.ChannelId)").
LeftJoin("Teams ON (Channels.TeamId = Teams.Id)").
Where(
sq.Eq{"ChannelMembers.UserId": userId},
).
OrderBy("Channels.Id ASC")
if fromChannelID != "" {
query = query.Where(sq.Gt{"Channels.Id": fromChannelID})
}
if pageSize != -1 {
query = query.Limit(uint64(pageSize))
}
if includeDeleted {
if lastDeleteAt != 0 {
// We filter by non-archived, and archived >= a timestamp.
query = query.Where(sq.And{
sq.Or{
sq.Eq{"Channels.DeleteAt": 0},
sq.GtOrEq{"Channels.DeleteAt": lastDeleteAt},
},
sq.Or{
sq.Eq{"Teams.Id": nil},
sq.Eq{"Teams.DeleteAt": 0},
sq.GtOrEq{"Teams.DeleteAt": lastDeleteAt},
},
})
}
// If lastDeleteAt is not set, we include everything. That means no filter is needed.
} else {
// Don't include archived channels or channels from deleted teams
query = query.Where(sq.And{
sq.Eq{"Channels.DeleteAt": 0},
sq.Or{
sq.Eq{"Teams.DeleteAt": 0},
sq.Eq{"Teams.Id": nil},
},
})
}
sql, args, err := query.ToSql()
if err != nil {
return nil, errors.Wrapf(err, "getchannels_tosql")
}
channels := model.ChannelList{}
err = s.GetReplica().Select(&channels, sql, args...)
if err != nil {
return nil, errors.Wrapf(err, "failed to get channels with UserId=%s", userId)
}
if len(channels) == 0 {
return nil, store.NewErrNotFound("Channel", "userId="+userId)
}
return channels, nil
}
func (s SqlChannelStore) GetAllChannelMemberIdsByChannelId(channelID string) ([]string, error) {
userIDs := []string{}
err := s.GetReplica().Select(&userIDs, `SELECT UserId
FROM ChannelMembers
WHERE ChannelId=?`, channelID)
if err != nil {
return nil, errors.Wrapf(err, "failed to get ChannelMembers with channelID=%s", channelID)
}
return userIDs, nil
}
func (s SqlChannelStore) GetAllChannels(offset, limit int, opts store.ChannelSearchOpts) (model.ChannelListWithTeamData, error) {
query := s.getAllChannelsQuery(opts, false)
query = query.
OrderBy("c.DisplayName, Teams.DisplayName").
Limit(uint64(limit)).
Offset(uint64(offset))
queryString, args, err := query.ToSql()
if err != nil {
return nil, errors.Wrap(err, "failed to create query")
}
data := model.ChannelListWithTeamData{}
err = s.GetReplica().Select(&data, queryString, args...)
if err != nil {
return nil, errors.Wrap(err, "failed to get all channels")
}
return data, nil
}
func (s SqlChannelStore) GetAllChannelsCount(opts store.ChannelSearchOpts) (int64, error) {
query := s.getAllChannelsQuery(opts, true)
queryString, args, err := query.ToSql()
if err != nil {
return 0, errors.Wrap(err, "failed to create query")
}
var count int64
err = s.GetReplica().Get(&count, queryString, args...)
if err != nil {
return 0, errors.Wrap(err, "failed to count all channels")
}
return count, nil
}
func (s SqlChannelStore) getAllChannelsQuery(opts store.ChannelSearchOpts, forCount bool) sq.SelectBuilder {
var selectQuery sq.SelectBuilder
if forCount {
selectQuery = s.getQueryBuilder().
Select("count(c.Id)")
} else {
selectQuery = s.getQueryBuilder().
Select(channelSliceColumns(true, "c")...).
Columns(
"Teams.DisplayName AS TeamDisplayName",
"Teams.Name AS TeamName",
"Teams.UpdateAt AS TeamUpdateAt",
)
if opts.IncludePolicyID {
selectQuery = selectQuery.Columns("RetentionPoliciesChannels.PolicyId AS PolicyID")
}
}
query := selectQuery.
From("Channels AS c").
Where(sq.Eq{"c.Type": []model.ChannelType{model.ChannelTypePrivate, model.ChannelTypeOpen}})
if !forCount {
query = query.Join("Teams ON Teams.Id = c.TeamId")
}
if !opts.IncludeDeleted {
query = query.Where(sq.Eq{"c.DeleteAt": int(0)})
}
if opts.NotAssociatedToGroup != "" {
query = query.Where("c.Id NOT IN (SELECT ChannelId FROM GroupChannels WHERE GroupChannels.GroupId = ? AND GroupChannels.DeleteAt = 0)", opts.NotAssociatedToGroup)
}
if opts.GroupConstrained {
query = query.Where(sq.Eq{"c.GroupConstrained": true})
} else if opts.ExcludeGroupConstrained {
query = query.Where(sq.Or{
sq.NotEq{"c.GroupConstrained": true},
sq.Eq{"c.GroupConstrained": nil},
})
}
if len(opts.ExcludeChannelNames) > 0 {
query = query.Where(sq.NotEq{"c.Name": opts.ExcludeChannelNames})
}
if opts.ExcludePolicyConstrained || opts.IncludePolicyID {
query = query.LeftJoin("RetentionPoliciesChannels ON c.Id = RetentionPoliciesChannels.ChannelId")
}
if opts.ExcludePolicyConstrained {
query = query.Where("RetentionPoliciesChannels.ChannelId IS NULL")
}
if opts.ExcludeAccessControlPolicyEnforced {
query = query.Where("c.Id NOT IN (SELECT ID From AccessControlPolicies WHERE Type = ?)", model.AccessControlPolicyTypeChannel)
} else if opts.AccessControlPolicyEnforced {
query = query.InnerJoin("AccessControlPolicies acp ON c.Id = acp.ID")
}
return query
}
func (s SqlChannelStore) GetMoreChannels(teamId string, userId string, offset int, limit int) (model.ChannelList, error) {
subQuery := s.getSubQueryBuilder().
Select("c.Id").
From("PublicChannels c").
Join("ChannelMembers cm ON (cm.ChannelId = c.Id)").
Where(sq.Eq{
"c.TeamId": teamId,
"cm.UserId": userId,
"c.DeleteAt": 0,
})
query := s.getQueryBuilder().
Select(channelSliceColumns(true, "Channels")...).
From("Channels").
Join("PublicChannels c ON (c.Id = Channels.Id)").
Where(sq.Eq{
"c.TeamId": teamId,
"c.DeleteAt": 0,
}).
Where(sq.Expr("c.Id NOT IN (?)", subQuery)).
OrderBy("c.DisplayName").
Limit(uint64(limit)).
Offset(uint64(offset))
channels := model.ChannelList{}
err := s.GetReplica().SelectBuilder(&channels, query)
if err != nil {
return nil, errors.Wrapf(err, "failed getting channels with teamId=%s and userId=%s", teamId, userId)
}
return channels, nil
}
func (s SqlChannelStore) GetPrivateChannelsForTeam(teamId string, offset int, limit int) (model.ChannelList, error) {
channels := model.ChannelList{}
builder := s.getQueryBuilder().
Select(channelSliceColumns(true)...).
From("Channels").
Where(sq.Eq{"Type": model.ChannelTypePrivate, "TeamId": teamId, "DeleteAt": 0}).
OrderBy("DisplayName").
Limit(uint64(limit)).
Offset(uint64(offset))
query, args, err := builder.ToSql()
if err != nil {
return nil, errors.Wrap(err, "channels_tosql")
}
err = s.GetReplica().Select(&channels, query, args...)
if err != nil {
return nil, errors.Wrapf(err, "failed to find channel with teamId=%s", teamId)
}
return channels, nil
}
func (s SqlChannelStore) GetPublicChannelsForTeam(teamId string, offset int, limit int) (model.ChannelList, error) {
query := s.getQueryBuilder().
Select(channelSliceColumns(true, "Channels")...).
From("Channels").
Join("PublicChannels pc ON (pc.Id = Channels.Id)").
Where(sq.Eq{
"pc.TeamId": teamId,
"pc.DeleteAt": 0,
}).
OrderBy("pc.DisplayName").
Limit(uint64(limit)).
Offset(uint64(offset))
channels := model.ChannelList{}
queryString, args, err := query.ToSql()
if err != nil {
return nil, errors.Wrap(err, "failed to convert query to string")
}
err = s.GetReplica().Select(&channels, queryString, args...)
if err != nil {
return nil, errors.Wrapf(err, "failed to find channel with teamId=%s", teamId)
}
return channels, nil
}
func (s SqlChannelStore) GetPublicChannelsByIdsForTeam(teamId string, channelIds []string) (model.ChannelList, error) {
props := make(map[string]any)
props["teamId"] = teamId
idQuery := ""
for index, channelId := range channelIds {
if idQuery != "" {
idQuery += ", "
}
props["channelId"+strconv.Itoa(index)] = channelId
idQuery += ":channelId" + strconv.Itoa(index)
}
var data model.ChannelList
builder := s.getQueryBuilder().
Select(channelSliceColumns(true, "Channels")...).
From("Channels").
Join("PublicChannels pc ON (pc.Id = Channels.Id)").
Where(sq.And{
sq.Eq{"pc.TeamId": teamId},
sq.Eq{"pc.DeleteAt": 0},
sq.Eq{"pc.Id": channelIds},
}).
OrderBy("pc.DisplayName")
queryString, args, err := builder.ToSql()
if err != nil {
return nil, errors.Wrap(err, "GetPublicChannelsByIdsForTeam to_sql")
}
err = s.GetReplica().Select(&data, queryString, args...)
if err != nil {
return nil, errors.Wrap(err, "failed to find Channels")
}
if len(data) == 0 {
return nil, store.NewErrNotFound("Channel", fmt.Sprintf("teamId=%s, channelIds=%v", teamId, channelIds))
}
return data, nil
}
func (s SqlChannelStore) GetChannelCounts(teamId string, userId string) (*model.ChannelCounts, error) {
data := []struct {
Id string
TotalMsgCount int64
TotalMsgCountRoot int64
UpdateAt int64
}{}
err := s.GetReplica().Select(&data, `SELECT Id, TotalMsgCount, TotalMsgCountRoot, UpdateAt
FROM Channels
WHERE Id IN (SELECT ChannelId FROM ChannelMembers WHERE UserId = ?)
AND (TeamId = ? OR TeamId = '')
AND DeleteAt = 0
ORDER BY DisplayName`, userId, teamId)
if err != nil {
return nil, errors.Wrapf(err, "failed to get channels count with teamId=%s and userId=%s", teamId, userId)
}
counts := &model.ChannelCounts{
Counts: make(map[string]int64),
CountsRoot: make(map[string]int64),
UpdateTimes: make(map[string]int64),
}
for i := range data {
v := data[i]
counts.Counts[v.Id] = v.TotalMsgCount
counts.CountsRoot[v.Id] = v.TotalMsgCountRoot
counts.UpdateTimes[v.Id] = v.UpdateAt
}
return counts, nil
}
func (s SqlChannelStore) GetTeamChannels(teamId string) (model.ChannelList, error) {
data := model.ChannelList{}
query := s.tableSelectQuery.Where(sq.And{sq.Eq{"TeamId": teamId}, sq.NotEq{"Type": model.ChannelTypeDirect}}).OrderBy("DisplayName")
err := s.GetReplica().SelectBuilder(&data, query)
if err != nil {
return nil, errors.Wrapf(err, "failed to find Channels with teamId=%s", teamId)
}
if len(data) == 0 {
return nil, store.NewErrNotFound("Channel", fmt.Sprintf("teamId=%s", teamId))
}
return data, nil
}
func (s SqlChannelStore) GetByNamesIncludeDeleted(teamId string, names []string, allowFromCache bool) ([]*model.Channel, error) {
return s.getByNames(teamId, names, allowFromCache, true)
}
func (s SqlChannelStore) GetByNames(teamId string, names []string, allowFromCache bool) ([]*model.Channel, error) {
return s.getByNames(teamId, names, allowFromCache, false)
}
func (s SqlChannelStore) getByNames(teamId string, names []string, allowFromCache, includeArchivedChannels bool) ([]*model.Channel, error) {
channels := []*model.Channel{}
if len(names) > 0 {
cond := sq.And{
sq.Eq{"Name": names},
}
if !includeArchivedChannels {
cond = append(cond, sq.Eq{"DeleteAt": 0})
}
builder := s.getQueryBuilder().
Select(channelSliceColumns(true)...).
From("Channels").
Where(cond)
if teamId != "" {
builder = builder.Where(sq.Eq{"TeamId": teamId})
}
query, args, err := builder.ToSql()
if err != nil {
return nil, errors.Wrap(err, "GetByNames_tosql")
}
if err := s.GetReplica().Select(&channels, query, args...); err != nil && err != sql.ErrNoRows {
msg := fmt.Sprintf("failed to get channels with names=%v", names)
if teamId != "" {
msg += fmt.Sprintf(" teamId=%s", teamId)
}
return nil, errors.Wrap(err, msg)
}
}
return channels, nil
}
func (s SqlChannelStore) GetByNameIncludeDeleted(teamId string, name string, allowFromCache bool) (*model.Channel, error) {
return s.getByName(teamId, name, true, allowFromCache)
}
func (s SqlChannelStore) GetByName(teamId string, name string, allowFromCache bool) (*model.Channel, error) {
return s.getByName(teamId, name, false, allowFromCache)
}
func (s SqlChannelStore) getByName(teamId string, name string, includeDeleted bool, allowFromCache bool) (*model.Channel, error) {
query := s.getQueryBuilder().
Select(channelSliceColumns(true)...).
From("Channels").
Where(sq.Eq{"Name": name}).
Where(sq.Or{
sq.Eq{"TeamId": teamId},
sq.Eq{"TeamId": ""},
})
if !includeDeleted {
query = query.Where(sq.Eq{"DeleteAt": 0})
}
queryStr, args, err := query.ToSql()
if err != nil {
return nil, errors.Wrapf(err, "getByName_tosql")
}
channel := model.Channel{}
if err := s.GetReplica().Get(&channel, queryStr, args...); err != nil {
if err == sql.ErrNoRows {
return nil, store.NewErrNotFound("Channel", fmt.Sprintf("TeamId=%s&Name=%s", teamId, name))
}
return nil, errors.Wrapf(err, "failed to find channel with TeamId=%s and Name=%s", teamId, name)
}
return &channel, nil
}
func (s SqlChannelStore) GetDeletedByName(teamId string, name string) (*model.Channel, error) {
channel := model.Channel{}
query := s.tableSelectQuery.Where(
sq.And{
sq.Or{sq.Eq{"TeamId": teamId}, sq.Eq{"TeamId": ""}},
sq.Eq{"Name": name},
sq.NotEq{"DeleteAt": 0},
})
if err := s.GetReplica().GetBuilder(&channel, query); err != nil {
if err == sql.ErrNoRows {
return nil, store.NewErrNotFound("Channel", fmt.Sprintf("name=%s", name))
}
return nil, errors.Wrapf(err, "failed to get channel by teamId=%s and name=%s", teamId, name)
}
return &channel, nil
}
func (s SqlChannelStore) GetDeleted(teamId string, offset int, limit int, userId string, skipTeamMembershipCheck bool) (model.ChannelList, error) {
channels := model.ChannelList{}
builder := s.getQueryBuilder().
Select(channelSliceColumns(true)...).
From("Channels").
Where(sq.Or{
sq.Eq{"TeamId": teamId},
sq.Eq{"TeamId": ""},
}).
Where(sq.NotEq{"DeleteAt": 0}).
OrderBy("DisplayName").
Limit(uint64(limit)).
Offset(uint64(offset))
if !skipTeamMembershipCheck {
builder = builder.Where(sq.Or{
sq.Eq{"Type": model.ChannelTypeOpen},
sq.And{
sq.Eq{"Type": model.ChannelTypePrivate},
sq.Expr("Id IN (?)", sq.Select("ChannelId").From("ChannelMembers").Where(sq.Eq{"UserId": userId})),
},
})
}
query, args, err := builder.ToSql()
if err != nil {
return nil, errors.Wrapf(err, "GetDeleted_ToSql")
}
if err := s.GetReplica().Select(&channels, query, args...); err != nil {
if err == sql.ErrNoRows {
return nil, store.NewErrNotFound("Channel", fmt.Sprintf("TeamId=%s,UserId=%s", teamId, userId))
}
return nil, errors.Wrapf(err, "failed to get deleted channels with TeamId=%s and UserId=%s", teamId, userId)
}
return channels, nil
}
var channelMembersWithSchemeSelectQuery = `
SELECT
ChannelMembers.ChannelId,
ChannelMembers.UserId,
ChannelMembers.Roles,
ChannelMembers.LastViewedAt,
ChannelMembers.MsgCount,
ChannelMembers.MentionCount,
ChannelMembers.MentionCountRoot,
COALESCE(ChannelMembers.UrgentMentionCount, 0) AS UrgentMentionCount,
ChannelMembers.MsgCountRoot,
ChannelMembers.NotifyProps,
ChannelMembers.LastUpdateAt,
ChannelMembers.SchemeUser,
ChannelMembers.SchemeAdmin,
ChannelMembers.SchemeGuest,
COALESCE(Teams.DisplayName, '') TeamDisplayName,
COALESCE(Teams.Name, '') TeamName,
COALESCE(Teams.UpdateAt, 0) TeamUpdateAt,
TeamScheme.DefaultChannelGuestRole TeamSchemeDefaultGuestRole,
TeamScheme.DefaultChannelUserRole TeamSchemeDefaultUserRole,
TeamScheme.DefaultChannelAdminRole TeamSchemeDefaultAdminRole,
ChannelScheme.DefaultChannelGuestRole ChannelSchemeDefaultGuestRole,
ChannelScheme.DefaultChannelUserRole ChannelSchemeDefaultUserRole,
ChannelScheme.DefaultChannelAdminRole ChannelSchemeDefaultAdminRole
FROM
ChannelMembers
INNER JOIN
Channels ON ChannelMembers.ChannelId = Channels.Id
LEFT JOIN
Schemes ChannelScheme ON Channels.SchemeId = ChannelScheme.Id
LEFT JOIN
Teams ON Channels.TeamId = Teams.Id
LEFT JOIN
Schemes TeamScheme ON Teams.SchemeId = TeamScheme.Id
`
func (s SqlChannelStore) SaveMultipleMembers(members []*model.ChannelMember) ([]*model.ChannelMember, error) {
for _, member := range members {
defer s.InvalidateAllChannelMembersForUser(member.UserId)
}
newMembers, err := s.saveMultipleMembers(members)
if err != nil {
return nil, err
}
return newMembers, nil
}
func (s SqlChannelStore) SaveMember(rctx request.CTX, member *model.ChannelMember) (*model.ChannelMember, error) {
newMembers, err := s.SaveMultipleMembers([]*model.ChannelMember{member})
if err != nil {
return nil, err
}
return newMembers[0], nil
}
func (s SqlChannelStore) saveMultipleMembers(members []*model.ChannelMember) ([]*model.ChannelMember, error) {
newChannelMembers := map[string]int{}
users := map[string]bool{}
for _, member := range members {
if val, ok := newChannelMembers[member.ChannelId]; val < 1 || !ok {
newChannelMembers[member.ChannelId] = 1
} else {
newChannelMembers[member.ChannelId]++
}
users[member.UserId] = true
member.PreSave()
if err := member.IsValid(); err != nil { // TODO: this needs to return plain error in v6.
return nil, err
}
}
channels := []string{}
for channel := range newChannelMembers {
channels = append(channels, channel)
}
defaultChannelRolesByChannel := map[string]struct {
Id string
Guest sql.NullString
User sql.NullString
Admin sql.NullString
}{}
channelRolesQuery := s.getQueryBuilder().
Select(
"Channels.Id as Id",
"ChannelScheme.DefaultChannelGuestRole as Guest",
"ChannelScheme.DefaultChannelUserRole as User",
"ChannelScheme.DefaultChannelAdminRole as Admin",
).
From("Channels").
LeftJoin("Schemes ChannelScheme ON Channels.SchemeId = ChannelScheme.Id").
Where(sq.Eq{"Channels.Id": channels})
channelRolesSql, channelRolesArgs, err := channelRolesQuery.ToSql()
if err != nil {
return nil, errors.Wrap(err, "channel_roles_tosql")
}
defaultChannelsRoles := []struct {
Id string
Guest sql.NullString
User sql.NullString
Admin sql.NullString
}{}
err = s.GetMaster().Select(&defaultChannelsRoles, channelRolesSql, channelRolesArgs...)
if err != nil {
return nil, errors.Wrap(err, "default_channel_roles_select")
}
for _, defaultRoles := range defaultChannelsRoles {
defaultChannelRolesByChannel[defaultRoles.Id] = defaultRoles
}
defaultTeamRolesByChannel := map[string]struct {
Id string
Guest sql.NullString
User sql.NullString
Admin sql.NullString
}{}
teamRolesQuery := s.getQueryBuilder().
Select(
"Channels.Id as Id",
"TeamScheme.DefaultChannelGuestRole as Guest",
"TeamScheme.DefaultChannelUserRole as User",
"TeamScheme.DefaultChannelAdminRole as Admin",
).
From("Channels").
LeftJoin("Teams ON Teams.Id = Channels.TeamId").
LeftJoin("Schemes TeamScheme ON Teams.SchemeId = TeamScheme.Id").
Where(sq.Eq{"Channels.Id": channels})
teamRolesSql, teamRolesArgs, err := teamRolesQuery.ToSql()
if err != nil {
return nil, errors.Wrap(err, "team_roles_tosql")
}
defaultTeamsRoles := []struct {
Id string
Guest sql.NullString
User sql.NullString
Admin sql.NullString
}{}
err = s.GetMaster().Select(&defaultTeamsRoles, teamRolesSql, teamRolesArgs...)
if err != nil {
return nil, errors.Wrap(err, "default_team_roles_select")
}
for _, defaultRoles := range defaultTeamsRoles {
defaultTeamRolesByChannel[defaultRoles.Id] = defaultRoles
}
query := s.getQueryBuilder().Insert("ChannelMembers").Columns(channelMemberSliceColumns()...)
for _, member := range members {
query = query.Values(channelMemberToSlice(member)...)
}
sql, args, err := query.ToSql()
if err != nil {
return nil, errors.Wrap(err, "channel_members_tosql")
}
if _, err := s.GetMaster().Exec(sql, args...); err != nil {
if IsUniqueConstraintError(err, []string{"ChannelId", "channelmembers_pkey", "PRIMARY"}) {
return nil, store.NewErrConflict("ChannelMembers", err, "")
}
return nil, errors.Wrap(err, "channel_members_save")
}
newMembers := []*model.ChannelMember{}
for _, member := range members {
defaultTeamGuestRole := defaultTeamRolesByChannel[member.ChannelId].Guest.String
defaultTeamUserRole := defaultTeamRolesByChannel[member.ChannelId].User.String
defaultTeamAdminRole := defaultTeamRolesByChannel[member.ChannelId].Admin.String
defaultChannelGuestRole := defaultChannelRolesByChannel[member.ChannelId].Guest.String
defaultChannelUserRole := defaultChannelRolesByChannel[member.ChannelId].User.String
defaultChannelAdminRole := defaultChannelRolesByChannel[member.ChannelId].Admin.String
rolesResult := getChannelRoles(
member.SchemeGuest, member.SchemeUser, member.SchemeAdmin,
defaultTeamGuestRole, defaultTeamUserRole, defaultTeamAdminRole,
defaultChannelGuestRole, defaultChannelUserRole, defaultChannelAdminRole,
strings.Fields(member.ExplicitRoles),
)
newMember := *member
newMember.SchemeGuest = rolesResult.schemeGuest
newMember.SchemeUser = rolesResult.schemeUser
newMember.SchemeAdmin = rolesResult.schemeAdmin
newMember.Roles = strings.Join(rolesResult.roles, " ")
newMember.ExplicitRoles = strings.Join(rolesResult.explicitRoles, " ")
newMembers = append(newMembers, &newMember)
}
return newMembers, nil
}
func (s SqlChannelStore) saveMemberT(member *model.ChannelMember) (*model.ChannelMember, error) {
members, err := s.saveMultipleMembers([]*model.ChannelMember{member})
if err != nil {
return nil, err
}
return members[0], nil
}
func (s SqlChannelStore) UpdateMultipleMembers(members []*model.ChannelMember) (_ []*model.ChannelMember, err error) {
for _, member := range members {
member.PreUpdate()
if err := member.IsValid(); err != nil {
return nil, err
}
}
var transaction *sqlxTxWrapper
if transaction, err = s.GetMaster().Beginx(); err != nil {
return nil, errors.Wrap(err, "begin_transaction")
}
defer finalizeTransactionX(transaction, &err)
updatedMembers := []*model.ChannelMember{}
for _, member := range members {
update := s.getQueryBuilder().
Update("ChannelMembers").
SetMap(NewMapFromChannelMemberModel(member)).
Where(sq.Eq{
"ChannelId": member.ChannelId,
"UserId": member.UserId,
})
sqlUpdate, args, err := update.ToSql()
if err != nil {
return nil, errors.Wrapf(err, "UpdateMultipleMembers_Update_ToSql ChannelID=%s UserID=%s", member.ChannelId, member.UserId)
}
if _, err = transaction.Exec(sqlUpdate, args...); err != nil {
return nil, errors.Wrap(err, "failed to update ChannelMember")
}
sqlSelect, args, err := s.channelMembersForTeamWithSchemeSelectQuery.
Where(sq.Eq{
"ChannelMembers.ChannelId": member.ChannelId,
"ChannelMembers.UserId": member.UserId,
}).ToSql()
if err != nil {
return nil, errors.Wrapf(err, "UpdateMultipleMembers_Select_ToSql ChannelID=%s UserID=%s", member.ChannelId, member.UserId)
}
// TODO: Get this out of the transaction when is possible
var dbMember channelMemberWithSchemeRoles
if err := transaction.Get(&dbMember, sqlSelect, args...); err != nil {
if err == sql.ErrNoRows {
return nil, store.NewErrNotFound("ChannelMember", fmt.Sprintf("channelId=%s, userId=%s", member.ChannelId, member.UserId))
}
return nil, errors.Wrapf(err, "failed to get ChannelMember with channelId=%s and userId=%s", member.ChannelId, member.UserId)
}
updatedMembers = append(updatedMembers, dbMember.ToModel())
}
if err := transaction.Commit(); err != nil {
return nil, errors.Wrap(err, "commit_transaction")
}
return updatedMembers, nil
}
func (s SqlChannelStore) UpdateMember(rctx request.CTX, member *model.ChannelMember) (*model.ChannelMember, error) {
updatedMembers, err := s.UpdateMultipleMembers([]*model.ChannelMember{member})
if err != nil {
return nil, err
}
return updatedMembers[0], nil
}
func (s SqlChannelStore) UpdateMemberNotifyProps(channelID, userID string, props map[string]string) (_ *model.ChannelMember, err error) {
tx, err := s.GetMaster().Beginx()
if err != nil {
return nil, errors.Wrap(err, "begin_transaction")
}
defer finalizeTransactionX(tx, &err)
jsonNotifyProps := model.MapToJSON(props)
if utf8.RuneCountInString(jsonNotifyProps) > model.ChannelMemberNotifyPropsMaxRunes {
return nil, store.NewErrInvalidInput("ChannelMember", "NotifyProps", props)
}
sqlStr, args, err2 := s.getQueryBuilder().
Update("channelmembers").
Set("notifyprops", sq.Expr("notifyprops || ?::jsonb", jsonNotifyProps)).
Set("LastUpdateAt", model.GetMillis()).
Where(sq.Eq{
"userid": userID,
"channelid": channelID,
}).ToSql()
if err2 != nil {
return nil, errors.Wrapf(err2, "UpdateMemberNotifyProps_Update_Postgres_ToSql channelID=%s and userID=%s", channelID, userID)
}
_, err = tx.Exec(sqlStr, args...)
if err != nil {
return nil, errors.Wrapf(err, "failed to update ChannelMember with channelID=%s and userID=%s", channelID, userID)
}
selectSQL, args, err := s.channelMembersForTeamWithSchemeSelectQuery.
Where(sq.Eq{
"ChannelMembers.ChannelId": channelID,
"ChannelMembers.UserId": userID,
}).ToSql()
if err != nil {
return nil, errors.Wrapf(err, "UpdateMemberNotifyProps_Select_ToSql channelID=%s and userID=%s", channelID, userID)
}
var dbMember channelMemberWithSchemeRoles
if err2 := tx.Get(&dbMember, selectSQL, args...); err2 != nil {
if err2 == sql.ErrNoRows {
return nil, store.NewErrNotFound("ChannelMember", fmt.Sprintf("channelId=%s, userId=%s", channelID, userID))
}
return nil, errors.Wrapf(err2, "failed to get ChannelMember with channelId=%s and userId=%s", channelID, userID)
}
if err2 := tx.Commit(); err2 != nil {
return nil, errors.Wrap(err2, "commit_transaction")
}
return dbMember.ToModel(), err
}
// PatchMultipleMembersNotifyProps updates the NotifyProps of multiple channel members at once without modifying
// unspecified fields.
//
// Note that the returned array may not be in the same order as the provided IDs.
func (s SqlChannelStore) PatchMultipleMembersNotifyProps(members []*model.ChannelMemberIdentifier, notifyProps map[string]string) ([]*model.ChannelMember, error) {
if len(notifyProps) == 0 {
return nil, errors.New("PatchMultipleMembersNotifyProps: No notifyProps specified")
}
if err := model.IsChannelMemberNotifyPropsValid(notifyProps, true); err != nil {
return nil, err
}
// Make the where clause first since it'll be used multiple times
whereClause := sq.Or{}
for _, member := range members {
whereClause = append(whereClause, sq.And{
sq.Eq{"ChannelId": member.ChannelId},
sq.Eq{"UserId": member.UserId},
})
}
// Update the channel members
builder := s.getQueryBuilder().Update("ChannelMembers")
jsonNotifyProps := string(model.ToJSON(notifyProps))
builder = builder.
Set("notifyprops", sq.Expr("notifyprops || ?::jsonb", jsonNotifyProps)).
Set("LastUpdateAt", model.GetMillis()).
Where(whereClause)
transaction, err := s.GetMaster().Beginx()
if err != nil {
return nil, errors.Wrap(err, "begin_transaction")
}
defer finalizeTransactionX(transaction, &err)
result, err := transaction.ExecBuilder(builder)
if err != nil {
return nil, errors.Wrap(err, "PatchMultipleMembersNotifyProps: Failed to update ChannelMembers")
} else if count, _ := result.RowsAffected(); count != int64(len(members)) {
return nil, errors.Wrap(err, "PatchMultipleMembersNotifyProps: Unable to update all ChannelMembers, some must not exist")
}
// Get the updated channel members
selectSQL, selectArgs, err := s.channelMembersForTeamWithSchemeSelectQuery.
Where(whereClause).ToSql()
if err != nil {
return nil, errors.Wrapf(err, "PatchMultipleMembersNotifyProps_Select_ToSql")
}
var dbMembers []*channelMemberWithSchemeRoles
if err := transaction.Select(&dbMembers, selectSQL, selectArgs...); err != nil {
return nil, errors.Wrapf(err, "PatchMultipleMembersNotifyProps: Failed to get updated ChannelMembers")
}
if err := transaction.Commit(); err != nil {
return nil, errors.Wrap(err, "commit_transaction")
}
updated := make([]*model.ChannelMember, len(dbMembers))
for i, dbMember := range dbMembers {
updated[i] = dbMember.ToModel()
}
return updated, nil
}
func (s SqlChannelStore) GetMembers(opts model.ChannelMembersGetOptions) (model.ChannelMembers, error) {
query := s.channelMembersForTeamWithSchemeSelectQuery.
Where(sq.Eq{
"ChannelId": opts.ChannelID,
})
if opts.UpdatedAfter > 0 {
query = query.Where(sq.Gt{"ChannelMembers.LastUpdateAt": opts.UpdatedAfter})
query = query.OrderBy("ChannelMembers.LastUpdateAt")
}
if opts.Limit > 0 {
query = query.Limit(uint64(opts.Limit))
}
if opts.Offset > 0 {
query = query.Offset(uint64(opts.Offset))
}
sql, args, err := query.ToSql()
if err != nil {
return nil, errors.Wrapf(err, "GetMember_ToSql ChannelID=%s", opts.ChannelID)
}
dbMembers := channelMemberWithSchemeRolesList{}
err = s.GetReplica().Select(&dbMembers, sql, args...)
if err != nil {
return nil, errors.Wrapf(err, "failed to get ChannelMembers with channelId=%s", opts.ChannelID)
}
return dbMembers.ToModel(), nil
}
func (s SqlChannelStore) GetChannelMembersTimezones(channelId string) ([]model.StringMap, error) {
dbMembersTimezone := []model.StringMap{}
err := s.GetReplica().Select(&dbMembersTimezone, `
SELECT
Users.Timezone
FROM
ChannelMembers
LEFT JOIN
Users ON ChannelMembers.UserId = Id
WHERE ChannelId = ?
`, channelId)
if err != nil {
return nil, errors.Wrapf(err, "failed to find user timezones for users in channels with channelId=%s", channelId)
}
return dbMembersTimezone, nil
}
func (s SqlChannelStore) GetChannelsWithUnreadsAndWithMentions(_ request.CTX, channelIDs []string, userID string, userNotifyProps model.StringMap) ([]string, []string, map[string]int64, error) {
query := s.getQueryBuilder().Select(
"Channels.Id",
"Channels.Type",
"Channels.TotalMsgCount",
"Channels.LastPostAt",
"ChannelMembers.MsgCount",
"ChannelMembers.MentionCount",
"ChannelMembers.NotifyProps",
"ChannelMembers.LastViewedAt",
).
From("ChannelMembers").
InnerJoin("Channels ON ChannelMembers.ChannelId = Channels.Id").
Where(sq.Eq{
"ChannelMembers.ChannelId": channelIDs,
"ChannelMembers.UserId": userID,
})
queryString, args, err := query.ToSql()
if err != nil {
return nil, nil, nil, errors.Wrap(err, "channel_tosql")
}
var channels []struct {
Id string
Type string
TotalMsgCount int
LastPostAt int64
MsgCount int
MentionCount int
NotifyProps model.StringMap
LastViewedAt int64
}
err = s.GetReplica().Select(&channels, queryString, args...)
if err != nil {
return nil, nil, nil, errors.Wrap(err, "failed to find channels with unreads and with mentions data")
}
channelsWithUnreads := []string{}
channelsWithMentions := []string{}
readTimes := map[string]int64{}
for i := range channels {
channel := channels[i]
hasMentions := (channel.MentionCount > 0)
hasUnreads := (channel.TotalMsgCount-channel.MsgCount > 0) || hasMentions
if hasUnreads {
channelsWithUnreads = append(channelsWithUnreads, channel.Id)
}
notify := channel.NotifyProps[model.PushNotifyProp]
if notify == model.ChannelNotifyDefault {
notify = userNotifyProps[model.PushNotifyProp]
}
if notify == model.UserNotifyAll || channel.Type == string(model.ChannelTypeDirect) {
if hasUnreads {
channelsWithMentions = append(channelsWithMentions, channel.Id)
}
} else if notify == model.UserNotifyMention {
if hasMentions {
channelsWithMentions = append(channelsWithMentions, channel.Id)
}
}
readTimes[channel.Id] = max(channel.LastPostAt, channel.LastViewedAt)
}
return channelsWithUnreads, channelsWithMentions, readTimes, nil
}
func (s SqlChannelStore) GetMember(rctx request.CTX, channelID string, userID string) (*model.ChannelMember, error) {
selectSQL, args, err := s.channelMembersForTeamWithSchemeSelectQuery.
Where(sq.Eq{
"ChannelMembers.ChannelId": channelID,
"ChannelMembers.UserId": userID,
}).ToSql()
if err != nil {
return nil, errors.Wrapf(err, "GetMember_ToSql ChannelID=%s UserID=%s", channelID, userID)
}
var dbMember channelMemberWithSchemeRoles
if err := s.DBXFromContext(rctx.Context()).Get(&dbMember, selectSQL, args...); err != nil {
if err == sql.ErrNoRows {
return nil, store.NewErrNotFound("ChannelMember", fmt.Sprintf("channelId=%s, userId=%s", channelID, userID))
}
return nil, errors.Wrapf(err, "failed to get ChannelMember with channelId=%s and userId=%s", channelID, userID)
}
return dbMember.ToModel(), nil
}
func (s SqlChannelStore) GetMemberLastViewedAt(rctx request.CTX, channelID string, userID string) (int64, error) {
var lastViewedAt int64
if err := s.DBXFromContext(rctx.Context()).Get(&lastViewedAt, `SELECT COALESCE(LastViewedAt, 0) AS LastViewedAt
FROM ChannelMembers
WHERE ChannelId=? AND UserId=?`, channelID, userID); err != nil {
if err == sql.ErrNoRows {
return 0, store.NewErrNotFound("LastViewedAt", fmt.Sprintf("channelId=%s, userId=%s", channelID, userID))
}
return 0, errors.Wrapf(err, "failed to get lastViewedAt with channelId=%s and userId=%s", channelID, userID)
}
return lastViewedAt, nil
}
func (s SqlChannelStore) InvalidateAllChannelMembersForUser(userId string) {
}
func (s SqlChannelStore) GetMemberForPost(postId string, userId string) (*model.ChannelMember, error) {
var dbMember channelMemberWithSchemeRoles
query := `
SELECT
ChannelMembers.ChannelId,
ChannelMembers.UserId,
ChannelMembers.Roles,
ChannelMembers.LastViewedAt,
ChannelMembers.MsgCount,
ChannelMembers.MentionCount,
ChannelMembers.MentionCountRoot,
COALESCE(ChannelMembers.UrgentMentionCount, 0) AS UrgentMentionCount,
ChannelMembers.MsgCountRoot,
ChannelMembers.NotifyProps,
ChannelMembers.LastUpdateAt,
ChannelMembers.SchemeUser,
ChannelMembers.SchemeAdmin,
ChannelMembers.SchemeGuest,
TeamScheme.DefaultChannelGuestRole TeamSchemeDefaultGuestRole,
TeamScheme.DefaultChannelUserRole TeamSchemeDefaultUserRole,
TeamScheme.DefaultChannelAdminRole TeamSchemeDefaultAdminRole,
ChannelScheme.DefaultChannelGuestRole ChannelSchemeDefaultGuestRole,
ChannelScheme.DefaultChannelUserRole ChannelSchemeDefaultUserRole,
ChannelScheme.DefaultChannelAdminRole ChannelSchemeDefaultAdminRole
FROM
ChannelMembers
INNER JOIN
Posts ON ChannelMembers.ChannelId = Posts.ChannelId
INNER JOIN
Channels ON ChannelMembers.ChannelId = Channels.Id
LEFT JOIN
Schemes ChannelScheme ON Channels.SchemeId = ChannelScheme.Id
LEFT JOIN
Teams ON Channels.TeamId = Teams.Id
LEFT JOIN
Schemes TeamScheme ON Teams.SchemeId = TeamScheme.Id
WHERE
ChannelMembers.UserId = ?
AND
Posts.Id = ?`
if err := s.GetReplica().Get(&dbMember, query, userId, postId); err != nil {
return nil, errors.Wrapf(err, "failed to get ChannelMember with postId=%s and userId=%s", postId, userId)
}
return dbMember.ToModel(), nil
}
func (s SqlChannelStore) GetAllChannelMembersForUser(rctx request.CTX, userId string, allowFromCache bool, includeDeleted bool) (_ map[string]string, err error) {
query := s.getQueryBuilder().
Select(`
ChannelMembers.ChannelId, ChannelMembers.Roles, ChannelMembers.SchemeGuest,
ChannelMembers.SchemeUser, ChannelMembers.SchemeAdmin,
TeamScheme.DefaultChannelGuestRole TeamSchemeDefaultGuestRole,
TeamScheme.DefaultChannelUserRole TeamSchemeDefaultUserRole,
TeamScheme.DefaultChannelAdminRole TeamSchemeDefaultAdminRole,
ChannelScheme.DefaultChannelGuestRole ChannelSchemeDefaultGuestRole,
ChannelScheme.DefaultChannelUserRole ChannelSchemeDefaultUserRole,
ChannelScheme.DefaultChannelAdminRole ChannelSchemeDefaultAdminRole
`).
From("ChannelMembers").
Join("Channels ON ChannelMembers.ChannelId = Channels.Id").
LeftJoin("Schemes ChannelScheme ON Channels.SchemeId = ChannelScheme.Id").
LeftJoin("Teams ON Channels.TeamId = Teams.Id").
LeftJoin("Schemes TeamScheme ON Teams.SchemeId = TeamScheme.Id").
Where(sq.Eq{"ChannelMembers.UserId": userId})
if !includeDeleted {
query = query.Where(sq.Eq{"Channels.DeleteAt": 0})
}
queryString, args, err := query.ToSql()
if err != nil {
return nil, errors.Wrap(err, "channel_tosql")
}
rows, err := s.SqlStore.DBXFromContext(rctx.Context()).Query(queryString, args...)
if err != nil {
return nil, errors.Wrap(err, "failed to find ChannelMembers, TeamScheme and ChannelScheme data")
}
defer deferClose(rows, &err)
scanner := func(rows *sql.Rows) (string, string, error) {
var cm allChannelMember
err = rows.Scan(
&cm.ChannelId, &cm.Roles, &cm.SchemeGuest, &cm.SchemeUser,
&cm.SchemeAdmin, &cm.TeamSchemeDefaultGuestRole, &cm.TeamSchemeDefaultUserRole,
&cm.TeamSchemeDefaultAdminRole, &cm.ChannelSchemeDefaultGuestRole,
&cm.ChannelSchemeDefaultUserRole, &cm.ChannelSchemeDefaultAdminRole,
)
k, v := cm.Process()
return k, v, errors.Wrap(err, "unable to scan columns")
}
return scanRowsIntoMap(rows, scanner, nil)
}
func (s SqlChannelStore) GetChannelsMemberCount(channelIDs []string) (_ map[string]int64, err error) {
query := s.getQueryBuilder().
Select("ChannelMembers.ChannelId,COUNT(*) AS Count").
From("ChannelMembers").
InnerJoin("Users ON ChannelMembers.UserId = Users.Id").
Where(sq.And{
sq.Eq{"ChannelMembers.ChannelId": channelIDs},
sq.Eq{"Users.DeleteAt": 0},
}).
GroupBy("ChannelMembers.ChannelId")
queryString, args, err := query.ToSql()
if err != nil {
return nil, errors.Wrap(err, "channels_member_count_tosql")
}
rows, err := s.GetReplica().Query(queryString, args...)
if err != nil {
return nil, errors.Wrap(err, "failed to fetch member counts")
}
defer rows.Close()
// Initialize default values map
defaults := make(map[string]int64, len(channelIDs))
for _, channelID := range channelIDs {
defaults[channelID] = 0
}
scanner := func(rows *sql.Rows) (string, int64, error) {
var channelID string
var count int64
err := rows.Scan(&channelID, &count)
return channelID, count, errors.Wrap(err, "failed to scan row")
}
return scanRowsIntoMap(rows, scanner, defaults)
}
func (s SqlChannelStore) InvalidateCacheForChannelMembersNotifyProps(channelId string) {
}
type allChannelMemberNotifyProps struct {
UserId string
NotifyProps model.StringMap
}
func (s SqlChannelStore) GetAllChannelMembersNotifyPropsForChannel(channelId string, allowFromCache bool) (map[string]model.StringMap, error) {
data := []allChannelMemberNotifyProps{}
err := s.GetReplica().Select(&data, `
SELECT UserId, NotifyProps
FROM ChannelMembers
WHERE ChannelId = ?`, channelId)
if err != nil {
return nil, errors.Wrapf(err, "failed to find data from ChannelMembers with channelId=%s", channelId)
}
props := make(map[string]model.StringMap)
for i := range data {
props[data[i].UserId] = data[i].NotifyProps
}
return props, nil
}
//nolint:unparam
func (s SqlChannelStore) InvalidateMemberCount(channelId string) {
}
func (s SqlChannelStore) GetMemberCountFromCache(channelId string) int64 {
count, _ := s.GetMemberCount(channelId, true)
return count
}
func (s SqlChannelStore) GetFileCount(channelId string) (int64, error) {
var count int64
err := s.GetReplica().Get(&count, `
SELECT
COUNT(*)
FROM
FileInfo
WHERE
FileInfo.DeleteAt = 0
AND FileInfo.PostId != ''
AND FileInfo.ChannelId = ?`,
channelId)
if err != nil {
return 0, errors.Wrapf(err, "failed to count files with channelId=%s", channelId)
}
return count, nil
}
//nolint:unparam
func (s SqlChannelStore) GetMemberCount(channelId string, allowFromCache bool) (int64, error) {
var count int64
err := s.GetReplica().Get(&count, `
SELECT
count(*)
FROM
ChannelMembers,
Users
WHERE
ChannelMembers.UserId = Users.Id
AND ChannelMembers.ChannelId = ?
AND Users.DeleteAt = 0`, channelId)
if err != nil {
return 0, errors.Wrapf(err, "failed to count ChannelMembers with channelId=%s", channelId)
}
return count, nil
}
// GetMemberCountsByGroup returns a slice of ChannelMemberCountByGroup for a given channel
// which contains the number of channel members for each group and optionally the number of unique timezones present for each group in the channel
func (s SqlChannelStore) GetMemberCountsByGroup(rctx request.CTX, channelID string, includeTimezones bool) ([]*model.ChannelMemberCountByGroup, error) {
selectStr := "GroupMembers.GroupId, COUNT(ChannelMembers.UserId) AS ChannelMemberCount"
if includeTimezones {
selectStr += `,
COUNT(DISTINCT
(
CASE WHEN Timezone->>'useAutomaticTimezone' = 'true' AND length(Timezone->>'automaticTimezone') > 0
THEN Timezone->>'automaticTimezone'
WHEN Timezone->>'useAutomaticTimezone' = 'false' AND length(Timezone->>'manualTimezone') > 0
THEN Timezone->>'manualTimezone'
END
)) AS ChannelMemberTimezonesCount`
}
query := s.getQueryBuilder().
Select(selectStr).
From("ChannelMembers").
Join("GroupMembers ON GroupMembers.UserId = ChannelMembers.UserId AND GroupMembers.DeleteAt = 0")
if includeTimezones {
query = query.Join("Users ON Users.Id = GroupMembers.UserId")
}
query = query.Where(sq.Eq{"ChannelMembers.ChannelId": channelID}).GroupBy("GroupMembers.GroupId")
queryString, args, err := query.ToSql()
if err != nil {
return nil, errors.Wrap(err, "channel_tosql")
}
data := []*model.ChannelMemberCountByGroup{}
if err := s.DBXFromContext(rctx.Context()).Select(&data, queryString, args...); err != nil {
return nil, errors.Wrapf(err, "failed to count ChannelMembers with channelId=%s", channelID)
}
return data, nil
}
//nolint:unparam
func (s SqlChannelStore) InvalidatePinnedPostCount(channelId string) {
}
//nolint:unparam
func (s SqlChannelStore) GetPinnedPostCount(channelId string, allowFromCache bool) (int64, error) {
var count int64
err := s.GetReplica().Get(&count, `
SELECT count(*)
FROM Posts
WHERE
IsPinned = true
AND ChannelId = ?
AND DeleteAt = 0`, channelId)
if err != nil {
return 0, errors.Wrapf(err, "failed to count pinned Posts with channelId=%s", channelId)
}
return count, nil
}
//nolint:unparam
func (s SqlChannelStore) InvalidateGuestCount(channelId string) {
}
//nolint:unparam
func (s SqlChannelStore) GetGuestCount(channelId string, allowFromCache bool) (int64, error) {
var count int64
err := s.GetReplica().Get(&count, `
SELECT
count(*)
FROM
ChannelMembers,
Users
WHERE
ChannelMembers.UserId = Users.Id
AND ChannelMembers.ChannelId = ?
AND ChannelMembers.SchemeGuest = TRUE
AND Users.DeleteAt = 0`, channelId)
if err != nil {
return 0, errors.Wrapf(err, "failed to count Guests with channelId=%s", channelId)
}
return count, nil
}
func (s SqlChannelStore) RemoveMembers(rctx request.CTX, channelId string, userIds []string) error {
builder := s.getQueryBuilder().
Delete("ChannelMembers").
Where(sq.Eq{"ChannelId": channelId}).
Where(sq.Eq{"UserId": userIds})
query, args, err := builder.ToSql()
if err != nil {
return errors.Wrap(err, "channel_tosql")
}
_, err = s.GetMaster().Exec(query, args...)
if err != nil {
return errors.Wrap(err, "failed to delete ChannelMembers")
}
// cleanup sidebarchannels table if the user is no longer a member of that channel
query, args, err = s.getQueryBuilder().
Delete("SidebarChannels").
Where(sq.And{
sq.Eq{"ChannelId": channelId},
sq.Eq{"UserId": userIds},
}).ToSql()
if err != nil {
return errors.Wrap(err, "channel_tosql")
}
_, err = s.GetMaster().Exec(query, args...)
if err != nil {
return errors.Wrap(err, "failed to delete SidebarChannels")
}
return nil
}
func (s SqlChannelStore) RemoveMember(rctx request.CTX, channelId string, userId string) error {
return s.RemoveMembers(rctx, channelId, []string{userId})
}
func (s SqlChannelStore) RemoveAllDeactivatedMembers(rctx request.CTX, channelId string) error {
query := `
DELETE
FROM
ChannelMembers
WHERE
UserId IN (
SELECT
Id
FROM
Users
WHERE
Users.DeleteAt != 0
)
AND
ChannelMembers.ChannelId = ?
`
_, err := s.GetMaster().Exec(query, channelId)
if err != nil {
return errors.Wrapf(err, "failed to delete ChannelMembers with channelId=%s", channelId)
}
return nil
}
func (s SqlChannelStore) PermanentDeleteMembersByUser(rctx request.CTX, userId string) error {
if _, err := s.GetMaster().Exec("DELETE FROM ChannelMembers WHERE UserId = ?", userId); err != nil {
return errors.Wrapf(err, "failed to permanent delete ChannelMembers with userId=%s", userId)
}
return nil
}
func (s SqlChannelStore) UpdateLastViewedAt(channelIds []string, userId string) (map[string]int64, error) {
lastPostAtTimes := []struct {
Id string
LastPostAt int64
TotalMsgCount int64
TotalMsgCountRoot int64
}{}
if len(channelIds) == 0 {
return map[string]int64{}, nil
}
// We use the question placeholder format for both databases, because
// we replace that with the dollar format later on.
// It's needed to support the prefix CTE query. See: https://github.com/Masterminds/squirrel/issues/285.
query := sq.StatementBuilder.PlaceholderFormat(sq.Question).
Select("Id, LastPostAt, TotalMsgCount, TotalMsgCountRoot").
From("Channels").
Where(sq.Eq{"Id": channelIds})
// TODO: use a CTE for mysql too when version 8 becomes the minimum supported version.
if s.DriverName() == model.DatabaseDriverPostgres {
with := query.Prefix("WITH c AS (").Suffix(") ,")
update := sq.StatementBuilder.PlaceholderFormat(sq.Question).
Update("ChannelMembers cm").
Set("MentionCount", 0).
Set("MentionCountRoot", 0).
Set("UrgentMentionCount", 0).
Set("MsgCount", sq.Expr("greatest(cm.MsgCount, c.TotalMsgCount)")).
Set("MsgCountRoot", sq.Expr("greatest(cm.MsgCountRoot, c.TotalMsgCountRoot)")).
Set("LastViewedAt", sq.Expr("greatest(cm.LastViewedAt, c.LastPostAt)")).
Set("LastUpdateAt", sq.Expr("greatest(cm.LastViewedAt, c.LastPostAt)")).
SuffixExpr(sq.Expr("FROM c WHERE cm.UserId = ? AND c.Id = cm.ChannelId", userId))
updateWrap := update.Prefix("updated AS (").Suffix(")")
query = with.SuffixExpr(updateWrap).Suffix("SELECT Id, LastPostAt FROM c")
}
sql, args, err := query.ToSql()
if err != nil {
return nil, errors.Wrap(err, "UpdateLastViewedAt_CTE_Tosql")
}
if s.DriverName() == model.DatabaseDriverPostgres {
sql, err = sq.Dollar.ReplacePlaceholders(sql)
if err != nil {
return nil, errors.Wrap(err, "UpdateLastViewedAt_ReplacePlaceholders")
}
}
err = s.GetMaster().Select(&lastPostAtTimes, sql, args...)
if err != nil {
return nil, errors.Wrapf(err, "failed to find ChannelMembers data with userId=%s and channelId in %v", userId, channelIds)
}
if len(lastPostAtTimes) == 0 {
return nil, store.NewErrInvalidInput("Channel", "Id", fmt.Sprintf("%v", channelIds))
}
times := map[string]int64{}
if s.DriverName() == model.DatabaseDriverPostgres {
for _, t := range lastPostAtTimes {
times[t.Id] = t.LastPostAt
}
return times, nil
}
msgCountQuery, msgCountQueryRoot, lastViewedQuery := sq.Case("ChannelId"), sq.Case("ChannelId"), sq.Case("ChannelId")
for _, t := range lastPostAtTimes {
times[t.Id] = t.LastPostAt
msgCountQuery = msgCountQuery.When(
sq.Expr("?", t.Id),
sq.Expr("GREATEST(MsgCount, ?)", t.TotalMsgCount))
msgCountQueryRoot = msgCountQueryRoot.When(
sq.Expr("?", t.Id),
sq.Expr("GREATEST(MsgCountRoot, ?)", t.TotalMsgCountRoot))
lastViewedQuery = lastViewedQuery.When(
sq.Expr("?", t.Id),
sq.Expr("GREATEST(LastViewedAt, ?)", t.LastPostAt))
}
updateQuery := s.getQueryBuilder().Update("ChannelMembers").
Set("MentionCount", 0).
Set("MentionCountRoot", 0).
Set("UrgentMentionCount", 0).
Set("MsgCount", msgCountQuery).
Set("MsgCountRoot", msgCountQueryRoot).
Set("LastViewedAt", lastViewedQuery).
Set("LastUpdateAt", sq.Expr("LastViewedAt")).
Where(sq.Eq{
"UserId": userId,
"ChannelId": channelIds,
})
sql, args, err = updateQuery.ToSql()
if err != nil {
return nil, errors.Wrap(err, "UpdateLastViewedAt_Update_Tosql")
}
if _, err := s.GetMaster().Exec(sql, args...); err != nil {
return nil, errors.Wrapf(err, "failed to update ChannelMembers with userId=%s and channelId in %v", userId, channelIds)
}
return times, nil
}
func (s SqlChannelStore) CountUrgentPostsAfter(channelId string, timestamp int64, excludedUserID string) (int, error) {
query := s.getQueryBuilder().
Select("count(*)").
From("PostsPriority").
Join("Posts ON Posts.Id = PostsPriority.PostId").
Where(sq.And{
sq.Eq{"PostsPriority.Priority": model.PostPriorityUrgent},
sq.Eq{"Posts.ChannelId": channelId},
sq.Gt{"Posts.CreateAt": timestamp},
sq.Eq{"Posts.DeleteAt": 0},
})
if excludedUserID != "" {
query = query.Where(sq.NotEq{"Posts.UserId": excludedUserID})
}
var urgent int64
err := s.GetReplica().GetBuilder(&urgent, query)
if err != nil {
return 0, errors.Wrap(err, "failed to count urgent Posts")
}
return int(urgent), nil
}
// CountPostsAfter returns the number of posts in the given channel created after but not including the given timestamp. If given a non-empty user ID, only counts posts made by any other user.
func (s SqlChannelStore) CountPostsAfter(channelId string, timestamp int64, excludedUserID string) (int, int, error) {
joinLeavePostTypes := []string{
// These types correspond to the ones checked by Post.IsJoinLeaveMessage
model.PostTypeJoinLeave,
model.PostTypeAddRemove,
model.PostTypeJoinChannel,
model.PostTypeLeaveChannel,
model.PostTypeJoinTeam,
model.PostTypeLeaveTeam,
model.PostTypeAddToChannel,
model.PostTypeRemoveFromChannel,
model.PostTypeAddToTeam,
model.PostTypeRemoveFromTeam,
}
query := s.getQueryBuilder().
Select("count(*)").
From("Posts").
Where(sq.And{
sq.Eq{"ChannelId": channelId},
sq.Gt{"CreateAt": timestamp},
sq.NotEq{"Type": joinLeavePostTypes},
sq.Eq{"DeleteAt": 0},
})
if excludedUserID != "" {
query = query.Where(sq.NotEq{"UserId": excludedUserID})
}
sql, args, err := query.ToSql()
if err != nil {
return 0, 0, errors.Wrap(err, "CountPostsAfter_ToSql1")
}
var unread int64
err = s.GetReplica().Get(&unread, sql, args...)
if err != nil {
return 0, 0, errors.Wrap(err, "failed to count Posts")
}
sql2, args2, err := query.Where(sq.Eq{"RootId": ""}).ToSql()
if err != nil {
return 0, 0, errors.Wrap(err, "CountPostsAfter_ToSql2")
}
var unreadRoot int64
err = s.GetReplica().Get(&unreadRoot, sql2, args2...)
if err != nil {
return 0, 0, errors.Wrap(err, "failed to count root Posts")
}
return int(unread), int(unreadRoot), nil
}
// UpdateLastViewedAtPost updates a ChannelMember as if the user last read the channel at the time of the given post.
// If the provided mentionCount is -1, the given post and all posts after it are considered to be mentions. Returns
// an updated model.ChannelUnreadAt that can be returned to the client.
func (s SqlChannelStore) UpdateLastViewedAtPost(unreadPost *model.Post, userID string, mentionCount, mentionCountRoot, urgentMentionCount int, setUnreadCountRoot bool) (*model.ChannelUnreadAt, error) {
unreadDate := unreadPost.CreateAt - 1
unread, unreadRoot, err := s.CountPostsAfter(unreadPost.ChannelId, unreadDate, "")
if err != nil {
return nil, err
}
if !setUnreadCountRoot {
unreadRoot = 0
}
params := map[string]any{
"mentions": mentionCount,
"mentionsroot": mentionCountRoot,
"urgentmentions": urgentMentionCount,
"unreadcount": unread,
"unreadcountroot": unreadRoot,
"lastviewedat": unreadDate,
"userid": userID,
"channelid": unreadPost.ChannelId,
"updatedat": model.GetMillis(),
}
// msg count uses the value from channels to prevent counting on older channels where no. of messages can be high.
// we only count the unread which will be a lot less in 99% cases
setUnreadQuery := `
UPDATE
ChannelMembers
SET
MentionCount = :mentions,
MentionCountRoot = :mentionsroot,
UrgentMentionCount = :urgentmentions,
MsgCount = (SELECT TotalMsgCount FROM Channels WHERE ID = :channelid) - :unreadcount,
MsgCountRoot = (SELECT TotalMsgCountRoot FROM Channels WHERE ID = :channelid) - :unreadcountroot,
LastViewedAt = :lastviewedat,
LastUpdateAt = :updatedat
WHERE
UserId = :userid
AND ChannelId = :channelid
`
_, err = s.GetMaster().NamedExec(setUnreadQuery, params)
if err != nil {
return nil, errors.Wrap(err, "failed to update ChannelMembers")
}
chanUnreadQuery := `
SELECT
c.TeamId TeamId,
cm.UserId UserId,
cm.ChannelId ChannelId,
cm.MsgCount MsgCount,
cm.MsgCountRoot MsgCountRoot,
cm.MentionCount MentionCount,
cm.MentionCountRoot MentionCountRoot,
COALESCE(cm.UrgentMentionCount, 0) UrgentMentionCount,
cm.LastViewedAt LastViewedAt,
cm.NotifyProps NotifyProps
FROM
ChannelMembers cm
LEFT JOIN Channels c ON c.Id=cm.ChannelId
WHERE
cm.UserId = ?
AND cm.channelId = ?
AND c.DeleteAt = 0
`
result := &model.ChannelUnreadAt{}
if err = s.GetMaster().Get(result, chanUnreadQuery, userID, unreadPost.ChannelId); err != nil {
return nil, errors.Wrapf(err, "failed to get ChannelMember with channelId=%s", unreadPost.ChannelId)
}
return result, nil
}
func (s SqlChannelStore) IncrementMentionCount(channelId string, userIDs []string, isRoot bool, isUrgent bool) error {
now := model.GetMillis()
rootInc := 0
if isRoot {
rootInc = 1
}
urgentInc := 0
if isUrgent {
urgentInc = 1
}
sql, args, err := s.getQueryBuilder().
Update("ChannelMembers").
Set("MentionCount", sq.Expr("MentionCount + 1")).
Set("MentionCountRoot", sq.Expr("MentionCountRoot + ?", rootInc)).
Set("UrgentMentionCount", sq.Expr("UrgentMentionCount + ?", urgentInc)).
Set("LastUpdateAt", now).
Where(sq.Eq{
"UserId": userIDs,
"ChannelId": channelId,
}).
ToSql()
if err != nil {
return errors.Wrap(err, "IncrementMentionCount_Tosql")
}
_, err = s.GetMaster().Exec(sql, args...)
if err != nil {
return errors.Wrapf(err, "failed to Update ChannelMembers with channelId=%s and userId=%v", channelId, userIDs)
}
return nil
}
func (s SqlChannelStore) GetAll(teamId string) ([]*model.Channel, error) {
data := []*model.Channel{}
query := s.tableSelectQuery.Where(sq.And{sq.Eq{"TeamId": teamId}, sq.NotEq{"Type": model.ChannelTypeDirect}}).OrderBy("Name")
if err := s.GetReplica().SelectBuilder(&data, query); err != nil {
return nil, errors.Wrapf(err, "failed to find Channels with teamId=%s", teamId)
}
return data, nil
}
func (s SqlChannelStore) GetChannelsByIds(channelIds []string, includeDeleted bool) ([]*model.Channel, error) {
query := s.getQueryBuilder().
Select(channelSliceColumns(true)...).
From("Channels").
Where(sq.Eq{"Id": channelIds}).
OrderBy("Name")
if !includeDeleted {
query = query.Where(sq.Eq{"DeleteAt": 0})
}
sql, args, err := query.ToSql()
if err != nil {
return nil, errors.Wrap(err, "GetChannelsByIds_tosql")
}
channels := []*model.Channel{}
err = s.GetReplica().Select(&channels, sql, args...)
if err != nil {
return nil, errors.Wrap(err, "failed to find Channels")
}
return channels, nil
}
func (s SqlChannelStore) GetChannelsWithTeamDataByIds(channelIDs []string, includeDeleted bool) ([]*model.ChannelWithTeamData, error) {
query := s.getQueryBuilder().
Select(channelSliceColumns(true, "c")...).
Columns(
"COALESCE(t.DisplayName, '') As TeamDisplayName",
"COALESCE(t.Name, '') AS TeamName",
"COALESCE(t.UpdateAt, 0) AS TeamUpdateAt",
).
From("Channels c").
LeftJoin("Teams t ON c.TeamId = t.Id").
Where(sq.Eq{"c.Id": channelIDs}).
OrderBy("c.Name")
if !includeDeleted {
query = query.Where(sq.Eq{"c.DeleteAt": 0})
}
sql, args, err := query.ToSql()
if err != nil {
return nil, errors.Wrapf(err, "getChannelsWithTeamData_tosql")
}
channels := []*model.ChannelWithTeamData{}
err = s.GetReplica().Select(&channels, sql, args...)
if err != nil {
return nil, errors.Wrap(err, "failed to find Channels")
}
return channels, nil
}
func (s SqlChannelStore) GetForPost(postId string) (*model.Channel, error) {
query := s.getQueryBuilder().
Select(channelSliceColumns(true, "Channels")...).
From("Channels").
Join("Posts ON Channels.Id = Posts.ChannelId").
Where(sq.Eq{
"Posts.Id": postId,
})
queryString, argss, err := query.ToSql()
if err != nil {
return nil, errors.Wrap(err, "GetForPost: failed to convert query to string")
}
channel := model.Channel{}
err = s.GetReplica().Get(&channel, queryString, argss...)
if err != nil {
return nil, errors.Wrapf(err, "failed to get Channel with postId=%s", postId)
}
return &channel, nil
}
func (s SqlChannelStore) AnalyticsTypeCount(teamId string, channelType model.ChannelType) (int64, error) {
query := s.getQueryBuilder().
Select("COUNT(*) AS Value").
From("Channels")
if channelType != "" {
query = query.Where(sq.Eq{"Type": channelType})
}
if teamId != "" {
query = query.Where(sq.Eq{"TeamId": teamId})
}
sql, args, err := query.ToSql()
if err != nil {
return 0, errors.Wrap(err, "AnalyticsTypeCount_ToSql")
}
var value int64
err = s.GetReplica().Get(&value, sql, args...)
if err != nil {
return 0, errors.Wrap(err, "failed to count Channels")
}
return value, nil
}
func (s SqlChannelStore) AnalyticsDeletedTypeCount(teamId string, channelType model.ChannelType) (int64, error) {
query := s.getQueryBuilder().
Select("COUNT(Id) AS Value").
From("Channels").
Where(sq.And{
sq.Eq{"Type": channelType},
sq.Gt{"DeleteAt": 0},
})
if teamId != "" {
query = query.Where(sq.Eq{"TeamId": teamId})
}
sql, args, err := query.ToSql()
if err != nil {
return 0, errors.Wrap(err, "AnalyticsDeletedTypeCount_ToSql")
}
var v int64
err = s.GetReplica().Get(&v, sql, args...)
if err != nil {
return 0, errors.Wrapf(err, "failed to count Channels with teamId=%s and channelType=%s", teamId, channelType)
}
return v, nil
}
func (s SqlChannelStore) AnalyticsCountAll(teamId string) (map[model.ChannelType]int64, error) {
query := s.getQueryBuilder().
Select("Type, COUNT(*) AS Count").
From("Channels").
GroupBy("Type")
if teamId != "" {
query = query.Where(sq.Eq{"TeamId": teamId})
}
sqlStr, args, err := query.ToSql()
if err != nil {
return nil, errors.Wrap(err, "AnalyticsCountAll_ToSql")
}
rows, err := s.GetReplica().Query(sqlStr, args...)
if err != nil {
return nil, errors.Wrap(err, "failed to count Channels by type")
}
defer rows.Close()
scanner := func(rows *sql.Rows) (model.ChannelType, int64, error) {
var channelType model.ChannelType
var count int64
err := rows.Scan(&channelType, &count)
return channelType, count, errors.Wrap(err, "unable to scan row")
}
return scanRowsIntoMap(rows, scanner, nil)
}
func (s SqlChannelStore) GetMembersForUser(teamID string, userID string) (model.ChannelMembers, error) {
sql, args, err := s.channelMembersForTeamWithSchemeSelectQuery.
Where(sq.And{
sq.Eq{"ChannelMembers.UserId": userID},
sq.Or{
sq.Eq{"Teams.Id": teamID},
sq.Eq{"Teams.Id": ""},
sq.Eq{"Teams.Id": nil},
},
}).ToSql()
if err != nil {
return nil, errors.Wrapf(err, "GetMembersForUser_ToSql teamID=%s userID=%s", teamID, userID)
}
dbMembers := channelMemberWithSchemeRolesList{}
err = s.GetReplica().Select(&dbMembers, sql, args...)
if err != nil {
return nil, errors.Wrapf(err, "failed to find ChannelMembers data with teamId=%s and userId=%s", teamID, userID)
}
return dbMembers.ToModel(), nil
}
func (s SqlChannelStore) GetMembersForUserWithPagination(userId string, page, perPage int) (model.ChannelMembersWithTeamData, error) {
dbMembers := channelMemberWithTeamWithSchemeRolesList{}
offset := page * perPage
err := s.GetReplica().Select(&dbMembers, channelMembersWithSchemeSelectQuery+"WHERE ChannelMembers.UserId = ? ORDER BY ChannelId ASC Limit ? Offset ?", userId, perPage, offset)
if err != nil {
return nil, errors.Wrapf(err, "failed to find ChannelMembers data with and userId=%s", userId)
}
return dbMembers.ToModel(), nil
}
func (s SqlChannelStore) GetMembersForUserWithCursorPagination(userId string, perPage int, fromChannelID string) (model.ChannelMembersWithTeamData, error) {
dbMembers := channelMemberWithTeamWithSchemeRolesList{}
err := s.GetReplica().Select(&dbMembers, channelMembersWithSchemeSelectQuery+"WHERE ChannelMembers.UserId = ? AND ChannelId > ? ORDER BY ChannelId ASC Limit ?", userId, fromChannelID, perPage)
if err != nil {
return nil, errors.Wrapf(err, "failed to find ChannelMembers data with and userId=%s", userId)
}
if len(dbMembers) == 0 {
return nil, store.NewErrNotFound("ChannelMembers", "userId="+userId)
}
return dbMembers.ToModel(), nil
}
func (s SqlChannelStore) GetTeamMembersForChannel(rctx request.CTX, channelID string) ([]string, error) {
teamMemberIDs := []string{}
if err := s.DBXFromContext(rctx.Context()).Select(&teamMemberIDs, `SELECT tm.UserId
FROM Channels c, Teams t, TeamMembers tm
WHERE
c.TeamId=t.Id
AND
t.Id=tm.TeamId
AND
c.Id = ?`,
channelID); err != nil {
return nil, errors.Wrapf(err, "error while getting team members for a channel")
}
return teamMemberIDs, nil
}
func (s SqlChannelStore) Autocomplete(rctx request.CTX, userID, term string, includeDeleted, isGuest bool) (model.ChannelListWithTeamData, error) {
query := s.getQueryBuilder().
Select(channelSliceColumns(true, "c")...).
Columns(
"t.DisplayName AS TeamDisplayName",
"t.Name AS TeamName",
"t.UpdateAt AS TeamUpdateAt",
).
From("Channels c, Teams t, TeamMembers tm").
Where(sq.And{
sq.Expr("c.TeamId = t.id"),
sq.Expr("t.id = tm.TeamId"),
sq.Eq{"tm.UserId": userID},
}).
OrderBy("c.DisplayName").
Limit(model.ChannelSearchDefaultLimit)
if !includeDeleted {
query = query.Where(sq.And{
sq.Eq{"c.DeleteAt": 0},
sq.Eq{"tm.DeleteAt": 0},
})
}
if isGuest {
query = query.Where(sq.Expr("c.Id IN (?)", sq.Select("ChannelId").
From("ChannelMembers").
Where(sq.Eq{"UserId": userID})))
} else {
query = query.Where(sq.Or{
sq.NotEq{"c.Type": model.ChannelTypePrivate},
sq.And{
sq.Eq{"c.Type": model.ChannelTypePrivate},
sq.Expr("c.Id IN (?)", sq.Select("ChannelId").
From("ChannelMembers").
Where(sq.Eq{"UserId": userID})),
},
})
}
searchClause := s.searchClause(term)
if searchClause != nil {
query = query.Where(searchClause)
}
sql, args, err := query.ToSql()
if err != nil {
return nil, errors.Wrap(err, "Autocomplete_Tosql")
}
channels := model.ChannelListWithTeamData{}
err = s.GetReplica().Select(&channels, sql, args...)
if err != nil {
return nil, errors.Wrapf(err, "could not find channel with term=%s", trimInput(term))
}
return channels, nil
}
func (s SqlChannelStore) AutocompleteInTeam(rctx request.CTX, teamID, userID, term string, includeDeleted, isGuest bool) (model.ChannelList, error) {
query := s.getQueryBuilder().Select(channelSliceColumns(true, "c")...).
From("Channels c").
Where(sq.Eq{"c.TeamId": teamID}).
OrderBy("c.DisplayName").
Limit(model.ChannelSearchDefaultLimit)
if !includeDeleted {
query = query.Where(sq.Eq{"c.DeleteAt": 0})
}
if isGuest {
query = query.Where(sq.Expr("c.Id IN (?)", sq.Select("ChannelId").
From("ChannelMembers").
Where(sq.Eq{"UserId": userID})))
} else {
query = query.Where(sq.Or{
sq.NotEq{"c.Type": model.ChannelTypePrivate},
sq.And{
sq.Eq{"c.Type": model.ChannelTypePrivate},
sq.Expr("c.Id IN (?)", sq.Select("ChannelId").
From("ChannelMembers").
Where(sq.Eq{"UserId": userID})),
},
})
}
searchClause := s.searchClause(term)
if searchClause != nil {
query = query.Where(searchClause)
}
return s.performSearch(query, term)
}
func (s SqlChannelStore) AutocompleteInTeamForSearch(teamID string, userID string, term string, includeDeleted bool) (model.ChannelList, error) {
// shared query
query := s.getSubQueryBuilder().Select(channelSliceColumns(true, "C")...).
From("Channels AS C").
Join("ChannelMembers AS CM ON CM.ChannelId = C.Id").
Limit(50).
Where(sq.And{
sq.Or{
sq.Eq{"C.TeamId": teamID},
sq.Eq{
"C.TeamId": "",
"C.Type": model.ChannelTypeGroup,
},
},
sq.Eq{"CM.UserId": userID},
})
if !includeDeleted {
// include the DeleteAt = 0 condition
query.Where(sq.Eq{"DeleteAt": 0})
}
var (
channels = model.ChannelList{}
sql string
args []any
)
// build the like clause
like := s.buildLIKEClauseX(term, "Name", "DisplayName", "Purpose")
if like == nil {
var err error
// generate the SQL query
sql, args, err = query.ToSql()
if err != nil {
return nil, errors.Wrap(err, "AutocompleteInTeamForSearch_Tosql")
}
} else {
// build the full text search clause
full := s.buildFulltextClauseX(term, "Name", "DisplayName", "Purpose")
// build the LIKE query
likeSQL, likeArgs, err := query.Where(like).ToSql()
if err != nil {
return nil, errors.Wrap(err, "AutocompleteInTeamForSearch_Like_Tosql")
}
// build the full text query
fullSQL, fullArgs, err := query.Where(full).ToSql()
if err != nil {
return nil, errors.Wrap(err, "AutocompleteInTeamForSearch_Full_Tosql")
}
// Using a UNION results in index_merge and fulltext queries and is much faster than the ref
// query you would get using an OR of the LIKE and full-text clauses.
sql = fmt.Sprintf("(%s) UNION (%s) LIMIT 50", likeSQL, fullSQL)
args = append(likeArgs, fullArgs...)
}
var err error
// since the UNION is not part of squirrel, we need to assemble it and then update
// the placeholders manually
if s.DriverName() == model.DatabaseDriverPostgres {
sql, err = sq.Dollar.ReplacePlaceholders(sql)
if err != nil {
return nil, errors.Wrap(err, "AutocompleteInTeamForSearch_Placeholder")
}
}
// query the database
err = s.GetReplica().Select(&channels, sql, args...)
if err != nil {
return nil, errors.Wrapf(err, "failed to find Channels with term='%s'", trimInput(term))
}
directChannels, err := s.autocompleteInTeamForSearchDirectMessages(userID, term)
if err != nil {
return nil, err
}
channels = append(channels, directChannels...)
sort.Slice(channels, func(a, b int) bool {
return strings.ToLower(channels[a].DisplayName) < strings.ToLower(channels[b].DisplayName)
})
return channels, nil
}
func (s SqlChannelStore) autocompleteInTeamForSearchDirectMessages(userID string, term string) ([]*model.Channel, error) {
// create the main query
query := s.getQueryBuilder().
Select(channelSliceColumns(true, "C")...).
Columns("OtherUsers.Username AS DisplayName").
From("Channels AS C").
Join("ChannelMembers AS CM ON CM.ChannelId = C.Id").
Where(sq.Eq{
"C.Type": model.ChannelTypeDirect,
"CM.UserId": userID,
}).
Limit(50)
// create the subquery
subQuery := s.getSubQueryBuilder().Select("ICM.ChannelId AS ChannelId", "IU.Username AS Username").
From("Users AS IU").
Join("ChannelMembers AS ICM ON ICM.UserId = IU.Id").
Where(sq.NotEq{"IU.Id": userID})
// try to create a LIKE clause from the search term
if like := s.buildLIKEClauseX(term, "IU.Username", "IU.Nickname"); like != nil {
subQuery = subQuery.Where(like)
}
// put the subquery into an INNER JOIN
innerJoin := subQuery.
Prefix("INNER JOIN (").
Suffix(") AS OtherUsers ON OtherUsers.ChannelId = C.Id")
// add the subquery to the main query
query = query.JoinClause(innerJoin)
// create the SQL query and argument list
sql, args, err := query.ToSql()
if err != nil {
return nil, errors.Wrap(err, "autocompleteInTeamForSearchDirectMessages_InnerJoin_Tosql")
}
// query the channel list from the database using SQLX
channels := model.ChannelList{}
if err := s.GetReplica().Select(&channels, sql, args...); err != nil {
return nil, errors.Wrapf(err, "failed to find Channels with term='%s'", trimInput(term))
}
return channels, nil
}
func (s SqlChannelStore) SearchInTeam(teamId string, term string, includeDeleted bool) (model.ChannelList, error) {
query := s.getQueryBuilder().Select(channelSliceColumns(true, "Channels")...).
From("Channels").
Join("PublicChannels c ON (c.Id = Channels.Id)").
Where(sq.Eq{"c.TeamId": teamId}).
OrderBy("c.DisplayName").
Limit(100)
if !includeDeleted {
query = query.Where(sq.Eq{"c.DeleteAt": 0})
}
if term != "" {
searchClause := s.searchClause(term)
if searchClause != nil {
query = query.Where(searchClause)
}
}
return s.performSearch(query, term)
}
func (s SqlChannelStore) SearchForUserInTeam(userId string, teamId string, term string, includeDeleted bool) (model.ChannelList, error) {
query := s.getQueryBuilder().Select(channelSliceColumns(true, "Channels")...).
From("Channels").
Join("PublicChannels c ON (c.Id = Channels.Id)").
Join("ChannelMembers cm ON (c.Id = cm.ChannelId)").
Where(sq.Eq{
"c.TeamId": teamId,
"cm.UserId": userId,
}).
OrderBy("c.DisplayName").
Limit(100)
if !includeDeleted {
query = query.Where(sq.Eq{"c.DeleteAt": 0})
}
searchClause := s.searchClause(term)
if searchClause != nil {
query = query.Where(searchClause)
}
return s.performSearch(query, term)
}
func (s SqlChannelStore) channelSearchQuery(opts *store.ChannelSearchOpts) sq.SelectBuilder {
var limit int
if opts.PerPage != nil {
limit = *opts.PerPage
} else {
limit = 100
}
var selectQuery sq.SelectBuilder
if opts.CountOnly {
selectQuery = s.getQueryBuilder().Select("count(*)")
} else {
selectQuery = s.getQueryBuilder().
Select(channelSliceColumns(true, "c")...)
if opts.IncludeTeamInfo {
selectQuery = selectQuery.Columns(
"t.DisplayName AS TeamDisplayName",
"t.Name AS TeamName",
"t.UpdateAt as TeamUpdateAt",
)
}
if opts.IncludePolicyID {
selectQuery = selectQuery.Columns("RetentionPoliciesChannels.PolicyId AS PolicyID")
}
}
query := selectQuery.
From("Channels AS c").
Join("Teams AS t ON t.Id = c.TeamId")
// don't bother ordering or limiting if we're just getting the count
if !opts.CountOnly {
query = query.
OrderBy("c.DisplayName, t.DisplayName").
Limit(uint64(limit))
}
if opts.Deleted {
query = query.Where(sq.NotEq{"c.DeleteAt": int(0)})
} else if !opts.IncludeDeleted {
query = query.Where(sq.Eq{"c.DeleteAt": int(0)})
}
if opts.IsPaginated() && !opts.CountOnly {
query = query.Offset(uint64(*opts.Page * *opts.PerPage))
}
if opts.PolicyID != "" {
query = query.
InnerJoin("RetentionPoliciesChannels ON c.Id = RetentionPoliciesChannels.ChannelId").
Where(sq.Eq{"RetentionPoliciesChannels.PolicyId": opts.PolicyID})
} else if opts.ExcludePolicyConstrained {
if s.DriverName() == model.DatabaseDriverPostgres {
query = query.
LeftJoin("RetentionPoliciesChannels ON c.Id = RetentionPoliciesChannels.ChannelId").
Where("RetentionPoliciesChannels.ChannelId IS NULL")
} else {
query = query.Where(sq.Expr(`c.Id NOT IN (SELECT ChannelId FROM RetentionPoliciesChannels)`))
}
} else if opts.IncludePolicyID {
query = query.
LeftJoin("RetentionPoliciesChannels ON c.Id = RetentionPoliciesChannels.ChannelId")
}
likeFields := "c.Name, c.DisplayName, c.Purpose"
if opts.IncludeSearchByID {
likeFields = likeFields + ", c.Id"
}
likeClause, likeTerm := s.buildLIKEClause(opts.Term, likeFields)
if likeTerm != "" {
// Keep the number of likeTerms same as the number of columns
// (c.Name, c.DisplayName, c.Purpose, c.Id?)
likeTerms := make([]any, len(strings.Split(likeFields, ",")))
for i := range likeTerms {
likeTerms[i] = likeTerm
}
likeClause = strings.ReplaceAll(likeClause, ":LikeTerm", "?")
fulltextClause, fulltextTerm := s.buildFulltextClause(opts.Term, "c.Name, c.DisplayName, c.Purpose")
fulltextClause = strings.ReplaceAll(fulltextClause, ":FulltextTerm", "?")
query = query.Where(sq.Or{
sq.Expr(likeClause, likeTerms...),
sq.Expr(fulltextClause, fulltextTerm),
})
}
if len(opts.ExcludeChannelNames) > 0 {
query = query.Where(sq.NotEq{"c.Name": opts.ExcludeChannelNames})
}
if opts.NotAssociatedToGroup != "" {
query = query.Where("c.Id NOT IN (SELECT ChannelId FROM GroupChannels WHERE GroupChannels.GroupId = ? AND GroupChannels.DeleteAt = 0)", opts.NotAssociatedToGroup)
}
if len(opts.TeamIds) > 0 {
query = query.Where(sq.Eq{"c.TeamId": opts.TeamIds})
}
if opts.GroupConstrained {
query = query.Where(sq.Eq{"c.GroupConstrained": true})
} else if opts.ExcludeGroupConstrained {
query = query.Where(sq.Or{
sq.NotEq{"c.GroupConstrained": true},
sq.Eq{"c.GroupConstrained": nil},
})
}
if opts.Public && !opts.Private {
query = query.InnerJoin("PublicChannels ON c.Id = PublicChannels.Id")
} else if opts.Private && !opts.Public {
query = query.Where(sq.Eq{"c.Type": model.ChannelTypePrivate})
} else {
query = query.Where(sq.Or{
sq.Eq{"c.Type": model.ChannelTypeOpen},
sq.Eq{"c.Type": model.ChannelTypePrivate},
})
}
if opts.ExcludeRemote {
// local channels either have a SharedChannels record with
// home set to true, or don't have a SharedChannels record at all
query = query.LeftJoin("SharedChannels ON c.Id = SharedChannels.ChannelId").
Where(sq.Or{
sq.Eq{"SharedChannels.Home": true},
sq.Eq{"SharedChannels.ChannelId": nil},
})
}
if opts.ExcludeAccessControlPolicyEnforced {
query = query.Where("c.Id NOT IN (SELECT ID From AccessControlPolicies WHERE Type = ?)", model.AccessControlPolicyTypeChannel)
} else if opts.ParentAccessControlPolicyId != "" {
if s.DriverName() == model.DatabaseDriverPostgres {
query = query.Where(sq.Expr("c.Id IN (SELECT ID From AccessControlPolicies WHERE Type = ? AND Data->'imports' @> ?)", model.AccessControlPolicyTypeChannel, fmt.Sprintf("%q", opts.ParentAccessControlPolicyId)))
} else {
query = query.Where(sq.Expr("c.Id IN (SELECT ID From AccessControlPolicies WHERE Type = ? AND JSON_CONTAINS(JSON_EXTRACT(Data, '$.imports'), ?))", model.AccessControlPolicyTypeChannel, fmt.Sprintf("%q", opts.ParentAccessControlPolicyId)))
}
} else if opts.AccessControlPolicyEnforced {
query = query.InnerJoin("AccessControlPolicies acp ON acp.ID = c.Id")
}
return query
}
func (s SqlChannelStore) SearchAllChannels(term string, opts store.ChannelSearchOpts) (model.ChannelListWithTeamData, int64, error) {
opts.Term = term
opts.IncludeTeamInfo = true
queryString, args, err := s.channelSearchQuery(&opts).ToSql()
if err != nil {
return nil, 0, errors.Wrap(err, "channel_tosql")
}
channels := model.ChannelListWithTeamData{}
if err2 := s.GetReplica().Select(&channels, queryString, args...); err2 != nil {
return nil, 0, errors.Wrapf(err2, "failed to find Channels with term='%s'", trimInput(term))
}
var totalCount int64
// only query a 2nd time for the count if the results are being requested paginated.
if opts.IsPaginated() {
opts.CountOnly = true
queryString, args, err = s.channelSearchQuery(&opts).ToSql()
if err != nil {
return nil, 0, errors.Wrap(err, "channel_tosql")
}
if err2 := s.GetReplica().Get(&totalCount, queryString, args...); err2 != nil {
return nil, 0, errors.Wrapf(err2, "failed to find Channels with term='%s'", trimInput(term))
}
} else {
totalCount = int64(len(channels))
}
return channels, totalCount, nil
}
func (s SqlChannelStore) SearchMore(userId string, teamId string, term string) (model.ChannelList, error) {
teamQuery := s.getSubQueryBuilder().Select("c.Id").
From("PublicChannels c").
Join("ChannelMembers cm ON (cm.ChannelId = c.Id)").
Where(sq.Eq{
"c.TeamId": teamId,
"cm.UserId": userId,
"c.DeleteAt": 0,
})
query := s.getQueryBuilder().Select(channelSliceColumns(true, "Channels")...).
From("Channels").
Join("PublicChannels c ON (c.Id=Channels.Id)").
Where(sq.And{
sq.Eq{"c.TeamId": teamId},
sq.Eq{"c.DeleteAt": 0},
sq.Expr("c.Id NOT IN (?)", teamQuery),
}).
OrderBy("c.DisplayName").
Limit(100)
searchClause := s.searchClause(term)
if searchClause != nil {
query = query.Where(searchClause)
}
return s.performSearch(query, term)
}
func (s SqlChannelStore) buildLIKEClause(term string, searchColumns string) (likeClause, likeTerm string) {
likeTerm = sanitizeSearchTerm(term, "*")
if likeTerm == "" {
return
}
// Prepare the LIKE portion of the query.
var searchFields []string
for field := range strings.SplitSeq(searchColumns, ", ") {
if s.DriverName() == model.DatabaseDriverPostgres {
searchFields = append(searchFields, fmt.Sprintf("lower(%s) LIKE lower(%s) escape '*'", field, ":LikeTerm"))
} else {
searchFields = append(searchFields, fmt.Sprintf("%s LIKE %s escape '*'", field, ":LikeTerm"))
}
}
likeClause = fmt.Sprintf("(%s)", strings.Join(searchFields, " OR "))
likeTerm = wildcardSearchTerm(likeTerm)
return
}
func (s SqlChannelStore) buildLIKEClauseX(term string, searchColumns ...string) sq.Sqlizer {
// escape the special characters with *
likeTerm := sanitizeSearchTerm(term, "*")
if likeTerm == "" {
return nil
}
// add a placeholder at the beginning and end
likeTerm = wildcardSearchTerm(likeTerm)
// Prepare the LIKE portion of the query.
var searchFields sq.Or
for _, field := range searchColumns {
if s.DriverName() == model.DatabaseDriverPostgres {
expr := fmt.Sprintf("LOWER(%s) LIKE LOWER(?) ESCAPE '*'", field)
searchFields = append(searchFields, sq.Expr(expr, likeTerm))
} else {
expr := fmt.Sprintf("%s LIKE ? ESCAPE '*'", field)
searchFields = append(searchFields, sq.Expr(expr, likeTerm))
}
}
return searchFields
}
const spaceFulltextSearchChars = "<>+-()~:*\"!@&"
func (s SqlChannelStore) buildFulltextClause(term string, searchColumns string) (fulltextClause, fulltextTerm string) {
// Copy the terms as we will need to prepare them differently for each search type.
fulltextTerm = term
// These chars must be treated as spaces in the fulltext query.
fulltextTerm = strings.Map(func(r rune) rune {
if strings.ContainsRune(spaceFulltextSearchChars, r) {
return ' '
}
return r
}, fulltextTerm)
// Prepare the FULLTEXT portion of the query.
fulltextTerm = strings.ReplaceAll(fulltextTerm, "|", "")
splitTerm := strings.Fields(fulltextTerm)
for i, t := range strings.Fields(fulltextTerm) {
splitTerm[i] = t + ":*"
}
fulltextTerm = strings.Join(splitTerm, " & ")
fulltextClause = fmt.Sprintf("((to_tsvector('%[1]s', %[2]s)) @@ to_tsquery('%[1]s', :FulltextTerm))", s.pgDefaultTextSearchConfig, convertMySQLFullTextColumnsToPostgres(searchColumns))
return
}
func (s SqlChannelStore) buildFulltextClauseX(term string, searchColumns ...string) sq.Sqlizer {
// Copy the terms as we will need to prepare them differently for each search type.
fulltextTerm := term
// These chars must be treated as spaces in the fulltext query.
fulltextTerm = strings.Map(func(r rune) rune {
if strings.ContainsRune(spaceFulltextSearchChars, r) {
return ' '
}
return r
}, fulltextTerm)
// Prepare the FULLTEXT portion of the query.
if s.DriverName() == model.DatabaseDriverPostgres {
// remove all pipes |
fulltextTerm = strings.ReplaceAll(fulltextTerm, "|", "")
// split the search term and append :* to each part
splitTerm := strings.Fields(fulltextTerm)
for i, t := range splitTerm {
splitTerm[i] = t + ":*"
}
// join the search term with &
fulltextTerm = strings.Join(splitTerm, " & ")
expr := fmt.Sprintf("((to_tsvector('%[1]s', %[2]s)) @@ to_tsquery('%[1]s', ?))", s.pgDefaultTextSearchConfig, strings.Join(searchColumns, " || ' ' || "))
return sq.Expr(expr, fulltextTerm)
}
splitTerm := strings.Fields(fulltextTerm)
for i, t := range splitTerm {
splitTerm[i] = "+" + t + "*"
}
fulltextTerm = strings.Join(splitTerm, " ")
expr := fmt.Sprintf("MATCH(%s) AGAINST (? IN BOOLEAN MODE)", strings.Join(searchColumns, ", "))
return sq.Expr(expr, fulltextTerm)
}
func (s SqlChannelStore) performSearch(searchQuery sq.SelectBuilder, term string) (model.ChannelList, error) {
sql, args, err := searchQuery.ToSql()
if err != nil {
return model.ChannelList{}, errors.Wrapf(err, "performSearch_ToSql")
}
channels := model.ChannelList{}
err = s.GetReplica().Select(&channels, sql, args...)
if err != nil {
return channels, errors.Wrapf(err, "failed to find Channels with term='%s'", trimInput(term))
}
return channels, nil
}
func (s SqlChannelStore) searchClause(term string) sq.Sqlizer {
likeClause := s.buildLIKEClauseX(term, "c.Name", "c.DisplayName", "c.Purpose")
if likeClause == nil {
return nil
}
fulltextClause := s.buildFulltextClauseX(term, "c.Name", "c.DisplayName", "c.Purpose")
return sq.Or{
likeClause,
fulltextClause,
}
}
func (s SqlChannelStore) searchGroupChannelsQuery(userId, term string, isPostgreSQL bool) sq.SelectBuilder {
var baseLikeTerm string
terms := strings.Fields((strings.ToLower(term)))
having := sq.And{}
if isPostgreSQL {
baseLikeTerm = "ARRAY_TO_STRING(ARRAY_AGG(u.Username), ', ') LIKE ?"
cc := s.getSubQueryBuilder().Select("c.Id").
From("Channels c").
Join("ChannelMembers cm ON c.Id=cm.ChannelId").
Join("Users u on u.Id = cm.UserId").
Where(sq.Eq{
"c.Type": model.ChannelTypeGroup,
"u.id": userId,
}).
GroupBy("c.Id")
for _, term := range terms {
term = sanitizeSearchTerm(term, "\\")
having = append(having, sq.Expr(baseLikeTerm, "%"+term+"%"))
}
subq := s.getSubQueryBuilder().Select("cc.id").
FromSelect(cc, "cc").
Join("ChannelMembers cm On cc.Id = cm.ChannelId").
Join("Users u On u.Id = cm.UserId").
GroupBy("cc.Id").
Having(having).
Limit(model.ChannelSearchDefaultLimit)
return s.getQueryBuilder().Select(channelSliceColumns(true)...).
From("Channels").
Where(sq.Expr("Id IN (?)", subq))
}
baseLikeTerm = "GROUP_CONCAT(u.Username SEPARATOR ', ') LIKE ?"
for _, term := range terms {
term = sanitizeSearchTerm(term, "\\")
having = append(having, sq.Expr(baseLikeTerm, "%"+term+"%"))
}
cc := s.getSubQueryBuilder().Select(channelSliceColumns(true, "c")...).
From("Channels c").
Join("ChannelMembers cm ON c.Id=cm.ChannelId").
Join("Users u on u.Id = cm.UserId").
Where(sq.Eq{
"c.Type": model.ChannelTypeGroup,
"u.Id": userId,
}).
GroupBy("c.Id")
return s.getQueryBuilder().Select(channelSliceColumns(true, "cc")...).
FromSelect(cc, "cc").
Join("ChannelMembers cm on cc.Id = cm.ChannelId").
Join("Users u on u.Id = cm.UserId").
GroupBy("cc.Id").
Having(having).
Limit(model.ChannelSearchDefaultLimit)
}
func (s SqlChannelStore) SearchGroupChannels(userId, term string) (model.ChannelList, error) {
isPostgreSQL := s.DriverName() == model.DatabaseDriverPostgres
query := s.searchGroupChannelsQuery(userId, term, isPostgreSQL)
sql, params, err := query.ToSql()
if err != nil {
return nil, errors.Wrap(err, "SearchGroupChannels_Tosql")
}
groupChannels := model.ChannelList{}
if err := s.GetReplica().Select(&groupChannels, sql, params...); err != nil {
return nil, errors.Wrapf(err, "failed to find Channels with term='%s' and userId=%s", trimInput(term), userId)
}
return groupChannels, nil
}
func (s SqlChannelStore) GetMembersByIds(channelID string, userIDs []string) (model.ChannelMembers, error) {
query := s.channelMembersForTeamWithSchemeSelectQuery.Where(
sq.Eq{
"ChannelMembers.ChannelId": channelID,
"ChannelMembers.UserId": userIDs,
},
)
sql, args, err := query.ToSql()
if err != nil {
return nil, errors.Wrap(err, "GetMembersByIds_ToSql")
}
dbMembers := channelMemberWithSchemeRolesList{}
if err := s.GetReplica().Select(&dbMembers, sql, args...); err != nil {
return nil, errors.Wrapf(err, "failed to find ChannelMembers with channelId=%s and userId in %v", channelID, userIDs)
}
return dbMembers.ToModel(), nil
}
func (s SqlChannelStore) GetMembersByChannelIds(channelIDs []string, userID string) (model.ChannelMembers, error) {
query := s.channelMembersForTeamWithSchemeSelectQuery.Where(
sq.Eq{
"ChannelMembers.ChannelId": channelIDs,
"ChannelMembers.UserId": userID,
},
)
sql, args, err := query.ToSql()
if err != nil {
return nil, errors.Wrap(err, "GetMembersByChannelIds_ToSql")
}
dbMembers := channelMemberWithSchemeRolesList{}
if err := s.GetReplica().Select(&dbMembers, sql, args...); err != nil {
return nil, errors.Wrapf(err, "failed to find ChannelMembers with userId=%s and channelId in %v", userID, channelIDs)
}
return dbMembers.ToModel(), nil
}
func (s SqlChannelStore) GetMembersInfoByChannelIds(channelIDs []string) (map[string][]*model.User, error) {
query := s.getQueryBuilder().
Select("Channels.Id as ChannelId, Users.Id, Users.FirstName, Users.LastName, Users.Nickname, Users.Username").
From("ChannelMembers as cm").
Join("Channels ON cm.ChannelId = Channels.Id").
Join("Users ON cm.UserId = Users.Id").
Where(sq.Eq{
"Channels.Id": channelIDs,
"Channels.DeleteAt": 0,
})
sql, args, err := query.ToSql()
if err != nil {
return nil, errors.Wrap(err, "dm_gm_names_tosql")
}
res := []*struct {
model.User
ChannelId string
}{}
if err := s.GetReplica().Select(&res, sql, args...); err != nil {
return nil, errors.Wrap(err, "failed to find channels display name")
}
if len(res) == 0 {
return nil, store.NewErrNotFound("User", fmt.Sprintf("%v", channelIDs))
}
userInfo := make(map[string][]*model.User)
for _, item := range res {
userInfo[item.ChannelId] = append(userInfo[item.ChannelId], &item.User)
}
return userInfo, nil
}
func (s SqlChannelStore) GetChannelsByScheme(schemeId string, offset int, limit int) (model.ChannelList, error) {
channels := model.ChannelList{}
query := s.tableSelectQuery.Where(sq.Eq{"SchemeId": schemeId}).OrderBy("DisplayName").Limit(uint64(limit)).Offset(uint64(offset))
if err := s.GetReplica().SelectBuilder(&channels, query); err != nil {
return nil, errors.Wrapf(err, "failed to find Channels with schemeId=%s", schemeId)
}
return channels, nil
}
// This function does the Advanced Permissions Phase 2 migration for ChannelMember objects. It performs the migration
// in batches as a single transaction per batch to ensure consistency but to also minimise execution time to avoid
// causing unnecessary table locks. **THIS FUNCTION SHOULD NOT BE USED FOR ANY OTHER PURPOSE.** Executing this function
// *after* the new Schemes functionality has been used on an installation will have unintended consequences.
func (s SqlChannelStore) MigrateChannelMembers(fromChannelId string, fromUserId string) (_ map[string]string, err error) {
var transaction *sqlxTxWrapper
if transaction, err = s.GetMaster().Beginx(); err != nil {
return nil, errors.Wrap(err, "begin_transaction")
}
defer finalizeTransactionX(transaction, &err)
channelMembers := []channelMember{}
query := `
SELECT
ChannelId,
UserId,
Roles,
LastViewedAt,
MsgCount,
MentionCount,
MentionCountRoot,
COALESCE(UrgentMentionCount, 0) AS UrgentMentionCount,
MsgCountRoot,
NotifyProps,
LastUpdateAt,
SchemeUser,
SchemeAdmin,
SchemeGuest
FROM
ChannelMembers
WHERE
(ChannelId, UserId) > (?, ?)
ORDER BY ChannelId, UserId
LIMIT 100
`
if err := transaction.Select(&channelMembers, query, fromChannelId, fromUserId); err != nil {
return nil, errors.Wrap(err, "failed to find ChannelMembers")
}
if len(channelMembers) == 0 {
// No more channel members in query result means that the migration has finished.
return nil, nil
}
for i := range channelMembers {
member := channelMembers[i]
roles := strings.Fields(member.Roles)
var newRoles []string
if !member.SchemeAdmin.Valid {
member.SchemeAdmin = sql.NullBool{Bool: false, Valid: true}
}
if !member.SchemeUser.Valid {
member.SchemeUser = sql.NullBool{Bool: false, Valid: true}
}
if !member.SchemeGuest.Valid {
member.SchemeGuest = sql.NullBool{Bool: false, Valid: true}
}
for _, role := range roles {
if role == model.ChannelAdminRoleId {
member.SchemeAdmin = sql.NullBool{Bool: true, Valid: true}
} else if role == model.ChannelUserRoleId {
member.SchemeUser = sql.NullBool{Bool: true, Valid: true}
} else if role == model.ChannelGuestRoleId {
member.SchemeGuest = sql.NullBool{Bool: true, Valid: true}
} else {
newRoles = append(newRoles, role)
}
}
member.Roles = strings.Join(newRoles, " ")
if _, err := transaction.NamedExec(`UPDATE ChannelMembers
SET Roles=:Roles,
LastViewedAt=:LastViewedAt,
MsgCount=:MsgCount,
MentionCount=:MentionCount,
UrgentMentionCount=:UrgentMentionCount,
NotifyProps=:NotifyProps,
LastUpdateAt=:LastUpdateAt,
SchemeUser=:SchemeUser,
SchemeAdmin=:SchemeAdmin,
SchemeGuest=:SchemeGuest,
MentionCountRoot=:MentionCountRoot,
MsgCountRoot=:MsgCountRoot
WHERE ChannelId=:ChannelId AND UserId=:UserId`, &member); err != nil {
return nil, errors.Wrap(err, "failed to update ChannelMember")
}
}
if err := transaction.Commit(); err != nil {
return nil, errors.Wrap(err, "commit_transaction")
}
data := make(map[string]string)
data["ChannelId"] = channelMembers[len(channelMembers)-1].ChannelId
data["UserId"] = channelMembers[len(channelMembers)-1].UserId
return data, nil
}
func (s SqlChannelStore) ResetAllChannelSchemes() (err error) {
transaction, err := s.GetMaster().Beginx()
if err != nil {
return errors.Wrap(err, "begin_transaction")
}
defer finalizeTransactionX(transaction, &err)
err = s.resetAllChannelSchemesT(transaction)
if err != nil {
return err
}
if err := transaction.Commit(); err != nil {
return errors.Wrap(err, "commit_transaction")
}
return nil
}
func (s SqlChannelStore) resetAllChannelSchemesT(transaction *sqlxTxWrapper) error {
if _, err := transaction.Exec("UPDATE Channels SET SchemeId=''"); err != nil {
return errors.Wrap(err, "failed to update Channels")
}
return nil
}
func (s SqlChannelStore) ClearAllCustomRoleAssignments() (err error) {
builtInRoles := model.MakeDefaultRoles()
lastUserId := strings.Repeat("0", 26)
lastChannelId := strings.Repeat("0", 26)
for {
var transaction *sqlxTxWrapper
if transaction, err = s.GetMaster().Beginx(); err != nil {
return errors.Wrap(err, "begin_transaction")
}
channelMembers := []*channelMember{}
query := `
SELECT
ChannelId,
UserId,
Roles,
LastViewedAt,
MsgCount,
MentionCount,
MentionCountRoot,
COALESCE(UrgentMentionCount, 0) AS UrgentMentionCount,
MsgCountRoot,
NotifyProps,
LastUpdateAt,
SchemeUser,
SchemeAdmin,
SchemeGuest
FROM
ChannelMembers
WHERE
(ChannelId, UserId) > (?, ?)
ORDER BY ChannelId, UserId
LIMIT 1000
`
if err = transaction.Select(&channelMembers, query, lastChannelId, lastUserId); err != nil {
finalizeTransactionX(transaction, &err)
return errors.Wrap(err, "failed to find ChannelMembers")
}
if len(channelMembers) == 0 {
finalizeTransactionX(transaction, &err)
break
}
for _, member := range channelMembers {
lastUserId = member.UserId
lastChannelId = member.ChannelId
var newRoles []string
for role := range strings.FieldsSeq(member.Roles) {
for name := range builtInRoles {
if name == role {
newRoles = append(newRoles, role)
break
}
}
}
newRolesString := strings.Join(newRoles, " ")
if newRolesString != member.Roles {
if _, err = transaction.Exec("UPDATE ChannelMembers SET Roles = ? WHERE UserId = ? AND ChannelId = ?", newRolesString, member.UserId, member.ChannelId); err != nil {
finalizeTransactionX(transaction, &err)
return errors.Wrap(err, "failed to update ChannelMembers")
}
}
}
if err = transaction.Commit(); err != nil {
finalizeTransactionX(transaction, &err)
return errors.Wrap(err, "commit_transaction")
}
}
return nil
}
func (s SqlChannelStore) GetAllChannelsForExportAfter(limit int, afterId string) ([]*model.ChannelForExport, error) {
query := s.getQueryBuilder().
Select(channelSliceColumns(true, "Channels")...).
Columns(
"Teams.Name as TeamName",
"Schemes.Name as SchemeName",
).
From("Channels").
InnerJoin("Teams ON Channels.TeamId = Teams.Id").
LeftJoin("Schemes ON Channels.SchemeId = Schemes.Id").
Where(sq.And{
sq.Gt{"Channels.Id": afterId},
sq.Eq{"Channels.Type": []model.ChannelType{model.ChannelTypeOpen, model.ChannelTypePrivate}},
}).
OrderBy("Id").
Limit(uint64(limit))
channels := []*model.ChannelForExport{}
queryString, args, err := query.ToSql()
if err != nil {
return nil, errors.Wrap(err, "failed to convert SQL query to string")
}
if err := s.GetReplica().Select(&channels, queryString, args...); err != nil {
return nil, errors.Wrap(err, "failed to find Channels for export")
}
return channels, nil
}
func (s SqlChannelStore) GetChannelMembersForExport(userId string, teamId string, includeArchivedChannel bool) ([]*model.ChannelMemberForExport, error) {
members := []*model.ChannelMemberForExport{}
q := `
SELECT
ChannelMembers.ChannelId,
ChannelMembers.UserId,
ChannelMembers.Roles,
ChannelMembers.LastViewedAt,
ChannelMembers.MsgCount,
ChannelMembers.MentionCount,
ChannelMembers.MentionCountRoot,
COALESCE(ChannelMembers.UrgentMentionCount, 0) AS UrgentMentionCount,
ChannelMembers.MsgCountRoot,
ChannelMembers.NotifyProps,
ChannelMembers.LastUpdateAt,
ChannelMembers.SchemeUser,
ChannelMembers.SchemeAdmin,
(ChannelMembers.SchemeGuest IS NOT NULL AND ChannelMembers.SchemeGuest) as SchemeGuest,
Channels.Name as ChannelName
FROM
ChannelMembers
INNER JOIN
Channels ON ChannelMembers.ChannelId = Channels.Id
WHERE
ChannelMembers.UserId = ?
AND Channels.TeamId = ?`
if !includeArchivedChannel {
q += " AND Channels.DeleteAt = 0"
}
err := s.GetReplica().Select(&members, q, userId, teamId)
if err != nil {
return nil, errors.Wrap(err, "failed to find Channels for export")
}
return members, nil
}
func (s SqlChannelStore) GetAllDirectChannelsForExportAfter(limit int, afterId string, includeArchivedChannels bool) ([]*model.DirectChannelForExport, error) {
directChannelsForExport := []*model.DirectChannelForExport{}
query := s.getQueryBuilder().
Select(channelSliceColumns(true, "Channels")...).
From("Channels").
Where(sq.And{
sq.Gt{"Channels.Id": afterId},
sq.Eq{"Channels.Type": []model.ChannelType{model.ChannelTypeDirect, model.ChannelTypeGroup}},
}).
OrderBy("Channels.Id").
Limit(uint64(limit))
if !includeArchivedChannels {
query = query.Where(
sq.Eq{"Channels.DeleteAt": int(0)},
)
}
queryString, args, err := query.ToSql()
if err != nil {
return nil, errors.Wrap(err, "channel_tosql")
}
if err2 := s.GetReplica().Select(&directChannelsForExport, queryString, args...); err2 != nil {
return nil, errors.Wrap(err2, "failed to find direct Channels for export")
}
var channelIds []string
for _, channel := range directChannelsForExport {
channelIds = append(channelIds, channel.Id)
}
query = s.getQueryBuilder().
Select("u.Username as Username, ChannelId, UserId, cm.Roles as Roles, LastViewedAt, MsgCount, MsgCountRoot, MentionCount, MentionCountRoot, COALESCE(UrgentMentionCount, 0) UrgentMentionCount, cm.NotifyProps as NotifyProps, LastUpdateAt, SchemeUser, SchemeAdmin, (SchemeGuest IS NOT NULL AND SchemeGuest) as SchemeGuest").
From("ChannelMembers cm").
Join("Users u ON ( u.Id = cm.UserId )").
Where(sq.Eq{"cm.ChannelId": channelIds})
queryString, args, err = query.ToSql()
if err != nil {
return nil, errors.Wrap(err, "channel_tosql")
}
channelMembers := []*model.ChannelMemberForExport{}
if err2 := s.GetReplica().Select(&channelMembers, queryString, args...); err2 != nil {
return nil, errors.Wrap(err2, "failed to find ChannelMembers")
}
// Populate each channel with its members
dmChannelsMap := make(map[string]*model.DirectChannelForExport)
for _, channel := range directChannelsForExport {
channel.Members = []*model.ChannelMemberForExport{}
dmChannelsMap[channel.Id] = channel
}
for _, member := range channelMembers {
dmChannelsMap[member.ChannelId].Members = append(dmChannelsMap[member.ChannelId].Members, member)
}
return directChannelsForExport, nil
}
func (s SqlChannelStore) GetChannelsBatchForIndexing(startTime int64, startChannelID string, limit int) ([]*model.Channel, error) {
query := s.getQueryBuilder().
Select(channelSliceColumns(false)...).
From("Channels").
Where(sq.Or{
sq.Gt{"CreateAt": startTime},
sq.And{
sq.Eq{"CreateAt": startTime},
sq.Gt{"Id": startChannelID},
},
}).
OrderBy("CreateAt ASC", "Id ASC").
Limit(uint64(limit))
channels := []*model.Channel{}
err := s.GetSearchReplicaX().SelectBuilder(&channels, query)
if err != nil {
return nil, errors.Wrap(err, "failed to find Channels")
}
return channels, nil
}
func (s SqlChannelStore) UserBelongsToChannels(userId string, channelIds []string) (bool, error) {
query := s.getQueryBuilder().
Select("Count(*)").
From("ChannelMembers").
Where(sq.And{
sq.Eq{"UserId": userId},
sq.Eq{"ChannelId": channelIds},
})
queryString, args, err := query.ToSql()
if err != nil {
return false, errors.Wrap(err, "channel_tosql")
}
var c int64
err = s.GetReplica().Get(&c, queryString, args...)
if err != nil {
return false, errors.Wrap(err, "failed to count ChannelMembers")
}
return c > 0, nil
}
// UpdateMembersRole updates all the members of channelID in the adminIDs string array to be admins and sets all other
// users as not being admin.
// It returns the list of userIDs whose roles got updated.
//
// TODO: parameterize adminIDs
func (s SqlChannelStore) UpdateMembersRole(channelID string, adminIDs []string) (_ []*model.ChannelMember, err error) {
transaction, err := s.GetMaster().Beginx()
if err != nil {
return nil, err
}
defer finalizeTransactionX(transaction, &err)
// On MySQL it's not possible to update a table and select from it in the same query.
// A SELECT and a UPDATE query are needed.
// Once we only support PostgreSQL, this can be done in a single query using RETURNING.
query, args, err := s.getQueryBuilder().
Select(channelMemberSliceColumns()...).
From("ChannelMembers").
Where(sq.Eq{"ChannelID": channelID}).
Where(sq.Or{sq.Eq{"SchemeGuest": false}, sq.Expr("SchemeGuest IS NULL")}).
Where(
sq.Or{
// New admins
sq.And{
sq.Eq{"SchemeAdmin": false},
sq.Eq{"UserId": adminIDs},
},
// Demoted admins
sq.And{
sq.Eq{"SchemeAdmin": true},
sq.NotEq{"UserId": adminIDs},
},
},
).ToSql()
if err != nil {
return nil, errors.Wrap(err, "channel_tosql")
}
var updatedMembers []*model.ChannelMember
if err = transaction.Select(&updatedMembers, query, args...); err != nil {
return nil, errors.Wrap(err, "failed to get list of updated users")
}
// Update SchemeAdmin field as the data from the SQL is not updated yet
for _, member := range updatedMembers {
if slices.Contains(adminIDs, member.UserId) {
member.SchemeAdmin = true
} else {
member.SchemeAdmin = false
}
}
query, args, err = s.getQueryBuilder().
Update("ChannelMembers").
Set("SchemeAdmin", sq.Case().When(sq.Eq{"UserId": adminIDs}, "true").Else("false")).
Where(sq.Eq{"ChannelId": channelID}).
Where(sq.Or{sq.Eq{"SchemeGuest": false}, sq.Expr("SchemeGuest IS NULL")}).ToSql()
if err != nil {
return nil, errors.Wrap(err, "team_tosql")
}
if _, err = transaction.Exec(query, args...); err != nil {
return nil, errors.Wrap(err, "failed to update ChannelMembers")
}
if err = transaction.Commit(); err != nil {
return nil, errors.Wrap(err, "commit_transaction")
}
return updatedMembers, nil
}
func (s SqlChannelStore) GroupSyncedChannelCount() (int64, error) {
query := s.getQueryBuilder().
Select("COUNT(*)").
From("Channels").
Where(sq.Eq{"GroupConstrained": true, "DeleteAt": 0})
sql, args, err := query.ToSql()
if err != nil {
return 0, errors.Wrap(err, "channel_tosql")
}
var count int64
err = s.GetReplica().Get(&count, sql, args...)
if err != nil {
return 0, errors.Wrap(err, "failed to count Channels")
}
return count, nil
}
// SetShared sets the Shared flag true/false
func (s SqlChannelStore) SetShared(channelId string, shared bool) error {
squery, args, err := s.getQueryBuilder().
Update("Channels").
Set("Shared", shared).
Where(sq.Eq{"Id": channelId}).
ToSql()
if err != nil {
return errors.Wrap(err, "channel_set_shared_tosql")
}
result, err := s.GetMaster().Exec(squery, args...)
if err != nil {
return errors.Wrap(err, "failed to update `Shared` for Channels")
}
count, err := result.RowsAffected()
if err != nil {
return errors.Wrap(err, "failed to determine rows affected")
}
if count == 0 {
return fmt.Errorf("id not found: %s", channelId)
}
return nil
}
// GetTeamForChannel returns the team for a given channelID.
func (s SqlChannelStore) GetTeamForChannel(channelID string) (*model.Team, error) {
nestedQ, nestedArgs, err := s.getQueryBuilder().Select("TeamId").From("Channels").Where(sq.Eq{"Id": channelID}).ToSql()
if err != nil {
return nil, errors.Wrap(err, "get_team_for_channel_nested_tosql")
}
query, args, err := s.getQueryBuilder().
Select(teamSliceColumns()...).
From("Teams").Where(sq.Expr("Id = ("+nestedQ+")", nestedArgs...)).ToSql()
if err != nil {
return nil, errors.Wrap(err, "get_team_for_channel_tosql")
}
team := model.Team{}
err = s.GetReplica().Get(&team, query, args...)
if err != nil {
if err == sql.ErrNoRows {
return nil, store.NewErrNotFound("Team", fmt.Sprintf("channel_id=%s", channelID))
}
return nil, errors.Wrapf(err, "failed to find team with channel_id=%s", channelID)
}
return &team, nil
}
func (s SqlChannelStore) IsReadOnlyChannel(channelID string) (bool, error) {
query := s.getQueryBuilder().Select("schemeid").From("channels").Where(sq.Eq{"id": channelID}).Limit(1)
squery, args, err := query.ToSql()
if err != nil {
return false, err
}
// we look for schemeID to look for a custom scheme, if there is none chances are it is a writeable
// there might be in effect a custom scheme for the user that doesn't allow to create posts, but that wouldn't
// be a readonly channel but a readonly user
var schemaId string
err = s.GetReplica().Get(&schemaId, squery, args...)
if err != nil {
return false, nil
}
if schemaId == "" {
return false, nil
}
return s.IsChannelReadOnlyScheme(schemaId)
}
func (s SqlChannelStore) IsChannelReadOnlyScheme(schemeID string) (bool, error) {
query := s.getQueryBuilder().Select("roles.permissions").From("roles").InnerJoin("schemes ON roles.name = schemes.defaultchanneluserrole").Where(sq.Eq{"schemes.id": schemeID}).Limit(1)
squery, args, err := query.ToSql()
if err != nil {
mlog.Err(err)
return false, err
}
var permissions string
err = s.GetReplica().Get(&permissions, squery, args...)
if err != nil {
mlog.Err(err)
return false, err
}
permissionList := strings.Split(permissions, " ")
return slices.Index(permissionList, model.PermissionCreatePost.Id) == -1, nil
}
Reference in New Issue View Git Blame Copy Permalink