toki/mattermost-mobile
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

MM-37781: Only evaluates some config settings if the server is less than v6. (#5627)

Browse source 
* MM-37781: Only check deprecated config settings if server is older than v6.

* Feedback review

* Add isMinimumServerVersion helper for iOS Native

* MM-37781: Adds missing parameters.

Co-authored-by: Elias Nahum <nahumhbl@gmail.com>
This commit is contained in:
Martin Kraft 2021-09-15 16:52:39 -04:00 committed by GitHub
parent ccba75c8cd
commit c704a752f8
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
11 changed files with 166 additions and 340 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
app/actions/helpers/channels.ts
View file

@ -328,7 +328,8 @@ function fetchDirectMessageProfileIfNeeded(state: GlobalState, channel: Channel,
const otherUserId = getUserIdFromChannelName(currentUserId, channel.name);
const otherUser = users[otherUserId];
const dmVisible = isDirectChannelVisible(currentUserId, myPreferences, channel);
const dmAutoClosed = isAutoClosed(config, myPreferences, channel, channel.last_post_at, otherUser ? otherUser.delete_at : 0, currentChannelId);
const {serverVersion} = state.entities.general;
const dmAutoClosed = isAutoClosed(config, myPreferences, channel, channel.last_post_at, otherUser ? otherUser.delete_at : 0, currentChannelId, undefined, serverVersion);
const member = channelMembers.find((cm) => cm.channel_id === channel.id);
const dmIsUnread = member ? member.mention_count > 0 : false;
const dmFetchProfile = dmIsUnread || (dmVisible && !dmAutoClosed);
@ -355,7 +356,9 @@ function fetchGroupMessageProfilesIfNeeded(state: GlobalState, channel: Channel,
const myPreferences = getMyPreferences(state);
const config = getConfig(state);
const gmVisible = isGroupChannelVisible(myPreferences, channel);
const gmAutoClosed = isAutoClosed(config, myPreferences, channel, channel.last_post_at, 0);
const {serverVersion} = state.entities.general;
const currentChannelId = getCurrentChannelId(state);
const gmAutoClosed = isAutoClosed(config, myPreferences, channel, channel.last_post_at, 0, currentChannelId, undefined, serverVersion);
const channelMember = channelMembers.find((cm) => cm.channel_id === channel.id);
let hasMentions = false;
let isUnread = false;

30
app/mm-redux/selectors/entities/channels.ts
View file

@ -1,5 +1,8 @@
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
// See LICENSE.txt for license information.
/* eslint-disable max-lines */
import {createSelector} from 'reselect';
import {getCurrentChannelId, getCurrentUser, getUsers, getMyChannelMemberships, getMyCurrentChannelMembership} from '@mm-redux/selectors/entities/common';
@ -19,7 +22,7 @@ import {ThreadsState} from '@mm-redux/types/threads';
import {UsersState, UserProfile} from '@mm-redux/types/users';
import {NameMappedObjects, UserIDMappedObjects, IDMappedObjects, RelationOneToOne, RelationOneToMany} from '@mm-redux/types/utilities';
import {buildDisplayableChannelListWithUnreadSection, completeDirectChannelInfo, completeDirectChannelDisplayName, getUserIdFromChannelName, getChannelByName as getChannelByNameHelper, isChannelMuted, getDirectChannelName, isAutoClosed, isDirectChannelVisible, isGroupChannelVisible, isGroupOrDirectChannelVisible, sortChannelsByDisplayName, isFavoriteChannel, isDefault, sortChannelsByRecency, getMsgCountInChannel} from '@mm-redux/utils/channel_utils';
import {createIdsSelector} from '@mm-redux/utils/helpers';
import {createIdsSelector, isMinimumServerVersion} from '@mm-redux/utils/helpers';
import {General, Permissions} from '../../constants';
@ -176,7 +179,8 @@ export function isChannelReadOnlyById(state: GlobalState, channelId: string): bo
}
export function isChannelReadOnly(state: GlobalState, channel: Channel): boolean {
return channel && channel.name === General.DEFAULT_CHANNEL && !isCurrentUserSystemAdmin(state) && getConfig(state).ExperimentalTownSquareIsReadOnly === 'true';
const {serverVersion} = state.entities.general;
return channel && channel.name === General.DEFAULT_CHANNEL && !isCurrentUserSystemAdmin(state) && (getConfig(state).ExperimentalTownSquareIsReadOnly === 'true' && !isMinimumServerVersion(serverVersion, 6));
}
export function shouldHideDefaultChannel(state: GlobalState, channel: Channel): boolean {
@ -473,17 +477,9 @@ export const getUnreadsInCurrentTeam: (a: GlobalState) => {
});
export const canManageChannelMembers: (a: GlobalState) => boolean = createSelector(
getCurrentChannel,
(state: GlobalState): boolean => haveICurrentChannelPermission(state, {
permission: Permissions.MANAGE_PRIVATE_CHANNEL_MEMBERS,
}),
(state: GlobalState): boolean => haveICurrentChannelPermission(state, {
permission: Permissions.MANAGE_PUBLIC_CHANNEL_MEMBERS,
}),
(
channel: Channel,
managePrivateMembers: boolean,
managePublicMembers: boolean,
): boolean => {
(state: GlobalState): boolean => haveICurrentChannelPermission(state, {permission: Permissions.MANAGE_PRIVATE_CHANNEL_MEMBERS}),
(state: GlobalState): boolean => haveICurrentChannelPermission(state, {permission: Permissions.MANAGE_PUBLIC_CHANNEL_MEMBERS}),
(channel: Channel, managePrivateMembers: boolean, managePublicMembers: boolean): boolean => {
if (!channel) {
return false;
}
@ -713,9 +709,9 @@ export const getPrivateChannelIds: (e: GlobalState, d: Channel, c: boolean, b: b
export const getSortedPrivateChannelIds: (e: GlobalState, d: Channel | null, c: boolean, b: boolean, a: SortingType) => Array<string> = createIdsSelector(getUnreadChannelIds, getFavoritesPreferences, (state: GlobalState, lastUnreadChannel: Channel, unreadsAtTop: boolean, favoritesAtTop: boolean, sorting: SortingType = 'alpha') => getPrivateChannelIds(state, lastUnreadChannel, unreadsAtTop, favoritesAtTop, sorting), (state, lastUnreadChannel, unreadsAtTop = true) => unreadsAtTop, (state, lastUnreadChannel, unreadsAtTop, favoritesAtTop = true) => favoritesAtTop, filterChannels); // Direct Messages
export const getDirectChannels: (a: GlobalState) => Array<Channel> = createSelector(getCurrentUser, getUsers, getUserIdsInChannels, getAllChannels, getVisibleTeammate, getVisibleGroupIds, getTeammateNameDisplaySetting, getConfig, getMyPreferences, getLastPostPerChannel, getCurrentChannelId, (currentUser: UserProfile, profiles: IDMappedObjects<UserProfile>, userIdsInChannels: any, channels: IDMappedObjects<Channel>, teammates: Array<string>, groupIds: Array<string>, settings, config, preferences: {
export const getDirectChannels: (a: GlobalState) => Array<Channel> = createSelector(getCurrentUser, getUsers, getUserIdsInChannels, getAllChannels, getVisibleTeammate, getVisibleGroupIds, getTeammateNameDisplaySetting, getConfig, getMyPreferences, getLastPostPerChannel, getCurrentChannelId, (state: GlobalState) => state.entities.general.serverVersion, (currentUser: UserProfile, profiles: IDMappedObjects<UserProfile>, userIdsInChannels: any, channels: IDMappedObjects<Channel>, teammates: Array<string>, groupIds: Array<string>, settings, config, preferences: {
[x: string]: PreferenceType;
}, lastPosts: RelationOneToOne<Channel, Post>, currentChannelId: string): Array<Channel> => {
}, lastPosts: RelationOneToOne<Channel, Post>, currentChannelId: string, serverVersion: string): Array<Channel> => {
if (!currentUser) {
return [];
}
@ -730,7 +726,7 @@ export const getDirectChannels: (a: GlobalState) => Array<Channel> = createSelec
const lastPost = lastPosts[channel.id];
const otherUser = profiles[getUserIdFromChannelName(currentUser.id, channel.name)];
if (!isAutoClosed(config, preferences, channel, lastPost ? lastPost.create_at : 0, otherUser ? otherUser.delete_at : 0, currentChannelId)) {
if (!isAutoClosed(config, preferences, channel, lastPost ? lastPost.create_at : 0, otherUser ? otherUser.delete_at : 0, currentChannelId, undefined, serverVersion)) {
result.push(channel.id);
}
}
@ -742,7 +738,7 @@ export const getDirectChannels: (a: GlobalState) => Array<Channel> = createSelec
if (channel && (channel.type === General.DM_CHANNEL || channel.type === General.GM_CHANNEL)) {
const lastPost = lastPosts[channel.id];
return !isAutoClosed(config, preferences, channels[id], lastPost ? lastPost.create_at : 0, 0, currentChannelId);
return !isAutoClosed(config, preferences, channels[id], lastPost ? lastPost.create_at : 0, 0, currentChannelId, undefined, serverVersion);
}
return false;

5
app/mm-redux/selectors/entities/preferences.ts
View file

@ -8,7 +8,7 @@ import {getCurrentTeamId} from '@mm-redux/selectors/entities/teams';
import {PreferenceType} from '@mm-redux/types/preferences';
import {GlobalState} from '@mm-redux/types/store';
import {Theme} from '@mm-redux/types/theme';
import {createShallowSelector} from '@mm-redux/utils/helpers';
import {createShallowSelector, isMinimumServerVersion} from '@mm-redux/utils/helpers';
import {getPreferenceKey} from '@mm-redux/utils/preference_utils';
import {setThemeDefaults} from '@mm-redux/utils/theme_utils';
@ -230,7 +230,8 @@ export const getNewSidebarPreference = reselect.createSelector(
export function shouldAutocloseDMs(state: GlobalState) {
const config = getConfig(state);
if (!config.CloseUnusedDirectMessages || config.CloseUnusedDirectMessages === 'false') {
const {serverVersion} = state.entities.general;
if ((!config.CloseUnusedDirectMessages || config.CloseUnusedDirectMessages === 'false') && !isMinimumServerVersion(serverVersion, 6)) {
return false;
}

1
app/mm-redux/types/config.ts
View file

@ -94,7 +94,6 @@ export type Config = {
EnableUserCreation: string;
EnableUserDeactivation: string;
EnableUserTypingMessages: string;
EnableXToLeaveChannelsFromLHS: string;
EnforceMultifactorAuthentication: string;
ExperimentalChannelOrganization: string;
ExperimentalChannelSidebarOrganization: string;

91
app/mm-redux/utils/channel_utils.test.js
View file

@ -5,7 +5,6 @@ import assert from 'assert';
import {
areChannelMentionsIgnored,
canManageMembersOldPermissions,
compareNotifyProps,
isAutoClosed,
isChannelMuted,
@ -15,97 +14,9 @@ import {
} from '@mm-redux/utils/channel_utils';
import TestHelper from '@test/test_helper';
import {General, Users} from '../constants';
import {Users} from '../constants';
describe('ChannelUtils', () => {
it('canManageMembersOldPermissions', () => {
const notLicensed = {IsLicensed: 'false'};
const licensed = {IsLicensed: 'true'};
const anyoneCanManageMembers = {RestrictPrivateChannelManageMembers: General.PERMISSIONS_ANY};
const channelAdminsCanManageMembers = {RestrictPrivateChannelManageMembers: General.PERMISSIONS_CHANNEL_ADMIN};
const teamAdminsCanManageMembers = {RestrictPrivateChannelManageMembers: General.PERMISSIONS_TEAM_ADMIN};
const systemAdminsCanManageMembers = {RestrictPrivateChannelManageMembers: General.PERMISSIONS_SYSTEM_ADMIN};
const townSquareChannel = {name: General.DEFAULT_CHANNEL, type: General.OPEN_CHANNEL};
const publicChannel = {type: General.PUBLIC_CHANNEL};
const privateChannel = {type: General.PRIVATE_CHANNEL};
const gmChannel = {type: General.GM_CHANNEL};
const dmChannel = {type: General.DM_CHANNEL};
const systemAdmin = {roles: General.SYSTEM_USER_ROLE + ' ' + General.SYSTEM_ADMIN_ROLE};
const systemUser = {roles: General.SYSTEM_USER_ROLE};
const teamAdmin = {roles: General.TEAM_USER_ROLE + ' ' + General.TEAM_ADMIN_ROLE};
const teamUser = {roles: General.TEAM_USER_ROLE};
const channelAdmin = {roles: General.CHANNEL_USER_ROLE + ' ' + General.CHANNEL_ADMIN_ROLE};
const channelUser = {roles: General.CHANNEL_USER_ROLE};
// No one can manage users of town square
assert.ok(!canManageMembersOldPermissions(townSquareChannel, systemAdmin, teamAdmin, channelAdmin, anyoneCanManageMembers, notLicensed));
assert.ok(!canManageMembersOldPermissions(townSquareChannel, systemAdmin, teamAdmin, channelAdmin, anyoneCanManageMembers, licensed));
// Or DM/GM channels
assert.ok(!canManageMembersOldPermissions(dmChannel, systemAdmin, teamAdmin, channelAdmin, anyoneCanManageMembers, notLicensed));
assert.ok(!canManageMembersOldPermissions(dmChannel, systemAdmin, teamAdmin, channelAdmin, anyoneCanManageMembers, licensed));
assert.ok(!canManageMembersOldPermissions(gmChannel, systemAdmin, teamAdmin, channelAdmin, anyoneCanManageMembers, notLicensed));
assert.ok(!canManageMembersOldPermissions(gmChannel, systemAdmin, teamAdmin, channelAdmin, anyoneCanManageMembers, licensed));
// Everyone can manage users of public channels
assert.ok(canManageMembersOldPermissions(publicChannel, systemAdmin, teamAdmin, channelAdmin, anyoneCanManageMembers, notLicensed));
assert.ok(canManageMembersOldPermissions(publicChannel, systemUser, teamUser, channelUser, anyoneCanManageMembers, notLicensed));
assert.ok(canManageMembersOldPermissions(publicChannel, systemAdmin, teamAdmin, channelAdmin, systemAdminsCanManageMembers, notLicensed));
assert.ok(canManageMembersOldPermissions(publicChannel, systemUser, teamUser, channelUser, systemAdminsCanManageMembers, notLicensed));
assert.ok(canManageMembersOldPermissions(publicChannel, systemAdmin, teamAdmin, channelAdmin, anyoneCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(publicChannel, systemUser, teamUser, channelUser, anyoneCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(publicChannel, systemAdmin, teamAdmin, channelAdmin, systemAdminsCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(publicChannel, systemUser, teamUser, channelUser, systemAdminsCanManageMembers, licensed));
// And private channels if not licensed
assert.ok(canManageMembersOldPermissions(privateChannel, systemAdmin, teamAdmin, channelAdmin, anyoneCanManageMembers, notLicensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemUser, teamUser, channelUser, anyoneCanManageMembers, notLicensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemAdmin, teamAdmin, channelAdmin, systemAdminsCanManageMembers, notLicensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemUser, teamUser, channelUser, systemAdminsCanManageMembers, notLicensed));
// But it gets complicated when you have a license
assert.ok(canManageMembersOldPermissions(privateChannel, systemAdmin, teamAdmin, channelAdmin, anyoneCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemAdmin, teamAdmin, channelAdmin, channelAdminsCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemAdmin, teamAdmin, channelAdmin, teamAdminsCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemAdmin, teamAdmin, channelAdmin, systemAdminsCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemAdmin, teamAdmin, channelUser, anyoneCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemAdmin, teamAdmin, channelUser, channelAdminsCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemAdmin, teamAdmin, channelUser, teamAdminsCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemAdmin, teamAdmin, channelUser, systemAdminsCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemAdmin, teamUser, channelAdmin, anyoneCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemAdmin, teamUser, channelAdmin, channelAdminsCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemAdmin, teamUser, channelAdmin, teamAdminsCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemAdmin, teamUser, channelAdmin, systemAdminsCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemAdmin, teamUser, channelUser, anyoneCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemAdmin, teamUser, channelUser, channelAdminsCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemAdmin, teamUser, channelUser, teamAdminsCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemAdmin, teamUser, channelUser, systemAdminsCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemUser, teamAdmin, channelAdmin, anyoneCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemUser, teamAdmin, channelAdmin, channelAdminsCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemUser, teamAdmin, channelAdmin, teamAdminsCanManageMembers, licensed));
assert.ok(!canManageMembersOldPermissions(privateChannel, systemUser, teamAdmin, channelAdmin, systemAdminsCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemUser, teamAdmin, channelUser, anyoneCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemUser, teamAdmin, channelUser, channelAdminsCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemUser, teamAdmin, channelUser, teamAdminsCanManageMembers, licensed));
assert.ok(!canManageMembersOldPermissions(privateChannel, systemUser, teamAdmin, channelUser, systemAdminsCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemUser, teamUser, channelAdmin, anyoneCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemUser, teamUser, channelAdmin, channelAdminsCanManageMembers, licensed));
assert.ok(!canManageMembersOldPermissions(privateChannel, systemUser, teamUser, channelAdmin, teamAdminsCanManageMembers, licensed));
assert.ok(!canManageMembersOldPermissions(privateChannel, systemUser, teamUser, channelAdmin, systemAdminsCanManageMembers, licensed));
assert.ok(canManageMembersOldPermissions(privateChannel, systemUser, teamUser, channelUser, anyoneCanManageMembers, licensed));
assert.ok(!canManageMembersOldPermissions(privateChannel, systemUser, teamUser, channelUser, channelAdminsCanManageMembers, licensed));
assert.ok(!canManageMembersOldPermissions(privateChannel, systemUser, teamUser, channelUser, teamAdminsCanManageMembers, licensed));
assert.ok(!canManageMembersOldPermissions(privateChannel, systemUser, teamUser, channelUser, systemAdminsCanManageMembers, licensed));
});
it('isAutoClosed', () => {
const autoCloseEnabled = {CloseUnusedDirectMessages: 'true'};
const autoCloseDisabled = {CloseUnusedDirectMessages: 'false'};

42
app/mm-redux/utils/channel_utils.ts
View file

@ -6,12 +6,12 @@ import {Channel, ChannelMembership, ChannelType, ChannelNotifyProps} from '@mm-r
import {Post} from '@mm-redux/types/posts';
import {PreferenceType} from '@mm-redux/types/preferences';
import {GlobalState} from '@mm-redux/types/store';
import {TeamMembership} from '@mm-redux/types/teams';
import {UserProfile, UsersState, UserNotifyProps} from '@mm-redux/types/users';
import {RelationOneToOne, IDMappedObjects} from '@mm-redux/types/utilities';
import {General, Preferences, Permissions, Users} from '../constants';
import {isMinimumServerVersion} from './helpers';
import {getPreferenceKey, getPreferencesByCategory} from './preference_utils';
import {displayUsername} from './user_utils';
@ -143,6 +143,7 @@ export function isAutoClosed(
channelArchiveTime: number,
currentChannelId = '',
now = Date.now(),
serverVersion = '',
): boolean {
const cutoff = now - (7 * 24 * 60 * 60 * 1000);
const viewTimePref = myPreferences[`${Preferences.CATEGORY_CHANNEL_APPROXIMATE_VIEW_TIME}--${channel.id}`];
@ -161,7 +162,7 @@ export function isAutoClosed(
return true;
}
if (config.CloseUnusedDirectMessages !== 'true' || isFavoriteChannel(myPreferences, channel.id)) {
if ((config.CloseUnusedDirectMessages !== 'true' && !isMinimumServerVersion(serverVersion, 6)) || isFavoriteChannel(myPreferences, channel.id)) {
return false;
}
@ -195,6 +196,7 @@ export function isDirectChannelVisible(
isUnread?: boolean,
currentChannelId = '',
now?: number,
serverVersion?: string,
): boolean {
const otherUser = typeof otherUserOrOtherUserId === 'object' ? otherUserOrOtherUserId : null;
const otherUserId = typeof otherUserOrOtherUserId === 'object' ? otherUserOrOtherUserId.id : otherUserOrOtherUserId;
@ -212,6 +214,7 @@ export function isDirectChannelVisible(
otherUser ? otherUser.delete_at : 0,
currentChannelId,
now,
serverVersion,
);
}
@ -228,6 +231,7 @@ export function isGroupChannelVisible(
lastPost?: Post,
isUnread?: boolean,
now?: number,
serverVersion?: string,
): boolean {
const gm = myPreferences[`${Preferences.CATEGORY_GROUP_CHANNEL_SHOW}--${channel.id}`];
@ -243,6 +247,7 @@ export function isGroupChannelVisible(
0,
'',
now,
serverVersion,
);
}
@ -311,39 +316,6 @@ export function showDeleteOption(state: GlobalState, channel: Channel): boolean
return true;
}
// Backwards compatibility with pre-advanced permissions config settings.
export function canManageMembersOldPermissions(channel: Channel, user: UserProfile, teamMember: TeamMembership, channelMember: ChannelMembership, config: any, license: any): boolean {
if (channel.type === General.DM_CHANNEL ||
channel.type === General.GM_CHANNEL ||
channel.name === General.DEFAULT_CHANNEL) {
return false;
}
if (license.IsLicensed !== 'true') {
return true;
}
if (channel.type === General.PRIVATE_CHANNEL) {
const isSystemAdmin = user.roles.includes(General.SYSTEM_ADMIN_ROLE);
if (config.RestrictPrivateChannelManageMembers === General.PERMISSIONS_SYSTEM_ADMIN && !isSystemAdmin) {
return false;
}
const isTeamAdmin = teamMember.roles.includes(General.TEAM_ADMIN_ROLE);
if (config.RestrictPrivateChannelManageMembers === General.PERMISSIONS_TEAM_ADMIN && !isTeamAdmin && !isSystemAdmin) {
return false;
}
const isChannelAdmin = channelMember.roles.includes(General.CHANNEL_ADMIN_ROLE);
if (config.RestrictPrivateChannelManageMembers === General.PERMISSIONS_CHANNEL_ADMIN && !isChannelAdmin && !isTeamAdmin && !isSystemAdmin) {
return false;
}
}
return true;
}
export function getChannelsIdForTeam(state: GlobalState, teamId: string): Array<string> {
const {channels} = state.entities.channels;

275
app/mm-redux/utils/post_utils.test.js
View file

@ -100,221 +100,192 @@ describe('PostUtils', () => {
const channelId = 'channel-id';
const userId = 'user-id';
it('should allow to edit my post without license', () => {
const newVersionState = {
entities: {
general: {
serverVersion: '5.26.0',
const state = {
entities: {
users: {
currentUserId: userId,
profiles: {
[userId]: {roles: 'system_role'},
},
users: {
currentUserId: userId,
profiles: {
'user-id': {roles: 'system_role'},
},
},
channels: {
currentChannelId: channelId,
myMembers: {
[channelId]: {roles: 'channel_role'},
},
teams: {
currentTeamId: teamId,
myMembers: {
'team-id': {roles: 'team_role'},
},
},
channels: {
currentChannelId: channelId,
myMembers: {
'channel-id': {roles: 'channel_role'},
},
},
teams: {
currentTeamId: teamId,
myMembers: {
[teamId]: {roles: 'team_role'},
},
},
roles: {
roles: {
roles: {
system_role: {permissions: [Permissions.EDIT_POST]},
team_role: {permissions: []},
channel_role: {permissions: []},
system_role: {
permissions: [Permissions.EDIT_POST],
},
team_role: {
permissions: [],
},
channel_role: {
permissions: [],
},
},
},
};
},
};
it('should allow to edit my post without license', () => {
// Hasn't license
assert.ok(canEditPost(newVersionState, {PostEditTimeLimit: -1}, notLicensed, teamId, channelId, userId, {user_id: userId, type: 'normal'}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: -1}, notLicensed, teamId, channelId, userId, {user_id: userId, type: 'system_test'}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: -1}, notLicensed, teamId, channelId, userId, {user_id: 'other', type: 'normal'}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: -1}, notLicensed, teamId, channelId, userId, {user_id: 'other', type: 'system_test'}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: -1}, notLicensed, teamId, channelId, userId, null));
assert.ok(canEditPost(state, {PostEditTimeLimit: -1}, notLicensed, teamId, channelId, userId, {user_id: userId, type: 'normal'}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: -1}, notLicensed, teamId, channelId, userId, {user_id: userId, type: 'system_test'}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: -1}, notLicensed, teamId, channelId, userId, {user_id: 'other', type: 'normal'}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: -1}, notLicensed, teamId, channelId, userId, {user_id: 'other', type: 'system_test'}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: -1}, notLicensed, teamId, channelId, userId, null));
});
it('should work with new permissions version', () => {
const newVersionState = {
entities: {
general: {
serverVersion: '5.26.0',
},
users: {
currentUserId: userId,
profiles: {
'user-id': {roles: 'system_role'},
},
},
teams: {
currentTeamId: teamId,
myMembers: {
'team-id': {roles: 'team_role'},
},
},
channels: {
currentChannelId: channelId,
myMembers: {
'channel-id': {roles: 'channel_role'},
},
},
roles: {
roles: {
system_role: {
permissions: [],
},
team_role: {
permissions: [],
},
channel_role: {
permissions: [],
},
},
},
// With new permissions
state.entities.roles = {
roles: {
system_role: {permissions: []},
team_role: {permissions: []},
channel_role: {permissions: []},
},
};
assert.ok(!canEditPost(state, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: userId}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 100}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 6000000}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: 'other'}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 100}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 6000000}));
// With new permissions
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: userId}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 100}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 6000000}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: 'other'}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 100}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 6000000}));
newVersionState.entities.roles = {
state.entities.roles = {
roles: {
system_role: {permissions: [Permissions.EDIT_POST]},
team_role: {permissions: []},
channel_role: {permissions: []},
},
};
assert.ok(canEditPost(newVersionState, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: userId}));
assert.ok(canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 100}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 6000000}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: 'other'}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 100}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 6000000}));
assert.ok(canEditPost(state, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: userId}));
assert.ok(canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 100}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 6000000}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: 'other'}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 100}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 6000000}));
newVersionState.entities.roles = {
state.entities.roles = {
roles: {
system_role: {permissions: []},
team_role: {permissions: [Permissions.EDIT_POST]},
channel_role: {permissions: []},
},
};
assert.ok(canEditPost(newVersionState, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: userId}));
assert.ok(canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 100}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 6000000}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: 'other'}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 100}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 6000000}));
assert.ok(canEditPost(state, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: userId}));
assert.ok(canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 100}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 6000000}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: 'other'}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 100}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 6000000}));
newVersionState.entities.roles = {
state.entities.roles = {
roles: {
system_role: {permissions: []},
team_role: {permissions: []},
channel_role: {permissions: [Permissions.EDIT_POST]},
},
};
assert.ok(canEditPost(newVersionState, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: userId}));
assert.ok(canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 100}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 6000000}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: 'other'}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 100}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 6000000}));
assert.ok(canEditPost(state, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: userId}));
assert.ok(canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 100}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 6000000}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: 'other'}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 100}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 6000000}));
newVersionState.entities.roles = {
roles: {
system_role: {permissions: [Permissions.EDIT_OTHERS_POSTS]},
team_role: {permissions: []},
channel_role: {permissions: []},
},
};
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: userId}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 100}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 6000000}));
assert.ok(canEditPost(newVersionState, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: 'other'}));
assert.ok(canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 100}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 6000000}));
newVersionState.entities.roles = {
roles: {
system_role: {permissions: []},
team_role: {permissions: [Permissions.EDIT_OTHERS_POSTS]},
channel_role: {permissions: []},
},
};
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: userId}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 100}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 6000000}));
assert.ok(canEditPost(newVersionState, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: 'other'}));
assert.ok(canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 100}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 6000000}));
newVersionState.entities.roles = {
state.entities.roles = {
roles: {
system_role: {permissions: []},
team_role: {permissions: []},
channel_role: {permissions: [Permissions.EDIT_OTHERS_POSTS]},
},
};
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: userId}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 100}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 6000000}));
assert.ok(canEditPost(newVersionState, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: 'other'}));
assert.ok(canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 100}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 6000000}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: userId}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 100}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 6000000}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: 'other'}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 100}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 6000000}));
newVersionState.entities.roles = {
state.entities.roles = {
roles: {
system_role: {permissions: []},
team_role: {permissions: [Permissions.EDIT_OTHERS_POSTS]},
channel_role: {permissions: []},
},
};
assert.ok(!canEditPost(state, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: userId}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 100}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 6000000}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: 'other'}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 100}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 6000000}));
state.entities.roles = {
roles: {
system_role: {permissions: []},
team_role: {permissions: []},
channel_role: {permissions: [Permissions.EDIT_OTHERS_POSTS]},
},
};
assert.ok(!canEditPost(state, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: userId}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 100}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 6000000}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: 'other'}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 100}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 6000000}));
state.entities.roles = {
roles: {
system_role: {permissions: [Permissions.EDIT_OTHERS_POSTS, Permissions.EDIT_POST]},
team_role: {permissions: []},
channel_role: {permissions: []},
},
};
assert.ok(canEditPost(newVersionState, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: userId}));
assert.ok(canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 100}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 6000000}));
assert.ok(canEditPost(newVersionState, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: 'other'}));
assert.ok(canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 100}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 6000000}));
assert.ok(canEditPost(state, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: userId}));
assert.ok(canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 100}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 6000000}));
assert.ok(canEditPost(state, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: 'other'}));
assert.ok(canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 100}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 6000000}));
newVersionState.entities.roles = {
state.entities.roles = {
roles: {
system_role: {permissions: []},
team_role: {permissions: [Permissions.EDIT_OTHERS_POSTS, Permissions.EDIT_POST]},
channel_role: {permissions: []},
},
};
assert.ok(canEditPost(newVersionState, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: userId}));
assert.ok(canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 100}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 6000000}));
assert.ok(canEditPost(newVersionState, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: 'other'}));
assert.ok(canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 100}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 6000000}));
assert.ok(canEditPost(state, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: userId}));
assert.ok(canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 100}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 6000000}));
assert.ok(canEditPost(state, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: 'other'}));
assert.ok(canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 100}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 6000000}));
newVersionState.entities.roles = {
state.entities.roles = {
roles: {
system_role: {permissions: []},
team_role: {permissions: []},
channel_role: {permissions: [Permissions.EDIT_OTHERS_POSTS, Permissions.EDIT_POST]},
},
};
assert.ok(canEditPost(newVersionState, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: userId}));
assert.ok(canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 100}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 6000000}));
assert.ok(canEditPost(newVersionState, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: 'other'}));
assert.ok(canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 100}));
assert.ok(!canEditPost(newVersionState, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 6000000}));
assert.ok(canEditPost(state, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: userId}));
assert.ok(canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 100}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: userId, create_at: Date.now() - 6000000}));
assert.ok(canEditPost(state, {PostEditTimeLimit: -1}, licensed, teamId, channelId, userId, {user_id: 'other'}));
assert.ok(canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 100}));
assert.ok(!canEditPost(state, {PostEditTimeLimit: 300}, licensed, teamId, channelId, userId, {user_id: 'other', create_at: Date.now() - 6000000}));
});
});

5
app/mm-redux/utils/post_utils.ts
View file

@ -58,14 +58,15 @@ export function canEditPost(state: GlobalState, config: any, license: any, teamI
}
const isOwner = isPostOwner(userId, post);
let canEdit = true;
let permissions = [];
if (isOwner) {
permissions = [Permissions.EDIT_POST];
} else {
permissions = [Permissions.EDIT_OTHERS_POSTS];
permissions = [Permissions.EDIT_POST, Permissions.EDIT_OTHERS_POSTS];
}
let canEdit = permissions.every((permission) => haveIChannelPermission(state, {team: teamId, channel: channelId, permission, default: false}));
canEdit = permissions.every((permission) => haveIChannelPermission(state, {team: teamId, channel: channelId, permission, default: false}));
if (license.IsLicensed === 'true' && config.PostEditTimeLimit !== '-1' && config.PostEditTimeLimit !== -1) {
const timeLeft = (post.create_at + (config.PostEditTimeLimit * 1000)) - Date.now();
if (timeLeft <= 0) {

4
app/screens/post_options/index.js
View file

@ -27,6 +27,7 @@ import {haveIChannelPermission} from '@mm-redux/selectors/entities/roles';
import {getCurrentTeamId, getCurrentTeamUrl} from '@mm-redux/selectors/entities/teams';
import {getThread} from '@mm-redux/selectors/entities/threads';
import {getCurrentUserId} from '@mm-redux/selectors/entities/users';
import {isMinimumServerVersion} from '@mm-redux/utils/helpers';
import {canEditPost, isPostFlagged, isSystemMessage} from '@mm-redux/utils/post_utils';
import {getDimensions} from '@selectors/device';
import {selectEmojisCountFromReactions} from '@selectors/emojis';
@ -52,6 +53,7 @@ export function makeMapStateToProps() {
const channelIsArchived = channel.delete_at !== 0;
const isSystemPost = isSystemMessage(post);
const hasBeenDeleted = (post.delete_at !== 0 || post.state === Posts.POST_DELETED);
const {serverVersion} = state.entities.general;
let canMarkAsUnread = true;
let canReply = true;
@ -96,7 +98,7 @@ export function makeMapStateToProps() {
} else {
canEdit = canEditPost(state, config, license, currentTeamId, currentChannelId, currentUserId, post);
if (canEdit && license.IsLicensed === 'true' &&
(config.AllowEditPost === General.ALLOW_EDIT_POST_TIME_LIMIT || (config.PostEditTimeLimit !== -1 && config.PostEditTimeLimit !== '-1'))
((config.AllowEditPost === General.ALLOW_EDIT_POST_TIME_LIMIT && !isMinimumServerVersion(serverVersion, 6)) || (config.PostEditTimeLimit !== -1 && config.PostEditTimeLimit !== '-1'))
) {
canEditUntil = post.create_at + (config.PostEditTimeLimit * 1000);
}

37
app/utils/channels.js
View file

@ -22,43 +22,6 @@ export function isFavoriteChannel(preferences, channelId) {
return fav ? fav.value === 'true' : false;
}
export function isDirectChannelAutoClosed(config, preferences, channelId, channelActivity, channelArchiveTime = 0, currentChannelId = '') {
// When the config is not set or is a favorite channel
if (config.CloseUnusedDirectMessages !== 'true' || isFavoriteChannel(preferences, channelId)) {
return false;
}
const cutoff = new Date().getTime() - (7 * 24 * 60 * 60 * 1000);
const viewTimePref = preferences[`${Preferences.CATEGORY_CHANNEL_APPROXIMATE_VIEW_TIME}--${channelId}`];
const viewTime = viewTimePref ? parseInt(viewTimePref.value || 0, 10) : 0;
if (viewTime > cutoff) {
return false;
}
const openTimePref = preferences[`${Preferences.CATEGORY_CHANNEL_OPEN_TIME}--${channelId}`];
const openTime = openTimePref ? parseInt(openTimePref.value || 0, 10) : 0;
// Only close archived channels when not being viewed
if (channelId !== currentChannelId && channelArchiveTime && channelArchiveTime > openTime) {
return true;
}
const autoClose = preferences[`${Preferences.CATEGORY_SIDEBAR_SETTINGS}--close_unused_direct_messages`];
if (!autoClose || autoClose.value === 'after_seven_days') {
if (channelActivity && channelActivity > cutoff) {
return false;
}
if (openTime > cutoff) {
return false;
}
return !channelActivity || channelActivity < cutoff;
}
return false;
}
export function getChannelSinceValue(state, channelId, postIds) {
const lastGetPosts = state.views.channel.lastGetPosts[channelId];
const lastConnectAt = state.websocket?.lastConnectAt || 0;

9
ios/UploadAttachments/UploadAttachments/StoreManager.m
View file

@ -380,7 +380,8 @@
}
NSDictionary *config = [self getConfig];
if (![[config objectForKey:@"CloseUnusedDirectMessages"] isEqualToString:@"true"] || [self isFavoriteChannel:channelId]) {
if ((![[config objectForKey:@"CloseUnusedDirectMessages"] isEqualToString:@"true"] && ![self isMinimumServerVersion:@"6.0.0"])
|| [self isFavoriteChannel:channelId]) {
return NO;
}
@ -415,6 +416,12 @@
return favoritePref != nil && [[favoritePref objectForKey:@"value"] isEqualToString:@"true"];
}
-(BOOL)isMinimumServerVersion:(NSString *)versionId {
NSDictionary *config = [self getConfig];
NSString* currentVersion = [config objectForKey:@"Version"];
return [versionId compare:currentVersion options:NSNumericSearch] == NSOrderedDescending;
}
-(NSNumber *)lastChannelPostActivity:(NSString *)channelId {
NSDictionary *allPosts = [[self.entities objectForKey:@"posts"] objectForKey:@"posts"];
NSDictionary *postsInChannels = [[self.entities objectForKey:@"posts"] objectForKey:@"postsInChannel"];