mattermost-redux/lib/actions/teams.js

Common code (API client, Redux stores, logic, utility functions) for building a Mattermost client

"use strict";
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
// See LICENSE.txt for license information.
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.selectTeam = selectTeam;
exports.getMyTeams = getMyTeams;
exports.getMyTeamUnreads = getMyTeamUnreads;
exports.getTeam = getTeam;
exports.getTeamByName = getTeamByName;
exports.getTeams = getTeams;
exports.searchTeams = searchTeams;
exports.createTeam = createTeam;
exports.deleteTeam = deleteTeam;
exports.unarchiveTeam = unarchiveTeam;
exports.updateTeam = updateTeam;
exports.patchTeam = patchTeam;
exports.regenerateTeamInviteId = regenerateTeamInviteId;
exports.getMyTeamMembers = getMyTeamMembers;
exports.getTeamMembers = getTeamMembers;
exports.getTeamMember = getTeamMember;
exports.getTeamMembersByIds = getTeamMembersByIds;
exports.getTeamsForUser = getTeamsForUser;
exports.getTeamMembersForUser = getTeamMembersForUser;
exports.getTeamStats = getTeamStats;
exports.addUserToTeamFromInvite = addUserToTeamFromInvite;
exports.addUserToTeam = addUserToTeam;
exports.addUsersToTeamGracefully = addUsersToTeamGracefully;
exports.removeUserFromTeam = removeUserFromTeam;
exports.sendEmailInvitesToTeam = sendEmailInvitesToTeam;
exports.sendEmailGuestInvitesToChannels = sendEmailGuestInvitesToChannels;
exports.sendEmailInvitesToTeamGracefully = sendEmailInvitesToTeamGracefully;
exports.sendEmailGuestInvitesToChannelsGracefully = sendEmailGuestInvitesToChannelsGracefully;
exports.sendEmailInvitesToTeamAndChannelsGracefully = sendEmailInvitesToTeamAndChannelsGracefully;
exports.getTeamInviteInfo = getTeamInviteInfo;
exports.checkIfTeamExists = checkIfTeamExists;
exports.setTeamIcon = setTeamIcon;
exports.removeTeamIcon = removeTeamIcon;
exports.updateTeamScheme = updateTeamScheme;
exports.updateTeamMemberSchemeRoles = updateTeamMemberSchemeRoles;
exports.invalidateAllEmailInvites = invalidateAllEmailInvites;
exports.membersMinusGroupMembers = membersMinusGroupMembers;
exports.getInProductNotices = getInProductNotices;
exports.updateNoticesAsViewed = updateNoticesAsViewed;
const redux_batched_actions_1 = require("redux-batched-actions");
const action_types_1 = require("mattermost-redux/action_types");
const channels_1 = require("mattermost-redux/actions/channels");
const errors_1 = require("mattermost-redux/actions/errors");
const helpers_1 = require("mattermost-redux/actions/helpers");
const roles_1 = require("mattermost-redux/actions/roles");
const users_1 = require("mattermost-redux/actions/users");
const client_1 = require("mattermost-redux/client");
const constants_1 = require("mattermost-redux/constants");
const common_1 = require("mattermost-redux/selectors/entities/common");
const teams_1 = require("mattermost-redux/selectors/entities/teams");
const users_2 = require("mattermost-redux/selectors/entities/users");
const event_emitter_1 = __importDefault(require("mattermost-redux/utils/event_emitter"));
async function getProfilesAndStatusesForMembers(userIds, dispatch, getState) {
    const state = getState();
    const { currentUserId, profiles, statuses, } = state.entities.users;
    const enabledUserStatuses = (0, common_1.getIsUserStatusesConfigEnabled)(state);
    const profilesToLoad = [];
    const statusesToLoad = [];
    userIds.forEach((userId) => {
        if (!profiles[userId] && !profilesToLoad.includes(userId) && userId !== currentUserId) {
            profilesToLoad.push(userId);
        }
        if (!statuses[userId] && !statusesToLoad.includes(userId) && userId !== currentUserId) {
            statusesToLoad.push(userId);
        }
    });
    const requests = [];
    if (profilesToLoad.length) {
        requests.push(dispatch((0, users_1.getProfilesByIds)(profilesToLoad)));
    }
    if (statusesToLoad.length && enabledUserStatuses) {
        requests.push(dispatch((0, users_1.getStatusesByIds)(statusesToLoad)));
    }
    await Promise.all(requests);
}
function selectTeam(team) {
    const teamId = (typeof team === 'string') ? team : team.id;
    return {
        type: action_types_1.TeamTypes.SELECT_TEAM,
        data: teamId,
    };
}
function getMyTeams() {
    return (0, helpers_1.bindClientFunc)({
        clientFunc: client_1.Client4.getMyTeams,
        onSuccess: action_types_1.TeamTypes.RECEIVED_TEAMS_LIST,
    });
}
function getMyTeamUnreads(collapsedThreads) {
    return async (dispatch, getState) => {
        let unreads;
        try {
            unreads = await client_1.Client4.getMyTeamUnreads(collapsedThreads);
        }
        catch (error) {
            (0, helpers_1.forceLogoutIfNecessary)(error, dispatch, getState);
            dispatch((0, errors_1.logError)(error));
            return { error };
        }
        dispatch({
            type: action_types_1.TeamTypes.RECEIVED_MY_TEAM_UNREADS,
            data: unreads,
        });
        return { data: unreads };
    };
}
function getTeam(teamId) {
    return (0, helpers_1.bindClientFunc)({
        clientFunc: client_1.Client4.getTeam,
        onSuccess: action_types_1.TeamTypes.RECEIVED_TEAM,
        params: [
            teamId,
        ],
    });
}
function getTeamByName(teamName) {
    return (0, helpers_1.bindClientFunc)({
        clientFunc: client_1.Client4.getTeamByName,
        onSuccess: action_types_1.TeamTypes.RECEIVED_TEAM,
        params: [
            teamName,
        ],
    });
}
function getTeams(page = 0, perPage = constants_1.General.TEAMS_CHUNK_SIZE, includeTotalCount = false, excludePolicyConstrained = false) {
    return async (dispatch, getState) => {
        let data;
        dispatch({ type: action_types_1.TeamTypes.GET_TEAMS_REQUEST, data });
        try {
            data = await client_1.Client4.getTeams(page, perPage, includeTotalCount, excludePolicyConstrained);
        }
        catch (error) {
            (0, helpers_1.forceLogoutIfNecessary)(error, dispatch, getState);
            dispatch({ type: action_types_1.TeamTypes.GET_TEAMS_FAILURE, data });
            dispatch((0, errors_1.logError)(error));
            return { error };
        }
        const actions = [
            {
                type: action_types_1.TeamTypes.RECEIVED_TEAMS_LIST,
                data: includeTotalCount ? data.teams : data,
            },
            {
                type: action_types_1.TeamTypes.GET_TEAMS_SUCCESS,
                data,
            },
        ];
        if (includeTotalCount) {
            actions.push({
                type: action_types_1.TeamTypes.RECEIVED_TOTAL_TEAM_COUNT,
                data: data.total_count,
            });
        }
        dispatch((0, redux_batched_actions_1.batchActions)(actions));
        return { data };
    };
}
function searchTeams(term, opts = {}) {
    return async (dispatch, getState) => {
        dispatch({ type: action_types_1.TeamTypes.GET_TEAMS_REQUEST, data: null });
        let response;
        try {
            response = await client_1.Client4.searchTeams(term, opts);
        }
        catch (error) {
            (0, helpers_1.forceLogoutIfNecessary)(error, dispatch, getState);
            dispatch({ type: action_types_1.TeamTypes.GET_TEAMS_FAILURE, error });
            dispatch((0, errors_1.logError)(error));
            return { error };
        }
        // The type of the response is determined by whether or not page/perPage were set
        let teams;
        if (!opts.page || !opts.per_page) {
            teams = response;
        }
        else {
            teams = response.teams;
        }
        dispatch((0, redux_batched_actions_1.batchActions)([
            {
                type: action_types_1.TeamTypes.RECEIVED_TEAMS_LIST,
                data: teams,
            },
            {
                type: action_types_1.TeamTypes.GET_TEAMS_SUCCESS,
            },
        ]));
        return { data: response };
    };
}
function createTeam(team) {
    return async (dispatch, getState) => {
        let created;
        try {
            created = await client_1.Client4.createTeam(team);
        }
        catch (error) {
            (0, helpers_1.forceLogoutIfNecessary)(error, dispatch, getState);
            dispatch((0, errors_1.logError)(error));
            return { error };
        }
        const member = {
            team_id: created.id,
            user_id: getState().entities.users.currentUserId,
            roles: `${constants_1.General.TEAM_ADMIN_ROLE} ${constants_1.General.TEAM_USER_ROLE}`,
            delete_at: 0,
            msg_count: 0,
            mention_count: 0,
        };
        dispatch((0, redux_batched_actions_1.batchActions)([
            {
                type: action_types_1.TeamTypes.CREATED_TEAM,
                data: created,
            },
            {
                type: action_types_1.TeamTypes.RECEIVED_MY_TEAM_MEMBER,
                data: member,
            },
            {
                type: action_types_1.TeamTypes.SELECT_TEAM,
                data: created.id,
            },
        ]));
        dispatch((0, roles_1.loadRolesIfNeeded)(member.roles.split(' ')));
        return { data: created };
    };
}
function deleteTeam(teamId) {
    return async (dispatch, getState) => {
        try {
            await client_1.Client4.deleteTeam(teamId);
        }
        catch (error) {
            (0, helpers_1.forceLogoutIfNecessary)(error, dispatch, getState);
            dispatch((0, errors_1.logError)(error));
            return { error };
        }
        const entities = getState().entities;
        const { currentTeamId, } = entities.teams;
        const actions = [];
        if (teamId === currentTeamId) {
            event_emitter_1.default.emit('leave_team');
            actions.push({ type: action_types_1.ChannelTypes.SELECT_CHANNEL, data: '' });
        }
        actions.push({
            type: action_types_1.TeamTypes.RECEIVED_TEAM_DELETED,
            data: { id: teamId },
        });
        dispatch((0, redux_batched_actions_1.batchActions)(actions));
        return { data: true };
    };
}
function unarchiveTeam(teamId) {
    return async (dispatch, getState) => {
        let team;
        try {
            team = await client_1.Client4.unarchiveTeam(teamId);
        }
        catch (error) {
            (0, helpers_1.forceLogoutIfNecessary)(error, dispatch, getState);
            dispatch((0, errors_1.logError)(error));
            return { error };
        }
        dispatch({
            type: action_types_1.TeamTypes.RECEIVED_TEAM_UNARCHIVED,
            data: team,
        });
        return { data: true };
    };
}
function updateTeam(team) {
    return (0, helpers_1.bindClientFunc)({
        clientFunc: client_1.Client4.updateTeam,
        onSuccess: action_types_1.TeamTypes.UPDATED_TEAM,
        params: [
            team,
        ],
    });
}
function patchTeam(team) {
    return (0, helpers_1.bindClientFunc)({
        clientFunc: client_1.Client4.patchTeam,
        onSuccess: action_types_1.TeamTypes.PATCHED_TEAM,
        params: [
            team,
        ],
    });
}
function regenerateTeamInviteId(teamId) {
    return (0, helpers_1.bindClientFunc)({
        clientFunc: client_1.Client4.regenerateTeamInviteId,
        onSuccess: action_types_1.TeamTypes.REGENERATED_TEAM_INVITE_ID,
        params: [
            teamId,
        ],
    });
}
function getMyTeamMembers() {
    return async (dispatch) => {
        const getMyTeamMembersFunc = (0, helpers_1.bindClientFunc)({
            clientFunc: client_1.Client4.getMyTeamMembers,
            onSuccess: action_types_1.TeamTypes.RECEIVED_MY_TEAM_MEMBERS,
        });
        const teamMembers = await dispatch(getMyTeamMembersFunc);
        if ('data' in teamMembers && teamMembers.data) {
            const roles = new Set();
            for (const teamMember of teamMembers.data) {
                for (const role of teamMember.roles.split(' ')) {
                    roles.add(role);
                }
            }
            if (roles.size > 0) {
                dispatch((0, roles_1.loadRolesIfNeeded)([...roles]));
            }
        }
        return teamMembers;
    };
}
function getTeamMembers(teamId, page = 0, perPage = constants_1.General.TEAMS_CHUNK_SIZE, options) {
    return (0, helpers_1.bindClientFunc)({
        clientFunc: client_1.Client4.getTeamMembers,
        onRequest: action_types_1.TeamTypes.GET_TEAM_MEMBERS_REQUEST,
        onSuccess: [action_types_1.TeamTypes.RECEIVED_MEMBERS_IN_TEAM, action_types_1.TeamTypes.GET_TEAM_MEMBERS_SUCCESS],
        onFailure: action_types_1.TeamTypes.GET_TEAM_MEMBERS_FAILURE,
        params: [
            teamId,
            page,
            perPage,
            options,
        ],
    });
}
function getTeamMember(teamId, userId) {
    return async (dispatch, getState) => {
        let member;
        try {
            const memberRequest = client_1.Client4.getTeamMember(teamId, userId);
            getProfilesAndStatusesForMembers([userId], dispatch, getState);
            member = await memberRequest;
        }
        catch (error) {
            (0, helpers_1.forceLogoutIfNecessary)(error, dispatch, getState);
            dispatch((0, errors_1.logError)(error));
            return { error };
        }
        dispatch({
            type: action_types_1.TeamTypes.RECEIVED_MEMBERS_IN_TEAM,
            data: [member],
        });
        return { data: member };
    };
}
function getTeamMembersByIds(teamId, userIds) {
    return async (dispatch, getState) => {
        let members;
        try {
            const membersRequest = client_1.Client4.getTeamMembersByIds(teamId, userIds);
            getProfilesAndStatusesForMembers(userIds, dispatch, getState);
            members = await membersRequest;
        }
        catch (error) {
            (0, helpers_1.forceLogoutIfNecessary)(error, dispatch, getState);
            dispatch((0, errors_1.logError)(error));
            return { error };
        }
        dispatch({
            type: action_types_1.TeamTypes.RECEIVED_MEMBERS_IN_TEAM,
            data: members,
        });
        return { data: members };
    };
}
function getTeamsForUser(userId) {
    return (0, helpers_1.bindClientFunc)({
        clientFunc: client_1.Client4.getTeamsForUser,
        onRequest: action_types_1.TeamTypes.GET_TEAMS_REQUEST,
        onSuccess: [action_types_1.TeamTypes.RECEIVED_TEAMS_LIST, action_types_1.TeamTypes.GET_TEAMS_SUCCESS],
        onFailure: action_types_1.TeamTypes.GET_TEAMS_FAILURE,
        params: [
            userId,
        ],
    });
}
function getTeamMembersForUser(userId) {
    return (0, helpers_1.bindClientFunc)({
        clientFunc: client_1.Client4.getTeamMembersForUser,
        onSuccess: action_types_1.TeamTypes.RECEIVED_TEAM_MEMBERS,
        params: [
            userId,
        ],
    });
}
function getTeamStats(teamId) {
    return (0, helpers_1.bindClientFunc)({
        clientFunc: client_1.Client4.getTeamStats,
        onSuccess: action_types_1.TeamTypes.RECEIVED_TEAM_STATS,
        params: [
            teamId,
        ],
    });
}
function addUserToTeamFromInvite(token, inviteId) {
    return (0, helpers_1.bindClientFunc)({
        clientFunc: client_1.Client4.addToTeamFromInvite,
        onRequest: action_types_1.TeamTypes.ADD_TO_TEAM_FROM_INVITE_REQUEST,
        onSuccess: action_types_1.TeamTypes.ADD_TO_TEAM_FROM_INVITE_SUCCESS,
        onFailure: action_types_1.TeamTypes.ADD_TO_TEAM_FROM_INVITE_FAILURE,
        params: [
            token,
            inviteId,
        ],
    });
}
function addUserToTeam(teamId, userId) {
    return async (dispatch, getState) => {
        let member;
        try {
            member = await client_1.Client4.addToTeam(teamId, userId);
        }
        catch (error) {
            (0, helpers_1.forceLogoutIfNecessary)(error, dispatch, getState);
            dispatch((0, errors_1.logError)(error));
            return { error: error };
        }
        dispatch((0, redux_batched_actions_1.batchActions)([
            {
                type: action_types_1.UserTypes.RECEIVED_PROFILE_IN_TEAM,
                data: { id: teamId, user_id: userId },
            },
            {
                type: action_types_1.TeamTypes.RECEIVED_MEMBER_IN_TEAM,
                data: member,
            },
        ]));
        return { data: member };
    };
}
function addUsersToTeamGracefully(teamId, userIds) {
    return async (dispatch, getState) => {
        let result;
        try {
            result = await client_1.Client4.addUsersToTeamGracefully(teamId, userIds);
        }
        catch (error) {
            (0, helpers_1.forceLogoutIfNecessary)(error, dispatch, getState);
            dispatch((0, errors_1.logError)(error));
            return { error };
        }
        const addedMembers = result ? result.filter((m) => !m.error) : [];
        const profiles = addedMembers.map((m) => ({ id: m.user_id }));
        const members = addedMembers.map((m) => m.member);
        dispatch((0, redux_batched_actions_1.batchActions)([
            {
                type: action_types_1.UserTypes.RECEIVED_PROFILES_LIST_IN_TEAM,
                data: profiles,
                id: teamId,
            },
            {
                type: action_types_1.TeamTypes.RECEIVED_MEMBERS_IN_TEAM,
                data: members,
            },
        ]));
        return { data: result };
    };
}
function removeUserFromTeam(teamId, userId) {
    return async (dispatch, getState) => {
        try {
            await client_1.Client4.removeFromTeam(teamId, userId);
        }
        catch (error) {
            (0, helpers_1.forceLogoutIfNecessary)(error, dispatch, getState);
            dispatch((0, errors_1.logError)(error));
            return { error };
        }
        const member = {
            team_id: teamId,
            user_id: userId,
        };
        const actions = [
            {
                type: action_types_1.UserTypes.RECEIVED_PROFILE_NOT_IN_TEAM,
                data: { id: teamId, user_id: userId },
            },
            {
                type: action_types_1.TeamTypes.REMOVE_MEMBER_FROM_TEAM,
                data: member,
            },
        ];
        const state = getState();
        const currentUserId = (0, users_2.getCurrentUserId)(state);
        if (userId === currentUserId) {
            const { channels, myMembers } = state.entities.channels;
            for (const channelMember of Object.values(myMembers)) {
                const channel = channels[channelMember.channel_id];
                if (channel && channel.team_id === teamId) {
                    actions.push({
                        type: action_types_1.ChannelTypes.LEAVE_CHANNEL,
                        data: channel,
                    });
                }
            }
            if (teamId === (0, teams_1.getCurrentTeamId)(state)) {
                actions.push((0, channels_1.selectChannel)(''));
            }
        }
        dispatch((0, redux_batched_actions_1.batchActions)(actions));
        return { data: true };
    };
}
function sendEmailInvitesToTeam(teamId, emails) {
    return (0, helpers_1.bindClientFunc)({
        clientFunc: client_1.Client4.sendEmailInvitesToTeam,
        params: [
            teamId,
            emails,
        ],
    });
}
function sendEmailGuestInvitesToChannels(teamId, channelIds, emails, message) {
    return (0, helpers_1.bindClientFunc)({
        clientFunc: client_1.Client4.sendEmailGuestInvitesToChannels,
        params: [
            teamId,
            channelIds,
            emails,
            message,
        ],
    });
}
function sendEmailInvitesToTeamGracefully(teamId, emails) {
    return (0, helpers_1.bindClientFunc)({
        clientFunc: client_1.Client4.sendEmailInvitesToTeamGracefully,
        params: [
            teamId,
            emails,
        ],
    });
}
function sendEmailGuestInvitesToChannelsGracefully(teamId, channelIds, emails, message, guestMagicLink = false) {
    return (0, helpers_1.bindClientFunc)({
        clientFunc: client_1.Client4.sendEmailGuestInvitesToChannelsGracefully,
        params: [
            teamId,
            channelIds,
            emails,
            message,
            guestMagicLink,
        ],
    });
}
function sendEmailInvitesToTeamAndChannelsGracefully(teamId, channelIds, emails, message) {
    return (0, helpers_1.bindClientFunc)({
        clientFunc: client_1.Client4.sendEmailInvitesToTeamAndChannelsGracefully,
        params: [
            teamId,
            channelIds,
            emails,
            message,
        ],
    });
}
function getTeamInviteInfo(inviteId) {
    return (0, helpers_1.bindClientFunc)({
        clientFunc: client_1.Client4.getTeamInviteInfo,
        onRequest: action_types_1.TeamTypes.TEAM_INVITE_INFO_REQUEST,
        onSuccess: action_types_1.TeamTypes.TEAM_INVITE_INFO_SUCCESS,
        onFailure: action_types_1.TeamTypes.TEAM_INVITE_INFO_FAILURE,
        params: [
            inviteId,
        ],
    });
}
function checkIfTeamExists(teamName) {
    return async (dispatch, getState) => {
        let data;
        try {
            data = await client_1.Client4.checkIfTeamExists(teamName);
        }
        catch (error) {
            (0, helpers_1.forceLogoutIfNecessary)(error, dispatch, getState);
            dispatch((0, errors_1.logError)(error));
            return { error };
        }
        return { data: data.exists };
    };
}
function setTeamIcon(teamId, imageData) {
    return async (dispatch) => {
        await client_1.Client4.setTeamIcon(teamId, imageData);
        const team = await client_1.Client4.getTeam(teamId);
        dispatch({
            type: action_types_1.TeamTypes.PATCHED_TEAM,
            data: team,
        });
        return { data: { status: 'OK' } };
    };
}
function removeTeamIcon(teamId) {
    return async (dispatch) => {
        await client_1.Client4.removeTeamIcon(teamId);
        const team = await client_1.Client4.getTeam(teamId);
        dispatch({
            type: action_types_1.TeamTypes.PATCHED_TEAM,
            data: team,
        });
        return { data: { status: 'OK' } };
    };
}
function updateTeamScheme(teamId, schemeId) {
    return (0, helpers_1.bindClientFunc)({
        clientFunc: async () => {
            await client_1.Client4.updateTeamScheme(teamId, schemeId);
            return { teamId, schemeId };
        },
        onSuccess: action_types_1.TeamTypes.UPDATED_TEAM_SCHEME,
    });
}
function updateTeamMemberSchemeRoles(teamId, userId, isSchemeUser, isSchemeAdmin) {
    return (0, helpers_1.bindClientFunc)({
        clientFunc: async () => {
            await client_1.Client4.updateTeamMemberSchemeRoles(teamId, userId, isSchemeUser, isSchemeAdmin);
            return { teamId, userId, isSchemeUser, isSchemeAdmin };
        },
        onSuccess: action_types_1.TeamTypes.UPDATED_TEAM_MEMBER_SCHEME_ROLES,
    });
}
function invalidateAllEmailInvites() {
    return (0, helpers_1.bindClientFunc)({
        clientFunc: client_1.Client4.invalidateAllEmailInvites,
    });
}
function membersMinusGroupMembers(teamID, groupIDs, page = 0, perPage = constants_1.General.PROFILE_CHUNK_SIZE) {
    return (0, helpers_1.bindClientFunc)({
        clientFunc: client_1.Client4.teamMembersMinusGroupMembers,
        onSuccess: action_types_1.TeamTypes.RECEIVED_TEAM_MEMBERS_MINUS_GROUP_MEMBERS,
        params: [
            teamID,
            groupIDs,
            page,
            perPage,
        ],
    });
}
function getInProductNotices(teamId, client, clientVersion) {
    return (0, helpers_1.bindClientFunc)({
        clientFunc: client_1.Client4.getInProductNotices,
        params: [
            teamId,
            client,
            clientVersion,
        ],
    });
}
function updateNoticesAsViewed(noticeIds) {
    return (0, helpers_1.bindClientFunc)({
        clientFunc: client_1.Client4.updateNoticesAsViewed,
        params: [
            noticeIds,
        ],
    });
}