Clean frontend files

This commit is contained in:
Romaric Mourgues
2023-04-18 11:22:14 +02:00
parent 1d83a583dc
commit 0ff1cc97d4
547 changed files with 1271 additions and 27036 deletions
@@ -1,24 +1,24 @@
/* eslint-disable @typescript-eslint/no-non-null-assertion */
/* eslint-disable @typescript-eslint/no-empty-function */
/* eslint-disable @typescript-eslint/no-explicit-any */
import { TdriveService } from 'app/features/global/framework/registry-decorator-service';
import { TdriveService } from '@features/global/framework/registry-decorator-service';
import InitService, {
ConsoleConfiguration,
InternalConfiguration,
} from 'app/features/global/services/init-service';
} from '@features/global/services/init-service';
import { AuthProvider } from './provider/auth-provider';
import OIDCAuthProviderService from './provider/oidc/oidc-auth-provider-service';
import InternalAuthProviderService from './provider/internal/internal-auth-provider-service';
import Logger from 'app/features/global/framework/logger-service';
import Logger from '@features/global/framework/logger-service';
import AlertManager from '../../features/global/services/alert-manager-service';
import Languages from 'app/features/global/services/languages-service';
import { UserType } from 'app/features/users/types/user';
import JWT, { JWTDataType } from 'app/features/auth/jwt-storage-service';
import Languages from '@features/global/services/languages-service';
import { UserType } from '@features/users/types/user';
import JWT, { JWTDataType } from '@features/auth/jwt-storage-service';
import UserAPIClient from '../../features/users/api/user-api-client';
import Application from 'app/features/applications/services/application-service';
import LocalStorage from 'app/features/global/framework/local-storage-service';
import Globals from 'app/features/global/services/globals-tdrive-app-service';
import Application from '@features/applications/services/application-service';
import LocalStorage from '@features/global/framework/local-storage-service';
import Globals from '@features/global/services/globals-tdrive-app-service';
type AccountType = 'remote' | 'internal';
export type LoginState =
@@ -1,8 +1,8 @@
/* eslint-disable @typescript-eslint/no-explicit-any */
import LocalStorage from 'app/features/global/framework/local-storage-service';
import LoginService from 'app/features/auth/login-service';
import WindowService from 'app/features/global/utils/window';
import ConsoleAPIClient from 'app/features/console/api/console-api-client';
import LocalStorage from '@features/global/framework/local-storage-service';
import LoginService from '@features/auth/login-service';
import WindowService from '@features/global/utils/window';
import ConsoleAPIClient from '@features/console/api/console-api-client';
import { TdriveService } from '../global/framework/registry-decorator-service';
import Logger from '../global/framework/logger-service';
@@ -1,14 +1,14 @@
/* eslint-disable @typescript-eslint/no-explicit-any */
/* eslint-disable @typescript-eslint/no-empty-function */
import Logger from 'app/features/global/framework/logger-service';
import Observable from 'app/deprecated/CollectionsV1/observable.js';
import WindowState from 'app/features/global/utils/window';
import Globals from 'app/features/global/services/globals-tdrive-app-service';
import Logger from '@features/global/framework/logger-service';
import Observable from '@deprecated/CollectionsV1/observable.js';
import WindowState from '@features/global/utils/window';
import Globals from '@features/global/services/globals-tdrive-app-service';
import RouterServices from '../router/services/router-service';
import LocalStorage from 'app/features/global/framework/local-storage-service';
import AuthService from 'app/features/auth/auth-service';
import LocalStorage from '@features/global/framework/local-storage-service';
import AuthService from '@features/auth/auth-service';
import Application from '../applications/services/application-service';
import { UserType } from 'app/features/users/types/user';
import { UserType } from '@features/users/types/user';
import { Cookies } from 'react-cookie';
import InitService from '../global/services/init-service';
@@ -1,4 +1,4 @@
import { JWTDataType } from 'app/features/auth/jwt-storage-service';
import { JWTDataType } from '@features/auth/jwt-storage-service';
type AuthEvent =
| 'userLoaded'
@@ -1,11 +1,11 @@
import Logger from 'app/features/global/framework/logger-service';
import Logger from '@features/global/framework/logger-service';
import { InternalConfiguration } from '../../../global/services/init-service';
import Observable from '../../../../deprecated/Observable/Observable';
import { TdriveService } from '../../../global/framework/registry-decorator-service';
import { AuthProvider, InitParameters } from '../auth-provider';
import Globals from 'app/features/global/services/globals-tdrive-app-service';
import RouterService from 'app/features/router/services/router-service';
import ConsoleAPIClient from 'app/features/console/api/console-api-client';
import Globals from '@features/global/services/globals-tdrive-app-service';
import RouterService from '@features/router/services/router-service';
import ConsoleAPIClient from '@features/console/api/console-api-client';
export type SignInParameters = {
username: string;
@@ -3,14 +3,14 @@ import Oidc from 'oidc-client';
import environment from '../../../../environment/environment';
import { ConsoleConfiguration } from '../../../global/services/init-service';
import Observable from '../../../../deprecated/Observable/Observable';
import Logger from 'app/features/global/framework/logger-service';
import { getAsFrontUrl } from 'app/features/global/utils/URLUtils';
import Logger from '@features/global/framework/logger-service';
import { getAsFrontUrl } from '@features/global/utils/URLUtils';
import { TdriveService } from '../../../global/framework/registry-decorator-service';
import EnvironmentService from '../../../global/framework/environment-service';
import { AuthProvider, InitParameters } from '../auth-provider';
import ConsoleService from 'app/features/console/services/console-service';
import jwtStorageService, { JWTDataType } from 'app/features/auth/jwt-storage-service';
import LocalStorage from 'app/features/global/framework/local-storage-service';
import ConsoleService from '@features/console/services/console-service';
import jwtStorageService, { JWTDataType } from '@features/auth/jwt-storage-service';
import LocalStorage from '@features/global/framework/local-storage-service';
const OIDC_CALLBACK_URL = '/oidccallback';
const OIDC_SIGNOUT_URL = '/signout';
@@ -96,7 +96,7 @@ export default class OIDCAuthProviderService
try {
await this.userManager!.signinRedirectCallback();
} catch (e) {
console.log("Not connected, connect through SSO");
console.log('Not connected, connect through SSO');
}
const user = await this.userManager?.getUser();
@@ -1,51 +0,0 @@
import { ChannelMemberType } from 'app/features/channel-members-search/types/channel-members';
import Api from 'app/features/global/framework/api-service';
import { TdriveService } from 'app/features/global/framework/registry-decorator-service';
import { WebsocketRoom } from 'app/features/global/types/websocket-types';
import {
ParamsChannelMember,
PayloadChannelMemberType,
ResponseChannelMemberType,
ResponseChannelMemberTypeList,
} from '../types/channel-members';
@TdriveService('ChannelMemberAPIClientService')
class ChannelMembersApiClient {
private readonly apiBaseUrl: string = '/internal/services/channels/v1/companies';
private _realtime: WebsocketRoom = { room: '', token: '' };
public get realtime(): WebsocketRoom {
return this._realtime;
}
public set realtime(value: WebsocketRoom) {
this._realtime = value;
}
async getMembers(params: ParamsChannelMember, search?: string) {
console.log('getMembers ....', params);
return Api.get<ResponseChannelMemberTypeList>(
`${this.apiBaseUrl}/${params.companyId}/workspaces/${params.workspaceId}/channels/${
params.channelId
}/members?websockets=1${search ? `&search=${search}` : ''}`,
).then(({ websockets, resources }) => {
if (websockets) this.realtime = websockets[0];
return resources;
});
}
async addMember(member: Partial<ChannelMemberType>, params: ParamsChannelMember) {
return Api.post<PayloadChannelMemberType, ResponseChannelMemberType>(
`${this.apiBaseUrl}/${params.companyId}/workspaces/${params.workspaceId}/channels/${params.channelId}/members`,
{ resource: member },
).then(({ resource }) => resource);
}
async deleteMember(memberId: string, params: ParamsChannelMember) {
return Api.delete<ResponseChannelMemberType>(
`${this.apiBaseUrl}/${params.companyId}/workspaces/${params.workspaceId}/channels/${params.channelId}/members/${memberId}`,
).then(({ resource }) => {
return resource;
});
}
}
export default new ChannelMembersApiClient();
@@ -1,49 +0,0 @@
import Api from "app/features/global/framework/api-service";
import { TdriveService } from "app/features/global/framework/registry-decorator-service";
import { ChannelPendingEmail, ChannelPendingEmailResponse, ParamsChannelMember, PayloadChannelPendingEmail, ResponseChannelPendingEmail, ResponseDeletePendingEmailResponse } from "../types/channel-members";
@TdriveService('ChannelPendingEmailMemberAPIClientService')
class ChannelPendingEmailApiClient {
private readonly apiBaseUrl: string = '/internal/services/channels/v1/companies';
async list(params: ParamsChannelMember) {
const { companyId, workspaceId, channelId } = params;
return Api.get<ChannelPendingEmailResponse>(
`${this.apiBaseUrl}/${companyId}/workspaces/${workspaceId}/channels/${channelId}/pending_emails`,
).then(({resources}) => resources);
}
async get(email: string, params: ParamsChannelMember) {
const { companyId, workspaceId, channelId } = params;
return Api.get<ChannelPendingEmail>(
`${this.apiBaseUrl}/${companyId}/workspaces/${workspaceId}/channels/${channelId}/pending_emails/${email}`,
);
}
async add(
guest: Partial<ChannelPendingEmail>,
params: ParamsChannelMember,
) {
const { companyId, workspaceId, channelId } = params;
return Api.post<PayloadChannelPendingEmail, ResponseChannelPendingEmail>(
`${this.apiBaseUrl}/${companyId}/workspaces/${workspaceId}/channels/${channelId}/pending_emails`,
{ resource: guest }
).then(({resource}) => resource);
}
async delete(
email: string,
params: ParamsChannelMember,
) {
const { companyId, workspaceId, channelId } = params;
return Api.delete<ResponseDeletePendingEmailResponse>(
`${this.apiBaseUrl}/${companyId}/workspaces/${workspaceId}/channels/${channelId}/pending_emails/${email}`,
);
}
}
export default new ChannelPendingEmailApiClient();
@@ -1,111 +0,0 @@
import ChannelMembersAPIClient from 'app/features/channel-members-search/api/members-api-client';
import ChannelCurrentMemberAPIClient from 'app/features/channel-members/api/channel-members-api-client';
import { useChannel } from 'app/features/channels/hooks/use-channel';
import {
useDirectChannels,
} from 'app/features/channels/hooks/use-direct-channels';
import { useFavoriteChannels } from 'app/features/channels/hooks/use-favorite-channels';
import {
usePublicOrPrivateChannels,
useRefreshPublicOrPrivateChannels,
} from 'app/features/channels/hooks/use-public-or-private-channels';
import useRouterChannel from 'app/features/router/hooks/use-router-channel';
import useRouterCompany from 'app/features/router/hooks/use-router-company';
import useRouterWorkspace from 'app/features/router/hooks/use-router-workspace';
import { useCurrentUser } from 'app/features/users/hooks/use-current-user';
import { useState } from 'react';
import { useRecoilValue } from 'recoil';
import { ChannelMemberSelector } from '../state/store';
import { ChannelMemberType, ParamsChannelMember } from '../types/channel-members';
import { useRefreshChannelMembers } from './members-hook';
export function useChannelMemberCurrentUser(channelId: string) {
const { favoriteChannels, refresh: refreshAllChannels } = useFavoriteChannels();
const { directChannels } = useDirectChannels();
const { publicChannels, privateChannels } = usePublicOrPrivateChannels();
const { channel } = useChannel(channelId);
const { user } = useCurrentUser();
const member = [...publicChannels, ...privateChannels, ...directChannels].find(
c => c.id === channelId,
)?.user_member;
return {
member,
favorite: favoriteChannels?.find(favoriteChannel => favoriteChannel.id === channel?.id),
setFavorite: async (favorite: boolean) => {
await ChannelCurrentMemberAPIClient.updateChannelMemberPreferences(
member as ChannelMemberType,
{ favorite },
{
companyId: channel.company_id || '',
workspaceId: channel.workspace_id || '',
channelId: channel.id || '',
userId: user?.id || '',
},
);
await refreshAllChannels();
},
setNotificationPreference: async (preference: 'all' | 'none' | 'mentions' | 'me') => {
if (channel.company_id && channel.workspace_id && channel.id && user?.id) {
await ChannelCurrentMemberAPIClient.updateChannelMemberPreferences(
member as ChannelMemberType,
{ notification_level: preference },
{
companyId: channel.company_id,
workspaceId: channel.workspace_id,
channelId: channel.id,
userId: user?.id,
},
);
await refreshAllChannels();
}
},
};
}
export function useChannelMember(userId: string, params?: ParamsChannelMember) {
const channelId = params?.channelId ? params.channelId : useRouterChannel();
const workspaceId = params?.workspaceId ? params.workspaceId : useRouterWorkspace();
const companyId = params?.companyId ? params.companyId : useRouterCompany();
const parameters = { companyId, workspaceId, channelId };
const member = useRecoilValue(ChannelMemberSelector({ channelId, userId }));
const { refresh } = useRefreshChannelMembers(parameters);
const { refresh: refreshChannelsBar } = useRefreshPublicOrPrivateChannels();
const [loading, setLoading] = useState<boolean>(false);
const leave = async (userId: string) => {
setLoading(true);
await ChannelMembersAPIClient.deleteMember(userId, {
companyId,
workspaceId,
channelId,
});
refresh();
refreshChannelsBar();
setLoading(false);
};
const addMember = async (userId: string) => {
setLoading(true);
await ChannelMembersAPIClient.addMember(
{ user_id: userId },
{
companyId,
workspaceId,
channelId,
},
);
setLoading(false);
refresh();
};
return {
member,
refresh,
leave,
addMember,
loading,
};
}
@@ -1,59 +0,0 @@
import ChannelMembersApiClient from 'app/features/channel-members-search/api/members-api-client';
import { useGlobalEffect } from 'app/features/global/hooks/use-global-effect';
import { useRecoilState } from 'recoil';
import { ChannelMemberWithUser, ParamsChannelMember } from '../types/channel-members';
import { ListChannelMembersStateFamily } from '../state/store';
import { LoadingState } from 'app/features/global/state/atoms/Loading';
import useRouterCompany from 'app/features/router/hooks/use-router-company';
import useRouterChannel from 'app/features/router/hooks/use-router-channel';
import useRouterWorkspace from 'app/features/router/hooks/use-router-workspace';
export const useRefreshChannelMembers = (parameters: ParamsChannelMember) => {
const [members, setMembers] = useRecoilState(ListChannelMembersStateFamily(parameters));
const [loading, setLoading] = useRecoilState(LoadingState('useChannelMembers'));
const refresh = async () => {
setLoading(true);
const listMembers = await ChannelMembersApiClient.getMembers(parameters);
if (listMembers) {
setMembers(listMembers);
}
setLoading(false);
};
return {
channelMembers: members,
loading,
refresh,
};
};
export function useChannelMembers(params?: ParamsChannelMember): {
channelMembers: ChannelMemberWithUser[];
loading: boolean;
refresh: () => Promise<void>;
} {
const companyId = params?.companyId ? params.companyId : useRouterCompany();
const workspaceId = params?.workspaceId ? params.workspaceId : useRouterWorkspace();
const channelId = params?.channelId ? params.channelId : useRouterChannel();
const parameters = { companyId, workspaceId, channelId };
const { refresh, channelMembers, loading } = useRefreshChannelMembers(parameters);
//Will be called once only
useGlobalEffect(
'useChannelMembers',
() => {
refresh();
},
[],
);
return {
channelMembers,
loading,
refresh,
};
}
@@ -1,78 +0,0 @@
import ChannelMembersAPIClient from 'app/features/channel-members-search/api/members-api-client';
import { useGlobalEffect } from 'app/features/global/hooks/use-global-effect';
import { LoadingState } from 'app/features/global/state/atoms/Loading';
import { delayRequest } from 'app/features/global/utils/managedSearchRequest';
import { matchQuery } from 'app/features/global/utils/strings';
import useRouterChannel from 'app/features/router/hooks/use-router-channel';
import useRouterCompany from 'app/features/router/hooks/use-router-company';
import useRouterWorkspace from 'app/features/router/hooks/use-router-workspace';
import _ from 'lodash';
import { useRecoilState, useRecoilValue, useSetRecoilState } from 'recoil';
import { SearchChannelMemberInputState } from '../state/search-channel-member';
import { ListChannelMembersStateFamily } from '../state/store';
import { ParamsChannelMember, ChannelMemberWithUser } from '../types/channel-members';
export const useRefreshSearchChannelMembers = (context: ParamsChannelMember) => {
const searchInput = useRecoilValue(SearchChannelMemberInputState);
const setLoading = useSetRecoilState(LoadingState('useSearchChannelMembers'));
const [listChannelMembers, setChannelMembers] = useRecoilState<ChannelMemberWithUser[]>(
ListChannelMembersStateFamily(context),
);
const refresh = async () => {
setLoading(true);
const response = await ChannelMembersAPIClient.getMembers(context, searchInput);
setChannelMembers(_.uniqBy([...listChannelMembers, ...response], 'user_id'));
setLoading(false);
};
return {
refresh,
listChannelMembers,
};
};
export const useSearchChannelMembers = (channelId: string) => {
const companyId = useRouterCompany();
const workspaceId = useRouterWorkspace();
const context: ParamsChannelMember = {
companyId,
workspaceId,
channelId: channelId ? channelId : useRouterChannel(),
};
const searchInput = useRecoilValue(SearchChannelMemberInputState);
const [loading, setLoading] = useRecoilState(LoadingState('useSearchChannelMembers'));
const { refresh, listChannelMembers } = useRefreshSearchChannelMembers(context);
useGlobalEffect(
'useSearchChannelMembers',
() => {
(async () => {
setLoading(true);
if (searchInput) {
delayRequest('useSearchChannelMembers', async () => {
await refresh();
});
}
})();
},
[searchInput],
);
const listChannelMembersFiltered = listChannelMembers.filter(cm => {
if (!cm.user) return false;
return matchQuery(
searchInput,
`${cm.user.email} ${cm.user.first_name} ${cm.user.last_name} ${cm.user.username}`,
);
});
return {
refresh,
loading,
listChannelMembers: listChannelMembersFiltered,
};
};
@@ -1,22 +0,0 @@
import { useRecoilValue } from 'recoil';
import { SearchChannelMemberInputState } from '../state/search-channel-member';
import { ParamsChannelMember } from '../types/channel-members';
import { useChannelPendingEmails } from './use-pending-emails';
export const useSearchChannelPendingEmail = (params?: ParamsChannelMember) => {
const searchInput = useRecoilValue(SearchChannelMemberInputState);
const { pendingEmails } = useChannelPendingEmails(params);
let filteredList = pendingEmails;
if (searchInput) {
filteredList = pendingEmails.filter(({ email }) => {
return searchInput.split(' ').every(() => {
return email.includes(searchInput);
});
});
}
return {
filteredPendingEmails: filteredList,
};
};
@@ -1,21 +0,0 @@
import { useSearchUsers } from 'app/features/users/hooks/use-search-user-list';
import { useRecoilValue } from 'recoil';
import { SearchChannelMemberInputState } from '../state/search-channel-member';
export const useSearchFilteredUsers = () => {
const searchInput = useRecoilValue(SearchChannelMemberInputState);
const { result: filteredUsers } = useSearchUsers({ scope: 'company' });
let filteredList = filteredUsers;
if (searchInput) {
filteredList = filteredUsers.filter(({ email }) => {
return searchInput.split(' ').every(item => {
return email.includes(item);
});
});
}
return {
filteredPendingEmails: filteredList,
};
};
@@ -1,71 +0,0 @@
import ChannelPendingEmailApiClient from 'app/features/channel-members-search/api/pending-emails-api-client';
import ConsoleService from 'app/features/console/services/console-service';
import useRouterChannel from 'app/features/router/hooks/use-router-channel';
import useRouterCompany from 'app/features/router/hooks/use-router-company';
import useRouterWorkspace from 'app/features/router/hooks/use-router-workspace';
import { useState } from 'react';
import { useRecoilValue, useSetRecoilState } from 'recoil';
import { SearchChannelMemberInputState } from '../state/search-channel-member';
import { PendingEmailSelector } from '../state/store';
import { useChannelPendingEmails } from './use-pending-emails';
export function usePendingEmail(email: string) {
const companyId = useRouterCompany();
const workspaceId = useRouterWorkspace();
const channelId = useRouterChannel();
const pEmail = useRecoilValue(PendingEmailSelector({ channelId, email }));
const { refresh } = useChannelPendingEmails();
const [loading, setLoading] = useState<boolean>(false);
const setSearchState = useSetRecoilState(SearchChannelMemberInputState);
const cancelInvite = async () => {
setLoading(true);
await ChannelPendingEmailApiClient.delete(email, {
companyId,
workspaceId,
channelId,
}).then(() => {
setLoading(false);
refresh();
});
};
const addInvite = async (role: 'guest' | 'member' = 'guest') => {
setLoading(true);
const guest = {
workspace_id: workspaceId,
channel_id: channelId,
company_id: companyId,
email: email,
};
await ChannelPendingEmailApiClient.add(guest, {
companyId,
workspaceId,
channelId,
}).then(() => {
setLoading(false);
setSearchState('');
refresh();
});
await ConsoleService.addMailsInWorkspace({
workspace_id: workspaceId,
company_id: companyId,
emails: [email],
workspace_role: 'member',
company_role: role,
});
};
return {
loading,
email: pEmail,
cancelInvite,
addInvite,
};
}
@@ -1,48 +0,0 @@
import { LoadingState } from 'app/features/global/state/atoms/Loading';
import useRouterChannel from 'app/features/router/hooks/use-router-channel';
import useRouterCompany from 'app/features/router/hooks/use-router-company';
import useRouterWorkspace from 'app/features/router/hooks/use-router-workspace';
import { useRecoilState } from 'recoil';
import { ListPendingEmailsStateFamily } from '../state/store';
import { ChannelPendingEmail, ParamsChannelMember } from '../types/channel-members';
import ChannelPendingEmailApiClient from 'app/features/channel-members-search/api/pending-emails-api-client';
import { useGlobalEffect } from 'app/features/global/hooks/use-global-effect';
export function useChannelPendingEmails(params?: ParamsChannelMember): {
pendingEmails: ChannelPendingEmail[];
loading: boolean;
refresh: () => Promise<void>;
} {
const companyId = params?.companyId ? params.companyId : useRouterCompany();
const channelId = params?.companyId ? params.companyId : useRouterChannel();
const workspaceId = params?.companyId ? params.companyId : useRouterWorkspace();
const parameters = { companyId, workspaceId, channelId };
const [loading, setLoading] = useRecoilState(LoadingState('useChannelPendingEmails'));
const [emails, setEmails] = useRecoilState(ListPendingEmailsStateFamily(parameters));
const refresh = async () => {
setLoading(true);
const listPendingEmails = await ChannelPendingEmailApiClient.list(parameters);
if (listPendingEmails) {
setEmails(listPendingEmails);
}
setLoading(false);
};
useGlobalEffect(
'useChannelPendingEmails',
() => {
refresh();
},
[channelId],
);
return {
pendingEmails: emails,
loading,
refresh,
};
}
@@ -1,60 +0,0 @@
import { useSearchUsers } from 'app/features/users/hooks/use-search-user-list';
import { UserType } from 'app/features/users/types/user';
import _ from 'lodash';
import { useEffect } from 'react';
import { useRecoilState } from 'recoil';
import { SearchChannelMemberInputState } from '../state/search-channel-member';
import { ChannelMemberWithUser, ParamsChannelMember } from '../types/channel-members';
import { useChannelMembers } from './members-hook';
import { useSearchChannelMembers } from './search-channel-member';
import { useSearchChannelPendingEmail } from './search-pending-email';
import { useChannelPendingEmails } from './use-pending-emails';
export const useSearchChannelMembersAll = (params: ParamsChannelMember) => {
const { channelMembers } = useChannelMembers(params);
const { listChannelMembers, refresh: refreshMembers } = useSearchChannelMembers(
params?.channelId || '',
);
const [searchState, setSearchState] = useRecoilState(SearchChannelMemberInputState);
const { pendingEmails } = useChannelPendingEmails(params);
const { filteredPendingEmails } = useSearchChannelPendingEmail(params);
const { result: usersList, search: searchUsers } = useSearchUsers({ scope: 'company' });
const pendingEmailList = searchState ? filteredPendingEmails : pendingEmails;
const channelMembersList = searchState ? listChannelMembers : channelMembers;
const refresh = async () => {
await refreshMembers();
searchUsers(searchState || '');
};
useEffect(() => {
searchUsers(searchState);
}, [searchState]);
const addEmailSuggestion =
!pendingEmailList.length &&
!!searchState.length &&
![
...pendingEmailList.map(e => e?.email.toLocaleLowerCase()),
...channelMembersList.map(e => e.user?.email.toLocaleLowerCase()),
...usersList.map(e => e?.email.toLocaleLowerCase()),
].includes((searchState || '').toLocaleLowerCase());
return {
addEmailSuggestion,
usersList: _.differenceBy(
usersList,
channelMembersList || [],
item => (item as ChannelMemberWithUser).user_id || (item as UserType).id,
),
pendingEmailList,
channelMembersList,
search: setSearchState,
query: searchState,
refresh,
};
};
@@ -1,19 +0,0 @@
import { atom, useRecoilState } from "recoil";
export const SearchChannelMemberInputState = atom<string>({
key: 'SearchChannelMemberInputState',
default: ''
});
const UsersSearchModalOpenState = atom<boolean>({
key: 'UsersSearchModalOpenState',
default: false
});
export const useUsersSearchModal = () => {
const [open, setOpen] = useRecoilState(UsersSearchModalOpenState);
return {
open,
setOpen,
};
};
@@ -1,55 +0,0 @@
import { atomFamily, selectorFamily, SerializableParam } from 'recoil';
import { ChannelMemberWithUser, ChannelPendingEmail } from '../types/channel-members';
// ChannelMemberType
export const ListChannelMembersStateFamily = atomFamily<ChannelMemberWithUser[], SerializableParam>(
{
key: 'ListChannelMembersStateFamily',
default: [],
},
);
export const ListPendingEmailsStateFamily = atomFamily<ChannelPendingEmail[], SerializableParam>({
key: 'ListPendingEmailsStateFamily',
default: [],
});
export const ChannelMemberSelector = selectorFamily<
ChannelMemberWithUser | null,
{ channelId: string; userId: string }
>({
key: 'ChannelMemberSelector',
get:
({ channelId, userId }) =>
({ get }) => {
const members = get(ListChannelMembersStateFamily(channelId));
const member = (members || []).find(m => m.user_id === userId);
if (member) {
return member;
}
return null;
},
});
export const PendingEmailSelector = selectorFamily<
ChannelPendingEmail | null,
{ channelId: string; email: string }
>({
key: 'PendingEmailSelector',
get:
({ channelId, email }) =>
({ get }) => {
const pendingEmails = get(ListPendingEmailsStateFamily(channelId));
const guest = (pendingEmails || []).find(m => m.email === email);
if (guest) {
return guest;
}
return null;
},
});
@@ -1,62 +0,0 @@
import { WebsocketRoom } from 'app/features/global/types/websocket-types';
import { UserType } from 'app/features/users/types/user';
export type ChannelMemberRole = 'member' | 'guest' | 'bot';
export type ChannelMemberNotificationLevel = 'all' | 'none' | 'mentions' | 'me';
export type ChannelMemberType = {
user_id?: string;
channel_id?: string;
type?: ChannelMemberRole;
last_access?: number; //Timestamp in seconds
last_increment?: number; //Number
favorite?: boolean; //Did the user add this channel to its favorites
notification_level?: ChannelMemberNotificationLevel;
};
export type ParamsChannelMember = {
companyId?: string;
workspaceId?: string;
channelId: string;
};
export type QueryChannelMember = {
search: string;
};
export type ResponseChannelMemberTypeList = {
resources: ChannelMemberWithUser[]; // before ChannelMemberType
websockets: WebsocketRoom[];
};
export type PayloadChannelMemberType = {
resource: Partial<ChannelMemberType>;
};
export type ResponseChannelMemberType = {
resource: ChannelMemberType;
};
export type ChannelPendingEmail = {
workspace_id: string;
channel_id: string;
company_id: string;
email: string;
};
export type ChannelPendingEmailResponse = {
resources: ChannelPendingEmail[];
};
export type PayloadChannelPendingEmail = {
resource: Partial<ChannelPendingEmail>;
};
export type ResponseChannelPendingEmail = {
resource: ChannelPendingEmail;
};
export type ResponseDeletePendingEmailResponse = { status: 'success' | 'error' };
export type ChannelMemberWithUser = ChannelMemberType & { user: UserType };
@@ -1,111 +0,0 @@
import Api from '../../global/framework/api-service';
import { TdriveService } from '../../global/framework/registry-decorator-service';
import {
ChannelMemberRole,
ChannelMemberType,
} from 'app/features/channel-members/types/channel-member-types';
import { WebsocketRoom } from 'app/features/global/types/websocket-types';
import { ChannelMemberReadSectionType } from '../types/channel-member-read-section-type';
type ChannelMembersSaveRequest = { resource: Partial<ChannelMemberType> };
type ChannelMembersSaveResponse = { resource: ChannelMemberType };
@TdriveService('ChannelMembersAPIClientService')
class ChannelCurrentMemberAPIClientService {
private readonly prefix = '/internal/services/channels/v1/companies';
private realtime: Map<
{ companyId: string; workspaceId: string; channelId: string },
WebsocketRoom[]
> = new Map();
websocket({
companyId,
workspaceId,
channelId,
}: {
companyId: string;
workspaceId: string;
channelId: string;
}): WebsocketRoom[] {
return this.realtime.get({ companyId, workspaceId, channelId }) || [];
}
/**
* Every member of the channel can list members of the channel.
* This returns a list of members in a channel.
*
* @param companyId string
* @param workspaceId string
* @param channelId string
* @returns ChannelMemberType[]
*/
async list(
context: { companyId: string; workspaceId: string; channelId: string },
filters?: { role: ChannelMemberRole },
) {
return Api.get<{ resources: ChannelMemberType[]; websockets: WebsocketRoom[] }>(
`${this.prefix}/${context.companyId}/workspaces/${context.workspaceId}/channels/${
context.channelId
}/members${filters?.role ? `?company_role=${filters.role}` : ''}?websockets=1`,
).then(result => {
result.websockets && this.realtime.set(context, result.websockets);
return result.resources;
});
}
/**
* Channel member can update their own preferences
*
* @param channelMember ChannelMemberType
* @param partialsToUpdate Partial ChannelMemberType
* @param context Execution context of the update
*/
async updateChannelMemberPreferences(
channelMember: ChannelMemberType,
partialsToUpdate: Partial<ChannelMemberType>,
context: { companyId: string; workspaceId: string; channelId: string; userId: string },
) {
return Api.post<ChannelMembersSaveRequest, ChannelMembersSaveResponse>(
`${this.prefix}/${context.companyId}/workspaces/${context.workspaceId}/channels/${context.channelId}/members/${context.userId}`,
{
resource: { ...channelMember, ...partialsToUpdate },
},
).then(result => result.resource);
}
/**
* Get the channel members read sections.
*
* @param context - channel members read sections context
* @returns {Promise<ChannelMemberReadSectionType[]>}
*/
async getChannelMembersReadSections(context: {
companyId: string;
workspaceId: string;
channelId: string;
}): Promise<ChannelMemberReadSectionType[]> {
return Api.get<{ resources: ChannelMemberReadSectionType[] }>(
`${this.prefix}/${context.companyId}/workspaces/${context.workspaceId}/channels/${context.channelId}/members/read_sections`,
).then(({ resources }) => resources);
}
/**
* Get the read sections for a specific member.
*
* @param context - channel member read sections context
* @returns {Promise<ChannelMemberReadSectionType>}
*/
async getChannelMemberReadSection(context: {
companyId: string;
workspaceId: string;
channelId: string;
userId: string;
}): Promise<ChannelMemberReadSectionType> {
return Api.get<{ resource: ChannelMemberReadSectionType }>(
`${this.prefix}/${context.companyId}/workspaces/${context.workspaceId}/channels/${context.channelId}/members/${context.userId}/read_sections`,
).then(({ resource }) => resource);
}
}
const ChannelCurrentMemberAPIClient = new ChannelCurrentMemberAPIClientService();
export default ChannelCurrentMemberAPIClient;
@@ -1,54 +0,0 @@
import { LoadingState } from 'app/features/global/state/atoms/Loading';
import { useRecoilState } from 'recoil';
import ChannelMembersAPIClient from '../api/channel-members-api-client';
import { ChannelMembersReadSectionsStateFamily } from '../state/channel-members-read-sections';
import Numbers from 'app/features/global/utils/Numbers';
export const useChannelMembersReadSections = (
companyId: string,
workspaceId: string,
channelId: string,
) => {
const [loading, setLoading] = useRecoilState(LoadingState('useChannelMembersReadSections'));
const [sections, setSections] = useRecoilState(ChannelMembersReadSectionsStateFamily(channelId));
const refresh = async () => {
setLoading(true);
const sections = await ChannelMembersAPIClient.getChannelMembersReadSections({
companyId,
workspaceId,
channelId,
});
if (sections) {
setSections(sections);
}
setLoading(false);
};
const getMemberReadSection = (userId: string) => {
return sections.find(section => section.user_id === userId && section.channel_id === channelId);
};
const seen = (userId: string, messageId: string): boolean => {
const userSection = getMemberReadSection(userId);
if (!userSection) {
return false;
}
const [start, end] = userSection.read_section;
const startTime = Numbers.timeuuidToDate(start);
const endTime = Numbers.timeuuidToDate(end);
const messageTime = Numbers.timeuuidToDate(messageId);
return startTime <= messageTime && messageTime <= endTime;
};
return {
loading,
sections,
refresh,
getMemberReadSection,
seen,
};
};
@@ -1,12 +0,0 @@
/* eslint-disable @typescript-eslint/no-unused-vars */
import { atomFamily } from 'recoil';
import {
AtomChannelMembersKey,
ChannelMemberType,
} from 'app/features/channel-members/types/channel-member-types';
export const ChannelGuestsState = atomFamily<ChannelMemberType[], AtomChannelMembersKey>({
key: 'ChannelGuestsState',
default: _key => [],
});
@@ -1,39 +0,0 @@
import { atomFamily, selectorFamily } from 'recoil';
import { ChannelMemberReadSectionType } from '../types/channel-member-read-section-type';
export const ChannelMembersReadSectionsStateFamily = atomFamily<ChannelMemberReadSectionType[], string>(
{
key: 'ChannelMembersReadSectionsStateFamily',
default: []
}
);
export const ChannelMembersReadSectionsSelector = selectorFamily<ChannelMemberReadSectionType[], { channelId: string }>(
{
key: 'ChannelMembersReadSectionsSelector',
get: ({ channelId }) => ({ get }) => {
const sections = get(ChannelMembersReadSectionsStateFamily(channelId));
if (sections) {
return sections;
}
return [];
}
}
);
export const ChannelMemberReadSectionSelector = selectorFamily<ChannelMemberReadSectionType | null, { channelId: string; userId: string }>({
key: 'ChannelMemberReadSectionSelector',
get: ({ channelId, userId }) => ({ get }) => {
const sections = get(ChannelMembersReadSectionsStateFamily(channelId));
const section = (sections || []).find(s => s.user_id === userId);
if (section) {
return section;
}
return null;
}
});
@@ -1,12 +0,0 @@
/* eslint-disable @typescript-eslint/no-unused-vars */
import { atomFamily } from 'recoil';
import {
AtomChannelMembersKey,
ChannelMemberType,
} from 'app/features/channel-members/types/channel-member-types';
export const ChannelMembersState = atomFamily<ChannelMemberType[], AtomChannelMembersKey>({
key: 'ChannelMembersState',
default: _key => [],
});
@@ -1,8 +0,0 @@
export type ChannelMemberReadSectionType = {
channel_id: string;
company_id: string;
user_id: string;
read_section: ReadSection;
}
export type ReadSection = [string, string];
@@ -1,19 +0,0 @@
export type ChannelMemberRole = 'member' | 'guest' | 'bot';
export type ChannelMemberNotificationLevel = 'all' | 'none' | 'mentions' | 'me';
export type ChannelMemberType = {
user_id?: string;
channel_id?: string;
type?: ChannelMemberRole;
last_access?: number; //Timestamp in seconds
last_increment?: number; //Number
favorite?: boolean; //Did the user add this channel to its favorites
notification_level?: ChannelMemberNotificationLevel;
};
export type AtomChannelMembersKey = {
companyId: string;
workspaceId: string;
channelId: string;
};
@@ -1,11 +0,0 @@
import { PendingEmail } from 'app/features/pending-emails/types/pending-email';
import { ChannelMemberType } from './channel-member-types';
export type GenericMemberType = 'pending-email' | 'guest';
export type GenericMember = {
key: string;
type: GenericMemberType;
filterString: string;
resource: PendingEmail | ChannelMemberType;
};
@@ -1,5 +0,0 @@
import { ChannelMemberRole } from '../types/channel-member-types';
export const isGuestMember = (role: ChannelMemberRole) => {
return role === 'member';
};
@@ -1,107 +0,0 @@
import Api from '../../global/framework/api-service';
import { ChannelType } from 'app/features/channels/types/channel';
import { TdriveService } from '../../global/framework/registry-decorator-service';
import { delayRequest } from 'app/features/global/utils/managedSearchRequest';
import { removeBadgesNow } from 'app/features/users/hooks/use-notifications';
import Workspace from 'app/deprecated/workspaces/workspaces';
import Logger from 'features/global/framework/logger-service';
const PREFIX = '/internal/services/channels/v1/companies';
export type SearchOptions = {
company_id: string;
page_token?: string;
limit?: number;
};
@TdriveService('ChannelAPIClientService')
class ChannelAPIClientService {
private logger = Logger.getLogger('ChannelAPIClientService');
async getDirect(companyId: string, membersId: string[]) {
return Api.post<{ options: { members: string[] }; resource: unknown }, { resource: ChannelType }>(
`${PREFIX}/${companyId}/workspaces/direct/channels`,
{ options: { members: membersId }, resource: {} },
).then(result => result.resource);
}
async get(companyId: string, workspaceId: string, channelId: string): Promise<ChannelType> {
return Api.get<{ resource: ChannelType }>(
`${PREFIX}/${companyId}/workspaces/${workspaceId}/channels/${channelId}`,
).then(result => result?.resource);
}
async save(
channel: ChannelType,
context: { companyId: string; workspaceId: string; channelId?: string },
) {
return Api.post<{ resource: ChannelType }, { resource: ChannelType }>(
`${PREFIX}/${context.companyId}/workspaces/${context.workspaceId}/channels${
context?.channelId ? `/${context.channelId}` : ''
}`,
{
resource: channel,
},
).then(result => result.resource);
}
async read(
companyId: string,
workspaceId: string,
channelId: string,
{ status = true, requireFocus = false, now = false },
): Promise<void> {
if (requireFocus && !document.hasFocus()) return;
if (status) removeBadgesNow('channel', channelId);
delayRequest(
'reach-end-read-channel-' + channelId,
async () =>
await Api.post<{ value: boolean }, void>(
`${PREFIX}/${companyId}/workspaces/${workspaceId}/channels/${channelId}/read`,
{
value: status,
},
),
{ doInitialCall: now, timeout: 2000 },
);
}
async recent(companyId: string, limit: number): Promise<ChannelType[]> {
try {
const res = await Api.get<{ resources: ChannelType[] }>(
`${PREFIX}/${companyId}/channels/recent?limit=${limit}`,
);
return res.resources;
} catch (e) {
console.error("Can't retrieve channels", e);
return [];
}
}
async search(
searchString: string | null,
options: SearchOptions,
): Promise<{ resources: ChannelType[] }> {
if (!searchString) {
return { resources: await this.recent(options.company_id, options?.limit || 100) };
}
const companyId = options?.company_id || Workspace.currentGroupId;
const query = `/internal/services/channels/v1/companies/${companyId}/search?q=${searchString}`;
const res = await Api.getWithParams<{ resources: ChannelType[] }>(query, options);
this.logger.debug(
`Search by name "${searchString}" with options`,
options,
'. Found',
res.resources.length,
'channels',
);
return res;
}
}
const ChannelAPIClient = new ChannelAPIClientService();
export default ChannelAPIClient;
@@ -1,98 +0,0 @@
import Api from '../../global/framework/api-service';
import { ChannelType } from 'app/features/channels/types/channel';
import { TdriveService } from '../../global/framework/registry-decorator-service';
import { WebsocketRoom } from '../../global/types/websocket-types';
type ChannelsMineGetResponse = { resources: ChannelType[]; websockets: WebsocketRoom[] };
type ChannelsMineDeleteBaseResponse = {
statusCode: number;
error: string;
message: string;
};
@TdriveService('ChannelsMineAPIClientService')
class ChannelsMineAPIClient {
private readonly prefix = '/internal/services/channels/v1/companies';
private readonly realtime: Map<string, WebsocketRoom[]> = new Map();
websockets(companyId: string, workspaceId: string): WebsocketRoom[] {
return this.realtime.get(this.getRealtimeKey(companyId, workspaceId)) || [];
}
getRealtimeKey(companyId: string, workspaceId: string) {
return `/companies/${companyId}/workspaces/${workspaceId}/channels`;
}
async save(
channel: ChannelType,
context: { companyId: string; workspaceId: string; channelId?: string },
) {
return Api.post<{ resource: ChannelType }, { resource: ChannelType }>(
`${this.prefix}/${context.companyId}/workspaces/${context.workspaceId}/channels${
context?.channelId ? `/${context.channelId}` : ''
}`,
{
resource: channel,
},
).then(result => result.resource);
}
/**
* @param companyId
* @param workspaceId
* @return channels that user is already a member
*/
async get(context: { companyId: string; workspaceId?: string }): Promise<ChannelType[]> {
context.workspaceId = context.workspaceId || 'direct';
return Api.get<ChannelsMineGetResponse>(
`${this.prefix}/${context.companyId}/workspaces/${
context.workspaceId
}/channels?mine=1&websockets=1${context.workspaceId == 'direct' ? '&include_users=1' : ''}`,
).then(result => {
this.realtime.set(
this.getRealtimeKey(context.companyId, context.workspaceId as string),
result.websockets,
);
return result.resources;
});
}
/**
* Remove user from a channel.
* Every user in the channel (except guests) can remove an user.
* A system message will be sent.
* We cannot call this route for direct channels.
* @param userId string
* @param context companyId - workspaceId - channelId
*/
async removeUser(
userId: string,
context: { companyId: string; workspaceId: string; channelId: string },
): Promise<ChannelsMineDeleteBaseResponse> {
return Api.delete<ChannelsMineDeleteBaseResponse>(
`${this.prefix}/${context.companyId}/workspaces/${context.workspaceId}/channels/${context.channelId}/members/${userId}`,
);
}
/**
* Remove a channel, this action is not reversible.
* Direct channels can not be removed.
* Only administrators and channel owner can remove a channel.
* @param companyId string
* @param workspaceId string
* @param channelId string
*
*/
removeChannel(
companyId: string,
workspaceId: string,
channelId: string,
): Promise<ChannelsMineDeleteBaseResponse> {
return Api.delete<ChannelsMineDeleteBaseResponse>(
`${this.prefix}/${companyId}/workspaces/${workspaceId}/channels/${channelId}`,
);
}
}
export default new ChannelsMineAPIClient();
@@ -1,52 +0,0 @@
import {
ChannelsReachableGetResponse,
ChannelsReachableInviteUserRequest,
ChannelsReachableInviteUserResponse,
} from 'app/features/channels/types/channels-reachable-types';
import Api from '../../global/framework/api-service';
import { ChannelType } from 'app/features/channels/types/channel';
import { TdriveService } from '../../global/framework/registry-decorator-service';
import { ChannelMemberType } from 'app/features/channel-members/types/channel-member-types';
@TdriveService('ChannelsReachableAPIClientService')
class ChannelsReachableAPIClientService {
private readonly prefix = '/internal/services/channels/v1/companies';
/**
* @param companyId
* @param workspaceId
* @return channels that user is not a member but could join
*/
async get(companyId: string, workspaceId: string): Promise<ChannelType[]> {
return Api.get<ChannelsReachableGetResponse>(
`${this.prefix}/${companyId}/workspaces/${workspaceId}/channels`,
).then(result => result.resources);
}
/**
* Add user to a channel.
* Every user in the channel (except guests) can invite or remove someone.
* A system message will be sent on invitations.
* @param companyId string
* @param workspaceId string
* @param userId string
*
*/
async inviteUser(
companyId: string,
workspaceId: string,
channelId: string,
userId: string,
): Promise<ChannelMemberType> {
return Api.post<ChannelsReachableInviteUserRequest, ChannelsReachableInviteUserResponse>(
`${this.prefix}/${companyId}/workspaces/${workspaceId}/channels/${channelId}/members`,
{
resource: {
user_id: userId,
},
},
).then(result => result.resource);
}
}
const ChannelsReachableAPIClient = new ChannelsReachableAPIClientService();
export default ChannelsReachableAPIClient;
@@ -1,46 +0,0 @@
/* eslint-disable @typescript-eslint/no-explicit-any */
import { useEffect } from 'react';
import useRouterWorkspace from 'app/features/router/hooks/use-router-workspace';
import useRouterChannel from 'app/features/router/hooks/use-router-channel';
import RouterServices from 'app/features/router/services/router-service';
import { useDirectChannels } from './use-direct-channels';
import { usePublicOrPrivateChannels } from './use-public-or-private-channels';
import LocalStorage from 'app/features/global/framework/local-storage-service';
const fromLocalStorage = LocalStorage.getItem('default_channel_id_per_workspace');
const activeChannelPerWorkspace: { [key: string]: string } =
(typeof fromLocalStorage === 'object' ? (fromLocalStorage as any) : {}) || {};
export function useAutoSelectChannel() {
const workspaceId = useRouterWorkspace();
const channelId = useRouterChannel();
const { directChannels } = useDirectChannels();
const { publicChannels, privateChannels } = usePublicOrPrivateChannels();
const channels = [...directChannels, ...publicChannels, ...privateChannels];
useEffect(() => {
if (channelId) {
activeChannelPerWorkspace[workspaceId] = channelId;
LocalStorage.setItem('default_channel_id_per_workspace', activeChannelPerWorkspace);
}
}, [channelId]);
useEffect(() => {
if (!channelId && channels.length > 0) {
let preferedChannelId = activeChannelPerWorkspace[workspaceId];
if (!preferedChannelId || !channels.find(c => c.id === preferedChannelId)) {
preferedChannelId =
channels.sort((a, b) => (b.last_activity || 0) - (a.last_activity || 0))[0]?.id ||
preferedChannelId;
}
if (preferedChannelId) {
const url = RouterServices.generateRouteFromState({
channelId: preferedChannelId,
});
RouterServices.replace(url);
}
}
}, [workspaceId, channels.length > 0]);
}
@@ -1,111 +0,0 @@
import { useRecoilState } from 'recoil';
import useRouterChannel from 'app/features/router/hooks/use-router-channel';
import useRouterCompany from 'app/features/router/hooks/use-router-company';
import useRouterWorkspace from 'app/features/router/hooks/use-router-workspace';
import { LoadingState } from 'app/features/global/state/atoms/Loading';
import messageApiClient from 'app/features/messages/api/message-api-client';
import { useGlobalEffect } from 'app/features/global/hooks/use-global-effect';
import {
channelAttachmentFileState,
channelAttachmentListState,
channelAttachmentMediaState,
} from '../state/channel-attachment-list';
import _ from 'lodash';
export const useChannelAttachmentList = (type: 'file' | 'media') => {
const limit = 25;
const companyId = useRouterCompany();
const workspaceId = useRouterWorkspace();
const channelId = useRouterChannel();
const [loading, setLoading] = useRecoilState(
LoadingState(`useChannelAttachmentList-${type}-${companyId}-${workspaceId}-${channelId}`),
);
const [isOpen] = useRecoilState(channelAttachmentListState);
const [, setchannelFiles] = useRecoilState(channelAttachmentFileState(companyId));
const [, setchannelMedia] = useRecoilState(channelAttachmentMediaState(companyId));
const [result, setResult] = useRecoilState(
type === 'media'
? channelAttachmentMediaState(companyId)
: channelAttachmentFileState(companyId),
);
const options = _.omitBy(
{
limit,
is_file: type === 'file' || undefined,
is_media: type === 'media' || undefined,
workspace_id: workspaceId,
channel_id: channelId,
},
_.isUndefined,
);
const loadItems = async () => {
setLoading(true);
const response = await messageApiClient.searchFile(null, options);
const results = (response.resources || []).sort(
(a, b) => (b?.message?.created_at || 0) - (a?.message?.created_at || 0),
);
const update = {
results,
nextPage: response.next_page_token || null,
};
setResult(update);
setLoading(false);
};
const loadMore = async () => {
if (result.nextPage && result.results.length % limit === 0) {
const response = await messageApiClient.searchFile(null, { ...options, next_page_token: result.nextPage });
const results = (response.resources || []).sort(
(a, b) => (b?.message?.created_at || 0) - (a?.message?.created_at || 0),
);
const update = {
results: _.uniqBy([...result.results, ...results] || [], 'id'),
nextPage: response.next_page_token || null,
};
setResult(update);
}
}
const reset = () => {
const update = {
results: [],
nextPage: null,
}
setchannelFiles(update);
setchannelMedia(update);
}
useGlobalEffect(
`useChannelAttachmentList${type}`,
() => {
if (!isOpen) {
reset();
}
},
[channelId, workspaceId, isOpen],
);
return {
loading,
result: result.results,
loadItems,
loadMore,
};
};
export const useChannelMediaList = () => {
return useChannelAttachmentList('media');
};
export const useChannelFileList = () => {
return useChannelAttachmentList('file');
};
@@ -1,150 +0,0 @@
/* eslint-disable @typescript-eslint/no-empty-function */
/* eslint-disable @typescript-eslint/no-explicit-any */
import { useRealtimeRoom } from 'app/features/global/hooks/use-realtime';
import WorkspaceAPIClient from 'app/features/workspaces/api/workspace-api-client';
import { useRecoilCallback, useRecoilValue } from 'recoil';
import {
ChannelWritingActivityState,
ChannelWritingActivityType,
} from '../state/channel-writing-activity';
import { ThreadWritingActivitySelector } from '../../messages/state/selectors/thread-writing-activity';
import UserService from 'app/features/users/services/current-user-service';
import useRouterCompany from '../../router/hooks/use-router-company';
import { useCallback, useRef } from 'react';
import { useCurrentUser } from '../../users/hooks/use-current-user';
const MAX_DELAY_BETWEEN_KEYDOWN = 500;
const MIN_DELAY_BETWEEN_EMIT = 8000;
const MAX_DELAY_AFTER_LAST_WRITE_EVENT = 10000;
export type WritingEvent = {
type: 'writing';
event: {
channel_id: string;
thread_id: string;
user_id: string;
name: string;
is_writing: boolean;
};
};
export type ChannelWritingActivityTypeEmit = {
iAmWriting: (writing: boolean) => void;
};
export function useChannelWritingActivityState(
channelId: string,
threadId?: string | null,
): ChannelWritingActivityType[] {
const threadIdSelector = useRecoilValue(
ThreadWritingActivitySelector({ channelId: channelId, threadId: threadId || '' }),
);
return threadIdSelector;
}
const receivedWritingTimeout = new Map<string, number>();
export default function useChannelWritingActivity() {
const companyId = useRouterCompany();
const { user } = useCurrentUser();
const setChannelWritingActivityState = useRecoilCallback(
({ set, snapshot }) =>
async (event: WritingEvent['event']) => {
let currentList: ChannelWritingActivityType[] = await snapshot.getPromise(
ChannelWritingActivityState(event.channel_id),
);
const newEvent: ChannelWritingActivityType = {
threadId: event.thread_id,
userId: event.user_id,
name: event.name,
};
currentList = currentList.filter(elem => elem.userId !== newEvent.userId);
if (event.is_writing) {
currentList = [...currentList, newEvent];
}
currentList = currentList.filter(elem => elem.userId !== user?.id);
set(ChannelWritingActivityState(event.channel_id), currentList);
//Fallback stop is_writing in case of lost connection
if (receivedWritingTimeout.has(event.user_id))
clearTimeout(receivedWritingTimeout.get(event.user_id));
if (event.is_writing) {
receivedWritingTimeout.set(
event.user_id,
window.setTimeout(() => {
setChannelWritingActivityState({ ...event, is_writing: false });
}, MAX_DELAY_AFTER_LAST_WRITE_EVENT),
);
}
},
);
useRealtimeRoom<WritingEvent>(
WorkspaceAPIClient.websockets(companyId)[0],
'useChannelWritingActivity',
(action, resource) => {
if (action === 'event' && resource.type === 'writing') {
setChannelWritingActivityState(resource.event);
}
},
);
}
export function useChannelWritingActivityEmit(
channelId: string,
threadId: string | null,
): ChannelWritingActivityTypeEmit {
const companyId = useRouterCompany();
const { user } = useCurrentUser();
const { send } = useRealtimeRoom<WritingEvent>(
WorkspaceAPIClient.websockets(companyId)[0],
'useChannelWritingActivityEmit',
() => undefined,
);
(window as any).send = send;
const iAmWriting = useCallback(
async (writing: boolean) => {
if (user)
send({
type: 'writing',
event: {
channel_id: channelId,
thread_id: threadId,
user_id: user.id,
name: UserService.getFullName(user),
is_writing: writing,
},
} as WritingEvent);
},
[send],
);
return { iAmWriting };
}
/** Keyboard typeing detection helper */
let writeTimeout = setTimeout(() => {}, 0);
export const useWritingDetector = () => {
const lastEmit = useRef(new Date().getTime());
const onKeydown = useCallback((emit: (value: boolean) => unknown) => {
const now = new Date().getTime();
if (now - lastEmit.current > MIN_DELAY_BETWEEN_EMIT) {
lastEmit.current = now;
emit(true);
}
if (writeTimeout) {
clearTimeout(writeTimeout);
}
writeTimeout = setTimeout(() => {
emit(false);
lastEmit.current = 0;
}, MAX_DELAY_BETWEEN_KEYDOWN);
}, []);
return { onKeydown };
};
@@ -1,89 +0,0 @@
import { useRecoilCallback, useRecoilState, useRecoilValue } from 'recoil';
import { ChannelType } from 'app/features/channels/types/channel';
import { ChannelsState, ChannelSelector } from '../state/channels';
import ChannelAPIClient from '../api/channel-api-client';
import { useGlobalEffect } from 'app/features/global/hooks/use-global-effect';
import useRouterCompany from 'app/features/router/hooks/use-router-company';
import useRouterWorkspace from 'app/features/router/hooks/use-router-workspace';
import { LoadingState } from 'app/features/global/state/atoms/Loading';
//Keep the channels in a easy to use variable
let channelsKeeper: ChannelType[] = [];
export function useChannel(
channelId: string,
options?: { companyId: string; workspaceId: string },
) {
const companyId = options?.companyId || useRouterCompany();
const workspaceId = options?.workspaceId || useRouterWorkspace();
const hookId = 'useChannel-' + companyId + '-' + workspaceId + '-' + channelId;
const [loading, setLoading] = useRecoilState(LoadingState(hookId));
const channel = useRecoilValue(ChannelSelector(channelId)) as ChannelType;
const { set } = useSetChannel();
const save = async (channel: ChannelType) => {
setLoading(true);
await ChannelAPIClient.save(channel, {
companyId: channel.company_id || '',
workspaceId: channel.workspace_id || '',
channelId: channel.id,
});
set(channel);
setLoading(false);
};
const refresh = async () => {
setLoading(true);
const ch = await ChannelAPIClient.get(companyId, workspaceId, channelId);
if (ch && ch?.id) {
set(ch);
} else {
set({
id: channelId,
name: '',
visibility: 'private',
});
}
setLoading(false);
};
useGlobalEffect(
hookId,
async () => {
if (!channel) refresh();
},
[],
);
return { channel, save, loading, refresh };
}
export const useIsChannelMember = (channelId: string) => {
return !!useChannel(channelId)?.channel?.user_member?.user_id;
};
export const useIsReadOnlyChannel = (channelId: string) => {
return useChannel(channelId)?.channel?.is_readonly;
};
export function getChannel(channelId: string) {
return channelsKeeper.find(ch => ch.id === channelId);
}
export function getAllChannelsCache() {
return channelsKeeper;
}
export function useSetChannel() {
const set = useRecoilCallback(({ set }) => (channel: ChannelType) => {
if (channel.id) {
channelsKeeper = channelsKeeper.filter(c => c.id !== channel.id);
channelsKeeper.push(channel);
set(ChannelsState, channelsKeeper);
}
});
return { set };
}
@@ -1,18 +0,0 @@
import { useRecoilValue } from 'recoil';
import { LoadingState } from 'app/features/global/state/atoms/Loading';
export const useChannelsBarLoader = ({
companyId,
workspaceId,
}: {
companyId: string;
workspaceId: string;
}) => {
const publicOrPrivateContext = useRecoilValue(
LoadingState(`channels-${companyId}-${workspaceId}`),
);
const applicationContext = useRecoilValue(LoadingState(`applications-${companyId}`));
const directContext = useRecoilValue(LoadingState(`channels-direct-${companyId}`));
return { loading: publicOrPrivateContext || applicationContext || directContext };
};
@@ -1,107 +0,0 @@
import { useRecoilState, useSetRecoilState } from 'recoil';
import { ChannelType } from 'app/features/channels/types/channel';
import { DirectChannelsState } from '../state/channels';
import useRouterCompany from 'app/features/router/hooks/use-router-company';
import ChannelsMineAPIClient from 'app/features/channels/api/channels-mine-api-client';
import { useRealtimeRoom } from 'app/features/global/hooks/use-realtime';
import { LoadingState } from 'app/features/global/state/atoms/Loading';
import { useGlobalEffect } from 'app/features/global/hooks/use-global-effect';
import { useSetUserList } from 'app/features/users/hooks/use-user-list';
import { UserType } from 'app/features/users/types/user';
import { getChannel, useSetChannel } from './use-channel';
import ChannelAPIClient from '../api/channel-api-client';
import MenusManager from 'app/components/menus/menus-manager.jsx';
import RouterService from 'app/features/router/services/router-service';
export function useRefreshDirectChannels(): {
refresh: () => Promise<void>;
} {
const companyId = useRouterCompany();
const { set: setUserList } = useSetUserList('useRefreshDirectChannels');
const { set } = useSetChannel();
const _setDirectChannels = useSetRecoilState(DirectChannelsState(companyId));
const refresh = async () => {
const directChannels = await ChannelsMineAPIClient.get({ companyId, workspaceId: 'direct' });
if (directChannels) _setDirectChannels(directChannels);
const users: UserType[] = [];
directChannels.forEach(c => {
if (c.users) users.push(...c.users);
});
directChannels.forEach(c => set(c));
if (users) setUserList(users);
};
return { refresh };
}
export function useDirectChannelsSetup() {
const companyId = useRouterCompany();
const [, setLoading] = useRecoilState(LoadingState(`channels-direct-${companyId}`));
const [didLoad, setDidLoad] = useRecoilState(
LoadingState(`channels-direct-did-load-${companyId}`),
);
const { refresh } = useRefreshDirectChannels();
const { set } = useSetChannel();
useGlobalEffect(
'useDirectChannels',
async () => {
if (!didLoad) setLoading(true);
await refresh();
setLoading(false);
setDidLoad(true);
},
[companyId],
);
useRealtimeRoom<ChannelType & { _type: string }>(
ChannelsMineAPIClient.websockets(companyId, 'direct')[0],
'useDirectChannels',
(_action, event) => {
//TODO replace this to avoid calling backend every time
if (_action === 'saved') refresh();
if (_action === 'updated' && event._type === 'channel_activity') {
if (event.id)
set({ ...getChannel(event.id), stats: event.stats, last_message: event.last_message });
}
},
);
}
export function useDirectChannels(): {
directChannels: ChannelType[];
refresh: () => Promise<void>;
openDiscussion: (membersId: string[]) => Promise<void>;
} {
const companyId = useRouterCompany();
const [directChannels] = useRecoilState(DirectChannelsState(companyId));
const { refresh } = useRefreshDirectChannels();
const openDiscussion = async (membersIds: string[]) => {
const channel = await ChannelAPIClient.getDirect(companyId, membersIds);
await refresh();
if (channel) {
RouterService.push(
RouterService.generateRouteFromState({
channelId: channel.id,
companyId: channel.company_id,
}),
);
}
MenusManager.closeMenu();
};
return {
refresh,
directChannels,
openDiscussion,
};
}
@@ -1,37 +0,0 @@
import { ChannelType } from 'app/features/channels/types/channel';
import { useDirectChannels, useRefreshDirectChannels } from './use-direct-channels';
import {
usePublicOrPrivateChannels,
useRefreshPublicOrPrivateChannels,
} from './use-public-or-private-channels';
export function useRefreshFavoriteChannels(): {
refresh: () => Promise<void>;
} {
const { refresh: refreshPublicOrPrivateChannels } = useRefreshPublicOrPrivateChannels();
const { refresh: refreshDirectChannels } = useRefreshDirectChannels();
const refresh = async () => {
await refreshPublicOrPrivateChannels();
await refreshDirectChannels();
};
return { refresh };
}
export function useFavoriteChannels(): {
favoriteChannels: ChannelType[];
refresh: () => Promise<void>;
} {
const { publicChannels, privateChannels } = usePublicOrPrivateChannels();
const { directChannels } = useDirectChannels();
const { refresh } = useRefreshFavoriteChannels();
return {
favoriteChannels: [...publicChannels, ...privateChannels, ...directChannels].filter(
c => c.user_member?.favorite,
),
refresh,
};
}
@@ -1,103 +0,0 @@
import { useRecoilState, useSetRecoilState } from 'recoil';
import { ChannelType } from 'app/features/channels/types/channel';
import { MineChannelsState } from '../state/channels';
import useRouterCompany from 'app/features/router/hooks/use-router-company';
import ChannelsMineAPIClient from 'app/features/channels/api/channels-mine-api-client';
import useRouterWorkspace from 'app/features/router/hooks/use-router-workspace';
import { isPrivateChannel, isPublicChannel } from 'app/features/channels/utils/utils';
import { useRealtimeRoom } from 'app/features/global/hooks/use-realtime';
import { LoadingState } from 'app/features/global/state/atoms/Loading';
import { useGlobalEffect } from 'app/features/global/hooks/use-global-effect';
import { getChannel, useSetChannel } from './use-channel';
export function useRefreshPublicOrPrivateChannels(): {
refresh: () => Promise<void>;
} {
const companyId = useRouterCompany();
const workspaceId = useRouterWorkspace();
const _setMineChannels = useSetRecoilState(MineChannelsState({ companyId, workspaceId }));
const { set } = useSetChannel();
const refresh = async () => {
const res = await ChannelsMineAPIClient.get({ companyId, workspaceId });
res.forEach(c => set(c));
if (res) _setMineChannels(res);
};
return { refresh };
}
export function usePublicOrPrivateChannelsSetup() {
const companyId = useRouterCompany();
const workspaceId = useRouterWorkspace();
const [, setLoading] = useRecoilState(LoadingState(`channels-${companyId}-${workspaceId}`));
const [didLoad, setDidLoad] = useRecoilState(
LoadingState(`channels-did-load-${companyId}-${workspaceId}`),
);
const { refresh } = useRefreshPublicOrPrivateChannels();
const { set } = useSetChannel();
useGlobalEffect(
'usePublicOrPrivateChannels',
async () => {
if (!didLoad) setLoading(true);
await refresh();
setLoading(false);
setDidLoad(true);
},
[companyId, workspaceId],
);
//Public channels
useRealtimeRoom<ChannelType & { _type: string }>(
ChannelsMineAPIClient.websockets(companyId, workspaceId)[0],
'usePublicOrPrivateChannelsPublic',
(_action, event) => {
//TODO replace this to avoid calling backend every time
if (_action === 'saved') refresh();
if (_action === 'updated' && event._type === 'channel_activity') {
if (event.id)
set({ ...getChannel(event.id), stats: event.stats, last_message: event.last_message });
}
},
);
//Private channels
useRealtimeRoom<ChannelType & { _type: string }>(
ChannelsMineAPIClient.websockets(companyId, workspaceId)[1],
'usePublicOrPrivateChannelsPrivate',
(_action, event) => {
//TODO replace this to avoid calling backend every time
if (_action === 'saved') refresh();
if (_action === 'updated' && event._type === 'channel_activity') {
if (event.id)
set({ ...getChannel(event.id), stats: event.stats, last_message: event.last_message });
}
},
);
}
export function usePublicOrPrivateChannels(): {
privateChannels: ChannelType[];
publicChannels: ChannelType[];
refresh: () => Promise<void>;
} {
const companyId = useRouterCompany();
const workspaceId = useRouterWorkspace();
const [mineChannels] = useRecoilState(
MineChannelsState({ companyId, workspaceId }),
);
const { refresh } = useRefreshPublicOrPrivateChannels();
return {
refresh: refresh,
privateChannels: (mineChannels || [])?.filter(
c => c.visibility && isPrivateChannel(c.visibility),
),
publicChannels: (mineChannels || [])?.filter(
c => c.visibility && isPublicChannel(c.visibility),
),
};
}
@@ -1,42 +0,0 @@
import { useEffect } from 'react';
import { useRecoilState } from 'recoil';
import { ChannelType } from 'app/features/channels/types/channel';
import { ReachableChannelsState } from '../state/channels';
import useRouterCompany from 'app/features/router/hooks/use-router-company';
import useRouterWorkspace from 'app/features/router/hooks/use-router-workspace';
import ChannelsReachableAPIClient from 'app/features/channels/api/channels-reachable-api-client';
import { useSetChannel } from './use-channel';
export function useReachableChannels(): {
reachableChannels: ChannelType[];
refresh: () => void;
} {
const companyId = useRouterCompany();
const workspaceId = useRouterWorkspace();
const [reachableChannels, _setReachableChannels] = useRecoilState(
ReachableChannelsState({ companyId, workspaceId }),
);
const { set } = useSetChannel();
const refresh = async () => {
const channels = await ChannelsReachableAPIClient.get(companyId, workspaceId);
channels.forEach(channel => {
set(channel);
});
if (channels) _setReachableChannels(channels);
};
useEffect(() => {
companyId.length > 1 && workspaceId.length > 1 && refresh();
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [companyId, workspaceId]);
return {
refresh,
reachableChannels,
};
}
@@ -1,44 +0,0 @@
import Observable from 'app/deprecated/Observable/Observable';
import LocalStorage from 'app/features/global/framework/local-storage-service';
class ChannelsBarService extends Observable {
private callbacks = new Map<string, (state: boolean) => void>();
private ready = new Map<string, boolean>();
collectionIsReady(companyId: string, workspaceId: string, suffix?: string[]): void {
const callbackId = this.getCallbackId(companyId, workspaceId, suffix);
if (!this.ready.has(callbackId)) {
this.ready.set(callbackId, true);
this.notify();
}
}
isReady(companyId = '', workspaceId = '', suffix?: string[]): boolean {
return !!this.ready.get(this.getCallbackId(companyId, workspaceId, suffix));
}
updateCurrentChannelId(
companyId = '',
workspaceId = '',
channelId = '',
): void {
LocalStorage.setItem(this.getLocalStorageKey(companyId, workspaceId), channelId);
}
private getLocalStorageKey(companyId: string, workspaceId: string): string {
return `${companyId}:${workspaceId}:channel`;
}
private getCallbackId(companyId: string, workspaceId: string, suffix?: string[]): string {
let key = `${companyId}+${workspaceId}`;
if (suffix && suffix.length) {
key = [key, ...suffix].join('+');
}
return key;
}
}
export default new ChannelsBarService();
@@ -1,28 +0,0 @@
import { MessageFileType } from 'app/features/messages/types/message';
import { atom, atomFamily } from 'recoil';
export type ChannelAttachment = {
results: MessageFileType[];
nextPage: string | null;
};
export const activeChannelAttachementListTabState = atom<number>({
key: 'activeChannelAttachementListTabState',
default: 0,
});
export const channelAttachmentListState = atom<boolean>({
key: 'channelAttachmentListState',
default: false,
});
export const channelAttachmentMediaState = atomFamily<ChannelAttachment, string>({
key: 'channelAttachmentMediaState',
default: () => ({ results: [], nextPage: '' }),
});
export const channelAttachmentFileState = atomFamily<ChannelAttachment, string>({
key: 'channelAttachmentFileState',
default: () => ({ results: [], nextPage: '' }),
});
@@ -1,12 +0,0 @@
import { atomFamily } from 'recoil';
export type ChannelWritingActivityType = {
threadId: string;
userId: string;
name: string;
};
export const ChannelWritingActivityState = atomFamily<ChannelWritingActivityType[], string>({
key: 'ChannelWritingActivityState',
default: [],
});
@@ -1,36 +0,0 @@
import { atom, atomFamily, selectorFamily } from 'recoil';
import _ from 'lodash';
import { ChannelType } from 'app/features/channels/types/channel';
type ChannelsListContextType = { companyId: string; workspaceId: string };
export const ChannelsState = atom<ChannelType[]>({
key: 'ChannelsState',
default: [],
});
export const ChannelSelector = selectorFamily<ChannelType | undefined, string>({
key: 'ChannelSelector',
get:
channelId =>
({ get }) => {
const channels = get(ChannelsState);
return _.find(channels, { id: channelId });
},
});
export const MineChannelsState = atomFamily<ChannelType[], ChannelsListContextType>({
key: 'MineChannelsState',
default: [],
});
export const ReachableChannelsState = atomFamily<ChannelType[], ChannelsListContextType>({
key: 'ReachableChannelsState',
default: [],
});
export const DirectChannelsState = atomFamily<ChannelType[], string>({
key: 'DirectChannelsState',
default: [],
});
@@ -1,61 +0,0 @@
import { ChannelMemberType } from 'app/features/channel-members/types/channel-member-types';
import { UserType } from 'app/features/users/types/user';
import _ from 'lodash';
export type ChannelType = {
company_id?: string;
workspace_id?: string | null; //Null for direct messages
type?: string;
id?: string;
icon?: string;
name?: string;
description?: string;
channel_group?: string;
visibility?: 'public' | 'direct' | 'private';
is_default?: boolean;
members?: string[];
owner?: string;
members_count?: number;
guests_count?: number;
messages_count?: number;
archived?: false | true;
archivation_date?: number; //Timestamp
user_member?: ChannelMemberType;
connectors?: string[];
last_activity?: number;
last_message?: {
date: number;
sender: string;
title: string;
text: string;
};
stats?: {
members: number;
messages: number;
};
users?: UserType[];
is_readonly?: boolean;
};
export const createDirectChannelFromUsers = (companyId: string, users: UserType[]): ChannelType => {
users = _.uniqBy(users, 'id');
const id = users.map(u => u.id).join('_') + '_frontend';
return {
company_id: companyId,
workspace_id: 'direct',
visibility: 'direct',
id: id,
members: users.map(u => u.id).filter(a => a) as string[],
owner: users[0].id,
members_count: users.length,
guests_count: 0,
messages_count: 0,
archived: false,
user_member: {
user_id: users[0].id,
channel_id: id,
},
connectors: [],
users: users,
};
};
@@ -1,15 +0,0 @@
import { ChannelMemberType } from 'app/features/channel-members/types/channel-member-types';
import { ChannelType } from './channel';
export type ChannelsReachableGetResponse = { resources: ChannelType[] };
export type ChannelsReachableInviteUserResponse = { resource: ChannelMemberType };
export type ChannelsReachableInviteUserRequest = {
resource: {
user_id: string;
};
};
export type ChannelsReachableRemoveUserResponse = {
status: 'success' | 'error';
errors: string[]; //List of errors
};
@@ -1,12 +0,0 @@
// Channel visibility utils
export function isPublicChannel(visibility: string): boolean {
return visibility === 'public' ? true : false;
}
export function isPrivateChannel(visibility: string): boolean {
return visibility === 'private' ? true : false;
}
export function isDirectChannel(visibility: string): boolean {
return visibility === 'direct' ? true : false;
}
@@ -1,5 +1,5 @@
import { CompanyType } from 'app/features/companies/types/company';
import { WorkspaceType } from 'app/features/workspaces/types/workspace';
import { CompanyType } from '@features/companies/types/company';
import { WorkspaceType } from '@features/workspaces/types/workspace';
import Api from '../../global/framework/api-service';
import { TdriveService } from '../../global/framework/registry-decorator-service';
import { WebsocketRoom } from '../../global/types/websocket-types';
@@ -2,19 +2,19 @@ import { CompaniesState } from '../state/companies';
import useRouterCompany from '../../router/hooks/use-router-company';
import { useRecoilState } from 'recoil';
import { CurrentUserState } from '../../users/state/atoms/current-user';
import { CompanyType } from 'app/features/companies/types/company';
import LocalStorage from 'app/features/global/framework/local-storage-service';
import { UserType } from 'app/features/users/types/user';
import { CompanyType } from '@features/companies/types/company';
import LocalStorage from '@features/global/framework/local-storage-service';
import { UserType } from '@features/users/types/user';
import { useCurrentUser } from '../../users/hooks/use-current-user';
import _ from 'lodash';
import RouterService from 'app/features/router/services/router-service';
import WorkspacesService from 'app/deprecated/workspaces/workspaces.jsx';
import AccessRightsService from 'app/features/workspace-members/services/workspace-members-access-rights-service';
import Groups from 'app/deprecated/workspaces/groups.js';
import LoginService from 'app/features/auth/login-service';
import UserAPIClient from 'app/features/users/api/user-api-client';
import { useRealtimeRoom } from 'app/features/global/hooks/use-realtime';
import CompanyAPIClient from 'app/features/companies/api/company-api-client';
import RouterService from '@features/router/services/router-service';
import WorkspacesService from '@deprecated/workspaces/workspaces.jsx';
import AccessRightsService from '@features/workspace-members/services/workspace-members-access-rights-service';
import Groups from '@deprecated/workspaces/groups.js';
import LoginService from '@features/auth/login-service';
import UserAPIClient from '@features/users/api/user-api-client';
import { useRealtimeRoom } from '@features/global/hooks/use-realtime';
import CompanyAPIClient from '@features/companies/api/company-api-client';
/**
* Will return the companies of the current user
@@ -1,8 +1,8 @@
import { atomFamily } from 'recoil';
import Collections from 'app/deprecated/CollectionsV1/Collections/Collections';
import Collections from '@deprecated/CollectionsV1/Collections/Collections';
import { CompanyType } from 'app/features/companies/types/company';
import CompanyAPIClient from 'app/features/companies/api/company-api-client';
import { CompanyType } from '@features/companies/types/company';
import CompanyAPIClient from '@features/companies/api/company-api-client';
import _ from 'lodash';
const companies: { [key: string]: CompanyType } = {};
@@ -1,4 +1,4 @@
import { FeatureValueType } from 'app/features/global/services/feature-toggles-service';
import { FeatureValueType } from '@features/global/services/feature-toggles-service';
export type CompanyRoleType = 'owner' | 'admin' | 'member' | 'guest';
@@ -12,7 +12,7 @@ export type CompanyBillingObjectType = {
export enum CompanyLimitsEnum {
CHAT_MESSAGE_HISTORY_LIMIT = 'chat:message_history_limit',
COMPANY_MEMBERS_LIMIT = 'company:members_limit', // 100
COMPANY_GUESTS_LIMIT = 'company:guests_limit'
COMPANY_GUESTS_LIMIT = 'company:guests_limit',
}
export type CompanyLimitsObjectType = {
@@ -1,6 +1,6 @@
import Api from 'app/features/global/framework/api-service';
import { TdriveService } from 'app/features/global/framework/registry-decorator-service';
import JWTStorage, { JWTDataType } from 'app/features/auth/jwt-storage-service';
import Api from '@features/global/framework/api-service';
import { TdriveService } from '@features/global/framework/registry-decorator-service';
import JWTStorage, { JWTDataType } from '@features/auth/jwt-storage-service';
type LoginParams = {
email: string;
@@ -1,11 +1,11 @@
/* eslint-disable @typescript-eslint/no-explicit-any */
import Api from 'app/features/global/framework/api-service';
import InitService from 'app/features/global/services/init-service';
import Languages from 'app/features/global/services/languages-service';
import { ToasterService as Toaster } from 'app/features/global/services/toaster-service';
import { ConsoleMemberRole } from 'app/features/console/types/types';
import Logger from 'app/features/global/framework/logger-service';
import { JWTDataType } from 'app/features/auth/jwt-storage-service';
import Api from '@features/global/framework/api-service';
import InitService from '@features/global/services/init-service';
import Languages from '@features/global/services/languages-service';
import { ToasterService as Toaster } from '@features/global/services/toaster-service';
import { ConsoleMemberRole } from '@features/console/types/types';
import Logger from '@features/global/framework/logger-service';
import { JWTDataType } from '@features/auth/jwt-storage-service';
class ConsoleService {
logger: Logger.Logger;
@@ -1,29 +0,0 @@
import Api from '../../global/framework/api-service';
import { DriveTdriveTab } from '../types';
export class DriveTdriveApiClient {
static async getTab(companyId: string, tabId: string) {
return await Api.get<DriveTdriveTab>(
`/internal/services/documents/v1/companies/${companyId}/tabs/${tabId}`,
);
}
static async setTab(
companyId: string,
tabId: string,
channelId: string,
itemId: string,
level: 'write' | 'read',
) {
return await Api.post<DriveTdriveTab, DriveTdriveTab>(
`/internal/services/documents/v1/companies/${companyId}/tabs/${tabId}`,
{
company_id: companyId,
tab_id: tabId,
channel_id: channelId,
item_id: itemId,
level,
},
);
}
}
@@ -1,29 +0,0 @@
import useRouterCompany from 'app/features/router/hooks/use-router-company';
import { useEffect, useState } from 'react';
import { useRecoilState } from 'recoil';
import { DriveTdriveApiClient } from '../api-client/api-client';
import { DriveTdriveTabAtom } from '../state/store';
export const useDriveTdriveTab = (channelId: string, tabId: string) => {
const companyId = useRouterCompany();
const [tab, setTab] = useRecoilState(DriveTdriveTabAtom(tabId));
const [loading, setLoading] = useState(false);
useEffect(() => {
setLoading(true);
DriveTdriveApiClient.getTab(companyId, tabId)
.then(setTab)
.finally(() => setLoading(false));
}, [companyId, tabId]);
return {
tab,
setTab: async (itemId: string, level: 'read' | 'write') => {
setLoading(true);
const tab = await DriveTdriveApiClient.setTab(companyId, tabId, channelId, itemId, level);
if (tab.item_id) setTab(tab);
setLoading(false);
},
loading,
};
};
@@ -1,7 +0,0 @@
import { atomFamily } from 'recoil';
import { DriveTdriveTab } from '../types';
export const DriveTdriveTabAtom = atomFamily<DriveTdriveTab | null, string>({
key: 'DriveTdriveTabAtom',
default: () => null,
});
@@ -1,7 +0,0 @@
export type DriveTdriveTab = {
company_id: string;
tab_id: string;
channel_id: string;
item_id: string;
level: 'write' | 'read';
};
@@ -1,6 +1,6 @@
import Api from '../../global/framework/api-service';
import { DriveItem, DriveItemDetails, DriveItemVersion } from '../types';
import Workspace from 'app/deprecated/workspaces/workspaces';
import Workspace from '@deprecated/workspaces/workspaces';
import Logger from 'features/global/framework/logger-service';
export interface BaseSearchOptions {
company_id?: string;
@@ -116,9 +116,9 @@ export class DriveApiClient {
const companyId = options?.company_id ? options.company_id : Workspace.currentGroupId;
const query = `/internal/services/documents/v1/companies/${companyId}/search`;
const searchData = {
"search": searchString
search: searchString,
};
const res = await Api.post<SearchDocumentsBody,{ entities: DriveItem[] }>(query, searchData);
const res = await Api.post<SearchDocumentsBody, { entities: DriveItem[] }>(query, searchData);
this.logger.debug(
`Drive search by text "${searchString}". Found`,
res.entities.length,
@@ -1,5 +1,5 @@
import { ToasterService } from 'app/features/global/services/toaster-service';
import useRouterCompany from 'app/features/router/hooks/use-router-company';
import { ToasterService } from '@features/global/services/toaster-service';
import useRouterCompany from '@features/router/hooks/use-router-company';
import { useCallback } from 'react';
import { useRecoilCallback } from 'recoil';
import { DriveApiClient } from '../api-client/api-client';
@@ -1,6 +1,6 @@
import { ToasterService } from 'app/features/global/services/toaster-service';
import { LoadingStateInitTrue } from 'app/features/global/state/atoms/Loading';
import useRouterCompany from 'app/features/router/hooks/use-router-company';
import { ToasterService } from '@features/global/services/toaster-service';
import { LoadingStateInitTrue } from '@features/global/state/atoms/Loading';
import useRouterCompany from '@features/router/hooks/use-router-company';
import { useCallback } from 'react';
import { useRecoilState, useRecoilValue } from 'recoil';
import { DriveItemAtom, DriveItemChildrenAtom } from '../state/store';
@@ -1,7 +1,7 @@
import fileUploadApiClient from 'app/features/files/api/file-upload-api-client';
import fileUploadService from 'app/features/files/services/file-upload-service';
import { useGlobalEffect } from 'app/features/global/hooks/use-global-effect';
import { LoadingState } from 'app/features/global/state/atoms/Loading';
import fileUploadApiClient from '@features/files/api/file-upload-api-client';
import fileUploadService from '@features/files/services/file-upload-service';
import { useGlobalEffect } from '@features/global/hooks/use-global-effect';
import { LoadingState } from '@features/global/state/atoms/Loading';
import { useRecoilState } from 'recoil';
import { DriveApiClient } from '../api-client/api-client';
import { DriveViewerState } from '../state/viewer';
@@ -1,4 +1,4 @@
import { useRealtimeRoom } from 'app/features/global/hooks/use-realtime';
import { useRealtimeRoom } from '@features/global/hooks/use-realtime';
import { useDriveActions } from './use-drive-actions';
import { useDriveItem } from './use-drive-item';
@@ -1,6 +1,6 @@
import { FileTreeObject } from 'app/components/uploads/file-tree-utils';
import FileUploadService from 'app/features/files/services/file-upload-service';
import { ToasterService } from 'app/features/global/services/toaster-service';
import { FileTreeObject } from '@components/uploads/file-tree-utils';
import FileUploadService from '@features/files/services/file-upload-service';
import { ToasterService } from '@features/global/services/toaster-service';
import { DriveApiClient } from '../api-client/api-client';
import { useDriveActions } from './use-drive-actions';
@@ -1,6 +1,6 @@
import Api from 'app/features/global/framework/api-service';
import { FileType } from 'app/features/files/types/file';
import { MessageFileType } from 'app/features/messages/types/message';
import Api from '@features/global/framework/api-service';
import { FileType } from '@features/files/types/file';
import { AttachedFileType } from '@features/files/types/file';
import extensionToMime from '../utils/extension-to-mime';
import { fileTypeMimes } from '../utils/type-mimes';
import AceModeList from '@features/global/utils/ace_modelist.js';
@@ -70,7 +70,7 @@ class FileUploadAPIClient {
})}/thumbnails/${file.thumbnails?.[0]?.index}`;
}
public getFileThumbnailUrlFromMessageFile(file: MessageFileType): string {
public getFileThumbnailUrlFromMessageFile(file: AttachedFileType): string {
if (file.metadata?.source !== 'internal') return file.metadata?.thumbnails?.[0]?.url || '';
if (!file.metadata?.thumbnails?.[0]) {
return '';
@@ -1,10 +1,10 @@
import { useEffect } from 'react';
import FileUploadService from 'app/features/files/services/file-upload-service';
import { MessageFileType } from 'app/features/messages/types/message';
import FileUploadService from '@features/files/services/file-upload-service';
import { AttachedFileType } from '@features/files/types/file';
import { useRecoilState } from 'recoil';
import { PendingUploadZonesListState } from '../state/atoms/pending-upload-zones-list';
import { useUpload } from './use-upload';
import { FileType, PendingFileType } from 'app/features/files/types/file';
import { FileType, PendingFileType } from '@features/files/types/file';
export const useUploadZones = (zoneId: string) => {
const { currentTask, getOnePendingFile } = useUpload();
@@ -51,7 +51,7 @@ export const useUploadZones = (zoneId: string) => {
};
};
const pendingFileToMessageFile = (f: MessageFileType, upToDate: PendingFileType) => {
const pendingFileToMessageFile = (f: AttachedFileType, upToDate: PendingFileType) => {
return {
...f,
company_id: upToDate.backendFile?.company_id,
@@ -67,5 +67,5 @@ const pendingFileToMessageFile = (f: MessageFileType, upToDate: PendingFileType)
name: upToDate.backendFile?.metadata?.name,
thumbnails: upToDate.backendFile?.thumbnails,
},
} as MessageFileType;
} as AttachedFileType;
};
@@ -1,9 +1,9 @@
import FileUploadService from 'app/features/files/services/file-upload-service';
import FileUploadService from '@features/files/services/file-upload-service';
import { useRecoilState, useRecoilValue } from 'recoil';
import { PendingFilesListState } from '../state/atoms/pending-files-list';
import { CurrentTaskSelector } from '../state/selectors/current-task';
import RouterServices from 'app/features/router/services/router-service';
import { MessageFileType } from 'app/features/messages/types/message';
import RouterServices from '@features/router/services/router-service';
import { AttachedFileType } from '@features/files/types/file';
export const useUpload = () => {
const { companyId } = RouterServices.getStateFromRoute();
@@ -25,16 +25,12 @@ export const useUpload = () => {
const downloadOneFile = ({
companyId,
fileId,
messageFile,
blob,
}: {
companyId: string;
fileId: string;
messageFile: MessageFileType;
blob?: boolean;
}) => {
if (messageFile) FileUploadService.markAsDownloadedFromMessage(messageFile);
if (blob) {
return FileUploadService.download({ companyId, fileId });
}
@@ -2,16 +2,15 @@
/* eslint-disable @typescript-eslint/ban-types */
import { v1 as uuid } from 'uuid';
import { FileType, PendingFileType } from 'app/features/files/types/file';
import JWTStorage from 'app/features/auth/jwt-storage-service';
import RouterServices from 'app/features/router/services/router-service';
import Resumable from 'app/features/files/utils/resumable';
import { FileType, PendingFileType } from '@features/files/types/file';
import JWTStorage from '@features/auth/jwt-storage-service';
import RouterServices from '@features/router/services/router-service';
import Resumable from '@features/files/utils/resumable';
import FileUploadAPIClient from '../api/file-upload-api-client';
import { isPendingFileStatusPending } from '../utils/pending-files';
import Logger from 'app/features/global/framework/logger-service';
import Logger from '@features/global/framework/logger-service';
import _ from 'lodash';
import { MessageFileType } from 'app/features/messages/types/message';
import MessageAPIClient from 'app/features/messages/api/message-api-client';
import { AttachedFileType } from '@features/files/types/file';
export enum Events {
ON_CHANGE = 'notify',
@@ -266,10 +265,6 @@ class FileUploadService {
fileId: fileId,
});
}
public async markAsDownloadedFromMessage(messageFile: MessageFileType) {
await MessageAPIClient.download(messageFile);
}
}
export default new FileUploadService();
@@ -1,5 +1,5 @@
import { atom } from 'recoil';
import { PendingFileRecoilType } from 'app/features/files/types/file';
import { PendingFileRecoilType } from '@features/files/types/file';
export const PendingFilesListState = atom<PendingFileRecoilType[] | undefined>({
key: 'PendingFilesListState',
@@ -1,7 +1,7 @@
import { MessageFileType } from 'app/features/messages/types/message';
import { AttachedFileType } from '@features/files/types/file';
import { atomFamily } from 'recoil';
export const PendingUploadZonesListState = atomFamily<MessageFileType[], string>({
export const PendingUploadZonesListState = atomFamily<AttachedFileType[], string>({
key: 'PendingUploadZonesListState',
default: () => [],
});
@@ -1,4 +1,4 @@
import FileUploadService from 'app/features/files/services/file-upload-service';
import FileUploadService from '@features/files/services/file-upload-service';
import { selector } from 'recoil';
import { PendingFilesListState } from '../atoms/pending-files-list';
@@ -1,6 +1,36 @@
import Resumable from 'app/features/files/utils/resumable';
import { ThumbnailType } from '../../messages/types/message';
import { UserType } from 'app/features/users/types/user';
import Resumable from '@features/files/utils/resumable';
import { UserType } from '@features/users/types/user';
export type ThumbnailType = {
width?: number; //Thumbnail width (for images only)
height?: number; //Thumbnail height (for images only)
id?: string; //Url to thumbnail (or set it to undefined if no relevant)
index?: number;
size?: number;
mime?: string;
type?: string;
url: string;
};
export type AttachedFileMetadataSource = 'internal' | 'drive' | string;
export type AttachedFileType = {
//Primary key
id?: string;
company_id?: string; // optional
message_id?: string; // optional
thread_id?: string; // optional
metadata?: {
//File information when attached (it can change if edited)
source?: AttachedFileMetadataSource;
external_id: string | { company_id: string; id: string } | any;
name?: string; //Original name
size?: number; //Original weight
mime?: string;
thumbnails?: ThumbnailType[];
};
};
export type MetaDataType = {
thumbnails?: ThumbnailType[];
@@ -1,4 +1,4 @@
import { PendingFileRecoilType } from 'app/features/files/types/file';
import { PendingFileRecoilType } from '@features/files/types/file';
export const isPendingFileStatusPause = (status: PendingFileRecoilType['status']): boolean => {
return status === 'pause' ? true : false;
@@ -1,7 +1,7 @@
/* eslint-disable @typescript-eslint/no-empty-function */
/* eslint-disable @typescript-eslint/no-explicit-any */
import Globals from 'app/features/global/services/globals-tdrive-app-service';
import Requests from 'app/features/global/framework/requests-api-service';
import Globals from '@features/global/services/globals-tdrive-app-service';
import Requests from '@features/global/framework/requests-api-service';
class GroupedQueryApi {
private groupedQueryBuffer: any;
@@ -1,5 +1,5 @@
/* eslint-disable @typescript-eslint/no-explicit-any */
import ServiceRegistry from 'app/features/global/framework/registry-service';
import ServiceRegistry from '@features/global/framework/registry-service';
const SERVICE_SUFFIX = 'ChannelServiceImpl';
@@ -1,5 +1,5 @@
/* eslint-disable @typescript-eslint/no-explicit-any */
import JWTStorage from 'app/features/auth/jwt-storage-service';
import JWTStorage from '@features/auth/jwt-storage-service';
import Logger from './logger-service';
class Requests {
@@ -1,5 +1,5 @@
import { useEffect, useState } from 'react';
import { Maybe } from 'app/features/global/types/global-types';
import { Maybe } from '@features/global/types/global-types';
import Globals from '../services/globals-tdrive-app-service';
import JWTStorage from '../../auth/jwt-storage-service';
import Logger from '../framework/logger-service';
@@ -1,5 +1,5 @@
import { useEffect, useLayoutEffect, useRef } from 'react';
import Logger from 'app/features/global/framework/logger-service';
import Logger from '@features/global/framework/logger-service';
const logger = Logger.getLogger('useInterval');
@@ -1,13 +1,13 @@
/* eslint-disable @typescript-eslint/no-explicit-any */
import { useCallback, useEffect, useRef, useState } from 'react';
import useWebSocket from 'app/features/global/hooks/use-websocket';
import Logger from 'app/features/global/framework/logger-service';
import useWebSocket from '@features/global/hooks/use-websocket';
import Logger from '@features/global/framework/logger-service';
import {
RealtimeBaseAction,
RealtimeBaseEvent,
RealtimeResourceEvent,
} from '../types/realtime-types';
import { WebsocketRoom } from 'app/features/global/types/websocket-types';
import { WebsocketRoom } from '@features/global/types/websocket-types';
const logger = Logger.getLogger('useRealtimeRoom');
@@ -1,9 +1,9 @@
/* eslint-disable @typescript-eslint/no-explicit-any */
import { useEffect } from 'react';
import { useCurrentUser } from 'app/features/users/hooks/use-current-user';
import Globals from 'app/features/global/services/globals-tdrive-app-service';
import Logger from 'app/features/global/framework/logger-service';
import { useCurrentUser } from '@features/users/hooks/use-current-user';
import Globals from '@features/global/services/globals-tdrive-app-service';
import Logger from '@features/global/framework/logger-service';
let initiatedService = false;
const logger = Logger.getLogger(`app/features/global/use-usetiful`);
@@ -1,6 +1,6 @@
import { useEffect, useRef, useState } from 'react';
import WebSocketFactory, { WebsocketEvents } from 'app/features/global/types/websocket-types';
import WebSocketService from 'app/features/global/services/websocket-service';
import WebSocketFactory, { WebsocketEvents } from '@features/global/types/websocket-types';
import WebSocketService from '@features/global/services/websocket-service';
const useWebSocket = () => {
const wsRef = useRef<WebSocketService>();
@@ -1,7 +1,7 @@
/* eslint-disable @typescript-eslint/no-empty-function */
import { Modal } from 'antd';
import Languages from 'app/features/global/services/languages-service';
import Languages from '@features/global/services/languages-service';
import { TdriveService } from '../framework/registry-decorator-service';
const { confirm, info } = Modal;
@@ -3,7 +3,7 @@ import environment from 'environment/environment';
import version from 'environment/version';
import * as Sentry from '@sentry/browser';
import LocalStorage from '../framework/local-storage-service';
import { EnvironmentType, EnvironmentVersionType } from 'app/environment/types';
import { EnvironmentType, EnvironmentVersionType } from '@environment/types';
import ServiceRegistry from '../framework/registry-service';
if (process.env.NODE_ENV === 'production' && (window as any).sentry_dsn) {
@@ -1,9 +1,9 @@
/* eslint-disable @typescript-eslint/no-explicit-any */
import Logger from 'app/features/global/framework/logger-service';
import Observable from 'app/deprecated/Observable/Observable';
import Api from 'app/features/global/framework/api-service';
import { getCompany } from 'app/features/companies/state/companies';
import WorkspaceService from 'app/deprecated/workspaces/workspaces.jsx';
import Logger from '@features/global/framework/logger-service';
import Observable from '@deprecated/Observable/Observable';
import Api from '@features/global/framework/api-service';
import { getCompany } from '@features/companies/state/companies';
import WorkspaceService from '@deprecated/workspaces/workspaces.jsx';
export type ConsoleConfiguration = {
authority: string;
@@ -1,12 +1,12 @@
/* eslint-disable @typescript-eslint/no-explicit-any */
/* eslint-disable @typescript-eslint/ban-types */
import Observable from 'app/deprecated/CollectionsV1/observable';
import DateTime from 'app/features/global/utils/datetime';
import Observable from '@deprecated/CollectionsV1/observable';
import DateTime from '@features/global/utils/datetime';
import i18n from 'i18next';
import { initReactI18next } from 'react-i18next';
import Backend from 'i18next-http-backend';
import LanguageDetector from 'i18next-browser-languagedetector';
import Version from 'app/environment/version';
import Version from '@environment/version';
class LanguagesService extends Observable {
private i18nt: Function | null = null;
private language = '';
@@ -1,869 +0,0 @@
/* eslint-disable @typescript-eslint/ban-ts-comment */
/* eslint-disable @typescript-eslint/no-unused-vars */
/* eslint-disable @typescript-eslint/no-explicit-any */
import UserService from 'app/features/users/services/current-user-service';
import Collections from 'app/deprecated/CollectionsV1/Collections/Collections.js';
import PseudoMarkdownDictionary from 'components/twacode/pseudo-markdown-dictionary';
import anchorme from 'anchorme';
import emojis_original_service from 'emojione';
import Globals from 'app/features/global/services/globals-tdrive-app-service';
class PseudoMarkdownCompiler {
saved_messages: { [key: string]: any } = {};
alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
bullets: { [key: string]: any } = {
'• ': () => '• ',
'- ': () => '- ',
'([0-9]+)\\. ': (match: any) => {
const i = parseInt(match[1]);
return i + 1 + '. ';
},
'([a-z])\\. ': (match: any) => {
const i = this.alphabet.toLowerCase().indexOf(match[1]);
return this.alphabet.toLowerCase()[i + 1] + '. ';
},
'([A-Z])\\. ': (match: any) => {
const i = this.alphabet.indexOf(match[1]);
return this.alphabet[i + 1] + '. ';
},
};
pseudo_markdown: { [key: string]: any } = {
text_block_parent: {
name: 'text',
object: PseudoMarkdownDictionary.render_block.text_block_parent.object,
simple_object: (child: any) => child,
},
text: {
name: 'text',
object: PseudoMarkdownDictionary.render_block.text.object,
simple_object: (child: any) => child,
},
'\n': {
name: 'br',
end: '^',
allowed_chars: '.',
object: PseudoMarkdownDictionary.render_block.br.object,
simple_object: (child: any) => child,
},
'[': {
name: 'markdown_link',
allowed_char_before: '', //"(^| )",
allowed_chars: '.+?\\]\\([^ ]+',
disable_recursion: true,
end: '\\)',
object: PseudoMarkdownDictionary.render_block.markdown_link.object,
},
':': {
name: 'emoji',
allowed_char_before: '', //"(^| )",
allowed_chars: '[a-z_]+',
disable_recursion: true,
end: ':',
object: PseudoMarkdownDictionary.render_block.emoji.object,
},
'@': {
name: 'user',
allowed_char_before: '(^|\\B)',
allowed_chars: '[a-z_.-A-Z0-9:]+',
disable_recursion: true,
after_end: ' |$|[^a-zA-Z0-9]',
object: PseudoMarkdownDictionary.render_block.user.object,
simple_object: (_child: any, obj: any) => '@' + (obj.content || '').split(':')[0] + ' ',
text_transform: (PseudoMarkdownDictionary.render_block.user as any).text_transform,
},
'#': {
name: 'channel',
allowed_char_before: '(^|\\B)',
allowed_chars: '[a-z_.-A-Z0-9\u00C0-\u017F:]+',
disable_recursion: true,
after_end: ' |$[^a-zA-Z0-9]',
object: PseudoMarkdownDictionary.render_block.channel.object,
simple_object: (_child: any, obj: any) => '#' + (obj.content || '').split(':')[0] + ' ',
text_transform: (PseudoMarkdownDictionary.render_block.channel as any).text_transform,
},
'```': {
name: 'mcode',
end: '```',
after_end: '$|\n',
view: true,
allowed_chars: '(.|\n)',
disable_recursion: true,
object: PseudoMarkdownDictionary.render_block.mcode.object,
text_transform: (PseudoMarkdownDictionary.render_block.mcode as any).text_transform,
simple_object: (_child: any, obj: any) => {
const str = (obj.content || '').trim();
return str.length > 40 ? str.substr(0, 37) + '...' : str;
},
},
'`': {
name: 'icode',
end: '`',
allowed_char_before: '(^|\\B)',
allowed_chars: '.',
disable_recursion: true,
object: PseudoMarkdownDictionary.render_block.icode.object,
text_transform: (PseudoMarkdownDictionary.render_block.icode as any).text_transform,
},
__: {
name: 'underline',
end: '__',
allowed_char_before: '(^|\\B)',
allowed_chars: '.',
object: PseudoMarkdownDictionary.render_block.underline.object,
text_transform: (PseudoMarkdownDictionary.render_block.underline as any).text_transform,
},
'~~': {
name: 'strikethrough',
end: '~~',
allowed_char_before: '(^|\\B)',
allowed_chars: '.',
object: PseudoMarkdownDictionary.render_block.strikethrough.object,
text_transform: (PseudoMarkdownDictionary.render_block.strikethrough as any).text_transform,
},
'**': {
name: 'bold',
end: '\\*\\*',
allowed_char_before: '(^|\\B|.)',
allowed_chars: '.',
object: PseudoMarkdownDictionary.render_block.bold.object,
text_transform: PseudoMarkdownDictionary.render_block.bold.text_transform,
},
'*': {
name: 'italic',
end: '\\*',
allowed_char_before: '(^|\\B)',
allowed_chars: '.',
object: PseudoMarkdownDictionary.render_block.italic.object,
text_transform: (PseudoMarkdownDictionary.render_block.italic as any).text_transform,
},
_: {
name: 'italic',
end: '_',
allowed_char_before: '(^|\\B)',
allowed_chars: '.',
object: PseudoMarkdownDictionary.render_block.italic.object,
text_transform: (PseudoMarkdownDictionary.render_block.italic as any).text_transform,
},
'>>>': {
name: 'mquote',
allowed_char_before: '^',
view: true,
end: false,
allowed_chars: '(.|\n)',
object: PseudoMarkdownDictionary.render_block.mquote.object,
simple_object: () => '',
text_transform: (PseudoMarkdownDictionary.render_block.mquote as any).text_transform,
},
'>': {
name: 'quote',
view: true,
allowed_char_before: '^',
after_end: '$|\n',
object: PseudoMarkdownDictionary.render_block.quote.object,
simple_object: () => '',
text_transform: (PseudoMarkdownDictionary.render_block.quote as any).text_transform,
},
};
pseudo_markdown_types: { [key: string]: any } = {
nop: {
object: PseudoMarkdownDictionary.render_block.nop.object,
simple_object: (child: any) => child,
text_transform: (PseudoMarkdownDictionary.render_block.nop as any).text_transform,
},
url: {
object: PseudoMarkdownDictionary.render_block.url.object,
text_transform: (PseudoMarkdownDictionary.render_block.url as any).text_transform,
},
email: {
object: PseudoMarkdownDictionary.render_block.email.object,
text_transform: (PseudoMarkdownDictionary.render_block.email as any).text_transform,
},
system: {
apps_only: true,
object: PseudoMarkdownDictionary.render_block.system.object,
simple_object: (child: any) => child,
text_transform: (PseudoMarkdownDictionary.render_block.system as any).text_transform,
},
file: {
view: true,
object: PseudoMarkdownDictionary.render_block.file.object,
simple_object: () => '',
text_transform: (PseudoMarkdownDictionary.render_block.file as any).text_transform,
},
iframe: {
view: true,
apps_only: true,
object: PseudoMarkdownDictionary.render_block.iframe.object,
simple_object: () => '',
text_transform: (PseudoMarkdownDictionary.render_block.iframe as any).text_transform,
},
image: {
view: true,
apps_only: true,
object: PseudoMarkdownDictionary.render_block.image.object,
simple_object: () => '',
text_transform: (PseudoMarkdownDictionary.render_block.image as any).text_transform,
},
icon: {
apps_only: true,
object: PseudoMarkdownDictionary.render_block.icon.object,
text_transform: (PseudoMarkdownDictionary.render_block.icon as any).text_transform,
},
progress_bar: {
view: true,
apps_only: true,
object: PseudoMarkdownDictionary.render_block.progress_bar.object,
simple_object: (_child: any, object: any) => (object.progress || 0) + '%',
text_transform: (PseudoMarkdownDictionary.render_block.progress_bar as any).text_transform,
},
attachment: {
view: true,
apps_only: true,
object: PseudoMarkdownDictionary.render_block.attachment.object,
simple_object: (child: any) => child,
text_transform: (PseudoMarkdownDictionary.render_block.attachment as any).text_transform,
},
button: {
view: true,
apps_only: true,
object: PseudoMarkdownDictionary.render_block.button.object,
simple_object: (_child: any) => '',
text_transform: (PseudoMarkdownDictionary.render_block.button as any).text_transform,
},
copiable: {
view: true,
apps_only: true,
object: PseudoMarkdownDictionary.render_block.copiable.object,
simple_object: (_child: any) => '',
text_transform: (PseudoMarkdownDictionary.render_block.copiable as any).text_transform,
},
input: {
view: true,
apps_only: true,
object: PseudoMarkdownDictionary.render_block.input.object,
simple_object: (_child: any) => '',
text_transform: (PseudoMarkdownDictionary.render_block.input as any).text_transform,
},
select: {
view: true,
apps_only: true,
object: PseudoMarkdownDictionary.render_block.select.object,
simple_object: (_child: any) => '',
text_transform: (PseudoMarkdownDictionary.render_block.select as any).text_transform,
},
};
constructor() {
Object.keys(this.pseudo_markdown).forEach(id => {
const item = this.pseudo_markdown[id];
this.pseudo_markdown_types[item.name] = item;
});
(Globals.window as any).pmc = this;
}
compileStringToLinkObject(string: string) {
//Monkey hack for new markdown links, not the best place for this code
const link_found = anchorme(string.replace(/\[.*?\]\(.*?\)/gm, ''), {
list: true,
ips: false,
files: false,
});
let result: any[] = [];
if (link_found.length === 0) {
return [string];
} else {
const first_link = link_found[0];
const pos = string.indexOf(first_link.raw);
if (pos > 0) {
result = result.concat(this.compileStringToLinkObject(string.slice(0, pos)));
}
result.push({
type: first_link.reason,
content: first_link.raw,
});
if (pos + first_link.raw.length < string.length) {
result = result.concat(
this.compileStringToLinkObject(string.slice(pos + first_link.raw.length)),
);
}
}
return result;
}
transformChannelsUsers(str: string) {
//Users
str = (str || '').replace(
/(\B@)([a-z_.-A-Z0-9]*[a-z_A-Z0-9-])(( |$|([^a-zA-Z0-9]|$){2}))/g,
(full_match, match1, username, match3) => {
const values = username.split(':');
if (values.length === 1) {
if (username === 'me') {
username = UserService.getCurrentUser().username;
}
let user_id = Collections.get('users').findBy({ username: username })[0];
if (user_id && user_id.id) {
user_id = user_id.id;
return match1 + username + ':' + user_id + match3;
} else {
return full_match;
}
} else {
return full_match;
}
},
);
//Channels
str = str.replace(
/(\B#)([a-z_.-A-Z0-9\u00C0-\u017F]*[a-z_A-Z0-9-])(( |$|([^a-zA-Z0-9]|$){2}))/g,
(full_match, match1, channel, match3) => {
const values = channel.split(':');
if (values.length === 1) {
let channel_id = Collections.get('channels')
.findBy({})
.filter(
(item: { [key: string]: any }) =>
(item.name || '').toLocaleLowerCase().replace(/[^a-z0-9_\-.\u00C0-\u017F]/g, '') ===
channel,
)[0];
if (channel_id && channel_id.id) {
channel_id = channel_id.id;
return match1 + channel + ':' + channel_id + match3;
} else {
return full_match;
}
} else {
return full_match;
}
},
);
return str;
}
transformBackChannelsUsers(str: string) {
//Users
str = (str || '').replace(/\B(@[^\s]*?):.*?(( |$|[^a-zA-Z0-9-]))/g, '$1$2');
//Channels
str = str.replace(/\B(#[^\s]*?):.*?(( |$|[^a-zA-Z0-9-]))/g, '$1$2');
return str;
}
compileToJSON(str: string, recursive: any = false) {
if (!recursive) {
const result: any[] = [];
const original_str = str;
const _str = str.split('```'); //Priority to code
_str.forEach((str, i) => {
if (i % 2 === 0) {
if (str) {
str = this.transformChannelsUsers(str);
emojis_original_service.ascii = true;
str = emojis_original_service.shortnameToUnicode(str);
str = emojis_original_service.toShort(str);
const links = this.compileStringToLinkObject(str);
links.forEach(item => {
if (typeof item === 'string') {
result.push(this.compileToJSON(item, true));
} else {
result.push(item);
}
});
}
} else {
const object = {
start: '```',
content: str,
end: '\n```',
};
result.push(object);
//original_str += "```\n"+str+"\n```";
}
});
const all = {
original_str: original_str,
fallback_string: original_str.substr(0, 280) + (original_str.length > 280 ? '...' : ''),
prepared: result,
};
return all;
}
// eslint-disable-next-line no-redeclare
const original_str = str;
// eslint-disable-next-line no-redeclare
let result: any = [];
let min_index_of = -1;
let min_index_of_key: any = null;
let ret: any = [];
Object.keys(this.pseudo_markdown)
.sort((a, b) => b.length - a.length)
.forEach(starting_value => {
if (starting_value === 'text') {
return;
}
const allowed_char_before = this.pseudo_markdown[starting_value].allowed_char_before;
let tmp = str;
let offset = 0;
const indexes = [];
let did_match = -1;
do {
did_match = tmp.indexOf(starting_value);
let match_char_before =
!allowed_char_before ||
null !== tmp.slice(0, did_match).match(new RegExp(allowed_char_before + '$', 'gmi'));
match_char_before = match_char_before && tmp[did_match - 1] !== '\\';
tmp = tmp.slice(did_match + 1);
if (did_match >= 0 && match_char_before) indexes.push(did_match + offset);
offset = offset + did_match + 1;
} while (did_match >= 0);
if (indexes.length > 0) {
const mini = Math.min(...indexes);
if (min_index_of < 0 || mini < min_index_of) {
min_index_of = mini;
min_index_of_key = starting_value;
}
}
});
str = original_str;
if (min_index_of_key) {
let str_left = str.substr(0, min_index_of);
const char = min_index_of_key;
let str_right = str.substr(min_index_of + char.length);
//Seach end of element in str_right
let match: any = -1;
let add_to_value = '';
while (match < 0 || (match && match[1][match[1].length - 1] === '\\')) {
if (match && match !== -1) {
//It mean we found an antislashed element
add_to_value += match[0];
}
const countManaged =
(this.pseudo_markdown[char].allowed_chars || '').slice(-1) === '+' ||
(this.pseudo_markdown[char].allowed_chars || '').slice(-1) === '}';
const regex =
'^(' +
(this.pseudo_markdown[char].allowed_chars || '.') +
(countManaged ? '' : '*') +
(this.pseudo_markdown[char].end ? '?' : '') +
')' +
(this.pseudo_markdown[char].end ? '(' + this.pseudo_markdown[char].end + ')' : '');
match = str_right.substr(add_to_value.length).match(new RegExp(regex, ''));
}
let completion_end_char = '';
if (match) {
match[0] = add_to_value + match[0];
match[1] = add_to_value + match[1];
completion_end_char = this.pseudo_markdown[char].after_end ? match[3] || '' : '';
}
if (!match) {
str_left = str_left + char;
result = result.concat(str_left);
} else {
if (str_left) {
result = result.concat(str_left);
}
//Generate object
const object = {
start: char,
content: this.pseudo_markdown[char].disable_recursion
? match[1]
: this.compileToJSON(match[1], 1),
end: match[2],
};
result.push(object);
str_right = completion_end_char + str_right.substr(match[0].length);
}
result = result.concat(this.compileToJSON(str_right, 1));
ret = result;
} else {
if (original_str) {
ret = original_str;
} else {
ret = [];
}
}
return ret;
}
compileToHTML(
json: any,
is_app: any = false,
event_container: any = undefined,
text_transform: any = undefined,
) {
if (!text_transform) {
text_transform = {};
}
if (!json) {
return this.pseudo_markdown['text'].object('');
}
if (json.formatted || json.prepared) json = json.formatted || json.prepared;
if (typeof json === 'string') {
json = [json];
}
if (json.type || json.start) {
json = [json];
}
let el = null;
let child_contain_view = false;
const result: any = [];
try {
json.forEach((item: any) => {
if (typeof item === 'string') {
result.push(
this.pseudo_markdown['text'].object(item, is_app, event_container, text_transform),
);
} else if (Array.isArray(item)) {
el = this.compileToHTML(item, is_app, event_container, text_transform);
child_contain_view = child_contain_view || el.child_contain_view;
result.push(el);
} else {
let type = this.pseudo_markdown[item.start];
if (item.type === 'compile' && is_app && typeof item.content === 'string') {
el = this.compileToHTML(
this.compileToJSON(item.content),
is_app,
event_container,
text_transform,
);
child_contain_view = child_contain_view || el.child_contain_view;
result.push(el);
} else {
if (item.type) {
type = this.pseudo_markdown_types[item.type];
}
if (type) {
if (!type.apps_only || is_app) {
//If text transform do it
const old_text_transform = JSON.parse(JSON.stringify(text_transform));
text_transform = JSON.parse(JSON.stringify(text_transform));
if (type.text_transform) {
Object.keys(type.text_transform).forEach(key => {
text_transform[key] = type.text_transform[key];
});
}
el = this.compileToHTML(
item.content || '',
is_app,
event_container,
text_transform,
);
if (type.view) {
child_contain_view = true;
}
child_contain_view = child_contain_view || el.child_contain_view;
result.push(
type.object(el, item, event_container, text_transform, child_contain_view),
);
text_transform = old_text_transform;
}
}
}
}
});
} catch (e) {
return this.pseudo_markdown['text'].object('An error occured while showing this message.');
}
result.child_contain_view = child_contain_view;
result.forEach((item: any) => {
if (!item.child_contain_view && child_contain_view) {
item = this.pseudo_markdown['text_block_parent'].object(item);
}
});
return result;
}
compileToSimpleHTML(
json: any,
is_app = false,
text_transform: any = undefined,
result_analysis: any = undefined,
) {
if (!text_transform) {
text_transform = {};
}
if (!json) {
return this.pseudo_markdown['text'].object('');
}
if (!result_analysis) {
result_analysis = {
has_string: false,
};
}
if (json.formatted || json.prepared) json = json.formatted || json.prepared;
if (typeof json === 'string') {
json = [json];
}
if (json.type || json.start) {
json = [json];
}
const result: any = [];
try {
json.forEach((item: any) => {
if (typeof item === 'string') {
result_analysis.has_string = true;
result.push(
this.pseudo_markdown['text'].object(item, is_app, {}, text_transform, result_analysis),
);
} else if (Array.isArray(item)) {
result.push(this.compileToSimpleHTML(item, is_app, text_transform, result_analysis));
} else {
let type = this.pseudo_markdown[item.start];
if (item.type) {
type = this.pseudo_markdown_types[item.type];
}
if (type) {
if (item.type === 'compile' && is_app && typeof item.content === 'string') {
result.push(
this.compileToSimpleHTML(
this.compileToJSON(item.content),
is_app,
text_transform,
result_analysis,
),
);
} else {
if (item.type) {
type = this.pseudo_markdown_types[item.type];
}
if (type) {
if (!type.apps_only || is_app) {
//If text transform do it
const old_text_transform = JSON.parse(JSON.stringify(text_transform));
text_transform = JSON.parse(JSON.stringify(text_transform));
if (type.text_transform) {
Object.keys(type.text_transform).forEach(key => {
text_transform[key] = type.text_transform[key];
});
}
result.push(
(type.simple_object || type.object)(
this.compileToSimpleHTML(
item.content || '',
is_app,
text_transform,
result_analysis,
),
item,
{},
),
);
text_transform = old_text_transform;
}
}
}
}
}
});
} catch (e) {
console.log(e);
return this.pseudo_markdown['text'].object('An error occured while showing this message.');
}
if (!result_analysis.has_string) {
return this.pseudo_markdown['text'].object('No text content to display.');
}
return result;
}
compileToText(json: any) {
if (!json) {
return '';
}
if (typeof json === 'string') {
json = [json];
}
if (json.original_str) {
return this.transformBackChannelsUsers(json.original_str);
}
if (json.type || json.start) {
json = [json];
}
let result = '';
try {
json.forEach((item: any) => {
if (typeof item === 'string') {
let tmp = item;
Object.keys(this.pseudo_markdown).forEach(starting_value => {
let starting_value_reg = starting_value;
const allowed_chars = this.pseudo_markdown[starting_value].allowed_chars;
if (starting_value === '*') {
starting_value_reg = '\\*';
}
if (allowed_chars) {
const reg = new RegExp(starting_value_reg, 'gm');
tmp = tmp.replace(reg + '(' + allowed_chars + ')', '\\' + starting_value + '$1');
} else {
// eslint-disable-next-line no-redeclare
const reg = new RegExp(starting_value_reg, 'gm');
tmp = tmp.replace(reg, '\\' + starting_value);
}
});
result += tmp;
} else if (Array.isArray(item)) {
result += this.compileToText(item);
} else {
result += item.start || '';
result += this.compileToText(item.content);
result += item.end || '';
}
});
} catch (e) {
return '';
}
return this.transformBackChannelsUsers(result);
}
insertAtCursor(myField: any, myValue: any) {
//IE support
if ((document as any).selection) {
myField.focus();
const sel = (document as any).selection.createRange();
sel.text = myValue;
}
//MOZILLA and others
else if (myField.selectionStart || myField.selectionStart === '0') {
const startPos = myField.selectionStart;
const endPos = myField.selectionEnd;
myField.value =
myField.value.substring(0, startPos) +
myValue +
myField.value.substring(endPos, myField.value.length);
} else {
myField.value += myValue;
}
}
//Call this function after each line break
autoCompleteBulletList(input: any, didEnter: any) {
const getCursorPos = (input: any) => {
if ('selectionStart' in input && document.activeElement === input) {
return {
start: input.selectionStart,
end: input.selectionEnd,
};
} else if (input.createTextRange) {
const sel = (document as any).selection.createRange();
if (sel.parentElement() === input) {
const rng = input.createTextRange();
rng.moveToBookmark(sel.getBookmark());
let len = 0;
for (len; rng.compareEndPoints('EndToStart', rng) > 0; rng.moveEnd('character', -1)) {
len++;
rng.setEndPoint('StartToStart', input.createTextRange());
}
const pos = { start: 0, end: len };
for (pos; rng.compareEndPoints('EndToStart', rng) > 0; rng.moveEnd('character', -1)) {
pos.start++;
pos.end++;
}
return pos;
}
}
return -1;
};
const setCaretPosition = (ctrl: any, pos: any) => {
// Modern browsers
if (ctrl.setSelectionRange) {
ctrl.focus();
ctrl.setSelectionRange(pos, pos);
// IE8 and below
} else if (ctrl.createTextRange) {
const range = ctrl.createTextRange();
range.collapse(true);
range.moveEnd('character', pos);
range.moveStart('character', pos);
range.select();
}
};
if (didEnter) {
//@ts-ignore
const cursor_position = (getCursorPos(input) || {}).start;
if (cursor_position === false || cursor_position < 0) {
return;
}
const value = input.value;
const str_before = value.substr(0, cursor_position);
const str_after = value.substr(cursor_position);
const src_line_before = str_before.split('\n').pop();
let addon = '';
let to_remove = 0;
Object.keys(this.bullets).forEach(regex => {
const match = src_line_before.match(new RegExp('^' + regex, ''));
if (match) {
if (src_line_before.length > match[0].length) {
addon = this.bullets[regex](match);
} else {
to_remove = src_line_before.length;
}
}
});
if (to_remove > 0) {
input.value = str_before.substr(0, str_before.length - to_remove) + str_after;
setCaretPosition(input, cursor_position - to_remove);
} else {
input.value = str_before + '\n' + addon + str_after;
setCaretPosition(input, cursor_position + addon.length + 1);
}
return input.value;
}
}
}
const service = new PseudoMarkdownCompiler();
export default service;
@@ -1,194 +0,0 @@
import { ChannelType } from 'app/features/channels/types/channel';
import { UserType } from 'app/features/users/types/user';
import Strings from 'app/features/global/utils/strings';
import UsersService from 'app/features/users/services/current-user-service';
import Workspaces from 'app/deprecated/workspaces/workspaces.jsx';
import RouterServices from 'app/features/router/services/router-service';
import { getUserParts } from 'app/components/member/user-parts';
import Observable from 'app/deprecated/Observable/Observable';
import UserAPIClient from '../../users/api/user-api-client';
import ChannelsReachableAPIClient from '../../channels/api/channels-reachable-api-client';
import ChannelsMineAPIClient from '../../channels/api/channels-mine-api-client';
export type GenericChannel = {
type: 'user' | 'direct' | 'workspace';
sortString: string;
filterString: string;
lastActivity?: number;
resource: UserType | ChannelType;
};
class SearchListManager extends Observable {
private workspaceChannels: GenericChannel[];
private directChannels: GenericChannel[];
private users: GenericChannel[];
public list: GenericChannel[];
constructor() {
super();
this.workspaceChannels = [];
this.directChannels = [];
this.users = [];
this.list = [];
}
public async searchAll(
search: string,
opts?: {
onlyChannel?: boolean;
userListState?: UserType[];
},
): Promise<void> {
const { workspaceId, companyId } = RouterServices.getStateFromRoute();
// Reachable
let channels: ChannelType[] = [];
// Direct Channels
let directChannels: ChannelType[] = [];
// Mine
let mineWorkspaceChannels: ChannelType[] = [];
const usersSearched: UserType[] = opts?.userListState ? opts.userListState : [];
if (companyId && workspaceId) {
channels = await ChannelsReachableAPIClient.get(companyId, workspaceId);
directChannels = await ChannelsMineAPIClient.get({ companyId, workspaceId: 'direct' });
mineWorkspaceChannels = await ChannelsMineAPIClient.get({ companyId, workspaceId });
}
// Filters
this.workspaceChannels = this.filterWorkspaceChannels({
channels,
mineWorkspaceChannels,
});
this.directChannels = opts?.onlyChannel
? []
: this.filterDirectChannels({ channels: directChannels });
this.users = this.filterUsers({ users: usersSearched });
// Concat list
this.list = [...this.workspaceChannels, ...this.directChannels, ...this.users];
this.removeDuplicate();
this.list = this.list
.filter(({ filterString }) => {
return filterString.toUpperCase().indexOf(search.toUpperCase()) > -1;
})
.sort((a, b) => (b.lastActivity || 0) - (a.lastActivity || 0));
this.notify();
}
private async searchUsers(text: string) {
return UserAPIClient.search<UserType>(Strings.removeAccents(text), {
scope: 'company',
companyId: Workspaces.currentGroupId,
});
}
private filterWorkspaceChannels({
channels,
mineWorkspaceChannels,
}: {
channels: ChannelType[];
mineWorkspaceChannels: ChannelType[];
}) {
const workspaceChannels: GenericChannel[] = channels.map(channel => {
return {
sortString: channel.name || '',
filterString: channel.name || '',
type: 'workspace',
lastActivity: channel.last_activity || 0,
resource: channel,
};
});
return workspaceChannels.filter(channel => {
if (channel.type === 'workspace') {
const resource = channel.resource as ChannelType;
const isNotAbleToSeeChannel =
!this.isChannelMember(mineWorkspaceChannels, resource) &&
resource.visibility === 'private';
return !isNotAbleToSeeChannel;
}
return undefined;
});
}
private filterDirectChannels({ channels }: { channels: ChannelType[] }) {
const directChannels: GenericChannel[] = channels.map((channel: ChannelType) => {
const { name } = getUserParts({
usersIds: channel.members || [],
});
return {
sortString: name,
filterString: name,
type: 'direct',
lastActivity: channel.last_activity || 0,
resource: channel,
};
});
return directChannels;
}
private filterUsers({ users }: { users: UserType[] }) {
const usersSearched: GenericChannel[] = users.map(user => {
return (
user && {
sortString: UsersService.getFullName(user),
filterString: UsersService.getFullName(user),
type: 'user',
resource: user,
}
);
});
return usersSearched;
}
/**
* Remove duplicates between direct channels and users
*/
private removeDuplicate() {
const existingUsersIdAsDirectChannels = this.list
.filter(
userOrChannel =>
userOrChannel.type === 'direct' &&
((userOrChannel.resource as ChannelType).members?.length || 0) <= 2,
)
.map(userOrChannel => {
const channel = userOrChannel.resource as ChannelType;
if (channel.members?.length === 1) {
return channel.members[0];
}
if (channel.members?.length === 2) {
const otherUserId = channel.members.filter(
id => id !== UsersService.getCurrentUserId(),
)[0];
return otherUserId;
}
return undefined;
});
this.list = this.list.filter(userOrChannel => {
if (userOrChannel.type === 'user') {
const user = userOrChannel.resource as UserType;
return !existingUsersIdAsDirectChannels.includes(user.id);
}
return true;
});
}
private isChannelMember(mine: ChannelType[], resource: ChannelType) {
return mine.some(channel => resource.id === channel.id && channel.user_member?.user_id);
}
}
const SearchListManagerService = new SearchListManager();
export default SearchListManagerService;
@@ -1,9 +1,9 @@
/* eslint-disable @typescript-eslint/no-explicit-any */
import io from 'socket.io-client';
import { EventEmitter } from 'events';
import Logger from 'app/features/global/framework/logger-service';
import Logger from '@features/global/framework/logger-service';
import { WebsocketEvents, WebSocketListener, WebsocketRoomActions } from '../types/websocket-types';
import { Maybe } from 'app/features/global/types/global-types';
import { Maybe } from '@features/global/types/global-types';
export type WebSocketOptions = {
url: string;
@@ -1,4 +1,4 @@
import Observable from 'app/deprecated/CollectionsV1/observable.js';
import Observable from '@deprecated/CollectionsV1/observable.js';
class Autocomplete extends Observable {
constructor() {
@@ -1,5 +1,5 @@
import environment from 'app/environment/environment';
import Globals from 'app/features/global/services/globals-tdrive-app-service';
import environment from '@environment/environment';
import Globals from '@features/global/services/globals-tdrive-app-service';
export function addApiUrlIfNeeded(url: string, asCssUrl?: boolean): string {
function _wrap(url: string): string {
@@ -4,10 +4,10 @@ import 'moment/locale/fr';
import 'moment/locale/de';
import 'moment/locale/ja';
import 'moment/locale/es';
import Observable from 'app/deprecated/CollectionsV1/observable.js';
import UserService from 'app/features/users/services/current-user-service';
import Observable from '@deprecated/CollectionsV1/observable.js';
import UserService from '@features/users/services/current-user-service';
import Globals from 'app/features/global/services/globals-tdrive-app-service';
import Globals from '@features/global/services/globals-tdrive-app-service';
class DateTime extends Observable {
constructor() {
@@ -1,6 +1,6 @@
/* eslint-disable @typescript-eslint/no-explicit-any */
import { capitalize } from 'lodash';
import Globals from 'app/features/global/services/globals-tdrive-app-service';
import Globals from '@features/global/services/globals-tdrive-app-service';
class WindowState {
public readonly app_name: string = 'Tdrive';
@@ -1,5 +1,5 @@
import Observable from 'app/deprecated/CollectionsV1/observable.js';
import Api from 'app/features/global/framework/api-service';
import Observable from '@deprecated/CollectionsV1/observable.js';
import Api from '@features/global/framework/api-service';
class WorkspacePicker extends Observable {
constructor() {
@@ -1,108 +0,0 @@
import Api from 'app/features/global/framework/api-service';
import { TdriveService } from 'app/features/global/framework/registry-decorator-service';
import { InvitationType as InvitationRoleType, InvitedUser } from '../state/invitation';
import Logger from 'app/features/global/framework/logger-service';
type InvitationType = {
email: string;
role: string;
company_role: InvitationRoleType;
};
type WorkspaceUserInvitationResponseType = {
email: string;
status: 'ok' | 'error';
message?: string;
};
type WorkspaceUserInvitationPayloadType = {
invitations: InvitationType[];
channels: string[];
};
type WorkspaceInvitationTokenResponseType = {
resource: {
token: string;
};
};
type WorkspaceInvitationTokenPayloadType = {
channels: string[];
};
@TdriveService('InvitationApiClientService')
class InvitationApiClient {
private readonly apiBaseUrl: string = '/internal/services/workspaces/v1/companies';
logger: Logger.Logger;
constructor() {
this.logger = Logger.getLogger('Invitation');
}
/**
* Creates an invitation token to the workspace
*
* @param {String} companyId - the company
* @param {String} workspaceId - the workspace to be invited in.
* @param {String[]} channels - the channels to be invited in.
* @returns {String} - the invitation token.
*/
async createInvitationToken(
companyId: string,
workspaceId: string,
channels: string[],
): Promise<string> {
return Api.post<WorkspaceInvitationTokenPayloadType, WorkspaceInvitationTokenResponseType>(
`${this.apiBaseUrl}/${companyId}/workspaces/${workspaceId}/users/tokens`,
{ channels },
).then(({ resource }) => resource.token);
}
/**
* Invite users to workspace by email
*
* @param {String} companyId - the company id.
* @param {String} workspaceId - the workspace id.
* @param {InvitedUser[]} invitedUsers - the array of emails to invite with their roles.
*/
async inviteToWorkspace(companyId: string, workspaceId: string, invitedUsers: InvitedUser[], channels: string[]) {
const response = await Api.post<
WorkspaceUserInvitationPayloadType,
{ resources: WorkspaceUserInvitationResponseType[] }
>(`${this.apiBaseUrl}/${companyId}/workspaces/${workspaceId}/users/invite`, {
invitations: [
...invitedUsers.map(({ email, role }) => ({
email,
role: 'member',
company_role: role,
})),
],
channels,
});
if (!response.resources || !response.resources.length) {
this.logger.error('Failed to invite users to the workspace');
throw Error('Failed to invite users to the workspace');
}
if (response.resources.filter(({ message }) => message && message.includes('403')).length) {
this.logger.error('No access rights to invite to this company');
throw Error('Failed to invite users: No access rights to invite to this company');
}
if (response.resources.filter(({ status }) => status === 'error').length === response.resources.length) {
this.logger.error('Failed to invite users to the company');
throw Error('Failed to invite users');
}
response.resources
.filter(({ status }) => status === 'error')
.forEach(({ email, message }) => {
this.logger.error(`Failed to invite ${email}: ${message}`);
});
return response;
}
}
export default new InvitationApiClient();
@@ -1,30 +0,0 @@
import { usePublicOrPrivateChannels } from 'app/features/channels/hooks/use-public-or-private-channels';
import { ChannelType } from 'app/features/channels/types/channel';
import { uniqBy } from 'lodash';
import { useEffect } from 'react';
import { useRecoilState } from 'recoil';
import { invitationChannelListState, invitationChannelSelectionState } from '../state/invitation';
export const useInvitationChannels = () => {
const [channels, setSelectedChannels] = useRecoilState(invitationChannelListState);
const [open, setOpen] = useRecoilState(invitationChannelSelectionState);
const { publicChannels } = usePublicOrPrivateChannels();
const defaultChannels = (publicChannels || []).filter(({ is_default }) => is_default);
const setChannels = (channels: ChannelType[]): void => {
setSelectedChannels(uniqBy([...channels, ...defaultChannels], 'id'));
};
useEffect(() => {
setSelectedChannels(uniqBy([...channels, ...defaultChannels], 'id'));
}, []);
return {
openSelection: () => setOpen(true),
closeSelection: () => setOpen(false),
setChannels,
selectedChannels: channels,
open,
reset: () => setSelectedChannels(defaultChannels),
};
};
@@ -1,71 +0,0 @@
import { useCurrentCompany } from 'app/features/companies/hooks/use-companies';
import { useCurrentUser } from 'app/features/users/hooks/use-current-user';
import { useEffect, useState } from 'react';
import { useRecoilState } from 'recoil';
import { invitationEmailsState, InvitationType, invitationTypeState } from '../state/invitation';
export const useInvitationUsers = () => {
const { company } = useCurrentCompany();
const [invitedUsers, setInvitedUsers] = useRecoilState(invitationEmailsState);
const [role] = useRecoilState(invitationTypeState);
const { user: currentUser } = useCurrentUser();
const currentUserEmailDomain = currentUser?.email.split('@').pop();
const emailRegex = /^[\w-.]+@([\w-]+\.)+[\w-]{2,4}$/;
const [allowedMembers, setAllowedMembers] = useState<number>(
company.plan?.limits?.['company:members_limit'] === -1
? Infinity
: company.plan?.limits?.['company:members_limit'] || Infinity,
);
const [allowedGuests, setAllowedGuests] = useState<number>(
company.plan?.limits?.['company:guests_limit'] === -1
? Infinity
: company.plan?.limits?.['company:guests_limit'] || Infinity,
);
const [canAddInvitations, setCanAddInvitations] = useState<boolean>(
role === InvitationType.member ? allowedMembers > 0 : allowedGuests > 0,
);
const [membersLimitReached, setMembersLimitReached] = useState<boolean>(false);
useEffect(() => {
const invitedMembers = invitedUsers.filter(({ role }) => role === InvitationType.member);
const invitedGuests = invitedUsers.filter(({ role }) => role === InvitationType.guest);
setAllowedMembers(
(company.plan?.limits?.['company:members_limit'] === -1
? Infinity
: company.plan?.limits?.['company:members_limit'] || Infinity) - invitedMembers.length,
);
setAllowedGuests(
(company.plan?.limits?.['company:guests_limit'] === -1
? Infinity
: company.plan?.limits?.['company:guests_limit'] || Infinity) - invitedGuests.length,
);
if (role === InvitationType.member) {
setMembersLimitReached(allowedMembers <= 0);
} else {
setMembersLimitReached(false);
}
setCanAddInvitations(role === InvitationType.member ? allowedMembers > 0 : allowedGuests > 0);
}, []);
const addInvitation = (email: string): void => {
if (!emailRegex.test(email)) return;
if (email.split('@').pop() !== currentUserEmailDomain) return;
if (role === InvitationType.member && allowedMembers <= 0) return;
if (role === InvitationType.guest && allowedGuests <= 0) return;
if (invitedUsers.find(invitation => invitation.email === email)) return;
setInvitedUsers([...invitedUsers, { email, role }]);
};
return {
allowed_members: allowedMembers,
allowed_guests: allowedGuests,
addInvitation,
can_add_invitations: canAddInvitations,
members_limit_reached: membersLimitReached,
};
};
@@ -1,54 +0,0 @@
import { ToasterService } from 'app/features/global/services/toaster-service';
import useRouterCompany from 'app/features/router/hooks/use-router-company';
import useRouterWorkspace from 'app/features/router/hooks/use-router-workspace';
import { useRecoilState } from 'recoil';
import invitationApiClient from '../api/invitation-api-client';
import { invitationChannelListState, invitationEmailsState, invitationSentState } from '../state/invitation';
import { useInvitationChannels } from './use-invitation-channels';
export const useInvitation = () => {
const companyId = useRouterCompany();
const workspaceId = useRouterWorkspace();
const [invitedUsers, setInvitedUsers] = useRecoilState(invitationEmailsState);
const [channels] = useRecoilState(invitationChannelListState);
const [, setSentState] = useRecoilState(invitationSentState);
const { reset: resetChannels } = useInvitationChannels();
const send = async () => {
try {
await invitationApiClient.inviteToWorkspace(
companyId,
workspaceId,
invitedUsers,
channels.map(channel => channel.id as string),
);
setSentState(true);
}
catch(error) {
ToasterService.error((error as Error).toString());
}
}
const generateInvitationLink = async () => {
try {
const token = await invitationApiClient.createInvitationToken(
companyId,
workspaceId,
channels.map(channel => channel.id as string),
);
return `${window.location.origin}/?join=${token}`;
}
catch(error) {
ToasterService.error((error as Error).toString());
}
}
const reset = () => {
setSentState(false);
setInvitedUsers([]);
resetChannels();
}
return { send, generateInvitationLink, reset };
};
@@ -1,47 +0,0 @@
import { ChannelType } from 'app/features/channels/types/channel';
import { atom } from 'recoil';
export enum InvitationType {
guest = "guest",
member = "member",
}
export type InvitedUser = {
email: string,
role: InvitationType
}
export const invitationState = atom<boolean>({
default: false,
key: 'invitationState',
});
export const invitationActiveTab = atom<number>({
default: 0,
key: 'invitationActiveTabState',
});
export const invitationTypeState = atom<InvitationType>({
default: InvitationType.member,
key: 'invitationTypeState',
});
export const invitationEmailsState = atom<InvitedUser[]>({
default: [],
key: 'invitationEmailsState',
});
export const invitationChannelSelectionState = atom<boolean>({
default: false,
key: 'invitationChannelSelectionState',
});
export const invitationChannelListState = atom<ChannelType[]>({
default: [],
key: 'invitationChannelListState',
});
export const invitationSentState = atom<boolean>({
default: false,
key: 'invitationSentState',
});
@@ -1,262 +0,0 @@
import { TdriveService } from '../../global/framework/registry-decorator-service';
import {
Message,
MessageExtended,
MessageFileType,
MessageSeenType,
MessageWithReplies,
NodeMessage,
} from 'app/features/messages/types/message';
import MessageViewAPIClient from './message-view-api-client';
import MessageThreadAPIClient from './message-thread-api-client';
import Api from 'app/features/global/framework/api-service';
import { WebsocketRoom } from 'app/features/global/types/websocket-types';
import Numbers from 'app/features/global/utils/Numbers';
import { MetaDataType } from 'features/files/types/file';
import Workspace from 'app/deprecated/workspaces/workspaces';
import Logger from 'features/global/framework/logger-service';
import { UserType } from 'features/users/types/user';
import { AtomMessageKey } from '../state/atoms/messages';
/**
* This service is to get, update, create, list messages in a thread
*/
export interface BaseSearchOptions {
company_id?: string;
workspace_id?: string;
channel_id?: string;
page_token?: string;
limit?: number;
}
export interface FileSearchOptions extends BaseSearchOptions {
sender?: string;
is_file?: boolean;
is_media?: boolean;
extension?: string;
workspace_id?: string;
channel_id?: string;
next_page_token?: string;
}
@TdriveService('MessageAPIClientService')
class MessageAPIClient {
private readonly prefixUrl: string = '/internal/services/messages/v1';
private realtime: Map<string, WebsocketRoom[]> = new Map();
private readonly _viewService = MessageViewAPIClient;
private readonly threadService = MessageThreadAPIClient;
private logger = Logger.getLogger('MessageAPIClientService');
websockets(threadId: string): WebsocketRoom[] {
return this.realtime.get(threadId) || [];
}
async list(
companyId: string,
threadId: string,
{
limit = 25,
pageToken = '',
direction = 'future',
}: { limit?: number; pageToken?: string; direction?: 'future' | 'history' } = {},
) {
const response = await Api.get<{ resources: NodeMessage[]; websockets: WebsocketRoom[] }>(
`${this.prefixUrl}/companies/${companyId}/threads/${threadId}/messages?limit=${limit}&include_users=1&page_token=${pageToken}&direction=${direction}`,
);
this.realtime.set(threadId, response.websockets);
return (response.resources || []).sort((a, b) => Numbers.compareTimeuuid(a.id, b.id));
}
async get(companyId: string, threadId: string, messageId: string) {
const response = await Api.get<{ resource: MessageWithReplies }>(
`${this.prefixUrl}/companies/${companyId}/threads/${threadId}/messages/${messageId}?include_users=1`,
);
return response.resource;
}
async reaction(companyId: string, threadId: string, messageId: string, reactions: string[] = []) {
const response = await Api.post<{ reactions: string[] }, { resource: NodeMessage }>(
`${this.prefixUrl}/companies/${companyId}/threads/${threadId}/messages/${messageId}/reaction`,
{ reactions },
);
return response.resource;
}
async bookmark(
companyId: string,
threadId: string,
messageId: string,
bookmarkId: string,
active = true,
) {
const response = await Api.post<
{ bookmark_id: string; active: boolean },
{ resource: NodeMessage }
>(
`${this.prefixUrl}/companies/${companyId}/threads/${threadId}/messages/${messageId}/bookmark`,
{ bookmark_id: bookmarkId, active },
);
return response.resource;
}
async pin(companyId: string, threadId: string, messageId: string, pin = true) {
const response = await Api.post<{ pin: boolean }, { resource: NodeMessage }>(
`${this.prefixUrl}/companies/${companyId}/threads/${threadId}/messages/${messageId}/pin`,
{ pin },
);
return response.resource;
}
async delete(companyId: string, threadId: string, messageId: string) {
const response = await Api.post<unknown, { resource: NodeMessage }>(
`${this.prefixUrl}/companies/${companyId}/threads/${threadId}/messages/${messageId}/delete`,
{},
);
return response.resource;
}
async save(
companyId: string,
threadId: string,
message: Partial<NodeMessage>,
{
movedFromThread = undefined,
}: {
movedFromThread?: string;
} = {},
) {
const response = await Api.post<
{ resource: Partial<NodeMessage>; options: { previous_thread?: string } },
{ resource: NodeMessage }
>(
`${this.prefixUrl}/companies/${companyId}/threads/${threadId}/messages${
message.id ? '/' + message.id : ''
}`,
{ resource: message, options: { previous_thread: movedFromThread } },
);
return response.resource;
}
async download(messageFile: MessageFileType) {
if (messageFile.thread_id)
await Api.post(
`${this.prefixUrl}/companies/${messageFile.company_id}/threads/${messageFile.thread_id}/messages/${messageFile.message_id}/download/${messageFile.id}`,
{},
);
}
/**
* Delete a link preview from a message
*
* @param {String} companyId - The company id
* @param {String} threadId - The thread id
* @param {String} messageId - The message id
* @param {String} url - The url to delete from the previews
* @returns {Promise<void>}
*/
async deleteLinkPreview(companyId: string, threadId: string, messageId: string, url: string) {
const response = await Api.post<{ url: string }, { resource: NodeMessage }>(
`${this.prefixUrl}/companies/${companyId}/threads/${threadId}/messages/${messageId}/deletelink`,
{ url },
);
return response.resource;
}
async search(searchString: string, options?: BaseSearchOptions) {
const companyId = options?.company_id ? options.company_id : Workspace.currentGroupId;
const query = `/internal/services/messages/v1/companies/${companyId}/search?q=${searchString}&include_users=1`;
const res = await Api.getWithParams<{ resources: MessageExtended[] }>(query, options);
this.logger.debug(
`Message search by text "${searchString}". Found`,
res.resources.length,
'messages',
);
return res;
}
async searchFile(searchString: string | null, options?: FileSearchOptions) {
try {
const companyId = options?.company_id ? options.company_id : Workspace.currentGroupId;
let query = `/internal/services/messages/v1/companies/${companyId}/files/search`;
if (searchString) {
query += `?q=${searchString}`;
}
const res = await Api.getWithParams<{
resources: (MessageFileType & {
company_id: string;
metadata: MetaDataType;
created_at: number;
message: Message;
user: UserType;
})[];
next_page_token: string;
}>(query, options);
return {
resources: res.resources,
next_page_token: res.next_page_token,
};
} catch (e) {
return { resources: [], next_page_token: null };
}
}
/**
* Mark messages as seen
*
* @param {String} companyId - The company id
* @param {String} channelId - The channel
* @param {String} workspaceId - the workspace
* @param {AtomMessageKey[]} messages - the messages to mark as seen
* @returns {Promise<boolean>} - true if the messages were marked as seen
*/
async read(
companyId: string,
channelId: string,
workspaceId: string,
messages: AtomMessageKey[],
): Promise<boolean> {
if (!messages || !messages.length) {
return true;
}
const body = {
messages: messages.map(message => ({
thread_id: message.threadId,
message_id: message.id || message.threadId,
})),
channel_id: channelId,
};
return await Api.post<MessageSeenType, boolean>(
`${this.prefixUrl}/companies/${companyId}/workspaces/${workspaceId}/threads/read`,
body,
);
}
/**
* List the users who've seen the message
*
* @param {String} messageId - the message id
* @param {String} companyId - the company id
* @param {String} workspaceId - the workspace id
* @returns {Promise<UserType[]>} - the users list
*/
async seenBy(
messageId: string,
threadId: string,
companyId: string,
workspaceId: string,
): Promise<UserType[]> {
const { resources } = await Api.get<{ resources: UserType[] }>(
`${this.prefixUrl}/companies/${companyId}/workspaces/${workspaceId}/threads/${threadId}/messages/${messageId}/seen`,
);
return resources;
}
}
export default new MessageAPIClient();
@@ -1,63 +0,0 @@
import {
NodeMessage,
Thread,
Participant,
MessageWithReplies,
} from 'app/features/messages/types/message';
import Api from 'app/features/global/framework/api-service';
import { TdriveService } from 'app/features/global/framework/registry-decorator-service';
/**
* This service is to create and update a thread
*/
@TdriveService('MessageThreadAPIClient')
class MessageThreadAPIClient {
private readonly prefixUrl: string = '/internal/services/messages/v1';
buildChannelParticipant(companyId: string, workspaceId: string, channelId: string) {
return {
type: 'channel',
company_id: companyId,
workspace_id: workspaceId,
id: channelId,
} as Participant;
}
async save(
companyId: string,
options: { message: NodeMessage; participants?: Participant[] },
): Promise<MessageWithReplies> {
const response = await Api.post<
{ resource: { participants: Participant[] }; options: { message: NodeMessage } },
{ resource: Thread & { message: NodeMessage } }
>(`${this.prefixUrl}/companies/${companyId}/threads`, {
resource: { participants: options.participants || [] },
options: { message: options.message },
});
return {
...response.resource.message,
last_replies: [],
stats: {
last_activity: response.resource.created_at,
replies: 0,
},
};
}
async participants(
companyId: string,
threadId: string,
participants: { add: Participant[]; remove: Participant[] },
) {
const response = await Api.post<
{ resource: unknown; options: { participants: { add: Participant[]; remove: Participant[] } } },
{ resource: Thread }
>(`${this.prefixUrl}/companies/${companyId}/threads/${threadId}`, {
resource: {},
options: { participants: participants },
});
return response.resource;
}
}
export default new MessageThreadAPIClient();
@@ -1,47 +0,0 @@
import { MessageWithReplies } from 'app/features/messages/types/message';
import { TdriveService } from 'app/features/global/framework/registry-decorator-service';
import Api from 'app/features/global/framework/api-service';
import { WebsocketRoom } from 'app/features/global/types/websocket-types';
import Numbers from 'app/features/global/utils/Numbers';
/**
* This service is to get messages using views.
* A view can be:
* - channel feed view
* - channel pinned messages view
* - my active threads view
* - ...
*/
@TdriveService('MessageViewAPIClientService')
class MessageViewAPIClient {
private readonly prefixUrl: string = '/internal/services/messages/v1';
private realtime: Map<string, WebsocketRoom[]> = new Map();
feedWebsockets(channelId: string): WebsocketRoom[] {
return this.realtime.get('feed-' + channelId) || [];
}
async feed(
companyId: string,
workspaceId: string,
channelId: string,
{ repliesPerThread = 5, limit = 25, pageToken = '', direction = 'future' } = {},
) {
if (!companyId || !workspaceId || !channelId) {
return;
}
const response = await Api.get<{
resources: MessageWithReplies[];
websockets: WebsocketRoom[];
}>(
`${this.prefixUrl}/companies/${companyId}/workspaces/${workspaceId}/channels/${channelId}/feed?replies_per_thread=${repliesPerThread}&limit=${limit}&include_users=1&page_token=${pageToken}&direction=${direction}&websockets=1`,
);
this.realtime.set('feed-' + channelId, response.websockets);
return (response.resources || []).sort((a, b) =>
Numbers.compareTimeuuid(a.thread_id, b.thread_id),
);
}
}
export default new MessageViewAPIClient();

Some files were not shown because too many files have changed in this diff Show More