Differential D6037 Diff 16760 src/plugins/scripting/kexidb/kexidbmodule.cpp

Changeset View

Standalone View

View Options

src/plugins/scripting/kexidb/kexidbmodule.cpp

Show All 17 Lines
18 ***************************************************************************/ 18​ ***************************************************************************/
19 19​
20#include "kexidbmodule.h" 20​#include "kexidbmodule.h"
21#include "kexidbconnection.h" 21​#include "kexidbconnection.h"
22#include "kexidbdriver.h" 22​#include "kexidbdriver.h"
23#include "kexidbconnectiondata.h" 23​#include "kexidbconnectiondata.h"
24#include "kexidbfield.h" 24​#include "kexidbfield.h"
25#include "kexidbschema.h" 25​#include "kexidbschema.h"
26​#include "kexiscriptingdebug.h"
26 27​
27#include <KDbDriver> 28​#include <KDbDriver>
28#include <KDbConnectionData> 29​#include <KDbConnectionData>
29#include <KDbField> 30​#include <KDbField>
30#include <KDbTableSchema> 31​#include <KDbTableSchema>
31#include <KDbQuerySchema> 32​#include <KDbQuerySchema>
32 33​
33#include <KConfigGroup> 34​#include <KConfigGroup>
35​#include <KConfig>
34 36​
35#include <QDebug> 37​#include <QDebug>
36#include <QMimeDatabase> 38​#include <QMimeDatabase>
39​#include <QUrl>
37 40​
38// The as version() published versionnumber of this kross-module. 41​// The as version() published versionnumber of this kross-module.
39#define KROSS_KEXIDB_VERSION 1 42​#define KROSS_KEXIDB_VERSION 1
40 43​
41extern "C" 44​extern "C"
42{ 45​{
43 /** 46​ /**
44 * Exported an loadable function as entry point to use 47​ * Exported an loadable function as entry point to use
45 * the \a KexiDBModule. 48​ * the \a KexiDBModule.
46 */ 49​ */
47 KDE_EXPORT QObject* krossmodule() { 50​ /*KEXI_EXPORT*/ QObject* krossmodule() {
48 return new Scripting::KexiDBModule(); 51​ return new Scripting::KexiDBModule();
49 } 52​ }
50} 53​}
51 54​
52using namespace Scripting; 55​using namespace Scripting;
53 56​
54KexiDBModule::KexiDBModule(QObject* parent) 57​KexiDBModule::KexiDBModule(QObject* parent)
55 : QObject(parent) 58​ : QObject(parent)
56{ 59​{
57 setObjectName("KexiDB"); 60​ setObjectName("KexiDB");
58} 61​}
59 62​
60KexiDBModule::~KexiDBModule() 63​KexiDBModule::~KexiDBModule()
61{ 64​{
62} 65​}
63 66​
64int KexiDBModule::version() 67​int KexiDBModule::version()
65{ 68​{
66 return KROSS_KEXIDB_VERSION; 69​ return KROSS_KEXIDB_VERSION;
67} 70​}
68 71​
69const QStringList KexiDBModule::driverNames() 72​const QStringList KexiDBModule::driverNames()
70{ 73​{
71 return m_drivermanager.driverNames(); 74​ return m_drivermanager.driverIds();
72} 75​}
73 76​
74QObject* KexiDBModule::driver(const QString& drivername) 77​QObject* KexiDBModule::driver(const QString& drivername)
75{ 78​{
76 QPointer< KDbDriver > driver = m_drivermanager.driver(drivername); // caching is done by the DriverManager 79​ QPointer< KDbDriver > driver = m_drivermanager.driver(drivername); // caching is done by the DriverManager
77 if (! driver) { 80​ if (! driver) {
78 qWarning() << "No such driver '%1'" << drivername; 81​ qWarning() << "No such driver '%1'" << drivername;
79 return 0; 82​ return 0;
80 } 83​ }
81 if (driver->error()) { 84​ if (driver->result().isError()) {
82 qWarning() << "Error for drivername" << drivername << driver->errorMsg(); 85​ qWarning() << "Error for drivername" << drivername << driver->result().message();
83 return 0; 86​ return 0;
84 } 87​ }
85 return new KexiDBDriver(this, driver); 88​ return new KexiDBDriver(this, driver);
86} 89​}
87 90​
88const QString KexiDBModule::lookupByMime(const QString& mimetype) 91​const QString KexiDBModule::lookupByMime(const QString& mimetype)
staniekUnsubmitted
Done

Remove const from return type

staniek: Remove const from return type
89{ 92​{
90 return m_drivermanager.lookupByMime(mimetype); 93​ return m_drivermanager.driverIdsForMimeType(mimetype).at(0);
staniekUnsubmitted
Done

check is the list is not empty

staniek: check is the list is not empty
91} 94​}
92 95​
93const QString KexiDBModule::mimeForFile(const QString& filename) 96​const QString KexiDBModule::mimeForFile(const QString& filename)
94{ 97​{
95 QMimeDatabase db; 98​ QMimeDatabase db;
96 QString mimename = db.mimeTypeForFile(filename, QMimeDatabase::MatchContent).name(); 99​ QString mimename = db.mimeTypeForFile(filename, QMimeDatabase::MatchContent).name();
97 if (mimename.isEmpty() || mimename == "application/octet-stream" || mimename == "text/plain") { 100​ if (mimename.isEmpty() || mimename == "application/octet-stream" || mimename == "text/plain") {
98 mimename = db.mimeTypeForUrl(filename).name(); 101​ mimename = db.mimeTypeForUrl(QUrl(filename)).name();
staniekUnsubmitted
Done

probably QUrl::fromLocalFile is better if we assume local files, otherwise only true URLs will work

staniek: probably QUrl::fromLocalFile is better if we assume local files, otherwise only true URLs will…
99 } 102​ }
100 return mimename; 103​ return mimename;
101} 104​}
102 105​
103QObject* KexiDBModule::createConnectionData() 106​QObject* KexiDBModule::createConnectionData()
104{ 107​{
105 return new KexiDBConnectionData(this, new KDbConnectionData(), true); 108​ return new KexiDBConnectionData();
106} 109​}
107 110​
108QObject* KexiDBModule::createConnectionDataByFile(const QString& filename) 111​QObject* KexiDBModule::createConnectionDataByFile(const QString& filename)
109{ 112​{
110 //! @todo reuse the original code! 113​ //! @todo reuse the original code!
111 QMimeDatabase db; 114​ QMimeDatabase db;
112 QString mimename = db.mimeTypeForFile(filename, QMimeDatabase::MatchContent).name(); 115​ QString mimename = db.mimeTypeForFile(filename, QMimeDatabase::MatchContent).name();
113 if (mimename.isEmpty() || mimename == "application/octet-stream" || mimename == "text/plain") { 116​ if (mimename.isEmpty() || mimename == "application/octet-stream" || mimename == "text/plain") {
114 mimename = db.mimeTypeForUrl(filename).name(); 117​ mimename = db.mimeTypeForUrl(QUrl(filename)).name();
staniekUnsubmitted
Done

Like above

staniek: Like above
115 } 118​ }
116 if (mimename == "application/x-kexiproject-shortcut" || mimename == "application/x-kexi-connectiondata") { 119​ if (mimename == "application/x-kexiproject-shortcut" || mimename == "application/x-kexi-connectiondata") {
117 KConfig _config(filename, KConfig::NoGlobals); 120​ KConfig _config(filename, KConfig::NoGlobals);
118 121​
119 QString groupkey; 122​ QString groupkey;
120 foreach(const QString &s, _config.groupList()) { 123​ foreach(const QString &s, _config.groupList()) {
121 if (s.toLower() != "file information") { 124​ if (s.toLower() != "file information") {
122 groupkey = s; 125​ groupkey = s;
123 break; 126​ break;
124 } 127​ }
125 } 128​ }
129​
126 if (groupkey.isNull()) { 130​ if (groupkey.isNull()) {
127 qDebug() << "No groupkey, filename=" << filename; 131​ KexiScriptingDebug() << "No groupkey, filename=" << filename;
staniekUnsubmitted
Done

-> KexiScriptingWarning

staniek: -> KexiScriptingWarning
128 return 0; 132​ return 0;
129 } 133​ }
130 134​
131 KConfigGroup config(&_config, groupkey); 135​ KConfigGroup config(&_config, groupkey);
132 KDbConnectionData* data = new KDbConnectionData(); 136​ KDbConnectionData* data = new KDbConnectionData();
133 int version = config.readEntry("version", 2); //KexiDBShortcutFile_version 137​ int version = config.readEntry("version", 2); //KexiDBShortcutFile_version
134 data->setDatabaseName(QString()); 138​ data->setDatabaseName(QString());
135 data->setCaption(config.readEntry("caption")); 139​ data->setCaption(config.readEntry("caption"));
Show All 15 Lines
151 } 155​ }
152 if (data->password().isEmpty()) { 156​ if (data->password().isEmpty()) {
153 data->setPassword(config.readEntry("password")); 157​ data->setPassword(config.readEntry("password"));
154 } 158​ }
155 159​
156 data->setSavePassword(!data->password().isEmpty()); 160​ data->setSavePassword(!data->password().isEmpty());
157 data->setUserName(config.readEntry("user")); 161​ data->setUserName(config.readEntry("user"));
158 162​
159 KexiDBConnectionData* c = new KexiDBConnectionData(this, data, true); 163​ KexiDBConnectionData* c = new KexiDBConnectionData(this, data);
160 c->setDatabaseName(dbname); 164​ c->setDatabaseName(dbname);
161 return c; 165​ return c;
162 } 166​ }
163 167​
164 const QStringList driverIds = m_drivermanager.driverIdsForMimeType(mimename); 168​ const QStringList driverIds = m_drivermanager.driverIdsForMimeType(mimename);
165 if (driverIds.isEmpty()) { 169​ if (driverIds.isEmpty()) {
166 qDebug() << "No driver, filename=" << filename << "mimename=" << mimename; 170​ KexiScriptingDebug() << "No driver, filename=" << filename << "mimename=" << mimename;
staniekUnsubmitted
Done

-> KexiScriptingWarning

staniek: -> KexiScriptingWarning
167 return 0; 171​ return 0;
168 } 172​ }
169 173​
170 KDbConnectionData* data = new KDbConnectionData(); 174​ KDbConnectionData* data = new KDbConnectionData();
171 data->setDatabaseName(filename); 175​ data->setDatabaseName(filename);
172 //! @todo there can be more than one driver 176​ //! @todo there can be more than one driver
173 data->setDriverId(driverIds.first()); 177​ data->setDriverId(driverIds.first());
174 return new KexiDBConnectionData(this, data, true); 178​ return new KexiDBConnectionData(this, data);
175} 179​}
176 180​
177QObject* KexiDBModule::field() 181​QObject* KexiDBModule::field()
178{ 182​{
179 return new KexiDBField(this, new KDbField(), true); 183​ return new KexiDBField(this, new KDbField(), true);
180} 184​}
181 185​
182QObject* KexiDBModule::tableSchema(const QString& tablename) 186​QObject* KexiDBModule::tableSchema(const QString& tablename)
183{ 187​{
184 return new KexiDBTableSchema(this, new KDbTableSchema(tablename), true); 188​ return new KexiDBTableSchema(this, new KDbTableSchema(tablename), true);
185} 189​}
186 190​
187QObject* KexiDBModule::querySchema() 191​QObject* KexiDBModule::querySchema()
188{ 192​{
189 return new KexiDBQuerySchema(this, new KDbQuerySchema(), true); 193​ return new KexiDBQuerySchema(this, new KDbQuerySchema(), true);
190} 194​}
191 195​
192QObject* KexiDBModule::connectionWrapper(QObject* connection) 196​QObject* KexiDBModule::connectionWrapper(KDbConnection* connection)
193{ 197​{
194 KDbConnection* c = dynamic_cast< KDbConnection* >(connection); 198​ return new KexiDBConnection(connection);
195 return c ? new KexiDBConnection(c) : 0; ​
196} 199​}
197 200​