verdnatura-mirror/Rocket.Chat.ReactNative
verdnatura-mirror
/
Rocket.Chat.ReactNative
mirror of https://github.com/RocketChat/Rocket.Chat.ReactNative
2
0
Fork 1
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'develop' into chore/migration-ts-redux-sortPreferences

This commit is contained in:
Gleidson Daniel Silva 2022-01-26 13:33:04 -03:00 committed by GitHub
parent cfbb3c8d27 596e8208b3
commit 2b3f67f801
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
38 changed files with 817 additions and 507 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
app/actions/customEmojis.js
View File

@ -1,8 +0,0 @@
import * as types from './actionsTypes';
export function setCustomEmojis(emojis) {
return {
type: types.SET_CUSTOM_EMOJIS,
emojis
};
}

17
app/actions/customEmojis.ts Normal file
View File

@ -0,0 +1,17 @@
import { Action } from 'redux';
import { ICustomEmojis } from '../reducers/customEmojis';
import { SET_CUSTOM_EMOJIS } from './actionsTypes';
export interface ISetCustomEmojis extends Action {
emojis: ICustomEmojis;
}
export type TActionCustomEmojis = ISetCustomEmojis;
export function setCustomEmojis(emojis: ICustomEmojis): ISetCustomEmojis {
return {
type: SET_CUSTOM_EMOJIS,
emojis
};
}

35
app/actions/encryption.js
View File

@ -1,35 +0,0 @@
import * as types from './actionsTypes';
export function encryptionInit() {
return {
type: types.ENCRYPTION.INIT
};
}
export function encryptionStop() {
return {
type: types.ENCRYPTION.STOP
};
}
export function encryptionSet(enabled = false, banner = null) {
return {
type: types.ENCRYPTION.SET,
enabled,
banner
};
}
export function encryptionSetBanner(banner) {
return {
type: types.ENCRYPTION.SET_BANNER,
banner
};
}
export function encryptionDecodeKey(password) {
return {
type: types.ENCRYPTION.DECODE_KEY,
password
};
}

52
app/actions/encryption.ts Normal file
View File

@ -0,0 +1,52 @@
import { Action } from 'redux';
import { IBanner } from '../reducers/encryption';
import { ENCRYPTION } from './actionsTypes';
export interface IEncryptionSet extends Action {
enabled: boolean;
banner: IBanner;
}
export interface IEncryptionSetBanner extends Action {
banner: IBanner;
}
export interface IEncryptionDecodeKey extends Action {
password: string;
}
export type TActionEncryption = IEncryptionSet & IEncryptionSetBanner & IEncryptionDecodeKey;
export function encryptionInit(): Action {
return {
type: ENCRYPTION.INIT
};
}
export function encryptionStop(): Action {
return {
type: ENCRYPTION.STOP
};
}
export function encryptionSet(enabled = false, banner: IBanner = ''): IEncryptionSet {
return {
type: ENCRYPTION.SET,
enabled,
banner
};
}
export function encryptionSetBanner(banner: IBanner = ''): IEncryptionSetBanner {
return {
type: ENCRYPTION.SET_BANNER,
banner
};
}
export function encryptionDecodeKey(password: string): IEncryptionDecodeKey {
return {
type: ENCRYPTION.DECODE_KEY,
password
};
}

54
app/actions/inviteLinks.js
View File

@ -1,54 +0,0 @@
import * as types from './actionsTypes';
export function inviteLinksSetToken(token) {
return {
type: types.INVITE_LINKS.SET_TOKEN,
token
};
}
export function inviteLinksRequest(token) {
return {
type: types.INVITE_LINKS.REQUEST,
token
};
}
export function inviteLinksSuccess() {
return {
type: types.INVITE_LINKS.SUCCESS
};
}
export function inviteLinksFailure() {
return {
type: types.INVITE_LINKS.FAILURE
};
}
export function inviteLinksClear() {
return {
type: types.INVITE_LINKS.CLEAR
};
}
export function inviteLinksCreate(rid) {
return {
type: types.INVITE_LINKS.CREATE,
rid
};
}
export function inviteLinksSetParams(params) {
return {
type: types.INVITE_LINKS.SET_PARAMS,
params
};
}
export function inviteLinksSetInvite(invite) {
return {
type: types.INVITE_LINKS.SET_INVITE,
invite
};
}

61
app/actions/inviteLinks.ts Normal file
View File

@ -0,0 +1,61 @@
import { Action } from 'redux';
import { TInvite } from '../reducers/inviteLinks';
import { INVITE_LINKS } from './actionsTypes';
interface IInviteLinksGeneric extends Action {
token: string;
}
interface IInviteLinksCreate extends Action {
rid: string;
}
interface IInviteLinksSetInvite extends Action {
invite: TInvite;
}
type TParams = Record<string, any>;
interface IInviteLinksSetParams extends Action {
params: TParams;
}
export type TActionInviteLinks = IInviteLinksGeneric & IInviteLinksCreate & IInviteLinksSetInvite & IInviteLinksSetParams;
export const inviteLinksSetToken = (token: string): IInviteLinksGeneric => ({
type: INVITE_LINKS.SET_TOKEN,
token
});
export const inviteLinksRequest = (token: string): IInviteLinksGeneric => ({
type: INVITE_LINKS.REQUEST,
token
});
export const inviteLinksSuccess = (): Action => ({
type: INVITE_LINKS.SUCCESS
});
export const inviteLinksFailure = (): Action => ({
type: INVITE_LINKS.FAILURE
});
export const inviteLinksClear = (): Action => ({
type: INVITE_LINKS.CLEAR
});
export const inviteLinksCreate = (rid: string): IInviteLinksCreate => ({
type: INVITE_LINKS.CREATE,
rid
});
export const inviteLinksSetParams = (params: TParams): IInviteLinksSetParams => ({
type: INVITE_LINKS.SET_PARAMS,
params
});
export const inviteLinksSetInvite = (invite: TInvite): IInviteLinksSetInvite => ({
type: INVITE_LINKS.SET_INVITE,
invite
});

8
app/actions/messages.js
View File

@ -1,8 +0,0 @@
import * as types from './actionsTypes';
export function replyBroadcast(message) {
return {
type: types.MESSAGES.REPLY_BROADCAST,
message
};
}

16
app/actions/messages.ts Normal file
View File

@ -0,0 +1,16 @@
import { Action } from 'redux';
import { MESSAGES } from './actionsTypes';
type IMessage = Record<string, string>;
interface IReplyBroadcast extends Action {
message: IMessage;
}
export function replyBroadcast(message: IMessage): IReplyBroadcast {
return {
type: MESSAGES.REPLY_BROADCAST,
message
};
}

20
app/actions/roles.js
View File

@ -1,20 +0,0 @@
import * as types from './actionsTypes';
export function setRoles(roles) {
return {
type: types.ROLES.SET,
roles
};
}
export function updateRoles(id, desc) {
return {
type: types.ROLES.UPDATE,
payload: { id, desc }
};
}
export function removeRoles(id) {
return {
type: types.ROLES.REMOVE,
payload: { id }
};
}

39
app/actions/roles.ts Normal file
View File

@ -0,0 +1,39 @@
import { Action } from 'redux';
import { IRoles } from '../reducers/roles';
import { ROLES } from './actionsTypes';
export interface ISetRoles extends Action {
roles: IRoles;
}
export interface IUpdateRoles extends Action {
payload: { id: string; desc: string };
}
export interface IRemoveRoles extends Action {
payload: { id: string };
}
export type IActionRoles = ISetRoles & IUpdateRoles & IRemoveRoles;
export function setRoles(roles: IRoles): ISetRoles {
return {
type: ROLES.SET,
roles
};
}
export function updateRoles(id: string, desc: string): IUpdateRoles {
return {
type: ROLES.UPDATE,
payload: { id, desc }
};
}
export function removeRoles(id: string): IRemoveRoles {
return {
type: ROLES.REMOVE,
payload: { id }
};
}

58
app/actions/rooms.js
View File

@ -1,58 +0,0 @@
import * as types from './actionsTypes';
export function roomsRequest(params = { allData: false }) {
return {
type: types.ROOMS.REQUEST,
params
};
}
export function roomsSuccess() {
return {
type: types.ROOMS.SUCCESS
};
}
export function roomsFailure(err) {
return {
type: types.ROOMS.FAILURE,
err
};
}
export function roomsRefresh() {
return {
type: types.ROOMS.REFRESH
};
}
export function setSearch(searchText) {
return {
type: types.ROOMS.SET_SEARCH,
searchText
};
}
export function closeServerDropdown() {
return {
type: types.ROOMS.CLOSE_SERVER_DROPDOWN
};
}
export function toggleServerDropdown() {
return {
type: types.ROOMS.TOGGLE_SERVER_DROPDOWN
};
}
export function openSearchHeader() {
return {
type: types.ROOMS.OPEN_SEARCH_HEADER
};
}
export function closeSearchHeader() {
return {
type: types.ROOMS.CLOSE_SEARCH_HEADER
};
}

78
app/actions/rooms.ts Normal file
View File

@ -0,0 +1,78 @@
import { Action } from 'redux';
import { ROOMS } from './actionsTypes';
export interface IRoomsRequest extends Action {
params: any;
}
export interface ISetSearch extends Action {
searchText: string;
}
export interface IRoomsFailure extends Action {
err: Record<string, any> | string;
}
export type IRoomsAction = IRoomsRequest & ISetSearch & IRoomsFailure;
export function roomsRequest(
params: {
allData: boolean;
} = { allData: false }
): IRoomsRequest {
return {
type: ROOMS.REQUEST,
params
};
}
export function roomsSuccess(): Action {
return {
type: ROOMS.SUCCESS
};
}
export function roomsFailure(err: string): IRoomsFailure {
return {
type: ROOMS.FAILURE,
err
};
}
export function roomsRefresh(): Action {
return {
type: ROOMS.REFRESH
};
}
export function setSearch(searchText: string): ISetSearch {
return {
type: ROOMS.SET_SEARCH,
searchText
};
}
export function closeServerDropdown(): Action {
return {
type: ROOMS.CLOSE_SERVER_DROPDOWN
};
}
export function toggleServerDropdown(): Action {
return {
type: ROOMS.TOGGLE_SERVER_DROPDOWN
};
}
export function openSearchHeader(): Action {
return {
type: ROOMS.OPEN_SEARCH_HEADER
};
}
export function closeSearchHeader(): Action {
return {
type: ROOMS.CLOSE_SEARCH_HEADER
};
}

5
app/actions/server.js
View File

@ -24,11 +24,12 @@ export function selectServerFailure() {
};
}
export function serverRequest(server, username = null, fromServerHistory = false) {
// TODO
export function serverRequest(server, username, fromServerHistory = false) {
return {
type: SERVER.REQUEST,
server,
username,
username: username || null,
fromServerHistory
};
}

21
app/actions/settings.js
View File

@ -1,21 +0,0 @@
import { SETTINGS } from './actionsTypes';
export function addSettings(settings) {
return {
type: SETTINGS.ADD,
payload: settings
};
}
export function updateSettings(id, value) {
return {
type: SETTINGS.UPDATE,
payload: { id, value }
};
}
export function clearSettings() {
return {
type: SETTINGS.CLEAR
};
}

34
app/actions/settings.ts Normal file
View File

@ -0,0 +1,34 @@
import { Action } from 'redux';
import { ISettings, TSettings } from '../reducers/settings';
import { SETTINGS } from './actionsTypes';
interface IAddSettings extends Action {
payload: ISettings;
}
interface IUpdateSettings extends Action {
payload: { id: string; value: TSettings };
}
export type IActionSettings = IAddSettings & IUpdateSettings;
export function addSettings(settings: ISettings): IAddSettings {
return {
type: SETTINGS.ADD,
payload: settings
};
}
export function updateSettings(id: string, value: TSettings): IUpdateSettings {
return {
type: SETTINGS.UPDATE,
payload: { id, value }
};
}
export function clearSettings(): Action {
return {
type: SETTINGS.CLEAR
};
}

1
app/definitions/index.ts
View File

@ -9,6 +9,7 @@ export * from './IRoom';
export * from './IServer';
export * from './ISubscription';
export * from './IPreferences';
export * from './IServerHistory';
export interface IBaseScreen<T extends Record<string, object | undefined>, S extends string> {
navigation: StackNavigationProp<T, S>;

26
app/definitions/redux/index.ts
View File

@ -1,12 +1,21 @@
import { TActionActiveUsers } from '../../actions/activeUsers';
import { TActionCustomEmojis } from '../../actions/customEmojis';
import { TActionEncryption } from '../../actions/encryption';
import { TActionInviteLinks } from '../../actions/inviteLinks';
import { IActionRoles } from '../../actions/roles';
import { TActionSelectedUsers } from '../../actions/selectedUsers';
import { IActionSettings } from '../../actions/settings';
import { TActionSortPreferences } from '../../actions/sortPreferences';
// REDUCERS
import { IActiveUsers } from '../../reducers/activeUsers';
import { IEncryption } from '../../reducers/encryption';
import { IInviteLinks } from '../../reducers/inviteLinks';
import { IRoles } from '../../reducers/roles';
import { ISelectedUsers } from '../../reducers/selectedUsers';
import { ISettings } from '../../reducers/settings';
export interface IApplicationState {
settings: any;
settings: ISettings;
login: any;
meteor: any;
server: any;
@ -20,13 +29,20 @@ export interface IApplicationState {
customEmojis: any;
activeUsers: IActiveUsers;
usersTyping: any;
inviteLinks: any;
inviteLinks: IInviteLinks;
createDiscussion: any;
inquiry: any;
enterpriseModules: any;
encryption: any;
encryption: IEncryption;
permissions: any;
roles: any;
roles: IRoles;
}
export type TApplicationActions = TActionActiveUsers & TActionSelectedUsers & TActionSortPreferences;
export type TApplicationActions = TActionActiveUsers &
TActionSelectedUsers &
TActionCustomEmojis &
TActionInviteLinks &
IActionRoles &
IActionSettings &
TActionEncryption &
TActionSortPreferences;

14
app/reducers/customEmojis.js
View File

@ -1,14 +0,0 @@
import { SET_CUSTOM_EMOJIS } from '../actions/actionsTypes';
const initialState = {
customEmojis: {}
};
export default function customEmojis(state = initialState, action) {
switch (action.type) {
case SET_CUSTOM_EMOJIS:
return action.emojis;
default:
return state;
}
}

16
app/reducers/customEmojis.test.ts Normal file
View File

@ -0,0 +1,16 @@
import { setCustomEmojis } from '../actions/customEmojis';
import { ICustomEmojis, initialState } from './customEmojis';
import { mockedStore } from './mockedStore';
describe('test reducer', () => {
it('should return initial state', () => {
const state = mockedStore.getState().customEmojis;
expect(state).toEqual(initialState);
});
it('should return modified store after action', () => {
const emojis: ICustomEmojis = { dog: { name: 'dog', extension: 'jpg' }, cat: { name: 'cat', extension: 'jpg' } };
mockedStore.dispatch(setCustomEmojis(emojis));
const state = mockedStore.getState().customEmojis;
expect(state).toEqual(emojis);
});
});

23
app/reducers/customEmojis.ts Normal file
View File

@ -0,0 +1,23 @@
import { SET_CUSTOM_EMOJIS } from '../actions/actionsTypes';
import { TApplicationActions } from '../definitions';
// There are at least three interfaces for emoji, but none of them includes only this data.
interface IEmoji {
name: string;
extension: string;
}
export interface ICustomEmojis {
[key: string]: IEmoji;
}
export const initialState: ICustomEmojis = {};
export default function customEmojis(state = initialState, action: TApplicationActions): ICustomEmojis {
switch (action.type) {
case SET_CUSTOM_EMOJIS:
return action.emojis;
default:
return state;
}
}

28
app/reducers/encryption.test.ts Normal file
View File

@ -0,0 +1,28 @@
import { encryptionSet, encryptionInit, encryptionSetBanner } from '../actions/encryption';
import { mockedStore } from './mockedStore';
import { initialState } from './encryption';
describe('test encryption reducer', () => {
it('should return initial state', () => {
const state = mockedStore.getState().encryption;
expect(state).toEqual(initialState);
});
it('should return modified store after encryptionSet', () => {
mockedStore.dispatch(encryptionSet(true, 'BANNER'));
const state = mockedStore.getState().encryption;
expect(state).toEqual({ banner: 'BANNER', enabled: true });
});
it('should return empty store after encryptionInit', () => {
mockedStore.dispatch(encryptionInit());
const state = mockedStore.getState().encryption;
expect(state).toEqual({ banner: '', enabled: false });
});
it('should return initial state after encryptionSetBanner', () => {
mockedStore.dispatch(encryptionSetBanner('BANNER_NEW'));
const state = mockedStore.getState().encryption;
expect(state).toEqual({ banner: 'BANNER_NEW', enabled: false });
});
});

13
app/reducers/encryption.js → app/reducers/encryption.ts
View File

@ -1,11 +1,18 @@
import { ENCRYPTION } from '../actions/actionsTypes';
import { TApplicationActions } from '../definitions';
const initialState = {
export type IBanner = string;
export interface IEncryption {
enabled: boolean;
banner: IBanner;
}
export const initialState: IEncryption = {
enabled: false,
banner: null
banner: ''
};
export default function encryption(state = initialState, action) {
export default function encryption(state = initialState, action: TApplicationActions): IEncryption {
switch (action.type) {
case ENCRYPTION.SET:
return {

72
app/reducers/inviteLinks.test.ts Normal file
View File

@ -0,0 +1,72 @@
import {
inviteLinksClear,
inviteLinksFailure,
inviteLinksRequest,
inviteLinksSetInvite,
inviteLinksSetParams,
inviteLinksSetToken,
inviteLinksSuccess
} from '../actions/inviteLinks';
import { initialState } from './inviteLinks';
import { mockedStore } from './mockedStore';
describe('test roles reducer', () => {
const invite = {
_id: 'nZestg',
days: 1,
maxUses: 0,
createdAt: '2022-01-17T20:32:44.695Z',
expires: '2022-01-18T20:32:44.695Z',
uses: 0,
_updatedAt: '2022-01-17T20:32:44.695Z',
url: 'https://go.rocket.chat/invite?host=open.rocket.chat&path=invite%2FnZestg',
success: true,
token: ''
};
it('should return initial state', () => {
const state = mockedStore.getState().inviteLinks;
expect(state).toEqual(initialState);
});
it('should return initialState after call inviteLinksFailure', () => {
mockedStore.dispatch(inviteLinksFailure());
const state = mockedStore.getState().inviteLinks;
expect(state).toEqual(initialState);
});
it('should return initialState after call inviteLinksSuccess', () => {
mockedStore.dispatch(inviteLinksSuccess());
const state = mockedStore.getState().inviteLinks;
expect(state).toEqual(initialState);
});
it('should return correctly token after call inviteLinksSetToken', () => {
mockedStore.dispatch(inviteLinksSetToken('xxx'));
const { token } = mockedStore.getState().inviteLinks;
expect(token).toEqual('xxx');
});
it('should return correctly invite value after call inviteLinksSetInvite', () => {
mockedStore.dispatch(inviteLinksSetInvite(invite));
const state = mockedStore.getState().inviteLinks;
expect(state.invite).toEqual(invite);
});
it('should return modified store after call inviteLinksSetParams', () => {
mockedStore.dispatch(inviteLinksSetParams({ token: 'nZestg' }));
const { token } = mockedStore.getState().inviteLinks;
expect(token).toEqual('nZestg');
});
it('should return initialState after call inviteLinksClear', () => {
mockedStore.dispatch(inviteLinksClear());
const state = mockedStore.getState().inviteLinks;
expect(state).toEqual(initialState);
});
it('should return actual state after call inviteLinksRequest', () => {
mockedStore.dispatch(inviteLinksRequest('xxx'));
const state = mockedStore.getState().inviteLinks;
expect(state).toEqual(initialState);
});
});

20
app/reducers/inviteLinks.js → app/reducers/inviteLinks.ts
View File

@ -1,18 +1,26 @@
import { TActionInviteLinks } from '../actions/inviteLinks';
import { INVITE_LINKS } from '../actions/actionsTypes';
const initialState = {
export type TInvite = { url: string; expires: string; maxUses: number; uses: number; [x: string]: any };
export interface IInviteLinks {
token: string;
days: number;
maxUses: number;
invite: TInvite;
}
export const initialState: IInviteLinks = {
token: '',
days: 1,
maxUses: 0,
invite: {}
invite: { url: '', expires: '', maxUses: 0, uses: 0 }
};
export default (state = initialState, action) => {
export default (state = initialState, action: TActionInviteLinks): IInviteLinks => {
switch (action.type) {
case INVITE_LINKS.SET_TOKEN:
return {
token: action.token
};
return { ...state, token: action.token };
case INVITE_LINKS.SET_PARAMS:
return {
...state,

35
app/reducers/roles.test.ts Normal file
View File

@ -0,0 +1,35 @@
import { setRoles, updateRoles, removeRoles } from '../actions/roles';
import { mockedStore } from './mockedStore';
import { initialState } from './roles';
describe('test roles reducer', () => {
it('should return initial state', () => {
const state = mockedStore.getState().roles;
expect(state).toEqual(initialState);
});
it('should return modified store after call setRoles action', () => {
const roles = { admin: 'enabled', user: 'enabled', dog: 'carlitos' };
mockedStore.dispatch(setRoles(roles));
const state = mockedStore.getState().roles;
expect(state.admin).toEqual('enabled');
expect(state.user).toEqual('enabled');
expect(state.dog).toEqual('carlitos');
});
it('should return modified store after call updateRoles action', () => {
mockedStore.dispatch(updateRoles('admin', 'disabled'));
const state = mockedStore.getState().roles;
expect(state.admin).toEqual('disabled');
expect(state.user).toEqual('enabled');
expect(state.dog).toEqual('carlitos');
});
it('should return modified store after call removeRoles action', () => {
mockedStore.dispatch(removeRoles('dog'));
const state = mockedStore.getState().roles;
expect(state.admin).toEqual('disabled');
expect(state.user).toEqual('enabled');
expect(state.dog).toEqual(undefined);
});
});

7
app/reducers/roles.js → app/reducers/roles.ts
View File

@ -1,8 +1,11 @@
import { ROLES } from '../actions/actionsTypes';
import { IActionRoles } from '../actions/roles';
const initialState = {};
export type IRoles = Record<string, string>;
export default function permissions(state = initialState, action) {
export const initialState: IRoles = {};
export default function roles(state = initialState, action: IActionRoles): IRoles {
switch (action.type) {
case ROLES.SET:
return action.roles;

77
app/reducers/rooms.test.ts Normal file
View File

@ -0,0 +1,77 @@
import {
closeSearchHeader,
closeServerDropdown,
openSearchHeader,
roomsFailure,
roomsRefresh,
roomsRequest,
roomsSuccess,
setSearch,
toggleServerDropdown
} from '../actions/rooms';
import { mockedStore } from './mockedStore';
import { initialState } from './rooms';
describe('test selectedUsers reducer', () => {
it('should return initial state', () => {
const state = mockedStore.getState().rooms;
expect(state).toEqual(initialState);
});
it('should return modified store after call roomsRequest', () => {
mockedStore.dispatch(roomsRequest());
const state = mockedStore.getState().rooms;
const manipulated = { ...initialState, isFetching: true, failure: false, errorMessage: {} };
expect(state).toEqual(manipulated);
});
it('should return modified store after call roomsSuccess', () => {
mockedStore.dispatch(roomsSuccess());
const state = mockedStore.getState().rooms;
const manipulated = { ...initialState, isFetching: false, refreshing: false };
expect(state).toEqual(manipulated);
});
it('should return modified store after call roomsRefresh', () => {
mockedStore.dispatch(roomsRefresh());
const state = mockedStore.getState().rooms;
const manipulated = { ...initialState, isFetching: true, refreshing: true };
expect(state).toEqual(manipulated);
});
it('should return modified store after call setSearch', () => {
mockedStore.dispatch(setSearch('dog'));
const state = mockedStore.getState().rooms;
expect(state.searchText).toEqual('dog');
});
it('should return modified store after call closeServerDropdown', () => {
mockedStore.dispatch(closeServerDropdown());
const state = mockedStore.getState().rooms;
expect(state.closeServerDropdown).toEqual(!initialState.closeServerDropdown);
});
it('should return modified store after call toggleServerDropdown', () => {
mockedStore.dispatch(toggleServerDropdown());
const state = mockedStore.getState().rooms;
expect(state.showServerDropdown).toEqual(!initialState.showServerDropdown);
});
it('should return modified store after call openSearchHeader', () => {
mockedStore.dispatch(openSearchHeader());
const state = mockedStore.getState().rooms;
expect(state.showSearchHeader).toEqual(true);
});
it('should return modified store after call closeSearchHeader', () => {
mockedStore.dispatch(closeSearchHeader());
const state = mockedStore.getState().rooms;
expect(state.showSearchHeader).toEqual(false);
});
it('should return modified store after call roomsFailure', () => {
mockedStore.dispatch(roomsFailure('error'));
const state = mockedStore.getState().rooms;
expect(state.errorMessage).toEqual('error');
});
});

36
app/reducers/rooms.js → app/reducers/rooms.ts
View File

@ -1,6 +1,18 @@
import * as types from '../actions/actionsTypes';
import { IRoomsAction } from '../actions/rooms';
import { ROOMS } from '../actions/actionsTypes';
const initialState = {
export interface IRooms {
isFetching: boolean;
refreshing: boolean;
failure: boolean;
errorMessage: Record<string, any> | string;
searchText: string;
showServerDropdown: boolean;
closeServerDropdown: boolean;
showSearchHeader: boolean;
}
export const initialState: IRooms = {
isFetching: false,
refreshing: false,
failure: false,
@ -11,22 +23,22 @@ const initialState = {
showSearchHeader: false
};
export default function login(state = initialState, action) {
export default function rooms(state = initialState, action: IRoomsAction): IRooms {
switch (action.type) {
case types.ROOMS.REQUEST:
case ROOMS.REQUEST:
return {
...state,
isFetching: true,
failure: false,
errorMessage: {}
};
case types.ROOMS.SUCCESS:
case ROOMS.SUCCESS:
return {
...state,
isFetching: false,
refreshing: false
};
case types.ROOMS.FAILURE:
case ROOMS.FAILURE:
return {
...state,
isFetching: false,
@ -34,33 +46,33 @@ export default function login(state = initialState, action) {
failure: true,
errorMessage: action.err
};
case types.ROOMS.REFRESH:
case ROOMS.REFRESH:
return {
...state,
isFetching: true,
refreshing: true
};
case types.ROOMS.SET_SEARCH:
case ROOMS.SET_SEARCH:
return {
...state,
searchText: action.searchText
};
case types.ROOMS.CLOSE_SERVER_DROPDOWN:
case ROOMS.CLOSE_SERVER_DROPDOWN:
return {
...state,
closeServerDropdown: !state.closeServerDropdown
};
case types.ROOMS.TOGGLE_SERVER_DROPDOWN:
case ROOMS.TOGGLE_SERVER_DROPDOWN:
return {
...state,
showServerDropdown: !state.showServerDropdown
};
case types.ROOMS.OPEN_SEARCH_HEADER:
case ROOMS.OPEN_SEARCH_HEADER:
return {
...state,
showSearchHeader: true
};
case types.ROOMS.CLOSE_SEARCH_HEADER:
case ROOMS.CLOSE_SEARCH_HEADER:
return {
...state,
showSearchHeader: false

31
app/reducers/settings.test.ts Normal file
View File

@ -0,0 +1,31 @@
import { addSettings, clearSettings, updateSettings } from '../actions/settings';
import { mockedStore } from './mockedStore';
import { initialState } from './settings';
describe('test settings reducer', () => {
it('should return initial state', () => {
const state = mockedStore.getState().settings;
expect(state).toEqual(initialState);
});
const settings = { API_Use_REST_For_DDP_Calls: true, FileUpload_MaxFileSize: 600857600, Jitsi_URL_Room_Prefix: 'RocketChat' };
it('should return modified store after call addSettings action', () => {
mockedStore.dispatch(addSettings(settings));
const state = mockedStore.getState().settings;
expect(state).toEqual(settings);
});
it('should return correctly settings after call updateSettings action', () => {
const id = 'Jitsi_URL_Room_Prefix';
mockedStore.dispatch(updateSettings(id, 'ChatRocket'));
const state = mockedStore.getState().settings;
expect(state[id]).toEqual('ChatRocket');
});
it('should return initial state after clearSettings', () => {
mockedStore.dispatch(clearSettings());
const state = mockedStore.getState().settings;
expect(state).toEqual({});
});
});

9
app/reducers/settings.js → app/reducers/settings.ts
View File

@ -1,8 +1,13 @@
import { IActionSettings } from '../actions/settings';
import { SETTINGS } from '../actions/actionsTypes';
const initialState = {};
export type TSettings = string | number | boolean;
export default (state = initialState, action) => {
export type ISettings = Record<string, TSettings>;
export const initialState: ISettings = {};
export default (state = initialState, action: IActionSettings): ISettings => {
switch (action.type) {
case SETTINGS.ADD:
return {

45
app/views/E2EEnterYourPasswordView.tsx
View File

@ -1,23 +1,23 @@
import { StackNavigationOptions } from '@react-navigation/stack';
import React from 'react';
import { ScrollView, StyleSheet, Text } from 'react-native';
import { connect } from 'react-redux';
import { Dispatch } from 'redux';
import { StackNavigationOptions, StackNavigationProp } from '@react-navigation/stack';
import I18n from '../i18n';
import { withTheme } from '../theme';
import Button from '../containers/Button';
import { encryptionDecodeKey } from '../actions/encryption';
import { themes } from '../constants/colors';
import TextInput from '../containers/TextInput';
import SafeAreaView from '../containers/SafeAreaView';
import Button from '../containers/Button';
import * as HeaderButton from '../containers/HeaderButton';
import { encryptionDecodeKey as encryptionDecodeKeyAction } from '../actions/encryption';
import scrollPersistTaps from '../utils/scrollPersistTaps';
import KeyboardView from '../presentation/KeyboardView';
import SafeAreaView from '../containers/SafeAreaView';
import StatusBar from '../containers/StatusBar';
import { events, logEvent } from '../utils/log';
import sharedStyles from './Styles';
import TextInput from '../containers/TextInput';
import { IBaseScreen } from '../definitions';
import I18n from '../i18n';
import KeyboardView from '../presentation/KeyboardView';
import { E2EEnterYourPasswordStackParamList } from '../stacks/types';
import { withTheme } from '../theme';
import { events, logEvent } from '../utils/log';
import scrollPersistTaps from '../utils/scrollPersistTaps';
import sharedStyles from './Styles';
const styles = StyleSheet.create({
container: {
@ -34,21 +34,17 @@ interface IE2EEnterYourPasswordViewState {
password: string;
}
interface IE2EEnterYourPasswordViewProps {
encryptionDecodeKey: (password: string) => void;
theme: string;
navigation: StackNavigationProp<E2EEnterYourPasswordStackParamList, 'E2EEnterYourPasswordView'>;
}
type TE2EEnterYourPasswordViewProps = IBaseScreen<E2EEnterYourPasswordStackParamList, 'E2EEnterYourPasswordView'>;
class E2EEnterYourPasswordView extends React.Component<IE2EEnterYourPasswordViewProps, IE2EEnterYourPasswordViewState> {
class E2EEnterYourPasswordView extends React.Component<TE2EEnterYourPasswordViewProps, IE2EEnterYourPasswordViewState> {
private passwordInput?: TextInput;
static navigationOptions = ({ navigation }: Pick<IE2EEnterYourPasswordViewProps, 'navigation'>): StackNavigationOptions => ({
static navigationOptions = ({ navigation }: Pick<TE2EEnterYourPasswordViewProps, 'navigation'>): StackNavigationOptions => ({
headerLeft: () => <HeaderButton.CloseModal navigation={navigation} testID='e2e-enter-your-password-view-close' />,
title: I18n.t('Enter_Your_E2E_Password')
});
constructor(props: IE2EEnterYourPasswordViewProps) {
constructor(props: TE2EEnterYourPasswordViewProps) {
super(props);
this.state = {
password: ''
@ -58,8 +54,8 @@ class E2EEnterYourPasswordView extends React.Component<IE2EEnterYourPasswordView
submit = () => {
logEvent(events.E2E_ENTER_PW_SUBMIT);
const { password } = this.state;
const { encryptionDecodeKey } = this.props;
encryptionDecodeKey(password);
const { dispatch } = this.props;
dispatch(encryptionDecodeKey(password));
};
render() {
@ -109,7 +105,4 @@ class E2EEnterYourPasswordView extends React.Component<IE2EEnterYourPasswordView
}
}
const mapDispatchToProps = (dispatch: Dispatch) => ({
encryptionDecodeKey: (password: string) => dispatch(encryptionDecodeKeyAction(password))
});
export default connect(null, mapDispatchToProps)(withTheme(E2EEnterYourPasswordView));
export default connect(null)(withTheme(E2EEnterYourPasswordView));

42
app/views/E2ESaveYourPasswordView.tsx
View File

@ -1,25 +1,24 @@
import React from 'react';
import { StackNavigationProp } from '@react-navigation/stack';
import { Dispatch } from 'redux';
import { connect } from 'react-redux';
import { Clipboard, ScrollView, StyleSheet, Text, View } from 'react-native';
import { connect } from 'react-redux';
import { encryptionSetBanner as encryptionSetBannerAction } from '../actions/encryption';
import { E2E_RANDOM_PASSWORD_KEY } from '../lib/encryption/constants';
import { encryptionSetBanner } from '../actions/encryption';
import { themes } from '../constants/colors';
import Button from '../containers/Button';
import * as HeaderButton from '../containers/HeaderButton';
import scrollPersistTaps from '../utils/scrollPersistTaps';
import SafeAreaView from '../containers/SafeAreaView';
import UserPreferences from '../lib/userPreferences';
import { events, logEvent } from '../utils/log';
import StatusBar from '../containers/StatusBar';
import { LISTENER } from '../containers/Toast';
import { themes } from '../constants/colors';
import EventEmitter from '../utils/events';
import Button from '../containers/Button';
import { withTheme } from '../theme';
import { IApplicationState, IBaseScreen } from '../definitions';
import I18n from '../i18n';
import sharedStyles from './Styles';
import { E2E_RANDOM_PASSWORD_KEY } from '../lib/encryption/constants';
import UserPreferences from '../lib/userPreferences';
import { E2ESaveYourPasswordStackParamList } from '../stacks/types';
import { withTheme } from '../theme';
import EventEmitter from '../utils/events';
import { events, logEvent } from '../utils/log';
import scrollPersistTaps from '../utils/scrollPersistTaps';
import sharedStyles from './Styles';
const styles = StyleSheet.create({
container: {
@ -59,11 +58,8 @@ interface IE2ESaveYourPasswordViewState {
password: string;
}
interface IE2ESaveYourPasswordViewProps {
interface IE2ESaveYourPasswordViewProps extends IBaseScreen<E2ESaveYourPasswordStackParamList, 'E2ESaveYourPasswordView'> {
server: string;
navigation: StackNavigationProp<E2ESaveYourPasswordStackParamList, 'E2ESaveYourPasswordView'>;
encryptionSetBanner(): void;
theme: string;
}
class E2ESaveYourPasswordView extends React.Component<IE2ESaveYourPasswordViewProps, IE2ESaveYourPasswordViewState> {
@ -103,11 +99,11 @@ class E2ESaveYourPasswordView extends React.Component<IE2ESaveYourPasswordViewPr
onSaved = async () => {
logEvent(events.E2E_SAVE_PW_SAVED);
const { navigation, server, encryptionSetBanner } = this.props;
const { navigation, server, dispatch } = this.props;
// Remove stored password
await UserPreferences.removeItem(`${server}-${E2E_RANDOM_PASSWORD_KEY}`);
// Hide encryption banner
encryptionSetBanner();
dispatch(encryptionSetBanner());
navigation.pop();
};
@ -173,10 +169,8 @@ class E2ESaveYourPasswordView extends React.Component<IE2ESaveYourPasswordViewPr
}
}
const mapStateToProps = (state: any) => ({
const mapStateToProps = (state: IApplicationState) => ({
server: state.server.server
});
const mapDispatchToProps = (dispatch: Dispatch) => ({
encryptionSetBanner: () => dispatch(encryptionSetBannerAction())
});
export default connect(mapStateToProps, mapDispatchToProps)(withTheme(E2ESaveYourPasswordView));
export default connect(mapStateToProps)(withTheme(E2ESaveYourPasswordView));

48
app/views/InviteUsersEditView/index.tsx
View File

@ -1,25 +1,21 @@
import { StackNavigationOptions } from '@react-navigation/stack';
import React from 'react';
import { TextInputProps, View } from 'react-native';
import { connect } from 'react-redux';
import RNPickerSelect from 'react-native-picker-select';
import { StackNavigationOptions, StackNavigationProp } from '@react-navigation/stack';
import { RouteProp } from '@react-navigation/core';
import { Dispatch } from 'redux';
import { connect } from 'react-redux';
import {
inviteLinksCreate as inviteLinksCreateAction,
inviteLinksSetParams as inviteLinksSetParamsAction
} from '../../actions/inviteLinks';
import * as List from '../../containers/List';
import Button from '../../containers/Button';
import I18n from '../../i18n';
import StatusBar from '../../containers/StatusBar';
import { inviteLinksCreate, inviteLinksSetParams } from '../../actions/inviteLinks';
import { themes } from '../../constants/colors';
import { withTheme } from '../../theme';
import Button from '../../containers/Button';
import * as List from '../../containers/List';
import SafeAreaView from '../../containers/SafeAreaView';
import StatusBar from '../../containers/StatusBar';
import { IApplicationState, IBaseScreen } from '../../definitions';
import I18n from '../../i18n';
import { ChatsStackParamList } from '../../stacks/types';
import { withTheme } from '../../theme';
import { events, logEvent } from '../../utils/log';
import styles from './styles';
import { ChatsStackParamList } from '../../stacks/types';
const OPTIONS = {
days: [
@ -68,12 +64,7 @@ const OPTIONS = {
]
};
interface IInviteUsersEditViewProps {
navigation: StackNavigationProp<ChatsStackParamList, 'InviteUsersEditView'>;
route: RouteProp<ChatsStackParamList, 'InviteUsersEditView'>;
theme: string;
createInviteLink(rid: string): void;
inviteLinksSetParams(params: { [key: string]: number }): void;
interface IInviteUsersEditViewProps extends IBaseScreen<ChatsStackParamList, 'InviteUsersEditView'> {
days: number;
maxUses: number;
}
@ -91,18 +82,18 @@ class InviteUsersEditView extends React.Component<IInviteUsersEditViewProps, any
}
onValueChangePicker = (key: string, value: number) => {
const { dispatch } = this.props;
logEvent(events.IU_EDIT_SET_LINK_PARAM);
const { inviteLinksSetParams } = this.props;
const params = {
[key]: value
};
inviteLinksSetParams(params);
dispatch(inviteLinksSetParams(params));
};
createInviteLink = () => {
const { dispatch, navigation } = this.props;
logEvent(events.IU_EDIT_CREATE_LINK);
const { createInviteLink, navigation } = this.props;
createInviteLink(this.rid);
dispatch(inviteLinksCreate(this.rid));
navigation.pop();
};
@ -151,14 +142,9 @@ class InviteUsersEditView extends React.Component<IInviteUsersEditViewProps, any
}
}
const mapStateToProps = (state: any) => ({
const mapStateToProps = (state: IApplicationState) => ({
days: state.inviteLinks.days,
maxUses: state.inviteLinks.maxUses
});
const mapDispatchToProps = (dispatch: Dispatch) => ({
inviteLinksSetParams: (params: object) => dispatch(inviteLinksSetParamsAction(params)),
createInviteLink: (rid: string) => dispatch(inviteLinksCreateAction(rid))
});
export default connect(mapStateToProps, mapDispatchToProps)(withTheme(InviteUsersEditView));
export default connect(mapStateToProps)(withTheme(InviteUsersEditView));

68
app/views/InviteUsersView/index.tsx
View File

@ -1,62 +1,49 @@
import { StackNavigationOptions } from '@react-navigation/stack';
import moment from 'moment';
import React from 'react';
import { ScrollView, Share, View } from 'react-native';
import moment from 'moment';
import { connect } from 'react-redux';
import { StackNavigationProp, StackNavigationOptions } from '@react-navigation/stack';
import { RouteProp } from '@react-navigation/core';
import { Dispatch } from 'redux';
import { ChatsStackParamList } from '../../stacks/types';
import {
inviteLinksClear as inviteLinksClearAction,
inviteLinksCreate as inviteLinksCreateAction
} from '../../actions/inviteLinks';
import RCTextInput from '../../containers/TextInput';
import Markdown from '../../containers/markdown';
import Button from '../../containers/Button';
import scrollPersistTaps from '../../utils/scrollPersistTaps';
import I18n from '../../i18n';
import StatusBar from '../../containers/StatusBar';
import { inviteLinksClear, inviteLinksCreate } from '../../actions/inviteLinks';
import { themes } from '../../constants/colors';
import { withTheme } from '../../theme';
import Button from '../../containers/Button';
import Markdown from '../../containers/markdown';
import SafeAreaView from '../../containers/SafeAreaView';
import StatusBar from '../../containers/StatusBar';
import RCTextInput from '../../containers/TextInput';
import { IApplicationState, IBaseScreen } from '../../definitions';
import I18n from '../../i18n';
import { TInvite } from '../../reducers/inviteLinks';
import { ChatsStackParamList } from '../../stacks/types';
import { withTheme } from '../../theme';
import { events, logEvent } from '../../utils/log';
import scrollPersistTaps from '../../utils/scrollPersistTaps';
import styles from './styles';
interface IInviteUsersViewProps {
navigation: StackNavigationProp<ChatsStackParamList, 'InviteUsersView'>;
route: RouteProp<ChatsStackParamList, 'InviteUsersView'>;
theme: string;
interface IInviteUsersViewProps extends IBaseScreen<ChatsStackParamList, 'InviteUsersView'> {
timeDateFormat: string;
invite: {
url: string;
expires: number;
maxUses: number;
uses: number;
};
createInviteLink(rid: string): void;
clearInviteLink(): void;
invite: TInvite;
}
class InviteUsersView extends React.Component<IInviteUsersViewProps, any> {
private rid: string;
static navigationOptions = (): StackNavigationOptions => ({
title: I18n.t('Invite_users')
});
private rid: string;
constructor(props: IInviteUsersViewProps) {
super(props);
this.rid = props.route.params?.rid;
}
componentDidMount() {
const { createInviteLink } = this.props;
createInviteLink(this.rid);
const { dispatch } = this.props;
dispatch(inviteLinksCreate(this.rid));
}
componentWillUnmount() {
const { clearInviteLink } = this.props;
clearInviteLink();
const { dispatch } = this.props;
dispatch(inviteLinksClear());
}
share = () => {
@ -133,16 +120,9 @@ class InviteUsersView extends React.Component<IInviteUsersViewProps, any> {
}
}
const mapStateToProps = (state: any) => ({
timeDateFormat: state.settings.Message_TimeAndDateFormat,
days: state.inviteLinks.days,
maxUses: state.inviteLinks.maxUses,
const mapStateToProps = (state: IApplicationState) => ({
timeDateFormat: state.settings.Message_TimeAndDateFormat as string,
invite: state.inviteLinks.invite
});
const mapDispatchToProps = (dispatch: Dispatch) => ({
createInviteLink: (rid: string) => dispatch(inviteLinksCreateAction(rid)),
clearInviteLink: () => dispatch(inviteLinksClearAction())
});
export default connect(mapStateToProps, mapDispatchToProps)(withTheme(InviteUsersView));
export default connect(mapStateToProps)(withTheme(InviteUsersView));

100
app/views/NewServerView/index.tsx
View File

@ -1,39 +1,37 @@
import React from 'react';
import { Text, Keyboard, StyleSheet, View, BackHandler, Image } from 'react-native';
import { connect } from 'react-redux';
import { Base64 } from 'js-base64';
import parse from 'url-parse';
import { Q } from '@nozbe/watermelondb';
import { Base64 } from 'js-base64';
import React from 'react';
import { BackHandler, Image, Keyboard, StyleSheet, Text, View } from 'react-native';
import { TouchableOpacity } from 'react-native-gesture-handler';
import Orientation from 'react-native-orientation-locker';
import { StackNavigationProp } from '@react-navigation/stack';
import { Dispatch } from 'redux';
import { connect } from 'react-redux';
import parse from 'url-parse';
import UserPreferences from '../../lib/userPreferences';
import EventEmitter from '../../utils/events';
import { selectServerRequest, serverRequest, serverFinishAdd as serverFinishAddAction } from '../../actions/server';
import { inviteLinksClear as inviteLinksClearAction } from '../../actions/inviteLinks';
import sharedStyles from '../Styles';
import Button from '../../containers/Button';
import OrSeparator from '../../containers/OrSeparator';
import FormContainer, { FormContainerInner } from '../../containers/FormContainer';
import I18n from '../../i18n';
import { inviteLinksClear } from '../../actions/inviteLinks';
import { selectServerRequest, serverFinishAdd, serverRequest } from '../../actions/server';
import { themes } from '../../constants/colors';
import { events, logEvent } from '../../utils/log';
import { withTheme } from '../../theme';
import { BASIC_AUTH_KEY, setBasicAuth } from '../../utils/fetch';
import Button from '../../containers/Button';
import FormContainer, { FormContainerInner } from '../../containers/FormContainer';
import * as HeaderButton from '../../containers/HeaderButton';
import { showConfirmationAlert } from '../../utils/info';
import OrSeparator from '../../containers/OrSeparator';
import { IBaseScreen, TServerHistory } from '../../definitions';
import { withDimensions } from '../../dimensions';
import I18n from '../../i18n';
import database from '../../lib/database';
import { sanitizeLikeString } from '../../lib/database/utils';
import SSLPinning from '../../utils/sslPinning';
import RocketChat from '../../lib/rocketchat';
import { isTablet } from '../../utils/deviceInfo';
import { verticalScale, moderateScale } from '../../utils/scaling';
import { withDimensions } from '../../dimensions';
import ServerInput from './ServerInput';
import UserPreferences from '../../lib/userPreferences';
import { OutsideParamList } from '../../stacks/types';
import { TServerHistory } from '../../definitions/IServerHistory';
import { withTheme } from '../../theme';
import { isTablet } from '../../utils/deviceInfo';
import EventEmitter from '../../utils/events';
import { BASIC_AUTH_KEY, setBasicAuth } from '../../utils/fetch';
import { showConfirmationAlert } from '../../utils/info';
import { events, logEvent } from '../../utils/log';
import { moderateScale, verticalScale } from '../../utils/scaling';
import SSLPinning from '../../utils/sslPinning';
import sharedStyles from '../Styles';
import ServerInput from './ServerInput';
const styles = StyleSheet.create({
onboardingImage: {
@ -68,20 +66,14 @@ const styles = StyleSheet.create({
}
});
interface INewServerView {
navigation: StackNavigationProp<OutsideParamList, 'NewServerView'>;
theme: string;
interface INewServerViewProps extends IBaseScreen<OutsideParamList, 'NewServerView'> {
connecting: boolean;
connectServer(server: string, username?: string, fromServerHistory?: boolean): void;
selectServer(server: string): void;
previousServer: string;
inviteLinksClear(): void;
serverFinishAdd(): void;
width: number;
height: number;
}
interface IState {
interface INewServerViewState {
text: string;
connectingOpen: boolean;
certificate: any;
@ -93,8 +85,8 @@ interface ISubmitParams {
username?: string;
}
class NewServerView extends React.Component<INewServerView, IState> {
constructor(props: INewServerView) {
class NewServerView extends React.Component<INewServerViewProps, INewServerViewState> {
constructor(props: INewServerViewProps) {
super(props);
if (!isTablet) {
Orientation.lockToPortrait();
@ -118,9 +110,9 @@ class NewServerView extends React.Component<INewServerView, IState> {
componentWillUnmount() {
EventEmitter.removeListener('NewServer', this.handleNewServerEvent);
BackHandler.removeEventListener('hardwareBackPress', this.handleBackPress);
const { previousServer, serverFinishAdd } = this.props;
const { previousServer, dispatch } = this.props;
if (previousServer) {
serverFinishAdd();
dispatch(serverFinishAdd());
}
}
@ -169,9 +161,9 @@ class NewServerView extends React.Component<INewServerView, IState> {
};
close = () => {
const { selectServer, previousServer, inviteLinksClear } = this.props;
inviteLinksClear();
selectServer(previousServer);
const { dispatch, previousServer } = this.props;
dispatch(inviteLinksClear());
dispatch(selectServerRequest(previousServer));
};
handleNewServerEvent = (event: { server: string }) => {
@ -179,10 +171,10 @@ class NewServerView extends React.Component<INewServerView, IState> {
if (!server) {
return;
}
const { connectServer } = this.props;
const { dispatch } = this.props;
this.setState({ text: server });
server = this.completeUrl(server);
connectServer(server);
dispatch(serverRequest(server));
};
onPressServerHistory = (serverHistory: TServerHistory) => {
@ -192,7 +184,7 @@ class NewServerView extends React.Component<INewServerView, IState> {
submit = async ({ fromServerHistory = false, username }: ISubmitParams = {}) => {
logEvent(events.NS_CONNECT_TO_WORKSPACE);
const { text, certificate } = this.state;
const { connectServer } = this.props;
const { dispatch } = this.props;
this.setState({ connectingOpen: false });
@ -207,9 +199,9 @@ class NewServerView extends React.Component<INewServerView, IState> {
await this.basicAuth(server, text);
if (fromServerHistory) {
connectServer(server, username, true);
dispatch(serverRequest(server, username, true));
} else {
connectServer(server);
dispatch(serverRequest(server));
}
}
};
@ -217,8 +209,8 @@ class NewServerView extends React.Component<INewServerView, IState> {
connectOpen = () => {
logEvent(events.NS_JOIN_OPEN_WORKSPACE);
this.setState({ connectingOpen: true });
const { connectServer } = this.props;
connectServer('https://open.rocket.chat');
const { dispatch } = this.props;
dispatch(serverRequest('https://open.rocket.chat'));
};
basicAuth = async (server: string, text: string) => {
@ -283,7 +275,7 @@ class NewServerView extends React.Component<INewServerView, IState> {
await db.write(async () => {
await item.destroyPermanently();
});
this.setState((prevstate: IState) => ({
this.setState((prevstate: INewServerViewState) => ({
serversHistory: prevstate.serversHistory.filter((server: TServerHistory) => server.id !== item.id)
}));
} catch {
@ -417,12 +409,4 @@ const mapStateToProps = (state: any) => ({
previousServer: state.server.previousServer
});
const mapDispatchToProps = (dispatch: Dispatch) => ({
connectServer: (server: string, username: string & null, fromServerHistory?: boolean) =>
dispatch(serverRequest(server, username, fromServerHistory)),
selectServer: (server: string) => dispatch(selectServerRequest(server)),
inviteLinksClear: () => dispatch(inviteLinksClearAction()),
serverFinishAdd: () => dispatch(serverFinishAddAction())
});
export default connect(mapStateToProps, mapDispatchToProps)(withDimensions(withTheme(NewServerView)));
export default connect(mapStateToProps)(withDimensions(withTheme(NewServerView)));

25
app/views/RoomsListView/Header/index.js
View File

@ -2,7 +2,7 @@ import React, { PureComponent } from 'react';
import PropTypes from 'prop-types';
import { connect } from 'react-redux';
import { toggleServerDropdown, closeServerDropdown, setSearch as setSearchAction } from '../../../actions/rooms';
import { toggleServerDropdown, closeServerDropdown, setSearch } from '../../../actions/rooms';
import { withTheme } from '../../../theme';
import EventEmitter from '../../../utils/events';
import { KEY_COMMAND, handleCommandOpenServerDropdown } from '../../../commands';
@ -19,10 +19,7 @@ class RoomsListHeaderView extends PureComponent {
connected: PropTypes.bool,
isFetching: PropTypes.bool,
theme: PropTypes.string,
server: PropTypes.string,
open: PropTypes.func,
close: PropTypes.func,
setSearch: PropTypes.func
server: PropTypes.string
};
componentDidMount() {
@ -45,17 +42,17 @@ class RoomsListHeaderView extends PureComponent {
};
onSearchChangeText = text => {
const { setSearch } = this.props;
setSearch(text.trim());
const { dispatch } = this.props;
dispatch(setSearch(text.trim()));
};
onPress = () => {
logEvent(events.RL_TOGGLE_SERVER_DROPDOWN);
const { showServerDropdown, close, open } = this.props;
const { showServerDropdown, dispatch } = this.props;
if (showServerDropdown) {
close();
dispatch(closeServerDropdown());
} else {
open();
dispatch(toggleServerDropdown());
}
};
@ -89,10 +86,4 @@ const mapStateToProps = state => ({
server: state.server.server
});
const mapDispatchtoProps = dispatch => ({
close: () => dispatch(closeServerDropdown()),
open: () => dispatch(toggleServerDropdown()),
setSearch: searchText => dispatch(setSearchAction(searchText))
});
export default connect(mapStateToProps, mapDispatchtoProps)(withTheme(RoomsListHeaderView));
export default connect(mapStateToProps)(withTheme(RoomsListHeaderView));

35
app/views/RoomsListView/ServerDropdown.js
View File

@ -6,9 +6,9 @@ import { withSafeAreaInsets } from 'react-native-safe-area-context';
import * as List from '../../containers/List';
import Button from '../../containers/Button';
import { toggleServerDropdown as toggleServerDropdownAction } from '../../actions/rooms';
import { selectServerRequest as selectServerRequestAction, serverInitAdd as serverInitAddAction } from '../../actions/server';
import { appStart as appStartAction, ROOT_OUTSIDE } from '../../actions/app';
import { toggleServerDropdown } from '../../actions/rooms';
import { selectServerRequest, serverInitAdd } from '../../actions/server';
import { appStart, ROOT_OUTSIDE } from '../../actions/app';
import RocketChat from '../../lib/rocketchat';
import I18n from '../../i18n';
import EventEmitter from '../../utils/events';
@ -36,11 +36,7 @@ class ServerDropdown extends Component {
closeServerDropdown: PropTypes.bool,
server: PropTypes.string,
theme: PropTypes.string,
isMasterDetail: PropTypes.bool,
appStart: PropTypes.func,
toggleServerDropdown: PropTypes.func,
selectServerRequest: PropTypes.func,
initAdd: PropTypes.func
isMasterDetail: PropTypes.bool
};
constructor(props) {
@ -89,13 +85,13 @@ class ServerDropdown extends Component {
}
close = () => {
const { toggleServerDropdown } = this.props;
const { dispatch } = this.props;
Animated.timing(this.animatedValue, {
toValue: 0,
duration: ANIMATION_DURATION,
easing: Easing.inOut(Easing.quad),
useNativeDriver: true
}).start(() => toggleServerDropdown());
}).start(() => dispatch(toggleServerDropdown()));
};
createWorkspace = async () => {
@ -108,10 +104,10 @@ class ServerDropdown extends Component {
};
navToNewServer = previousServer => {
const { appStart, initAdd } = this.props;
const { dispatch } = this.props;
batch(() => {
appStart({ root: ROOT_OUTSIDE });
initAdd(previousServer);
dispatch(appStart({ root: ROOT_OUTSIDE }));
dispatch(serverInitAdd(previousServer));
});
};
@ -125,7 +121,7 @@ class ServerDropdown extends Component {
};
select = async (server, version) => {
const { server: currentServer, selectServerRequest, isMasterDetail } = this.props;
const { server: currentServer, dispatch, isMasterDetail } = this.props;
this.close();
if (currentServer !== server) {
logEvent(events.RL_CHANGE_SERVER);
@ -142,7 +138,7 @@ class ServerDropdown extends Component {
}, ANIMATION_DURATION);
} else {
await localAuthenticate(server);
selectServerRequest(server, version);
dispatch(selectServerRequest(server, version, true, true));
}
}
};
@ -263,11 +259,4 @@ const mapStateToProps = state => ({
isMasterDetail: state.app.isMasterDetail
});
const mapDispatchToProps = dispatch => ({
toggleServerDropdown: () => dispatch(toggleServerDropdownAction()),
selectServerRequest: (server, version) => dispatch(selectServerRequestAction(server, version, true, true)),
appStart: params => dispatch(appStartAction(params)),
initAdd: previousServer => dispatch(serverInitAddAction(previousServer))
});
export default connect(mapStateToProps, mapDispatchToProps)(withSafeAreaInsets(withTheme(ServerDropdown)));
export default connect(mapStateToProps)(withSafeAreaInsets(withTheme(ServerDropdown)));

47
app/views/RoomsListView/index.js
View File

@ -12,19 +12,13 @@ import RocketChat from '../../lib/rocketchat';
import RoomItem, { ROW_HEIGHT, ROW_HEIGHT_CONDENSED } from '../../presentation/RoomItem';
import log, { logEvent, events } from '../../utils/log';
import I18n from '../../i18n';
import {
closeSearchHeader as closeSearchHeaderAction,
closeServerDropdown as closeServerDropdownAction,
openSearchHeader as openSearchHeaderAction,
roomsRequest as roomsRequestAction
} from '../../actions/rooms';
import { appStart as appStartAction, ROOT_OUTSIDE } from '../../actions/app';
import { closeSearchHeader, closeServerDropdown, openSearchHeader, roomsRequest } from '../../actions/rooms';
import { appStart, ROOT_OUTSIDE } from '../../actions/app';
import debounce from '../../utils/debounce';
import { isIOS, isTablet } from '../../utils/deviceInfo';
import * as HeaderButton from '../../containers/HeaderButton';
import StatusBar from '../../containers/StatusBar';
import ActivityIndicator from '../../containers/ActivityIndicator';
import { selectServerRequest as selectServerRequestAction, serverInitAdd as serverInitAddAction } from '../../actions/server';
import { animateNextTransition } from '../../utils/layoutAnimation';
import { withTheme } from '../../theme';
import { themes } from '../../constants/colors';
@ -124,11 +118,6 @@ class RoomsListView extends React.Component {
refreshing: PropTypes.bool,
StoreLastMessage: PropTypes.bool,
theme: PropTypes.string,
openSearchHeader: PropTypes.func,
closeSearchHeader: PropTypes.func,
appStart: PropTypes.func,
roomsRequest: PropTypes.func,
closeServerDropdown: PropTypes.func,
useRealName: PropTypes.bool,
isMasterDetail: PropTypes.bool,
rooms: PropTypes.array,
@ -169,7 +158,7 @@ class RoomsListView extends React.Component {
}
componentDidMount() {
const { navigation, closeServerDropdown } = this.props;
const { navigation, dispatch } = this.props;
this.handleHasPermission();
this.mounted = true;
@ -193,7 +182,7 @@ class RoomsListView extends React.Component {
});
this.unsubscribeBlur = navigation.addListener('blur', () => {
this.animated = false;
closeServerDropdown();
dispatch(closeServerDropdown());
this.cancelSearch();
if (this.backHandler && this.backHandler.remove) {
this.backHandler.remove();
@ -553,9 +542,9 @@ class RoomsListView extends React.Component {
initSearching = () => {
logEvent(events.RL_SEARCH);
const { openSearchHeader } = this.props;
const { dispatch } = this.props;
this.internalSetState({ searching: true }, () => {
openSearchHeader();
dispatch(openSearchHeader());
this.search('');
this.setHeader();
});
@ -563,7 +552,7 @@ class RoomsListView extends React.Component {
cancelSearch = () => {
const { searching } = this.state;
const { closeSearchHeader } = this.props;
const { dispatch } = this.props;
if (!searching) {
return;
@ -573,7 +562,7 @@ class RoomsListView extends React.Component {
this.setState({ searching: false, search: [] }, () => {
this.setHeader();
closeSearchHeader();
dispatch(closeSearchHeader());
setTimeout(() => {
this.scrollToTop();
}, 200);
@ -842,7 +831,7 @@ class RoomsListView extends React.Component {
};
handleCommands = ({ event }) => {
const { navigation, server, isMasterDetail, appStart, initAdd } = this.props;
const { navigation, server, isMasterDetail, dispatch, initAdd } = this.props;
const { input } = event;
if (handleCommandShowPreferences(event)) {
navigation.navigate('SettingsView');
@ -862,7 +851,7 @@ class RoomsListView extends React.Component {
}
} else if (handleCommandAddNewServer(event)) {
batch(() => {
appStart({ root: ROOT_OUTSIDE });
dispatch(appStart({ root: ROOT_OUTSIDE }));
initAdd(server);
});
}
@ -870,11 +859,11 @@ class RoomsListView extends React.Component {
onRefresh = () => {
const { searching } = this.state;
const { roomsRequest } = this.props;
const { dispatch } = this.props;
if (searching) {
return;
}
roomsRequest({ allData: true });
dispatch(roomsRequest({ allData: true }));
};
onEndReached = () => {
@ -1045,14 +1034,4 @@ const mapStateToProps = state => ({
createDiscussionPermission: state.permissions['start-discussion']
});
const mapDispatchToProps = dispatch => ({
openSearchHeader: () => dispatch(openSearchHeaderAction()),
closeSearchHeader: () => dispatch(closeSearchHeaderAction()),
roomsRequest: params => dispatch(roomsRequestAction(params)),
selectServerRequest: server => dispatch(selectServerRequestAction(server)),
closeServerDropdown: () => dispatch(closeServerDropdownAction()),
appStart: params => dispatch(appStartAction(params)),
initAdd: previousServer => dispatch(serverInitAddAction(previousServer))
});
export default connect(mapStateToProps, mapDispatchToProps)(withDimensions(withTheme(withSafeAreaInsets(RoomsListView))));
export default connect(mapStateToProps)(withDimensions(withTheme(withSafeAreaInsets(RoomsListView))));