712 lines
29 KiB
JavaScript
712 lines
29 KiB
JavaScript
'use strict';
|
|
|
|
import React from "react";
|
|
import {ACEEditor, AlignedRow, Dropdown, StaticField, TableSelect} from "../lib/form";
|
|
import 'ace-builds/src-noconflict/mode-text';
|
|
import 'ace-builds/src-noconflict/mode-html';
|
|
|
|
import {MosaicoHost} from "../lib/sandboxed-mosaico";
|
|
import {CKEditorHost} from "../lib/sandboxed-ckeditor";
|
|
import {GrapesJSHost} from "../lib/sandboxed-grapesjs";
|
|
import {CodeEditorHost} from "../lib/sandboxed-codeeditor";
|
|
|
|
import {getGrapesJSSourceTypeOptions, GrapesJSSourceType} from "../lib/sandboxed-grapesjs-shared";
|
|
|
|
import {CodeEditorSourceType, getCodeEditorSourceTypeOptions} from "../lib/sandboxed-codeeditor-shared";
|
|
|
|
import {getTemplateTypes as getMosaicoTemplateTypes} from './mosaico/helpers';
|
|
import {getSandboxUrl} from "../lib/urls";
|
|
import mailtrainConfig from 'mailtrainConfig';
|
|
import {ActionLink, Button} from "../lib/bootstrap-components";
|
|
import {Trans} from "react-i18next";
|
|
import {TagLanguages, renderTag} from "../../../shared/templates";
|
|
|
|
import styles from "../lib/styles.scss";
|
|
|
|
export const ResourceType = {
|
|
TEMPLATE: 'template',
|
|
CAMPAIGN: 'campaign'
|
|
};
|
|
|
|
export function getTagLanguages(t) {
|
|
return {
|
|
[TagLanguages.SIMPLE]: {
|
|
name: t('Simple')
|
|
},
|
|
[TagLanguages.HBS]: {
|
|
name: t('Handlebars')
|
|
}
|
|
};
|
|
}
|
|
|
|
export function getTemplateTypes(t, prefix = '', entityTypeId = ResourceType.TEMPLATE, allowEmpty = false) {
|
|
// The prefix is used to to enable use within other forms (i.e. campaign form)
|
|
const templateTypes = {};
|
|
|
|
function initFieldsIfMissing(mutState, templateType) {
|
|
const initVals = templateTypes[templateType].initData();
|
|
|
|
for (const key in initVals) {
|
|
if (!mutState.hasIn([key])) {
|
|
mutState.setIn([key, 'value'], initVals[key]);
|
|
}
|
|
}
|
|
}
|
|
|
|
function clearBeforeSave(data) {
|
|
for (const templateKey in templateTypes) {
|
|
const initVals = templateTypes[templateKey].initData();
|
|
for (const fieldKey in initVals) {
|
|
delete data[fieldKey];
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
const mosaicoTemplateTypes = getMosaicoTemplateTypes(t);
|
|
const mosaicoTemplatesColumns = [
|
|
{
|
|
data: 1,
|
|
title: t('name')
|
|
},
|
|
{
|
|
data: 2,
|
|
title: t('description')
|
|
},
|
|
{
|
|
data: 3,
|
|
title: t('type'),
|
|
render: data => mosaicoTemplateTypes[data].typeName
|
|
},
|
|
{
|
|
data: 6,
|
|
title: t('namespace')
|
|
},
|
|
];
|
|
|
|
templateTypes.mosaico = {
|
|
typeName: t('mosaico'),
|
|
getTypeForm: (owner, isEdit) => {
|
|
const tagLanguageKey = owner.getFormValue(prefix + 'tag_language');
|
|
if (tagLanguageKey) {
|
|
return <TableSelect
|
|
id={prefix + 'mosaicoTemplate'}
|
|
label={t('mosaicoTemplate')}
|
|
withHeader
|
|
dropdown
|
|
dataUrl={`rest/mosaico-templates-by-tag-language-table/${tagLanguageKey}`}
|
|
columns={mosaicoTemplatesColumns}
|
|
selectionLabelIndex={1}
|
|
disabled={isEdit}
|
|
withClear={allowEmpty}
|
|
/>
|
|
} else {
|
|
return null;
|
|
}
|
|
},
|
|
getHTMLEditor: owner =>
|
|
<AlignedRow
|
|
label={t('templateContentHtml')}>
|
|
<MosaicoHost
|
|
ref={owner.editorNodeRefHandler}
|
|
entity={owner.props.entity}
|
|
initialModel={owner.getFormValue(prefix + 'mosaicoData').model}
|
|
initialMetadata={owner.getFormValue(prefix + 'mosaicoData').metadata}
|
|
templateId={owner.getFormValue(prefix + 'mosaicoTemplate')}
|
|
entityTypeId={entityTypeId}
|
|
title={t('mosaicoTemplateDesigner')}
|
|
onSave={::owner.save}
|
|
canSave={owner.isFormWithoutErrors()}
|
|
onTestSend={::owner.showTestSendModal}
|
|
onShowExport={::owner.showExportModal}
|
|
onFullscreenAsync={::owner.setElementInFullscreen}
|
|
/>
|
|
</AlignedRow>,
|
|
exportHTMLEditorData: async owner => {
|
|
const state = await owner.editorNode.exportState();
|
|
// If the sandbox is still loading, the exportState returns null.
|
|
if (state) {
|
|
return {
|
|
[prefix + 'html']: state.html,
|
|
[prefix + 'mosaicoData']: {
|
|
metadata: state.metadata,
|
|
model: state.model
|
|
}
|
|
};
|
|
} else {
|
|
return null;
|
|
}
|
|
},
|
|
exportContent: async (owner, contentType) => {
|
|
const {html, metadata, model} = await owner.editorNode.exportState();
|
|
if (contentType === 'html') return html;
|
|
return null;
|
|
},
|
|
initData: () => ({
|
|
[prefix + 'mosaicoTemplate']: null,
|
|
[prefix + 'mosaicoData']: {}
|
|
}),
|
|
afterLoad: data => {
|
|
data[prefix + 'mosaicoTemplate'] = data[prefix + 'data'].mosaicoTemplate;
|
|
data[prefix + 'mosaicoData'] = {
|
|
metadata: data[prefix + 'data'].metadata,
|
|
model: data[prefix + 'data'].model
|
|
};
|
|
},
|
|
beforeSave: data => {
|
|
data[prefix + 'data'] = {
|
|
mosaicoTemplate: data[prefix + 'mosaicoTemplate'],
|
|
metadata: data[prefix + 'mosaicoData'].metadata,
|
|
model: data[prefix + 'mosaicoData'].model
|
|
};
|
|
clearBeforeSave(data);
|
|
},
|
|
afterTypeChange: mutState => {
|
|
initFieldsIfMissing(mutState, 'mosaico');
|
|
},
|
|
afterTagLanguageChange: (mutState, isEdit) => {
|
|
if (!isEdit) {
|
|
mutState.setIn([prefix + 'mosaicoTemplate', 'value'], null);
|
|
}
|
|
},
|
|
validate: state => {
|
|
const mosaicoTemplate = state.getIn([prefix + 'mosaicoTemplate', 'value']);
|
|
if (!allowEmpty && !mosaicoTemplate) {
|
|
state.setIn([prefix + 'mosaicoTemplate', 'error'], t('mosaicoTemplateMustBeSelected'));
|
|
}
|
|
}
|
|
};
|
|
|
|
const mosaicoFsTemplatesOptions = mailtrainConfig.mosaico.fsTemplates;
|
|
const mosaicoFsTemplatesLabels = new Map(mailtrainConfig.mosaico.fsTemplates.map(({key, label}) => ([key, label])));
|
|
|
|
templateTypes.mosaicoWithFsTemplate = {
|
|
typeName: t('mosaicoWithPredefinedTemplates'),
|
|
getTypeForm: (owner, isEdit) => {
|
|
if (isEdit) {
|
|
return <StaticField
|
|
id={prefix + 'mosaicoFsTemplate'}
|
|
className={styles.formDisabled}
|
|
label={t('mosaicoTemplate-1')}>{mosaicoFsTemplatesLabels.get(owner.getFormValue(prefix + 'mosaicoFsTemplate'))}</StaticField>;
|
|
} else {
|
|
return <Dropdown
|
|
id={prefix + 'mosaicoFsTemplate'}
|
|
label={t('mosaicoTemplate-1')}
|
|
options={mosaicoFsTemplatesOptions}/>;
|
|
}
|
|
},
|
|
getHTMLEditor: owner =>
|
|
<AlignedRow
|
|
label={t('templateContentHtml')}>
|
|
<MosaicoHost
|
|
ref={owner.editorNodeRefHandler}
|
|
entity={owner.props.entity}
|
|
initialModel={owner.getFormValue(prefix + 'mosaicoData').model}
|
|
initialMetadata={owner.getFormValue(prefix + 'mosaicoData').metadata}
|
|
templatePath={getSandboxUrl(`static/mosaico/templates/${owner.getFormValue(prefix + 'mosaicoFsTemplate')}/template-${owner.getFormValue(prefix + 'mosaicoFsTemplate')}.html`)}
|
|
entityTypeId={entityTypeId}
|
|
title={t('mosaicoTemplateDesigner')}
|
|
onSave={::owner.save}
|
|
canSave={owner.isFormWithoutErrors()}
|
|
onTestSend={::owner.showTestSendModal}
|
|
onShowExport={::owner.showExportModal}
|
|
onFullscreenAsync={::owner.setElementInFullscreen}
|
|
/>
|
|
</AlignedRow>,
|
|
exportHTMLEditorData: async owner => {
|
|
const state = await owner.editorNode.exportState();
|
|
// If the sandbox is still loading, the exportState returns null.
|
|
if (state) {
|
|
return {
|
|
[prefix + 'html']: state.html,
|
|
[prefix + 'mosaicoData']: {
|
|
metadata: state.metadata,
|
|
model: state.model
|
|
}
|
|
};
|
|
} else {
|
|
return null;
|
|
}
|
|
},
|
|
exportContent: async (owner, contentType) => {
|
|
const {html, metadata, model} = await owner.editorNode.exportState();
|
|
if (contentType === 'html') return html;
|
|
return null;
|
|
},
|
|
initData: () => ({
|
|
[prefix + 'mosaicoFsTemplate']: mailtrainConfig.mosaico.fsTemplates[0].key,
|
|
[prefix + 'mosaicoData']: {}
|
|
}),
|
|
afterLoad: data => {
|
|
data[prefix + 'mosaicoFsTemplate'] = data[prefix + 'data'].mosaicoFsTemplate;
|
|
data[prefix + 'mosaicoData'] = {
|
|
metadata: data[prefix + 'data'].metadata,
|
|
model: data[prefix + 'data'].model
|
|
};
|
|
},
|
|
beforeSave: data => {
|
|
data[prefix + 'data'] = {
|
|
mosaicoFsTemplate: data[prefix + 'mosaicoFsTemplate'],
|
|
metadata: data[prefix + 'mosaicoData'].metadata,
|
|
model: data[prefix + 'mosaicoData'].model
|
|
};
|
|
clearBeforeSave(data);
|
|
},
|
|
afterTypeChange: mutState => {
|
|
initFieldsIfMissing(mutState, 'mosaicoWithFsTemplate');
|
|
},
|
|
afterTagLanguageChange: (mutState, isEdit) => {
|
|
},
|
|
validate: state => {
|
|
}
|
|
};
|
|
|
|
|
|
const grapesJSSourceTypes = getGrapesJSSourceTypeOptions(t);
|
|
const grapesJSSourceTypeLabels = {};
|
|
for (const srcType of grapesJSSourceTypes) {
|
|
grapesJSSourceTypeLabels[srcType.key] = srcType.label;
|
|
}
|
|
|
|
templateTypes.grapesjs = {
|
|
typeName: t('grapesJs'),
|
|
getTypeForm: (owner, isEdit) => {
|
|
if (isEdit) {
|
|
return <StaticField
|
|
id={prefix + 'grapesJSSourceType'}
|
|
className={styles.formDisabled}
|
|
label={t('content')}>{grapesJSSourceTypeLabels[owner.getFormValue(prefix + 'grapesJSSourceType')]}</StaticField>;
|
|
} else {
|
|
return <Dropdown
|
|
id={prefix + 'grapesJSSourceType'}
|
|
label={t('content')}
|
|
options={grapesJSSourceTypes}/>;
|
|
}
|
|
},
|
|
getHTMLEditor: owner =>
|
|
<AlignedRow
|
|
label={t('templateContentHtml')}>
|
|
<GrapesJSHost
|
|
ref={owner.editorNodeRefHandler}
|
|
entity={owner.props.entity}
|
|
entityTypeId={entityTypeId}
|
|
initialSource={owner.getFormValue(prefix + 'grapesJSData').source}
|
|
initialStyle={owner.getFormValue(prefix + 'grapesJSData').style}
|
|
sourceType={owner.getFormValue(prefix + 'grapesJSSourceType')}
|
|
title={t('grapesJsTemplateDesigner')}
|
|
onSave={::owner.save}
|
|
canSave={owner.isFormWithoutErrors()}
|
|
onTestSend={::owner.showTestSendModal}
|
|
onShowExport={::owner.showExportModal}
|
|
onFullscreenAsync={::owner.setElementInFullscreen}
|
|
/>
|
|
</AlignedRow>,
|
|
exportHTMLEditorData: async owner => {
|
|
const state = await owner.editorNode.exportState();
|
|
// If the sandbox is still loading, the exportState returns null.
|
|
if (state) {
|
|
return {
|
|
[prefix + 'html']: state.html,
|
|
[prefix + 'grapesJSData']: {
|
|
source: state.source,
|
|
style: state.style
|
|
}
|
|
};
|
|
} else {
|
|
return null;
|
|
}
|
|
},
|
|
exportContent: async (owner, contentType) => {
|
|
const {html, source, style} = await owner.editorNode.exportState();
|
|
if (contentType === 'html') return html;
|
|
if (contentType === 'mjml') return source;
|
|
return null;
|
|
},
|
|
initData: () => ({
|
|
[prefix + 'grapesJSSourceType']: GrapesJSSourceType.MJML,
|
|
[prefix + 'grapesJSData']: {}
|
|
}),
|
|
afterLoad: data => {
|
|
data[prefix + 'grapesJSSourceType'] = data[prefix + 'data'].sourceType;
|
|
data[prefix + 'grapesJSData'] = {
|
|
source: data[prefix + 'data'].source,
|
|
style: data[prefix + 'data'].style
|
|
};
|
|
},
|
|
beforeSave: data => {
|
|
data[prefix + 'data'] = {
|
|
sourceType: data[prefix + 'grapesJSSourceType'],
|
|
source: data[prefix + 'grapesJSData'].source,
|
|
style: data[prefix + 'grapesJSData'].style
|
|
};
|
|
clearBeforeSave(data);
|
|
},
|
|
afterTypeChange: mutState => {
|
|
initFieldsIfMissing(mutState, 'grapesjs');
|
|
},
|
|
afterTagLanguageChange: (mutState, isEdit) => {
|
|
},
|
|
validate: state => {
|
|
}
|
|
};
|
|
|
|
templateTypes.ckeditor4 = {
|
|
typeName: t('ckEditor4'),
|
|
getTypeForm: (owner, isEdit) => null,
|
|
getHTMLEditor: owner =>
|
|
<AlignedRow
|
|
label={t('templateContentHtml')}>
|
|
<CKEditorHost
|
|
ref={owner.editorNodeRefHandler}
|
|
entity={owner.props.entity}
|
|
initialSource={owner.getFormValue(prefix + 'ckeditor4Data').source}
|
|
entityTypeId={entityTypeId}
|
|
title={t('ckEditor4TemplateDesigner')}
|
|
onSave={::owner.save}
|
|
canSave={owner.isFormWithoutErrors()}
|
|
onTestSend={::owner.showTestSendModal}
|
|
onShowExport={::owner.showExportModal}
|
|
onFullscreenAsync={::owner.setElementInFullscreen}
|
|
/>
|
|
</AlignedRow>,
|
|
exportHTMLEditorData: async owner => {
|
|
const state = await owner.editorNode.exportState();
|
|
// If the sandbox is still loading, the exportState returns null.
|
|
if (state) {
|
|
return {
|
|
[prefix + 'html']: state.html,
|
|
[prefix + 'ckeditor4Data']: {
|
|
source: state.source
|
|
}
|
|
};
|
|
} else {
|
|
return null;
|
|
}
|
|
},
|
|
exportContent: async (owner, contentType) => {
|
|
const {html, source} = await owner.editorNode.exportState();
|
|
if (contentType === 'html') return html;
|
|
return null;
|
|
},
|
|
initData: () => ({
|
|
[prefix + 'ckeditor4Data']: {}
|
|
}),
|
|
afterLoad: data => {
|
|
data[prefix + 'ckeditor4Data'] = {
|
|
source: data[prefix + 'data'].source
|
|
};
|
|
},
|
|
beforeSave: data => {
|
|
data[prefix + 'data'] = {
|
|
source: data[prefix + 'ckeditor4Data'].source,
|
|
};
|
|
clearBeforeSave(data);
|
|
},
|
|
afterTypeChange: mutState => {
|
|
initFieldsIfMissing(mutState, 'ckeditor4');
|
|
},
|
|
afterTagLanguageChange: (mutState, isEdit) => {
|
|
},
|
|
validate: state => {
|
|
}
|
|
};
|
|
|
|
|
|
const codeEditorSourceTypes = getCodeEditorSourceTypeOptions(t);
|
|
const codeEditorSourceTypeLabels = {};
|
|
for (const srcType of codeEditorSourceTypes) {
|
|
codeEditorSourceTypeLabels[srcType.key] = srcType.label;
|
|
}
|
|
|
|
templateTypes.codeeditor = {
|
|
typeName: t('codeEditor'),
|
|
getTypeForm: (owner, isEdit) => {
|
|
const sourceType = owner.getFormValue(prefix + 'codeEditorSourceType');
|
|
if (isEdit) {
|
|
return <StaticField
|
|
id={prefix + 'codeEditorSourceType'}
|
|
className={styles.formDisabled}
|
|
label={t('type')}>{codeEditorSourceTypeLabels[sourceType]}</StaticField>;
|
|
} else {
|
|
return <Dropdown
|
|
id={prefix + 'codeEditorSourceType'}
|
|
label={t('type')}
|
|
options={codeEditorSourceTypes}/>;
|
|
}
|
|
},
|
|
getHTMLEditor: owner =>
|
|
<AlignedRow
|
|
label={t('templateContentHtml')}>
|
|
<CodeEditorHost
|
|
ref={owner.editorNodeRefHandler}
|
|
entity={owner.props.entity}
|
|
entityTypeId={entityTypeId}
|
|
initialSource={owner.getFormValue(prefix + 'codeEditorData').source}
|
|
sourceType={owner.getFormValue(prefix + 'codeEditorSourceType')}
|
|
title={t('codeEditorTemplateDesigner')}
|
|
onSave={::owner.save}
|
|
canSave={owner.isFormWithoutErrors()}
|
|
onTestSend={::owner.showTestSendModal}
|
|
onShowExport={::owner.showExportModal}
|
|
onFullscreenAsync={::owner.setElementInFullscreen}
|
|
/>
|
|
</AlignedRow>,
|
|
exportHTMLEditorData: async owner => {
|
|
const state = await owner.editorNode.exportState();
|
|
// If the sandbox is still loading, the exportState returns null.
|
|
if (state) {
|
|
return {
|
|
[prefix + 'html']: state.html,
|
|
[prefix + 'codeEditorData']: {
|
|
source: state.source
|
|
}
|
|
};
|
|
} else {
|
|
return null;
|
|
}
|
|
},
|
|
exportContent: async (owner, contentType) => {
|
|
const {html, source} = await owner.editorNode.exportState();
|
|
if (contentType === 'html') return html;
|
|
return null;
|
|
},
|
|
initData: () => ({
|
|
[prefix + 'codeEditorSourceType']: CodeEditorSourceType.HTML,
|
|
[prefix + 'codeEditorData']: {}
|
|
}),
|
|
afterLoad: data => {
|
|
data[prefix + 'codeEditorSourceType'] = data[prefix + 'data'].sourceType;
|
|
data[prefix + 'codeEditorData'] = {
|
|
source: data[prefix + 'data'].source
|
|
};
|
|
},
|
|
beforeSave: data => {
|
|
data[prefix + 'data'] = {
|
|
sourceType: data[prefix + 'codeEditorSourceType'],
|
|
source: data[prefix + 'codeEditorData'].source
|
|
};
|
|
|
|
clearBeforeSave(data);
|
|
},
|
|
afterTypeChange: mutState => {
|
|
initFieldsIfMissing(mutState, 'codeeditor');
|
|
},
|
|
afterTagLanguageChange: (mutState, isEdit) => {
|
|
},
|
|
validate: state => {
|
|
}
|
|
};
|
|
|
|
return templateTypes;
|
|
}
|
|
|
|
|
|
export function getEditForm(owner, typeKey, prefix = '') {
|
|
const t = owner.props.t;
|
|
|
|
const tagLanguage = owner.getFormValue(prefix + 'tag_language');
|
|
|
|
const tg = tag => renderTag(tagLanguage, tag);
|
|
|
|
let instructions = null;
|
|
if (tagLanguage === TagLanguages.SIMPLE) {
|
|
instructions = (
|
|
<>
|
|
<Trans i18nKey="mergeTagsAreTagsThatAreReplacedBefore">
|
|
<p>Merge tags are tags that are replaced before sending out the message. The format of the merge tag is the following: <code>{tg('TAG_NAME')}</code> or <code>[TAG_NAME/fallback]</code> where <code>fallback</code> is an optional text value used when <code>TAG_NAME</code> is empty.</p>
|
|
</Trans>
|
|
<Trans i18nKey="youCanUseAnyOfTheStandardMergeTagsBelow">
|
|
<p>You can use any of the standard merge tags below. In addition to that every custom field has its own merge tag. Check the fields of the list you are going to send to.</p>
|
|
</Trans>
|
|
</>
|
|
);
|
|
} else if (tagLanguage === TagLanguages.HBS) {
|
|
instructions = (
|
|
<>
|
|
<Trans>
|
|
<p>Merge tags are tags that are replaced before sending out the message. The format of the merge tag is the following: <code>{tg('TAG_NAME')}</code>. </p>
|
|
</Trans>
|
|
<Trans i18nKey="youCanUseAnyOfTheStandardMergeTagsBelow">
|
|
<p>You can use any of the standard merge tags below. In addition to that every custom field has its own merge tag. Check the fields of the list you are going to send to.</p>
|
|
</Trans>
|
|
<Trans>
|
|
<p>The whole message is interpreted as Handlebars template (see <a href="http://handlebarsjs.com/">http://handlebarsjs.com/</a>). You can use any Handlebars blocks and expressions
|
|
in the template. The merge tags form the root context of the Handlebars template.</p>
|
|
</Trans>
|
|
</>
|
|
);
|
|
}
|
|
|
|
return (
|
|
<div>
|
|
<AlignedRow>
|
|
<Button
|
|
className="btn-secondary"
|
|
onClickAsync={::owner.toggleMergeTagReference}
|
|
label={t('mergeTagReference')}/>
|
|
{owner.state.showMergeTagReference &&
|
|
<div style={{marginTop: '15px'}}>
|
|
{instructions}
|
|
<table className="table table-bordered table-condensed table-striped">
|
|
<thead>
|
|
<tr>
|
|
<th>
|
|
<Trans i18nKey="mergeTag-1">Merge tag</Trans>
|
|
</th>
|
|
<th>
|
|
<Trans i18nKey="description">Description</Trans>
|
|
</th>
|
|
</tr>
|
|
</thead>
|
|
<tbody>
|
|
<tr>
|
|
<th scope="row">
|
|
{tg('LINK_UNSUBSCRIBE')}
|
|
</th>
|
|
<td>
|
|
<Trans i18nKey="urlThatPointsToTheUnsubscribePage">URL that points to the unsubscribe page</Trans>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<th scope="row">
|
|
{tg('LINK_PREFERENCES')}
|
|
</th>
|
|
<td>
|
|
<Trans i18nKey="urlThatPointsToThePreferencesPageOfThe">URL that points to the preferences page of the subscriber</Trans>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<th scope="row">
|
|
{tg('LINK_BROWSER')}
|
|
</th>
|
|
<td>
|
|
<Trans i18nKey="urlToPreviewTheMessageInABrowser">URL to preview the message in a browser</Trans>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<th scope="row">
|
|
{tg('EMAIL')}
|
|
</th>
|
|
<td>
|
|
<Trans i18nKey="emailAddress-1">Email address</Trans>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<th scope="row">
|
|
{tg('SUBSCRIPTION_ID')}
|
|
</th>
|
|
<td>
|
|
<Trans i18nKey="uniqueIdThatIdentifiesTheRecipient">Unique ID that identifies the recipient</Trans>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<th scope="row">
|
|
{tg('LIST_ID')}
|
|
</th>
|
|
<td>
|
|
<Trans i18nKey="uniqueIdThatIdentifiesTheListUsedForThis">Unique ID that identifies the list used for this campaign</Trans>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<th scope="row">
|
|
{tg('CAMPAIGN_ID')}
|
|
</th>
|
|
<td>
|
|
<Trans i18nKey="uniqueIdThatIdentifiesCurrentCampaign">Unique ID that identifies current campaign</Trans>
|
|
</td>
|
|
</tr>
|
|
</tbody>
|
|
</table>
|
|
<Trans i18nKey="forRssCampaignsTheFollowingFurtherTags">
|
|
<p>For RSS campaigns, the following further tags can be used.</p>
|
|
</Trans>
|
|
<table className="table table-bordered table-condensed table-striped">
|
|
<thead>
|
|
<tr>
|
|
<th>
|
|
<Trans i18nKey="mergeTag-1">Merge tag</Trans>
|
|
</th>
|
|
<th>
|
|
<Trans i18nKey="description">Description</Trans>
|
|
</th>
|
|
</tr>
|
|
</thead>
|
|
<tbody>
|
|
<tr>
|
|
<th scope="row">
|
|
{tg('RSS_ENTRY_TITLE')}
|
|
</th>
|
|
<td>
|
|
<Trans i18nKey="rssEntryTitle">RSS entry title</Trans>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<th scope="row">
|
|
{tg('RSS_ENTRY_DATE')}
|
|
</th>
|
|
<td>
|
|
<Trans i18nKey="rssEntryDate">RSS entry date</Trans>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<th scope="row">
|
|
{tg('RSS_ENTRY_LINK')}
|
|
</th>
|
|
<td>
|
|
<Trans i18nKey="rssEntryLink">RSS entry link</Trans>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<th scope="row">
|
|
{tg('RSS_ENTRY_CONTENT')}
|
|
</th>
|
|
<td>
|
|
<Trans i18nKey="contentOfAnRssEntry">Content of an RSS entry</Trans>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<th scope="row">
|
|
{tg('RSS_ENTRY_SUMMARY')}
|
|
</th>
|
|
<td>
|
|
<Trans i18nKey="rssEntrySummary">RSS entry summary</Trans>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<th scope="row">
|
|
{tg('RSS_ENTRY_IMAGE_URL')}
|
|
</th>
|
|
<td>
|
|
<Trans i18nKey="rssEntryImageUrl">RSS entry image URL</Trans>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<th scope="row">
|
|
{tg('RSS_ENTRY_CUSTOM_TAGS')}
|
|
</th>
|
|
<td>
|
|
<Trans>Mailtrain custom tags. The custom tags can be passed in via <code>mt:entries-json</code> element in RSS entry. The text contents of the elements is interpreted as JSON-formatted object..</Trans>
|
|
</td>
|
|
</tr>
|
|
</tbody>
|
|
</table>
|
|
</div>}
|
|
</AlignedRow>
|
|
|
|
{owner.templateTypes[typeKey].getHTMLEditor(owner)}
|
|
|
|
<ACEEditor
|
|
id={prefix + 'text'}
|
|
height="400px"
|
|
mode="text"
|
|
label={t('templateContentPlainText')}
|
|
help={<Trans i18nKey="toExtractTheTextFromHtmlClickHerePlease">To extract the text from HTML click <ActionLink onClickAsync={::owner.extractPlainText}>here</ActionLink>. Please note that your existing plaintext in the field above will be overwritten.</Trans>}
|
|
/>
|
|
</div>
|
|
);
|
|
}
|
|
|
|
export function getTypeForm(owner, typeKey, isEdit) {
|
|
return owner.templateTypes[typeKey].getTypeForm(owner, isEdit);
|
|
}
|
|
|