You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1911 lines
69 KiB
1911 lines
69 KiB
/**
|
|
* Importer manages an import files to Grist tables
|
|
* TODO: hidden tables should be also deleted on page refresh, error...
|
|
*/
|
|
// tslint:disable:no-console
|
|
|
|
import {GristDoc} from 'app/client/components/GristDoc';
|
|
import {buildParseOptionsForm, ParseOptionValues} from 'app/client/components/ParseOptions';
|
|
import {PluginScreen} from 'app/client/components/PluginScreen';
|
|
import {makeTestId} from 'app/client/lib/domUtils';
|
|
import {FocusLayer} from 'app/client/lib/FocusLayer';
|
|
import {ImportSourceElement} from 'app/client/lib/ImportSourceElement';
|
|
import {makeT} from 'app/client/lib/localization';
|
|
import {fetchURL, isDriveUrl, selectFiles, uploadFiles} from 'app/client/lib/uploads';
|
|
import {reportError} from 'app/client/models/AppModel';
|
|
import {ColumnRec, ViewFieldRec, ViewSectionRec} from 'app/client/models/DocModel';
|
|
import {SortedRowSet} from 'app/client/models/rowset';
|
|
import {buildHighlightedCode} from 'app/client/ui/CodeHighlight';
|
|
import {openFilePicker} from 'app/client/ui/FileDialog';
|
|
import {ACCESS_DENIED, AUTH_INTERRUPTED, canReadPrivateFiles, getGoogleCodeForReading} from 'app/client/ui/googleAuth';
|
|
import {cssPageIcon} from 'app/client/ui/LeftPanelCommon';
|
|
import {hoverTooltip, overflowTooltip} from 'app/client/ui/tooltips';
|
|
import {bigBasicButton, bigPrimaryButton, textButton} from 'app/client/ui2018/buttons';
|
|
import {labeledSquareCheckbox} from 'app/client/ui2018/checkbox';
|
|
import {testId as baseTestId, theme, vars} from 'app/client/ui2018/cssVars';
|
|
import {icon} from 'app/client/ui2018/icons';
|
|
import {loadingSpinner} from 'app/client/ui2018/loaders';
|
|
import {IOptionFull, menuDivider, menuItem, multiSelect, selectMenu, selectOption} from 'app/client/ui2018/menus';
|
|
import {cssModalTitle} from 'app/client/ui2018/modals';
|
|
import {openFormulaEditor} from 'app/client/widgets/FormulaEditor';
|
|
import {
|
|
DataSourceTransformed,
|
|
DestId,
|
|
ImportResult,
|
|
ImportTableResult,
|
|
MergeOptions,
|
|
MergeOptionsMap,
|
|
MergeStrategy,
|
|
NEW_TABLE,
|
|
SKIP_TABLE,
|
|
TransformColumn,
|
|
TransformRule,
|
|
TransformRuleMap
|
|
} from 'app/common/ActiveDocAPI';
|
|
import {DisposableWithEvents} from 'app/common/DisposableWithEvents';
|
|
import {byteString, not} from 'app/common/gutil';
|
|
import {FetchUrlOptions, UploadResult} from 'app/common/uploads';
|
|
import {ParseOptions, ParseOptionSchema} from 'app/plugin/FileParserAPI';
|
|
import {
|
|
Computed,
|
|
Disposable,
|
|
dom,
|
|
DomContents,
|
|
fromKo,
|
|
Holder,
|
|
IDisposable,
|
|
MultiHolder,
|
|
MutableObsArray,
|
|
obsArray,
|
|
Observable,
|
|
styled,
|
|
UseCBOwner
|
|
} from 'grainjs';
|
|
import debounce = require('lodash/debounce');
|
|
|
|
const t = makeT('Importer');
|
|
// Custom testId that can be appended conditionally.
|
|
const testId = makeTestId('test-importer-');
|
|
|
|
|
|
// We expect a function for creating the preview GridView, to avoid the need to require the
|
|
// GridView module here. That brings many dependencies, making a simple test fixture difficult.
|
|
type CreatePreviewFunc = (vs: ViewSectionRec) => GridView;
|
|
type GridView = IDisposable & {viewPane: HTMLElement, sortedRows: SortedRowSet, listenTo: (...args: any[]) => void};
|
|
const TABLE_MAPPING = 1;
|
|
const COLUMN_MAPPING = 2;
|
|
type ViewType = typeof TABLE_MAPPING | typeof COLUMN_MAPPING;
|
|
|
|
/**
|
|
* Information returned by the backend of the current import state, and how the table and sections look there.
|
|
* Also contains some UI state, so it is updated with the data that comes from the backend.
|
|
*/
|
|
export interface SourceInfo {
|
|
/** Table id that holds the imported data. */
|
|
hiddenTableId: string;
|
|
/** Uploaded file index */
|
|
uploadFileIndex: number;
|
|
/** Table name that was figured out by the backend. File name or tab in excel name */
|
|
origTableName: string;
|
|
/**
|
|
* Section that contains only imported columns. It is not shown to the user.
|
|
* Table besides the imported data have formula columns that are used to finalize import. Those formula
|
|
* columns are not part of this section.
|
|
*/
|
|
sourceSection: ViewSectionRec;
|
|
/**
|
|
* A viewSection containing transform (formula) columns pointing to the original source columns.
|
|
* When user selects New table, they are basically formulas pointing to the source columns.
|
|
* When user selects Existing table, new formula columns are created that look like the selected table, and this
|
|
* section contains those formula columns.
|
|
*/
|
|
transformSection: Observable<ViewSectionRec|null>;
|
|
/** The destination table id, selected by the user. Can be null for skip and empty string for `New table` */
|
|
destTableId: Observable<DestId>;
|
|
/** True if there is at least one request in progress to create a new transform section. */
|
|
isLoadingSection: Observable<boolean>;
|
|
/** Reference to last promise for the GenImporterView action (which creates `transformSection`). */
|
|
lastGenImporterViewPromise: Promise<any>|null;
|
|
/** Selected view, can be table mapping or column mapping, used only in UI. */
|
|
selectedView: Observable<ViewType>;
|
|
/** List of columns that were customized (have custom formulas) */
|
|
customizedColumns: Observable<Set<string>>;
|
|
}
|
|
|
|
/** Changes the customization flag for the column */
|
|
function toggleCustomized(info: SourceInfo, colId: string, on: boolean): void {
|
|
const customizedColumns = info.customizedColumns.get();
|
|
if (!on) {
|
|
customizedColumns.delete(colId);
|
|
} else {
|
|
customizedColumns.add(colId);
|
|
}
|
|
info.customizedColumns.set(new Set(customizedColumns));
|
|
}
|
|
|
|
|
|
/**
|
|
* UI state for each imported table (file). Maps table id to the info object.
|
|
*/
|
|
interface MergeOptionsStateMap {
|
|
[hiddenTableId: string]: MergeOptionsState|undefined;
|
|
}
|
|
|
|
/**
|
|
* UI state of merge options for a SourceInfo.
|
|
*/
|
|
interface MergeOptionsState {
|
|
/**
|
|
* Whether to update existing records or only add new ones. If false, mergeCols is empty.
|
|
*/
|
|
updateExistingRecords: Observable<boolean>;
|
|
/**
|
|
* List of column ids to merge on if user set `updateExistingRecords` to true. Those are columns from the
|
|
* target table.
|
|
*/
|
|
mergeCols: MutableObsArray<string>;
|
|
/**
|
|
* Merge strategy to use, not used currently.
|
|
*/
|
|
mergeStrategy: Observable<MergeStrategy>;
|
|
/**
|
|
* Whether mergeCols contains invalid columns (set in the code to show error message).
|
|
*/
|
|
hasInvalidMergeCols: Observable<boolean>;
|
|
}
|
|
|
|
/**
|
|
* Imports using the given plugin importer.
|
|
*/
|
|
export async function selectAndImport(
|
|
gristDoc: GristDoc,
|
|
imports: ImportSourceElement[],
|
|
importSourceElem: ImportSourceElement,
|
|
createPreview: CreatePreviewFunc
|
|
) {
|
|
// HACK: The url plugin does not support importing from google drive, and we don't want to
|
|
// ask a user for permission to access all his files (needed to download a single file from an URL).
|
|
// So to have a nice user experience, we will switch to the built-in google drive plugin and allow
|
|
// user to chose a file manually.
|
|
// Suggestion for the future is:
|
|
// (1) ask the user for the greater permission,
|
|
// (2) detect when the permission is not granted, and open the picker-based plugin in that case.
|
|
try {
|
|
// Importer disposes itself when its dialog is closed, so we do not take ownership of it.
|
|
await Importer.create(null, gristDoc, importSourceElem, createPreview).pickAndUploadSource(null);
|
|
} catch(err1) {
|
|
// If the url was a Google Drive Url, run the google drive plugin.
|
|
if (!(err1 instanceof GDriveUrlNotSupported)) {
|
|
reportError(err1);
|
|
} else {
|
|
const gdrivePlugin = imports.find((p) => p.plugin.definition.id === 'builtIn/gdrive' && p !== importSourceElem);
|
|
if (!gdrivePlugin) {
|
|
reportError(err1);
|
|
} else {
|
|
try {
|
|
await Importer.create(null, gristDoc, gdrivePlugin, createPreview).pickAndUploadSource(null);
|
|
} catch(err2) {
|
|
reportError(err2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Imports from file.
|
|
*/
|
|
export async function importFromFile(gristDoc: GristDoc, createPreview: CreatePreviewFunc) {
|
|
// In case of using built-in file picker we want to get upload result before instantiating Importer
|
|
// because if the user dismisses the dialog without picking a file,
|
|
// there is no good way to detect this and dispose Importer.
|
|
let uploadResult: UploadResult|null = null;
|
|
// Use the built-in file picker. On electron, it uses the native file selector (without
|
|
// actually uploading anything), which is why this requires a slightly different flow.
|
|
const files: File[] = await openFilePicker({multiple: true});
|
|
// Important to fork first before trying to import, so we end up uploading to a
|
|
// consistent doc worker.
|
|
await gristDoc.forkIfNeeded();
|
|
const label = files.map(f => f.name).join(', ');
|
|
const size = files.reduce((acc, f) => acc + f.size, 0);
|
|
const app = gristDoc.app.topAppModel.appObs.get();
|
|
const progress = app ? app.notifier.createProgressIndicator(label, byteString(size)) : null;
|
|
const onProgress = (percent: number) => progress && progress.setProgress(percent);
|
|
try {
|
|
onProgress(0);
|
|
uploadResult = await uploadFiles(files, {docWorkerUrl: gristDoc.docComm.docWorkerUrl,
|
|
sizeLimit: 'import'}, onProgress);
|
|
onProgress(100);
|
|
} finally {
|
|
if (progress) {
|
|
progress.dispose();
|
|
}
|
|
}
|
|
// Importer disposes itself when its dialog is closed, so we do not take ownership of it.
|
|
await Importer.create(null, gristDoc, null, createPreview).pickAndUploadSource(uploadResult);
|
|
}
|
|
|
|
|
|
/**
|
|
* Importer manages an import files to Grist tables and shows Preview
|
|
*/
|
|
export class Importer extends DisposableWithEvents {
|
|
|
|
private _docComm = this._gristDoc.docComm;
|
|
private _uploadResult?: UploadResult;
|
|
|
|
private _screen: PluginScreen;
|
|
private _optionsScreenHolder = Holder.create(this);
|
|
/**
|
|
* Merge information (for updating existing rows).
|
|
*/
|
|
private _mergeOptions: MergeOptionsStateMap = {};
|
|
/**
|
|
* Parsing options (for parsing the file), passed to the backend directly.
|
|
*/
|
|
private _parseOptions = Observable.create<ParseOptions>(this, {});
|
|
/**
|
|
* Info about the data that was parsed from the imported files (or tabs in excel).
|
|
*/
|
|
private _sourceInfoArray = Observable.create<SourceInfo[]>(this, []);
|
|
/**
|
|
* Currently selected table to import (a file or a tab in excel).
|
|
*/
|
|
private _sourceInfoSelected = Observable.create<SourceInfo|null>(this, null);
|
|
|
|
// Owner of the observables in the _sourceInfoArray
|
|
private readonly _sourceInfoHolder = Holder.create(this);
|
|
|
|
// Holder for the column mapping formula editor.
|
|
private readonly _formulaEditorHolder = Holder.create(this);
|
|
|
|
/**
|
|
* Helper for the preview section (the transformSection from the backend). The naming is misleading a bit, sorry
|
|
* about that, but this transform section is shown to the user as a Grid.
|
|
*
|
|
* We need a helper to make sure section is in good state before showing it to the user.
|
|
*/
|
|
private _previewViewSection: Observable<ViewSectionRec|null> =
|
|
Computed.create(this, this._sourceInfoSelected, (use, info) => {
|
|
if (!info) { return null; }
|
|
|
|
const isLoading = use(info.isLoadingSection);
|
|
if (isLoading) { return null; }
|
|
|
|
const viewSection = use(info.transformSection);
|
|
return viewSection && !viewSection.isDisposed() && !use(viewSection._isDeleted) ? viewSection : null;
|
|
});
|
|
|
|
/**
|
|
* True if there is at least one request in progress to generate an import diff.
|
|
*/
|
|
private _isLoadingDiff = Observable.create(this, false);
|
|
// Promise for the most recent generateImportDiff action.
|
|
private _lastGenImportDiffPromise: Promise<any>|null = null;
|
|
|
|
private _debouncedUpdateDiff = debounce(this._updateDiff, 1000, {leading: true, trailing: true});
|
|
|
|
/**
|
|
* Flag that is set when _updateImportDiff is called, and unset when _debouncedUpdateDiff begins executing.
|
|
*
|
|
* This is a workaround until Lodash's next release, which supports checking if a debounced function is
|
|
* pending. We need to know if more debounced calls are pending so that we can decide to take down the
|
|
* loading spinner over the preview table, or leave it up until all scheduled calls settle.
|
|
*/
|
|
private _hasScheduledDiffUpdate = false;
|
|
|
|
/**
|
|
* destTables is a list of tables user can choose to import data into, in the format suitable for the UI to consume.
|
|
*/
|
|
private _destTables = Computed.create<Array<IOptionFull<DestId>>>(this, (use) => [
|
|
...use(this._gristDoc.docModel.visibleTableIds.getObservable()).map((id) => ({value: id, label: id})),
|
|
]);
|
|
|
|
/**
|
|
* List of transform fields, i.e. those formula fields of the transform section whose values will be used to
|
|
* populate the destination columns.
|
|
* For `New table` those fields are 1-1 with columns imported from the file.
|
|
* For `Existing table` those are fields that simulate the target table columns.
|
|
* In UI we will call it `GRIST COLUMNS`, whereas source columns will be called `SOURCE COLUMNS`.
|
|
*
|
|
* This is helper that makes sure that those fields from the transformSection are in a good state to show.
|
|
*/
|
|
private _transformFields: Computed<ViewFieldRec[]|null> = Computed.create(
|
|
this, this._sourceInfoSelected, (use, info) => {
|
|
const section = info && use(info.transformSection);
|
|
if (!section || use(section._isDeleted)) { return null; }
|
|
return use(use(section.viewFields).getObservable());
|
|
});
|
|
|
|
/**
|
|
* Prepare a Map, mapping of colRef of each transform column to the set of options to offer in
|
|
* the dropdown. The options are represented as a Map too, mapping formula to label.
|
|
*
|
|
* It only matters for importing into existing table. Transform column are perceived as GRIST COLUMNS, so those
|
|
* columns that will be updated or imported into.
|
|
*
|
|
* For each of such column, this will create a map of possible options to choose in from (except SKIP).
|
|
* The result is a map (treated as just list of Records), with a formula and label to show in the UI.
|
|
* This formula will be used to update the target helper column, when user selects it.
|
|
*
|
|
* For example:
|
|
* File has those columns: `Name`, `Age`, `City`, `Country`
|
|
* Existing table has those: `First name`, `Last name`.
|
|
*
|
|
* So for `First name` (and `Last name`) we will have a map of options:
|
|
* - `$Name` -> `Name`
|
|
* - `$City` -> `City`
|
|
* - `$Country` -> `Country`
|
|
* - `$Age` -> `Age`
|
|
* (and skip added in the UI).
|
|
*
|
|
* There are some special cases for References and column ids.
|
|
*/
|
|
private _transformColImportOptions: Computed<Map<number, Map<string, string>>> = Computed.create(
|
|
this, this._transformFields, this._sourceInfoSelected, (use, fields, info) => {
|
|
if (!fields || !info) { return new Map(); }
|
|
return new Map(fields.map(f =>
|
|
[use(f.colRef), this._makeImportOptionsForCol(use(f.column), info)]));
|
|
});
|
|
|
|
/**
|
|
* List of labels of destination columns that aren't mapped to a source column, i.e. transform
|
|
* columns with empty formulas.
|
|
*
|
|
* In other words, this is a list of GRIST COLUMNS that are not mapped to any SOURCE COLUMNS, so
|
|
* columns that won't be imported.
|
|
*/
|
|
private _unmatchedFieldsMap: Computed<Map<SourceInfo, string[]|null>> = Computed.create(this, use => {
|
|
const sources = use(this._sourceInfoArray);
|
|
const result = new Map<SourceInfo, string[]|null>();
|
|
const unmatched = (info: SourceInfo) => {
|
|
// If Skip import selected, ignore.
|
|
if (use(info.destTableId) === SKIP_TABLE) { return null; }
|
|
// If New table selected, ignore.
|
|
if (use(info.destTableId) === NEW_TABLE) { return null; }
|
|
// Otherwise, return list of labels of unmatched fields.
|
|
const section = info && use(info.transformSection);
|
|
if (!section || section.isDisposed() || use(section._isDeleted)) { return null; }
|
|
const fields = use(use(section.viewFields).getObservable());
|
|
const labels = fields?.filter(f => (use(use(f.column).formula).trim() === ''))
|
|
.map(f => use(f.label)) ?? null;
|
|
return labels?.length ? labels : null;
|
|
};
|
|
for (const info of sources) {
|
|
result.set(info, unmatched(info));
|
|
}
|
|
return result;
|
|
});
|
|
|
|
constructor(private _gristDoc: GristDoc,
|
|
// null tells to use the built-in file picker.
|
|
private _importSourceElem: ImportSourceElement|null,
|
|
private _createPreview: CreatePreviewFunc) {
|
|
super();
|
|
const label = _importSourceElem?.importSource.label || "Import from file";
|
|
this._screen = PluginScreen.create(this, label);
|
|
|
|
this.onDispose(() => {
|
|
this._resetImportDiffState();
|
|
});
|
|
}
|
|
|
|
/*
|
|
* Uploads file to the server using the built-in file picker or a plugin instance.
|
|
*/
|
|
public async pickAndUploadSource(uploadResult: UploadResult|null = null) {
|
|
try {
|
|
if (!this._importSourceElem) {
|
|
// Use upload result if it was passed in or the built-in file picker.
|
|
// On electron, it uses the native file selector (without actually uploading anything),
|
|
// which is why this requires a slightly different flow.
|
|
uploadResult = uploadResult || await selectFiles({docWorkerUrl: this._docComm.docWorkerUrl,
|
|
multiple: true, sizeLimit: 'import'});
|
|
} else {
|
|
// Need to use plugin to get the data, and manually upload it.
|
|
const plugin = this._importSourceElem.plugin;
|
|
const handle = this._screen.renderPlugin(plugin);
|
|
const importSource = await this._importSourceElem.importSourceStub.getImportSource(handle);
|
|
plugin.removeRenderTarget(handle);
|
|
this._screen.renderSpinner();
|
|
|
|
if (importSource) {
|
|
// If data has been picked, upload it.
|
|
const item = importSource.item;
|
|
if (item.kind === "fileList") {
|
|
const files = item.files.map(({content, name}) => new File([content], name));
|
|
uploadResult = await uploadFiles(files, {docWorkerUrl: this._docComm.docWorkerUrl,
|
|
sizeLimit: 'import'});
|
|
} else if (item.kind === "url") {
|
|
if (isDriveUrl(item.url)) {
|
|
uploadResult = await this._fetchFromDrive(item.url);
|
|
} else {
|
|
uploadResult = await fetchURL(this._docComm, item.url);
|
|
}
|
|
} else {
|
|
throw new Error(`Import source of kind ${(item as any).kind} are not yet supported!`);
|
|
}
|
|
}
|
|
}
|
|
} catch (err) {
|
|
if (err instanceof CancelledError) {
|
|
await this._cancelImport();
|
|
return;
|
|
}
|
|
if (err instanceof GDriveUrlNotSupported) {
|
|
await this._cancelImport();
|
|
throw err;
|
|
}
|
|
this._screen.renderError(err.message);
|
|
return;
|
|
}
|
|
|
|
if (uploadResult) {
|
|
this._uploadResult = uploadResult;
|
|
await this._reImport(uploadResult);
|
|
} else {
|
|
await this._cancelImport();
|
|
}
|
|
}
|
|
|
|
private _getPrimaryViewSection(tableId: string): ViewSectionRec {
|
|
const tableModel = this._gristDoc.getTableModel(tableId);
|
|
const viewRow = tableModel.tableMetaRow.primaryView.peek();
|
|
return viewRow.viewSections.peek().peek()[0];
|
|
}
|
|
|
|
private _getSectionByRef(sectionRef: number): ViewSectionRec {
|
|
return this._gristDoc.docModel.viewSections.getRowModel(sectionRef);
|
|
}
|
|
|
|
private async _updateTransformSection(sourceInfo: SourceInfo) {
|
|
this._resetImportDiffState();
|
|
|
|
sourceInfo.isLoadingSection.set(true);
|
|
sourceInfo.transformSection.set(null);
|
|
|
|
const genImporterViewPromise = this._gristDoc.docData.sendAction(
|
|
['GenImporterView', sourceInfo.hiddenTableId, sourceInfo.destTableId.get(), null, null]);
|
|
sourceInfo.lastGenImporterViewPromise = genImporterViewPromise;
|
|
const transformSectionRef = (await genImporterViewPromise).viewSectionRef;
|
|
|
|
// If the request is superseded by a newer request, or the Importer is disposed, do nothing.
|
|
if (this.isDisposed() || sourceInfo.lastGenImporterViewPromise !== genImporterViewPromise) {
|
|
return;
|
|
}
|
|
|
|
// Otherwise, update the transform section for `sourceInfo`.
|
|
sourceInfo.transformSection.set(this._gristDoc.docModel.viewSections.getRowModel(transformSectionRef));
|
|
sourceInfo.isLoadingSection.set(false);
|
|
|
|
// Change the active section to the transform section, so that formula autocomplete works.
|
|
this._gristDoc.viewModel.activeSectionId(transformSectionRef);
|
|
}
|
|
|
|
/**
|
|
* Reads the configuration from the temporary table and creates a configuration map for each table.
|
|
*/
|
|
private _getTransformedDataSource(upload: UploadResult): DataSourceTransformed {
|
|
const transforms: TransformRuleMap[] = upload.files.map((file, i) => this._createTransformRuleMap(i));
|
|
return {uploadId: upload.uploadId, transforms};
|
|
}
|
|
|
|
private _getMergeOptionMaps(upload: UploadResult): MergeOptionsMap[] {
|
|
return upload.files.map((_file, i) => this._createMergeOptionsMap(i));
|
|
}
|
|
|
|
private _createTransformRuleMap(uploadFileIndex: number): TransformRuleMap {
|
|
const result: TransformRuleMap = {};
|
|
for (const sourceInfo of this._sourceInfoArray.get()) {
|
|
if (sourceInfo.uploadFileIndex === uploadFileIndex) {
|
|
result[sourceInfo.origTableName] = this._createTransformRule(sourceInfo);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private _createMergeOptionsMap(uploadFileIndex: number): MergeOptionsMap {
|
|
const result: MergeOptionsMap = {};
|
|
for (const sourceInfo of this._sourceInfoArray.get()) {
|
|
if (sourceInfo.uploadFileIndex === uploadFileIndex) {
|
|
result[sourceInfo.origTableName] = this._getMergeOptionsForSource(sourceInfo);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private _createTransformRule(sourceInfo: SourceInfo): TransformRule {
|
|
const transformSection = sourceInfo.transformSection.get();
|
|
if (!transformSection) {
|
|
throw new Error(`Table ${sourceInfo.hiddenTableId} is missing transform section`);
|
|
}
|
|
|
|
const transformFields = transformSection.viewFields().peek();
|
|
const sourceFields = sourceInfo.sourceSection.viewFields().peek();
|
|
|
|
const destTableId: DestId = sourceInfo.destTableId.get();
|
|
return {
|
|
destTableId,
|
|
destCols: transformFields.map<TransformColumn>((field) => ({
|
|
label: field.label(),
|
|
colId: destTableId ? field.colId() : null, // if inserting into new table, colId isn't defined
|
|
type: field.column().type(),
|
|
widgetOptions: field.column().widgetOptions(),
|
|
formula: field.column().formula()
|
|
})),
|
|
sourceCols: sourceFields.map((field) => field.colId())
|
|
};
|
|
}
|
|
|
|
private _getMergeOptionsForSource(sourceInfo: SourceInfo): MergeOptions|undefined {
|
|
const mergeOptions = this._mergeOptions[sourceInfo.hiddenTableId];
|
|
if (!mergeOptions) { return undefined; }
|
|
|
|
const {updateExistingRecords, mergeCols, mergeStrategy} = mergeOptions;
|
|
return {
|
|
mergeCols: updateExistingRecords.get() ? mergeCols.get() : [],
|
|
mergeStrategy: mergeStrategy.get()
|
|
};
|
|
}
|
|
|
|
private _getHiddenTableIds(): string[] {
|
|
return this._sourceInfoArray.get().map((si: SourceInfo) => si.hiddenTableId);
|
|
}
|
|
|
|
private async _reImport(upload: UploadResult) {
|
|
this._screen.renderSpinner();
|
|
this._resetImportDiffState();
|
|
try {
|
|
// Initialize parsing options with NUM_ROWS=0 (a whole file).
|
|
const parseOptions = {...this._parseOptions.get(), NUM_ROWS: 0};
|
|
|
|
// Create the temporary tables and import the files into it.
|
|
const importResult: ImportResult = await this._docComm.importFiles(
|
|
this._getTransformedDataSource(upload), parseOptions, this._getHiddenTableIds());
|
|
|
|
// Update the parsing options with the actual one used by the importer (it might have changed)
|
|
this._parseOptions.set(importResult.options);
|
|
|
|
this._sourceInfoHolder.clear();
|
|
const owner = MultiHolder.create(this._sourceInfoHolder);
|
|
|
|
// Read the information from what was imported in a better representation and some metadata, we
|
|
// will allow to change by the user.
|
|
this._sourceInfoArray.set(importResult.tables.map((info: ImportTableResult) => ({
|
|
hiddenTableId: info.hiddenTableId,
|
|
uploadFileIndex: info.uploadFileIndex,
|
|
origTableName: info.origTableName,
|
|
// This is the section with the data imported.
|
|
sourceSection: this._getPrimaryViewSection(info.hiddenTableId)!,
|
|
// This is the section created every time user changes the configuration, used for the preview.
|
|
transformSection: Observable.create(owner, this._getSectionByRef(info.transformSectionRef)),
|
|
// This is the table where the data will be imported, either a new table or an existing one.
|
|
// If a new one, it will be hidden for a while, until the user confirms the import.
|
|
destTableId: Observable.create<DestId>(owner, info.destTableId ?? NEW_TABLE),
|
|
// Helper to show the spinner.
|
|
isLoadingSection: Observable.create(owner, false),
|
|
// and another one.
|
|
lastGenImporterViewPromise: null,
|
|
// Which view to show or was shown previously.
|
|
selectedView: Observable.create(owner, TABLE_MAPPING),
|
|
// List of customized
|
|
customizedColumns: Observable.create(owner, new Set<string>()),
|
|
})));
|
|
|
|
if (this._sourceInfoArray.get().length === 0) {
|
|
throw new Error("No data was imported");
|
|
}
|
|
|
|
this._prepareMergeOptions();
|
|
|
|
// Select the first sourceInfo to show in preview.
|
|
this._sourceInfoSelected.set(this._sourceInfoArray.get()[0] || null);
|
|
|
|
// And finally render the main screen.
|
|
this._renderMain(upload);
|
|
} catch (e) {
|
|
console.warn("Import failed", e);
|
|
this._screen.renderError(e.message);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create a merging options. This is an extension to the configuration above (_sourceInfoArray).
|
|
* By default, we are pointing to new tables, so it is empty. This method is used to communicate
|
|
* with the user about what they want and how they want to merge the data.
|
|
* For an existing table, it will be filled by the user with columns to merge on (how to identify
|
|
* existing rows).
|
|
*/
|
|
private _prepareMergeOptions() {
|
|
this._mergeOptions = {};
|
|
this._getHiddenTableIds().forEach(tableId => {
|
|
this._mergeOptions[tableId] = {
|
|
// By default no, as we are importing into new tables.
|
|
updateExistingRecords: Observable.create(null, false),
|
|
// Empty, user will select it for existing table.
|
|
mergeCols: obsArray(),
|
|
// Strategy for the backend (from UI we don't care about it).
|
|
mergeStrategy: Observable.create(null, {type: 'replace-with-nonblank-source'}),
|
|
// Helper to show the validation that something is wrong with the columns selected to merge.
|
|
hasInvalidMergeCols: Observable.create(null, false),
|
|
};
|
|
});
|
|
}
|
|
|
|
private async _maybeFinishImport(upload: UploadResult) {
|
|
const isConfigValid = this._validateImportConfiguration();
|
|
if (!isConfigValid) { return; }
|
|
|
|
this._screen.renderSpinner();
|
|
this._resetImportDiffState();
|
|
|
|
const parseOptions = {...this._parseOptions.get(), NUM_ROWS: 0};
|
|
const mergeOptionMaps = this._getMergeOptionMaps(upload);
|
|
|
|
const importResult: ImportResult = await this._docComm.finishImportFiles(
|
|
this._getTransformedDataSource(upload), this._getHiddenTableIds(), {mergeOptionMaps, parseOptions});
|
|
|
|
// This is not hidden table anymore, it was renamed to the name of the final table.
|
|
if (importResult.tables[0]?.hiddenTableId) {
|
|
const tableRowModel = this._gristDoc.docModel.dataTables[importResult.tables[0].hiddenTableId].tableMetaRow;
|
|
const primaryViewId = tableRowModel.primaryViewId();
|
|
if (primaryViewId) {
|
|
// Switch page if there is a sensible one to switch to.
|
|
await this._gristDoc.openDocPage(primaryViewId);
|
|
}
|
|
}
|
|
this._screen.close();
|
|
this.dispose();
|
|
}
|
|
|
|
private async _cancelImport() {
|
|
this._resetImportDiffState();
|
|
// Formula editor cleanup needs to happen before the hidden tables are removed.
|
|
this._formulaEditorHolder.dispose();
|
|
if (this._uploadResult) {
|
|
await this._docComm.cancelImportFiles(this._uploadResult.uploadId, this._getHiddenTableIds());
|
|
}
|
|
this._screen.close();
|
|
this.dispose();
|
|
}
|
|
|
|
private _resetTableMergeOptions(tableId: string) {
|
|
this._mergeOptions[tableId]?.mergeCols.set([]);
|
|
}
|
|
|
|
private _validateImportConfiguration(): boolean {
|
|
let isValid = true;
|
|
|
|
const selectedSourceInfo = this._sourceInfoSelected.get();
|
|
if (!selectedSourceInfo) { return isValid; } // No configuration to validate.
|
|
|
|
const mergeOptions = this._mergeOptions[selectedSourceInfo.hiddenTableId];
|
|
if (!mergeOptions) { return isValid; } // No configuration to validate.
|
|
|
|
const destTableId = selectedSourceInfo.destTableId.get();
|
|
const {updateExistingRecords, mergeCols, hasInvalidMergeCols} = mergeOptions;
|
|
|
|
// Check that at least one merge column was selected (if merging into an existing table).
|
|
if (destTableId !== null && updateExistingRecords.get() && mergeCols.get().length === 0) {
|
|
hasInvalidMergeCols.set(true);
|
|
isValid = false;
|
|
}
|
|
|
|
return isValid;
|
|
}
|
|
|
|
private _buildModalTitle(rightElement?: DomContents) {
|
|
const title = this._importSourceElem ? this._importSourceElem.importSource.label : 'Import from file';
|
|
return cssModalHeader(cssModalTitle(title), rightElement);
|
|
}
|
|
|
|
private _buildStaticTitle() {
|
|
return cssStaticHeader(cssModalTitle(t('Import from file')));
|
|
}
|
|
|
|
/**
|
|
* Triggers an update of the import diff in the preview table. When called in quick succession,
|
|
* only the most recent call will result in an update being made to the preview table.
|
|
*
|
|
* @param {SourceInfo} info The source to update the diff for.
|
|
*/
|
|
private async _updateImportDiff(info: SourceInfo) {
|
|
const {updateExistingRecords, mergeCols} = this._mergeOptions[info.hiddenTableId]!;
|
|
const isMerging = info.destTableId && updateExistingRecords.get() && mergeCols.get().length > 0;
|
|
if (!isMerging && this._gristDoc.comparison) {
|
|
// If we're not merging but diffing is enabled, disable it; since `comparison` isn't
|
|
// currently observable, we'll wrap the modification around the `_isLoadingDiff`
|
|
// flag, which will force the preview table to re-render with diffing disabled.
|
|
this._isLoadingDiff.set(true);
|
|
this._gristDoc.comparison = null;
|
|
this._isLoadingDiff.set(false);
|
|
}
|
|
|
|
// If we're not merging, no diff is shown, so don't schedule an update for one.
|
|
if (!isMerging) { return; }
|
|
|
|
this._hasScheduledDiffUpdate = true;
|
|
this._isLoadingDiff.set(true);
|
|
await this._debouncedUpdateDiff(info);
|
|
}
|
|
|
|
/**
|
|
* NOTE: This method should not be called directly. Instead, use _updateImportDiff above, which
|
|
* wraps this method and calls a debounced version of it.
|
|
*
|
|
* Triggers an update of the import diff in the preview table. When called in quick succession,
|
|
* only the most recent call will result in an update being made to the preview table.
|
|
*
|
|
* @param {SourceInfo} info The source to update the diff for.
|
|
*/
|
|
private async _updateDiff(info: SourceInfo) {
|
|
// Reset the flag tracking scheduled updates since the debounced update has started.
|
|
this._hasScheduledDiffUpdate = false;
|
|
|
|
// Request a diff of the current source and wait for a response.
|
|
const genImportDiffPromise = this._docComm.generateImportDiff(info.hiddenTableId,
|
|
this._createTransformRule(info), this._getMergeOptionsForSource(info)!);
|
|
this._lastGenImportDiffPromise = genImportDiffPromise;
|
|
const diff = await genImportDiffPromise;
|
|
|
|
// If the request is superseded by a newer request, or the Importer is disposed, do nothing.
|
|
if (this.isDisposed() || genImportDiffPromise !== this._lastGenImportDiffPromise) { return; }
|
|
|
|
// Put the document in comparison mode with the diff data.
|
|
this._gristDoc.comparison = diff;
|
|
|
|
// If more updates where scheduled since we started the update, leave the loading spinner up.
|
|
if (!this._hasScheduledDiffUpdate) {
|
|
this._isLoadingDiff.set(false);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Resets all state variables related to diffs to their default values.
|
|
*/
|
|
private _resetImportDiffState() {
|
|
this._cancelPendingDiffRequests();
|
|
this._gristDoc.comparison = null;
|
|
}
|
|
|
|
/**
|
|
* Effectively cancels all pending diff requests by causing their fulfilled promises to
|
|
* be ignored by their attached handlers. Since we can't natively cancel the promises, this
|
|
* is functionally equivalent to canceling the outstanding requests.
|
|
*/
|
|
private _cancelPendingDiffRequests() {
|
|
this._debouncedUpdateDiff.cancel();
|
|
this._lastGenImportDiffPromise = null;
|
|
this._hasScheduledDiffUpdate = false;
|
|
this._isLoadingDiff.set(false);
|
|
}
|
|
|
|
// The importer state showing import in progress, with a list of tables, and a preview.
|
|
private _renderMain(upload: UploadResult) {
|
|
const schema = this._parseOptions.get().SCHEMA;
|
|
const header = this._buildModalTitle();
|
|
const options = schema ? cssActionLink(cssLinkIcon('Settings'), 'Import options',
|
|
testId('options-link'),
|
|
dom.on('click', () => this._renderParseOptions(schema, upload))
|
|
) : null;
|
|
|
|
const selectTab = async (info: SourceInfo) => {
|
|
// Ignore click if source is already selected.
|
|
if (info === this._sourceInfoSelected.get()) { return; }
|
|
// Prevent changing selected source if current configuration is invalid.
|
|
if (!this._validateImportConfiguration()) { return; }
|
|
this._cancelPendingDiffRequests();
|
|
this._sourceInfoSelected.set(info);
|
|
await this._updateImportDiff(info);
|
|
};
|
|
|
|
const tabs = cssTableList(
|
|
dom.forEach(this._sourceInfoArray, (info) => {
|
|
const owner = MultiHolder.create(null);
|
|
const destTableId = Computed.create(owner, (use) => use(info.destTableId));
|
|
destTableId.onWrite(async (destId) => {
|
|
// Prevent changing destination of un-selected sources if current configuration is invalid.
|
|
if (info !== this._sourceInfoSelected.get() && !this._validateImportConfiguration()) {
|
|
return;
|
|
}
|
|
info.destTableId.set(destId);
|
|
this._resetTableMergeOptions(info.hiddenTableId);
|
|
if (destId !== SKIP_TABLE) {
|
|
await this._updateTransformSection(info);
|
|
}
|
|
});
|
|
|
|
// If this is selected source.
|
|
const isSelected = Computed.create(owner, (use) => use(this._sourceInfoSelected) === info);
|
|
|
|
const unmatchedCount = Computed.create(owner, use => {
|
|
const map = use(this._unmatchedFieldsMap);
|
|
return map.get(info)?.length ?? 0;
|
|
});
|
|
|
|
return cssTabItem(
|
|
dom.autoDispose(owner),
|
|
cssBorderBottom(),
|
|
cssTabItem.cls('-not-selected', not(isSelected)),
|
|
testId('source'),
|
|
testId('source-selected', isSelected),
|
|
testId('source-not-selected', not(isSelected)),
|
|
cssTabItemContent(
|
|
cssFileTypeIcon(getSourceFileExtension(info, upload),
|
|
cssFileTypeIcon.cls('-active', isSelected),
|
|
),
|
|
cssTabItemContent.cls('-selected', isSelected),
|
|
cssTableLine(cssTableSource(
|
|
getSourceDescription(info, upload),
|
|
testId('from'),
|
|
overflowTooltip(),
|
|
)),
|
|
dom.on('click', () => selectTab(info)),
|
|
),
|
|
dom.maybe(unmatchedCount, (count) => cssError(
|
|
'Exclamation',
|
|
testId('error'),
|
|
hoverTooltip(t('{{count}} unmatched field', {count}))
|
|
)),
|
|
);
|
|
}),
|
|
);
|
|
const previewAndConfig = dom.maybeOwned(this._sourceInfoSelected, (owner, info) => {
|
|
const {mergeCols, updateExistingRecords, hasInvalidMergeCols} = this._mergeOptions[info.hiddenTableId]!;
|
|
|
|
// Computed for transform section if we have destination table selected.
|
|
const configSection = Computed.create(owner,
|
|
use => use(info.destTableId) && use(info.transformSection) ? use(info.transformSection) : null);
|
|
|
|
// Computed to show the loader while we are waiting for the preview.
|
|
const showLoader = Computed.create(owner, use => {
|
|
return use(this._isLoadingDiff) || !use(this._previewViewSection);
|
|
});
|
|
|
|
// The same computed as configSection, but will evaluate to null while we are waiting for the preview
|
|
const previewSection = Computed.create(owner, use => {
|
|
return use(showLoader) ? null : use(this._previewViewSection);
|
|
});
|
|
|
|
// Use helper for checking if destination is selected.
|
|
const isSelected = (destId: DestId) => (use: UseCBOwner) => use(info.destTableId) === destId;
|
|
|
|
// True if user selected `Skip import`
|
|
const isSkipTable = Computed.create(owner, isSelected(SKIP_TABLE));
|
|
|
|
// True if user selected a valid destination table.
|
|
const isMergeTable = Computed.create(owner, use => ![NEW_TABLE, SKIP_TABLE].includes(use(info.destTableId)));
|
|
|
|
// Changes the class if the item is selected. Creates a dom method that can be attached to element.
|
|
const selectIfDestIs = (destId: DestId) => cssDestination.cls('-selected', isSelected(destId));
|
|
|
|
// Helper to toggle visibility if target is selected.
|
|
const visibleIfDestIs = (destId: DestId) => dom.show(isSelected(destId));
|
|
|
|
// Creates a click handler that changes the destination table to the given value.
|
|
const onClickChangeDestTo = (destId: DestId) => dom.on('click', async () => {
|
|
if (info !== this._sourceInfoSelected.get() && !this._validateImportConfiguration()) {
|
|
return;
|
|
}
|
|
info.selectedView.set(TABLE_MAPPING);
|
|
info.destTableId.set(destId);
|
|
this._resetTableMergeOptions(info.hiddenTableId);
|
|
if (destId !== SKIP_TABLE) {
|
|
await this._updateTransformSection(info);
|
|
}
|
|
});
|
|
|
|
// Should we show the right panel with the column mapping.
|
|
const showRightPanel = Computed.create(owner, use => {
|
|
return use(isMergeTable) && use(info.selectedView) === COLUMN_MAPPING;
|
|
});
|
|
|
|
// Handler to switch the view, between destination and column mapping panes.
|
|
const onClickShowView = (view: ViewType) => dom.on('click', () => {
|
|
info.selectedView.set(view);
|
|
});
|
|
|
|
// Pattern to create a computed value that can create and dispose objects in its callback.
|
|
Computed.create(owner, use => {
|
|
// This value must be returned for this pattern to work.
|
|
const holder = MultiHolder.create(use.owner);
|
|
// Now we can safely take ownership of things we create here - the subscriber.
|
|
if (use(configSection)) {
|
|
holder.autoDispose(updateExistingRecords.addListener(async () => {
|
|
if (holder.isDisposed()) { return; }
|
|
await this._updateImportDiff(info);
|
|
}));
|
|
}
|
|
return holder;
|
|
});
|
|
|
|
return cssConfigAndPreview(
|
|
cssConfigPanel(
|
|
cssConfigPanel.cls('-right', showRightPanel),
|
|
cssConfigLeft(
|
|
cssTitle('Destination table', testId('target-top')),
|
|
cssDestinationWrapper(cssDestination(
|
|
cssPageIcon('Plus'),
|
|
dom('span', 'New Table'),
|
|
selectIfDestIs(NEW_TABLE),
|
|
onClickChangeDestTo(NEW_TABLE),
|
|
testId('target'),
|
|
testId('target-new-table'),
|
|
testId('target-selected', isSelected(NEW_TABLE)),
|
|
)),
|
|
dom.maybe(use => use(this._sourceInfoArray).length > 1, () => [
|
|
cssDestinationWrapper(cssDestination(
|
|
cssPageIcon('CrossBig'),
|
|
dom('span', t('Skip Import')),
|
|
selectIfDestIs(SKIP_TABLE),
|
|
onClickChangeDestTo(SKIP_TABLE),
|
|
testId('target'),
|
|
testId('target-skip'),
|
|
testId('target-selected', isSelected(SKIP_TABLE)),
|
|
)),
|
|
]),
|
|
dom.forEach(this._destTables, (destTable) => {
|
|
return cssDestinationWrapper(
|
|
testId('target'),
|
|
testId('target-existing-table'),
|
|
testId('target-selected', isSelected(destTable.value)),
|
|
cssDestination(
|
|
cssPageIcon('TypeTable'),
|
|
dom('span', destTable.label),
|
|
selectIfDestIs(destTable.value),
|
|
onClickChangeDestTo(destTable.value),
|
|
onClickShowView(COLUMN_MAPPING),
|
|
),
|
|
cssDetailsIcon('ArrowRight',
|
|
onClickShowView(COLUMN_MAPPING),
|
|
visibleIfDestIs(destTable.value),
|
|
hoverTooltip(t('Column mapping')),
|
|
testId('target-column-mapping'),
|
|
)
|
|
);
|
|
}),
|
|
),
|
|
cssConfigRight(
|
|
cssNavigation(
|
|
cssFlexBaseline(
|
|
cssDestinationTableSecondary(
|
|
cssNavigationIcon('ArrowLeft'),
|
|
t('Destination table'),
|
|
onClickShowView(TABLE_MAPPING),
|
|
testId('table-mapping')
|
|
),
|
|
cssSlash(' / '),
|
|
cssColumnMappingNav(t('Column Mapping')),
|
|
)
|
|
),
|
|
cssMergeOptions(
|
|
dom.maybe(isMergeTable, () => cssMergeOptionsToggle(labeledSquareCheckbox(
|
|
updateExistingRecords,
|
|
t("Update existing records"),
|
|
testId('update-existing-records')
|
|
))),
|
|
dom.maybe(configSection, (section) => {
|
|
return dom.maybeOwned(updateExistingRecords, (owner2) => {
|
|
owner2.autoDispose(mergeCols.addListener(async val => {
|
|
// Reset the error state of the multiSelect on change.
|
|
if (val.length !== 0 && hasInvalidMergeCols.get()) {
|
|
hasInvalidMergeCols.set(false);
|
|
}
|
|
await this._updateImportDiff(info);
|
|
}));
|
|
return [
|
|
cssMergeOptionsMessage(
|
|
t("Merge rows that match these fields:"),
|
|
testId('merge-fields-message')
|
|
),
|
|
multiSelect(
|
|
mergeCols,
|
|
section.viewFields().peek().map(f => ({label: f.label(), value: f.colId()})) ?? [],
|
|
{
|
|
placeholder: t("Select fields to match on"),
|
|
error: hasInvalidMergeCols
|
|
},
|
|
testId('merge-fields-select')
|
|
)
|
|
];
|
|
});
|
|
}),
|
|
),
|
|
dom.maybeOwned(configSection, (owner1, section) => {
|
|
owner1.autoDispose(updateExistingRecords.addListener(async () => {
|
|
await this._updateImportDiff(info);
|
|
}));
|
|
return dom('div',
|
|
cssColumnMatchHeader(
|
|
dom('span', t('Grist column')),
|
|
dom('div', null),
|
|
dom('span', t('Source column')),
|
|
),
|
|
dom.forEach(fromKo(section.viewFields().getObservable()), field => {
|
|
const owner2 = MultiHolder.create(null);
|
|
const isCustomFormula = Computed.create(owner2, use => {
|
|
return use(info.customizedColumns).has(field.colId());
|
|
});
|
|
return cssColumnMatchRow(
|
|
testId('column-match-source-destination'),
|
|
dom.autoDispose(owner2),
|
|
dom.domComputed(field.label, () => cssDestinationFieldLabel(
|
|
dom.text(field.label),
|
|
overflowTooltip(),
|
|
testId('column-match-destination'),
|
|
)),
|
|
cssIcon180('ArrowRightOutlined'),
|
|
dom.domComputedOwned(isCustomFormula, (owner3, isCustom) => {
|
|
if (isCustom) {
|
|
return this._buildCustomFormula(owner3, field, info);
|
|
} else {
|
|
return this._buildSourceSelector(owner3, field, info);
|
|
}
|
|
}),
|
|
dom('div',
|
|
dom.maybe(isCustomFormula, () => icon('Revert',
|
|
dom.style('cursor', 'pointer'),
|
|
hoverTooltip(t('Revert')),
|
|
dom.on('click', async () => {
|
|
toggleCustomized(info, field.colId(), false);
|
|
// Try to set the default label.
|
|
const transformCol = field.column.peek();
|
|
const possibilities = this._transformColImportOptions.get().get(transformCol.getRowId())
|
|
?? new Map<string, string>();
|
|
const matched = [...possibilities.entries()].find(([, v]) => v === transformCol.label.peek());
|
|
if (matched) {
|
|
await this._setColumnFormula(transformCol, matched[0], info);
|
|
} else {
|
|
await this._gristDoc.clearColumns([field.colRef()]);
|
|
}
|
|
}),
|
|
)),
|
|
),
|
|
);
|
|
}),
|
|
testId('column-match-options'),
|
|
);
|
|
}),
|
|
)
|
|
),
|
|
cssPreviewColumn(
|
|
dom.maybe(showLoader, () => cssPreviewSpinner(loadingSpinner(), testId('preview-spinner'))),
|
|
dom.maybe(previewSection, () => [
|
|
cssOptions(
|
|
dom.domComputed(info.destTableId, destId => cssTableName(
|
|
destId === NEW_TABLE ? t("New Table") :
|
|
destId === SKIP_TABLE ? t("Skip Import") :
|
|
dom.domComputed(this._destTables, list =>
|
|
list.find(dt => dt.value === destId)?.label ?? t("New Table")
|
|
)
|
|
)),
|
|
options,
|
|
)
|
|
]),
|
|
cssWarningText(dom.text(use => use(this._parseOptions)?.WARNING || ""), testId('warning')),
|
|
dom.domComputed(use => {
|
|
if (use(isSkipTable)) {
|
|
return cssOverlay(t('Skip Table on Import'), testId('preview-overlay'));
|
|
}
|
|
const section = use(previewSection);
|
|
if (!section || section.isDisposed()) { return null; }
|
|
const gridView = this._createPreview(section);
|
|
return cssPreviewGrid(
|
|
dom.autoDispose(gridView),
|
|
gridView.viewPane,
|
|
testId('preview'),
|
|
);
|
|
})
|
|
)
|
|
);
|
|
});
|
|
|
|
const buttons = cssImportButtons(cssImportButtonsLine(
|
|
bigPrimaryButton('Import',
|
|
dom.on('click', () => this._maybeFinishImport(upload)),
|
|
dom.boolAttr('disabled', use => {
|
|
return use(this._previewViewSection) === null ||
|
|
use(this._sourceInfoArray).every(i => use(i.destTableId) === SKIP_TABLE);
|
|
}),
|
|
baseTestId('modal-confirm'),
|
|
),
|
|
bigBasicButton('Cancel',
|
|
dom.on('click', () => this._cancelImport()),
|
|
baseTestId('modal-cancel'),
|
|
),
|
|
dom.domComputed(this._unmatchedFieldsMap, fields => {
|
|
const piles: HTMLElement[] = [];
|
|
let count = 0;
|
|
for(const [info, list] of fields) {
|
|
if (!list?.length) { continue; }
|
|
count += list.length;
|
|
piles.push(cssUnmatchedFieldsList(
|
|
list.join(', '),
|
|
dom.on('click', () => selectTab(info)),
|
|
hoverTooltip(getSourceDescription(info, upload)),
|
|
));
|
|
}
|
|
if (!count) { return null; }
|
|
return cssUnmatchedFields(
|
|
cssUnmatchedFieldsIntro(
|
|
cssUnmatchedIcon('Exclamation'),
|
|
t('{{count}} unmatched field in import', {count}), ': ',
|
|
),
|
|
...piles,
|
|
testId('unmatched-fields'),
|
|
);
|
|
}),
|
|
));
|
|
const body = cssContainer(
|
|
{tabIndex: '-1'},
|
|
header,
|
|
cssPreviewWrapper(
|
|
cssTabsWrapper(
|
|
tabs,
|
|
),
|
|
previewAndConfig,
|
|
),
|
|
buttons,
|
|
);
|
|
this._addFocusLayer(body);
|
|
this._screen.render(body, {
|
|
fullscreen: true,
|
|
fullbody: true
|
|
});
|
|
}
|
|
|
|
private _makeImportOptionsForCol(gristCol: ColumnRec, info: SourceInfo) {
|
|
const options = new Map<string, string>(); // Maps formula to label.
|
|
const sourceFields = info.sourceSection.viewFields.peek().peek();
|
|
|
|
// Reference columns are populated using lookup formulas, so figure out now if this is a
|
|
// reference column, and if so, its destination table and the lookup column ID.
|
|
const refTable = gristCol.refTable.peek();
|
|
const refTableId = refTable ? refTable.tableId.peek() : undefined;
|
|
|
|
const visibleColId = gristCol.visibleColModel.peek().colId.peek();
|
|
const isRefDest = Boolean(info.destTableId.get() && gristCol.pureType.peek() === 'Ref');
|
|
|
|
for (const sourceField of sourceFields) {
|
|
const sourceCol = sourceField.column.peek();
|
|
const sourceId = sourceCol.colId.peek();
|
|
const sourceLabel = sourceCol.label.peek();
|
|
if (isRefDest && visibleColId) {
|
|
const formula = `${refTableId}.lookupOne(${visibleColId}=$${sourceId}) or ($${sourceId} and str($${sourceId}))`;
|
|
options.set(formula, sourceLabel);
|
|
} else {
|
|
options.set(`$${sourceId}`, sourceLabel);
|
|
}
|
|
if (isRefDest && ['Numeric', 'Int'].includes(sourceCol.type.peek())) {
|
|
options.set(`${refTableId}.lookupOne(id=NUM($${sourceId})) or ($${sourceId} and str(NUM($${sourceId})))`,
|
|
`${sourceLabel} (as row ID)`);
|
|
}
|
|
}
|
|
return options;
|
|
}
|
|
|
|
private _makeImportOptionsMenu(transformCol: ColumnRec, others: [string, string][], info: SourceInfo) {
|
|
return [
|
|
menuItem(() => this._setColumnFormula(transformCol, null, info),
|
|
'Skip',
|
|
testId('column-match-menu-item')),
|
|
others.length ? menuDivider() : null,
|
|
...others.map(([formula, label]) =>
|
|
menuItem(() => this._setColumnFormula(transformCol, formula, info),
|
|
label,
|
|
testId('column-match-menu-item'))
|
|
)
|
|
];
|
|
}
|
|
|
|
private _addFocusLayer(container: HTMLElement) {
|
|
dom.autoDisposeElem(container, new FocusLayer({
|
|
defaultFocusElem: container,
|
|
allowFocus: (elem) => (elem !== document.body),
|
|
onDefaultFocus: () => this.trigger('importer_focus'),
|
|
}));
|
|
}
|
|
|
|
/**
|
|
* Updates the formula on column `colRef` to `formula`, when user wants to match it to a source column.
|
|
*/
|
|
private async _setColumnFormula(transformCol: ColumnRec, formula: string|null, info: SourceInfo) {
|
|
const transformColRef = transformCol.id();
|
|
const customized = info.customizedColumns.get();
|
|
customized.delete(transformCol.colId());
|
|
info.customizedColumns.set(customized);
|
|
if (formula === null) {
|
|
await this._gristDoc.clearColumns([transformColRef], {keepType: true});
|
|
} else {
|
|
await this._gristDoc.docModel.columns.sendTableAction(
|
|
['UpdateRecord', transformColRef, { formula, isFormula: true }]);
|
|
}
|
|
await this._updateImportDiff(info);
|
|
}
|
|
|
|
/**
|
|
* Opens a formula editor for `field` over `refElem`.
|
|
*/
|
|
private _activateFormulaEditor(refElem: Element, field: ViewFieldRec, onSave: (formula: string) => Promise<void>) {
|
|
const vsi = this._gristDoc.viewModel.activeSection().viewInstance();
|
|
const editRow = vsi?.moveEditRowToCursor();
|
|
const editorHolder = openFormulaEditor({
|
|
gristDoc: this._gristDoc,
|
|
column: field.column(),
|
|
editingFormula: field.editingFormula,
|
|
refElem,
|
|
editRow,
|
|
canDetach: false,
|
|
setupCleanup: this._setupFormulaEditorCleanup.bind(this),
|
|
onSave: async (column, formula) => {
|
|
if (formula === column.formula.peek()) { return; }
|
|
// Sorry for this hack. We need to store somewhere an info that the formula was edited
|
|
// unfortunately, we don't have a better place to store it. So we will save this by setting
|
|
// display column to the same column. This won't break anything as this is a default value.
|
|
await column.updateColValues({formula});
|
|
await onSave(formula);
|
|
}
|
|
});
|
|
this._formulaEditorHolder.autoDispose(editorHolder);
|
|
}
|
|
|
|
/**
|
|
* Called by _activateFormulaEditor to initialize cleanup
|
|
* code for when the formula editor is closed. Registers and
|
|
* unregisters callbacks for saving edits when the editor loses
|
|
* focus.
|
|
*/
|
|
private _setupFormulaEditorCleanup(
|
|
owner: Disposable, _doc: GristDoc, editingFormula: ko.Computed<boolean>, _saveEdit: () => Promise<unknown>
|
|
) {
|
|
const saveEdit = () => _saveEdit().catch(reportError);
|
|
|
|
// Whenever focus returns to the dialog, close the editor by saving the value.
|
|
this.on('importer_focus', saveEdit);
|
|
|
|
owner.onDispose(() => {
|
|
this.off('importer_focus', saveEdit);
|
|
editingFormula(false);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Builds an editable formula component that is displayed
|
|
* in the column mapping section of Importer. On click, opens
|
|
* an editor for the formula for `column`.
|
|
*/
|
|
private _buildSourceSelector(owner: MultiHolder, field: ViewFieldRec, info: SourceInfo) {
|
|
const anyOtherColumns = Computed.create(owner, use => {
|
|
const transformCol = field.column.peek();
|
|
const options = use(this._transformColImportOptions)!.get(transformCol.getRowId()) ?? new Map<string, string>();
|
|
const otherFilter = ([formula]: [string, string] ) => {
|
|
// Notice how this is only reactive to the formula value, every other observable is
|
|
// just picked without being tracked. This is because we only want to recompute this
|
|
// when the formula is changed (so the target column is changed). If anything other is
|
|
// changed, we don't care here as this whole computed will be recreated by the caller.
|
|
const myFormula = use(transformCol.formula);
|
|
const anyOther = info.transformSection.get()?.viewFields.peek().all()
|
|
.filter(f => f.column.peek() !== transformCol)
|
|
.map(f => use(f.column.peek().formula));
|
|
// If we picked this formula thats ok.
|
|
if (formula === myFormula) { return true; }
|
|
// If any other column picked this formula, then we should not show it.
|
|
if (anyOther?.includes(formula)) { return false; }
|
|
// Otherwise, show it.
|
|
return true;
|
|
};
|
|
const possibleSources = Array.from(options).filter(otherFilter);
|
|
|
|
return this._makeImportOptionsMenu(transformCol, possibleSources, info);
|
|
});
|
|
|
|
const selectedSource = Computed.create(owner, use => {
|
|
const column = use(field.column);
|
|
const importOptions = use(this._transformColImportOptions).get(column.getRowId());
|
|
// Now translate the formula generated (which is unique) to the source label.
|
|
const label = importOptions?.get(use(column.formula)) || null;
|
|
return label;
|
|
});
|
|
const selectedSourceText = Computed.create(owner, use => use(selectedSource) || t('Skip'));
|
|
|
|
const selectedOption = cssSelected(
|
|
dom.text(selectedSourceText),
|
|
testId('column-match-formula'),
|
|
cssSelected.cls('-skip', not(selectedSource)),
|
|
overflowTooltip(),
|
|
);
|
|
const otherColsOptions = dom.domComputed(anyOtherColumns, x => x);
|
|
const formulaOption = selectOption(
|
|
() => {
|
|
this._activateFormulaEditor(selectMenuElement, field, async (newFormula) => {
|
|
toggleCustomized(info, field.colId.peek(), !!newFormula);
|
|
await this._updateImportDiff(info);
|
|
});
|
|
},
|
|
"Apply Formula",
|
|
"Lighting",
|
|
testId('apply-formula'),
|
|
cssGreenIcon.cls(''),
|
|
);
|
|
const selectMenuElement = selectMenu(selectedOption, () => [
|
|
otherColsOptions,
|
|
menuDivider(),
|
|
formulaOption,
|
|
], testId('column-match-source'));
|
|
return selectMenuElement;
|
|
}
|
|
|
|
/**
|
|
* Builds an editable formula component that is displayed
|
|
* in the column mapping section of Importer. On click, opens
|
|
* an editor for the formula for `column`.
|
|
*/
|
|
private _buildCustomFormula(owner: MultiHolder, field: ViewFieldRec, info: SourceInfo) {
|
|
const formula = Computed.create(owner, use => {
|
|
const column = use(field.column);
|
|
return use(column.formula);
|
|
});
|
|
const codeOptions = {placeholder: 'Skip', maxLines: 1};
|
|
return dom.create(buildHighlightedCode, formula, codeOptions,
|
|
dom.cls(cssFieldFormula.className),
|
|
dom.cls('disabled'),
|
|
dom.cls('formula_field_sidepane'),
|
|
{tabIndex: '-1'},
|
|
dom.on('focus', (_ev, elem) => this._activateFormulaEditor(elem, field, async (newFormula) => {
|
|
toggleCustomized(info, field.colId.peek(), !!newFormula);
|
|
await this._updateImportDiff(info);
|
|
})),
|
|
testId('column-match-formula'),
|
|
);
|
|
}
|
|
|
|
// The importer state showing parse options that may be changed.
|
|
private _renderParseOptions(schema: ParseOptionSchema[], upload: UploadResult) {
|
|
const anotherScreen = PluginScreen.create(this._optionsScreenHolder, 'Import from file');
|
|
anotherScreen.showImportDialog({
|
|
noClickAway: false,
|
|
noEscapeKey: false,
|
|
});
|
|
anotherScreen.render([
|
|
this._buildStaticTitle(),
|
|
dom.create(buildParseOptionsForm, schema, this._parseOptions.get() as ParseOptionValues,
|
|
(p: ParseOptions) => {
|
|
anotherScreen.dispose();
|
|
this._parseOptions.set(p);
|
|
// Drop what we previously matched because we may have different columns.
|
|
// If user manually matched, then changed import options, they'll have to re-match; when
|
|
// columns change at all, the alternative has incorrect columns in UI and is more confusing.
|
|
this._sourceInfoArray.set([]);
|
|
this._reImport(upload).catch((err) => reportError(err));
|
|
},
|
|
() => {
|
|
anotherScreen.dispose();
|
|
this._renderMain(upload);
|
|
},
|
|
)
|
|
]);
|
|
}
|
|
|
|
private async _fetchFromDrive(itemUrl: string) {
|
|
// First we will assume that this is public file, so no need to ask for permissions.
|
|
try {
|
|
return await fetchURL(this._docComm, itemUrl);
|
|
} catch(err) {
|
|
// It is not a public file or the file id in the url is wrong,
|
|
// but we have no way to check it, so we assume that it is private file
|
|
// and ask the user for the permission (if we are configured to do so)
|
|
if (canReadPrivateFiles()) {
|
|
const options: FetchUrlOptions = {};
|
|
try {
|
|
// Request for authorization code from Google.
|
|
const code = await getGoogleCodeForReading(this);
|
|
options.googleAuthorizationCode = code;
|
|
} catch(permError) {
|
|
if (permError?.message === ACCESS_DENIED) {
|
|
// User declined to give us full readonly permission, fallback to GoogleDrive plugin
|
|
// or cancel import if GoogleDrive plugin is not configured.
|
|
throw new GDriveUrlNotSupported(itemUrl);
|
|
} else if(permError?.message === AUTH_INTERRUPTED) {
|
|
// User closed the window - we assume he doesn't want to continue.
|
|
throw new CancelledError();
|
|
} else {
|
|
// Some other error happened during authentication, report to user.
|
|
throw err;
|
|
}
|
|
}
|
|
// Download file from private drive, if it fails, report the error to user.
|
|
return await fetchURL(this._docComm, itemUrl, options);
|
|
} else {
|
|
// We are not allowed to ask for full readonly permission, fallback to GoogleDrive plugin.
|
|
throw new GDriveUrlNotSupported(itemUrl);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Used for switching from URL plugin to Google drive plugin.
|
|
class GDriveUrlNotSupported extends Error {
|
|
constructor(public url: string) {
|
|
super(`This url ${url} is not supported`);
|
|
}
|
|
}
|
|
|
|
// Used to cancel import (close the dialog without any error).
|
|
class CancelledError extends Error {
|
|
}
|
|
|
|
function getSourceDescription(sourceInfo: SourceInfo, upload: UploadResult) {
|
|
const origName = upload.files[sourceInfo.uploadFileIndex].origName;
|
|
return sourceInfo.origTableName ? `${sourceInfo.origTableName} - ${origName}` : origName;
|
|
}
|
|
|
|
function getSourceFileExtension(sourceInfo: SourceInfo, upload: UploadResult) {
|
|
const origName = upload.files[sourceInfo.uploadFileIndex].origName;
|
|
return origName.includes(".") ? origName.split('.').pop() : "file";
|
|
}
|
|
|
|
const cssContainer = styled('div', `
|
|
height: 100%;
|
|
display: flex;
|
|
flex-direction: column;
|
|
outline: unset;
|
|
`);
|
|
|
|
const cssActionLink = styled('div', `
|
|
display: inline-flex;
|
|
align-items: center;
|
|
cursor: pointer;
|
|
color: ${theme.controlFg};
|
|
--icon-color: ${theme.controlFg};
|
|
&:hover {
|
|
color: ${theme.controlHoverFg};
|
|
--icon-color: ${theme.controlHoverFg};
|
|
}
|
|
`);
|
|
|
|
const cssLinkIcon = styled(icon, `
|
|
flex: none;
|
|
margin-right: 4px;
|
|
`);
|
|
|
|
const cssStaticHeader = styled('div', `
|
|
display: flex;
|
|
align-items: center;
|
|
justify-content: space-between;
|
|
margin-bottom: 16px;
|
|
& > .${cssModalTitle.className} {
|
|
margin-bottom: 0px;
|
|
}
|
|
`);
|
|
|
|
const cssModalHeader = styled(cssStaticHeader, `
|
|
padding-left: var(--css-modal-dialog-padding-horizontal, 0px);
|
|
padding-right: var(--css-modal-dialog-padding-horizontal, 0px);
|
|
padding-top: var(--css-modal-dialog-padding-vertical, 0px);
|
|
`);
|
|
|
|
const cssPreviewWrapper = styled('div', `
|
|
display: flex;
|
|
flex-direction: column;
|
|
flex-grow: 1;
|
|
`);
|
|
|
|
const cssBorderBottom = styled('div', `
|
|
border-bottom: 1px solid ${theme.importerTableInfoBorder};
|
|
display: none;
|
|
height: 0px;
|
|
bottom: 0px;
|
|
position: absolute;
|
|
width: 100%;
|
|
`);
|
|
|
|
|
|
const cssFileTypeIcon = styled('div', `
|
|
background: ${theme.importerInactiveFileBg};
|
|
color: ${theme.importerInactiveFileFg};
|
|
border-radius: 4px;
|
|
height: 2em;
|
|
text-align: center;
|
|
display: flex;
|
|
align-items: center;
|
|
padding: 1em;
|
|
font-size: 15px;
|
|
font-weight: 600;
|
|
text-transform: uppercase;
|
|
&-active{
|
|
background: ${theme.importerActiveFileBg};
|
|
color: ${theme.importerActiveFileFg};
|
|
}
|
|
`);
|
|
|
|
const cssTabsWrapper = styled('div', `
|
|
border-bottom: 1px solid ${theme.importerTableInfoBorder};
|
|
display: flex;
|
|
flex-direction: column;
|
|
`);
|
|
|
|
const cssWarningText = styled('div', `
|
|
margin-bottom: 8px;
|
|
color: ${theme.errorText};
|
|
white-space: pre-line;
|
|
`);
|
|
|
|
const cssTableList = styled('div', `
|
|
align-self: flex-start;
|
|
max-width: 100%;
|
|
display: flex;
|
|
padding: 0px var(--css-modal-dialog-padding-horizontal, 0px);
|
|
`);
|
|
|
|
const cssTabItemContent = styled('div', `
|
|
border: 1px solid transparent;
|
|
padding-left: 20px;
|
|
padding-right: 20px;
|
|
display: flex;
|
|
align-items: center;
|
|
align-content: flex-end;
|
|
overflow: hidden;
|
|
border-radius: 4px 4px 0px 0px;
|
|
height: 56px;
|
|
column-gap: 8px;
|
|
&-selected {
|
|
border: 1px solid ${theme.importerTableInfoBorder};
|
|
border-bottom-color: ${theme.importerMainContentBg};
|
|
background-color: ${theme.importerMainContentBg};
|
|
}
|
|
`);
|
|
|
|
const cssTabItem = styled('div', `
|
|
background: ${theme.importerOutsideBg};
|
|
position: relative;
|
|
cursor: pointer;
|
|
margin-bottom: -2px;
|
|
border-bottom: 1px solid ${theme.importerMainContentBg};
|
|
flex: 1;
|
|
&-not-selected + &-not-selected::after{
|
|
content: '';
|
|
position: absolute;
|
|
left: 0px;
|
|
top: 20%;
|
|
height: 60%;
|
|
border-left: 1px solid ${theme.importerTableInfoBorder};
|
|
}
|
|
&-not-selected .${cssBorderBottom.className} {
|
|
display: block;
|
|
}
|
|
&-not-selected .${cssFileTypeIcon.className} {
|
|
display: none;
|
|
}
|
|
&-not-selected {
|
|
min-width: 0px;
|
|
}
|
|
&-not-selected:first-child .${cssTabItemContent.className} {
|
|
padding-left: 0px;
|
|
}
|
|
`);
|
|
|
|
const cssTableLine = styled('div', `
|
|
display: flex;
|
|
align-items: center;
|
|
overflow: hidden;
|
|
flex-shrink: 1;
|
|
height: 100%;
|
|
`);
|
|
|
|
const cssTableSource = styled('div', `
|
|
overflow: hidden;
|
|
white-space: nowrap;
|
|
text-overflow: ellipsis;
|
|
flex-shrink: 1;
|
|
`);
|
|
|
|
const cssConfigAndPreview = styled('div', `
|
|
display: flex;
|
|
gap: 8px;
|
|
flex-grow: 1;
|
|
height: 0px;
|
|
background-color: ${theme.importerMainContentBg};
|
|
padding-right: var(--css-modal-dialog-padding-horizontal, 0px);
|
|
`);
|
|
|
|
const cssConfigLeft = styled('div', `
|
|
padding-right: 8px;
|
|
padding-top: 16px;
|
|
position: absolute;
|
|
inset: 0;
|
|
display: flex;
|
|
flex-direction: column;
|
|
overflow-y: auto;
|
|
width: 100%;
|
|
transition: transform 0.2s ease-in-out;
|
|
`);
|
|
|
|
const cssConfigRight = styled(cssConfigLeft, `
|
|
left: 100%;
|
|
padding-left: var(--css-modal-dialog-padding-horizontal, 0px);
|
|
`);
|
|
|
|
const cssConfigPanel = styled('div', `
|
|
width: 360px;
|
|
height: 100%;
|
|
position: relative;
|
|
overflow-x: hidden;
|
|
&-right .${cssConfigLeft.className} {
|
|
transform: translateX(-100%);
|
|
}
|
|
&-right .${cssConfigRight.className} {
|
|
transform: translateX(-100%);
|
|
}
|
|
`);
|
|
|
|
|
|
const cssPreviewColumn = styled('div', `
|
|
display: flex;
|
|
flex-direction: column;
|
|
flex-grow: 1;
|
|
`);
|
|
|
|
const cssPreview = styled('div', `
|
|
display: flex;
|
|
flex-grow: 1;
|
|
`);
|
|
|
|
const cssPreviewSpinner = styled(cssPreview, `
|
|
align-items: center;
|
|
justify-content: center;
|
|
`);
|
|
|
|
const cssOverlay = styled('div', `
|
|
background: ${theme.importerSkippedTableOverlay};
|
|
flex: 1;
|
|
display: grid;
|
|
place-items: center;
|
|
`);
|
|
|
|
const cssPreviewGrid = styled(cssPreview, `
|
|
border: 1px solid ${theme.importerPreviewBorder};
|
|
position: relative;
|
|
`);
|
|
|
|
const cssMergeOptions = styled('div', `
|
|
margin-bottom: 16px;
|
|
`);
|
|
|
|
const cssMergeOptionsToggle = styled('div', `
|
|
margin-bottom: 8px;
|
|
margin-top: 8px;
|
|
`);
|
|
|
|
const cssMergeOptionsMessage = styled('div', `
|
|
color: ${theme.lightText};
|
|
margin-bottom: 8px;
|
|
`);
|
|
|
|
const cssColumnMatchHeader = styled('div', `
|
|
display: grid;
|
|
grid-template-columns: 1fr 20px 1fr;
|
|
text-transform: uppercase;
|
|
color: ${theme.lightText};
|
|
letter-spacing: 1px;
|
|
font-size: ${vars.xsmallFontSize};
|
|
margin-bottom: 12px;
|
|
`);
|
|
|
|
const cssColumnMatchRow = styled('div', `
|
|
display: grid;
|
|
grid-template-columns: 1fr 20px 1fr 20px;
|
|
gap: 4px;
|
|
align-items: center;
|
|
--icon-color: ${theme.iconDisabled};
|
|
& + & {
|
|
margin-top: 16px;
|
|
}
|
|
`);
|
|
|
|
const cssFieldFormula = styled('div', `
|
|
flex: auto;
|
|
cursor: pointer;
|
|
margin-top: 1px;
|
|
padding-left: 24px;
|
|
--icon-color: ${theme.accentIcon};
|
|
`);
|
|
|
|
const cssDestinationFieldLabel = styled('div', `
|
|
overflow: hidden;
|
|
white-space: nowrap;
|
|
text-overflow: ellipsis;
|
|
padding-left: 4px;
|
|
cursor: unset;
|
|
background-color: ${theme.pageBg};
|
|
color: ${theme.text};
|
|
width: 100%;
|
|
height: 30px;
|
|
line-height: 16px;
|
|
font-size: ${vars.mediumFontSize};
|
|
padding: 5px;
|
|
border: 1px solid ${theme.selectButtonBorder};
|
|
border-radius: 3px;
|
|
user-select: none;
|
|
outline: none;
|
|
`);
|
|
|
|
const cssUnmatchedIcon = styled(icon, `
|
|
height: 12px;
|
|
--icon-color: ${theme.lightText};
|
|
vertical-align: bottom;
|
|
margin-bottom: 2px;
|
|
`);
|
|
|
|
const cssUnmatchedFields = styled('div', `
|
|
display: flex;
|
|
flex-wrap: wrap;
|
|
row-gap: 2px;
|
|
column-gap: 4px;
|
|
align-items: flex-start;
|
|
`);
|
|
|
|
const cssUnmatchedFieldsIntro = styled('div', `
|
|
padding: 4px 8px;
|
|
`);
|
|
|
|
const cssUnmatchedFieldsList = styled('div', `
|
|
white-space: nowrap;
|
|
text-overflow: ellipsis;
|
|
overflow: hidden;
|
|
padding-right: 16px;
|
|
color: ${theme.text};
|
|
border-radius: 8px;
|
|
padding: 4px 8px;
|
|
background-color: ${theme.pagePanelsBorder};
|
|
max-width: 160px;
|
|
cursor: pointer;
|
|
`);
|
|
|
|
const cssImportButtons = styled('div', `
|
|
padding-top: 40px;
|
|
padding-left: var(--css-modal-dialog-padding-horizontal, 0px);
|
|
padding-right: var(--css-modal-dialog-padding-horizontal, 0px);
|
|
padding-bottom: calc(var(--css-modal-dialog-padding-vertical, 0px) - 12px);
|
|
background-color: ${theme.importerMainContentBg};
|
|
`);
|
|
|
|
const cssImportButtonsLine = styled('div', `
|
|
height: 52px;
|
|
overflow: hidden;
|
|
display: flex;
|
|
gap: 8px;
|
|
align-items: flex-start;
|
|
`);
|
|
|
|
|
|
const cssTitle = styled('span._cssToFrom', `
|
|
color: ${theme.darkText};
|
|
text-transform: uppercase;
|
|
font-weight: 600;
|
|
font-size: ${vars.smallFontSize};
|
|
letter-spacing: 0.5px;
|
|
padding-left: var(--css-modal-dialog-padding-horizontal, 0px);
|
|
text-align: left;
|
|
margin-bottom: 16px;
|
|
`);
|
|
|
|
const cssDestinationWrapper = styled('div', `
|
|
margin-bottom: 1px;
|
|
/* Reuse the modal padding but move 16px to left if possible */
|
|
margin-left: max(0px, calc(var(--css-modal-dialog-padding-horizontal, 0px) - 16px));
|
|
display: flex;
|
|
align-items: center;
|
|
`);
|
|
|
|
const cssDestination = styled('div', `
|
|
--icon-color: ${theme.lightText};
|
|
align-items: center;
|
|
border-radius: 0 3px 3px 0;
|
|
padding-left: 16px;
|
|
color: ${theme.text};
|
|
cursor: pointer;
|
|
display: flex;
|
|
height: 32px;
|
|
line-height: 32px;
|
|
flex: 1;
|
|
&:hover {
|
|
background-color: ${theme.pageHoverBg};
|
|
}
|
|
&-selected, &-selected:hover {
|
|
background-color: ${theme.activePageBg};
|
|
color: ${theme.activePageFg};
|
|
--icon-color: ${theme.activePageFg};
|
|
}
|
|
`);
|
|
|
|
const cssOptions = styled('div', `
|
|
display: flex;
|
|
align-items: flex-end;
|
|
padding-bottom: 8px;
|
|
justify-content: space-between;
|
|
height: 36px;
|
|
`);
|
|
|
|
const cssTableName = styled('span', `
|
|
font-weight: 600;
|
|
`);
|
|
|
|
const cssNavigation = styled('div', `
|
|
display: flex;
|
|
align-items: center;
|
|
margin-bottom: 8px;
|
|
`);
|
|
|
|
const cssDetailsIcon = styled(icon, `
|
|
flex: none;
|
|
color: ${theme.controlFg};
|
|
--icon-color: ${theme.controlFg};
|
|
margin-left: 4px;
|
|
margin-top: -4px;
|
|
cursor: pointer;
|
|
&:hover {
|
|
--icon-color: ${theme.controlHoverFg};
|
|
}
|
|
`);
|
|
|
|
const cssError = styled(icon, `
|
|
--icon-color: ${theme.iconError};
|
|
right: 2px;
|
|
position: absolute;
|
|
z-index: 1;
|
|
top: calc(50% - 8px);
|
|
`);
|
|
|
|
const cssNavigationIcon = styled(icon, `
|
|
flex: none;
|
|
color: ${theme.controlFg};
|
|
--icon-color: ${theme.controlFg};
|
|
margin-right: 4px;
|
|
margin-top: -3px;
|
|
width: 12px;
|
|
`);
|
|
|
|
const cssFlexBaseline = styled('div', `
|
|
display: flex;
|
|
align-items: baseline;
|
|
`);
|
|
|
|
const cssSelected = styled(cssTableSource, `
|
|
&-skip {
|
|
color: ${theme.lightText};
|
|
}
|
|
`);
|
|
|
|
const cssIcon180 = styled(icon, `
|
|
transform: rotate(180deg);
|
|
`);
|
|
|
|
const cssGreenIcon = styled(`div`, `
|
|
--icon-color: ${theme.accentIcon};
|
|
`);
|
|
|
|
|
|
const cssColumnMappingNav = styled('span', `
|
|
text-transform: uppercase;
|
|
color: ${theme.darkText};
|
|
text-transform: uppercase;
|
|
font-weight: 600;
|
|
font-size: ${vars.smallFontSize};
|
|
letter-spacing: 0.5px;
|
|
`);
|
|
|
|
const cssSlash = styled('div', `
|
|
padding: 0px 4px;
|
|
font-size: ${vars.xsmallFontSize};
|
|
color: ${theme.lightText};
|
|
`);
|
|
|
|
const cssDestinationTableSecondary = styled(textButton, `
|
|
text-transform: uppercase;
|
|
font-size: ${vars.smallFontSize};
|
|
letter-spacing: 0.5px;
|
|
text-align: left;
|
|
margin-bottom: 16px;
|
|
color: ${theme.lightText};
|
|
`);
|