1 /*
2     SPDX-FileCopyrightText: 2014 Daniel Vrátil <dvratil@redhat.com>
3 
4     SPDX-License-Identifier: LGPL-2.0-or-later
5 */
6 
7 #include "fakedatastore.h"
8 #include "akonadischema.h"
9 #include "dbpopulator.h"
10 #include "fakeakonadiserver.h"
11 #include "inspectablenotificationcollector.h"
12 #include "storage/dbconfig.h"
13 #include "storage/dbinitializer.h"
14 
15 #include <QThread>
16 
17 using namespace Akonadi::Server;
18 
19 Q_DECLARE_METATYPE(PimItem)
Q_DECLARE_METATYPE(PimItem::List)20 Q_DECLARE_METATYPE(PimItem::List)
21 Q_DECLARE_METATYPE(Collection)
22 Q_DECLARE_METATYPE(Flag)
23 Q_DECLARE_METATYPE(QVector<Flag>)
24 Q_DECLARE_METATYPE(Tag)
25 Q_DECLARE_METATYPE(QVector<Tag>)
26 Q_DECLARE_METATYPE(MimeType)
27 Q_DECLARE_METATYPE(QList<QByteArray>)
28 
29 FakeDataStoreFactory::FakeDataStoreFactory(FakeAkonadiServer &akonadi)
30     : m_akonadi(akonadi)
31 {
32 }
33 
createStore()34 DataStore *FakeDataStoreFactory::createStore()
35 {
36     return new FakeDataStore(m_akonadi);
37 }
38 
FakeDataStore(FakeAkonadiServer & akonadi)39 FakeDataStore::FakeDataStore(FakeAkonadiServer &akonadi)
40     : DataStore(akonadi)
41     , mPopulateDb(true)
42 {
43     mNotificationCollector = std::make_unique<InspectableNotificationCollector>(m_akonadi, this);
44 }
45 
46 FakeDataStore::~FakeDataStore() = default;
47 
init()48 bool FakeDataStore::init()
49 {
50     if (!DataStore::init()) {
51         return false;
52     }
53 
54     if (mPopulateDb) {
55         DbPopulator dbPopulator;
56         if (!dbPopulator.run()) {
57             qWarning() << "Failed to populate database";
58             return false;
59         }
60     }
61 
62     return true;
63 }
64 
setItemsFlags(const PimItem::List & items,const QVector<Flag> * currentFlags,const QVector<Flag> & flags,bool * flagsChanged,const Collection & col,bool silent)65 bool FakeDataStore::setItemsFlags(const PimItem::List &items,
66                                   const QVector<Flag> *currentFlags,
67                                   const QVector<Flag> &flags,
68                                   bool *flagsChanged,
69                                   const Collection &col,
70                                   bool silent)
71 {
72     mChanges.insert(QStringLiteral("setItemsFlags"),
73                     QVariantList() << QVariant::fromValue(items) << QVariant::fromValue(flags) << QVariant::fromValue(col) << silent);
74     return DataStore::setItemsFlags(items, currentFlags, flags, flagsChanged, col, silent);
75 }
76 
appendItemsFlags(const PimItem::List & items,const QVector<Flag> & flags,bool * flagsChanged,bool checkIfExists,const Collection & col,bool silent)77 bool FakeDataStore::appendItemsFlags(const PimItem::List &items,
78                                      const QVector<Flag> &flags,
79                                      bool *flagsChanged,
80                                      bool checkIfExists,
81                                      const Collection &col,
82                                      bool silent)
83 {
84     mChanges.insert(QStringLiteral("appendItemsFlags"),
85                     QVariantList() << QVariant::fromValue(items) << QVariant::fromValue(flags) << checkIfExists << QVariant::fromValue(col) << silent);
86     return DataStore::appendItemsFlags(items, flags, flagsChanged, checkIfExists, col, silent);
87 }
88 
removeItemsFlags(const PimItem::List & items,const QVector<Flag> & flags,bool * flagsChanged,const Collection & col,bool silent)89 bool FakeDataStore::removeItemsFlags(const PimItem::List &items, const QVector<Flag> &flags, bool *flagsChanged, const Collection &col, bool silent)
90 {
91     mChanges.insert(QStringLiteral("removeItemsFlags"),
92                     QVariantList() << QVariant::fromValue(items) << QVariant::fromValue(flags) << QVariant::fromValue(col) << silent);
93     return DataStore::removeItemsFlags(items, flags, flagsChanged, col, silent);
94 }
95 
setItemsTags(const PimItem::List & items,const Tag::List & tags,bool * tagsChanged,bool silent)96 bool FakeDataStore::setItemsTags(const PimItem::List &items, const Tag::List &tags, bool *tagsChanged, bool silent)
97 {
98     mChanges.insert(QStringLiteral("setItemsTags"), QVariantList() << QVariant::fromValue(items) << QVariant::fromValue(tags) << silent);
99     return DataStore::setItemsTags(items, tags, tagsChanged, silent);
100 }
101 
appendItemsTags(const PimItem::List & items,const Tag::List & tags,bool * tagsChanged,bool checkIfExists,const Collection & col,bool silent)102 bool FakeDataStore::appendItemsTags(const PimItem::List &items,
103                                     const Tag::List &tags,
104                                     bool *tagsChanged,
105                                     bool checkIfExists,
106                                     const Collection &col,
107                                     bool silent)
108 {
109     mChanges.insert(QStringLiteral("appendItemsTags"),
110                     QVariantList() << QVariant::fromValue(items) << QVariant::fromValue(tags) << checkIfExists << QVariant::fromValue(col) << silent);
111     return DataStore::appendItemsTags(items, tags, tagsChanged, checkIfExists, col, silent);
112 }
113 
removeItemsTags(const PimItem::List & items,const Tag::List & tags,bool * tagsChanged,bool silent)114 bool FakeDataStore::removeItemsTags(const PimItem::List &items, const Tag::List &tags, bool *tagsChanged, bool silent)
115 {
116     mChanges.insert(QStringLiteral("removeItemsTags"), QVariantList() << QVariant::fromValue(items) << QVariant::fromValue(tags) << silent);
117     return DataStore::removeItemsTags(items, tags, tagsChanged, silent);
118 }
119 
removeItemParts(const PimItem & item,const QSet<QByteArray> & parts)120 bool FakeDataStore::removeItemParts(const PimItem &item, const QSet<QByteArray> &parts)
121 {
122     mChanges.insert(QStringLiteral("remoteItemParts"), QVariantList() << QVariant::fromValue(item) << QVariant::fromValue(parts));
123     return DataStore::removeItemParts(item, parts);
124 }
125 
invalidateItemCache(const PimItem & item)126 bool FakeDataStore::invalidateItemCache(const PimItem &item)
127 {
128     mChanges.insert(QStringLiteral("invalidateItemCache"), QVariantList() << QVariant::fromValue(item));
129     return DataStore::invalidateItemCache(item);
130 }
131 
appendCollection(Collection & collection,const QStringList & mimeTypes,const QMap<QByteArray,QByteArray> & attributes)132 bool FakeDataStore::appendCollection(Collection &collection, const QStringList &mimeTypes, const QMap<QByteArray, QByteArray> &attributes)
133 {
134     mChanges.insert(QStringLiteral("appendCollection"), QVariantList() << QVariant::fromValue(collection) << mimeTypes << QVariant::fromValue(attributes));
135     return DataStore::appendCollection(collection, mimeTypes, attributes);
136 }
137 
cleanupCollection(Collection & collection)138 bool FakeDataStore::cleanupCollection(Collection &collection)
139 {
140     mChanges.insert(QStringLiteral("cleanupCollection"), QVariantList() << QVariant::fromValue(collection));
141     return DataStore::cleanupCollection(collection);
142 }
143 
cleanupCollection_slow(Collection & collection)144 bool FakeDataStore::cleanupCollection_slow(Collection &collection)
145 {
146     mChanges.insert(QStringLiteral("cleanupCollection_slow"), QVariantList() << QVariant::fromValue(collection));
147     return DataStore::cleanupCollection_slow(collection);
148 }
149 
moveCollection(Collection & collection,const Collection & newParent)150 bool FakeDataStore::moveCollection(Collection &collection, const Collection &newParent)
151 {
152     mChanges.insert(QStringLiteral("moveCollection"), QVariantList() << QVariant::fromValue(collection) << QVariant::fromValue(newParent));
153     return DataStore::moveCollection(collection, newParent);
154 }
155 
appendMimeTypeForCollection(qint64 collectionId,const QStringList & mimeTypes)156 bool FakeDataStore::appendMimeTypeForCollection(qint64 collectionId, const QStringList &mimeTypes)
157 {
158     mChanges.insert(QStringLiteral("appendMimeTypeForCollection"), QVariantList() << collectionId << QVariant::fromValue(mimeTypes));
159     return DataStore::appendMimeTypeForCollection(collectionId, mimeTypes);
160 }
161 
activeCachePolicy(Collection & col)162 void FakeDataStore::activeCachePolicy(Collection &col)
163 {
164     mChanges.insert(QStringLiteral("activeCachePolicy"), QVariantList() << QVariant::fromValue(col));
165     return DataStore::activeCachePolicy(col);
166 }
167 
appendPimItem(QVector<Part> & parts,const QVector<Flag> & flags,const MimeType & mimetype,const Collection & collection,const QDateTime & dateTime,const QString & remote_id,const QString & remoteRevision,const QString & gid,PimItem & pimItem)168 bool FakeDataStore::appendPimItem(QVector<Part> &parts,
169                                   const QVector<Flag> &flags,
170                                   const MimeType &mimetype,
171                                   const Collection &collection,
172                                   const QDateTime &dateTime,
173                                   const QString &remote_id,
174                                   const QString &remoteRevision,
175                                   const QString &gid,
176                                   PimItem &pimItem)
177 {
178     mChanges.insert(QStringLiteral("appendPimItem"),
179                     QVariantList() << QVariant::fromValue(mimetype) << QVariant::fromValue(collection) << dateTime << remote_id << remoteRevision << gid);
180     return DataStore::appendPimItem(parts, flags, mimetype, collection, dateTime, remote_id, remoteRevision, gid, pimItem);
181 }
182 
cleanupPimItems(const PimItem::List & items,bool silent)183 bool FakeDataStore::cleanupPimItems(const PimItem::List &items, bool silent)
184 {
185     mChanges.insert(QStringLiteral("cleanupPimItems"), QVariantList() << QVariant::fromValue(items) << silent);
186     return DataStore::cleanupPimItems(items, silent);
187 }
188 
unhidePimItem(PimItem & pimItem)189 bool FakeDataStore::unhidePimItem(PimItem &pimItem)
190 {
191     mChanges.insert(QStringLiteral("unhidePimItem"), QVariantList() << QVariant::fromValue(pimItem));
192     return DataStore::unhidePimItem(pimItem);
193 }
194 
unhideAllPimItems()195 bool FakeDataStore::unhideAllPimItems()
196 {
197     mChanges.insert(QStringLiteral("unhideAllPimItems"), QVariantList());
198     return DataStore::unhideAllPimItems();
199 }
200 
addCollectionAttribute(const Collection & col,const QByteArray & key,const QByteArray & value,bool silent)201 bool FakeDataStore::addCollectionAttribute(const Collection &col, const QByteArray &key, const QByteArray &value, bool silent)
202 {
203     mChanges.insert(QStringLiteral("addCollectionAttribute"), QVariantList() << QVariant::fromValue(col) << key << value << silent);
204     return DataStore::addCollectionAttribute(col, key, value, silent);
205 }
206 
removeCollectionAttribute(const Collection & col,const QByteArray & key)207 bool FakeDataStore::removeCollectionAttribute(const Collection &col, const QByteArray &key)
208 {
209     mChanges.insert(QStringLiteral("removeCollectionAttribute"), QVariantList() << QVariant::fromValue(col) << key);
210     return DataStore::removeCollectionAttribute(col, key);
211 }
212 
beginTransaction(const QString & name)213 bool FakeDataStore::beginTransaction(const QString &name)
214 {
215     mChanges.insert(QStringLiteral("beginTransaction"), QVariantList() << name);
216     return DataStore::beginTransaction(name);
217 }
218 
commitTransaction()219 bool FakeDataStore::commitTransaction()
220 {
221     mChanges.insert(QStringLiteral("commitTransaction"), QVariantList());
222     return DataStore::commitTransaction();
223 }
224 
rollbackTransaction()225 bool FakeDataStore::rollbackTransaction()
226 {
227     mChanges.insert(QStringLiteral("rollbackTransaction"), QVariantList());
228     return DataStore::rollbackTransaction();
229 }
230 
setPopulateDb(bool populate)231 void FakeDataStore::setPopulateDb(bool populate)
232 {
233     mPopulateDb = populate;
234 }
235