1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
#ifndef IMPORTPLUGIN_H
#define IMPORTPLUGIN_H
#include "plugin.h"
#include "services/importmanager.h"
class QIODevice;
class CfgMain;
/**
* @brief Provides support for particular import format.
*
* All import methods in this class should report any warnings, error messages, etc through the NotifyManager,
* that is by using notifyError() and its family methods.
*/
class ImportPlugin : virtual public Plugin
{
public:
/**
* @brief Pair of column name and its data type.
*/
typedef QPair<QString,QString> ColumnDefinition;
/**
* @brief Used to show this plugin in the combo of data source types in the import dialog.
* @return String representing this plugin in the import dialog.
*/
virtual QString getDataSourceTypeName() const = 0;
/**
* @brief Tells which standard import options should be available on to the user.
* @return OR-ed set of standard option enums.
*/
virtual ImportManager::StandardConfigFlags standardOptionsToEnable() const = 0;
/**
* @brief Provides file name filter for file dialog.
* @return Filter compliant with QFileDialog documentation.
*
* If your plugin does not return ImportManager::FILE_NAME, this method can simply return QString().
* If your plugin does use input file name, then this method can (but don't have to) return file name filter
* to match expected files when user browses for the input file.
*
* The filter value (if not null) is passed directly to the QFileDialog.
*/
virtual QString getFileFilter() const = 0;
/**
* @brief Called before each import that user makes.
* @param config Standard options configured by user in the import dialog.
* @return true if everything looks fine from plugin's perspective, or false otherwise.
*
* In case there were some problems at this step, plugin should return false, but before that it should tell what was wrong using NotifyManager's global shortcut
* method: notifyError().
*/
virtual bool beforeImport(const ImportManager::StandardImportConfig& config) = 0;
/**
* @brief Called after import process has been finished (successfully or not).
*
* Implement this method to clean up any resources that the plugin has initialized before.
*/
virtual void afterImport() = 0;
/**
* @brief Provides list of columns (with their datatypes) for the data to be imported.
* @return List of columns, each column consists of column name and its data type definition.
*
* The ColumnDefinition is actually a QPair of two QString types. First in the pair is column name, second is column's data type,
* as a string representation.
*
* Let's say your plugin wants to import data that fits into 2 columns, first of <tt>INTEGER</tt> type and the second of <tt>VARCHAR(0, 5)</tt> type.
* You would write it like this:
* @code
* QList<ColumnDefinition> list;
* list << ColumnDefinition("column1", "INTEGER");
* list << ColumnDefinition("column2", "VARCHAR (0, 5)");
* return list;
* @endcode
*/
virtual QList<ColumnDefinition> getColumns() const = 0;
/**
* @brief Provides next set of data from the data source.
* @return List of values, where number of elements must be equal to number of columns returned from getColumns().
*
* This is essential import plugin method. It provides the data.
* This method simply provides next row of the data for a table.
* It will be called again and again, until it returns empty list, which will be interpreted as the end of data to import.
*/
virtual QList<QVariant> next() = 0;
/**
* @brief Provides config object that holds configuration for importing.
* @return Config object, or null if the importing with this plugin is not configurable.
*/
virtual CfgMain* getConfig() = 0;
/**
* @brief Provides name of the form to use for configuration of import dialog.
* @return Name of the form (toplevel QWidget in the ui file).
*
* If importing with this plugin is not configurable (i.e. getConfig() returns null),
* then this method is not even called, so it can return anything, just to satisfy method
* return type. In that case good idea is to always return QString().
*
* @see FormManager
*/
virtual QString getImportConfigFormName() const = 0;
/**
* @brief Called when the UI expects any configuration options to be re-validated.
* @return true when validation was successful, or false if any error occured.
*
* When user interacts with the UI in a way that it doesn't change the config values,
* but it still requires some options to be re-validated, this method is called.
*
* It should validate any configuration values defined with CFG_CATEGORY and CFG_ENTRY
* and post the validation results by calling IMPORT_MANAGER->handleValidationFromPlugin()
* for every validated CfgEntry.
*
* This is also a good idea to connect to the CfgEntry::changed() signal for entries that should be validated
* and call this method from the slot, so any changes to the configuration values will be
* immediately validated and reflected on the UI.
*
* In this method you can also call IMPORT_MANAGER->configStateUpdateFromPlugin() to adjust options UI
* to the current config values.
*/
virtual bool validateOptions() = 0;
};
#endif // IMPORTPLUGIN_H
|
