index
int64 0
0
| repo_id
stringlengths 16
181
| file_path
stringlengths 28
270
| content
stringlengths 1
11.6M
| __index_level_0__
int64 0
10k
|
|---|---|---|---|---|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/Modals/OAuth/StepPrepareOAuth
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/Modals/OAuth/StepPrepareOAuth/hooks/useStepPrepareOAuthEmailSummary.tsx
|
import { c, msgid } from 'ttag';
import { MailImportFields } from '@proton/activation/src/components/Modals/CustomizeMailImportModal/CustomizeMailImportModal.interface';
import { getMailMappingErrors } from '@proton/activation/src/helpers/getMailMappingErrors';
import { ImportProvider } from '@proton/activation/src/interface';
import { updateEmailsData } from '@proton/activation/src/logic/draft/oauthDraft/oauthDraft.actions';
import {
selectOauthDraftProvider,
selectOauthImportStateImporterData,
} from '@proton/activation/src/logic/draft/oauthDraft/oauthDraft.selector';
import { useEasySwitchDispatch, useEasySwitchSelector } from '@proton/activation/src/logic/store';
import { useFolders, useLabels } from '@proton/components';
interface Props {
handleCloseCustomizeModal: () => void;
}
const useStepPrepareEmailSummary = ({ handleCloseCustomizeModal }: Props) => {
const [folders = []] = useFolders();
const [labels = []] = useLabels();
const dispatch = useEasySwitchDispatch();
const importerData = useEasySwitchSelector(selectOauthImportStateImporterData);
const provider = useEasySwitchSelector(selectOauthDraftProvider);
const toEmail = importerData?.importedEmail;
const storeFields = importerData?.emails?.fields;
if (!storeFields || !toEmail || !provider) {
throw new Error('Folders or importedEmail should be defined');
}
const isLabelMapping = provider === ImportProvider.GOOGLE;
const itemsToImportCount = storeFields.mapping.filter((item) => !item?.category).length;
const selectedItemsToImportCount = storeFields.mapping.filter((item) => item.checked && !item?.category).length;
const errors = getMailMappingErrors(storeFields.mapping, isLabelMapping, labels, folders);
const summaryAllLabels = isLabelMapping
? // translator: here is an example of a complete sentence: "Import all messages from 12 labels and label them as ..." followed by the label HTML element
c('Mail import summary').ngettext(
msgid`Import all messages from ${itemsToImportCount} label and label them as`,
`Import all messages from ${itemsToImportCount} labels and label them as`,
itemsToImportCount
)
: // translator: here is an example of a complete sentence: "Import all messages from 12 folders and label them as ..." followed by the label HTML element
c('Mail import summary').ngettext(
msgid`Import all messages from ${itemsToImportCount} folder and label them as`,
`Import all messages from ${itemsToImportCount} folders and label them as`,
itemsToImportCount
);
const summarySelectedLabels = isLabelMapping
? // translator: here is an example of a complete sentence: "Import all messages from 3 out of 5 labels and label them as ..." followed by the label HTML element
c('Mail import summary').ngettext(
msgid`Import all messages from ${selectedItemsToImportCount} out of ${itemsToImportCount} label and label them as`,
`Import all messages from ${selectedItemsToImportCount} out of ${itemsToImportCount} labels and label them as`,
itemsToImportCount
)
: // translator: here is an example of a complete sentence: "Import all messages from 3 out of 5 folders and label them as ..." followed by the label HTML element
c('Mail import summary').ngettext(
msgid`Import all messages from ${selectedItemsToImportCount} out of ${itemsToImportCount} folder and label them as`,
`Import all messages from ${selectedItemsToImportCount} out of ${itemsToImportCount} folders and label them as`,
itemsToImportCount
);
const summary = itemsToImportCount === selectedItemsToImportCount ? summaryAllLabels : summarySelectedLabels;
const handleSubmitCustomizeModal = (updatedFields: MailImportFields) => {
dispatch(updateEmailsData(updatedFields));
handleCloseCustomizeModal();
};
return { fields: storeFields, errors: errors.errors, summary, toEmail, handleSubmitCustomizeModal };
};
export default useStepPrepareEmailSummary;
| 4,900
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/Modals/OAuth
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/Modals/OAuth/StepProducts/StepProducts.tsx
|
import { c } from 'ttag';
import { Button } from '@proton/atoms/Button';
import { ModalTwo, ModalTwoContent, ModalTwoFooter, PrimaryButton } from '@proton/components';
import StepProductsHeader from './StepProductsHeader';
import StepProductsRowItem from './StepProductsRowItem';
import useStepProducts from './useStepProducts';
interface Props {
triggerOAuth: (scopes: string[]) => void;
}
const StepProducts = ({ triggerOAuth }: Props) => {
const {
mailChecked,
setMailChecked,
contactChecked,
setContactChecked,
calendarChecked,
setCalendarChecked,
handleCancel,
handleSubmit,
nextDisabled,
enabledFeatures,
} = useStepProducts({ triggerOAuth });
const { isEmailsEnabled, isCalendarsEnabled, isContactsEnabled } = enabledFeatures;
return (
<ModalTwo size="large" onClose={handleCancel} open>
<StepProductsHeader />
<ModalTwoContent>
<div>{c('Info').t`Select what you want to import.`}</div>
<div className="max-w-custom" style={{ '--max-w-custom': '30em' }} data-testid="StepProducts:modal">
<StepProductsRowItem
id="mail"
label={c('Label').t`Emails`}
value={mailChecked}
setValue={setMailChecked}
disabled={!isEmailsEnabled}
/>
<StepProductsRowItem
id="contact"
label={c('Label').t`Contacts`}
value={contactChecked}
setValue={setContactChecked}
disabled={!isContactsEnabled}
/>
<StepProductsRowItem
id="calendar"
label={c('Label').t`Calendar`}
value={calendarChecked}
setValue={setCalendarChecked}
disabled={!isCalendarsEnabled}
/>
</div>
</ModalTwoContent>
<ModalTwoFooter>
<Button shape="outline" onClick={handleCancel}>
{c('Action').t`Cancel`}
</Button>
<PrimaryButton disabled={nextDisabled} onClick={handleSubmit} data-testid="StepProducts:submit">{c(
'Action'
).t`Start import`}</PrimaryButton>
</ModalTwoFooter>
</ModalTwo>
);
};
export default StepProducts;
| 4,901
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/Modals/OAuth
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/Modals/OAuth/StepProducts/StepProductsHeader.tsx
|
import { c } from 'ttag';
import { ModalTwoHeader } from '@proton/components';
const StepProductsHeader = () => {
return <ModalTwoHeader title={c('Title').t`What would you like to import?`} />;
};
export default StepProductsHeader;
| 4,902
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/Modals/OAuth
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/Modals/OAuth/StepProducts/StepProductsRowItem.test.tsx
|
import { fireEvent, screen } from '@testing-library/dom';
import { easySwitchRender } from '@proton/activation/src/tests/render';
import StepProductsRowItem from './StepProductsRowItem';
describe('StepProductsRowItem', () => {
it('Should render the default component when no errors', () => {
easySwitchRender(<StepProductsRowItem id="mail" label="label" value={true} setValue={jest.fn} />);
screen.getByTestId('StepProductsRowItem:label');
});
it('Should render the error component when has errors', () => {
easySwitchRender(
<StepProductsRowItem id="mail" label="label" value={true} setValue={jest.fn} error={'There is an error'} />
);
screen.getByText('There is an error');
});
it('Should render a warning when the component is disabled', () => {
easySwitchRender(
<StepProductsRowItem id="mail" label="label" value={true} setValue={jest.fn} disabled={true} />
);
screen.getByText('(Temporarily unavailable. Please check back later.)');
});
it('Should update the value when the checkbox is clicked', () => {
const setValue = jest.fn();
easySwitchRender(<StepProductsRowItem id="mail" label="label" value={true} setValue={setValue} />);
const label = screen.getByTestId('StepProductsRowItem:label');
fireEvent.click(label);
expect(setValue).toBeCalledTimes(1);
});
});
| 4,903
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/Modals/OAuth
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/Modals/OAuth/StepProducts/StepProductsRowItem.tsx
|
import { ReactNode } from 'react';
import { c } from 'ttag';
import { Checkbox, Label } from '@proton/components';
import clsx from '@proton/utils/clsx';
import StepPrepareDisabledCheckbox from '../StepPrepareOAuth/StepPrepareOAuthDisabledCheckbox';
interface Props {
id: 'mail' | 'contact' | 'calendar';
label: string;
disabled?: boolean;
value: boolean;
setValue: (value: boolean) => void;
error?: string;
children?: ReactNode;
}
const StepProductsRowItem = ({ id, label, disabled, value, setValue, error, children }: Props) => {
if (error) {
return <StepPrepareDisabledCheckbox id={id}>{error}</StepPrepareDisabledCheckbox>;
}
return (
<Label
htmlFor={id}
className={clsx(['py-5 border-bottom flex label w-full', disabled && 'cursor-default color-weak'])}
data-testid="StepProductsRowItem:label"
>
<Checkbox
id={id}
checked={disabled ? false : value}
onChange={(e) => setValue(e.target.checked)}
className="mr-2 flex-align-self-start"
disabled={disabled}
/>
<div className="flex flex-column flex-item-fluid">
<div className={clsx(disabled && 'color-weak')}>
{label}
{disabled && (
<span className="block">
{c('Label').t`(Temporarily unavailable. Please check back later.)`}
</span>
)}
</div>
{children}
</div>
</Label>
);
};
export default StepProductsRowItem;
| 4,904
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/Modals/OAuth
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/Modals/OAuth/StepProducts/useStepProducts.helpers.test.ts
|
import {
G_OAUTH_SCOPE_CALENDAR,
G_OAUTH_SCOPE_CONTACTS,
G_OAUTH_SCOPE_DEFAULT,
G_OAUTH_SCOPE_MAIL_READONLY,
O_OAUTH_SCOPE_CALENDAR,
O_OAUTH_SCOPE_CONTACTS,
O_OAUTH_SCOPE_DEFAULT,
O_OAUTH_SCOPE_MAIL,
} from '@proton/activation/src/constants';
import { ImportProvider, ImportType } from '@proton/activation/src/interface';
import { getScopeFromProvider } from './useStepProducts.helpers';
describe('useStepProducts tests', () => {
it('Should return empty array', () => {
const scope = getScopeFromProvider(ImportProvider.DEFAULT, [
ImportType.CALENDAR,
ImportType.CONTACTS,
ImportType.MAIL,
]);
expect(scope).toStrictEqual([]);
});
it('Should test all possible outlook scopes', () => {
const scopeEmail = getScopeFromProvider(ImportProvider.OUTLOOK, [ImportType.MAIL]);
expect(scopeEmail).toStrictEqual([...O_OAUTH_SCOPE_DEFAULT, ...O_OAUTH_SCOPE_MAIL]);
const scopeContact = getScopeFromProvider(ImportProvider.OUTLOOK, [ImportType.CONTACTS]);
expect(scopeContact).toStrictEqual([...O_OAUTH_SCOPE_DEFAULT, ...O_OAUTH_SCOPE_CONTACTS]);
const scopeCalendar = getScopeFromProvider(ImportProvider.OUTLOOK, [ImportType.CALENDAR]);
expect(scopeCalendar).toStrictEqual([...O_OAUTH_SCOPE_DEFAULT, ...O_OAUTH_SCOPE_CALENDAR]);
});
it('Should test all possible gmail scopes', () => {
const scopeEmail = getScopeFromProvider(ImportProvider.GOOGLE, [ImportType.MAIL]);
expect(scopeEmail).toStrictEqual([...G_OAUTH_SCOPE_DEFAULT, ...G_OAUTH_SCOPE_MAIL_READONLY]);
const scopeContact = getScopeFromProvider(ImportProvider.GOOGLE, [ImportType.CONTACTS]);
expect(scopeContact).toStrictEqual([...G_OAUTH_SCOPE_DEFAULT, ...G_OAUTH_SCOPE_CONTACTS]);
const scopeCalendar = getScopeFromProvider(ImportProvider.GOOGLE, [ImportType.CALENDAR]);
expect(scopeCalendar).toStrictEqual([...G_OAUTH_SCOPE_DEFAULT, ...G_OAUTH_SCOPE_CALENDAR]);
});
});
| 4,905
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/Modals/OAuth
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/Modals/OAuth/StepProducts/useStepProducts.helpers.ts
|
import {
G_OAUTH_SCOPE_CALENDAR,
G_OAUTH_SCOPE_CONTACTS,
G_OAUTH_SCOPE_DEFAULT,
G_OAUTH_SCOPE_MAIL_READONLY,
O_OAUTH_SCOPE_CALENDAR,
O_OAUTH_SCOPE_CONTACTS,
O_OAUTH_SCOPE_DEFAULT,
O_OAUTH_SCOPE_MAIL,
} from '@proton/activation/src/constants';
import { ImportProvider, ImportType } from '@proton/activation/src/interface';
import isTruthy from '@proton/utils/isTruthy';
const getGoogleScopes = (products?: ImportType[]) => {
const scopes = [...G_OAUTH_SCOPE_DEFAULT];
if (products?.includes(ImportType.MAIL)) {
scopes.push(...G_OAUTH_SCOPE_MAIL_READONLY);
}
if (products?.includes(ImportType.CALENDAR)) {
scopes.push(...G_OAUTH_SCOPE_CALENDAR);
}
if (products?.includes(ImportType.CONTACTS)) {
scopes.push(...G_OAUTH_SCOPE_CONTACTS);
}
scopes.filter(isTruthy).flat(1);
return scopes;
};
const getOutlookScopes = (products?: ImportType[]) => {
const scopes = [...O_OAUTH_SCOPE_DEFAULT];
if (products?.includes(ImportType.MAIL)) {
scopes.push(...O_OAUTH_SCOPE_MAIL);
}
if (products?.includes(ImportType.CALENDAR)) {
scopes.push(...O_OAUTH_SCOPE_CALENDAR);
}
if (products?.includes(ImportType.CONTACTS)) {
scopes.push(...O_OAUTH_SCOPE_CONTACTS);
}
scopes.filter(isTruthy).flat(1);
return scopes;
};
export const getScopeFromProvider = (provider: ImportProvider, products: ImportType[]) => {
if (provider === ImportProvider.GOOGLE) {
return getGoogleScopes(products);
}
if (provider === ImportProvider.OUTLOOK) {
return getOutlookScopes(products);
}
return [];
};
| 4,906
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/Modals/OAuth
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/Modals/OAuth/StepProducts/useStepProducts.ts
|
import { useState } from 'react';
import { EasySwitchFeatureFlag, ImportProvider, ImportType } from '@proton/activation/src/interface';
import {
changeOAuthStep,
displayConfirmLeaveModal,
resetOauthDraft,
submitProductProvider,
} from '@proton/activation/src/logic/draft/oauthDraft/oauthDraft.actions';
import {
selectOauthDraftProvider,
selectOauthImportStateProducts,
} from '@proton/activation/src/logic/draft/oauthDraft/oauthDraft.selector';
import { useEasySwitchDispatch, useEasySwitchSelector } from '@proton/activation/src/logic/store';
import { FeatureCode, useFeature } from '@proton/components';
import { getEnabledFeature } from '../OAuthModal.helpers';
import { getScopeFromProvider } from './useStepProducts.helpers';
interface Props {
triggerOAuth: (scopes: string[]) => void;
}
const useStepProducts = ({ triggerOAuth }: Props) => {
const dispatch = useEasySwitchDispatch();
const products = useEasySwitchSelector(selectOauthImportStateProducts);
const provider = useEasySwitchSelector(selectOauthDraftProvider);
if (!products || !provider) {
throw new Error('products and provider must be defined');
}
const easySwitchFeature = useFeature<EasySwitchFeatureFlag>(FeatureCode.EasySwitch);
const featureMap = easySwitchFeature.feature!.Value;
const [mailChecked, setMailChecked] = useState(products.includes(ImportType.MAIL) ?? false);
const [contactChecked, setContactChecked] = useState(products.includes(ImportType.CONTACTS) ?? false);
const [calendarChecked, setCalendarChecked] = useState(products.includes(ImportType.CALENDAR) ?? false);
const handleCancel = () => {
dispatch(displayConfirmLeaveModal(false));
dispatch(resetOauthDraft());
};
const handleSubmit = () => {
const products = [];
if (mailChecked) {
products.push(ImportType.MAIL);
}
if (contactChecked) {
products.push(ImportType.CONTACTS);
}
if (calendarChecked) {
products.push(ImportType.CALENDAR);
}
const scopes = getScopeFromProvider(provider, products);
dispatch(submitProductProvider({ products, scopes }));
if (provider === ImportProvider.OUTLOOK) {
triggerOAuth(scopes);
} else if (provider === ImportProvider.GOOGLE) {
dispatch(changeOAuthStep('instructions'));
}
};
const nextDisabled = !mailChecked && !contactChecked && !calendarChecked;
return {
mailChecked,
setMailChecked,
contactChecked,
setContactChecked,
calendarChecked,
setCalendarChecked,
handleCancel,
handleSubmit,
nextDisabled,
enabledFeatures: getEnabledFeature(provider, featureMap),
};
};
export default useStepProducts;
| 4,907
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/Modals/OAuth
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/Modals/OAuth/StepSuccess/StepSuccess.test.tsx
|
import { useLocation } from 'react-router-dom';
import { fireEvent, screen } from '@testing-library/dom';
import { easySwitchRender } from '@proton/activation/src/tests/render';
import StepSuccess from './StepSuccess';
jest.mock('react-router-dom', () => ({ ...jest.requireActual('react-router-dom'), useLocation: jest.fn() }));
const mockedUseLocation = useLocation as jest.Mock;
describe('StepSuccess tests', () => {
it('Should render simple success step, no settings button while in settings', async () => {
mockedUseLocation.mockImplementation(() => {
return { pathname: '/easy-switch' };
});
easySwitchRender(<StepSuccess />);
screen.getByTestId('StepSuccess:Modal');
expect(screen.queryByTestId('StepSuccess:SettingsLink')).toBeNull();
const closeButton = screen.getByTestId('StepSuccess:CloseButton');
fireEvent.click(closeButton);
});
it('Should renter the settings link button if not in settings', () => {
mockedUseLocation.mockImplementation(() => {
return { pathname: '/mail' };
});
easySwitchRender(<StepSuccess />);
screen.getByTestId('StepSuccess:Modal');
screen.getByTestId('StepSuccess:SettingsLink');
screen.getByTestId('StepSuccess:RedirectFooter');
const submitFooter = screen.getByTestId('StepSuccess:RedirectFooterSubmit');
fireEvent.click(submitFooter);
});
});
| 4,908
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/Modals/OAuth
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/Modals/OAuth/StepSuccess/StepSuccess.tsx
|
import { useLocation } from 'react-router-dom';
import { c } from 'ttag';
import { IA_PATHNAME_REGEX } from '@proton/activation/src/constants';
import { resetOauthDraft } from '@proton/activation/src/logic/draft/oauthDraft/oauthDraft.actions';
import { selectOauthImportStateImporterData } from '@proton/activation/src/logic/draft/oauthDraft/oauthDraft.selector';
import { useEasySwitchDispatch, useEasySwitchSelector } from '@proton/activation/src/logic/store';
import { Button } from '@proton/atoms/Button';
import {
ModalTwo,
ModalTwoContent,
PrimaryButton,
SettingsLink,
useModalState,
useSettingsLink,
} from '@proton/components/components';
import ModalFooter from '@proton/components/components/modalTwo/ModalFooter';
import importStartedSvg from '@proton/styles/assets/img/onboarding/import-assistant.svg';
interface Props {
isCurrentLocationImportPage: boolean;
handleModalDisplay: (val: boolean) => void;
}
const StepSuccessFooterAction = ({ handleModalDisplay, isCurrentLocationImportPage }: Props) => {
const dispatch = useEasySwitchDispatch();
const settingsLink = useSettingsLink();
const handleClose = (redirect?: boolean) => {
dispatch(resetOauthDraft());
handleModalDisplay(false);
if (redirect) {
settingsLink(`/easy-switch`);
}
};
if (isCurrentLocationImportPage) {
return (
<ModalFooter className="flex-justify-end">
<Button data-testid="StepSuccess:CloseButton" shape="outline" onClick={() => handleClose(false)}>
{c('Action').t`Close`}
</Button>
</ModalFooter>
);
}
return (
<ModalFooter data-testid="StepSuccess:RedirectFooter">
<Button shape="outline" onClick={() => handleClose(false)} data-testid="StepSuccess:RedirectFooterSubmit">
{c('Action').t`Close`}
</Button>
<PrimaryButton onClick={() => handleClose(true)}>{c('Action').t`Check import progress`}</PrimaryButton>
</ModalFooter>
);
};
const StepSuccess = () => {
const location = useLocation();
const [modalProps, handleModalDisplay] = useModalState({ open: true });
const importerData = useEasySwitchSelector(selectOauthImportStateImporterData);
const isCurrentLocationImportPage = IA_PATHNAME_REGEX.test(location.pathname);
const toEmail = importerData?.emails?.fields?.importAddress.Email;
const fromEmail = importerData?.importedEmail;
const importProgressLink = (
<SettingsLink key="link" path="/easy-switch" onClick={() => handleModalDisplay(false)}>{c('Info')
.t`here`}</SettingsLink>
);
return (
<ModalTwo {...modalProps} size="xlarge">
<ModalTwoContent>
<div className="text-center mb-8" data-testid="StepSuccess:Modal">
<img src={importStartedSvg} alt="" className="max-w-4/5" />
<h3>{c('Info').t`Import in progress`}</h3>
<div className="mb-4">{c('Info').t`Importing your data from ${fromEmail} to ${toEmail}.`}</div>
<div>{c('Info').t`We'll notify you when the import is done.`}</div>
<div className="mb-4">{c('Info').t`Large imports can take several days.`}</div>
{!isCurrentLocationImportPage && (
<div className="mb-4" data-testid="StepSuccess:SettingsLink">{c('Info')
.jt`You can check the progress ${importProgressLink}.`}</div>
)}
<div>{c('Info').t`Close this screen to exit.`}</div>
</div>
</ModalTwoContent>
<StepSuccessFooterAction
handleModalDisplay={handleModalDisplay}
isCurrentLocationImportPage={isCurrentLocationImportPage}
/>
</ModalTwo>
);
};
export default StepSuccess;
| 4,909
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/OAuthImportButton/GoogleButton.tsx
|
import { c } from 'ttag';
import { Button } from '@proton/atoms';
import googleLogo from '@proton/styles/assets/img/import/providers/google.svg';
import clsx from '@proton/utils/clsx';
interface Props {
label?: string;
className?: string;
disabled?: boolean;
onClick: () => void;
}
const GoogleButton = ({ className, disabled, onClick, label }: Props) => {
return (
<Button
className={clsx(['inline-flex flex-justify-center', className])}
disabled={disabled}
onClick={onClick}
data-testid="OAuthImportButton:button:google"
>
<img src={googleLogo} className="mr-2 flex-align-self-center" alt="" />
{label ?? c('Action').t`Continue with Google`}
</Button>
);
};
export default GoogleButton;
| 4,910
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/OAuthImportButton/OAuthImportButton.test.tsx
|
import { fireEvent, screen } from '@testing-library/dom';
import { EASY_SWITCH_SOURCE, ImportProvider, ImportType } from '@proton/activation/src/interface';
import { easySwitchRender } from '@proton/activation/src/tests/render';
import OAuthImportButton from './OAuthImportButton';
describe('Test correct rendering of loading importer', () => {
it('Should render importer', () => {
easySwitchRender(
<OAuthImportButton
source={EASY_SWITCH_SOURCE.EASY_SWITCH_SETTINGS}
defaultCheckedTypes={[ImportType.MAIL]}
displayOn="GoogleCalendar"
provider={ImportProvider.GOOGLE}
/>
);
const button = screen.getByTestId('OAuthImportButton:button:google');
fireEvent.click(button);
});
});
| 4,911
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/OAuthImportButton/OAuthImportButton.tsx
|
import { c } from 'ttag';
import {
EASY_SWITCH_SOURCE,
EasySwitchFeatureFlag,
ImportProvider,
ImportType,
} from '@proton/activation/src/interface';
import { startOauthDraft } from '@proton/activation/src/logic/draft/oauthDraft/oauthDraft.actions';
import { useEasySwitchDispatch } from '@proton/activation/src/logic/store';
import { FeatureCode } from '@proton/components/containers/features';
import { useFeature, useUser } from '@proton/components/hooks';
import GoogleButton from './GoogleButton';
import OutlookButton from './OutlookButton';
type AllowedImporter = ImportProvider.GOOGLE | ImportProvider.OUTLOOK;
interface Props {
className?: string;
source: EASY_SWITCH_SOURCE;
defaultCheckedTypes: ImportType[];
displayOn: keyof EasySwitchFeatureFlag;
onClick?: () => void;
provider: AllowedImporter;
}
const OAuthImportButton = ({ className, provider, defaultCheckedTypes, displayOn, onClick }: Props) => {
const [user, userLoading] = useUser();
const isDelinquent = !user.hasNonDelinquentScope;
const dispatch = useEasySwitchDispatch();
const easySwitchFeature = useFeature<EasySwitchFeatureFlag>(FeatureCode.EasySwitch);
const easySwitchFeatureLoading = easySwitchFeature.loading;
const easySwitchFeatureValue = easySwitchFeature.feature?.Value;
const disabled = easySwitchFeatureLoading || userLoading || isDelinquent || !easySwitchFeatureValue?.[displayOn];
const handleClick = () => {
dispatch(
startOauthDraft({
provider,
products: defaultCheckedTypes,
})
);
onClick?.();
};
if (provider === ImportProvider.GOOGLE) {
return (
<GoogleButton
disabled={disabled}
className={className}
onClick={handleClick}
label={c('Action').t`Import from Google`}
/>
);
}
if (provider === ImportProvider.OUTLOOK) {
return (
<OutlookButton
disabled={disabled}
className={className}
onClick={handleClick}
label={c('Action').t`Import from Outlook`}
/>
);
}
return null;
};
export default OAuthImportButton;
| 4,912
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/OAuthImportButton/OutlookButton.tsx
|
import { c } from 'ttag';
import { Button } from '@proton/atoms';
import outlookLogo from '@proton/styles/assets/img/import/providers/outlook.svg';
import clsx from '@proton/utils/clsx';
interface Props {
className?: string;
disabled?: boolean;
label?: string;
onClick: () => void;
}
const OutlookButton = ({ className, disabled, onClick, label }: Props) => {
return (
<Button
className={clsx(['inline-flex flex-justify-center', className])}
disabled={disabled}
onClick={onClick}
data-testid="OAuthImportButton:button:outlook"
>
<img
alt=""
src={outlookLogo}
className="mr-2 w-custom flex-align-self-center"
style={{ '--w-custom': '18px' }}
/>
{label ?? c('Action').t`Continue with Outlook`}
</Button>
);
};
export default OutlookButton;
| 4,913
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable/ReportsTable.test.tsx
|
import { fireEvent, screen, waitFor } from '@testing-library/dom';
import { rest } from 'msw';
import { setupServer } from 'msw/node';
import { easySwitchRender } from '@proton/activation/src/tests/render';
import ReportsTable from './ReportsTable';
const server = setupServer();
beforeAll(() => {
server.listen();
});
afterEach(() => server.resetHandlers());
afterAll(() => {
server.close();
});
describe('Reports table testing', () => {
it('Should display placeholder text when no imports available', async () => {
server.use(
rest.get('importer/v1/reports', (req, res, ctx) => res(ctx.set('date', '01/01/2022'), ctx.json([]))),
rest.get('importer/v1/importers', (req, res, ctx) => res(ctx.set('date', '01/01/2022'), ctx.json([]))),
rest.get('importer/v1/sync', (req, res, ctx) => res(ctx.set('date', '01/01/2022'), ctx.json([])))
);
easySwitchRender(<ReportsTable />);
screen.getByTestId('reportsTable:noImports');
});
it('Should display the list of finished importer', async () => {
const finishedReport = {
Code: 1000,
Reports: [
{
ID: 'testingImporter',
CreateTime: 1671548668,
EndTime: 1671548773,
Provider: 1,
Account: 'easyflavien@gmail.com',
State: 1,
Summary: {
Calendar: {
State: 2,
NumEvents: 0,
TotalSize: 0,
RollbackState: 0,
},
Contacts: {
State: 2,
NumContacts: 100,
NumGroups: 1,
TotalSize: 55003,
RollbackState: 0,
},
Mail: {
State: 2,
NumMessages: 88,
TotalSize: 1393911,
RollbackState: 1,
CanDeleteSource: 0,
},
},
TotalSize: 1448914,
},
],
};
server.use(
rest.get('importer/v1/reports', (req, res, ctx) =>
res(ctx.set('date', '01/01/2022'), ctx.json(finishedReport))
)
);
easySwitchRender(<ReportsTable />);
const reportRows = await waitFor(() => screen.findAllByTestId('reportsTable:reportRow'));
expect(reportRows).toHaveLength(3);
const deleteReport = screen.getAllByTestId('ReportsTable:deleteReport');
fireEvent.click(deleteReport[0]);
await waitFor(() => screen.getByTestId('ReportsTable:deleteModal'));
});
it('Should allow reconnection when importer has failed', async () => {
const importerData = {
ID: 'testingImporter',
Account: 'testing@proton.ch',
Product: ['Mail'],
Provider: 0,
TokenID: null,
ImapHost: 'imap.proton.ch',
ImapPort: 993,
Email: 'testing@testing.com',
Sasl: 'PLAIN',
AllowSelfSigned: 0,
MailboxSize: {
Archive: 0,
Draft: 2191,
Inbox: 315729,
Sent: 5862,
"Spéciæl charaters-&'(yeah": 0,
"Spéciæl charaters-&'(yeah/sub spécïªl charaters": 7549,
'Test folder': 134826,
'Test folder/a test folder with big name': 10100,
'Test folder/a test folder with big name/a sub sub folder': 13120,
'another test foldr with a really long name hey hye hey': 226333,
},
Active: {
Mail: {
CreateTime: 1671630060,
State: 4,
ErrorCode: 1,
},
},
};
const apiCallSpy = jest.fn();
const importersSpy = jest.fn();
const singleImporterSpy = jest.fn();
server.use(
rest.get('/core/v4/features', (req, res, ctx) => {
apiCallSpy();
return res(ctx.set('date', '01/01/2022'), ctx.json({}));
}),
rest.get('/importer/v1/mail/importers/authinfo', (req, res, ctx) => {
apiCallSpy();
return res(ctx.set('date', '01/01/2022'), ctx.json({}));
}),
rest.get('/core/v4/system/config', (req, res, ctx) => {
apiCallSpy();
return res(ctx.set('date', '01/01/2022'), ctx.json({}));
}),
rest.get('importer/v1/importers', (req, res, ctx) => {
importersSpy();
return res(
ctx.set('date', '01/01/2022'),
ctx.json({
Code: 1000,
Importers: [importerData],
})
);
}),
rest.get(`importer/v1/importers/${importerData.ID}`, (req, res, ctx) => {
singleImporterSpy();
return res(
ctx.set('date', '01/01/2022'),
ctx.json({
Code: 1000,
Importer: importerData,
})
);
})
);
easySwitchRender(<ReportsTable />);
await waitFor(() => expect(importersSpy).toHaveBeenCalledTimes(1));
await waitFor(() => expect(apiCallSpy).toHaveBeenCalled());
const reconnectButton = screen.getByTestId('ReportsTable:reconnectImporter');
fireEvent.click(reconnectButton);
await waitFor(() => expect(singleImporterSpy).toHaveBeenCalledTimes(1));
const emailInput = screen.getByTestId('StepForm:emailInput');
const passwordInput = screen.getByTestId('StepForm:passwordInput');
const serverInput = screen.getByTestId('StepForm:serverInput');
const portInput = screen.getByTestId('StepForm:portInput');
const submitButton = screen.getByTestId('StepForm:submitButton');
expect(emailInput).toHaveValue(importerData.Account);
expect(serverInput).toHaveValue(importerData.ImapHost);
expect(portInput).toHaveValue('993');
expect(emailInput).toBeDisabled();
expect(submitButton).toBeDisabled();
fireEvent.change(passwordInput, { target: { value: 'app password' } });
await waitFor(() => expect(submitButton).toBeEnabled());
});
it('Should display the list of ongoing forwarding', async () => {
const ongoingForward = {
Code: 1000,
Syncs: [
{
ID: 'forward-1',
ImporterID: 'forwardImporter-1',
Account: 'easyflavien@gmail.com',
Product: 'Mail',
State: 1,
CreateTime: 1677771164,
LastRenewTime: 1677771164,
LastImportTime: 0,
},
],
};
const apiCallSpy = jest.fn();
const importersSpy = jest.fn();
server.use(
rest.get('/core/v4/features', (req, res, ctx) => {
apiCallSpy();
return res(ctx.set('date', '01/01/2022'), ctx.json({}));
}),
rest.get('/importer/v1/mail/importers/authinfo', (req, res, ctx) => {
apiCallSpy();
return res(ctx.set('date', '01/01/2022'), ctx.json({}));
}),
rest.get('/core/v4/system/config', (req, res, ctx) => {
apiCallSpy();
return res(ctx.set('date', '01/01/2022'), ctx.json({}));
}),
rest.get('importer/v1/sync', (req, res, ctx) => {
importersSpy();
return res(ctx.set('date', '01/01/2022'), ctx.json(ongoingForward));
})
);
easySwitchRender(<ReportsTable />);
await waitFor(() => expect(apiCallSpy).toHaveBeenCalled());
await waitFor(() => expect(importersSpy).toHaveBeenCalledTimes(1));
const reportRows = screen.getAllByTestId('reportsTable:syncRow');
expect(reportRows).toHaveLength(1);
const deleteReport = screen.getAllByTestId('ReportsTable:deleteForward');
fireEvent.click(deleteReport[0]);
await waitFor(() => screen.getByTestId('ReportsTable:deleteModal'));
});
});
| 4,914
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable/ReportsTable.tsx
|
import { useEffect } from 'react';
import { c } from 'ttag';
import { loadDashboard } from '@proton/activation/src/logic/actions';
import { selectActiveImporterIdsByDate } from '@proton/activation/src/logic/importers/importers.selectors';
import { selectReportSummaryIdsByDate } from '@proton/activation/src/logic/reports/reports.selectors';
import { useEasySwitchDispatch, useEasySwitchSelector } from '@proton/activation/src/logic/store';
import { selectSyncIdsByDate } from '@proton/activation/src/logic/sync/sync.selectors';
import { SettingsParagraph, Table, TableBody, TableHeader, TableHeaderCell, TableRow } from '@proton/components';
import ImporterRow from './Importers/ImporterRow';
import ReportRow from './Reports/ReportRow';
import ReportsTableInfos from './ReportsTableInfos';
import SyncRow from './Sync/SyncRow';
const ReportsTable = () => {
const reportIds = useEasySwitchSelector(selectReportSummaryIdsByDate);
const activeImporterIds = useEasySwitchSelector(selectActiveImporterIdsByDate);
const syncIdsArray = useEasySwitchSelector(selectSyncIdsByDate);
const dispatch = useEasySwitchDispatch();
useEffect(() => {
const request = dispatch(loadDashboard());
return () => {
request.abort();
};
}, []);
if (reportIds.length === 0 && activeImporterIds.length === 0 && syncIdsArray.length === 0) {
return (
<SettingsParagraph data-testid="reportsTable:noImports">{c('Info')
.t`No imports or forwarding history.`}</SettingsParagraph>
);
}
return (
<>
<ReportsTableInfos />
<Table hasActions responsive="cards">
<TableHeader>
<TableRow>
<TableHeaderCell>{c('Title header').t`Import`}</TableHeaderCell>
<TableHeaderCell>{c('Title header').t`Status`}</TableHeaderCell>
<TableHeaderCell>{c('Title header').t`Date`}</TableHeaderCell>
<TableHeaderCell>{c('Title header').t`Size`}</TableHeaderCell>
<TableHeaderCell>{c('Title header').t`Actions`}</TableHeaderCell>
</TableRow>
</TableHeader>
<TableBody>
{syncIdsArray.map((id) => (
<SyncRow key={id} syncId={id} />
))}
{activeImporterIds.map((id) => (
<ImporterRow key={id} activeImporterId={id} />
))}
{reportIds.map((id) => (
<ReportRow key={id} reportSummaryId={id} />
))}
</TableBody>
</Table>
</>
);
};
export default ReportsTable;
| 4,915
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable/ReportsTableCell.helpers.test.ts
|
import { ImportType } from '@proton/activation/src/interface';
import { getImportIconNameByProduct, getImportProductName } from './ReportsTableCell.helpers';
describe('ReportsTableCell.helpers', () => {
it('getImportProductName - test all types', () => {
const mail = getImportProductName(ImportType.MAIL);
const calendar = getImportProductName(ImportType.CALENDAR);
const contact = getImportProductName(ImportType.CONTACTS);
expect(mail).toStrictEqual('Mail');
expect(calendar).toStrictEqual('Calendar');
expect(contact).toStrictEqual('Contacts');
});
it('getImportIconNameByProduct - test all types', () => {
const mail = getImportIconNameByProduct(ImportType.MAIL);
const calendar = getImportIconNameByProduct(ImportType.CALENDAR);
const contact = getImportIconNameByProduct(ImportType.CONTACTS);
expect(mail).toStrictEqual('envelope');
expect(calendar).toStrictEqual('calendar-grid');
expect(contact).toStrictEqual('users');
});
});
| 4,916
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable/ReportsTableCell.helpers.ts
|
import { c } from 'ttag';
import { ImportType } from '@proton/activation/src/interface';
import { IconName } from '@proton/components/components';
export const getImportProductName = (type: ImportType) => {
switch (type) {
case ImportType.MAIL:
return c('Import type').t`Mail`;
case ImportType.CALENDAR:
return c('Import type').t`Calendar`;
case ImportType.CONTACTS:
return c('Import type').t`Contacts`;
}
};
export const getImportIconNameByProduct = (type: ImportType, isSync?: boolean): IconName => {
if (isSync) {
return 'arrows-rotate';
}
switch (type) {
case ImportType.MAIL:
return 'envelope';
case ImportType.CALENDAR:
return 'calendar-grid';
case ImportType.CONTACTS:
return 'users';
}
};
| 4,917
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable/ReportsTableCell.tsx
|
import { ImportType } from '@proton/activation/src/interface';
import { Icon, TableCell } from '@proton/components/components';
import { getImportIconNameByProduct, getImportProductName } from './ReportsTableCell.helpers';
interface Props {
product: ImportType;
title: string;
isSync?: boolean;
}
const ReportsTableCell = ({ product: app, title, isSync }: Props) => (
<TableCell>
<div className="flex">
<div className="flex-item-noshrink mr-2 hidden md:flex">
<Icon name={getImportIconNameByProduct(app, isSync)} className="color-weak" />
</div>
<div className="flex-item-fluid">
<div className="w-full text-ellipsis" title={title}>
{title}
</div>
<div className="flex color-weak">{getImportProductName(app)}</div>
</div>
</div>
</TableCell>
);
export default ReportsTableCell;
| 4,918
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable/ReportsTableInfos.tsx
|
import { c, msgid } from 'ttag';
import { selectActiveImportersErrors } from '@proton/activation/src/logic/importers/importers.selectors';
import { useEasySwitchSelector } from '@proton/activation/src/logic/store';
import { Href } from '@proton/atoms';
import { Alert, SettingsParagraph } from '@proton/components';
import { BRAND_NAME } from '@proton/shared/lib/constants';
import { getKnowledgeBaseUrl } from '@proton/shared/lib/helpers/url';
const ReportsTableInfos = () => {
const { importErrors, delayedImportAccounts } = useEasySwitchSelector(selectActiveImportersErrors);
const delayedImportsCount = delayedImportAccounts.length;
const accounts = delayedImportAccounts.join(', ');
const bandwidthLimitLink = (
<Href
key="bandwidthLimitLink"
href={getKnowledgeBaseUrl(
'/manage-imports-easy-switch#:~:text=notification%20in%20advance.-,Delayed%20imports,-Some%20email%20providers'
)}
>
{c('Import error link').t`bandwidth limit`}
</Href>
);
// translator: the variable here is a HTML tag, here is the complete sentence: "Proton will try to resume the import as soon as your email provider resets your account’s bandwidth limit. You don’t need to do anything. If you cancel your import, you won't be able to resume it and you will need to start over."
const bandwidthMessage = c('Info')
.jt`${BRAND_NAME} will try to resume the import as soon as your email provider resets your account’s ${bandwidthLimitLink}. You don’t need to do anything. If you cancel your import, you won't be able to resume it and you will need to start over.`;
return (
<>
{!importErrors.includes('authConnection') && (
<SettingsParagraph>{c('Info').t`Check the status of imports and forwarding.`}</SettingsParagraph>
)}
{importErrors.includes('storageLimit') && (
<Alert className="mb-4" type="warning">
{c('Info').t`${BRAND_NAME} paused an import because your account is running low on space. You can:`}
<ul className="m-0">
<li>{c('Info').t`free up space by deleting older messages or other data`}</li>
<li>{c('Info').t`purchase additional storage`}</li>
</ul>
</Alert>
)}
{importErrors.includes('authConnection') && (
<Alert className="mb-4" type="warning">
{c('Info')
.t`${BRAND_NAME} paused an import because it lost the connection with your other email provider. Please reconnect.`}
</Alert>
)}
{importErrors.includes('delayedImport') && (
<Alert className="mb-4" type="warning">
{c('Info').ngettext(
msgid`Your import from ${accounts} is temporarily delayed.`,
`Your imports from ${accounts} are temporarily delayed.`,
delayedImportsCount
)}
<br />
{bandwidthMessage}
</Alert>
)}
</>
);
};
export default ReportsTableInfos;
| 4,919
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable/Importers/ImporterRow.tsx
|
import { memo } from 'react';
import { format } from 'date-fns';
import { c } from 'ttag';
import { ActiveImportID } from '@proton/activation/src/logic/importers/importers.interface';
import {
selectActiveImporterById,
selectImporterById,
} from '@proton/activation/src/logic/importers/importers.selectors';
import { useEasySwitchSelector } from '@proton/activation/src/logic/store';
import { TableCell, TableRow } from '@proton/components';
import { dateLocale } from '@proton/shared/lib/i18n';
import ReportsTableCell from '../ReportsTableCell';
import ImporterRowActions from './ImporterRowActions';
import ImporterRowStatus from './ImporterRowStatus';
interface Props {
activeImporterId: ActiveImportID;
}
const ImporterRow = ({ activeImporterId }: Props) => {
const activeImporter = useEasySwitchSelector((state) => selectActiveImporterById(state, activeImporterId));
const importer = useEasySwitchSelector((state) => selectImporterById(state, activeImporter.importerID));
const { product, importState, startDate, errorCode } = activeImporter;
const { account } = importer;
return (
<TableRow>
<ReportsTableCell product={product} title={account} />
<TableCell>
<div>
<ImporterRowStatus state={importState} errorCode={errorCode} />
</div>
</TableCell>
<TableCell>
<time>{format(startDate * 1000, 'PPp', { locale: dateLocale })}</time>
</TableCell>
<TableCell label={c('Title header').t`Size`}>{'-'}</TableCell>
<TableCell>
<ImporterRowActions activeImporterID={activeImporter.localID} />
</TableCell>
</TableRow>
);
};
export default memo(ImporterRow);
| 4,920
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable/Importers/ImporterRowActions.tsx
|
import { c } from 'ttag';
import { createToken, resumeImport, updateImport } from '@proton/activation/src/api';
import { ApiImporterError, ApiImporterState } from '@proton/activation/src/api/api.interface';
import { getImportProviderFromApiProvider } from '@proton/activation/src/helpers/getImportProviderFromApiProvider';
import useOAuthPopup from '@proton/activation/src/hooks/useOAuthPopup';
import { AuthenticationMethod, EASY_SWITCH_SOURCE, ImportToken, OAuthProps } from '@proton/activation/src/interface';
import { reconnectImapImport } from '@proton/activation/src/logic/draft/imapDraft/imapDraft.actions';
import { cancelImporter } from '@proton/activation/src/logic/importers/importers.actions';
import { ActiveImportID } from '@proton/activation/src/logic/importers/importers.interface';
import {
selectActiveImporterById,
selectImporterById,
} from '@proton/activation/src/logic/importers/importers.selectors';
import { useEasySwitchDispatch, useEasySwitchSelector } from '@proton/activation/src/logic/store';
import { Button } from '@proton/atoms';
import { Alert, DropdownActions, Prompt, useModalState } from '@proton/components';
import { useApi, useEventManager, useNotifications } from '@proton/components/hooks';
import { useLoading } from '@proton/hooks';
import { BRAND_NAME } from '@proton/shared/lib/constants';
import { getScopeFromProvider } from '../../Modals/OAuth/StepProducts/useStepProducts.helpers';
interface Props {
activeImporterID: ActiveImportID;
}
const ImporterRowActions = ({ activeImporterID }: Props) => {
const dispatch = useEasySwitchDispatch();
const activeImporter = useEasySwitchSelector((state) => selectActiveImporterById(state, activeImporterID));
const importer = useEasySwitchSelector((state) => selectImporterById(state, activeImporter.importerID));
const { ID, account, sasl, provider, products } = importer;
const importProvider = getImportProviderFromApiProvider(provider);
const { product, errorCode, importState } = activeImporter;
const { triggerOAuthPopup, loadingConfig } = useOAuthPopup({
errorMessage: c('Error').t`Your import will not be processed.`,
});
const api = useApi();
const { call } = useEventManager();
const { createNotification } = useNotifications();
const [loadingPrimaryAction, withLoadingPrimaryAction] = useLoading();
const [loadingSecondaryAction, withLoadingSecondaryAction] = useLoading();
const [cancelModalProps, showCancelModal, renderCancelModal] = useModalState();
const handleReconnectOAuth = async (ImporterID: string) => {
const scopes = getScopeFromProvider(importProvider, products);
triggerOAuthPopup({
provider: importProvider,
loginHint: account,
scope: scopes.join(' '),
callback: async ({ Code, Provider, RedirectUri }: OAuthProps) => {
const { Token }: { Token: ImportToken } = await api(
createToken({
Provider,
Code,
RedirectUri,
Source: EASY_SWITCH_SOURCE.RECONNECT_IMPORT,
Products: products || [product],
})
);
await api(updateImport(ID, { TokenID: Token.ID }));
await api(
resumeImport({
ImporterID,
Products: [product],
})
);
await call();
createNotification({ text: c('Success').t`Resuming import` });
},
});
};
const handleReconnect = async (importerID: string) => {
await dispatch(reconnectImapImport(importerID));
// const apiImporterResponse = await api<ApiImportResponse>(getImport(importerID));
// const activeImport = getDeprecatedImporterFormatByID(apiImporterResponse);
// await createModal(<ImportMailModal addresses={addresses} currentImport={activeImport} />);
};
const handleResume = async (ImporterID: string) => {
await api(
resumeImport({
ImporterID,
Products: [product],
})
);
await call();
createNotification({ text: c('Success').t`Resuming import` });
};
const isAuthError = errorCode === ApiImporterError.ERROR_CODE_IMAP_CONNECTION;
const list = [
...(importState === ApiImporterState.PAUSED
? [
{
text: isAuthError ? c('Action').t`Reconnect` : c('Action').t`Resume`,
onClick: () => {
if (isAuthError) {
return withLoadingSecondaryAction(
!sasl || sasl === AuthenticationMethod.OAUTH
? handleReconnectOAuth(ID)
: handleReconnect(ID)
);
}
return withLoadingSecondaryAction(handleResume(ID));
},
loading: loadingConfig || loadingSecondaryAction,
'data-testid': 'ReportsTable:reconnectImporter',
},
]
: []),
{
text: c('Action').t`Cancel`,
onClick: () => showCancelModal(true),
loading: loadingPrimaryAction,
disabled: importState === ApiImporterState.CANCELED,
},
];
return (
<>
<DropdownActions size="small" list={list} />
{renderCancelModal && (
<Prompt
{...cancelModalProps}
title={c('Confirm modal title').t`Import is incomplete!`}
buttons={[
<Button
color="danger"
onClick={() => {
void withLoadingPrimaryAction(dispatch(cancelImporter({ activeImporterID })));
showCancelModal(false);
}}
>{c('Action').t`Cancel`}</Button>,
<Button
color="weak"
onClick={() => {
showCancelModal(false);
}}
>{c('Action').t`Continue`}</Button>,
]}
>
<Alert className="mb-4" type="error">
{c('Warning')
.t`If you cancel this import, you won't be able to resume it. ${BRAND_NAME} saved all progress in your account. Cancel anyway?`}
</Alert>
</Prompt>
)}
</>
);
};
export default ImporterRowActions;
| 4,921
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable/Importers/ImporterRowStatus.test.tsx
|
import { screen } from '@testing-library/dom';
import { ApiImporterError, ApiImporterState } from '@proton/activation/src/api/api.interface';
import { easySwitchRender } from '@proton/activation/src/tests/render';
import ImporterRowStatus from './ImporterRowStatus';
describe('ReportRowStatus', () => {
it('Should display PAUSED status%', () => {
easySwitchRender(<ImporterRowStatus state={ApiImporterState.PAUSED} errorCode={undefined} />);
screen.getByText('Paused');
});
it('Should display PAUSED status', () => {
easySwitchRender(<ImporterRowStatus state={ApiImporterState.PAUSED} errorCode={undefined} />);
screen.getByText('Paused');
});
it('Should display PAUSED status ERROR_CODE_IMAP_CONNECTION', () => {
easySwitchRender(
<ImporterRowStatus
state={ApiImporterState.PAUSED}
errorCode={ApiImporterError.ERROR_CODE_IMAP_CONNECTION}
/>
);
screen.getByTestId('ImporterRowStatus:IMAP_Error');
});
it('Should display PAUSED status ERROR_CODE_QUOTA_LIMIT', () => {
easySwitchRender(
<ImporterRowStatus state={ApiImporterState.PAUSED} errorCode={ApiImporterError.ERROR_CODE_QUOTA_LIMIT} />
);
screen.getByTestId('ImporterRowStatus:quota_Error');
});
it('Should display QUEUED status', () => {
easySwitchRender(<ImporterRowStatus state={ApiImporterState.QUEUED} errorCode={undefined} />);
screen.getByText('Started');
});
it('Should display CANCELED status', () => {
easySwitchRender(<ImporterRowStatus state={ApiImporterState.CANCELED} errorCode={undefined} />);
screen.getByText('Canceling');
});
it('Should display DELAYED status', () => {
easySwitchRender(<ImporterRowStatus state={ApiImporterState.DELAYED} errorCode={undefined} />);
screen.getByText('Delayed');
});
});
| 4,922
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable/Importers/ImporterRowStatus.tsx
|
import { c } from 'ttag';
import { ApiImporterError, ApiImporterState } from '@proton/activation/src/api/api.interface';
import { Badge, Icon, Tooltip } from '@proton/components';
import { BRAND_NAME, MAIL_APP_NAME } from '@proton/shared/lib/constants';
interface Props {
state: ApiImporterState | undefined;
errorCode: ApiImporterError | undefined;
}
const ImporterRowStatus = ({ state, errorCode }: Props) => {
switch (state) {
case ApiImporterState.PAUSED:
return (
<>
<Badge type="warning">{c('Import status').t`Paused`}</Badge>
{errorCode === ApiImporterError.ERROR_CODE_IMAP_CONNECTION && (
<Tooltip
title={c('Tooltip').t`Account is disconnected`}
data-testid="ImporterRowStatus:IMAP_Error"
>
<Icon name="exclamation-circle-filled" />
</Tooltip>
)}
{errorCode === ApiImporterError.ERROR_CODE_QUOTA_LIMIT && (
<Tooltip
title={c('Tooltip').t`Your ${MAIL_APP_NAME} inbox is almost full`}
data-testid="ImporterRowStatus:quota_Error"
>
<Icon name="exclamation-circle-filled" />
</Tooltip>
)}
</>
);
case ApiImporterState.QUEUED:
return <Badge type="primary">{c('Import status').t`Started`}</Badge>;
case ApiImporterState.CANCELED:
return <Badge type="error">{c('Import status').t`Canceling`}</Badge>;
case ApiImporterState.DELAYED:
return (
<>
<Badge type="warning">{c('Import status').t`Delayed`}</Badge>
<Tooltip
title={c('Tooltip')
.t`Your external account may have reached its 24-hour bandwidth limit. ${BRAND_NAME} will try to resume the import as soon as possible.`}
>
<Icon name="exclamation-circle-filled" />
</Tooltip>
</>
);
/*
* Default case is "in progress"
*/
default:
return <Badge type="primary">{c('Import status').t`In progress`}</Badge>;
}
};
export default ImporterRowStatus;
| 4,923
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable/Reports/ReportRow.tsx
|
import { memo } from 'react';
import { format } from 'date-fns';
import { c } from 'ttag';
import { ReportSummaryID } from '@proton/activation/src/logic/reports/reports.interface';
import { selectReportById, selectReportSummaryById } from '@proton/activation/src/logic/reports/reports.selectors';
import { useEasySwitchSelector } from '@proton/activation/src/logic/store';
import { TableCell, TableRow } from '@proton/components';
import humanSize from '@proton/shared/lib/helpers/humanSize';
import { dateLocale } from '@proton/shared/lib/i18n';
import ReportsTableCell from '../ReportsTableCell';
import ReportRowActions from './ReportRowActions';
import ReportRowStatus from './ReportRowStatus';
interface Props {
reportSummaryId: ReportSummaryID;
}
const ReportRow = ({ reportSummaryId }: Props) => {
const reportSummary = useEasySwitchSelector((state) => selectReportSummaryById(state, reportSummaryId));
const report = useEasySwitchSelector((state) => selectReportById(state, reportSummary.reportID));
const { product, rollbackState, state, size } = reportSummary;
const { account, endDate } = report;
return (
<TableRow data-testid="reportsTable:reportRow">
<ReportsTableCell product={product} title={account} />
<TableCell>
<div>
<ReportRowStatus status={state} rollbackState={rollbackState} />
</div>
</TableCell>
<TableCell>
<time>{format(endDate * 1000, 'PPp', { locale: dateLocale })}</time>
</TableCell>
<TableCell label={c('Title header').t`Size`}>{humanSize(size)}</TableCell>
<TableCell>
<ReportRowActions key="button" reportSummaryID={reportSummaryId} rollbackState={rollbackState} />
</TableCell>
</TableRow>
);
};
export default memo(ReportRow);
| 4,924
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable/Reports/ReportRowActions.tsx
|
import { c } from 'ttag';
import { ApiReportRollbackState } from '@proton/activation/src/api/api.interface';
import { deleteReportSummary, rollbackReportSummary } from '@proton/activation/src/logic/reports/reports.actions';
import { ReportSummaryID } from '@proton/activation/src/logic/reports/reports.interface';
import { useEasySwitchDispatch } from '@proton/activation/src/logic/store';
import { Button } from '@proton/atoms';
import { Alert, DropdownActions, Prompt, useModalState } from '@proton/components';
import { useLoading } from '@proton/hooks';
interface Props {
reportSummaryID: ReportSummaryID;
rollbackState: ApiReportRollbackState | undefined;
}
const ReportRowActions = ({ reportSummaryID, rollbackState }: Props) => {
const dispatch = useEasySwitchDispatch();
const [deleteModalProps, showDeleteModal, renderDeleteModal] = useModalState();
const [rollbackModalProps, showRollbackModal, renderRollbackModal] = useModalState();
const [loadingDeleteRecord, withLoadingDeleteRecord] = useLoading();
const [loadingUndoRecord, withLoadingUndoRecord] = useLoading();
const list =
loadingUndoRecord || rollbackState === ApiReportRollbackState.ROLLING_BACK
? []
: [
{
text: c('Action').t`Delete record`,
onClick: () => showDeleteModal(true),
loading: loadingDeleteRecord,
'data-testid': 'ReportsTable:deleteReport',
},
...(rollbackState === ApiReportRollbackState.CAN_ROLLBACK && !loadingDeleteRecord
? [
{
text: c('Action').t`Undo import`,
onClick: () => showRollbackModal(true),
},
]
: []),
];
return (
<>
<DropdownActions size="small" list={list} />
{renderDeleteModal && (
<Prompt
{...deleteModalProps}
title={c('Confirm modal title').t`Remove from the list?`}
buttons={[
<Button
color="danger"
onClick={() => {
void withLoadingDeleteRecord(dispatch(deleteReportSummary({ reportSummaryID })));
showDeleteModal(false);
}}
>{c('Action').t`Remove`}</Button>,
<Button color="weak" onClick={() => showDeleteModal(false)}>{c('Action').t`Keep`}</Button>,
]}
data-testid="ReportsTable:deleteModal"
>
<Alert className="mb-4" type="error">
{c('Warning').t`You will not see this import record in the list any more.`}
</Alert>
</Prompt>
)}
{renderRollbackModal && (
<Prompt
{...rollbackModalProps}
title={c('Confirm modal title').t`Undo this import?`}
buttons={[
<Button
color="danger"
onClick={() => {
void withLoadingUndoRecord(dispatch(rollbackReportSummary({ reportSummaryID })));
showRollbackModal(false);
}}
>{c('Action').t`Yes, undo`}</Button>,
<Button color="weak" onClick={() => showRollbackModal(false)}>{c('Action').t`Cancel`}</Button>,
]}
>
<Alert className="mb-4" type="error">
{c('Warning').t`This will remove all messages, folders, and labels created during the import.`}
</Alert>
</Prompt>
)}
</>
);
};
export default ReportRowActions;
| 4,925
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable/Reports/ReportRowStatus.test.tsx
|
import { screen } from '@testing-library/dom';
import { ApiImporterState, ApiReportRollbackState } from '@proton/activation/src/api/api.interface';
import { easySwitchRender } from '@proton/activation/src/tests/render';
import ReportRowStatus from './ReportRowStatus';
describe('ReportRowStatus', () => {
it('Should display paused status', () => {
easySwitchRender(<ReportRowStatus status={ApiImporterState.PAUSED} rollbackState={undefined} />);
screen.getByText('Paused');
});
it('Should display canceled status', () => {
easySwitchRender(<ReportRowStatus status={ApiImporterState.CANCELED} rollbackState={undefined} />);
screen.getByText('Canceled');
});
it('Should display Completed status', () => {
easySwitchRender(<ReportRowStatus status={ApiImporterState.DONE} rollbackState={undefined} />);
screen.getByText('Completed');
});
it('Should display FAILED status', () => {
easySwitchRender(<ReportRowStatus status={ApiImporterState.FAILED} rollbackState={undefined} />);
screen.getByText('Failed');
});
it('Should display ROLLED_BACK status', () => {
easySwitchRender(
<ReportRowStatus status={ApiImporterState.FAILED} rollbackState={ApiReportRollbackState.ROLLED_BACK} />
);
screen.getByText('Undo finished');
});
it('Should display ROLLING_BACK status', () => {
easySwitchRender(
<ReportRowStatus status={ApiImporterState.FAILED} rollbackState={ApiReportRollbackState.ROLLING_BACK} />
);
screen.getByText('Undo in progress');
});
});
| 4,926
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable/Reports/ReportRowStatus.tsx
|
import { c } from 'ttag';
import { ApiImporterState, ApiReportRollbackState } from '@proton/activation/src/api/api.interface';
import { Badge } from '@proton/components';
interface Props {
status: ApiImporterState;
rollbackState: ApiReportRollbackState | undefined;
}
const ReportRowStatus = ({ status, rollbackState }: Props) => {
if (rollbackState === ApiReportRollbackState.ROLLED_BACK || rollbackState === ApiReportRollbackState.ROLLING_BACK) {
switch (rollbackState) {
case ApiReportRollbackState.ROLLED_BACK:
return <Badge type="success" className="m-0">{c('Import rollback status').t`Undo finished`}</Badge>;
case ApiReportRollbackState.ROLLING_BACK:
return <Badge type="warning" className="m-0">{c('Import rollback status').t`Undo in progress`}</Badge>;
}
}
switch (status) {
case ApiImporterState.PAUSED:
return <Badge type="warning" className="m-0">{c('Import status').t`Paused`}</Badge>;
case ApiImporterState.CANCELED:
return <Badge type="error" className="m-0">{c('Import status').t`Canceled`}</Badge>;
case ApiImporterState.DONE:
return <Badge type="success" className="m-0">{c('Import status').t`Completed`}</Badge>;
case ApiImporterState.FAILED:
return <Badge type="error" className="m-0">{c('Import status').t`Failed`}</Badge>;
}
return null;
};
export default ReportRowStatus;
| 4,927
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable/Sync/SyncRow.tsx
|
import { format } from 'date-fns';
import { useEasySwitchSelector } from '@proton/activation/src/logic/store';
import { selectSyncById } from '@proton/activation/src/logic/sync/sync.selectors';
import { TableCell, TableRow } from '@proton/components';
import { dateLocale } from '@proton/shared/lib/i18n';
import ReportsTableCell from '../ReportsTableCell';
import SyncRowActions from './SyncRowActions';
import SyncRowStatus from './SyncRowStatus';
interface Props {
syncId: string;
}
const SyncRow = ({ syncId }: Props) => {
const syncItem = useEasySwitchSelector((state) => selectSyncById(state, syncId));
const { product, account, state, startDate } = syncItem;
return (
<TableRow data-testid="reportsTable:syncRow">
<ReportsTableCell product={product} title={account} isSync />
<TableCell>
<div className="text-center md:text-left">
<SyncRowStatus state={state} />
</div>
</TableCell>
<TableCell>
<time>{format(startDate * 1000, 'PPp', { locale: dateLocale })}</time>
</TableCell>
<TableCell>-</TableCell>
<TableCell>
<SyncRowActions syncId={syncId} />
</TableCell>
</TableRow>
);
};
export default SyncRow;
| 4,928
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable/Sync/SyncRowActions.tsx
|
import { c } from 'ttag';
import { ApiSyncState } from '@proton/activation/src/api/api.interface';
import { SYNC_G_OAUTH_SCOPES, SYNC_SOURCE } from '@proton/activation/src/constants';
import useOAuthPopup from '@proton/activation/src/hooks/useOAuthPopup';
import { EasySwitchFeatureFlag, ImportProvider, OAuthProps } from '@proton/activation/src/interface';
import { useEasySwitchDispatch, useEasySwitchSelector } from '@proton/activation/src/logic/store';
import { deleteSyncItem, resumeSyncItem } from '@proton/activation/src/logic/sync/sync.actions';
import { selectSyncById } from '@proton/activation/src/logic/sync/sync.selectors';
import { Button } from '@proton/atoms/Button';
import { Alert, DropdownActions, Prompt, useModalState } from '@proton/components/components';
import { FeatureCode } from '@proton/components/containers';
import { useFeature } from '@proton/components/hooks';
import { useLoading } from '@proton/hooks';
interface Props {
syncId: string;
}
const SyncRowActions = ({ syncId }: Props) => {
const dispatch = useEasySwitchDispatch();
const syncItem = useEasySwitchSelector((state) => selectSyncById(state, syncId));
const [deleteModalProps, showDeleteModal, renderDeleteModal] = useModalState();
const [loadingApiChange, withLoadingApiChange] = useLoading();
const { triggerOAuthPopup, loadingConfig } = useOAuthPopup({
errorMessage: c('Error').t`Your forward will not be processed.`,
});
const { feature } = useFeature<EasySwitchFeatureFlag>(FeatureCode.EasySwitch);
const handleReconnectClick = () => {
triggerOAuthPopup({
provider: ImportProvider.GOOGLE,
scope: SYNC_G_OAUTH_SCOPES.join(' '),
callback: async (oAuthProps: OAuthProps) => {
const { Code, Provider, RedirectUri } = oAuthProps;
void withLoadingApiChange(
dispatch(
resumeSyncItem({
Code,
Provider,
RedirectUri,
Source: SYNC_SOURCE,
notification: { text: c('action').t`Resuming forward` },
syncId,
importerId: syncItem.importerID,
})
)
);
},
});
};
const getStoppedAction = () => {
const deleteSyncButton = {
text: c('account').t`Delete forward`,
onClick: () => showDeleteModal(true),
};
if (feature?.Value.GoogleMailSync) {
return [
{
text: c('account').t`Reconnect`,
onClick: handleReconnectClick,
disabled: loadingConfig,
},
deleteSyncButton,
];
}
// If gmail sync isn't available users can only delete sync
return [deleteSyncButton];
};
const activeAction = [
{
text: c('account').t`Delete forward`,
onClick: () => showDeleteModal(true),
'data-testid': 'ReportsTable:deleteForward',
loading: loadingApiChange,
},
];
const handleDeleteSync = () => {
void withLoadingApiChange(dispatch(deleteSyncItem({ syncId })));
showDeleteModal(false);
};
return (
<>
<DropdownActions
loading={loadingApiChange}
size="small"
list={syncItem.state === ApiSyncState.ACTIVE ? activeAction : getStoppedAction()}
/>
{renderDeleteModal && (
<Prompt
title={c('account').t`Remove forward`}
data-testid="ReportsTable:deleteModal"
buttons={[
<Button color="danger" onClick={handleDeleteSync}>
{c('Action').t`Remove`}
</Button>,
<Button color="weak" onClick={() => showDeleteModal(false)}>
{c('Action').t`Keep`}
</Button>,
]}
{...deleteModalProps}
>
<Alert className="mb-4" type="error">
{c('account').t`You will stop the mail forwarding.`}
</Alert>
</Prompt>
)}
</>
);
};
export default SyncRowActions;
| 4,929
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable/Sync/SyncRowStatus.test.tsx
|
import { screen } from '@testing-library/dom';
import { ApiSyncState } from '@proton/activation/src/api/api.interface';
import { easySwitchRender } from '@proton/activation/src/tests/render';
import SyncRowStatus from './SyncRowStatus';
describe('SyncRowStatus', () => {
it('Should display active when status is ACTIVE', () => {
easySwitchRender(<SyncRowStatus state={ApiSyncState.ACTIVE} />);
screen.getByText('Active');
});
it('Should display paused when status is EXPIRED', () => {
easySwitchRender(<SyncRowStatus state={ApiSyncState.EXPIRED} />);
screen.getByText('Paused');
});
it('Should display paused when status is OFFLINE', () => {
easySwitchRender(<SyncRowStatus state={ApiSyncState.OFFLINE} />);
screen.getByText('Paused');
});
});
| 4,930
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/ReportsTable/Sync/SyncRowStatus.tsx
|
import { c } from 'ttag';
import { ApiSyncState } from '@proton/activation/src/api/api.interface';
import { Badge } from '@proton/components';
interface Props {
state: ApiSyncState;
}
const SyncRowStatus = ({ state }: Props) => {
switch (state) {
case ApiSyncState.ACTIVE:
return <Badge type="primary">{c('Import status').t`Active`}</Badge>;
case ApiSyncState.OFFLINE:
case ApiSyncState.EXPIRED:
return <Badge type="warning">{c('Import status').t`Paused`}</Badge>;
}
return null;
};
export default SyncRowStatus;
| 4,931
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/SettingsArea/GmailForwarding.test.tsx
|
import { screen } from '@testing-library/dom';
import { useFlag } from '@proton/components/containers/unleash';
import { useUser } from '@proton/components/hooks/useUser';
import { easySwitchRender } from '../../tests/render';
import GmailForwarding from './GmailForwarding';
jest.mock('@proton/components/hooks/useUser');
const mockUseUser = useUser as jest.MockedFunction<any>;
jest.mock('@proton/components/containers/unleash');
const mockUseFlag = useFlag as unknown as jest.MockedFunction<any>;
describe('GmailForwarding', () => {
it('Should be enabled if user is not delinquent', () => {
mockUseFlag.mockReturnValue(false);
mockUseUser.mockReturnValue([{ hasNonDelinquentScope: true }, false]);
easySwitchRender(<GmailForwarding />);
const gmailForward = screen.getByTestId('ProviderCard:googleCardForward').firstChild;
expect(gmailForward).toBeEnabled();
});
it('Should be disabled if user is delinquent', () => {
mockUseFlag.mockReturnValue(false);
mockUseUser.mockReturnValue([{ hasNonDelinquentScope: false }, false]);
easySwitchRender(<GmailForwarding />);
const gmailForward = screen.getByTestId('ProviderCard:googleCardForward');
expect(gmailForward).toBeDisabled();
});
it('Should be disabled if loading user is true', () => {
mockUseFlag.mockReturnValue(false);
mockUseUser.mockReturnValue([{ hasNonDelinquentScope: true }, true]);
easySwitchRender(<GmailForwarding />);
const gmailForward = screen.getByTestId('ProviderCard:googleCardForward');
expect(gmailForward).toBeDisabled();
});
it('Should be disabled if maintenance mode is enabled', () => {
mockUseFlag.mockReturnValue(true);
mockUseUser.mockReturnValue([{ hasNonDelinquentScope: true }, false]);
easySwitchRender(<GmailForwarding />);
const gmailForward = screen.getByTestId('ProviderCard:googleCardForward');
expect(gmailForward).toBeDisabled();
});
});
| 4,932
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/SettingsArea/GmailForwarding.tsx
|
import { CheckListGmailForward, GmailSyncModal, useFlag, useModalState, useUser } from '@proton/components';
const GmailForwarding = () => {
const isInMaintenance = useFlag('MaintenanceImporter');
const [syncModalProps, setSyncModalProps, renderSyncModal] = useModalState();
const [user, loadingUser] = useUser();
const disabled = loadingUser || !user.hasNonDelinquentScope;
const handleModalClose = (hasError?: boolean) => {
if (!hasError) {
setSyncModalProps(false);
}
};
return (
<>
<div className="inline-block">
<CheckListGmailForward
onClick={() => setSyncModalProps(true)}
disabled={disabled}
data-testid="ProviderCard:googleCardForward"
isInMaintenance={isInMaintenance}
/>
</div>
{renderSyncModal && <GmailSyncModal noSkip onSyncCallback={handleModalClose} {...syncModalProps} />}
</>
);
};
export default GmailForwarding;
| 4,933
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/SettingsArea/SettingsArea.test.tsx
|
import { screen } from '@testing-library/dom';
import useFeature from '@proton/components/hooks/useFeature';
import { easySwitchRender } from '../../tests/render';
import SettingsArea from './SettingsArea';
const settingsAreaConfig = {
text: 'Import via Easy Switch',
to: '/easy-switch',
icon: 'arrow-down-to-square',
available: true,
description: 'Complete the transition to privacy with our secure importing and forwarding tools.',
subsections: [
{
text: 'Set up forwarding',
id: 'start-forward',
},
{
text: 'Import messages',
id: 'start-import',
},
{
text: 'History',
id: 'import-list',
},
],
};
jest.mock('@proton/components/hooks/useFeature');
const mockUseFeature = useFeature as jest.MockedFunction<any>;
describe('SettingsArea', () => {
it('Should render a loader while loading feature flag', async () => {
mockUseFeature.mockReturnValue({ feature: { Value: { GoogleMailSync: true } }, loading: true });
easySwitchRender(<SettingsArea config={settingsAreaConfig} />);
const forwardSection = screen.queryByTestId('SettingsArea:forwardSection');
expect(forwardSection).toBeNull();
});
it('Should render the forward section if feature is enabled', async () => {
mockUseFeature.mockReturnValue({ feature: { Value: { GoogleMailSync: true } }, loading: false });
easySwitchRender(<SettingsArea config={settingsAreaConfig} />);
const googleInScreen = screen.getAllByText('Google');
const gmailInScreen = screen.getByTestId('ProviderCard:googleCardForward');
screen.getByTestId('SettingsArea:forwardSection');
expect(googleInScreen).toHaveLength(1);
expect(gmailInScreen).toBeVisible();
});
});
| 4,934
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/SettingsArea/SettingsArea.tsx
|
import { c } from 'ttag';
import { Loader } from '@proton/components/components';
import { FeatureCode } from '@proton/components/containers';
import { SettingsParagraph, SettingsSectionWide } from '@proton/components/containers/account';
import { PrivateMainSettingsArea, SettingsAreaConfig } from '@proton/components/containers/layout';
import { PrivateMainSettingsAreaBase } from '@proton/components/containers/layout/PrivateMainSettingsArea';
import { useFeature } from '@proton/components/hooks';
import { BRAND_NAME, MAIL_APP_NAME } from '@proton/shared/lib/constants';
import { EasySwitchFeatureFlag } from '../../interface';
import EasySwitchStoreProvider from '../../logic/StoreProvider';
import ReportsTable from '../ReportsTable/ReportsTable';
import GmailForwarding from './GmailForwarding';
import ProviderCards from './ProviderCards/ProviderCards';
interface Props {
config: SettingsAreaConfig;
}
const SettingsArea = ({ config }: Props) => {
const { loading } = useFeature<EasySwitchFeatureFlag>(FeatureCode.EasySwitch);
if (loading) {
return (
<PrivateMainSettingsAreaBase title={config.text} description={config.description}>
<Loader size="medium" className="py-14 text-center" />
</PrivateMainSettingsAreaBase>
);
}
return (
<EasySwitchStoreProvider>
<PrivateMainSettingsArea config={config}>
<SettingsSectionWide>
<SettingsParagraph data-testid="SettingsArea:forwardSection">
{c('Info').t`Forward incoming mail from another account to your secure ${MAIL_APP_NAME} inbox.`}
</SettingsParagraph>
<GmailForwarding />
</SettingsSectionWide>
<SettingsSectionWide>
<SettingsParagraph>
{c('Info')
.t`Import your emails, calendars, and contacts from another service to ${BRAND_NAME}.`}
</SettingsParagraph>
<ProviderCards />
</SettingsSectionWide>
<SettingsSectionWide>
<ReportsTable />
</SettingsSectionWide>
</PrivateMainSettingsArea>
</EasySwitchStoreProvider>
);
};
export default SettingsArea;
| 4,935
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/SettingsArea
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/SettingsArea/ProviderCards/ProviderCard.scss
|
.provider-card {
inline-size: 11rem;
block-size: 8rem;
}
| 4,936
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/SettingsArea
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/SettingsArea/ProviderCards/ProviderCard.tsx
|
import { c } from 'ttag';
import { ImportProvider } from '@proton/activation/src/interface';
import { Button, ButtonProps } from '@proton/atoms';
import { Icon } from '@proton/components';
import googleLogo from '@proton/styles/assets/img/import/providers/google.svg';
import outlookLogo from '@proton/styles/assets/img/import/providers/outlook.svg';
import yahooLogo from '@proton/styles/assets/img/import/providers/yahoo.svg';
import clsx from '@proton/utils/clsx';
import './ProviderCard.scss';
interface Props extends ButtonProps {
provider: ImportProvider;
}
const { GOOGLE, OUTLOOK, YAHOO, DEFAULT } = ImportProvider;
const ProviderCard = ({ className, provider, ...rest }: Props) => {
const providerMap = {
[GOOGLE]: {
name: 'Google',
logo: googleLogo,
width: 32,
height: 32,
},
[OUTLOOK]: {
name: 'Outlook',
logo: outlookLogo,
width: 44,
height: 44,
},
[YAHOO]: {
name: 'Yahoo',
logo: yahooLogo,
width: 76,
height: 22,
},
[DEFAULT]: {
// translator: here 'Other' stand for "other provider"
name: c('Import provider').t`Other`,
logo: 'three-dots-horizontal',
width: 48,
height: 46,
},
};
const { name, logo, width, height } = providerMap[provider];
return (
<Button
className={clsx(['provider-card inline-flex flex-column py-5', className])}
aria-label={c('Import provider').t`Import from ${provider}`}
{...rest}
>
<div className="flex-item-fluid flex flex-justify-center w-full">
{provider === ImportProvider.DEFAULT ? (
<Icon name={logo} className="flex-align-self-center" size={40} />
) : (
<img src={logo} alt="" className="flex-align-self-center" width={width} height={height} />
)}
</div>
<span className="flex-align-self-center">{name}</span>
</Button>
);
};
export default ProviderCard;
| 4,937
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/SettingsArea
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/SettingsArea/ProviderCards/ProviderCards.test.tsx
|
import { fireEvent, screen, waitFor } from '@testing-library/dom';
import { rest } from 'msw';
import { setupServer } from 'msw/node';
import { easySwitchRender } from '@proton/activation/src/tests/render';
import { useUser } from '@proton/components/index';
import ProviderCards from './ProviderCards';
const defaultUseUser = [
{
isAdmin: true,
isFree: true,
isMember: true,
isPaid: true,
isPrivate: true,
isSubUser: true,
isDelinquent: true,
hasNonDelinquentScope: true,
hasPaidMail: true,
hasPaidVpn: true,
canPay: true,
},
false,
];
jest.mock('@proton/components/hooks/useUser');
const mockUseUser = useUser as jest.MockedFunction<any>;
jest.mock('@proton/components/hooks/useFeature', () => () => {
return {
feature: {
Code: 'EasySwitch',
Type: 'mixed',
Global: true,
DefaultValue: {
GoogleMail: true,
GoogleCalendar: true,
GoogleContacts: true,
GoogleDrive: false,
OutlookMail: true,
OutlookCalendar: true,
OutlookContacts: true,
OtherMail: true,
OtherCalendar: true,
OtherContacts: true,
OtherDrive: false,
},
Value: {
GoogleMail: true,
GoogleCalendar: true,
GoogleContacts: true,
GoogleDrive: false,
OutlookMail: true,
OutlookCalendar: true,
OutlookContacts: true,
OtherMail: true,
OtherCalendar: true,
OtherContacts: true,
OtherDrive: false,
},
Writable: false,
},
};
});
jest.mock('@proton/components/hooks/useCalendars', () => () => [
[
{
ID: 'calendarId',
Name: 'testing@proton.ch',
Description: '',
Type: 0,
Owner: {
Email: 'testing@proton.ch',
},
Flags: 1,
Members: [
{
ID: 'memberId',
Permissions: 127,
Email: 'testing@proton.ch',
AddressID: 'addressID',
CalendarID: 'calendarId',
Name: 'testing@proton.ch',
Description: '',
Color: '#273EB2',
Display: 1,
Flags: 1,
},
],
Color: '#273EB2',
Display: 1,
Email: 'testing@proton.ch',
Permissions: 127,
},
],
false,
]);
const server = setupServer();
beforeAll(() => {
server.listen();
server.use(
rest.get('/core/v4/features', (req, res, ctx) => {
return res(ctx.set('date', '01/01/2022'), ctx.json({}));
}),
rest.get('/importer/v1/mail/importers/authinfo', (req, res, ctx) => {
return res(ctx.set('date', '01/01/2022'), ctx.json({}));
}),
rest.get('/core/v4/system/config', (req, res, ctx) => {
return res(ctx.set('date', '01/01/2022'), ctx.json({}));
}),
rest.get('/calendar/v1', (req, res, ctx) => {
return res(ctx.set('date', '01/01/2022'), ctx.json({}));
})
);
});
afterEach(() => server.resetHandlers());
afterAll(() => {
server.close();
});
describe('Provider cards process testing', () => {
it('Should display the four cards on the page without user data', async () => {
mockUseUser.mockReturnValue(defaultUseUser);
easySwitchRender(<ProviderCards />);
const google = screen.getByTestId('ProviderCard:googleCard');
const yahoo = screen.getByTestId('ProviderCard:yahooCard');
const outlook = screen.getByTestId('ProviderCard:outlookCard');
const imap = screen.getByTestId('ProviderCard:imapCard');
expect(google).toBeEnabled();
expect(yahoo).toBeEnabled();
expect(outlook).toBeEnabled();
expect(imap).toBeEnabled();
// Open imap modal
fireEvent.click(imap);
await waitFor(() => screen.getByTestId('MailModal:ProductModal'));
let productButtons = screen.getAllByTestId('MailModal:ProductButton');
expect(productButtons).toHaveLength(3);
// Close imap modal
let closeButton = screen.getByTestId('modal:close');
fireEvent.click(closeButton);
await waitFor(() => screen.queryAllByTestId('MailModal:ProductModal'));
productButtons = screen.queryAllByTestId('MailModal:ProductButton');
expect(productButtons).toStrictEqual([]);
// Open yahoo modal
fireEvent.click(yahoo);
await waitFor(() => screen.getByTestId('MailModal:ProductModal'));
productButtons = screen.getAllByTestId('MailModal:ProductButton');
expect(productButtons).toHaveLength(3);
closeButton = screen.getByTestId('modal:close');
// Close yahoo modal
closeButton = screen.getByTestId('modal:close');
fireEvent.click(closeButton);
await waitFor(() => screen.queryAllByTestId('MailModal:ProductModal'));
productButtons = screen.queryAllByTestId('MailModal:ProductButton');
expect(productButtons).toStrictEqual([]);
});
it('Should trigger yahoo auth error', async () => {
mockUseUser.mockReturnValue(defaultUseUser);
server.use(
rest.get('/core/v4/features', (req, res, ctx) => {
return res(ctx.set('date', '01/01/2022'), ctx.json({}));
}),
rest.get('/importer/v1/mail/importers/authinfo', (req, res, ctx) => {
return res(ctx.set('date', '01/01/2022'), ctx.json({}));
}),
rest.get('/core/v4/system/config', (req, res, ctx) => {
return res(ctx.set('date', '01/01/2022'), ctx.json({}));
}),
rest.get('/calendar/v1', (req, res, ctx) => {
return res(ctx.set('date', '01/01/2022'), ctx.json({}));
}),
rest.get('/settings/calendar', (req, res, ctx) => {
return res(ctx.set('date', '01/01/2022'), ctx.json({}));
}),
rest.post('/importer/v1/importers', (req, res, ctx) => {
return res(
ctx.set('date', '01/01/2022'),
ctx.status(422),
ctx.json({
Code: 2901,
Error: 'Invalid credentials',
Details: {
ProviderError:
'AUTHENTICATE command failed: NO [AUTHENTICATIONFAILED] AUTHENTICATE Invalid credentials\r\n',
},
})
);
})
);
easySwitchRender(<ProviderCards />);
const yahoo = screen.getByTestId('ProviderCard:yahooCard');
// Open imap product modal and click calendar
fireEvent.click(yahoo);
await waitFor(() => screen.getByTestId('MailModal:ProductModal'));
const productButtons = screen.getAllByTestId('MailModal:ProductButton');
expect(productButtons).toHaveLength(3);
fireEvent.click(productButtons[0]);
// SKip instructions and expect to see calendar modal
fireEvent.click(screen.getByTestId('Instruction:continue'));
const emailInput = screen.getByTestId('StepForm:emailInput');
const passwordInput = screen.getByTestId('StepForm:passwordInput');
fireEvent.change(emailInput, { target: { value: 'testing@yahoo.com' } });
fireEvent.change(passwordInput, { target: { value: 'password' } });
const nextButton = screen.getByTestId('StepForm:submitButton');
await waitFor(() => expect(nextButton).toBeEnabled());
fireEvent.click(nextButton);
await waitFor(() => screen.getByTestId('StepForm:yahooAuthError'));
});
it('Should click on imap calendar product', async () => {
mockUseUser.mockReturnValue(defaultUseUser);
easySwitchRender(<ProviderCards />);
const imap = screen.getByTestId('ProviderCard:imapCard');
// Open imap product modal and click calendar
fireEvent.click(imap);
await waitFor(() => screen.getByTestId('MailModal:ProductModal'));
const productButtons = screen.getAllByTestId('MailModal:ProductButton');
expect(productButtons).toHaveLength(3);
fireEvent.click(productButtons[1]);
// SKip instructions and expect to see calendar modal
fireEvent.click(screen.getByTestId('Instruction:continue'));
});
it('Should click on every product in the imap modal', async () => {
mockUseUser.mockReturnValue(defaultUseUser);
easySwitchRender(<ProviderCards />);
const imap = screen.getByTestId('ProviderCard:imapCard');
// Open imap modal and click on email
fireEvent.click(imap);
await waitFor(() => screen.getByTestId('MailModal:ProductModal'));
let productButtons = screen.getAllByTestId('MailModal:ProductButton');
expect(productButtons).toHaveLength(3);
fireEvent.click(productButtons[0]);
await waitFor(() => screen.getByTestId('Instruction:defaultMailInstructions'));
fireEvent.click(screen.getByTestId('Instruction:close'));
// Open imap modal and click on contact
fireEvent.click(imap);
await waitFor(() => screen.getByTestId('MailModal:ProductModal'));
productButtons = screen.getAllByTestId('MailModal:ProductButton');
expect(productButtons).toHaveLength(3);
fireEvent.click(productButtons[1]);
await waitFor(() => screen.getByTestId('Instruction:defaultCalendarInstructions'));
fireEvent.click(screen.getByTestId('Instruction:close'));
// Open imap modal and click on contact
fireEvent.click(imap);
await waitFor(() => screen.getByTestId('MailModal:ProductModal'));
productButtons = screen.getAllByTestId('MailModal:ProductButton');
expect(productButtons).toHaveLength(3);
fireEvent.click(productButtons[2]);
await waitFor(() => screen.getByTestId('Instruction:defaultContactInstructions'));
fireEvent.click(screen.getByTestId('Instruction:close'));
});
it('Should click on every product in the yahoo modal', async () => {
mockUseUser.mockReturnValue(defaultUseUser);
easySwitchRender(<ProviderCards />);
const yahoo = screen.getByTestId('ProviderCard:yahooCard');
// Open yahoo modal and click on email
fireEvent.click(yahoo);
await waitFor(() => screen.getByTestId('MailModal:ProductModal'));
let productButtons = screen.getAllByTestId('MailModal:ProductButton');
expect(productButtons).toHaveLength(3);
fireEvent.click(productButtons[0]);
await waitFor(() => screen.getByTestId('Instruction:yahooMailInstructions'));
fireEvent.click(screen.getByTestId('Instruction:close'));
// Open yahoo modal and click on contact
fireEvent.click(yahoo);
await waitFor(() => screen.getByTestId('MailModal:ProductModal'));
productButtons = screen.getAllByTestId('MailModal:ProductButton');
expect(productButtons).toHaveLength(3);
fireEvent.click(productButtons[1]);
await waitFor(() => screen.getByTestId('Instruction:yahooCalendarInstructions'));
fireEvent.click(screen.getByTestId('Instruction:close'));
// Open yahoo modal and click on contact
fireEvent.click(yahoo);
await waitFor(() => screen.getByTestId('MailModal:ProductModal'));
productButtons = screen.getAllByTestId('MailModal:ProductButton');
expect(productButtons).toHaveLength(3);
fireEvent.click(productButtons[2]);
await waitFor(() => screen.getByTestId('Instruction:yahooContactInstructions'));
fireEvent.click(screen.getByTestId('Instruction:close'));
});
it('Should disable all cards if user is delinquent', () => {
mockUseUser.mockReturnValue([{ hasNonDelinquentScope: false }, false]);
easySwitchRender(<ProviderCards />);
const google = screen.getByTestId('ProviderCard:googleCard');
const yahoo = screen.getByTestId('ProviderCard:yahooCard');
const outlook = screen.getByTestId('ProviderCard:outlookCard');
const imap = screen.getByTestId('ProviderCard:imapCard');
expect(google).toBeDisabled();
expect(yahoo).toBeDisabled();
expect(outlook).toBeDisabled();
expect(imap).toBeDisabled();
});
it('Should disable all cards while user is loading', () => {
mockUseUser.mockReturnValue([{ hasNonDelinquentScope: true }, true]);
easySwitchRender(<ProviderCards />);
const google = screen.getByTestId('ProviderCard:googleCard');
const yahoo = screen.getByTestId('ProviderCard:yahooCard');
const outlook = screen.getByTestId('ProviderCard:outlookCard');
const imap = screen.getByTestId('ProviderCard:imapCard');
expect(google).toBeDisabled();
expect(yahoo).toBeDisabled();
expect(outlook).toBeDisabled();
expect(imap).toBeDisabled();
});
});
| 4,938
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/SettingsArea
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/components/SettingsArea/ProviderCards/ProviderCards.tsx
|
import { c } from 'ttag';
import { ImportProvider, ImportType } from '@proton/activation/src/interface';
import { startImapDraft } from '@proton/activation/src/logic/draft/imapDraft/imapDraft.actions';
import { startOauthDraft } from '@proton/activation/src/logic/draft/oauthDraft/oauthDraft.actions';
import { useEasySwitchDispatch } from '@proton/activation/src/logic/store';
import { FeatureCode } from '@proton/components';
import { useFeature, useUser } from '@proton/components/hooks';
import ProviderCard from './ProviderCard';
const ProviderCards = () => {
const dispatch = useEasySwitchDispatch();
const [user, loadingUser] = useUser();
const isLoading = loadingUser;
const disabled = isLoading || !user.hasNonDelinquentScope;
const easySwitchFeature = useFeature(FeatureCode.EasySwitch);
const handleGoogleClick = () => {
dispatch(
startOauthDraft({
provider: ImportProvider.GOOGLE,
products: [ImportType.CONTACTS, ImportType.CALENDAR, ImportType.MAIL],
})
);
};
return (
<>
<div className="mb-4 text-bold">{c('Info').t`Select a service provider to start`}</div>
<div className="mt-2">
<ProviderCard
loading={easySwitchFeature.loading}
provider={ImportProvider.GOOGLE}
onClick={handleGoogleClick}
disabled={disabled}
className="mb-4 mr-4"
data-testid="ProviderCard:googleCard"
/>
<ProviderCard
provider={ImportProvider.YAHOO}
onClick={() => dispatch(startImapDraft({ provider: ImportProvider.YAHOO }))}
disabled={disabled}
className="mb-4 mr-4"
data-testid="ProviderCard:yahooCard"
/>
<ProviderCard
provider={ImportProvider.OUTLOOK}
onClick={() =>
dispatch(
startOauthDraft({
provider: ImportProvider.OUTLOOK,
products: [ImportType.CONTACTS, ImportType.CALENDAR, ImportType.MAIL],
})
)
}
disabled={disabled}
className="mb-4 mr-4"
data-testid="ProviderCard:outlookCard"
/>
<ProviderCard
provider={ImportProvider.DEFAULT}
onClick={() => dispatch(startImapDraft({ provider: ImportProvider.DEFAULT }))}
disabled={disabled}
className="mb-4"
data-testid="ProviderCard:imapCard"
/>
</div>
</>
);
};
export default ProviderCards;
| 4,939
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/helpers/easyTrans.test.ts
|
import { EasyTrans } from './easyTrans';
describe('Testing instances returned by easy trans', () => {
it('Should return labelInstance', () => {
const trans = EasyTrans.get(true).hide();
expect(trans).toStrictEqual('Hide labels');
});
it('Should return folderInstance', () => {
const trans = EasyTrans.get(false).hide();
expect(trans).toStrictEqual('Hide folders');
});
});
| 4,940
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/helpers/easyTrans.ts
|
import { c, msgid } from 'ttag';
import { MAIL_APP_NAME } from '@proton/shared/lib/constants';
class GetLabelsTranslation implements TranslationInterface {
public infoHeader = () =>
c('Info')
.t`Create a label for the imported messages, a time range for this import, and the labels you would like to import.`;
public hide = () => c('Action').t`Hide labels`;
public show = () => c('Action').t`Show labels`;
public manage = () => c('Action').t`Manage labels`;
public editName = () => c('Tooltip').t`Edit label names`;
public totalCount = (totalFoldersCount: number) =>
c('Info').ngettext(
msgid`All (${totalFoldersCount} label)`,
`All (${totalFoldersCount} labels)`,
totalFoldersCount
);
public partialCount = (selectedFoldersCount: number) =>
c('Info').ngettext(
msgid`${selectedFoldersCount} label selected`,
`${selectedFoldersCount} labels selected`,
selectedFoldersCount
);
public errorNameTooLong = () => c('Error').t`The label name is too long. Please choose a different name.`;
public errorEmptyValue = () => c('Error').t`Label name cannot be empty.`;
public errorNameAlreadyExists = () =>
c('Error').t`This label name is not available. Please choose a different name.`;
public errorReservedName = () => c('Error').t`The label name is invalid. Please choose a different name.`;
public errorMaxItems = () => c('Tooltip').t`Customize import to reduce the number of labels`;
public errorItemsLimit = () =>
c('Error')
.t`Some of your label names exceed ${MAIL_APP_NAME}'s maximum character limit. Please customize the import to edit these names.`;
public errorUnavailableName = () =>
c('Error').t`Some of your label names are unavailable. Please customize the import to edit these names.`;
public foundCount = (providerFoldersNumLocalized: string, providerFoldersNum: number) =>
c('Info').ngettext(
msgid`${providerFoldersNumLocalized} label found in Gmail`,
`${providerFoldersNumLocalized} labels found in Gmail`,
providerFoldersNum
);
public selectedCount = (selectedFoldersCountLocalized: string, selectedFoldersCount: number) =>
c('Info').ngettext(
msgid`${selectedFoldersCountLocalized} label selected`,
`${selectedFoldersCountLocalized} labels selected`,
selectedFoldersCount
);
}
class GetFoldersTranslation implements TranslationInterface {
public infoHeader = () =>
c('Info')
.t`Create a label for the imported messages, a time range for this import, and the folders you would like to import.`;
public hide = () => c('Action').t`Hide folders`;
public show = () => c('Action').t`Show folders`;
public manage = () => c('Action').t`Manage folders`;
public editName = () => c('Tooltip').t`Edit folder names`;
public totalCount = (totalFoldersCount: number) =>
c('Info').ngettext(
msgid`All (${totalFoldersCount} folder)`,
`All (${totalFoldersCount} folders)`,
totalFoldersCount
);
public partialCount = (selectedFoldersCount: number) =>
c('Info').ngettext(
msgid`${selectedFoldersCount} folder selected`,
`${selectedFoldersCount} folders selected`,
selectedFoldersCount
);
public errorNameTooLong = () => c('Error').t`The folder name is too long. Please choose a different name.`;
public errorEmptyValue = () => c('Error').t`Folder name cannot be empty.`;
public errorNameAlreadyExists = () =>
c('Error').t`This folder name is not available. Please choose a different name.`;
public errorReservedName = () => c('Error').t`The folder name is invalid. Please choose a different name.`;
public errorMaxItems = () => c('Tooltip').t`Customize import to reduce the number of folders`;
public errorItemsLimit = () =>
c('Error')
.t`Some of your folder names exceed ${MAIL_APP_NAME}'s maximum character limit. Please customize the import to edit these names.`;
public errorUnavailableName = () =>
c('Error').t`Some of your folder names are unavailable. Please customize the import to edit these names.`;
public foundCount = (providerFoldersNumLocalized: string, providerFoldersNum: number) =>
c('Info').ngettext(
msgid`${providerFoldersNumLocalized} folder found`,
`${providerFoldersNumLocalized} folders found`,
providerFoldersNum
);
public selectedCount = (selectedFoldersCountLocalized: string, selectedFoldersCount: number) =>
c('Info').ngettext(
msgid`${selectedFoldersCountLocalized} folder selected`,
`${selectedFoldersCountLocalized} folders selected`,
selectedFoldersCount
);
}
export class EasyTrans {
private static labelInstance = new GetLabelsTranslation();
private static folderInstance = new GetFoldersTranslation();
public static get(isLabelMapping: boolean): GetLabelsTranslation | GetFoldersTranslation {
return isLabelMapping ? this.labelInstance : this.folderInstance;
}
}
interface TranslationInterface {
infoHeader: () => string;
hide: () => string;
show: () => string;
manage: () => string;
editName: () => string;
errorNameTooLong: () => string;
errorEmptyValue: () => string;
errorNameAlreadyExists: () => string;
errorReservedName: () => string;
errorMaxItems: () => string;
errorItemsLimit: () => string;
errorUnavailableName: () => string;
totalCount: (totalFoldersCount: number) => string;
partialCount: (selectedFoldersCount: number) => string;
foundCount: (totalFoldersCount: string, providerFoldersNum: number) => string;
selectedCount: (selectedFoldersCountLocalized: string, selectedFoldersCount: number) => string;
}
| 4,941
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/helpers/errorsMapping.test.ts
|
import { Label } from '@proton/shared/lib/interfaces';
import { Folder } from '@proton/shared/lib/interfaces/Folder';
import MailImportFoldersParser from './MailImportFoldersParser/MailImportFoldersParser';
import { getApiFoldersTestHelper } from './MailImportFoldersParser/MailImportFoldersParser.test';
import { isNameAlreadyUsed, isNameEmpty, isNameReserved, isNameTooLong } from './errorsMapping';
const smallString = '6NLaLHynY3YPM8gGLncefo5PP7n2Db';
const longString =
'wIfm5MY1a2j7MwYAFNzQapBIXZdBxZaqRGwun6UBFNVimgw38tmmLhn7HewkHhvuNYf5QlC8a2NmfctV42tdfrJJm10okXooWV5f';
describe('Activation errors mapping', () => {
describe('isNameTooLong', () => {
it('Should return false if the folder/label name is smaller than limit', () => {
const res = isNameTooLong(smallString);
expect(res).toBe(false);
});
it('Should return true if the folder/label name is longer than limit', () => {
const res = isNameTooLong(longString);
expect(res).toBe(true);
});
});
describe('isNameReserved', () => {
it('Should return false if the name is not reserved', () => {
const res = isNameReserved('folder');
expect(res).toBe(false);
});
it('Should return true if the name is reserved and capitalized', () => {
const res = isNameReserved('Scheduled');
expect(res).toBe(true);
});
it('Should return true if the name is reserved and lowercase', () => {
const res = isNameReserved('scheduled');
expect(res).toBe(true);
});
});
describe('isNameAlreadyUsed', () => {
describe('Is folder mapping', () => {
const isLabelMapping = false;
it('Should return false if the name not present in collection', () => {
const collection = new MailImportFoldersParser(
getApiFoldersTestHelper(['path1', 'path2', 'path3']),
isLabelMapping
).folders;
const item = collection[0];
const res = isNameAlreadyUsed(item, collection, [], [], isLabelMapping);
expect(res).toBe(false);
});
it('Should return false if a parent has same name as the child', () => {
const collection = new MailImportFoldersParser(
getApiFoldersTestHelper(['marco', 'marco/marco']),
isLabelMapping
).folders;
const item = collection[0];
const res = isNameAlreadyUsed(item, collection, [], [], isLabelMapping);
expect(res).toBe(false);
});
it('Should return false if name not present in array', () => {
const collection = new MailImportFoldersParser(
getApiFoldersTestHelper(['path1', 'path2']),
isLabelMapping
).folders;
const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path3']), isLabelMapping).folders[0];
const res = isNameAlreadyUsed(item, collection, [], [], isLabelMapping);
expect(res).toBe(false);
});
it('Should return false if name not present in array', () => {
const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path3']), isLabelMapping).folders[0];
const collection = new MailImportFoldersParser(
getApiFoldersTestHelper(['path1', 'path2']),
isLabelMapping
).folders;
const res = isNameAlreadyUsed(item, collection, [], [], isLabelMapping);
expect(res).toBe(false);
});
it('Should return true if name present in array', () => {
const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path3']), isLabelMapping).folders[0];
// @ts-expect-error need to override the ID because test will think it's the same item
item.id = 'anothername';
const collection = new MailImportFoldersParser(
getApiFoldersTestHelper(['path1', 'path2', 'path3']),
isLabelMapping
).folders;
const res = isNameAlreadyUsed(item, collection, [], [], isLabelMapping);
expect(res).toBe(true);
});
it('Should return false if name present in an empty array', () => {
const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path1']), isLabelMapping).folders[0];
const collection = new MailImportFoldersParser(getApiFoldersTestHelper([]), isLabelMapping).folders;
const res = isNameAlreadyUsed(item, collection, [], [], isLabelMapping);
expect(res).toBe(false);
});
it('Should return false if label with similar name exists', () => {
const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path1']), isLabelMapping).folders[0];
const collection = new MailImportFoldersParser(getApiFoldersTestHelper([]), isLabelMapping).folders;
const res = isNameAlreadyUsed(item, collection, [], [], isLabelMapping);
expect(res).toBe(false);
});
it('Should return true if label has same name', () => {
const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path1']), isLabelMapping).folders[0];
const res = isNameAlreadyUsed(item, [], [{ Path: 'path1' } as Label], [], isLabelMapping);
expect(res).toBe(true);
});
it('Should return false if folder has same name', () => {
const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path1']), isLabelMapping).folders[0];
const res = isNameAlreadyUsed(item, [], [], [{ Path: 'path1' } as Folder], isLabelMapping);
expect(res).toBe(false);
});
});
describe('Is label mapping', () => {
const isLabelMapping = true;
it('Should return false if the name not present in collection', () => {
const collection = new MailImportFoldersParser(
getApiFoldersTestHelper(['path1', 'path2', 'path3']),
isLabelMapping
).folders;
const item = collection[0];
const res = isNameAlreadyUsed(item, collection, [], [], isLabelMapping);
expect(res).toBe(false);
});
it('Should return false if a parent has same name as the child', () => {
const collection = new MailImportFoldersParser(
getApiFoldersTestHelper(['marco', 'marco/marco']),
isLabelMapping
).folders;
const item = collection[0];
const res = isNameAlreadyUsed(item, collection, [], [], isLabelMapping);
expect(res).toBe(false);
});
it('Should return false if name not present in array', () => {
const collection = new MailImportFoldersParser(
getApiFoldersTestHelper(['path1', 'path2']),
isLabelMapping
).folders;
const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path3']), isLabelMapping).folders[0];
const res = isNameAlreadyUsed(item, collection, [], [], isLabelMapping);
expect(res).toBe(false);
});
it('Should return false if name not present in array', () => {
const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path3']), isLabelMapping).folders[0];
const collection = new MailImportFoldersParser(
getApiFoldersTestHelper(['path1', 'path2']),
isLabelMapping
).folders;
const res = isNameAlreadyUsed(item, collection, [], [], isLabelMapping);
expect(res).toBe(false);
});
it('Should return true if name present in array', () => {
const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path3']), isLabelMapping).folders[0];
// @ts-expect-error need to override the ID because test will think it's the same item
item.id = 'anothername';
const collection = new MailImportFoldersParser(
getApiFoldersTestHelper(['path1', 'path2', 'path3']),
isLabelMapping
).folders;
const res = isNameAlreadyUsed(item, collection, [], [], isLabelMapping);
expect(res).toBe(true);
});
it('Should return false if name present in an empty array', () => {
const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path1']), isLabelMapping).folders[0];
const collection = new MailImportFoldersParser(getApiFoldersTestHelper([]), isLabelMapping).folders;
const res = isNameAlreadyUsed(item, collection, [], [], isLabelMapping);
expect(res).toBe(false);
});
it('Should return false if label has same name', () => {
const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path1']), isLabelMapping).folders[0];
const res = isNameAlreadyUsed(item, [], [{ Path: 'path1' } as Label], [], isLabelMapping);
expect(res).toBe(false);
});
it('Should return true if folder has same name', () => {
const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path1']), isLabelMapping).folders[0];
const res = isNameAlreadyUsed(item, [], [], [{ Path: 'path1' } as Folder], isLabelMapping);
expect(res).toBe(true);
});
});
describe('Spaces checks', () => {
it('Should return true if name in collection contains a space before', () => {
const isLabelMapping = false;
const item = new MailImportFoldersParser(getApiFoldersTestHelper([' path3']), isLabelMapping)
.folders[0];
// @ts-expect-error need to override the ID because test will think it's the same item
item.id = 'anothername';
const collection = new MailImportFoldersParser(
getApiFoldersTestHelper(['path1', 'path2', 'path3']),
isLabelMapping
).folders;
const res = isNameAlreadyUsed(item, collection, [], [], false);
expect(res).toBe(true);
});
it('Should return true if name in item contains a space after', () => {
const isLabelMapping = false;
const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path3 ']), isLabelMapping)
.folders[0];
// @ts-expect-error need to override the ID because test will think it's the same item
item.id = 'anothername';
const collection = new MailImportFoldersParser(
getApiFoldersTestHelper(['path1', 'path2', 'path3']),
isLabelMapping
).folders;
const res = isNameAlreadyUsed(item, collection, [], [], false);
expect(res).toBe(true);
});
it('Should return true if name in item contains a space before and after', () => {
const isLabelMapping = false;
const item = new MailImportFoldersParser(getApiFoldersTestHelper([' path3 ']), isLabelMapping)
.folders[0];
// @ts-expect-error need to override the ID because test will think it's the same item
item.id = 'anothername';
const collection = new MailImportFoldersParser(
getApiFoldersTestHelper(['path1', 'path2', 'path3']),
isLabelMapping
).folders;
const res = isNameAlreadyUsed(item, collection, [], [], false);
expect(res).toBe(true);
});
it('Should return true if the name present in item contains a space before and after and is capitalized', () => {
const isLabelMapping = false;
const item = new MailImportFoldersParser(getApiFoldersTestHelper([' Path3 ']), isLabelMapping)
.folders[0];
// @ts-expect-error need to override the ID because test will think it's the same item
item.id = 'anothername';
const collection = new MailImportFoldersParser(
getApiFoldersTestHelper(['path1', 'path2', 'path3']),
isLabelMapping
).folders;
const res = isNameAlreadyUsed(item, collection, [], [], false);
expect(res).toBe(true);
});
it('Should return true if the name present in item contains two space before', () => {
const isLabelMapping = false;
const item = new MailImportFoldersParser(getApiFoldersTestHelper([' Path3']), isLabelMapping)
.folders[0];
// @ts-expect-error need to override the ID because test will think it's the same item
item.id = 'anothername';
const collection = new MailImportFoldersParser(
getApiFoldersTestHelper(['path1', 'path2', 'path3']),
isLabelMapping
).folders;
const res = isNameAlreadyUsed(item, collection, [], [], false);
expect(res).toBe(true);
});
it('Should return true if the name in collection contains a space before and after', () => {
const isLabelMapping = false;
const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path3']), isLabelMapping).folders[0];
// @ts-expect-error need to override the ID because test will think it's the same item
item.id = 'anothername';
const collection = new MailImportFoldersParser(
getApiFoldersTestHelper(['path1', 'path2', ' path3 ']),
isLabelMapping
).folders;
const res = isNameAlreadyUsed(item, collection, [], [], false);
expect(res).toBe(true);
});
it('Should return true if the name passed in collection contains a space before and after and is capitalized', () => {
const isLabelMapping = false;
const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path3']), isLabelMapping).folders[0];
// @ts-expect-error need to override the ID because test will think it's the same item
item.id = 'anothername';
const collection = new MailImportFoldersParser(
getApiFoldersTestHelper(['path1', 'path2', ' Path3 ']),
isLabelMapping
).folders;
const res = isNameAlreadyUsed(item, collection, [], [], false);
expect(res).toBe(true);
});
});
});
describe('isNameEmpty', () => {
it('Should return false if the name is not empty', () => {
const res = isNameEmpty('folder');
expect(res).toBe(false);
});
it('Should return true if the name is an empty string', () => {
const res = isNameEmpty('');
expect(res).toBe(true);
});
it('Should return true if the name is undefined', () => {
const res = isNameEmpty(undefined);
expect(res).toBe(true);
});
});
describe('hasMergeWarning', () => {});
});
| 4,942
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/helpers/errorsMapping.ts
|
import { Folder } from '@proton/shared/lib/interfaces/Folder';
import { Label } from '@proton/shared/lib/interfaces/Label';
import { MailImportFolder } from './MailImportFoldersParser/MailImportFoldersParser';
export const RESERVED_NAMES = ['scheduled', 'spam', 'trash', 'outbox', 'snoozed'];
export const isNameTooLong = (folderPath: string) => new Blob([folderPath]).size >= 100;
export const isNameReserved = (folderPath: string) => RESERVED_NAMES.includes(folderPath.toLowerCase());
export const isNameAlreadyUsed = (
item: MailImportFolder,
collection: MailImportFolder[],
labels: Label[],
folders: Folder[],
isLabelMapping: boolean
) => {
const itemName = item.protonPath[item.protonPath.length - 1];
/**
* 1. Check if item has same name than folder or labels
*
* When `labelMapping` is `true` we check over folder names and vice versa
*
* This check can seem strange at first glance. Why when we import folders
* we ensure that no labels have the same name and vice versa ?
*
* Because when importing folders if a folder has same name we move it's content directly inside.
* Short answer is "Mapping is already done"
*
* On our side Label and folders as the same root entity so their names can't be the same.
* So if we import folders and a local label has the same name, we need to ask for a rename.
*/
const folderOrLabelsCollection = isLabelMapping
? folders.map((item) => item.Path)
: labels.map((item) => item.Path);
const hasSameNameWithFoldersOrLabels = folderOrLabelsCollection.some(
(path) => path.toLowerCase().trim() === itemName.toLowerCase().trim()
);
if (hasSameNameWithFoldersOrLabels) {
return true;
}
/**
* 2. Check if item has same name than other item in the collection
*/
let isDuplicateNameError = false;
for (const collectionItem of collection) {
const isCurrentItem = collectionItem.id === item.id;
if (!collectionItem.checked || isCurrentItem) {
continue;
}
const collectionItemName = collectionItem.protonPath[collectionItem.protonPath.length - 1];
const isDuplicateName = collectionItemName.toLowerCase().trim() === itemName.toLowerCase().trim();
/**
* If it's a label mapping, we don't care about the parent ID
* because labels have no parent/child relationship
*/
const hasSameParentID = isLabelMapping ? true : collectionItem.folderParentID === item.folderParentID;
if (isDuplicateName && hasSameParentID) {
isDuplicateNameError = true;
break;
}
}
return isDuplicateNameError;
};
export const isNameEmpty = (name: string | undefined) => !name || !name.trim();
export const hasMergeWarning = (
collection: MailImportFolder[],
folderItem: MailImportFolder,
isLabelMapping: boolean
) => {
return collection.some((item) => {
const isNotCurrentFolderRow = item.id !== folderItem.id;
const isSameInitialPath = item.id === folderItem.protonPath.join(folderItem.separator);
return (
folderItem.checked &&
!isLabelMapping &&
!folderItem.systemFolder &&
isNotCurrentFolderRow &&
isSameInitialPath
);
});
};
| 4,943
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/helpers/getDefaultImportCategories.test.ts
|
import { MailImportDestinationFolder, MailImportGmailCategories } from '../interface';
import { MailImportFolder } from './MailImportFoldersParser/MailImportFoldersParser';
import { getDefaultImportCategoriesDestination } from './getDefaultImportCategories';
const dummyEmail: MailImportFolder = {
id: 'id',
checked: true,
color: 'test color',
isSystemFolderChild: false,
folderChildIDS: [''],
protonPath: ['path'],
providerPath: ['providerPath'],
separator: '/',
size: 0,
category: undefined,
folderParentID: '',
systemFolder: MailImportDestinationFolder.ARCHIVE,
};
const dummyEmailWithCategory: MailImportFolder = {
id: 'id',
checked: true,
color: 'test color',
isSystemFolderChild: false,
folderChildIDS: [''],
protonPath: ['path'],
providerPath: ['providerPath'],
separator: '/',
size: 0,
category: MailImportGmailCategories.SOCIAL,
folderParentID: '',
systemFolder: MailImportDestinationFolder.ARCHIVE,
};
const dummyEmailWithCategoryAndSystem: MailImportFolder = {
id: 'id',
checked: true,
color: 'test color',
isSystemFolderChild: false,
folderChildIDS: [''],
protonPath: ['path'],
providerPath: ['providerPath'],
separator: '/',
size: 0,
category: MailImportGmailCategories.SOCIAL,
folderParentID: '',
systemFolder: undefined,
};
describe('get default import category', () => {
it('Should return inbox if no category folder', () => {
const mapping: MailImportFolder[] = [dummyEmail, dummyEmail];
const defaultDestination = getDefaultImportCategoriesDestination(mapping);
expect(defaultDestination).toStrictEqual(MailImportDestinationFolder.INBOX);
});
it('Should return inbox if category but no system folder', () => {
const mapping: MailImportFolder[] = [dummyEmail, dummyEmail, dummyEmailWithCategory];
const defaultDestination = getDefaultImportCategoriesDestination(mapping);
expect(defaultDestination).toStrictEqual(dummyEmailWithCategory.systemFolder);
});
it('Should return system folder if category', () => {
const mapping: MailImportFolder[] = [dummyEmail, dummyEmail, dummyEmailWithCategoryAndSystem];
const defaultDestination = getDefaultImportCategoriesDestination(mapping);
expect(defaultDestination).toStrictEqual(MailImportDestinationFolder.INBOX);
});
});
| 4,944
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/helpers/getDefaultImportCategories.ts
|
import { GMAIL_CATEGORIES } from '../constants';
import { MailImportDestinationFolder } from '../interface';
import { MailImportFolder } from './MailImportFoldersParser/MailImportFoldersParser';
export const getDefaultImportCategoriesDestination = (foldersMapping: MailImportFolder[]) => {
const firstMappingItemWithCategory = foldersMapping.find(
(item) => item.category && GMAIL_CATEGORIES.includes(item.category)
);
return firstMappingItemWithCategory?.systemFolder || MailImportDestinationFolder.INBOX;
};
| 4,945
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/helpers/getDefaultTimePeriod.test.ts
|
import { UserModel } from '@proton/shared/lib/interfaces';
import { TIME_PERIOD } from '../interface';
import { getDefaultTimePeriod } from './getDefaultTimePeriod';
describe('get getDefault time period', () => {
it('Should return 3 month for free users', () => {
const user: Partial<UserModel> = {
hasPaidMail: false,
};
const timePeriod = getDefaultTimePeriod(user as UserModel);
expect(timePeriod).toBe(TIME_PERIOD.LAST_3_MONTHS);
});
it('Should return big bang for free users', () => {
const user: Partial<UserModel> = {
hasPaidMail: true,
};
const timePeriod = getDefaultTimePeriod(user as UserModel);
expect(timePeriod).toBe(TIME_PERIOD.BIG_BANG);
});
});
| 4,946
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/helpers/getDefaultTimePeriod.ts
|
import { UserModel } from '@proton/shared/lib/interfaces';
import { TIME_PERIOD } from '../interface';
export const getDefaultTimePeriod = (user: UserModel) => {
return user.hasPaidMail ? TIME_PERIOD.BIG_BANG : TIME_PERIOD.LAST_3_MONTHS;
};
| 4,947
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/helpers/getImportProviderFromApiProvider.test.ts
|
import { ApiImportProvider } from '../api/api.interface';
import { ImportProvider } from '../interface';
import { getImportProviderFromApiProvider } from './getImportProviderFromApiProvider';
describe('getImportProviderFromApiProvider', () => {
it('Should return Google provider', () => {
expect(getImportProviderFromApiProvider(ApiImportProvider.GOOGLE)).toBe(ImportProvider.GOOGLE);
});
it('Should return Outlook provider', () => {
expect(getImportProviderFromApiProvider(ApiImportProvider.OUTLOOK)).toBe(ImportProvider.OUTLOOK);
});
it('Should return IMAP provider', () => {
expect(getImportProviderFromApiProvider(ApiImportProvider.IMAP)).toBe(ImportProvider.DEFAULT);
});
});
| 4,948
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/helpers/getImportProviderFromApiProvider.ts
|
import { ApiImportProvider } from '../api/api.interface';
import { ImportProvider } from '../interface';
export const getImportProviderFromApiProvider = (provider: ApiImportProvider) => {
switch (provider) {
case ApiImportProvider.GOOGLE:
return ImportProvider.GOOGLE;
case ApiImportProvider.OUTLOOK:
return ImportProvider.OUTLOOK;
case ApiImportProvider.IMAP:
return ImportProvider.DEFAULT;
default:
return ImportProvider.YAHOO;
}
};
| 4,949
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/helpers/getMailMappingErrors.ts
|
import { MAX_FOLDER_LIMIT } from '@proton/activation/src/constants';
import { MailImportPayloadError } from '@proton/activation/src/interface';
import { Label } from '@proton/shared/lib/interfaces';
import { Folder } from '@proton/shared/lib/interfaces/Folder';
import { MailImportFolder } from './MailImportFoldersParser/MailImportFoldersParser';
import { hasMergeWarning, isNameAlreadyUsed, isNameEmpty, isNameReserved, isNameTooLong } from './errorsMapping';
const {
EMPTY,
FOLDER_NAMES_TOO_LONG,
LABEL_NAMES_TOO_LONG,
MAX_FOLDERS_LIMIT_REACHED,
RESERVED_NAMES,
UNAVAILABLE_NAMES,
MERGE_WARNING,
} = MailImportPayloadError;
export const getMailMappingError = (
item: MailImportFolder,
labels: Label[],
folders: Folder[],
collection: MailImportFolder[],
isLabelMapping: boolean
): MailImportPayloadError[] => {
const errors: MailImportPayloadError[] = [];
const itemName = item.protonPath[item.protonPath.length - 1];
const hasFoldersTooLongError = item.checked && isNameTooLong(itemName);
const hasReservedNamesError = item.checked && isNameReserved(itemName);
const hasUnavailableNamesError = isNameAlreadyUsed(item, collection, labels, folders, isLabelMapping);
const hasEmptyError = isNameEmpty(itemName);
const hasMergeWarningError = hasMergeWarning(collection, item, isLabelMapping);
if (hasFoldersTooLongError) {
errors.push(isLabelMapping ? LABEL_NAMES_TOO_LONG : FOLDER_NAMES_TOO_LONG);
}
if (hasReservedNamesError) {
errors.push(RESERVED_NAMES);
}
if (hasUnavailableNamesError) {
errors.push(UNAVAILABLE_NAMES);
}
if (hasEmptyError) {
errors.push(EMPTY);
}
if (hasMergeWarningError) {
errors.push(MERGE_WARNING);
}
return errors;
};
type GetMailMappingErrorsResult = {
errors: MailImportPayloadError[];
erroredIds: MailImportFolder['id'][];
};
export const getMailMappingErrors = (
importMapping: MailImportFolder[],
isLabelMapping: boolean,
labels: Label[],
folders: Folder[]
): GetMailMappingErrorsResult => {
const checkedMapping = importMapping.filter((m) => m.checked);
const hasMaxFoldersError = checkedMapping.length + folders.length >= MAX_FOLDER_LIMIT;
const errorsSet = new Set<MailImportPayloadError>([]);
const erroredIds: MailImportFolder['id'][] = [];
importMapping
.filter((item) => {
//We remove the items with categories when importing with Google to avoid conflicts if user has a folder named "Forums", "Updates", "Promotions" or "Social"
return isLabelMapping ? !item.category : true;
})
.filter((item) => item.checked)
.forEach((item) => {
const itemErrors = getMailMappingError(item, labels, folders, importMapping, isLabelMapping);
if (itemErrors.length) {
itemErrors.forEach((error) => {
errorsSet.add(error);
});
erroredIds.push(item.id);
}
});
// Check only on mapping
if (hasMaxFoldersError) {
errorsSet.add(MAX_FOLDERS_LIMIT_REACHED);
}
return {
errors: Array.from(errorsSet),
erroredIds,
};
};
| 4,950
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/helpers
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/helpers/MailImportFoldersParser/MailImportFoldersParser.test.ts
|
import { ApiMailImporterFolder } from '@proton/activation/src/api/api.interface';
import { MailImportDestinationFolder } from '@proton/activation/src/interface';
import MailImportFoldersParser, { MailImportFolder } from './MailImportFoldersParser';
/**
* List of provider folders paths
*
* It should respect the parent/child order. No childs can be before their parent
*
* Naming:
* - p => parent
* - c => child
* - cc => subchild
* - ...
*/
const paths = [
'Inbox',
'p',
'p/c',
'p/c2',
'p/c2/cc',
'p/c3',
'p2',
'p2/c',
'p2/c/cc',
'p2/c/cc/ccc',
'p2/c/cc/ccc/cccc',
'p2/c/cc/ccc/cccc',
];
/** Basic ApiMailImporterFolders: Source is the minimal required fields */
export const getApiFoldersTestHelper = (paths: string[]) =>
paths.map(
(path) =>
({
Source: path,
Separator: '/',
...(Object.values(MailImportDestinationFolder).some((dest) => dest.toLowerCase() === path.toLowerCase())
? { DestinationFolder: path }
: {}),
} as ApiMailImporterFolder)
);
/** Used for testing purpose: Allows to navigate quickier through results */
export const getMappingTestHelper = (folders: MailImportFolder[]) =>
folders.reduce<Record<string, MailImportFolder>>((acc, folder) => {
acc[folder.id] = folder;
return acc;
}, {});
describe('MailFolderMapping', () => {
describe('Folders', () => {
it('Should contain expected ids', () => {
const isLabelMapping = false;
const foldersMapping = getMappingTestHelper(
new MailImportFoldersParser(getApiFoldersTestHelper(paths), isLabelMapping).folders
);
expect(paths.every((path) => path in foldersMapping)).toBe(true);
});
it('Should contain expected path', () => {
const isLabelMapping = false;
const foldersMapping = getMappingTestHelper(
new MailImportFoldersParser(getApiFoldersTestHelper(paths), isLabelMapping).folders
);
expect(foldersMapping.Inbox.protonPath).toEqual(['Inbox']);
expect(foldersMapping['p/c2/cc'].protonPath).toEqual(['p', 'c2', 'cc']);
});
it('Should have color defined', () => {
const isLabelMapping = false;
const foldersMapping = getMappingTestHelper(
new MailImportFoldersParser(getApiFoldersTestHelper(paths), isLabelMapping).folders
);
expect(foldersMapping.Inbox.color).toBeDefined();
expect(foldersMapping['p/c2/cc'].color).toBeDefined();
});
it('Should contain expected folderParentIDs', () => {
const isLabelMapping = false;
const foldersMapping = getMappingTestHelper(
new MailImportFoldersParser(getApiFoldersTestHelper(paths), isLabelMapping).folders
);
expect(foldersMapping.Inbox.folderParentID).toBeUndefined();
expect(foldersMapping['p/c2'].folderParentID).toBe('p');
expect(foldersMapping['p/c3'].folderParentID).toBe('p');
expect(foldersMapping['p/c2/cc'].folderParentID).toBe('p/c2');
});
it('Should contain expected childIDS', () => {
const isLabelMapping = false;
const foldersMapping = getMappingTestHelper(
new MailImportFoldersParser(getApiFoldersTestHelper(paths), isLabelMapping).folders
);
expect(foldersMapping.Inbox.folderChildIDS).toEqual([]);
expect(foldersMapping.p.folderChildIDS).toEqual(['p/c', 'p/c2', 'p/c2/cc', 'p/c3']);
expect(foldersMapping['p/c2'].folderChildIDS).toEqual(['p/c2/cc']);
expect(foldersMapping['p/c2'].folderChildIDS).toEqual(['p/c2/cc']);
});
it('Should contain a valid protonPath for folders', () => {
const isLabelMapping = false;
const foldersMapping = getMappingTestHelper(
new MailImportFoldersParser(getApiFoldersTestHelper(paths), isLabelMapping).folders
);
expect(foldersMapping['p2/c/cc/ccc/cccc'].protonPath).toEqual(['p2', 'c', 'cc/ccc/cccc']);
});
it('Should contain a valid protonPath for labels', () => {
const isLabelMapping = true;
const foldersMapping = getMappingTestHelper(
new MailImportFoldersParser(getApiFoldersTestHelper(paths), isLabelMapping).folders
);
expect(foldersMapping['p2/c'].protonPath).toEqual(['p2-c']);
expect(foldersMapping['p2/c/cc/ccc/cccc'].protonPath).toEqual(['p2-c-cc-ccc-cccc']);
});
it('Should have a specific syntax when system folders have subfolders', () => {
const apiFolders = getApiFoldersTestHelper([
'Inbox',
'Inbox/c',
'Inbox/c/cc',
'Inbox/c/cc/ccc',
'Inbox/c/cc/ccc/cccc',
]);
const foldersMapping = getMappingTestHelper(new MailImportFoldersParser(apiFolders, false).folders);
expect(foldersMapping['Inbox/c'].protonPath).toEqual(['[Inbox]c']);
expect(foldersMapping['Inbox/c/cc'].protonPath).toEqual(['[Inbox]c', 'cc']);
expect(foldersMapping['Inbox/c/cc/ccc'].protonPath).toEqual(['[Inbox]c', 'cc', 'ccc']);
expect(foldersMapping['Inbox/c/cc/ccc/cccc'].protonPath).toEqual(['[Inbox]c', 'cc', 'ccc/cccc']);
const labelsMapping = getMappingTestHelper(new MailImportFoldersParser(apiFolders, true).folders);
expect(labelsMapping['Inbox/c'].protonPath).toEqual(['[Inbox]c']);
expect(labelsMapping['Inbox/c/cc'].protonPath).toEqual(['[Inbox]c-cc']);
});
it('Should tag systemfoldersChilds', () => {
const apiFolders = getApiFoldersTestHelper([
'Inbox',
'Inbox/c',
'Inbox/c/cc',
'Inbox/c/cc/ccc',
'dude',
'dude/c',
]);
const foldersMapping = getMappingTestHelper(new MailImportFoldersParser(apiFolders, false).folders);
expect(foldersMapping.Inbox.isSystemFolderChild).toBe(false);
expect(foldersMapping['Inbox/c'].isSystemFolderChild).toBe(true);
expect(foldersMapping['Inbox/c/cc'].isSystemFolderChild).toBe(true);
expect(foldersMapping['Inbox/c/cc/ccc'].isSystemFolderChild).toBe(true);
expect(foldersMapping.dude.isSystemFolderChild).toBe(false);
expect(foldersMapping['dude/c'].isSystemFolderChild).toBe(false);
});
it('Should reorder correctly', () => {
// Reorder when child before a parent
let apiFolders = getApiFoldersTestHelper(['p/c', 'p']);
let foldersMapping = new MailImportFoldersParser(apiFolders, false).folders;
expect(foldersMapping.map((f) => f.id)).toEqual(['p', 'p/c']);
// Reorders nothing when everything is correctly ordered
apiFolders = getApiFoldersTestHelper(paths);
foldersMapping = new MailImportFoldersParser(apiFolders, false).folders;
expect(foldersMapping.map((f) => f.id)).toEqual(paths);
// Reorders when system folders has child in wrong place
apiFolders = getApiFoldersTestHelper(['inbox', '1234', 'inbox/c']);
foldersMapping = new MailImportFoldersParser(apiFolders, false).folders;
expect(foldersMapping.map((f) => f.id)).toEqual(['inbox', 'inbox/c', '1234']);
// Reorders when system folders has child in wrong place
// Non system folders moves dowmside when above system folder
apiFolders = getApiFoldersTestHelper([
'inbox',
'drafts/c/cc',
'dude',
'drafts/c',
'drafts',
'inbox/c',
'inbox/c/cc',
'dude/child',
'adude',
]);
foldersMapping = new MailImportFoldersParser(apiFolders, false).folders;
expect(foldersMapping.map((f) => f.id)).toEqual([
'inbox',
'inbox/c',
'inbox/c/cc',
'drafts',
'drafts/c',
'drafts/c/cc',
'adude',
'dude',
'dude/child',
]);
});
it('Should ensure that a folder with no parents containing separator is a valid folder', () => {
const apiFolders = getApiFoldersTestHelper(['p/c/cc', 'parent', 'parent/child', 'marco', 'marco/marco']);
const foldersMapping = getMappingTestHelper(new MailImportFoldersParser(apiFolders, false).folders);
expect(foldersMapping['p/c/cc'].protonPath).toEqual(['p/c/cc']);
expect(foldersMapping['p/c/cc'].providerPath).toEqual(['p/c/cc']);
expect(foldersMapping['marco/marco'].providerPath).toEqual(['marco', 'marco']);
const labelsMapping = getMappingTestHelper(new MailImportFoldersParser(apiFolders, true).folders);
expect(labelsMapping['p/c/cc'].protonPath).toEqual(['p/c/cc']);
expect(labelsMapping['p/c/cc'].providerPath).toEqual(['p/c/cc']);
expect(labelsMapping['marco/marco'].providerPath).toEqual(['marco', 'marco']);
const apiFoldersA = getApiFoldersTestHelper(['p/c', 'parent', 'parent/child']);
const foldersMappingA = getMappingTestHelper(new MailImportFoldersParser(apiFoldersA, false).folders);
expect(foldersMappingA['p/c'].protonPath).toEqual(['p/c']);
expect(foldersMappingA['p/c'].providerPath).toEqual(['p/c']);
const labelsMappingA = getMappingTestHelper(new MailImportFoldersParser(apiFoldersA, true).folders);
expect(labelsMappingA['p/c'].protonPath).toEqual(['p/c']);
expect(labelsMappingA['p/c'].providerPath).toEqual(['p/c']);
const apiFoldersB = getApiFoldersTestHelper(['p', 'p/c', 'p/c/cc/ccc']);
const foldersMappingB = getMappingTestHelper(new MailImportFoldersParser(apiFoldersB, false).folders);
expect(foldersMappingB['p/c/cc/ccc'].protonPath).toEqual(['p', 'c/cc/ccc']);
expect(foldersMappingB['p/c/cc/ccc'].providerPath).toEqual(['p', 'c/cc/ccc']);
const apiFoldersC = getApiFoldersTestHelper(['p', 'p/c', 'p/c/cc', 'p/c/cc/ccc', 'p/c/cc/ccc/cccc/ccccc']);
const foldersMappingC = getMappingTestHelper(new MailImportFoldersParser(apiFoldersC, false).folders);
expect(foldersMappingC['p/c/cc/ccc/cccc/ccccc'].protonPath).toEqual(['p', 'c', 'cc/ccc/cccc/ccccc']);
expect(foldersMappingC['p/c/cc/ccc/cccc/ccccc'].providerPath).toEqual(['p', 'c', 'cc', 'ccc/cccc/ccccc']);
const labelsMappingC = getMappingTestHelper(new MailImportFoldersParser(apiFoldersC, true).folders);
expect(labelsMappingC['p/c/cc/ccc/cccc/ccccc'].providerPath).toEqual(['p', 'c', 'cc', 'ccc/cccc/ccccc']);
expect(labelsMappingC['p/c/cc/ccc/cccc/ccccc'].protonPath).toEqual(['p-c-cc-ccc/cccc/ccccc']);
});
});
});
| 4,951
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/helpers
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/helpers/MailImportFoldersParser/MailImportFoldersParser.ts
|
import cloneDeep from 'lodash/cloneDeep';
import { ApiMailImporterFolder } from '@proton/activation/src/api/api.interface';
import { MAX_FOLDERS_DEPTH } from '@proton/activation/src/constants';
import { MailImportDestinationFolder } from '@proton/activation/src/interface';
import { getRandomAccentColor } from '@proton/shared/lib/colors';
import isTruthy from '@proton/utils/isTruthy';
import move from '@proton/utils/move';
const DESTINATION_FOLDERS = Object.values(MailImportDestinationFolder);
/**
* MailImportFolder(s) are the result of provider folders parsing
*
* created by MailImportFoldersParser class
*/
export interface MailImportFolder {
/** Api folder source */
readonly id: ApiMailImporterFolder['Source'];
readonly category: ApiMailImporterFolder['DestinationCategory'];
checked: boolean;
readonly color: string;
readonly systemFolder: ApiMailImporterFolder['DestinationFolder'];
readonly isSystemFolderChild: boolean;
readonly folderChildIDS: ApiMailImporterFolder['Source'][];
readonly folderParentID: ApiMailImporterFolder['Source'] | undefined;
/**
* Path with the proton folders or labels parent/child depth restrictions
* - if folder id is 'p1/p2/p3/p4/p5' then proton path will be ['p1','p2','p3/p4/p5'].
* - if label id is 'p1/p2/p3/p4/p5' then proton path will be ['p1-p2-p3-p4-p5']
* - if folder has a parent destination folder 'Inbox/c/cc' proton path will be ['[Inbox]c', 'cc']
* - if label has a parent destination folder 'Inbox/c/cc' proton path will be ['[Inbox]c-cc']
*/
protonPath: string[];
/**
* Path without the proton folders or labels parent/child depth restrictions
*
* If folder or label id is 'p1/p2/p3/p4' then provider path will be the same
* as an array. ['p1','p2','p3','p4']
*/
readonly providerPath: string[];
readonly separator: ApiMailImporterFolder['Separator'];
readonly size: ApiMailImporterFolder['Size'];
}
/**
* Parse folders from provider
*
* @example
* ```
* const parser = new MailImportFoldersParser(apiFolders, isLabelMapping);
* const parsedFolders = parser.folders;
* ```
* @returns MailImportFoldersParser.folders - The parsed folders - MailImportFolder[]
*/
class MailImportFoldersParser {
private separatorSplitToken: string;
private providerFolders: ApiMailImporterFolder[];
private providerFoldersSources: ApiMailImporterFolder['Source'][];
public folders: MailImportFolder[];
constructor(apiFolders: ApiMailImporterFolder[], isLabelMapping: boolean) {
this.separatorSplitToken = `##**${Date.now()}**##`;
this.providerFoldersSources = apiFolders.map((folder) => folder.Source);
this.providerFolders = this.sortByDestinationFolder(cloneDeep(apiFolders));
this.folders = this.createFolders(isLabelMapping);
}
/**
* Sort folders order alphabetically
*
* Note about System folders
* - Parent system folders are not sorted alpha
* - System folders children are sorted alpha and moved under their parent system folder
*/
private sortByDestinationFolder = (apiFolders: ApiMailImporterFolder[]) => {
const sortedFolders = apiFolders.sort((a, b) => {
// Parent destination folders
if (a.DestinationFolder && b.DestinationFolder) {
return 0;
}
if (a.DestinationFolder) {
return -1;
}
if (b.DestinationFolder) {
return 1;
}
// Other folders
return a.Source.toLowerCase().localeCompare(b.Source.toLowerCase());
});
const systemFolderSourcesInList = sortedFolders.reduce<string[]>((acc, folder) => {
if (folder.DestinationFolder) {
acc.push(folder.Source);
}
return acc;
}, []);
let finalSort = sortedFolders;
systemFolderSourcesInList.forEach((systemFolderSource) => {
const systemFolderIndex = finalSort.findIndex((f) => f.Source === systemFolderSource);
const childSources = finalSort.reduce<string[]>((acc, folder) => {
const path = this.getProviderPath(folder.Source, folder.Separator);
if (path.length > 1 && path[0] === finalSort[systemFolderIndex].Source) {
acc.push(folder.Source);
}
return acc;
}, []);
childSources.forEach((childSource, index) => {
const from = finalSort.findIndex((f) => f.Source === childSource);
const to =
(index === 0
? systemFolderIndex
: finalSort.findIndex((f) => f.Source === childSources[index - 1])) + 1;
finalSort = move(finalSort, from, to);
});
});
return finalSort;
};
private getProviderPath = (folderSource: ApiMailImporterFolder['Source'] = '', separator = '/') => {
/**
* We determine a path based on the provided folder source and separator
* Example: 'p/c/cc' will become ['p', 'c', 'cc']
*/
let pathBasedOnSeparator = (() => {
if (separator !== '/') {
return folderSource.split(separator);
}
return folderSource
.split('\\/')
.join(this.separatorSplitToken)
.split('/')
.map((s) => s.split(this.separatorSplitToken).join('\\/'));
})();
/**
* We go through each chunk of the path and verify if there's a corresponding source in providerFolders
*
* Checks if a source like this 'p/c' has a parent with source 'p'.
* If yes path will be ['p','c']
* If not path will be ['p/c']
*/
const verifiedPath = (() => {
let isBroken: boolean;
const result = pathBasedOnSeparator.reduce<string[]>((acc, pathChunk, index) => {
const isFirstChunk = index === 0;
if (isFirstChunk) {
isBroken = false;
}
if (isBroken) {
const accWithoutLastChunk = acc.filter((_, accIndex) => acc.length - 1 !== accIndex);
const lastChunk = isFirstChunk ? pathChunk : acc[acc.length - 1] + separator + pathChunk;
return [...accWithoutLastChunk, lastChunk];
}
/**
* expectedParentSource value changes through each iterations
*
* If we discover that parent/child relationship is broken at any chunk
* we concatenate for every following chunks
*
* Example:
* - Given the following path ['p', 'c', 'cc', 'ccc'] with '/' separator
* - Value at iteration 1 will be 'p'
* - Value at iteration 2 will be 'p/c'
* - Value at iteration 3 will be 'p/c/cc'
* ...
*/
const expectedParentSource = isFirstChunk ? pathChunk : acc.join(separator) + separator + pathChunk;
if (this.providerFoldersSources.includes(expectedParentSource)) {
return [...acc, pathChunk];
} else {
isBroken = true;
const accWithoutLastChunk = acc.filter((_, accIndex) => acc.length - 1 !== accIndex);
const lastChunk = isFirstChunk ? pathChunk : acc[acc.length - 1] + separator + pathChunk;
return [...accWithoutLastChunk, lastChunk];
}
}, []);
return result;
})();
return verifiedPath;
};
private getProtonPath = (
folderSource: ApiMailImporterFolder['Source'] = '',
separator = '/',
isLabelMapping: boolean
) => {
let path = this.getProviderPath(folderSource, separator);
const parentSystemFolder =
path.length > 1 &&
DESTINATION_FOLDERS.find((destFolder) => destFolder.toLocaleLowerCase() === path[0].toLocaleLowerCase());
if (parentSystemFolder) {
const [first, second, ...third] = path;
path = [`[${first}]${second}`, ...third];
}
if (isLabelMapping) {
return [path.join('-')];
}
if (path.length <= MAX_FOLDERS_DEPTH) {
return path;
}
const [first, second, ...third] = path;
return [first, second, third.join(separator)];
};
private getFolderChildIds = (index: number): string[] => {
const folder = this.providerFolders[index];
/**
* Children are folder that starts with the same source and have a separator right at the end of the current folder
*
* For example the following folder:
* 'folder' is the parent of 'folder/sub folder' since 'folder/sub folder' starts with 'folder' and has '/' right after
*/
return this.providerFolders
.map((item) => {
if (
item.Source.startsWith(folder.Source) &&
item.Source.charAt(folder.Source.length) === folder.Separator
) {
return item;
}
})
.filter(isTruthy)
.map((item) => item.Source);
};
private getParentFolderId = (index: number): string | undefined => {
const folder = this.providerFolders[index];
/**
* Parents folders are folders that are one level above in the providerPath
* We must return the whole parent path and not just the parent id, this is why we do the slice
* It can either be undefined or a string
*/
const folderProviderPath = this.getProviderPath(folder.Source, folder.Separator);
return folderProviderPath.slice(0, folderProviderPath.length - 1).join(folder.Separator) || undefined;
};
private createFolders(isLabelMapping = false) {
let memoizedRootFolderColor: MailImportFolder['color'];
const result = this.providerFolders
.filter((folder) => !!folder.Source)
.map((folder, index) => {
const isRootFolder = this.getProviderPath(folder.Source, folder.Separator).length === 1;
if (isRootFolder) {
// Generate a random color
memoizedRootFolderColor = getRandomAccentColor();
}
const providerPath = this.getProviderPath(folder.Source, folder.Separator);
// System subfolders need to have root parent with a destination.
const isSystemFolderChild = this.providerFolders.some((item) => {
return item.Source === providerPath[0] && providerPath.length > 1 && item.DestinationFolder;
});
const parsedFolder = {
id: folder.Source,
providerPath,
category: folder.DestinationCategory,
checked: true, // By default we assume that every folders should be imported
color: memoizedRootFolderColor,
systemFolder: folder.DestinationFolder,
isSystemFolderChild: isSystemFolderChild,
folderChildIDS: this.getFolderChildIds(index),
folderParentID: this.getParentFolderId(index),
protonPath: this.getProtonPath(folder.Source, folder.Separator, isLabelMapping),
separator: folder.Separator,
size: folder.Size || 0,
};
return parsedFolder;
});
const sortedResults = new Set<MailImportFolder>();
result.forEach((item) => {
if (item.folderChildIDS.length > 0) {
sortedResults.add(item);
item.folderChildIDS.forEach((childId) => {
const child = result.find((item) => item.id.endsWith(childId));
if (child) {
sortedResults.add(child);
}
});
}
sortedResults.add(item);
});
return Array.from(sortedResults);
}
}
export default MailImportFoldersParser;
| 4,952
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/hooks/useAvailableAddresses.test.ts
|
import { renderHook } from '@testing-library/react-hooks';
import { useAddresses } from '@proton/components/index';
import { ADDRESS_TYPE } from '@proton/shared/lib/constants';
import { generateMockAddress, generateMockAddressArray } from '../tests/data/addresses';
import useAvailableAddresses from './useAvailableAddresses';
jest.mock('@proton/components/hooks/useAddresses');
const mockUseAddresses = useAddresses as jest.MockedFunction<any>;
describe('useAvailableAddresses', () => {
it('Should return empty addresses', () => {
mockUseAddresses.mockReturnValue([[], false]);
const { result } = renderHook(() => useAvailableAddresses());
expect(result.current).toStrictEqual({ availableAddresses: [], defaultAddress: undefined, loading: false });
});
it('Should return available addresses with active keys', () => {
const activeAddresses = generateMockAddressArray(2, true);
const disabledAddress = generateMockAddress(3, false);
mockUseAddresses.mockReturnValue([[...activeAddresses, disabledAddress], false]);
const { result } = renderHook(() => useAvailableAddresses());
expect(result.current.availableAddresses).toHaveLength(2);
expect(result.current).toStrictEqual({
availableAddresses: activeAddresses,
defaultAddress: activeAddresses[0],
loading: false,
});
});
it('Should return available addresses and filter external addresses', () => {
const activeAddresses = generateMockAddressArray(2, true);
const externalAddress = generateMockAddress(3, true, ADDRESS_TYPE.TYPE_EXTERNAL);
mockUseAddresses.mockReturnValue([[...activeAddresses, externalAddress], false]);
const { result } = renderHook(() => useAvailableAddresses());
expect(result.current.availableAddresses).toHaveLength(2);
expect(result.current).toStrictEqual({
availableAddresses: activeAddresses,
defaultAddress: activeAddresses[0],
loading: false,
});
});
});
| 4,953
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/hooks/useAvailableAddresses.ts
|
import { useAddresses } from '@proton/components/hooks';
import { ADDRESS_STATUS, ADDRESS_TYPE } from '@proton/shared/lib/constants';
const useAvailableAddresses = () => {
const [addresses, loading] = useAddresses();
const availableAddresses = addresses.filter(
(addr) =>
addr.Receive &&
addr.Send &&
addr.Keys.some((k) => k.Active) &&
addr.Status === ADDRESS_STATUS.STATUS_ENABLED &&
addr.Type !== ADDRESS_TYPE.TYPE_EXTERNAL
);
return {
availableAddresses,
defaultAddress: availableAddresses[0],
loading,
};
};
export default useAvailableAddresses;
| 4,954
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/hooks/useOAuthPopup.helpers.test.ts
|
import { getScopeFromProvider } from '../components/Modals/OAuth/StepProducts/useStepProducts.helpers';
import { ImportProvider, ImportType, OAUTH_PROVIDER } from '../interface';
import { getOAuthAuthorizationUrl, getOAuthRedirectURL, getProviderNumber } from './useOAuthPopup.helpers';
describe('OAuth url generation', () => {
it('Should throw an error when unsupported provider (getProviderNumber)', () => {
expect(() => getProviderNumber(ImportProvider.DEFAULT)).toThrowError('Provider does not exist');
});
it('Should throw an error when unsupported provider (getOAuthRedirectURL)', () => {
expect(() => getOAuthRedirectURL(ImportProvider.DEFAULT)).toThrowError('Provider does not exist');
});
it('Should throw an error when unsupported provider (getOAuthAuthorizationUrl)', () => {
const config = {
'importer.google.client_id': 'string',
'importer.outlook.client_id': 'string',
};
expect(() => getOAuthAuthorizationUrl({ provider: ImportProvider.DEFAULT, scope: '', config })).toThrowError(
'Provider does not exist'
);
});
it('Should return appropriate number for each supported providers', () => {
const googleNumber = getProviderNumber(ImportProvider.GOOGLE);
expect(googleNumber).toStrictEqual(OAUTH_PROVIDER.GOOGLE);
const outlookNumber = getProviderNumber(ImportProvider.OUTLOOK);
expect(outlookNumber).toStrictEqual(OAUTH_PROVIDER.OUTLOOK);
});
it('Should return appropriate Google redirect URL', () => {
Object.defineProperty(window, 'location', {
configurable: true,
enumerable: true,
value: new URL(window.location.href),
});
const expectedUrl = 'https://www.protontesting.com/mypath';
window.location.href = expectedUrl;
const redirectUrl = getOAuthRedirectURL(ImportProvider.GOOGLE);
expect(redirectUrl).toStrictEqual('https://www.protontesting.com/oauth/callback');
});
it('Should return appropriate Outlook redirect URL', () => {
Object.defineProperty(window, 'location', {
configurable: true,
enumerable: true,
value: new URL(window.location.href),
});
const expectedUrl = 'https://www.protontesting.com/mypath';
window.location.href = expectedUrl;
const redirectUrl = getOAuthRedirectURL(ImportProvider.OUTLOOK);
expect(redirectUrl).toStrictEqual('https://www.protontesting.com/oauth/callback');
});
it('Should return appropriate Outlook OAuth URL', () => {
const provider = ImportProvider.OUTLOOK;
const scopesMail = getScopeFromProvider(provider, [ImportType.MAIL]);
const config = {
'importer.google.client_id': 'string',
'importer.outlook.client_id': 'string',
};
const outlookMailsRedirect = getOAuthAuthorizationUrl({ provider, scope: scopesMail.join(' '), config });
expect(outlookMailsRedirect).toStrictEqual(
'https://login.microsoftonline.com/common/oauth2/v2.0/authorize?redirect_uri=https%3A%2F%2Fwww.protontesting.com%2Foauth%2Fcallback&response_type=code&scope=email+openid+User.Read+offline_access+Mail.read&prompt=consent&client_id=string'
);
const scopesContact = getScopeFromProvider(provider, [ImportType.CONTACTS]);
const outlookContactsRedirect = getOAuthAuthorizationUrl({ provider, scope: scopesContact.join(' '), config });
expect(outlookContactsRedirect).toStrictEqual(
'https://login.microsoftonline.com/common/oauth2/v2.0/authorize?redirect_uri=https%3A%2F%2Fwww.protontesting.com%2Foauth%2Fcallback&response_type=code&scope=email+openid+User.Read+offline_access+Contacts.read&prompt=consent&client_id=string'
);
const outlookHintRedirect = getOAuthAuthorizationUrl({
provider,
scope: scopesContact.join(' '),
config,
loginHint: 'login hint',
});
expect(outlookHintRedirect).toStrictEqual(
'https://login.microsoftonline.com/common/oauth2/v2.0/authorize?redirect_uri=https%3A%2F%2Fwww.protontesting.com%2Foauth%2Fcallback&response_type=code&scope=email+openid+User.Read+offline_access+Contacts.read&prompt=consent&client_id=string'
);
const scopesCalendars = getScopeFromProvider(provider, [ImportType.CALENDAR]);
const outlookCalendarsRedirect = getOAuthAuthorizationUrl({
provider,
scope: scopesCalendars.join(' '),
config,
});
expect(outlookCalendarsRedirect).toStrictEqual(
'https://login.microsoftonline.com/common/oauth2/v2.0/authorize?redirect_uri=https%3A%2F%2Fwww.protontesting.com%2Foauth%2Fcallback&response_type=code&scope=email+openid+User.Read+offline_access+Calendars.read&prompt=consent&client_id=string'
);
const scopesAll = getScopeFromProvider(provider, [ImportType.CALENDAR, ImportType.CONTACTS, ImportType.MAIL]);
const outlookAllScopes = getOAuthAuthorizationUrl({
provider,
scope: scopesAll.join(' '),
config,
});
expect(outlookAllScopes).toStrictEqual(
'https://login.microsoftonline.com/common/oauth2/v2.0/authorize?redirect_uri=https%3A%2F%2Fwww.protontesting.com%2Foauth%2Fcallback&response_type=code&scope=email+openid+User.Read+offline_access+Mail.read+Calendars.read+Contacts.read&prompt=consent&client_id=string'
);
});
it('Should return appropriate Google OAuth URL', () => {
const provider = ImportProvider.GOOGLE;
const scopesMail = getScopeFromProvider(provider, [ImportType.MAIL]);
const config = {
'importer.google.client_id': 'string',
'importer.outlook.client_id': 'string',
};
const googleMailsRedirect = getOAuthAuthorizationUrl({ provider, scope: scopesMail.join(' '), config });
expect(googleMailsRedirect).toStrictEqual(
'https://accounts.google.com/o/oauth2/v2/auth?redirect_uri=https%3A%2F%2Fwww.protontesting.com%2Foauth%2Fcallback&response_type=code&scope=email+openid+https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fgmail.readonly&prompt=consent&access_type=offline&client_id=string'
);
const scopesContact = getScopeFromProvider(provider, [ImportType.CONTACTS]);
const googleContactsRedirect = getOAuthAuthorizationUrl({
provider,
scope: scopesContact.join(' '),
config,
});
expect(googleContactsRedirect).toStrictEqual(
'https://accounts.google.com/o/oauth2/v2/auth?redirect_uri=https%3A%2F%2Fwww.protontesting.com%2Foauth%2Fcallback&response_type=code&scope=email+openid+https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fcontacts.readonly&prompt=consent&access_type=offline&client_id=string'
);
const googleHintRedirect = getOAuthAuthorizationUrl({
provider,
scope: scopesContact.join(' '),
config,
loginHint: 'login hint',
});
expect(googleHintRedirect).toStrictEqual(
'https://accounts.google.com/o/oauth2/v2/auth?redirect_uri=https%3A%2F%2Fwww.protontesting.com%2Foauth%2Fcallback&response_type=code&scope=email+openid+https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fcontacts.readonly&prompt=consent&access_type=offline&client_id=string&login_hint=login+hint'
);
const scopesCalendars = getScopeFromProvider(provider, [ImportType.CALENDAR]);
const googleCalendarsRedirect = getOAuthAuthorizationUrl({
provider,
scope: scopesCalendars.join(' '),
config,
});
expect(googleCalendarsRedirect).toStrictEqual(
'https://accounts.google.com/o/oauth2/v2/auth?redirect_uri=https%3A%2F%2Fwww.protontesting.com%2Foauth%2Fcallback&response_type=code&scope=email+openid+https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fcalendar.readonly&prompt=consent&access_type=offline&client_id=string'
);
const scopesAll = getScopeFromProvider(provider, [ImportType.CALENDAR, ImportType.CONTACTS, ImportType.MAIL]);
const googleAllScopes = getOAuthAuthorizationUrl({
provider,
scope: scopesAll.join(' '),
config,
});
expect(googleAllScopes).toStrictEqual(
'https://accounts.google.com/o/oauth2/v2/auth?redirect_uri=https%3A%2F%2Fwww.protontesting.com%2Foauth%2Fcallback&response_type=code&scope=email+openid+https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fgmail.readonly+https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fcalendar.readonly+https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fcontacts.readonly&prompt=consent&access_type=offline&client_id=string'
);
});
});
| 4,955
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/hooks/useOAuthPopup.helpers.ts
|
import { ApiEnvironmentConfig } from '@proton/shared/lib/interfaces';
import { G_OAUTH_REDIRECT_PATH, O_OAUTH_REDIRECT_PATH } from '../constants';
import { ImportProvider, OAUTH_PROVIDER } from '../interface';
const generateGoogleOAuthUrl = (params: URLSearchParams, config: ApiEnvironmentConfig, loginHint?: string) => {
params.append('access_type', 'offline');
params.append('client_id', config['importer.google.client_id']);
if (loginHint) {
params.append('login_hint', loginHint);
}
return `https://accounts.google.com/o/oauth2/v2/auth?${params.toString()}`;
};
const generateOutlookOAuthUrl = (params: URLSearchParams, config: ApiEnvironmentConfig) => {
params.append('client_id', config['importer.outlook.client_id']);
return `https://login.microsoftonline.com/common/oauth2/v2.0/authorize?${params.toString()}`;
};
export const getOAuthRedirectURL = (provider: ImportProvider) => {
const { protocol, host } = window.location;
if (provider === ImportProvider.GOOGLE) {
return `${protocol}//${host}${G_OAUTH_REDIRECT_PATH}`;
}
if (provider === ImportProvider.OUTLOOK) {
return `${protocol}//${host}${O_OAUTH_REDIRECT_PATH}`;
}
throw new Error('Provider does not exist');
};
export const getOAuthAuthorizationUrl = ({
provider,
scope,
config,
loginHint,
}: {
provider: ImportProvider;
scope: string;
config: ApiEnvironmentConfig;
loginHint?: string;
}) => {
const params = new URLSearchParams();
params.append('redirect_uri', getOAuthRedirectURL(provider));
params.append('response_type', 'code');
params.append('scope', scope);
// force user to consent again so that we can always get a refresh token
params.append('prompt', 'consent');
if (provider === ImportProvider.GOOGLE) {
return generateGoogleOAuthUrl(params, config, loginHint);
}
if (provider === ImportProvider.OUTLOOK) {
return generateOutlookOAuthUrl(params, config);
}
throw new Error('Provider does not exist');
};
export const getProviderNumber = (provider: ImportProvider) => {
if ([ImportProvider.GOOGLE, ImportProvider.OUTLOOK].includes(provider)) {
return provider === ImportProvider.GOOGLE ? OAUTH_PROVIDER.GOOGLE : OAUTH_PROVIDER.OUTLOOK;
}
throw new Error('Provider does not exist');
};
| 4,956
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/hooks/useOAuthPopup.tsx
|
import { useRef } from 'react';
import { c } from 'ttag';
import { ImportProvider } from '@proton/activation/src/interface';
import useApiEnvironmentConfig from '@proton/components/hooks/useApiEnvironmentConfig';
import useNotifications from '@proton/components/hooks/useNotifications';
import { generateProtonWebUID } from '@proton/shared/lib/helpers/uid';
import { getOAuthAuthorizationUrl, getOAuthRedirectURL, getProviderNumber } from './useOAuthPopup.helpers';
const WINDOW_WIDTH = 500;
const WINDOW_HEIGHT = 600;
const POLLING_INTERVAL = 100;
const CreateAuthCancelledError = (errorMessage: string) => {
const { createNotification } = useNotifications();
createNotification({
text: (
<div className="text-center">
{c('Error').t`Authentication canceled.`}
<br />
{errorMessage}
</div>
),
type: 'error',
});
};
const CreateAuthError = (errorMessage: string) => {
const { createNotification } = useNotifications();
createNotification({
text: (
<div className="text-center">
{c('Error').t`Authentication error.`}
<br />
{errorMessage}
</div>
),
type: 'error',
});
};
interface Props {
errorMessage: string;
}
const useOAuthPopup = ({ errorMessage }: Props) => {
const [config, loadingConfig] = useApiEnvironmentConfig();
const stateId = useRef<string>();
const triggerOAuthPopup = ({
provider,
scope,
loginHint,
callback,
}: {
provider: ImportProvider;
scope: string;
loginHint?: string;
// TODO properly type this
callback: (oauthProps: any) => void | Promise<void>;
}) => {
let interval: number;
const authorizationUrl = getOAuthAuthorizationUrl({ provider, scope, config, loginHint });
const RedirectUri = getOAuthRedirectURL(provider);
const uid = generateProtonWebUID();
stateId.current = uid;
const authWindow = window.open(
`${authorizationUrl}&state=${uid}`,
'oauthPopup',
`height=${WINDOW_HEIGHT},width=${WINDOW_WIDTH},top=${window.screen.height / 2 - WINDOW_HEIGHT / 2},left=${
window.screen.width / 2 - WINDOW_WIDTH / 2
}`
);
if (authWindow) {
authWindow.focus();
/*
To be changed by a proper callback URL that will
communicate with this component via `window.postMessage()`
We can then move the following logic to a `onmessage` listener
*/
interval = window.setInterval(() => {
if (authWindow.closed) {
window.clearInterval(interval);
return;
}
try {
const url = new URL(authWindow.document.URL);
const params = new URLSearchParams(url.search);
if (authWindow.document.URL.startsWith(RedirectUri)) {
authWindow.close();
const error = params.get('error');
if (error) {
return CreateAuthCancelledError(errorMessage);
}
const state = params.get('state');
// State passthrough mismatch error
if (state !== stateId.current) {
return CreateAuthError(errorMessage);
}
const Code = params.get('code');
if (!Code) {
return;
}
const providerNum = getProviderNumber(provider);
void callback({ Code, Provider: providerNum, RedirectUri });
}
} catch (err: any) {
// silent error
}
}, POLLING_INTERVAL);
}
};
return { triggerOAuthPopup, loadingConfig };
};
export default useOAuthPopup;
| 4,957
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/StoreProvider.tsx
|
import { Provider } from 'react-redux';
import { ApiEvent } from '@proton/activation/src/api/api.interface';
import { useSubscribeEventManager } from '@proton/components/hooks';
import MainModal from '../components/Modals/MainModal';
import { event } from './actions';
import { useEasySwitchDispatch, useGenerateEasySwitchStore } from './store';
interface Props {
children: JSX.Element | (JSX.Element | null)[] | null;
}
const EasySwitchEventListener = ({ children }: Props) => {
const dispatch = useEasySwitchDispatch();
useSubscribeEventManager((apiEvent: ApiEvent) => {
dispatch(event(apiEvent));
});
return <>{children}</>;
};
const EasySwitchStoreProvider = ({ children }: Props) => {
const easySwitchStore = useGenerateEasySwitchStore();
return (
<Provider store={easySwitchStore}>
<EasySwitchEventListener>{children}</EasySwitchEventListener>
<MainModal />
</Provider>
);
};
export default EasySwitchStoreProvider;
| 4,958
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/actions.ts
|
import { createAction, createAsyncThunk } from '@reduxjs/toolkit';
import { ApiEvent } from '@proton/activation/src/api/api.interface';
import { loadImporters } from './importers/importers.actions';
import { loadReports } from './reports/reports.actions';
import { EasySwitchThunkExtra } from './store';
import { loadSyncList } from './sync/sync.actions';
export const event = createAction<ApiEvent>('event');
export const loadDashboard = createAsyncThunk<void, undefined, EasySwitchThunkExtra>(
'dashboard/load',
async (_, thunkApi) => {
await Promise.all([
thunkApi.dispatch(loadSyncList()),
thunkApi.dispatch(loadReports()),
thunkApi.dispatch(loadImporters()),
]);
}
);
| 4,959
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/store.ts
|
import { useMemo } from 'react';
import { TypedUseSelectorHook, useDispatch, useSelector } from 'react-redux';
import { configureStore } from '@reduxjs/toolkit';
import { useApi, useEventManager, useNotifications } from '@proton/components';
import { NotificationsManager } from '@proton/components/containers/notifications/manager';
import { EventManager } from '@proton/shared/lib/eventManager/eventManager';
import { Api } from '@proton/shared/lib/interfaces';
import imapDraft from './draft/imapDraft/imapDraft.slice';
import oauthDraft from './draft/oauthDraft/oauthDraft.slice';
import importers from './importers/importers.slice';
import reports from './reports/reports.slice';
import sync from './sync/sync.slice';
export const useGenerateEasySwitchStore = () => {
const api = useApi();
const notificationManager = useNotifications();
const eventManager = useEventManager();
const store = useMemo(() => {
return configureStore({
reducer: { reports, importers, sync, oauthDraft, imapDraft },
middleware: (getDefaultMiddleware) =>
getDefaultMiddleware({
thunk: { extraArgument: { api, notificationManager, eventManager } },
}),
});
}, []);
return store;
};
export type EasySwitchState = ReturnType<ReturnType<typeof useGenerateEasySwitchStore>['getState']>;
export type EasySwitchDispatch = ReturnType<typeof useGenerateEasySwitchStore>['dispatch'];
export type EasySwitchThunkExtra = {
state: EasySwitchState;
dispatch: EasySwitchDispatch;
extra: { api: Api; notificationManager: NotificationsManager; eventManager: EventManager };
};
export const useEasySwitchDispatch: () => EasySwitchDispatch = useDispatch;
export const useEasySwitchSelector: TypedUseSelectorHook<EasySwitchState> = useSelector;
| 4,960
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/draft/draft.selector.test.ts
|
import { ImportType } from '@proton/activation/src/interface';
import { ImportProvider } from '@proton/activation/src/interface';
import { EasySwitchState } from '../store';
import { selectDraftModal } from './draft.selector';
const BASE_STATE: Omit<EasySwitchState, 'oauthDraft' | 'imapDraft'> = {
importers: { importers: {}, activeImporters: {}, loading: 'idle' },
reports: { reports: {}, summaries: {}, loading: 'idle' },
sync: { syncs: {}, listLoading: 'idle', creatingLoading: 'idle' },
};
describe('EasySwitch draft selectors', () => {
describe('SelectDraftModal', () => {
it('Should return null when idle', () => {
const state: EasySwitchState = {
...BASE_STATE,
oauthDraft: {
step: 'idle',
},
imapDraft: {
step: 'idle',
},
};
expect(selectDraftModal(state)).toEqual(null);
});
it('Should return null if imap and oauth started', () => {
const state: EasySwitchState = {
...BASE_STATE,
oauthDraft: {
step: 'started',
},
imapDraft: {
step: 'started',
},
};
expect(selectDraftModal(state)).toEqual(null);
});
it('Should return "select-product" when start', () => {
const state: EasySwitchState = {
...BASE_STATE,
oauthDraft: {
step: 'idle',
},
imapDraft: {
step: 'started',
provider: ImportProvider.DEFAULT,
hasReadInstructions: false,
},
};
expect(selectDraftModal(state)).toEqual('select-product');
});
it('Should return "select-product" when start', () => {
const state: EasySwitchState = {
...BASE_STATE,
oauthDraft: {
step: 'idle',
},
imapDraft: {
step: 'started',
provider: ImportProvider.DEFAULT,
product: ImportType.MAIL,
hasReadInstructions: false,
},
};
expect(selectDraftModal(state)).toEqual('read-instructions');
});
it('Should return "import-{type}" when start import email', () => {
const state: EasySwitchState = {
...BASE_STATE,
oauthDraft: {
step: 'idle',
},
imapDraft: {
step: 'started',
provider: ImportProvider.DEFAULT,
product: ImportType.MAIL,
hasReadInstructions: true,
},
};
expect(selectDraftModal(state)).toEqual('import-Mail');
const state2: EasySwitchState = {
...BASE_STATE,
oauthDraft: {
step: 'idle',
},
imapDraft: {
step: 'started',
provider: ImportProvider.DEFAULT,
product: ImportType.CALENDAR,
hasReadInstructions: true,
},
};
expect(selectDraftModal(state2)).toEqual('import-Calendar');
const state3: EasySwitchState = {
...BASE_STATE,
oauthDraft: {
step: 'idle',
},
imapDraft: {
step: 'started',
provider: ImportProvider.DEFAULT,
product: ImportType.CONTACTS,
hasReadInstructions: true,
},
};
expect(selectDraftModal(state3)).toEqual('import-Contacts');
});
it('Should return "oauth" when selecting OAuth import', () => {
const state: EasySwitchState = {
...BASE_STATE,
oauthDraft: {
step: 'started',
mailImport: {
products: [ImportType.MAIL, ImportType.CALENDAR],
},
provider: ImportProvider.GOOGLE,
},
imapDraft: {
step: 'idle',
},
};
expect(selectDraftModal(state)).toEqual('oauth');
});
});
});
| 4,961
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/draft/draft.selector.ts
|
import { createSelector } from '@reduxjs/toolkit';
import { ImportType } from '@proton/activation/src/interface';
import { EasySwitchState } from '../store';
const selectImapDraft = (state: EasySwitchState) => state.imapDraft;
const selectOauthDraft = (state: EasySwitchState) => state.oauthDraft;
export const selectImapDraftProduct = createSelector(selectImapDraft, (draft) => draft.product);
type DraftModal = 'select-product' | `import-${ImportType}` | 'read-instructions' | 'oauth' | null;
export const selectDraftModal = createSelector(
selectImapDraft,
selectOauthDraft,
(imapDraft, oauthDraft): DraftModal => {
/**
* We don't display modal if:
* - both imap and oauth draft steps are idle,
* - both imap and oauth draft steps are started (not idle)
*/
if (
(imapDraft.step === 'idle' && oauthDraft.step === 'idle') ||
(imapDraft.step !== 'idle' && oauthDraft.step !== 'idle')
) {
return null;
}
/**
* We consider a draft as started if it's not idle.
*/
if (imapDraft.step !== 'idle') {
if (!imapDraft.product) {
return 'select-product';
}
if (!imapDraft.hasReadInstructions) {
return 'read-instructions';
}
if (imapDraft.product) {
return `import-${imapDraft.product}`;
}
}
/**
* We consider a draft as started if it's not idle.
*/
if (oauthDraft.step !== 'idle') {
return 'oauth';
}
return null;
}
);
| 4,962
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/draft
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/draft/imapDraft/imapDraft.actions.ts
|
import { createAction, createAsyncThunk } from '@reduxjs/toolkit';
import { createImport, getImport, getMailImportData, resumeImport, startImportTask } from '@proton/activation/src/api';
import {
ApiCreateImporterResponse,
ApiImportResponse,
ApiImporterImportResponse,
ApiStartImportParams,
ApiStartImportResponse,
} from '@proton/activation/src/api/api.interface';
import { MailImportFields } from '@proton/activation/src/components/Modals/CustomizeMailImportModal/CustomizeMailImportModal.interface';
import { IMAPS } from '@proton/activation/src/constants';
import MailImportFoldersParser, {
MailImportFolder,
} from '@proton/activation/src/helpers/MailImportFoldersParser/MailImportFoldersParser';
import { AuthenticationMethod, ImportType, OAUTH_PROVIDER } from '@proton/activation/src/interface';
import { ImportProvider } from '@proton/activation/src/interface';
import { ApiResponse } from '@proton/shared/lib/interfaces';
import { EasySwitchThunkExtra } from '../../store';
import { MailImportState } from './imapDraft.interface';
const ACTION_PREFIX = 'draft/imap';
export const resetImapDraft = createAction(`${ACTION_PREFIX}/reset`);
export const startImapDraft = createAction<{ provider: ImportProvider }>(`${ACTION_PREFIX}/start`);
export const selectImapProduct = createAction<{ product: ImportType }>(`${ACTION_PREFIX}/selectProduct`);
export const readImapInstructions = createAction(`${ACTION_PREFIX}/readInstructions`);
export const initImapMailImport = createAction(`${ACTION_PREFIX}/initMailImport`);
type ImportFormValues = Required<Pick<MailImportState, 'domain' | 'email' | 'password' | 'port'>>;
type Response = {
importerID: string;
sasl: AuthenticationMethod;
foldersMapping: MailImportFolder[];
} & ImportFormValues;
type SubmitError = { Code: number; Error: string };
export const submitImapMailCredentials = createAsyncThunk<
Response,
ImportFormValues & { allowSelfSigned: boolean },
EasySwitchThunkExtra & {
rejectValue: SubmitError;
}
>(`${ACTION_PREFIX}/submitCredentials`, async (formValues, thunkApi) => {
try {
const sasl = AuthenticationMethod.PLAIN;
const { email, domain, port, password, allowSelfSigned } = formValues;
const { ImporterID } = await thunkApi.extra.api<ApiCreateImporterResponse>({
...createImport({
[ImportType.MAIL]: {
Account: email,
ImapHost: domain,
ImapPort: parseInt(port, 10),
Sasl: sasl,
Code: password,
AllowSelfSigned: allowSelfSigned ? 1 : 0,
},
}),
/*
* For this call we display a custom error message on top of the form
* and want to prevent the growler display
*/
silence: true,
});
const { Folders = [] } = await thunkApi.extra.api<ApiImporterImportResponse>(
getMailImportData(ImporterID, { Code: formValues.password })
);
const isLabelMapping = domain === IMAPS[OAUTH_PROVIDER.GOOGLE];
const result: Response = {
importerID: ImporterID,
domain,
email,
foldersMapping: new MailImportFoldersParser(Folders, isLabelMapping).folders,
password,
port,
sasl,
};
return result;
} catch (error: any) {
return thunkApi.rejectWithValue(error.data as SubmitError);
}
});
export const saveImapMailFields = createAction<MailImportFields>(`${ACTION_PREFIX}/saveFields`);
export const startImapMailImport = createAsyncThunk<ApiStartImportResponse, ApiStartImportParams, EasySwitchThunkExtra>(
`${ACTION_PREFIX}/startImport`,
async (params, thunkApi) => {
const result = await thunkApi.extra.api(startImportTask(params));
await thunkApi.extra.eventManager.call();
return result;
}
);
export const reconnectImapImport = createAsyncThunk<ApiImportResponse['Importer'], string, EasySwitchThunkExtra>(
`${ACTION_PREFIX}/reconnect`,
async (importID, thunkApi) => {
const apiImporterResponse = await thunkApi.extra.api<ApiImportResponse>(getImport(importID));
return apiImporterResponse.Importer;
}
);
export const resumeImapImport = createAsyncThunk<
void,
{
importID: string;
product: ImportType;
},
EasySwitchThunkExtra
>(`${ACTION_PREFIX}/resumeImport`, async ({ importID, product }, thunkApi) => {
await thunkApi.extra.api<ApiResponse>(
resumeImport({
ImporterID: importID,
Products: [product],
})
);
await thunkApi.extra.eventManager.call();
});
export const displayConfirmLeaveModal = createAction<boolean>(`${ACTION_PREFIX}/displayConfirmLeaveModal`);
| 4,963
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/draft
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/draft/imapDraft/imapDraft.interface.ts
|
import { MailImportFields } from '@proton/activation/src/components/Modals/CustomizeMailImportModal/CustomizeMailImportModal.interface';
import { StepFormState } from '@proton/activation/src/components/Modals/Imap/ImapMailModal/StepForm/hooks/useStepForm.interface';
import { MailImportFolder } from '@proton/activation/src/helpers/MailImportFoldersParser/MailImportFoldersParser';
import { AuthenticationMethod, ImportType } from '@proton/activation/src/interface';
import { ImportProvider } from '@proton/activation/src/interface';
export type MailImportState = {
step: 'form' | 'reconnect-form' | 'prepare-import' | 'importing';
loading?: boolean;
apiErrorCode?: number;
apiErrorLabel?: string;
apiImporterID?: string;
apiSasl?: AuthenticationMethod;
domain?: StepFormState['imap'];
email?: StepFormState['emailAddress'];
fields?: MailImportFields;
password?: StepFormState['password'];
port?: StepFormState['port'];
foldersMapping?: MailImportFolder[];
};
export type ImapDraftState = {
step: 'idle' | 'started';
provider?: ImportProvider;
product?: ImportType;
/** User can be asked to read an instructions modal */
hasReadInstructions?: boolean;
mailImport?: MailImportState;
displayConfirmLeaveModal?: boolean;
};
| 4,964
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/draft
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/draft/imapDraft/imapDraft.selector.ts
|
import { createSelector } from '@reduxjs/toolkit';
import { EasySwitchState } from '../../store';
const selectImapDraft = (state: EasySwitchState) => state.imapDraft;
export const selectImapDraftStep = createSelector(selectImapDraft, (draft) => draft.step);
export const selectImapDraftProvider = createSelector(selectImapDraft, (draft) => draft.provider);
export const selectImapDraftProduct = createSelector(selectImapDraft, (draft) => draft.product);
export const selectImapDraftMailImport = createSelector(selectImapDraft, (draft) => draft.mailImport);
export const selectImapDraftMailConfirmModalDisplay = createSelector(
selectImapDraft,
(draft) => draft.displayConfirmLeaveModal
);
export const selectImapDraftMailImportStep = createSelector(
selectImapDraftMailImport,
(mailImport) => mailImport?.step
);
export const selectImapDraftMailImportApiError = createSelector(selectImapDraftMailImport, (mailImport) => {
if (mailImport?.step !== 'form') {
return undefined;
}
return {
code: mailImport?.apiErrorCode,
message: mailImport?.apiErrorLabel,
};
});
export const selectImapDraftMailImportApiErrorCode = createSelector(
selectImapDraftMailImportApiError,
(apiError) => apiError?.code
);
| 4,965
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/draft
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/draft/imapDraft/imapDraft.slice.ts
|
import { Action, Draft, createSlice } from '@reduxjs/toolkit';
import { ImportType } from '@proton/activation/src/interface';
import { ImportProvider } from '@proton/activation/src/interface';
import { RequireSome } from '@proton/shared/lib/interfaces';
import * as actions from './imapDraft.actions';
import { ImapDraftState } from './imapDraft.interface';
const initialState: ImapDraftState = { step: 'idle' };
const mailImportIsDefined = (
state: ImapDraftState,
action: Action
): state is RequireSome<ImapDraftState, 'mailImport'> => {
if (state.mailImport === undefined) {
throw new Error(`Reducer for ${action.type} should not be called if 'mailImport' is not defined`);
}
return state.mailImport !== undefined;
};
const resetState = (state: Draft<ImapDraftState>) => {
state.step = 'idle';
delete state.provider;
delete state.product;
delete state.hasReadInstructions;
delete state.mailImport;
delete state.displayConfirmLeaveModal;
};
const imapDraftSlice = createSlice({
name: 'imapDraft',
initialState,
reducers: {},
extraReducers: (builder) => {
builder.addCase(actions.resetImapDraft, resetState);
builder.addCase(actions.startImapDraft, (state, action) => {
state.step = 'started';
state.provider = action.payload.provider;
state.hasReadInstructions = false;
});
builder.addCase(actions.selectImapProduct, (state, action) => {
state.product = action.payload.product;
});
builder.addCase(actions.readImapInstructions, (state) => {
state.hasReadInstructions = true;
});
builder.addCase(actions.initImapMailImport, (state) => {
state.mailImport = {
step: 'form',
};
});
/**
* Reconnect IMAP import thunk
*/
builder.addCase(actions.reconnectImapImport.fulfilled, (state, action) => {
state.step = 'started';
state.provider = ImportProvider.DEFAULT;
state.product = ImportType.MAIL;
state.hasReadInstructions = true;
state.mailImport = {
step: 'reconnect-form',
apiImporterID: action.payload.ID,
apiSasl: action.payload.Sasl,
domain: action.payload.ImapHost,
email: action.payload.Account,
port: action.payload.ImapPort,
loading: false,
};
});
/**
* Submit IMAP credentials thunk
*/
builder.addCase(actions.submitImapMailCredentials.pending, (state) => {
if (mailImportIsDefined(state, actions.submitImapMailCredentials.pending)) {
state.mailImport.loading = true;
}
});
builder.addCase(actions.submitImapMailCredentials.fulfilled, (state, action) => {
if (mailImportIsDefined(state, actions.submitImapMailCredentials.pending)) {
const { email, port, domain, foldersMapping, importerID, sasl, password } = action.payload;
state.mailImport.step = 'prepare-import';
state.mailImport.loading = false;
state.mailImport.apiImporterID = importerID;
state.mailImport.apiSasl = sasl;
state.mailImport.domain = domain;
state.mailImport.email = email;
state.mailImport.foldersMapping = foldersMapping;
state.mailImport.password = password;
state.mailImport.port = port;
}
});
builder.addCase(actions.submitImapMailCredentials.rejected, (state, action) => {
if (mailImportIsDefined(state, actions.submitImapMailCredentials.pending)) {
state.mailImport.step = 'form';
state.mailImport.apiErrorCode = action.payload?.Code;
state.mailImport.apiErrorLabel = action.payload?.Error;
state.mailImport.loading = false;
}
});
builder.addCase(actions.saveImapMailFields, (state, action) => {
if (mailImportIsDefined(state, actions.saveImapMailFields)) {
state.mailImport.fields = action.payload;
}
});
/**
* Prepare IMAP import thunk
*/
builder.addCase(actions.startImapMailImport.pending, (state) => {
if (mailImportIsDefined(state, actions.startImapMailImport.pending)) {
state.mailImport.loading = true;
}
});
builder.addCase(actions.startImapMailImport.fulfilled, (state) => {
if (mailImportIsDefined(state, actions.startImapMailImport.fulfilled)) {
state.mailImport.step = 'importing';
state.mailImport.loading = false;
}
});
builder.addCase(actions.startImapMailImport.rejected, (state) => {
if (mailImportIsDefined(state, actions.startImapMailImport.rejected)) {
state.mailImport.loading = false;
}
});
builder.addCase(actions.resumeImapImport.rejected, resetState);
builder.addCase(actions.resumeImapImport.fulfilled, resetState);
builder.addCase(actions.displayConfirmLeaveModal, (state, action) => {
state.displayConfirmLeaveModal = action.payload;
});
},
});
export default imapDraftSlice.reducer;
| 4,966
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/draft
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/draft/oauthDraft/createImporter.action.ts
|
import { createAsyncThunk } from '@reduxjs/toolkit';
import { c } from 'ttag';
import {
createImport,
createToken,
getCalendarImportData,
getContactsImportData,
getMailImportData,
} from '@proton/activation/src/api';
import { ApiMailImporterFolder } from '@proton/activation/src/api/api.interface';
import { MailImportFields } from '@proton/activation/src/components/Modals/CustomizeMailImportModal/CustomizeMailImportModal.interface';
import getDefaultLabel from '@proton/activation/src/components/Modals/Imap/ImapMailModal/StepPrepareImap/useStepPrepareImap.helpers';
import MailImportFoldersParser from '@proton/activation/src/helpers/MailImportFoldersParser/MailImportFoldersParser';
import { getDefaultImportCategoriesDestination } from '@proton/activation/src/helpers/getDefaultImportCategories';
import { getDefaultTimePeriod } from '@proton/activation/src/helpers/getDefaultTimePeriod';
import {
AuthenticationMethod,
CreateImportPayload,
IMPORT_ERROR,
ImportProvider,
ImportToken,
ImportType,
ImportedCalendar,
OAuthProps,
} from '@proton/activation/src/interface';
import { getApiError, getIsTimeoutError } from '@proton/shared/lib/api/helpers/apiErrorHelper';
import { MAX_CHARS_API } from '@proton/shared/lib/calendar/constants';
import { HTTP_ERROR_CODES } from '@proton/shared/lib/errors';
import { Address, UserModel } from '@proton/shared/lib/interfaces';
import truncate from '@proton/utils/truncate';
import { EasySwitchThunkExtra } from '../../store';
import { OAUTH_ACTION_PREFIX } from './oauthDraft.actions';
import { ImporterCalendar, ImporterData } from './oauthDraft.interface';
type Props = {
oAuthProps: OAuthProps;
source: string;
defaultAddress: Address;
user: UserModel;
};
interface ImportRawData {
importType: ImportType;
Folders?: ApiMailImporterFolder[];
Calendars?: APICalendar[];
error?: string;
}
interface APICalendar {
Source: string;
ID: string;
Description: string;
}
export enum Separator {
Empty = '/',
}
export const createImporterThunk = createAsyncThunk<ImporterData, Props, EasySwitchThunkExtra>(
`${OAUTH_ACTION_PREFIX}/createImporter`,
async (props, thunkAPI) => {
const { oAuthProps, source, defaultAddress, user } = props;
const state = thunkAPI.getState();
const products = state.oauthDraft.mailImport?.products!;
const provider = state.oauthDraft.provider;
const { Code, Provider, RedirectUri } = oAuthProps;
const { Token }: { Token: ImportToken } = await thunkAPI.extra.api(
createToken({
Provider,
Code,
RedirectUri,
Source: source,
Products: products,
})
);
const { Products, ID, Account } = Token;
const createImportPayload: CreateImportPayload = { TokenID: ID, Source: source };
if (Products.includes(ImportType.MAIL)) {
createImportPayload[ImportType.MAIL] = {
Account,
Sasl: AuthenticationMethod.OAUTH,
};
}
// Calendar and contacts need empty payload
if (Products.includes(ImportType.CALENDAR)) {
createImportPayload[ImportType.CALENDAR] = {};
}
if (Products.includes(ImportType.CONTACTS)) {
createImportPayload[ImportType.CONTACTS] = {};
}
const { ImporterID } = await thunkAPI.extra.api(createImport(createImportPayload));
const importsRawData: ImportRawData[] = await Promise.all(
products.map(async (product: ImportType): Promise<ImportRawData> => {
if (product === ImportType.MAIL) {
try {
const { Folders } = await thunkAPI.extra.api<{
Code: number;
Folders: ApiMailImporterFolder[];
}>({ ...getMailImportData(ImporterID), silence: true });
return {
importType: product,
Folders,
};
} catch (e) {
const { code, status } = getApiError(e);
if (
status === HTTP_ERROR_CODES.UNPROCESSABLE_ENTITY &&
code === IMPORT_ERROR.ACCOUNT_DOES_NOT_EXIST
) {
return {
importType: product,
error: c('Error').t`No emails found to import - the account does not have an inbox`,
};
} else {
throw e;
}
}
}
if (product === ImportType.CALENDAR) {
try {
const { Calendars } = await thunkAPI.extra.api<{
Code: number;
Calendars: ImportedCalendar[];
}>({ ...getCalendarImportData(ImporterID), silence: true });
return {
importType: product,
Calendars,
};
} catch (e) {
const { code, status } = getApiError(e);
if (
status === HTTP_ERROR_CODES.UNPROCESSABLE_ENTITY &&
code === IMPORT_ERROR.ACCOUNT_DOES_NOT_EXIST
) {
return {
importType: product,
error: c('Error').t`No calendars found to import`,
};
} else {
throw e;
}
}
}
if (product === ImportType.CONTACTS) {
try {
await thunkAPI.extra.api<{ Contacts: any }>({
...getContactsImportData(ImporterID),
silence: true,
});
return {
importType: product,
};
} catch (e) {
const { code, status } = getApiError(e);
const isTimeout = getIsTimeoutError(e);
//Fetching contacts can take a long time and can timeout
if (isTimeout) {
return {
importType: product,
};
} else if (status === HTTP_ERROR_CODES.UNPROCESSABLE_ENTITY) {
if (code === IMPORT_ERROR.TOO_LARGE) {
return {
importType: product,
error: c('Error').t`You have reached the contacts limit for your account`,
};
} else if (code === IMPORT_ERROR.ACCOUNT_DOES_NOT_EXIST) {
return {
importType: product,
error: c('Error').t`No contacts found to import`,
};
}
} else {
throw e;
}
}
}
return { importType: product };
})
);
const emailData = importsRawData.find((item) => item.importType === ImportType.MAIL);
const contactData = importsRawData.find((item) => item.importType === ImportType.CONTACTS);
const calendarData = importsRawData.find((item) => item.importType === ImportType.CALENDAR);
const calendarResponse: ImporterCalendar[] | undefined = calendarData?.Calendars?.map(
(item: APICalendar): ImporterCalendar => {
return {
id: item.ID,
source: truncate(item.Source, MAX_CHARS_API.CALENDAR_NAME),
description: truncate(item.Description, MAX_CHARS_API.CALENDAR_DESCRIPTION),
checked: true,
};
}
);
const apiFolders = emailData?.Folders ?? [];
const foldersMapping = new MailImportFoldersParser(apiFolders, provider === ImportProvider.GOOGLE).folders;
const emailFields: MailImportFields = {
mapping: foldersMapping,
importLabel: getDefaultLabel(Account),
importAddress: defaultAddress,
importPeriod: getDefaultTimePeriod(user),
importCategoriesDestination: getDefaultImportCategoriesDestination(foldersMapping),
};
return {
importerId: ImporterID,
importedEmail: Account,
emails: { error: emailData?.error, fields: emailFields, initialFields: emailFields },
calendars: { error: calendarData?.error, calendars: calendarResponse, initialFields: calendarResponse },
contacts: {
error: contactData?.error,
},
};
}
);
| 4,967
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/draft
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/draft/oauthDraft/oauthDraft.actions.ts
|
import { createAction } from '@reduxjs/toolkit';
import { MailImportFields } from '@proton/activation/src/components/Modals/CustomizeMailImportModal/CustomizeMailImportModal.interface';
import { ImportProvider, ImportType } from '@proton/activation/src/interface';
import { ImporterCalendar, MailImportState } from './oauthDraft.interface';
export const OAUTH_ACTION_PREFIX = 'draft/oauth';
export const resetOauthDraft = createAction(`${OAUTH_ACTION_PREFIX}/reset`);
export const startOauthDraft = createAction<{
provider: ImportProvider;
products: ImportType[];
}>(`${OAUTH_ACTION_PREFIX}/start`);
export const initOauthMailImport = createAction(`${OAUTH_ACTION_PREFIX}/initOauthImport`);
export const displayConfirmLeaveModal = createAction<boolean>(`${OAUTH_ACTION_PREFIX}/displayConfirmLeaveModal`);
export const submitProductProvider = createAction<{ products: ImportType[]; scopes: string[] }>(
`${OAUTH_ACTION_PREFIX}/submitProductProvider`
);
export const submitProducts = createAction<ImportType[]>(`${OAUTH_ACTION_PREFIX}/submitProducts`);
export const changeOAuthStep = createAction<MailImportState['step']>(`${OAUTH_ACTION_PREFIX}/changeOAuthStep`);
export const updateCalendarData = createAction<ImporterCalendar[]>(`${OAUTH_ACTION_PREFIX}/updateCalendarData`);
export const updateEmailsData = createAction<MailImportFields>(`${OAUTH_ACTION_PREFIX}/updateEmailsData`);
| 4,968
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/draft
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/draft/oauthDraft/oauthDraft.interface.ts
|
import { MailImportFields } from '@proton/activation/src/components/Modals/CustomizeMailImportModal/CustomizeMailImportModal.interface';
import { ImportProvider, ImportType } from '@proton/activation/src/interface';
import { VisualCalendar } from '@proton/shared/lib/interfaces/calendar';
import { Separator } from './createImporter.action';
export type ImporterContact = {
error?: string;
};
export type ImporterCalendar = {
source: string;
description: string;
id: string;
checked: boolean;
error?: string;
newCalendar?: boolean;
mergedTo?: VisualCalendar;
};
export interface ImporterFolder {
Source: string;
Separator: Separator;
Flags: any[];
DestinationFolder?: string;
DestinationCategory?: string;
}
export type ImporterData = {
importerId: string;
importedEmail: string;
emails?: { error?: string; fields?: MailImportFields; readonly initialFields?: MailImportFields };
calendars?: { error?: string; calendars?: ImporterCalendar[]; readonly initialFields?: ImporterCalendar[] };
contacts?: ImporterContact;
};
export type MailImportState = {
step?: 'products' | 'instructions' | 'loading-importer' | 'prepare-import' | 'importing' | 'success';
products?: ImportType[];
hasReadInstructions?: boolean;
isCreatingImporter?: boolean;
scopes?: string[];
importerData?: ImporterData;
};
export type OauthDraftState = {
step: 'idle' | 'started';
provider?: ImportProvider;
displayConfirmLeaveModal?: boolean;
mailImport?: MailImportState;
};
| 4,969
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/draft
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/draft/oauthDraft/oauthDraft.selector.ts
|
import { createSelector } from '@reduxjs/toolkit';
import { EasySwitchState } from '../../store';
const selectOauthDraft = (state: EasySwitchState) => state.oauthDraft;
export const selectOauthDraftStep = createSelector(selectOauthDraft, (draft) => draft.step);
export const selectOauthDraftProvider = createSelector(selectOauthDraft, (draft) => draft.provider);
export const selectOauthDraftStepConfirmModalDisplay = createSelector(
selectOauthDraft,
(draft) => draft.displayConfirmLeaveModal
);
export const selectOauthImportState = createSelector(selectOauthDraft, (draft) => draft.mailImport);
export const selectOauthImportStateStep = createSelector(selectOauthImportState, (draft) => draft?.step);
export const selectOauthImportStateScopes = createSelector(selectOauthImportState, (draft) => draft?.scopes);
export const selectOauthImportStateProducts = createSelector(selectOauthImportState, (draft) => draft?.products);
export const selectOauthImportStateImporterData = createSelector(
selectOauthImportState,
(draft) => draft?.importerData
);
export const selectOauthImportStateLoadingImporters = createSelector(
selectOauthImportState,
(draft) => draft?.isCreatingImporter
);
| 4,970
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/draft
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/draft/oauthDraft/oauthDraft.slice.ts
|
import { Action, createSlice } from '@reduxjs/toolkit';
import { RequireSome } from '@proton/shared/lib/interfaces';
import { createImporterThunk } from './createImporter.action';
import * as actions from './oauthDraft.actions';
import { OauthDraftState } from './oauthDraft.interface';
const initialState: OauthDraftState = { step: 'idle' };
const mailImportIsDefined = (
state: OauthDraftState,
action: Action
): state is RequireSome<OauthDraftState, 'mailImport'> => {
if (state.mailImport === undefined) {
throw new Error(`Reducer for ${action.type} should not be called if 'mailImport' is not defined`);
}
return state.mailImport !== undefined;
};
const oauthDraftSlice = createSlice({
name: 'oauthDraft',
initialState,
reducers: {},
extraReducers: (builder) => {
builder.addCase(actions.startOauthDraft, (state, action) => {
state.step = 'started';
state.provider = action.payload.provider;
state.mailImport = {
...state.mailImport,
products: action.payload.products,
};
});
builder.addCase(actions.displayConfirmLeaveModal, (state, action) => {
state.displayConfirmLeaveModal = action.payload;
});
builder.addCase(actions.resetOauthDraft, (state) => {
state.step = 'idle';
delete state.provider;
delete state.mailImport;
delete state.displayConfirmLeaveModal;
});
builder.addCase(actions.initOauthMailImport, (state) => {
if (mailImportIsDefined(state, actions.initOauthMailImport)) {
state.mailImport.step = 'products';
}
});
builder.addCase(actions.submitProducts, (state, action) => {
if (mailImportIsDefined(state, actions.submitProducts)) {
state.mailImport.products = action.payload;
}
});
builder.addCase(actions.submitProductProvider, (state, action) => {
if (mailImportIsDefined(state, actions.submitProductProvider)) {
state.mailImport.products = action.payload.products;
state.mailImport.scopes = action.payload.scopes;
}
});
builder.addCase(actions.changeOAuthStep, (state, action) => {
if (mailImportIsDefined(state, actions.changeOAuthStep)) {
state.mailImport.step = action.payload;
}
});
builder.addCase(createImporterThunk.fulfilled, (state, action) => {
if (mailImportIsDefined(state, createImporterThunk.fulfilled)) {
state.mailImport.isCreatingImporter = false;
state.mailImport.importerData = action.payload;
state.mailImport.step = 'prepare-import';
}
});
builder.addCase(createImporterThunk.rejected, (state) => {
state.step = 'idle';
delete state.provider;
delete state.mailImport;
delete state.displayConfirmLeaveModal;
});
builder.addCase(createImporterThunk.pending, (state) => {
if (mailImportIsDefined(state, createImporterThunk.pending)) {
state.mailImport.isCreatingImporter = true;
}
});
builder.addCase(actions.updateCalendarData, (state, action) => {
if (mailImportIsDefined(state, actions.updateCalendarData) && state.mailImport.importerData?.calendars) {
state.mailImport.importerData.calendars.calendars = action.payload;
}
});
builder.addCase(actions.updateEmailsData, (state, action) => {
if (mailImportIsDefined(state, actions.updateEmailsData) && state.mailImport.importerData?.emails) {
state.mailImport.importerData.emails.fields = action.payload;
}
});
},
});
export default oauthDraftSlice.reducer;
| 4,971
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/importers/importers.actions.ts
|
import { createAsyncThunk } from '@reduxjs/toolkit';
import { c } from 'ttag';
import { cancelImport, getImportsList } from '@proton/activation/src/api';
import { ApiImportListResponse } from '@proton/activation/src/api/api.interface';
import { EasySwitchThunkExtra } from '../store';
import { ActiveImportID } from './importers.interface';
export const loadImporters = createAsyncThunk<ApiImportListResponse, undefined, EasySwitchThunkExtra>(
'importers/load',
async (_, thunkApi) => {
const importers = await thunkApi.extra.api<ApiImportListResponse>(getImportsList());
return importers;
}
);
export const cancelImporter = createAsyncThunk<void, { activeImporterID: ActiveImportID }, EasySwitchThunkExtra>(
'importers/cancel',
async ({ activeImporterID }, thunkApi) => {
const state = thunkApi.getState();
const activeImporter = state.importers.activeImporters[activeImporterID];
await thunkApi.extra.api(
cancelImport({
ImporterID: activeImporter.importerID,
Products: [activeImporter.product],
})
);
await thunkApi.extra.eventManager.call();
thunkApi.extra.notificationManager.createNotification({ text: c('Success').t`Canceling import` });
}
);
| 4,972
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/importers/importers.helpers.ts
|
import { ApiImportListResponse, ApiImporter } from '@proton/activation/src/api/api.interface';
import { ImportType } from '@proton/activation/src/interface';
import { ActiveImporter, ActiveImportersMap, Importer, ImportersMap } from './importers.interface';
export const normalizeImporter = (apiImporter: ApiImporter) => {
const importer: Importer = {
ID: apiImporter.ID,
account: apiImporter.Account,
products: apiImporter.Product,
provider: apiImporter.Provider,
sasl: apiImporter.Sasl,
};
const activeImporters: ActiveImporter[] = [];
if (apiImporter.Active) {
Object.entries(apiImporter.Active).forEach(([product, value]) => {
if (value) {
const formattedReport: ActiveImporter = {
localID: `${importer.ID}-${product as ImportType}`,
importerID: importer.ID,
product: product as ImportType,
importState: value.State,
startDate: value.CreateTime,
errorCode: value.ErrorCode,
mapping: value.Mapping,
total: value.Total,
};
activeImporters.push(formattedReport);
}
});
}
return { importer, activeImporters };
};
export const normalizeImporters = (importersResponse: ApiImportListResponse) => {
let imports: Importer[] = [];
let activeImports: ActiveImporter[] = [];
importersResponse.Importers.forEach((apiImporter) => {
const { importer, activeImporters } = normalizeImporter(apiImporter);
imports.push(importer);
activeImports = activeImports.concat(activeImporters);
});
const importersMap = imports.reduce<ImportersMap>((acc, importer) => {
acc[importer.ID] = importer;
return acc;
}, {});
const activeImportersMap = activeImports.reduce<ActiveImportersMap>((acc, activeImporter) => {
acc[activeImporter.localID] = activeImporter;
return acc;
}, {});
return { importersMap, activeImportersMap };
};
| 4,973
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/importers/importers.interface.ts
|
import { ApiImporter, ApiImporterActive, ApiImporterFolder } from '@proton/activation/src/api/api.interface';
import { ImportType } from '@proton/activation/src/interface';
/**
* TODO: Change typing depending on IMAP and OAUTH context
*/
export type Importer = {
ID: ApiImporter['ID'];
account: ApiImporter['Account'];
products: ApiImporter['Product'];
/** Only on IMAP flow */
sasl?: ApiImporter['Sasl'];
provider: ApiImporter['Provider'];
};
/**
* Active importers don't have ID returned by API
* We define it by using import ImporterID and ImportType
*/
export type ActiveImportID = `${Importer['ID']}-${ImportType}`;
export type ActiveImporter = {
localID: ActiveImportID;
importerID: ApiImporter['ID'];
product: ImportType;
errorCode?: ApiImporterActive['ErrorCode'];
importState: ApiImporterActive['State'];
mapping?: ApiImporterFolder[];
startDate: ApiImporterActive['CreateTime'];
total?: ApiImporterActive['Total'];
};
export type ImportersMap = Record<string, Importer>;
export type ActiveImportersMap = Record<ActiveImportID, ActiveImporter>;
export interface ImportersState {
importers: ImportersMap;
activeImporters: ActiveImportersMap;
loading: 'idle' | 'pending' | 'success' | 'failed';
}
| 4,974
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/importers/importers.selectors.ts
|
import { createSelector } from '@reduxjs/toolkit';
import { ApiImporterError, ApiImporterState } from '@proton/activation/src/api/api.interface';
import orderBy from '@proton/utils/orderBy';
import { EasySwitchState } from '../store';
import { ActiveImportID, ActiveImporter, ActiveImportersMap, Importer, ImportersMap } from './importers.interface';
const selectImportersMap = (state: EasySwitchState): ImportersMap => state.importers.importers;
const selectActiveImportersMap = (state: EasySwitchState): ActiveImportersMap => state.importers.activeImporters;
export const selectImportersState = (state: EasySwitchState) => state.importers.loading;
export const selectImporters = createSelector([selectImportersMap], (importersMap): Importer[] =>
Object.values(importersMap)
);
export const selectActiveImporters = createSelector(selectActiveImportersMap, (activeImportersMap): ActiveImporter[] =>
Object.values(activeImportersMap)
);
export const selectImporterById = createSelector(
selectImportersMap,
(_: EasySwitchState, ID: string) => ID,
(importersMap, ID) => importersMap[ID]
);
export const selectActiveImporterById = createSelector(
selectActiveImportersMap,
(_: EasySwitchState, ID: ActiveImportID) => ID,
(activeImportersMap, ID) => activeImportersMap[ID]
);
export const selectActiveImporterIdsByDate = createSelector(selectActiveImporters, (activeImporters) =>
orderBy(activeImporters, 'startDate')
.map(({ localID }) => localID)
.reverse()
);
export const selectActiveImportersErrors = createSelector(
[selectImportersMap, selectActiveImporters],
(importersMap, activeImporters) => {
const delayedImportAccounts: string[] = [];
const importErrors = activeImporters.reduce<('storageLimit' | 'authConnection' | 'delayedImport')[]>(
(acc, activeImporter) => {
const { importState, errorCode, importerID } = activeImporter;
const { account } = importersMap[importerID];
if (
!acc.includes('storageLimit') &&
importState === ApiImporterState.PAUSED &&
errorCode === ApiImporterError.ERROR_CODE_QUOTA_LIMIT
) {
acc.push('storageLimit');
}
if (
!acc.includes('authConnection') &&
importState === ApiImporterState.PAUSED &&
errorCode === ApiImporterError.ERROR_CODE_IMAP_CONNECTION
) {
acc.push('authConnection');
}
if (!acc.includes('authConnection') && importState === ApiImporterState.DELAYED) {
acc.push('delayedImport');
}
if (importState === ApiImporterState.DELAYED) {
delayedImportAccounts.push(account);
}
return acc;
},
[]
);
return { importErrors, delayedImportAccounts };
}
);
| 4,975
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/importers/importers.slice.ts
|
import { createSlice } from '@reduxjs/toolkit';
import { EVENT_ACTIONS } from '@proton/shared/lib/constants';
import * as globalAction from '../actions';
import * as action from './importers.actions';
import { normalizeImporter, normalizeImporters } from './importers.helpers';
import { ImportersState } from './importers.interface';
const initialState: ImportersState = { importers: {}, activeImporters: {}, loading: 'idle' };
const importersSlice = createSlice({
name: 'importers',
initialState,
reducers: {},
extraReducers: (builder) => {
builder.addCase(action.loadImporters.pending, (state) => {
state.loading = 'pending';
});
builder.addCase(action.loadImporters.rejected, (state) => {
state.loading = 'failed';
});
builder.addCase(action.loadImporters.fulfilled, (state, action) => {
state.loading = 'success';
if (action.payload) {
const { importersMap, activeImportersMap } = normalizeImporters(action.payload);
state.importers = importersMap;
state.activeImporters = activeImportersMap;
}
});
builder.addCase(globalAction.event, (state, action) => {
const importEvents = action.payload.Imports;
if (importEvents) {
importEvents.forEach(({ Importer, Action, ID }) => {
if (Importer) {
if (EVENT_ACTIONS.CREATE === Action) {
const { importer, activeImporters } = normalizeImporter(Importer);
state.importers[importer.ID] = importer;
activeImporters.forEach((activeImporter) => {
state.activeImporters[activeImporter.localID] = activeImporter;
});
}
if (EVENT_ACTIONS.UPDATE === Action) {
const { importer, activeImporters } = normalizeImporter(Importer);
// Update importer
state.importers[importer.ID] = importer;
// Delete importer active imports
const stateActiveImporterIds = Object.values(state.activeImporters)
.filter((activeImporter) => activeImporter.importerID === importer.ID)
.map(({ localID }) => localID);
stateActiveImporterIds.forEach((id) => {
delete state.activeImporters[id];
});
// Create updated importers
activeImporters.forEach((activeImporter) => {
state.activeImporters[activeImporter.localID] = activeImporter;
});
}
}
if (Action === EVENT_ACTIONS.DELETE) {
// Delete importer and it's related active importers
delete state.importers[ID];
Object.values(state.activeImporters).forEach((activeImporter) => {
if (activeImporter.importerID === ID) {
delete state.activeImporters[activeImporter.localID];
}
});
}
});
}
});
},
});
export default importersSlice.reducer;
| 4,976
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/reports/reports.actions.ts
|
import { createAsyncThunk } from '@reduxjs/toolkit';
import { c } from 'ttag';
import { deleteImportReport, getImportReportsList, rollbackImport } from '@proton/activation/src/api';
import { ApiImportReportListResponse } from '@proton/activation/src/api/api.interface';
import { EasySwitchThunkExtra } from '../store';
import { ReportSummaryID } from './reports.interface';
export const loadReports = createAsyncThunk<ApiImportReportListResponse, undefined, EasySwitchThunkExtra>(
'reports/load',
async (_, thunkApi) => {
const activeImports = await thunkApi.extra.api<ApiImportReportListResponse>(getImportReportsList());
return activeImports;
}
);
export const deleteReportSummary = createAsyncThunk<void, { reportSummaryID: ReportSummaryID }, EasySwitchThunkExtra>(
'reports/delete',
async ({ reportSummaryID }, thunkApi) => {
const state = thunkApi.getState();
const reportSummary = state.reports.summaries[reportSummaryID];
await thunkApi.extra.api(deleteImportReport(reportSummary.reportID, reportSummary.product));
await thunkApi.extra.eventManager.call();
thunkApi.extra.notificationManager.createNotification({ text: c('Success').t`Import record deleted` });
}
);
export const rollbackReportSummary = createAsyncThunk<void, { reportSummaryID: ReportSummaryID }, EasySwitchThunkExtra>(
'reports/rollback',
async ({ reportSummaryID }, thunkApi) => {
const state = thunkApi.getState();
const reportSummary = state.reports.summaries[reportSummaryID];
await thunkApi.extra.api(rollbackImport(reportSummary.reportID, [reportSummary.product]));
await thunkApi.extra.eventManager.call();
thunkApi.extra.notificationManager.createNotification({ text: c('Success').t`Undo in progress` });
}
);
| 4,977
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/reports/reports.helpers.ts
|
import { ApiImportReportListResponse, ApiReport } from '@proton/activation/src/api/api.interface';
import { ImportType } from '@proton/activation/src/interface';
import { Report, ReportSummariesMap, ReportSummary, ReportsMap } from './reports.interface';
type NormalizeReport = (apiReport: ApiReport) => { report: Report; reportSummaries: ReportSummary[] };
export const normalizeReport: NormalizeReport = (apiReport) => {
const report: Report = {
ID: apiReport.ID,
account: apiReport.Account,
startDate: apiReport.CreateTime,
endDate: apiReport.EndTime,
size: apiReport.TotalSize,
state: apiReport.State,
};
const reportSummaries: ReportSummary[] = [];
if (apiReport.Summary) {
Object.entries(apiReport.Summary).forEach(([key, { RollbackState, State, TotalSize }]) => {
const product = key as ImportType;
const summary: ReportSummary = {
localID: `${apiReport.ID}-${product}`,
reportID: apiReport.ID,
product,
rollbackState: RollbackState,
size: TotalSize,
state: State,
};
reportSummaries.push(summary);
});
}
return { report, reportSummaries };
};
type NormalizeReports = (reportsResponse: ApiImportReportListResponse) => {
reportsMap: ReportsMap;
reportSummariesMap: ReportSummariesMap;
};
export const normalizeReports: NormalizeReports = (reportsResponse) => {
const reports: Report[] = [];
const reportSummaries: ReportSummary[] = [];
reportsResponse.Reports.forEach((report) => {
const formattedReport = normalizeReport(report);
reports.push(formattedReport.report);
formattedReport.reportSummaries.forEach((reportSummary) => {
reportSummaries.push(reportSummary);
});
});
const reportsMap = reports.reduce<ReportsMap>((acc, report) => {
acc[report.ID] = report;
return acc;
}, {});
const reportSummariesMap = reportSummaries.reduce<ReportSummariesMap>((acc, reportSummary) => {
acc[reportSummary.localID] = reportSummary;
return acc;
}, {});
return { reportsMap, reportSummariesMap };
};
| 4,978
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/reports/reports.interface.ts
|
import { ApiReport, ApiReportState, ApiReportSummary } from '@proton/activation/src/api/api.interface';
import { ImportType } from '@proton/activation/src/interface';
export type Report = {
ID: ApiReport['ID'];
state: ApiReportState;
account: ApiReport['Account'];
startDate: ApiReport['CreateTime'];
endDate: ApiReport['EndTime'];
size: ApiReport['TotalSize'];
};
export type ReportSummaryID = `${Report['ID']}-${ImportType}`;
export type ReportSummary = {
localID: ReportSummaryID;
reportID: ApiReport['ID'];
product: keyof ApiReport['Summary'];
state: ApiReportSummary['State'];
size: ApiReportSummary['TotalSize'];
rollbackState: ApiReportSummary['RollbackState'];
};
export type ReportsMap = Record<string, Report>;
export type ReportSummariesMap = Record<string, ReportSummary>;
export interface ReportsState {
summaries: ReportSummariesMap;
reports: ReportsMap;
loading: 'idle' | 'pending' | 'success' | 'failed';
}
| 4,979
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/reports/reports.selectors.ts
|
import { createSelector } from '@reduxjs/toolkit';
import orderBy from '@proton/utils/orderBy';
import { EasySwitchState } from '../store';
import { Report, ReportSummariesMap, ReportSummary, ReportSummaryID, ReportsMap } from './reports.interface';
export const selectReportsMap = (state: EasySwitchState): ReportsMap => state.reports.reports;
export const selectReportsSummariesMap = (state: EasySwitchState): ReportSummariesMap => state.reports.summaries;
export const selectReportsState = (state: EasySwitchState) => state.reports.loading;
export const selectReportById = createSelector(
selectReportsMap,
(_: EasySwitchState, ID: string) => ID,
(reportsMap, ID) => reportsMap[ID]
);
export const selectReportSummaryById = createSelector(
selectReportsSummariesMap,
(_: EasySwitchState, ID: ReportSummaryID) => ID,
(summariesMap, ID) => summariesMap[ID]
);
export const selectReports = createSelector(selectReportsMap, (reportsMap): Report[] => {
const reports = Object.values(reportsMap);
return reports;
});
export const selectReportSummaries = createSelector(
selectReportsSummariesMap,
(reportsSummariesMap): ReportSummary[] => {
const summaries = Object.values(reportsSummariesMap);
return summaries;
}
);
/**
* @returns array of summary ids ordered by report date DESC
*/
export const selectReportSummaryIdsByDate = createSelector(
[selectReports, selectReportSummaries],
(reports, summaries) =>
orderBy(reports, 'endDate')
.reduce<ReportSummaryID[]>((acc, { ID }) => {
const ids = summaries.filter(({ reportID }) => reportID === ID).map(({ localID }) => localID);
acc = [...acc, ...ids];
return acc;
}, [])
.reverse()
);
| 4,980
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/reports/reports.slice.ts
|
import { createSlice } from '@reduxjs/toolkit';
import { EVENT_ACTIONS } from '@proton/shared/lib/constants';
import * as globalAction from '../actions';
import * as action from './reports.actions';
import { normalizeReport, normalizeReports } from './reports.helpers';
import { ReportsState } from './reports.interface';
const initialState: ReportsState = { reports: {}, summaries: {}, loading: 'idle' };
const reportsSlice = createSlice({
name: 'reports',
initialState,
reducers: {},
extraReducers: (builder) => {
builder.addCase(action.loadReports.pending, (state) => {
state.loading = 'pending';
});
builder.addCase(action.loadReports.rejected, (state) => {
state.loading = 'failed';
});
builder.addCase(action.loadReports.fulfilled, (state, action) => {
state.loading = 'success';
if (action.payload) {
const { reportsMap, reportSummariesMap } = normalizeReports(action.payload);
state.reports = reportsMap;
state.summaries = reportSummariesMap;
}
});
builder.addCase(globalAction.event, (state, action) => {
const reportEvents = action.payload.ImportReports;
if (reportEvents) {
reportEvents.forEach(({ ImportReport, Action, ID }) => {
if (ImportReport) {
if (EVENT_ACTIONS.CREATE === Action) {
const { report, reportSummaries } = normalizeReport(ImportReport);
state.reports[report.ID] = report;
reportSummaries.forEach((summary) => {
state.summaries[summary.localID] = summary;
});
}
if (EVENT_ACTIONS.UPDATE === Action) {
const { report, reportSummaries } = normalizeReport(ImportReport);
// Update reports
state.reports[report.ID] = report;
// Delete old summaries
const stateSummariesIds = Object.values(state.summaries)
.filter((summary) => summary.reportID === report.ID)
.map(({ localID }) => localID);
stateSummariesIds.forEach((stateSummaryID) => {
delete state.summaries[stateSummaryID];
});
// Create new summaries
reportSummaries.forEach((reportSummary) => {
state.summaries[reportSummary.localID] = reportSummary;
});
}
}
if (Action === EVENT_ACTIONS.DELETE) {
// Delete report and it's related summaries
delete state.reports[ID];
Object.values(state.summaries).forEach((summary) => {
if (summary.reportID === ID) {
delete state.summaries[summary.localID];
}
});
}
});
}
});
},
});
export default reportsSlice.reducer;
| 4,981
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/sync/sync.actions.ts
|
import { createAction, createAsyncThunk } from '@reduxjs/toolkit';
import { c } from 'ttag';
import {
createImport,
createSync,
createToken,
deleteSync,
getSyncList,
resumeSync,
updateImport,
} from '@proton/activation/src/api';
import { APIImportSyncListResponse } from '@proton/activation/src/api/api.interface';
import {
AuthenticationMethod,
CreateImportPayload,
EASY_SWITCH_SOURCE,
ImportToken,
ImportType,
OAUTH_PROVIDER,
} from '@proton/activation/src/interface';
import { CreateNotificationOptions } from '@proton/components';
import { EasySwitchThunkExtra } from '../store';
import { LoadingState } from './sync.interface';
type SubmitError = { Code: number; Error: string };
export const changeCreateLoadingState = createAction<LoadingState>('sync/changeCreateLoadingState');
export const loadSyncList = createAsyncThunk<
APIImportSyncListResponse,
undefined,
EasySwitchThunkExtra & { rejectedValue: SubmitError }
>('sync/load', async (_, thunkApi) => {
try {
const activeSync = await thunkApi.extra.api<APIImportSyncListResponse>(getSyncList());
return activeSync;
} catch (error: any) {
return thunkApi.rejectWithValue(error.data as SubmitError);
}
});
export const deleteSyncItem = createAsyncThunk<
string,
{ syncId: string },
EasySwitchThunkExtra & { rejectedValue: SubmitError }
>('sync/delete', async ({ syncId }, thunkApi) => {
try {
await thunkApi.extra.api(deleteSync(syncId));
await thunkApi.extra.eventManager.call();
thunkApi.extra.notificationManager.createNotification({
text: c('account').t`Mail forward stopped`,
});
return syncId;
} catch (error: any) {
return thunkApi.rejectWithValue(error.data as SubmitError);
}
});
interface CreateSyncProps {
Code: string;
Provider: OAUTH_PROVIDER;
RedirectUri: string;
Source: EASY_SWITCH_SOURCE;
notification: CreateNotificationOptions;
}
export const createSyncItem = createAsyncThunk<
any,
CreateSyncProps,
EasySwitchThunkExtra & {
rejectValue: SubmitError;
}
>('sync/create', async (props, thunkApi) => {
try {
const { Code, Provider, RedirectUri, Source, notification } = props;
const { Token }: { Token: ImportToken } = await thunkApi.extra.api(
createToken({
Provider,
Code,
RedirectUri,
Source,
Products: [ImportType.MAIL],
})
);
const { Products, ID, Account } = Token;
const createImportPayload: CreateImportPayload = {
TokenID: ID,
Source,
};
if (Products.includes(ImportType.MAIL)) {
createImportPayload[ImportType.MAIL] = {
Account,
Sasl: AuthenticationMethod.OAUTH,
};
}
const { ImporterID } = await thunkApi.extra.api(createImport(createImportPayload));
await thunkApi.extra.api(createSync(ImporterID));
await thunkApi.extra.eventManager.call();
thunkApi.extra.notificationManager.createNotification(notification);
return;
} catch (error: any) {
return thunkApi.rejectWithValue(error.data as SubmitError);
}
});
interface ResumeSyncProps extends CreateSyncProps {
syncId: string;
importerId: string;
}
export const resumeSyncItem = createAsyncThunk<
any,
ResumeSyncProps,
EasySwitchThunkExtra & {
rejectValue: SubmitError;
}
>('sync/resume', async (props, thunkApi) => {
try {
const { Code, Provider, RedirectUri, Source, notification, syncId, importerId } = props;
const { Token }: { Token: ImportToken } = await thunkApi.extra.api(
createToken({
Provider,
Code,
RedirectUri,
Source,
Products: [ImportType.MAIL],
})
);
await thunkApi.extra.api(updateImport(importerId, { TokenID: Token.ID }));
await thunkApi.extra.api(resumeSync(syncId));
await thunkApi.extra.eventManager.call();
thunkApi.extra.notificationManager.createNotification(notification);
return;
} catch (error: any) {
return thunkApi.rejectWithValue(error.data as SubmitError);
}
});
| 4,982
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/sync/sync.helpers.ts
|
import { ApiSync } from '@proton/activation/src/api/api.interface';
import { Sync } from './sync.interface';
export const formatApiSync = (sync: ApiSync): Sync => {
return {
account: sync.Account,
id: sync.ID,
importerID: sync.ImporterID,
product: sync.Product,
state: sync.State,
startDate: sync.CreateTime,
};
};
export const formatApiSyncs = (syncs: ApiSync[]): Sync[] => {
return syncs.map((item) => {
return formatApiSync(item);
});
};
| 4,983
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/sync/sync.interface.ts
|
import { ApiSyncState } from '@proton/activation/src/api/api.interface';
import { ImportType } from '@proton/activation/src/interface';
export type Sync = {
account: string;
id: string;
importerID: string;
product: ImportType;
state: ApiSyncState;
startDate: number;
};
export type SyncMap = Record<string, Sync>;
export type LoadingState = 'idle' | 'pending' | 'success' | 'failed';
export interface SyncState {
syncs: SyncMap;
creatingLoading: LoadingState;
listLoading: LoadingState;
apiErrorCode?: number;
apiErrorLabel?: string;
}
| 4,984
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/sync/sync.selectors.ts
|
import { createSelector } from '@reduxjs/toolkit';
import orderBy from 'lodash/orderBy';
import { EasySwitchState } from '../store';
import { SyncMap, SyncState } from './sync.interface';
export const selectSyncStore = (state: EasySwitchState): SyncState => state.sync;
export const selectSync = (state: EasySwitchState): SyncMap => state.sync.syncs;
export const selectCreateSyncState = createSelector(selectSyncStore, (state) => state.creatingLoading);
export const selectSyncIds = createSelector(selectSync, (sync) => {
return Object.keys(sync);
});
export const selectSyncById = createSelector(
selectSync,
(_: EasySwitchState, ID: string) => ID,
(selectMap, ID) => selectMap[ID]
);
export const selectSyncIdsByDate = createSelector(selectSync, (sync) =>
orderBy(sync, 'startDate', 'desc').map((sync) => sync.id)
);
| 4,985
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/logic/sync/sync.slice.ts
|
import { createSlice } from '@reduxjs/toolkit';
import { EVENT_ACTIONS } from '@proton/shared/lib/constants';
import * as globalAction from '../actions';
import { changeCreateLoadingState, createSyncItem, loadSyncList, resumeSyncItem } from './sync.actions';
import { formatApiSync, formatApiSyncs } from './sync.helpers';
import { SyncMap, SyncState } from './sync.interface';
const initialState: SyncState = { listLoading: 'idle', creatingLoading: 'idle', syncs: {} };
const syncSlice = createSlice({
name: 'sync',
initialState,
reducers: {},
extraReducers: (builder) => {
builder.addCase(changeCreateLoadingState, (state, action) => {
state.creatingLoading = action.payload;
});
builder.addCase(createSyncItem.pending, (state) => {
state.creatingLoading = 'pending';
});
builder.addCase(createSyncItem.rejected, (state, action) => {
state.creatingLoading = 'failed';
state.apiErrorCode = action.payload?.Code;
state.apiErrorLabel = action.payload?.Error;
});
builder.addCase(createSyncItem.fulfilled, (state) => {
state.creatingLoading = 'success';
//reset error
delete state.apiErrorCode;
delete state.apiErrorLabel;
});
builder.addCase(resumeSyncItem.pending, (state) => {
state.creatingLoading = 'pending';
});
builder.addCase(resumeSyncItem.rejected, (state, action) => {
state.creatingLoading = 'failed';
state.apiErrorCode = action.payload?.Code;
state.apiErrorLabel = action.payload?.Error;
});
builder.addCase(resumeSyncItem.fulfilled, (state) => {
state.creatingLoading = 'success';
//reset error
delete state.apiErrorCode;
delete state.apiErrorLabel;
});
builder.addCase(loadSyncList.pending, (state) => {
state.listLoading = 'pending';
});
builder.addCase(loadSyncList.rejected, (state) => {
state.listLoading = 'failed';
});
builder.addCase(loadSyncList.fulfilled, (state, payload) => {
state.listLoading = 'success';
const syncs = formatApiSyncs(payload.payload.Syncs);
const formattedSync = syncs.reduce<SyncMap>((acc, sync) => {
acc[sync.id] = sync;
return acc;
}, {});
state.syncs = formattedSync;
});
builder.addCase(globalAction.event, (state, action) => {
const importerSyncs = action.payload.ImporterSyncs;
if (importerSyncs) {
importerSyncs.forEach(({ ImporterSync, Action, ID }) => {
if (ImporterSync) {
//The update or create are the same since we replace the state with new sync
if (EVENT_ACTIONS.CREATE === Action || EVENT_ACTIONS.UPDATE === Action) {
const newSync = formatApiSync(ImporterSync);
state.syncs[newSync.id] = newSync;
}
}
if (EVENT_ACTIONS.DELETE === Action) {
delete state.syncs[ID];
}
});
}
});
},
});
export default syncSlice.reducer;
| 4,986
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/tests/fakeCache.ts
|
import { ADDRESS_STATUS } from '@proton/shared/lib/constants';
import createCache from '@proton/shared/lib/helpers/cache';
import { Address, Key } from '@proton/shared/lib/interfaces';
import { STATUS } from '@proton/shared/lib/models/cache';
type CacheKeys = 'User' | 'Addresses' | 'Labels';
const resolvedRequest = <T>(
value: T
): {
status: STATUS;
value: T;
} => ({ status: STATUS.RESOLVED, value });
const cache = createCache();
const setToCache = (key: CacheKeys, value: any) => {
cache.set(key, resolvedRequest(value));
};
const getFromCache = (key: CacheKeys) => cache.get(key);
/**
* Sets the minimal required cache
*/
const setBaseCache = () => {
setToCache('User', { UsedSpace: 10, MaxSpace: 100 });
setToCache('Addresses', []);
setToCache('Labels', []);
};
/**
* Adds an address to the cache
* @param inputAddress
*/
const addAddressToCache = (inputAddress: Partial<Address>) => {
const address = {
ID: 'AddressID',
Keys: [{ ID: 'KeyID' } as Key],
Status: ADDRESS_STATUS.STATUS_ENABLED,
Send: 1,
Receive: 1,
...inputAddress,
} as Address;
const addressCache = cache.get('Addresses');
// @ts-expect-error
addressCache?.value?.push(address);
};
const fakeCache = {
instance: cache,
get: getFromCache,
set: setToCache,
setBase: setBaseCache,
addAddress: addAddressToCache,
};
export default fakeCache;
| 4,987
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/tests/render.tsx
|
import { ReactElement } from 'react';
import * as React from 'react';
import { Router } from 'react-router';
import { render as originalRender } from '@testing-library/react';
import { renderHook } from '@testing-library/react-hooks';
import { createMemoryHistory } from 'history';
import EasySwitchStoreProvider from '@proton/activation/src/logic/StoreProvider';
import {
ApiProvider,
CacheProvider,
EventManagerProvider,
EventModelListener,
ExperimentsProvider,
ModalsChildren,
ModalsProvider,
NotificationsContext,
} from '@proton/components';
import ConfigProvider from '@proton/components/containers/config/Provider';
import FeaturesProvider from '@proton/components/containers/features/FeaturesProvider';
import { APPS } from '@proton/shared/lib/constants';
import { ProtonConfig } from '@proton/shared/lib/interfaces';
import fakeCache from './fakeCache';
/**
* Mocks
*/
jest.mock('@proton/components/hooks/useEventManager.ts', () => {
const subscribe = jest.fn();
const call = jest.fn();
const stop = jest.fn();
const start = jest.fn();
const result = () => {
return { subscribe, call, stop, start };
};
result.subscribe = subscribe;
result.call = call;
result.stop = stop;
result.start = start;
return result;
});
const config = {
APP_NAME: APPS.PROTONACCOUNT,
APP_VERSION: 'test-version',
DATE_VERSION: 'test-date-version',
API_URL: 'http://localhost',
} as ProtonConfig;
const eventManager = {
setEventID: () => {},
getEventID: () => {},
start: () => {},
stop: () => {},
call: () => {
// @ts-ignore
return new Promise<void>();
},
reset: () => {},
} as any;
const notificationsManager = {
clearNotifications: () => {},
createNotification: () => 0,
hideNotification: () => {},
removeNotification: () => {},
removeDuplicate: () => {},
setOffset: () => {},
};
let history = createMemoryHistory();
export const EasySwitchTestProviders = ({ children }: { children: JSX.Element | (JSX.Element | null)[] | null }) => (
<ConfigProvider config={config}>
<NotificationsContext.Provider value={notificationsManager}>
<ModalsProvider>
<ApiProvider config={config}>
<EventManagerProvider eventManager={eventManager}>
<CacheProvider cache={fakeCache.instance}>
<FeaturesProvider>
<ExperimentsProvider>
<ModalsChildren />
<EventModelListener models={[]} />
<Router history={history}>
<EasySwitchStoreProvider>{children}</EasySwitchStoreProvider>
</Router>
</ExperimentsProvider>
</FeaturesProvider>
</CacheProvider>
</EventManagerProvider>
</ApiProvider>
</ModalsProvider>
</NotificationsContext.Provider>
</ConfigProvider>
);
export const easySwitchRender = (ui: ReactElement) => {
fakeCache.setBase();
const result = originalRender(<EasySwitchTestProviders>{ui}</EasySwitchTestProviders>);
return result;
};
const easySwitchHookWrapper = ({ children }: { children: any }) => {
return <EasySwitchTestProviders>{children}</EasySwitchTestProviders>;
};
export const easySwitchHookRender = (hook: any) => renderHook(() => hook(), { wrapper: easySwitchHookWrapper });
| 4,988
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/tests
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/tests/data/addresses.ts
|
import { ADDRESS_TYPE } from '@proton/shared/lib/constants';
import { Address, AddressKey } from '@proton/shared/lib/interfaces';
const activeKey: AddressKey = {
ID: 'key',
Primary: 1,
Active: 1,
Fingerprint: 'fingerprint',
Fingerprints: [],
PublicKey: 'PublicKey',
Version: 1,
PrivateKey: 'PrivateKey',
Signature: 'signature',
RecoverySecret: null,
RecoverySecretSignature: null,
Flags: 1,
AddressForwardingID: 'AddressForwardingID',
};
const disabledKey: AddressKey = {
...activeKey,
Active: 0,
};
export const generateMockAddress = (n: number, keyActive: boolean, type?: ADDRESS_TYPE): Address => {
return {
DisplayName: `Testing ${n}`,
DomainID: 'proton.ch',
Email: `testing${n}@proton.ch`,
HasKeys: 1,
ID: `ID-${n}`,
Keys: [keyActive ? activeKey : disabledKey],
SignedKeyList: null,
Order: 1,
Priority: 1,
Receive: 1,
Send: 1,
Signature: 'Testing signature',
Status: 1,
Type: type ?? 1,
ProtonMX: true,
ConfirmationState: 1,
CatchAll: false,
};
};
export const generateMockAddressArray = (n: number, keyActive: boolean, type?: ADDRESS_TYPE) => {
return Array.from(Array(n)).map((_, i) => generateMockAddress(i, keyActive, type));
};
| 4,989
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/tests
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/tests/data/folders.ts
|
import { FolderMapItem } from '@proton/activation/src/components/Modals/CustomizeMailImportModal/CustomizeMailImportModal.interface';
export const systemFolders = [
{
id: 'INBOX',
providerPath: ['INBOX'],
checked: true,
color: '#DB60D6',
systemFolder: 'Inbox',
isSystemFolderChild: false,
folderChildIDS: [],
protonPath: ['INBOX'],
separator: '/',
size: 0,
},
{
id: 'Sent',
providerPath: ['Sent'],
checked: true,
color: '#0A77A6',
systemFolder: 'Sent',
isSystemFolderChild: false,
folderChildIDS: [],
protonPath: ['Sent'],
separator: '/',
size: 1545215,
},
{
id: 'Drafts',
providerPath: ['Drafts'],
checked: true,
color: '#C44800',
systemFolder: 'Drafts',
isSystemFolderChild: false,
folderChildIDS: [],
protonPath: ['Drafts'],
separator: '/',
size: 0,
},
];
export const folderWithChildren: FolderMapItem[] = [
{
id: 'parent folder',
providerPath: ['parent folder'],
checked: true,
color: '#0A77A6',
isSystemFolderChild: false,
folderChildIDS: [
'parent folder/first child',
'parent folder/first child/another sub child',
'parent folder/first child/sub child',
'parent folder/second child',
],
protonPath: ['parent folder'],
separator: '/',
size: 0,
disabled: false,
errors: [],
isLabel: false,
category: undefined,
systemFolder: undefined,
folderParentID: undefined,
},
{
id: 'parent folder/first child',
providerPath: ['parent folder', 'first child'],
checked: true,
color: '#0A77A6',
isSystemFolderChild: false,
folderChildIDS: ['parent folder/first child/another sub child', 'parent folder/first child/sub child'],
folderParentID: 'parent folder',
protonPath: ['parent folder', 'first child'],
separator: '/',
size: 0,
disabled: false,
errors: [],
isLabel: false,
category: undefined,
systemFolder: undefined,
},
{
id: 'parent folder/first child/another sub child',
providerPath: ['parent folder', 'first child', 'another sub child'],
checked: true,
color: '#0A77A6',
isSystemFolderChild: false,
folderChildIDS: [],
folderParentID: 'parent folder/first child',
protonPath: ['parent folder', 'first child', 'another sub child'],
separator: '/',
size: 0,
disabled: false,
errors: [],
isLabel: false,
category: undefined,
systemFolder: undefined,
},
{
id: 'parent folder/first child/sub child',
providerPath: ['parent folder', 'first child', 'sub child'],
checked: true,
color: '#0A77A6',
isSystemFolderChild: false,
folderChildIDS: [],
folderParentID: 'parent folder/first child',
protonPath: ['parent folder', 'first child', 'sub child'],
separator: '/',
size: 0,
disabled: false,
errors: [],
isLabel: false,
category: undefined,
systemFolder: undefined,
},
{
id: 'parent folder/second child',
providerPath: ['parent folder', 'second child'],
checked: true,
color: '#0A77A6',
isSystemFolderChild: false,
folderChildIDS: [],
folderParentID: 'parent folder',
protonPath: ['parent folder', 'second child'],
separator: '/',
size: 0,
disabled: false,
errors: [],
isLabel: false,
category: undefined,
systemFolder: undefined,
},
];
export const getRenamedFolders = (newName: string) => {
return [
{
id: 'parent folder',
providerPath: ['parent folder'],
checked: true,
color: '#0A77A6',
isSystemFolderChild: false,
folderChildIDS: [
'parent folder/first child',
'parent folder/first child/another sub child',
'parent folder/first child/sub child',
'parent folder/second child',
],
protonPath: [newName],
separator: '/',
size: 0,
disabled: false,
errors: [],
isLabel: false,
category: undefined,
systemFolder: undefined,
folderParentID: undefined,
},
{
id: 'parent folder/first child',
providerPath: ['parent folder', 'first child'],
checked: true,
color: '#0A77A6',
isSystemFolderChild: false,
folderChildIDS: ['parent folder/first child/another sub child', 'parent folder/first child/sub child'],
folderParentID: 'parent folder',
protonPath: [newName, 'first child'],
separator: '/',
size: 0,
disabled: false,
errors: [],
isLabel: false,
category: undefined,
systemFolder: undefined,
},
{
id: 'parent folder/first child/another sub child',
providerPath: ['parent folder', 'first child', 'another sub child'],
checked: true,
color: '#0A77A6',
isSystemFolderChild: false,
folderChildIDS: [],
folderParentID: 'parent folder/first child',
protonPath: [newName, 'first child', 'another sub child'],
separator: '/',
size: 0,
disabled: false,
errors: [],
isLabel: false,
category: undefined,
systemFolder: undefined,
},
{
id: 'parent folder/first child/sub child',
providerPath: ['parent folder', 'first child', 'sub child'],
checked: true,
color: '#0A77A6',
isSystemFolderChild: false,
folderChildIDS: [],
folderParentID: 'parent folder/first child',
protonPath: [newName, 'first child', 'sub child'],
separator: '/',
size: 0,
disabled: false,
errors: [],
isLabel: false,
category: undefined,
systemFolder: undefined,
},
{
id: 'parent folder/second child',
providerPath: ['parent folder', 'second child'],
checked: true,
color: '#0A77A6',
isSystemFolderChild: false,
folderChildIDS: [],
folderParentID: 'parent folder',
protonPath: [newName, 'second child'],
separator: '/',
size: 0,
disabled: false,
errors: [],
isLabel: false,
category: undefined,
systemFolder: undefined,
},
];
};
| 4,990
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/tests
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/tests/data/gmail.formattedResponse.ts
|
export const standardFolderResponse = {
ImporterID: 'importerID',
Mail: {
AddressID: 'ID',
Mapping: [
{
Source: 'Inbox',
Destinations: {
FolderPath: 'Inbox',
},
checked: true,
},
{
Source: 'Forums',
Destinations: {
FolderPath: 'Inbox',
Category: 'Forums',
},
checked: true,
},
{
Source: 'Updates',
Destinations: {
FolderPath: 'Inbox',
Category: 'Updates',
},
checked: true,
},
{
Source: 'Promotions',
Destinations: {
FolderPath: 'Inbox',
Category: 'Promotions',
},
checked: true,
},
{
Source: 'Social',
Destinations: {
FolderPath: 'Inbox',
Category: 'Social',
},
checked: true,
},
{
Source: 'Sent',
Destinations: {
FolderPath: 'Sent',
},
checked: true,
},
{
Source: 'Drafts',
Destinations: {
FolderPath: 'Drafts',
},
checked: true,
},
{
Source: 'Starred',
Destinations: {
FolderPath: 'Starred',
},
checked: true,
},
{
Source: 'Archive',
Destinations: {
FolderPath: 'Archive',
},
checked: true,
},
{
Source: 'a folder name',
Destinations: {
Labels: [
{
Name: 'a folder name',
Color: '#8080FF',
},
],
},
checked: true,
},
{
Source: 'aaa',
Destinations: {
Labels: [
{
Name: 'aaa',
Color: '#8080FF',
},
],
},
checked: true,
},
{
Source: 'aaa/child a',
Destinations: {
Labels: [
{
Name: 'aaa-child a',
Color: '#8080FF',
},
],
},
checked: true,
},
{
Source: 'aaa/child aa',
Destinations: {
Labels: [
{
Name: 'aaa-child aa',
Color: '#8080FF',
},
],
},
checked: true,
},
{
Source: 'aaa/child aaa',
Destinations: {
Labels: [
{
Name: 'aaa-child aaa',
Color: '#8080FF',
},
],
},
checked: true,
},
{
Source: 'hello another test',
Destinations: {
Labels: [
{
Name: 'hello another test',
Color: '#8080FF',
},
],
},
checked: true,
},
{
Source: 'hello another test/a child test',
Destinations: {
Labels: [
{
Name: 'hello another test-a child test',
Color: '#8080FF',
},
],
},
checked: true,
},
{
Source: 'hello another test/a child test/a child of child',
Destinations: {
Labels: [
{
Name: 'hello another test-a child test-a child of child',
Color: '#8080FF',
},
],
},
checked: true,
},
{
Source: 'hello another test/another child test',
Destinations: {
Labels: [
{
Name: 'hello another test-another child test',
Color: '#8080FF',
},
],
},
checked: true,
},
{
Source: 'Important',
Destinations: {
Labels: [
{
Name: 'Important',
Color: '#8080FF',
},
],
},
checked: true,
},
],
StartTime: undefined,
Code: 'password',
CustomFields: 7,
ImportLabel: {
Color: '#fff',
Name: 'label',
Type: 1,
},
},
};
| 4,991
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/tests
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/tests/data/gmail.imap.formattedResponse.ts
|
export const gmailImapResponse = {
ImporterID: 'importerID',
Mail: {
AddressID: 'ID',
Mapping: [
{
Source: 'INBOX',
Destinations: { FolderPath: 'Inbox' },
checked: true,
},
{
Source: '[Gmail]/Sent Mail',
Destinations: { FolderPath: 'Sent' },
checked: true,
},
{
Source: '[Gmail]/Drafts',
Destinations: { FolderPath: 'Drafts' },
checked: true,
},
{
Source: '[Gmail]/Starred',
Destinations: { FolderPath: 'Starred' },
checked: true,
},
{
Source: '[Gmail]/All Mail',
Destinations: { FolderPath: 'All Mail' },
checked: true,
},
{
Source: 'Important',
Destinations: {
Labels: [
{
Name: 'Important',
Color: '#8080FF',
},
],
},
checked: true,
},
],
Code: 'password',
CustomFields: 7,
ImportLabel: {
Color: '#fff',
Name: 'label',
Type: 1,
},
},
};
| 4,992
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/tests
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/tests/data/gmail.imap.providerFolders.ts
|
const gmailImapModalLabels = [
{
Source: 'INBOX',
Separator: '/',
Flags: ['HasNoChildren'],
DestinationFolder: 'Inbox',
},
{
Source: '[Gmail]/Sent Mail',
Separator: '/',
Flags: ['HasNoChildren', 'Sent'],
DestinationFolder: 'Sent',
},
{
Source: '[Gmail]/Drafts',
Separator: '/',
Flags: ['Drafts', 'HasNoChildren'],
DestinationFolder: 'Drafts',
},
{
Source: '[Gmail]/Starred',
Separator: '/',
Flags: ['Flagged', 'HasNoChildren'],
DestinationFolder: 'Starred',
},
{
Source: '[Gmail]/All Mail',
Separator: '/',
Flags: ['All', 'HasNoChildren'],
DestinationFolder: 'All Mail',
},
{
Source: 'Important',
Separator: '/',
Flags: ['HasChildren'],
},
];
export default gmailImapModalLabels;
| 4,993
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/tests
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/tests/data/gmail.providerFolders.ts
|
const labels = [
{
Source: 'Inbox',
Separator: '/',
Flags: [],
DestinationFolder: 'Inbox',
},
{
Source: 'Forums',
Separator: '/',
Flags: [],
DestinationFolder: 'Inbox',
DestinationCategory: 'Forums',
},
{
Source: 'Updates',
Separator: '/',
Flags: [],
DestinationFolder: 'Inbox',
DestinationCategory: 'Updates',
},
{
Source: 'Promotions',
Separator: '/',
Flags: [],
DestinationFolder: 'Inbox',
DestinationCategory: 'Promotions',
},
{
Source: 'Social',
Separator: '/',
Flags: [],
DestinationFolder: 'Inbox',
DestinationCategory: 'Social',
},
{
Source: 'Sent',
Separator: '/',
Flags: [],
DestinationFolder: 'Sent',
},
{
Source: 'Drafts',
Separator: '/',
Flags: [],
DestinationFolder: 'Drafts',
},
{
Source: 'Starred',
Separator: '/',
Flags: [],
DestinationFolder: 'Starred',
},
{
Source: 'Archive',
Separator: null,
Flags: [],
DestinationFolder: 'Archive',
},
{
Source: 'a folder name',
Separator: '/',
Flags: [],
},
{
Source: 'aaa',
Separator: '/',
Flags: [],
},
{
Source: 'aaa/child a',
Separator: '/',
Flags: [],
},
{
Source: 'aaa/child aa',
Separator: '/',
Flags: [],
},
{
Source: 'aaa/child aaa',
Separator: '/',
Flags: [],
},
{
Source: 'hello another test',
Separator: '/',
Flags: [],
},
{
Source: 'hello another test/a child test',
Separator: '/',
Flags: [],
},
{
Source: 'hello another test/a child test/a child of child',
Separator: '/',
Flags: [],
},
{
Source: 'hello another test/another child test',
Separator: '/',
Flags: [],
},
{
Source: 'Important',
Separator: '/',
Flags: [],
},
];
export default labels;
| 4,994
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/tests
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/tests/data/outlook.providerfolders.ts
|
const data = [
{
Source: 'Inbox',
Separator: '/',
Flags: [],
DestinationFolder: 'Inbox',
},
{
Source: 'Sent Items',
Separator: '/',
Flags: [],
DestinationFolder: 'Sent',
},
{
Source: 'Drafts',
Separator: '/',
Flags: [],
DestinationFolder: 'Drafts',
},
{
Source: 'Archive',
Separator: '/',
Flags: [],
DestinationFolder: 'Archive',
},
{
Source: 'a really long folder name which should fail in this situation dsude because the name is really really really really long no ? what do you think ? I think it fails',
Separator: '/',
Flags: [],
},
{
Source: 'A test folder',
Separator: '/',
Flags: [],
},
{
Source: 'A test folder/A test subfolder',
Separator: '/',
Flags: [],
},
{
Source: 'A test folder/sub folder',
Separator: '/',
Flags: [],
},
{
Source: 'A test folder/sub folder/sub sub folder',
Separator: '/',
Flags: [],
},
{
Source: 'A test folder/sub folder/sub sub folder/sub sub sub folder should be 2 lvl deep only',
Separator: '/',
Flags: [],
},
{
Source: 'child folder with system folder name should be ok',
Separator: '/',
Flags: [],
},
{
Source: 'child folder with system folder name should be ok/INBOX',
Separator: '/',
Flags: [],
},
{
Source: 'just/slashes',
Separator: '/',
Flags: [],
},
{
Source: 'just\\backslashes',
Separator: '/',
Flags: [],
},
{
Source: 'Scheduled',
Separator: '/',
Flags: [],
},
{
Source: 'slashe/backslash\\etvoila',
Separator: '/',
Flags: [],
},
{
Source: 'slashes////backslashes\\\\\\\\etvoila',
Separator: '/',
Flags: [],
},
{
Source: 'test slashes/in/name/then\\backslashes/the backslash and slash\\/dude',
Separator: '/',
Flags: [],
},
{
Source: 'test slashes/in/name/then\\backslashes/the backslash and slash\\/dude/subfolder/with/\\slashes:é&êspecial=)characters',
Separator: '/',
Flags: [],
},
];
export default data;
| 4,995
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/tests
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/tests/data/prepareState.ts
|
import {
ImportProvider,
ImportType,
MailImportDestinationFolder,
MailImportGmailCategories,
TIME_PERIOD,
} from '@proton/activation/src/interface';
import { OauthDraftState } from '@proton/activation/src/logic/draft/oauthDraft/oauthDraft.interface';
import { generateMockAddress } from './addresses';
export const prepareState: OauthDraftState = {
step: 'started',
provider: ImportProvider.GOOGLE,
mailImport: {
step: 'prepare-import',
products: [ImportType.MAIL, ImportType.CALENDAR, ImportType.CONTACTS],
importerData: {
importerId: 'importerId',
importedEmail: 'easyflavien@gmail.com',
emails: {
fields: {
importAddress: generateMockAddress(0, true),
importPeriod: TIME_PERIOD.LAST_3_MONTHS,
importCategoriesDestination: MailImportDestinationFolder.INBOX,
importLabel: {
Name: 'gmail.com 09-01-2023 09:34',
Color: '#3CBB3A',
Type: 1,
},
mapping: [
{
id: 'Inbox',
providerPath: ['Inbox'],
checked: true,
color: '#B4A40E',
folderParentID: undefined,
systemFolder: MailImportDestinationFolder.INBOX,
isSystemFolderChild: false,
category: undefined,
folderChildIDS: [],
protonPath: ['Inbox'],
separator: '/',
size: 0,
},
{
id: 'Forums',
providerPath: ['Forums'],
category: MailImportGmailCategories.FORUMS,
checked: true,
folderParentID: undefined,
color: '#DB60D6',
systemFolder: MailImportDestinationFolder.INBOX,
isSystemFolderChild: false,
folderChildIDS: [],
protonPath: ['Forums'],
separator: '/',
size: 0,
},
{
id: 'Updates',
providerPath: ['Updates'],
category: MailImportGmailCategories.UPDATES,
checked: true,
color: '#A839A4',
folderParentID: undefined,
systemFolder: MailImportDestinationFolder.INBOX,
isSystemFolderChild: false,
folderChildIDS: [],
protonPath: ['Updates'],
separator: '/',
size: 0,
},
{
id: 'Promotions',
providerPath: ['Promotions'],
category: MailImportGmailCategories.PROMOTIONS,
checked: true,
color: '#5252CC',
folderParentID: undefined,
systemFolder: MailImportDestinationFolder.INBOX,
isSystemFolderChild: false,
folderChildIDS: [],
protonPath: ['Promotions'],
separator: '/',
size: 0,
},
{
id: 'Social',
providerPath: ['Social'],
category: MailImportGmailCategories.SOCIAL,
checked: true,
color: '#B4A40E',
folderParentID: undefined,
systemFolder: MailImportDestinationFolder.INBOX,
isSystemFolderChild: false,
folderChildIDS: [],
protonPath: ['Social'],
separator: '/',
size: 0,
},
{
id: 'Sent',
providerPath: ['Sent'],
checked: true,
color: '#5252CC',
category: undefined,
folderParentID: undefined,
systemFolder: MailImportDestinationFolder.SENT,
isSystemFolderChild: false,
folderChildIDS: [],
protonPath: ['Sent'],
separator: '/',
size: 0,
},
{
id: 'Drafts',
providerPath: ['Drafts'],
checked: true,
color: '#DB60D6',
category: undefined,
folderParentID: undefined,
systemFolder: MailImportDestinationFolder.DRAFTS,
isSystemFolderChild: false,
folderChildIDS: [],
protonPath: ['Drafts'],
separator: '/',
size: 0,
},
{
id: 'Starred',
providerPath: ['Starred'],
checked: true,
color: '#5252CC',
category: undefined,
folderParentID: undefined,
systemFolder: MailImportDestinationFolder.STARRED,
isSystemFolderChild: false,
folderChildIDS: [],
protonPath: ['Starred'],
separator: '/',
size: 0,
},
{
id: 'Important',
providerPath: ['Important'],
checked: true,
color: '#8080FF',
folderChildIDS: [],
category: undefined,
systemFolder: undefined,
isSystemFolderChild: false,
folderParentID: undefined,
protonPath: ['Important'],
separator: '/',
size: 0,
},
{
id: 'Schedule',
providerPath: ['Schedule'],
checked: true,
color: '#1DA583',
folderChildIDS: [],
category: undefined,
systemFolder: undefined,
isSystemFolderChild: false,
folderParentID: undefined,
protonPath: ['Schedule'],
separator: '/',
size: 0,
},
{
id: 'test',
providerPath: ['test'],
checked: true,
color: '#807304',
category: undefined,
systemFolder: undefined,
isSystemFolderChild: false,
folderParentID: undefined,
folderChildIDS: ['test/Schedule', 'test/Schedule/hello', 'test/Scheduled'],
protonPath: ['test'],
separator: '/',
size: 0,
},
{
id: 'test/Schedule',
providerPath: ['test', 'Schedule'],
checked: true,
color: '#807304',
category: undefined,
systemFolder: undefined,
isSystemFolderChild: false,
folderParentID: undefined,
folderChildIDS: ['test/Schedule/hello'],
protonPath: ['test-Schedule'],
separator: '/',
size: 0,
},
{
id: 'test/Schedule/hello',
providerPath: ['test', 'Schedule', 'hello'],
checked: true,
color: '#807304',
folderChildIDS: [],
category: undefined,
systemFolder: undefined,
isSystemFolderChild: false,
folderParentID: 'test/Schedule',
protonPath: ['test-Schedule-hello'],
separator: '/',
size: 0,
},
{
id: 'test/Scheduled',
providerPath: ['test', 'Scheduled'],
checked: true,
color: '#807304',
folderChildIDS: [],
category: undefined,
systemFolder: undefined,
isSystemFolderChild: false,
folderParentID: 'test',
protonPath: ['test-Scheduled'],
separator: '/',
size: 0,
},
],
},
},
calendars: {
calendars: [
{
id: 'easyflavien@gmail.com',
source: 'easyflavien@gmail.com',
description: '',
checked: true,
},
{
id: '5245558e2814165719009b25011d988f038c0d7ab37e1509cb7641e5f893f6f5@group.calendar.google.com',
source: 'Agenda temp',
description: '',
checked: true,
},
{
id: '571814dc052c54d2dda066ea0694ea43658b395dbc46d7c4bdcedea8aa91a958@group.calendar.google.com',
source: 'Meeting',
description: 'test',
checked: true,
},
],
},
contacts: {},
},
},
};
| 4,996
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/tests
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/tests/data/yahoo.providerfolders.ts
|
const data = [
{
Source: 'Inbox',
Separator: '/',
Flags: ['HasNoChildren'],
DestinationFolder: 'Inbox',
},
{
Source: 'Sent',
Separator: '/',
Flags: ['Sent', 'HasNoChildren'],
DestinationFolder: 'Sent',
},
{
Source: 'Draft',
Separator: '/',
Flags: ['Drafts', 'HasNoChildren'],
DestinationFolder: 'Drafts',
},
{
Source: 'Archive',
Separator: '/',
Flags: ['Archive', 'HasNoChildren'],
DestinationFolder: 'Archive',
},
{
Source: 'another test foldr with a really long name hey hye hey',
Separator: '/',
Flags: ['HasNoChildren'],
},
{
Source: "Spéciæl charaters-&'(yeah",
Separator: '/',
Flags: ['HasChildren'],
},
{
Source: "Spéciæl charaters-&'(yeah/sub spécïªl charaters",
Separator: '/',
Flags: ['HasNoChildren'],
},
{
Source: 'Test folder',
Separator: '/',
Flags: ['HasChildren'],
},
{
Source: 'Test folder/a test folder with big name',
Separator: '/',
Flags: ['HasChildren'],
},
{
Source: 'Test folder/a test folder with big name/a sub sub folder',
Separator: '/',
Flags: ['HasNoChildren'],
},
];
export default data;
| 4,997
|
0
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/tests
|
petrpan-code/ProtonMail/WebClients/packages/activation/src/tests/mock/ResizeObserver.ts
|
class ResizeObserver {
observe() {
// do nothing
}
unobserve() {
// do nothing
}
disconnect() {
// do nothing
}
}
export default ResizeObserver;
| 4,998
|
0
|
petrpan-code/ProtonMail/WebClients/packages
|
petrpan-code/ProtonMail/WebClients/packages/atoms/.eslintrc.js
|
module.exports = {
extends: ['@proton/eslint-config-proton', 'plugin:storybook/recommended'],
parser: '@typescript-eslint/parser',
env: {
jasmine: true,
},
parserOptions: {
tsconfigRootDir: __dirname,
project: './tsconfig.json',
},
rules: {},
ignorePatterns: ['.eslintrc.js'],
};
| 4,999
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.