##// END OF EJS Templates
GIT_REPOSITORIES » LPP » Users » mperrinel » SciQLop-fork
RSS

Fork of HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop

Add fix for default repository init
perrinel -
r1310:f8c4dc0020e5
parent child
Show More
Side by Side Unified
Context file:
r1310:f8c4dc0020e5 Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,83 +1,84
1 #ifndef SCIQLOP_CATALOGUECONTROLLER_H
1 #ifndef SCIQLOP_CATALOGUECONTROLLER_H
2 #define SCIQLOP_CATALOGUECONTROLLER_H
2 #define SCIQLOP_CATALOGUECONTROLLER_H
3
3
4 #include "CoreGlobal.h"
4 #include "CoreGlobal.h"
5
5
6 #include <Data/SqpRange.h>
6 #include <Data/SqpRange.h>
7
7
8 #include <QLoggingCategory>
8 #include <QLoggingCategory>
9 #include <QObject>
9 #include <QObject>
10 #include <QUuid>
10 #include <QUuid>
11
11
12 #include <Common/spimpl.h>
12 #include <Common/spimpl.h>
13
13
14 #include <memory>
14 #include <memory>
15
15
16 class DBCatalogue;
16 class DBCatalogue;
17 class DBEvent;
17 class DBEvent;
18 class DBEventProduct;
18 class DBEventProduct;
19
19
20 Q_DECLARE_LOGGING_CATEGORY(LOG_CatalogueController)
20 Q_DECLARE_LOGGING_CATEGORY(LOG_CatalogueController)
21
21
22 class DataSourceItem;
22 class DataSourceItem;
23 class Variable;
23 class Variable;
24
24
25 /**
25 /**
26 * @brief The CatalogueController class aims to handle catalogues and event using the CatalogueAPI
26 * @brief The CatalogueController class aims to handle catalogues and event using the CatalogueAPI
27 * library.
27 * library.
28 */
28 */
29 class SCIQLOP_CORE_EXPORT CatalogueController : public QObject {
29 class SCIQLOP_CORE_EXPORT CatalogueController : public QObject {
30 Q_OBJECT
30 Q_OBJECT
31 public:
31 public:
32 explicit CatalogueController(QObject *parent = 0);
32 explicit CatalogueController(QObject *parent = 0);
33 virtual ~CatalogueController();
33 virtual ~CatalogueController();
34
34
35 // DB
35 // DB
36 QStringList getRepositories() const;
36 QStringList getRepositories() const;
37 void addDB(const QString &dbPath);
37 void addDB(const QString &dbPath);
38 void saveDB(const QString &destinationPath, const QString &repository);
38 void saveDB(const QString &destinationPath, const QString &repository);
39
39
40 // Event
40 // Event
41 /// retrieveEvents with empty repository retrieve them from the default repository
41 /// retrieveEvents with empty repository retrieve them from the default repository
42 std::list<std::shared_ptr<DBEvent> > retrieveEvents(const QString &repository) const;
42 std::list<std::shared_ptr<DBEvent> > retrieveEvents(const QString &repository) const;
43 std::list<std::shared_ptr<DBEvent> > retrieveAllEvents() const;
43 std::list<std::shared_ptr<DBEvent> > retrieveAllEvents() const;
44 std::list<std::shared_ptr<DBEvent> >
44
45 retrieveEventsFromCatalogue(std::shared_ptr<DBCatalogue> catalogue) const;
46 void addEvent(std::shared_ptr<DBEvent> event);
45 void addEvent(std::shared_ptr<DBEvent> event);
47 void updateEvent(std::shared_ptr<DBEvent> event);
46 void updateEvent(std::shared_ptr<DBEvent> event);
48 void updateEventProduct(std::shared_ptr<DBEventProduct> eventProduct);
47 void updateEventProduct(std::shared_ptr<DBEventProduct> eventProduct);
49 void removeEvent(std::shared_ptr<DBEvent> event);
48 void removeEvent(std::shared_ptr<DBEvent> event);
50 // void trashEvent(std::shared_ptr<DBEvent> event);
49 // void trashEvent(std::shared_ptr<DBEvent> event);
51 // void restore(std::shared_ptr<DBEvent> event);
50 // void restore(std::shared_ptr<DBEvent> event);
52 void saveEvent(std::shared_ptr<DBEvent> event);
51 void saveEvent(std::shared_ptr<DBEvent> event);
53 void discardEvent(std::shared_ptr<DBEvent> event);
52 void discardEvent(std::shared_ptr<DBEvent> event);
54 bool eventHasChanges(std::shared_ptr<DBEvent> event) const;
53 bool eventHasChanges(std::shared_ptr<DBEvent> event) const;
55
54
56 // Catalogue
55 // Catalogue
56 std::list<std::shared_ptr<DBEvent> >
57 retrieveEventsFromCatalogue(std::shared_ptr<DBCatalogue> catalogue) const;
57 // bool createCatalogue(const QString &name, QVector<QUuid> eventList);
58 // bool createCatalogue(const QString &name, QVector<QUuid> eventList);
58 /// retrieveEvents with empty repository retrieve them from the default repository
59 /// retrieveEvents with empty repository retrieve them from the default repository
59 std::list<std::shared_ptr<DBCatalogue> > retrieveCatalogues(const QString &repository
60 std::list<std::shared_ptr<DBCatalogue> > retrieveCatalogues(const QString &repository
60 = QString()) const;
61 = QString()) const;
61 void updateCatalogue(std::shared_ptr<DBCatalogue> catalogue);
62 void updateCatalogue(std::shared_ptr<DBCatalogue> catalogue);
62 void removeCatalogue(std::shared_ptr<DBCatalogue> catalogue);
63 void removeCatalogue(std::shared_ptr<DBCatalogue> catalogue);
63 void saveCatalogue(std::shared_ptr<DBCatalogue> catalogue);
64 void saveCatalogue(std::shared_ptr<DBCatalogue> catalogue);
64
65
65 void saveAll();
66 void saveAll();
66 bool hasChanges() const;
67 bool hasChanges() const;
67
68
68 /// Returns the MIME data associated to a list of variables
69 /// Returns the MIME data associated to a list of variables
69 QByteArray mimeDataForEvents(const QVector<std::shared_ptr<DBEvent> > &events) const;
70 QByteArray mimeDataForEvents(const QVector<std::shared_ptr<DBEvent> > &events) const;
70
71
71 /// Returns the list of variables contained in a MIME data
72 /// Returns the list of variables contained in a MIME data
72 QVector<std::shared_ptr<DBEvent> > eventsForMimeData(const QByteArray &mimeData) const;
73 QVector<std::shared_ptr<DBEvent> > eventsForMimeData(const QByteArray &mimeData) const;
73
74
74 public slots:
75 public slots:
75 /// Manage init/end of the controller
76 /// Manage init/end of the controller
76 void initialize();
77 void initialize();
77
78
78 private:
79 private:
79 class CatalogueControllerPrivate;
80 class CatalogueControllerPrivate;
80 spimpl::unique_impl_ptr<CatalogueControllerPrivate> impl;
81 spimpl::unique_impl_ptr<CatalogueControllerPrivate> impl;
81 };
82 };
82
83
83 #endif // SCIQLOP_CATALOGUECONTROLLER_H
84 #endif // SCIQLOP_CATALOGUECONTROLLER_H
Show file before | Show file after | Hide comments
@@ -1,420 +1,434
1 #include <Catalogue/CatalogueController.h>
1 #include <Catalogue/CatalogueController.h>
2
2
3 #include <Variable/Variable.h>
3 #include <Variable/Variable.h>
4
4
5 #include <CatalogueDao.h>
5 #include <CatalogueDao.h>
6
6
7 #include <ComparaisonPredicate.h>
7 #include <ComparaisonPredicate.h>
8 #include <CompoundPredicate.h>
8 #include <CompoundPredicate.h>
9 #include <DBCatalogue.h>
9 #include <DBCatalogue.h>
10 #include <DBEvent.h>
10 #include <DBEvent.h>
11 #include <DBEventProduct.h>
11 #include <DBEventProduct.h>
12 #include <DBTag.h>
12 #include <DBTag.h>
13 #include <IRequestPredicate.h>
13 #include <IRequestPredicate.h>
14
14
15 #include <QDataStream>
15 #include <QDataStream>
16 #include <QMutex>
16 #include <QMutex>
17 #include <QThread>
17 #include <QThread>
18
18
19 #include <QDir>
19 #include <QDir>
20 #include <QStandardPaths>
20 #include <QStandardPaths>
21
21
22 Q_LOGGING_CATEGORY(LOG_CatalogueController, "CatalogueController")
22 Q_LOGGING_CATEGORY(LOG_CatalogueController, "CatalogueController")
23
23
24 namespace {
24 namespace {
25
25
26 static QString REPOSITORY_WORK_SUFFIX = QString{"_work"};
26 static QString REPOSITORY_WORK_SUFFIX = QString{"_work"};
27 static QString REPOSITORY_TRASH_SUFFIX = QString{"_trash"};
27 static QString REPOSITORY_TRASH_SUFFIX = QString{"_trash"};
28 }
28 }
29
29
30 class CatalogueController::CatalogueControllerPrivate {
30 class CatalogueController::CatalogueControllerPrivate {
31
31
32 public:
32 public:
33 explicit CatalogueControllerPrivate(CatalogueController *parent) : m_Q{parent} {}
33 explicit CatalogueControllerPrivate(CatalogueController *parent) : m_Q{parent} {}
34
34
35 CatalogueDao m_CatalogueDao;
35 CatalogueDao m_CatalogueDao;
36
36
37 QStringList m_RepositoryList;
37 QStringList m_RepositoryList;
38 CatalogueController *m_Q;
38 CatalogueController *m_Q;
39
39
40 QSet<QString> m_EventKeysWithChanges;
40 QSet<QString> m_EventKeysWithChanges;
41
41
42 QString eventUniqueKey(const std::shared_ptr<DBEvent> &event) const;
42 QString eventUniqueKey(const std::shared_ptr<DBEvent> &event) const;
43
43
44 void copyDBtoDB(const QString &dbFrom, const QString &dbTo);
44 void copyDBtoDB(const QString &dbFrom, const QString &dbTo);
45 QString toWorkRepository(QString repository);
45 QString toWorkRepository(QString repository);
46 QString toSyncRepository(QString repository);
46 QString toSyncRepository(QString repository);
47 void savAllDB();
47 void savAllDB();
48
48
49 void saveEvent(std::shared_ptr<DBEvent> event, bool persist = true);
49 void saveEvent(std::shared_ptr<DBEvent> event, bool persist = true);
50 void saveCatalogue(std::shared_ptr<DBCatalogue> catalogue, bool persist = true);
50 void saveCatalogue(std::shared_ptr<DBCatalogue> catalogue, bool persist = true);
51 };
51 };
52
52
53 CatalogueController::CatalogueController(QObject *parent)
53 CatalogueController::CatalogueController(QObject *parent)
54 : impl{spimpl::make_unique_impl<CatalogueControllerPrivate>(this)}
54 : impl{spimpl::make_unique_impl<CatalogueControllerPrivate>(this)}
55 {
55 {
56 qCDebug(LOG_CatalogueController()) << tr("CatalogueController construction")
56 qCDebug(LOG_CatalogueController()) << tr("CatalogueController construction")
57 << QThread::currentThread();
57 << QThread::currentThread();
58 }
58 }
59
59
60 CatalogueController::~CatalogueController()
60 CatalogueController::~CatalogueController()
61 {
61 {
62 qCDebug(LOG_CatalogueController()) << tr("CatalogueController destruction")
62 qCDebug(LOG_CatalogueController()) << tr("CatalogueController destruction")
63 << QThread::currentThread();
63 << QThread::currentThread();
64 }
64 }
65
65
66 QStringList CatalogueController::getRepositories() const
66 QStringList CatalogueController::getRepositories() const
67 {
67 {
68 return impl->m_RepositoryList;
68 return impl->m_RepositoryList;
69 }
69 }
70
70
71 void CatalogueController::addDB(const QString &dbPath)
71 void CatalogueController::addDB(const QString &dbPath)
72 {
72 {
73 QDir dbDir(dbPath);
73 QDir dbDir(dbPath);
74 if (dbDir.exists()) {
74 if (dbDir.exists()) {
75 auto dirName = dbDir.dirName();
75 auto dirName = dbDir.dirName();
76
76
77 if (std::find(impl->m_RepositoryList.cbegin(), impl->m_RepositoryList.cend(), dirName)
77 if (std::find(impl->m_RepositoryList.cbegin(), impl->m_RepositoryList.cend(), dirName)
78 != impl->m_RepositoryList.cend()) {
78 != impl->m_RepositoryList.cend()) {
79 qCCritical(LOG_CatalogueController())
79 qCCritical(LOG_CatalogueController())
80 << tr("Impossible to addDB that is already loaded");
80 << tr("Impossible to addDB that is already loaded");
81 }
81 }
82
82
83 if (!impl->m_CatalogueDao.addDB(dbPath, dirName)) {
83 if (!impl->m_CatalogueDao.addDB(dbPath, dirName)) {
84 qCCritical(LOG_CatalogueController())
84 qCCritical(LOG_CatalogueController())
85 << tr("Impossible to addDB %1 from %2 ").arg(dirName, dbPath);
85 << tr("Impossible to addDB %1 from %2 ").arg(dirName, dbPath);
86 }
86 }
87 else {
87 else {
88 impl->m_RepositoryList << dirName;
88 impl->m_RepositoryList << dirName;
89 impl->copyDBtoDB(dirName, impl->toWorkRepository(dirName));
89 impl->copyDBtoDB(dirName, impl->toWorkRepository(dirName));
90 }
90 }
91 }
91 }
92 else {
92 else {
93 qCCritical(LOG_CatalogueController()) << tr("Impossible to addDB that not exists: ")
93 qCCritical(LOG_CatalogueController()) << tr("Impossible to addDB that not exists: ")
94 << dbPath;
94 << dbPath;
95 }
95 }
96 }
96 }
97
97
98 void CatalogueController::saveDB(const QString &destinationPath, const QString &repository)
98 void CatalogueController::saveDB(const QString &destinationPath, const QString &repository)
99 {
99 {
100 if (!impl->m_CatalogueDao.saveDB(destinationPath, repository)) {
100 if (!impl->m_CatalogueDao.saveDB(destinationPath, repository)) {
101 qCCritical(LOG_CatalogueController())
101 qCCritical(LOG_CatalogueController())
102 << tr("Impossible to saveDB %1 from %2 ").arg(repository, destinationPath);
102 << tr("Impossible to saveDB %1 from %2 ").arg(repository, destinationPath);
103 }
103 }
104 }
104 }
105
105
106 std::list<std::shared_ptr<DBEvent> >
106 std::list<std::shared_ptr<DBEvent> >
107 CatalogueController::retrieveEvents(const QString &repository) const
107 CatalogueController::retrieveEvents(const QString &repository) const
108 {
108 {
109 QString dbDireName = repository.isEmpty() ? REPOSITORY_DEFAULT : repository;
109 QString dbDireName = repository.isEmpty() ? REPOSITORY_DEFAULT : repository;
110
110
111 auto eventsShared = std::list<std::shared_ptr<DBEvent> >{};
111 auto eventsShared = std::list<std::shared_ptr<DBEvent> >{};
112 auto events = impl->m_CatalogueDao.getEvents(impl->toWorkRepository(dbDireName));
112 auto events = impl->m_CatalogueDao.getEvents(impl->toWorkRepository(dbDireName));
113 for (auto event : events) {
113 for (auto event : events) {
114 eventsShared.push_back(std::make_shared<DBEvent>(event));
114 eventsShared.push_back(std::make_shared<DBEvent>(event));
115 }
115 }
116 return eventsShared;
116 return eventsShared;
117 }
117 }
118
118
119 std::list<std::shared_ptr<DBEvent> > CatalogueController::retrieveAllEvents() const
119 std::list<std::shared_ptr<DBEvent> > CatalogueController::retrieveAllEvents() const
120 {
120 {
121 auto eventsShared = std::list<std::shared_ptr<DBEvent> >{};
121 auto eventsShared = std::list<std::shared_ptr<DBEvent> >{};
122 for (auto repository : impl->m_RepositoryList) {
122 for (auto repository : impl->m_RepositoryList) {
123 eventsShared.splice(eventsShared.end(), retrieveEvents(repository));
123 eventsShared.splice(eventsShared.end(), retrieveEvents(repository));
124 }
124 }
125
125
126 return eventsShared;
126 return eventsShared;
127 }
127 }
128
128
129 std::list<std::shared_ptr<DBEvent> >
129 std::list<std::shared_ptr<DBEvent> >
130 CatalogueController::retrieveEventsFromCatalogue(std::shared_ptr<DBCatalogue> catalogue) const
130 CatalogueController::retrieveEventsFromCatalogue(std::shared_ptr<DBCatalogue> catalogue) const
131 {
131 {
132 auto eventsShared = std::list<std::shared_ptr<DBEvent> >{};
132 auto eventsShared = std::list<std::shared_ptr<DBEvent> >{};
133 auto events = impl->m_CatalogueDao.getCatalogueEvents(*catalogue);
133 auto events = impl->m_CatalogueDao.getCatalogueEvents(*catalogue);
134 for (auto event : events) {
134 for (auto event : events) {
135 eventsShared.push_back(std::make_shared<DBEvent>(event));
135 eventsShared.push_back(std::make_shared<DBEvent>(event));
136 }
136 }
137 return eventsShared;
137 return eventsShared;
138 }
138 }
139
139
140 void CatalogueController::updateEvent(std::shared_ptr<DBEvent> event)
140 void CatalogueController::updateEvent(std::shared_ptr<DBEvent> event)
141 {
141 {
142 event->setRepository(impl->toWorkRepository(event->getRepository()));
142 event->setRepository(impl->toWorkRepository(event->getRepository()));
143
143
144 auto uniqueId = impl->eventUniqueKey(event);
144 auto uniqueId = impl->eventUniqueKey(event);
145 impl->m_EventKeysWithChanges.insert(uniqueId);
145 impl->m_EventKeysWithChanges.insert(uniqueId);
146
146
147 impl->m_CatalogueDao.updateEvent(*event);
147 impl->m_CatalogueDao.updateEvent(*event);
148 }
148 }
149
149
150 void CatalogueController::updateEventProduct(std::shared_ptr<DBEventProduct> eventProduct)
150 void CatalogueController::updateEventProduct(std::shared_ptr<DBEventProduct> eventProduct)
151 {
151 {
152 impl->m_CatalogueDao.updateEventProduct(*eventProduct);
152 impl->m_CatalogueDao.updateEventProduct(*eventProduct);
153 }
153 }
154
154
155 void CatalogueController::removeEvent(std::shared_ptr<DBEvent> event)
155 void CatalogueController::removeEvent(std::shared_ptr<DBEvent> event)
156 {
156 {
157 // Remove it from both repository and repository_work
157 // Remove it from both repository and repository_work
158 event->setRepository(impl->toWorkRepository(event->getRepository()));
158 event->setRepository(impl->toWorkRepository(event->getRepository()));
159 impl->m_CatalogueDao.removeEvent(*event);
159 impl->m_CatalogueDao.removeEvent(*event);
160 event->setRepository(impl->toSyncRepository(event->getRepository()));
160 event->setRepository(impl->toSyncRepository(event->getRepository()));
161 impl->m_CatalogueDao.removeEvent(*event);
161 impl->m_CatalogueDao.removeEvent(*event);
162 impl->savAllDB();
162 impl->savAllDB();
163 }
163 }
164
164
165 void CatalogueController::addEvent(std::shared_ptr<DBEvent> event)
165 void CatalogueController::addEvent(std::shared_ptr<DBEvent> event)
166 {
166 {
167 event->setRepository(impl->toWorkRepository(event->getRepository()));
167 event->setRepository(impl->toWorkRepository(event->getRepository()));
168
168
169 auto eventTemp = *event;
169 auto eventTemp = *event;
170 impl->m_CatalogueDao.addEvent(eventTemp);
170 impl->m_CatalogueDao.addEvent(eventTemp);
171
171
172 // Call update is necessary at the creation of add Event if it has some tags or some event
172 // Call update is necessary at the creation of add Event if it has some tags or some event
173 // products
173 // products
174 if (!event->getEventProducts().empty() || !event->getTags().empty()) {
174 if (!event->getEventProducts().empty() || !event->getTags().empty()) {
175
175
176 auto eventProductsTemp = eventTemp.getEventProducts();
176 auto eventProductsTemp = eventTemp.getEventProducts();
177 auto eventProductTempUpdated = std::list<DBEventProduct>{};
177 auto eventProductTempUpdated = std::list<DBEventProduct>{};
178 for (auto eventProductTemp : eventProductsTemp) {
178 for (auto eventProductTemp : eventProductsTemp) {
179 eventProductTemp.setEvent(eventTemp);
179 eventProductTemp.setEvent(eventTemp);
180 eventProductTempUpdated.push_back(eventProductTemp);
180 eventProductTempUpdated.push_back(eventProductTemp);
181 }
181 }
182 eventTemp.setEventProducts(eventProductTempUpdated);
182 eventTemp.setEventProducts(eventProductTempUpdated);
183
183
184 impl->m_CatalogueDao.updateEvent(eventTemp);
184 impl->m_CatalogueDao.updateEvent(eventTemp);
185 }
185 }
186 }
186 }
187
187
188 void CatalogueController::saveEvent(std::shared_ptr<DBEvent> event)
188 void CatalogueController::saveEvent(std::shared_ptr<DBEvent> event)
189 {
189 {
190 impl->saveEvent(event, true);
190 impl->saveEvent(event, true);
191 impl->m_EventKeysWithChanges.remove(impl->eventUniqueKey(event));
191 impl->m_EventKeysWithChanges.remove(impl->eventUniqueKey(event));
192 }
192 }
193
193
194 void CatalogueController::discardEvent(std::shared_ptr<DBEvent> event)
194 void CatalogueController::discardEvent(std::shared_ptr<DBEvent> event)
195 {
195 {
196 auto uniqIdPredicate = std::make_shared<ComparaisonPredicate>(
196 auto uniqIdPredicate = std::make_shared<ComparaisonPredicate>(
197 QString{"uniqId"}, event->getUniqId(), ComparaisonOperation::EQUALEQUAL);
197 QString{"uniqId"}, event->getUniqId(), ComparaisonOperation::EQUALEQUAL);
198
198
199 auto syncRepositoryPredicate = std::make_shared<ComparaisonPredicate>(
199 auto syncRepositoryPredicate = std::make_shared<ComparaisonPredicate>(
200 QString{"repository"}, impl->toSyncRepository(event->getRepository()),
200 QString{"repository"}, impl->toSyncRepository(event->getRepository()),
201 ComparaisonOperation::EQUALEQUAL);
201 ComparaisonOperation::EQUALEQUAL);
202
202
203 auto syncPred = std::make_shared<CompoundPredicate>(CompoundOperation::AND);
203 auto syncPred = std::make_shared<CompoundPredicate>(CompoundOperation::AND);
204 syncPred->AddRequestPredicate(uniqIdPredicate);
204 syncPred->AddRequestPredicate(uniqIdPredicate);
205 syncPred->AddRequestPredicate(syncRepositoryPredicate);
205 syncPred->AddRequestPredicate(syncRepositoryPredicate);
206
206
207
207
208 auto workRepositoryPredicate = std::make_shared<ComparaisonPredicate>(
208 auto workRepositoryPredicate = std::make_shared<ComparaisonPredicate>(
209 QString{"repository"}, impl->toWorkRepository(event->getRepository()),
209 QString{"repository"}, impl->toWorkRepository(event->getRepository()),
210 ComparaisonOperation::EQUALEQUAL);
210 ComparaisonOperation::EQUALEQUAL);
211
211
212 auto workPred = std::make_shared<CompoundPredicate>(CompoundOperation::AND);
212 auto workPred = std::make_shared<CompoundPredicate>(CompoundOperation::AND);
213 workPred->AddRequestPredicate(uniqIdPredicate);
213 workPred->AddRequestPredicate(uniqIdPredicate);
214 workPred->AddRequestPredicate(workRepositoryPredicate);
214 workPred->AddRequestPredicate(workRepositoryPredicate);
215
215
216
216
217 auto syncEvent = impl->m_CatalogueDao.getEvent(syncPred);
217 auto syncEvent = impl->m_CatalogueDao.getEvent(syncPred);
218 impl->m_CatalogueDao.copyEvent(syncEvent, impl->toWorkRepository(event->getRepository()), true);
218 impl->m_CatalogueDao.copyEvent(syncEvent, impl->toWorkRepository(event->getRepository()), true);
219
219
220 auto workEvent = impl->m_CatalogueDao.getEvent(workPred);
220 auto workEvent = impl->m_CatalogueDao.getEvent(workPred);
221 *event = workEvent;
221 *event = workEvent;
222 impl->m_EventKeysWithChanges.remove(impl->eventUniqueKey(event));
222 impl->m_EventKeysWithChanges.remove(impl->eventUniqueKey(event));
223 }
223 }
224
224
225 bool CatalogueController::eventHasChanges(std::shared_ptr<DBEvent> event) const
225 bool CatalogueController::eventHasChanges(std::shared_ptr<DBEvent> event) const
226 {
226 {
227 return impl->m_EventKeysWithChanges.contains(impl->eventUniqueKey(event));
227 return impl->m_EventKeysWithChanges.contains(impl->eventUniqueKey(event));
228 }
228 }
229
229
230 std::list<std::shared_ptr<DBCatalogue> >
230 std::list<std::shared_ptr<DBCatalogue> >
231 CatalogueController::retrieveCatalogues(const QString &repository) const
231 CatalogueController::retrieveCatalogues(const QString &repository) const
232 {
232 {
233 QString dbDireName = repository.isEmpty() ? REPOSITORY_DEFAULT : repository;
233 QString dbDireName = repository.isEmpty() ? REPOSITORY_DEFAULT : repository;
234
234
235 auto cataloguesShared = std::list<std::shared_ptr<DBCatalogue> >{};
235 auto cataloguesShared = std::list<std::shared_ptr<DBCatalogue> >{};
236 auto catalogues = impl->m_CatalogueDao.getCatalogues(impl->toWorkRepository(dbDireName));
236 auto catalogues = impl->m_CatalogueDao.getCatalogues(impl->toWorkRepository(dbDireName));
237 for (auto catalogue : catalogues) {
237 for (auto catalogue : catalogues) {
238 cataloguesShared.push_back(std::make_shared<DBCatalogue>(catalogue));
238 cataloguesShared.push_back(std::make_shared<DBCatalogue>(catalogue));
239 }
239 }
240 return cataloguesShared;
240 return cataloguesShared;
241 }
241 }
242
242
243 void CatalogueController::updateCatalogue(std::shared_ptr<DBCatalogue> catalogue)
243 void CatalogueController::updateCatalogue(std::shared_ptr<DBCatalogue> catalogue)
244 {
244 {
245 catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));
245 catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));
246
246
247 impl->m_CatalogueDao.updateCatalogue(*catalogue);
247 impl->m_CatalogueDao.updateCatalogue(*catalogue);
248 }
248 }
249
249
250 void CatalogueController::removeCatalogue(std::shared_ptr<DBCatalogue> catalogue)
250 void CatalogueController::removeCatalogue(std::shared_ptr<DBCatalogue> catalogue)
251 {
251 {
252 // Remove it from both repository and repository_work
252 // Remove it from both repository and repository_work
253 catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));
253 catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));
254 impl->m_CatalogueDao.removeCatalogue(*catalogue);
254 impl->m_CatalogueDao.removeCatalogue(*catalogue);
255 catalogue->setRepository(impl->toSyncRepository(catalogue->getRepository()));
255 catalogue->setRepository(impl->toSyncRepository(catalogue->getRepository()));
256 impl->m_CatalogueDao.removeCatalogue(*catalogue);
256 impl->m_CatalogueDao.removeCatalogue(*catalogue);
257 }
257 }
258
258
259 void CatalogueController::saveCatalogue(std::shared_ptr<DBCatalogue> catalogue)
259 void CatalogueController::saveCatalogue(std::shared_ptr<DBCatalogue> catalogue)
260 {
260 {
261 impl->saveCatalogue(catalogue, true);
261 impl->saveCatalogue(catalogue, true);
262 }
262 }
263
263
264 void CatalogueController::saveAll()
264 void CatalogueController::saveAll()
265 {
265 {
266 for (auto repository : impl->m_RepositoryList) {
266 for (auto repository : impl->m_RepositoryList) {
267 // Save Event
267 // Save Event
268 auto events = this->retrieveEvents(repository);
268 auto events = this->retrieveEvents(repository);
269 for (auto event : events) {
269 for (auto event : events) {
270 impl->saveEvent(event, false);
270 impl->saveEvent(event, false);
271 }
271 }
272
272
273 // Save Catalogue
273 // Save Catalogue
274 auto catalogues = this->retrieveCatalogues(repository);
274 auto catalogues = this->retrieveCatalogues(repository);
275 for (auto catalogue : catalogues) {
275 for (auto catalogue : catalogues) {
276 impl->saveCatalogue(catalogue, false);
276 impl->saveCatalogue(catalogue, false);
277 }
277 }
278 }
278 }
279
279
280 impl->savAllDB();
280 impl->savAllDB();
281 impl->m_EventKeysWithChanges.clear();
281 impl->m_EventKeysWithChanges.clear();
282 }
282 }
283
283
284 bool CatalogueController::hasChanges() const
284 bool CatalogueController::hasChanges() const
285 {
285 {
286 return !impl->m_EventKeysWithChanges.isEmpty(); // TODO: catalogues
286 return !impl->m_EventKeysWithChanges.isEmpty(); // TODO: catalogues
287 }
287 }
288
288
289 QByteArray
289 QByteArray
290 CatalogueController::mimeDataForEvents(const QVector<std::shared_ptr<DBEvent> > &events) const
290 CatalogueController::mimeDataForEvents(const QVector<std::shared_ptr<DBEvent> > &events) const
291 {
291 {
292 auto encodedData = QByteArray{};
292 auto encodedData = QByteArray{};
293
293
294 QMap<QString, QVariantList> idsPerRepository;
294 QMap<QString, QVariantList> idsPerRepository;
295 for (auto event : events) {
295 for (auto event : events) {
296 idsPerRepository[event->getRepository()] << event->getUniqId();
296 idsPerRepository[event->getRepository()] << event->getUniqId();
297 }
297 }
298
298
299 QDataStream stream{&encodedData, QIODevice::WriteOnly};
299 QDataStream stream{&encodedData, QIODevice::WriteOnly};
300 stream << idsPerRepository;
300 stream << idsPerRepository;
301
301
302 return encodedData;
302 return encodedData;
303 }
303 }
304
304
305 QVector<std::shared_ptr<DBEvent> >
305 QVector<std::shared_ptr<DBEvent> >
306 CatalogueController::eventsForMimeData(const QByteArray &mimeData) const
306 CatalogueController::eventsForMimeData(const QByteArray &mimeData) const
307 {
307 {
308 auto events = QVector<std::shared_ptr<DBEvent> >{};
308 auto events = QVector<std::shared_ptr<DBEvent> >{};
309 QDataStream stream{mimeData};
309 QDataStream stream{mimeData};
310
310
311 QMap<QString, QVariantList> idsPerRepository;
311 QMap<QString, QVariantList> idsPerRepository;
312 stream >> idsPerRepository;
312 stream >> idsPerRepository;
313
313
314 for (auto it = idsPerRepository.cbegin(); it != idsPerRepository.cend(); ++it) {
314 for (auto it = idsPerRepository.cbegin(); it != idsPerRepository.cend(); ++it) {
315 auto repository = it.key();
315 auto repository = it.key();
316 auto allRepositoryEvent = retrieveEvents(repository);
316 auto allRepositoryEvent = retrieveEvents(repository);
317 for (auto uuid : it.value()) {
317 for (auto uuid : it.value()) {
318 for (auto repositoryEvent : allRepositoryEvent) {
318 for (auto repositoryEvent : allRepositoryEvent) {
319 if (uuid.toUuid() == repositoryEvent->getUniqId()) {
319 if (uuid.toUuid() == repositoryEvent->getUniqId()) {
320 events << repositoryEvent;
320 events << repositoryEvent;
321 }
321 }
322 }
322 }
323 }
323 }
324 }
324 }
325
325
326 return events;
326 return events;
327 }
327 }
328
328
329 void CatalogueController::initialize()
329 void CatalogueController::initialize()
330 {
330 {
331 qCDebug(LOG_CatalogueController()) << tr("CatalogueController init")
331 qCDebug(LOG_CatalogueController()) << tr("CatalogueController init")
332 << QThread::currentThread();
332 << QThread::currentThread();
333
333
334 impl->m_CatalogueDao.initialize();
334 impl->m_CatalogueDao.initialize();
335 auto defaultRepositoryLocation
335 auto defaultRepositoryLocation
336 = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
336 = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
337
337
338 QDir defaultRepositoryLocationDir;
338 QDir defaultRepositoryLocationDir;
339 if (defaultRepositoryLocationDir.mkpath(defaultRepositoryLocation)) {
339 if (defaultRepositoryLocationDir.mkpath(defaultRepositoryLocation)) {
340 defaultRepositoryLocationDir.cd(defaultRepositoryLocation);
340 defaultRepositoryLocationDir.cd(defaultRepositoryLocation);
341 auto defaultRepository = defaultRepositoryLocationDir.absoluteFilePath(REPOSITORY_DEFAULT);
341 auto defaultRepository = defaultRepositoryLocationDir.absoluteFilePath(REPOSITORY_DEFAULT);
342
342 qCInfo(LOG_CatalogueController()) << tr("Persistant data loading from: ")
343 qCInfo(LOG_CatalogueController()) << tr("Persistant data loading from: ")
343 << defaultRepository;
344 << defaultRepository;
344 this->addDB(defaultRepository);
345
346 QDir dbDir(defaultRepository);
347 impl->m_RepositoryList << REPOSITORY_DEFAULT;
348 if (dbDir.exists()) {
349 auto dirName = dbDir.dirName();
350
351 if (impl->m_CatalogueDao.addDB(defaultRepository, dirName)) {
352 impl->copyDBtoDB(dirName, impl->toWorkRepository(dirName));
353 }
354 }
355 else {
356 qCInfo(LOG_CatalogueController()) << tr("Initialisation of Default repository detected")
357 << defaultRepository;
358 }
345 }
359 }
346 else {
360 else {
347 qCWarning(LOG_CatalogueController())
361 qCWarning(LOG_CatalogueController())
348 << tr("Cannot load the persistent default repository from ")
362 << tr("Cannot load the persistent default repository from ")
349 << defaultRepositoryLocation;
363 << defaultRepositoryLocation;
350 }
364 }
351
365
352 qCDebug(LOG_CatalogueController()) << tr("CatalogueController init END");
366 qCDebug(LOG_CatalogueController()) << tr("CatalogueController init END");
353 }
367 }
354
368
355 QString CatalogueController::CatalogueControllerPrivate::eventUniqueKey(
369 QString CatalogueController::CatalogueControllerPrivate::eventUniqueKey(
356 const std::shared_ptr<DBEvent> &event) const
370 const std::shared_ptr<DBEvent> &event) const
357 {
371 {
358 return event->getUniqId().toString().append(event->getRepository());
372 return event->getUniqId().toString().append(event->getRepository());
359 }
373 }
360
374
361 void CatalogueController::CatalogueControllerPrivate::copyDBtoDB(const QString &dbFrom,
375 void CatalogueController::CatalogueControllerPrivate::copyDBtoDB(const QString &dbFrom,
362 const QString &dbTo)
376 const QString &dbTo)
363 {
377 {
364 // auto cataloguesShared = std::list<std::shared_ptr<DBCatalogue> >{};
378 // auto cataloguesShared = std::list<std::shared_ptr<DBCatalogue> >{};
365 auto catalogues = m_CatalogueDao.getCatalogues(dbFrom);
379 auto catalogues = m_CatalogueDao.getCatalogues(dbFrom);
366 auto events = m_CatalogueDao.getEvents(dbFrom);
380 auto events = m_CatalogueDao.getEvents(dbFrom);
367 for (auto catalogue : catalogues) {
381 for (auto catalogue : catalogues) {
368 m_CatalogueDao.copyCatalogue(catalogue, dbTo, true);
382 m_CatalogueDao.copyCatalogue(catalogue, dbTo, true);
369 }
383 }
370
384
371 for (auto event : events) {
385 for (auto event : events) {
372 m_CatalogueDao.copyEvent(event, dbTo, true);
386 m_CatalogueDao.copyEvent(event, dbTo, true);
373 }
387 }
374 }
388 }
375
389
376 QString CatalogueController::CatalogueControllerPrivate::toWorkRepository(QString repository)
390 QString CatalogueController::CatalogueControllerPrivate::toWorkRepository(QString repository)
377 {
391 {
378 auto syncRepository = toSyncRepository(repository);
392 auto syncRepository = toSyncRepository(repository);
379
393
380 return QString("%1%2").arg(syncRepository, REPOSITORY_WORK_SUFFIX);
394 return QString("%1%2").arg(syncRepository, REPOSITORY_WORK_SUFFIX);
381 }
395 }
382
396
383 QString CatalogueController::CatalogueControllerPrivate::toSyncRepository(QString repository)
397 QString CatalogueController::CatalogueControllerPrivate::toSyncRepository(QString repository)
384 {
398 {
385 auto syncRepository = repository;
399 auto syncRepository = repository;
386 if (repository.endsWith(REPOSITORY_WORK_SUFFIX)) {
400 if (repository.endsWith(REPOSITORY_WORK_SUFFIX)) {
387 syncRepository.remove(REPOSITORY_WORK_SUFFIX);
401 syncRepository.remove(REPOSITORY_WORK_SUFFIX);
388 }
402 }
389 else if (repository.endsWith(REPOSITORY_TRASH_SUFFIX)) {
403 else if (repository.endsWith(REPOSITORY_TRASH_SUFFIX)) {
390 syncRepository.remove(REPOSITORY_TRASH_SUFFIX);
404 syncRepository.remove(REPOSITORY_TRASH_SUFFIX);
391 }
405 }
392 return syncRepository;
406 return syncRepository;
393 }
407 }
394
408
395 void CatalogueController::CatalogueControllerPrivate::savAllDB()
409 void CatalogueController::CatalogueControllerPrivate::savAllDB()
396 {
410 {
397 for (auto repository : m_RepositoryList) {
411 for (auto repository : m_RepositoryList) {
398 auto defaultRepositoryLocation
412 auto defaultRepositoryLocation
399 = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
413 = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
400 m_CatalogueDao.saveDB(defaultRepositoryLocation, repository);
414 m_CatalogueDao.saveDB(defaultRepositoryLocation, repository);
401 }
415 }
402 }
416 }
403
417
404 void CatalogueController::CatalogueControllerPrivate::saveEvent(std::shared_ptr<DBEvent> event,
418 void CatalogueController::CatalogueControllerPrivate::saveEvent(std::shared_ptr<DBEvent> event,
405 bool persist)
419 bool persist)
406 {
420 {
407 m_CatalogueDao.copyEvent(*event, toSyncRepository(event->getRepository()), true);
421 m_CatalogueDao.copyEvent(*event, toSyncRepository(event->getRepository()), true);
408 if (persist) {
422 if (persist) {
409 savAllDB();
423 savAllDB();
410 }
424 }
411 }
425 }
412
426
413 void CatalogueController::CatalogueControllerPrivate::saveCatalogue(
427 void CatalogueController::CatalogueControllerPrivate::saveCatalogue(
414 std::shared_ptr<DBCatalogue> catalogue, bool persist)
428 std::shared_ptr<DBCatalogue> catalogue, bool persist)
415 {
429 {
416 m_CatalogueDao.copyCatalogue(*catalogue, toSyncRepository(catalogue->getRepository()), true);
430 m_CatalogueDao.copyCatalogue(*catalogue, toSyncRepository(catalogue->getRepository()), true);
417 if (persist) {
431 if (persist) {
418 savAllDB();
432 savAllDB();
419 }
433 }
420 }
434 }
General Comments 0
You need to be logged in to leave comments. Login now