HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1259:5258f026c355

1

#include <Catalogue/CatalogueController.h>

1

#include <Catalogue/CatalogueController.h>

2

3

#include <Variable/Variable.h>

3

#include <Variable/Variable.h>

4

5

#include <CatalogueDao.h>

5

#include <CatalogueDao.h>

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

15

#include <QDataStream>

15

#include <QDataStream>

16

#include <QMutex>

16

#include <QMutex>

17

#include <QThread>

17

#include <QThread>

18

19

#include <QDir>

19

#include <QDir>

20

#include <QStandardPaths>

20

#include <QStandardPaths>

21

22

Q_LOGGING_CATEGORY(LOG_CatalogueController, "CatalogueController")

22

Q_LOGGING_CATEGORY(LOG_CatalogueController, "CatalogueController")

23

24

namespace {

24

namespace {

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

30

class CatalogueController::CatalogueControllerPrivate {

30

class CatalogueController::CatalogueControllerPrivate {

31

32

public:

32

public:

33

explicit CatalogueControllerPrivate(CatalogueController *parent) : m_Q{parent} {}

33

explicit CatalogueControllerPrivate(CatalogueController *parent) : m_Q{parent} {}

34

35

CatalogueDao m_CatalogueDao;

35

CatalogueDao m_CatalogueDao;

36

37

QStringList m_RepositoryList;

37

QStringList m_RepositoryList;

38

CatalogueController *m_Q;

38

CatalogueController *m_Q;

39

40

QSet<QString> m_EventKeysWithChanges;

40

QSet<QString> m_EventKeysWithChanges;

41

42

QString eventUniqueKey(const std::shared_ptr<DBEvent> &event) const;

42

QString eventUniqueKey(const std::shared_ptr<DBEvent> &event) const;

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

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

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

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

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

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

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

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

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

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

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

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

126

return eventsShared;

126

return eventsShared;

127

}

127

}

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

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

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

147

impl->m_CatalogueDao.updateEvent(*event);

147

impl->m_CatalogueDao.updateEvent(*event);

148

}

148

}

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

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

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

169

auto eventTemp = *event;

169

auto eventTemp = *event;

170

impl->m_CatalogueDao.addEvent(eventTemp);

170

impl->m_CatalogueDao.addEvent(eventTemp);

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

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

184

impl->m_CatalogueDao.updateEvent(eventTemp);

184

impl->m_CatalogueDao.updateEvent(eventTemp);

185

}

185

}

186

187

auto uniqueId = impl->eventUniqueKey(event);

188

impl->m_EventKeysWithChanges.insert(uniqueId);

186

}

189

}

187

190

188

void CatalogueController::saveEvent(std::shared_ptr<DBEvent> event)

191

void CatalogueController::saveEvent(std::shared_ptr<DBEvent> event)

189

{

192

{

190

impl->saveEvent(event, true);

193

impl->saveEvent(event, true);

191

impl->m_EventKeysWithChanges.remove(impl->eventUniqueKey(event));

194

impl->m_EventKeysWithChanges.remove(impl->eventUniqueKey(event));

192

}

195

}

193

196

194

void CatalogueController::discardEvent(std::shared_ptr<DBEvent> event)

197

void CatalogueController::discardEvent(std::shared_ptr<DBEvent> event)

195

{

198

{

196

auto uniqIdPredicate = std::make_shared<ComparaisonPredicate>(

199

auto uniqIdPredicate = std::make_shared<ComparaisonPredicate>(

197

QString{"uniqId"}, event->getUniqId(), ComparaisonOperation::EQUALEQUAL);

200

QString{"uniqId"}, event->getUniqId(), ComparaisonOperation::EQUALEQUAL);

198

201

199

auto syncRepositoryPredicate = std::make_shared<ComparaisonPredicate>(

202

auto syncRepositoryPredicate = std::make_shared<ComparaisonPredicate>(

200

QString{"repository"}, impl->toSyncRepository(event->getRepository()),

203

QString{"repository"}, impl->toSyncRepository(event->getRepository()),

201

ComparaisonOperation::EQUALEQUAL);

204

ComparaisonOperation::EQUALEQUAL);

202

205

203

auto syncPred = std::make_shared<CompoundPredicate>(CompoundOperation::AND);

206

auto syncPred = std::make_shared<CompoundPredicate>(CompoundOperation::AND);

204

syncPred->AddRequestPredicate(uniqIdPredicate);

207

syncPred->AddRequestPredicate(uniqIdPredicate);

205

syncPred->AddRequestPredicate(syncRepositoryPredicate);

208

syncPred->AddRequestPredicate(syncRepositoryPredicate);

206

209

207

210

208

auto workRepositoryPredicate = std::make_shared<ComparaisonPredicate>(

211

auto workRepositoryPredicate = std::make_shared<ComparaisonPredicate>(

209

QString{"repository"}, impl->toWorkRepository(event->getRepository()),

212

QString{"repository"}, impl->toWorkRepository(event->getRepository()),

210

ComparaisonOperation::EQUALEQUAL);

213

ComparaisonOperation::EQUALEQUAL);

211

214

212

auto workPred = std::make_shared<CompoundPredicate>(CompoundOperation::AND);

215

auto workPred = std::make_shared<CompoundPredicate>(CompoundOperation::AND);

213

workPred->AddRequestPredicate(uniqIdPredicate);

216

workPred->AddRequestPredicate(uniqIdPredicate);

214

workPred->AddRequestPredicate(workRepositoryPredicate);

217

workPred->AddRequestPredicate(workRepositoryPredicate);

215

218

216

219

217

auto syncEvent = impl->m_CatalogueDao.getEvent(syncPred);

220

auto syncEvent = impl->m_CatalogueDao.getEvent(syncPred);

218

impl->m_CatalogueDao.copyEvent(syncEvent, impl->toWorkRepository(event->getRepository()), true);

221

impl->m_CatalogueDao.copyEvent(syncEvent, impl->toWorkRepository(event->getRepository()), true);

219

222

220

auto workEvent = impl->m_CatalogueDao.getEvent(workPred);

223

auto workEvent = impl->m_CatalogueDao.getEvent(workPred);

221

*event = workEvent;

224

*event = workEvent;

222

impl->m_EventKeysWithChanges.remove(impl->eventUniqueKey(event));

225

impl->m_EventKeysWithChanges.remove(impl->eventUniqueKey(event));

223

}

226

}

224

227

225

bool CatalogueController::eventHasChanges(std::shared_ptr<DBEvent> event) const

228

bool CatalogueController::eventHasChanges(std::shared_ptr<DBEvent> event) const

226

{

229

{

227

return impl->m_EventKeysWithChanges.contains(impl->eventUniqueKey(event));

230

return impl->m_EventKeysWithChanges.contains(impl->eventUniqueKey(event));

228

}

231

}

229

232

230

std::list<std::shared_ptr<DBCatalogue> >

233

std::list<std::shared_ptr<DBCatalogue> >

231

CatalogueController::retrieveCatalogues(const QString &repository) const

234

CatalogueController::retrieveCatalogues(const QString &repository) const

232

{

235

{

233

QString dbDireName = repository.isEmpty() ? REPOSITORY_DEFAULT : repository;

236

QString dbDireName = repository.isEmpty() ? REPOSITORY_DEFAULT : repository;

234

237

235

auto cataloguesShared = std::list<std::shared_ptr<DBCatalogue> >{};

238

auto cataloguesShared = std::list<std::shared_ptr<DBCatalogue> >{};

236

auto catalogues = impl->m_CatalogueDao.getCatalogues(impl->toWorkRepository(dbDireName));

239

auto catalogues = impl->m_CatalogueDao.getCatalogues(impl->toWorkRepository(dbDireName));

237

for (auto catalogue : catalogues) {

240

for (auto catalogue : catalogues) {

238

cataloguesShared.push_back(std::make_shared<DBCatalogue>(catalogue));

241

cataloguesShared.push_back(std::make_shared<DBCatalogue>(catalogue));

239

}

242

}

240

return cataloguesShared;

243

return cataloguesShared;

241

}

244

}

242

245

243

void CatalogueController::updateCatalogue(std::shared_ptr<DBCatalogue> catalogue)

246

void CatalogueController::updateCatalogue(std::shared_ptr<DBCatalogue> catalogue)

244

{

247

{

245

catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));

248

catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));

246

249

247

impl->m_CatalogueDao.updateCatalogue(*catalogue);

250

impl->m_CatalogueDao.updateCatalogue(*catalogue);

248

}

251

}

249

252

250

void CatalogueController::removeCatalogue(std::shared_ptr<DBCatalogue> catalogue)

253

void CatalogueController::removeCatalogue(std::shared_ptr<DBCatalogue> catalogue)

251

{

254

{

252

// Remove it from both repository and repository_work

255

// Remove it from both repository and repository_work

253

catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));

256

catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));

254

impl->m_CatalogueDao.removeCatalogue(*catalogue);

257

impl->m_CatalogueDao.removeCatalogue(*catalogue);

255

catalogue->setRepository(impl->toSyncRepository(catalogue->getRepository()));

258

catalogue->setRepository(impl->toSyncRepository(catalogue->getRepository()));

256

impl->m_CatalogueDao.removeCatalogue(*catalogue);

259

impl->m_CatalogueDao.removeCatalogue(*catalogue);

257

}

260

}

258

261

259

void CatalogueController::saveCatalogue(std::shared_ptr<DBCatalogue> catalogue)

262

void CatalogueController::saveCatalogue(std::shared_ptr<DBCatalogue> catalogue)

260

{

263

{

261

impl->saveCatalogue(catalogue, true);

264

impl->saveCatalogue(catalogue, true);

262

}

265

}

263

266

264

void CatalogueController::saveAll()

267

void CatalogueController::saveAll()

265

{

268

{

266

for (auto repository : impl->m_RepositoryList) {

269

for (auto repository : impl->m_RepositoryList) {

267

// Save Event

270

// Save Event

268

auto events = this->retrieveEvents(repository);

271

auto events = this->retrieveEvents(repository);

269

for (auto event : events) {

272

for (auto event : events) {

270

impl->saveEvent(event, false);

273

impl->saveEvent(event, false);

271

}

274

}

272

275

273

// Save Catalogue

276

// Save Catalogue

274

auto catalogues = this->retrieveCatalogues(repository);

277

auto catalogues = this->retrieveCatalogues(repository);

275

for (auto catalogue : catalogues) {

278

for (auto catalogue : catalogues) {

276

impl->saveCatalogue(catalogue, false);

279

impl->saveCatalogue(catalogue, false);

277

}

280

}

278

}

281

}

279

282

280

impl->savAllDB();

283

impl->savAllDB();

281

impl->m_EventKeysWithChanges.clear();

284

impl->m_EventKeysWithChanges.clear();

282

}

285

}

283

286

284

bool CatalogueController::hasChanges() const

287

bool CatalogueController::hasChanges() const

285

{

288

{

286

return !impl->m_EventKeysWithChanges.isEmpty(); // TODO: catalogues

289

return !impl->m_EventKeysWithChanges.isEmpty(); // TODO: catalogues

287

}

290

}

288

291

289

QByteArray

292

QByteArray

290

CatalogueController::mimeDataForEvents(const QVector<std::shared_ptr<DBEvent> > &events) const

293

CatalogueController::mimeDataForEvents(const QVector<std::shared_ptr<DBEvent> > &events) const

291

{

294

{

292

auto encodedData = QByteArray{};

295

auto encodedData = QByteArray{};

293

296

294

QMap<QString, QVariantList> idsPerRepository;

297

QMap<QString, QVariantList> idsPerRepository;

295

for (auto event : events) {

298

for (auto event : events) {

296

idsPerRepository[event->getRepository()] << event->getUniqId();

299

idsPerRepository[event->getRepository()] << event->getUniqId();

297

}

300

}

298

301

299

QDataStream stream{&encodedData, QIODevice::WriteOnly};

302

QDataStream stream{&encodedData, QIODevice::WriteOnly};

300

stream << idsPerRepository;

303

stream << idsPerRepository;

301

304

302

return encodedData;

305

return encodedData;

303

}

306

}

304

307

305

QVector<std::shared_ptr<DBEvent> >

308

QVector<std::shared_ptr<DBEvent> >

306

CatalogueController::eventsForMimeData(const QByteArray &mimeData) const

309

CatalogueController::eventsForMimeData(const QByteArray &mimeData) const

307

{

310

{

308

auto events = QVector<std::shared_ptr<DBEvent> >{};

311

auto events = QVector<std::shared_ptr<DBEvent> >{};

309

QDataStream stream{mimeData};

312

QDataStream stream{mimeData};

310

313

311

QMap<QString, QVariantList> idsPerRepository;

314

QMap<QString, QVariantList> idsPerRepository;

312

stream >> idsPerRepository;

315

stream >> idsPerRepository;

313

316

314

for (auto it = idsPerRepository.cbegin(); it != idsPerRepository.cend(); ++it) {

317

for (auto it = idsPerRepository.cbegin(); it != idsPerRepository.cend(); ++it) {

315

auto repository = it.key();

318

auto repository = it.key();

316

auto allRepositoryEvent = retrieveEvents(repository);

319

auto allRepositoryEvent = retrieveEvents(repository);

317

for (auto uuid : it.value()) {

320

for (auto uuid : it.value()) {

318

for (auto repositoryEvent : allRepositoryEvent) {

321

for (auto repositoryEvent : allRepositoryEvent) {

319

if (uuid.toUuid() == repositoryEvent->getUniqId()) {

322

if (uuid.toUuid() == repositoryEvent->getUniqId()) {

320

events << repositoryEvent;

323

events << repositoryEvent;

321

}

324

}

322

}

325

}

323

}

326

}

324

}

327

}

325

328

326

return events;

329

return events;

327

}

330

}

328

331

329

void CatalogueController::initialize()

332

void CatalogueController::initialize()

330

{

333

{

331

qCDebug(LOG_CatalogueController()) << tr("CatalogueController init")

334

qCDebug(LOG_CatalogueController()) << tr("CatalogueController init")

332

<< QThread::currentThread();

335

<< QThread::currentThread();

333

336

334

impl->m_CatalogueDao.initialize();

337

impl->m_CatalogueDao.initialize();

335

auto defaultRepositoryLocation

338

auto defaultRepositoryLocation

336

= QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);

339

= QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);

337

340

338

QDir defaultRepositoryLocationDir;

341

QDir defaultRepositoryLocationDir;

339

if (defaultRepositoryLocationDir.mkpath(defaultRepositoryLocation)) {

342

if (defaultRepositoryLocationDir.mkpath(defaultRepositoryLocation)) {

340

defaultRepositoryLocationDir.cd(defaultRepositoryLocation);

343

defaultRepositoryLocationDir.cd(defaultRepositoryLocation);

341

auto defaultRepository = defaultRepositoryLocationDir.absoluteFilePath(REPOSITORY_DEFAULT);

344

auto defaultRepository = defaultRepositoryLocationDir.absoluteFilePath(REPOSITORY_DEFAULT);

342

345

343

qCInfo(LOG_CatalogueController()) << tr("Persistant data loading from: ")

346

qCInfo(LOG_CatalogueController()) << tr("Persistant data loading from: ")

344

<< defaultRepository;

347

<< defaultRepository;

345

348

346

QDir dbDir(defaultRepository);

349

QDir dbDir(defaultRepository);

347

impl->m_RepositoryList << REPOSITORY_DEFAULT;

350

impl->m_RepositoryList << REPOSITORY_DEFAULT;

348

if (dbDir.exists()) {

351

if (dbDir.exists()) {

349

auto dirName = dbDir.dirName();

352

auto dirName = dbDir.dirName();

350

353

351

if (impl->m_CatalogueDao.addDB(defaultRepository, dirName)) {

354

if (impl->m_CatalogueDao.addDB(defaultRepository, dirName)) {

352

impl->copyDBtoDB(dirName, impl->toWorkRepository(dirName));

355

impl->copyDBtoDB(dirName, impl->toWorkRepository(dirName));

353

}

356

}

354

}

357

}

355

else {

358

else {

356

qCInfo(LOG_CatalogueController()) << tr("Initialisation of Default repository detected")

359

qCInfo(LOG_CatalogueController()) << tr("Initialisation of Default repository detected")

357

<< defaultRepository;

360

<< defaultRepository;

358

}

361

}

359

}

362

}

360

else {

363

else {

361

qCWarning(LOG_CatalogueController())

364

qCWarning(LOG_CatalogueController())

362

<< tr("Cannot load the persistent default repository from ")

365

<< tr("Cannot load the persistent default repository from ")

363

<< defaultRepositoryLocation;

366

<< defaultRepositoryLocation;

364

}

367

}

365

368

366

qCDebug(LOG_CatalogueController()) << tr("CatalogueController init END");

369

qCDebug(LOG_CatalogueController()) << tr("CatalogueController init END");

367

}

370

}

368

371

369

QString CatalogueController::CatalogueControllerPrivate::eventUniqueKey(

372

QString CatalogueController::CatalogueControllerPrivate::eventUniqueKey(

370

const std::shared_ptr<DBEvent> &event) const

373

const std::shared_ptr<DBEvent> &event) const

371

{

374

{

372

return event->getUniqId().toString().append(event->getRepository());

375

return event->getUniqId().toString().append(event->getRepository());

373

}

376

}

374

377

375

void CatalogueController::CatalogueControllerPrivate::copyDBtoDB(const QString &dbFrom,

378

void CatalogueController::CatalogueControllerPrivate::copyDBtoDB(const QString &dbFrom,

376

const QString &dbTo)

379

const QString &dbTo)

377

{

380

{

378

// auto cataloguesShared = std::list<std::shared_ptr<DBCatalogue> >{};

381

// auto cataloguesShared = std::list<std::shared_ptr<DBCatalogue> >{};

379

auto catalogues = m_CatalogueDao.getCatalogues(dbFrom);

382

auto catalogues = m_CatalogueDao.getCatalogues(dbFrom);

380

auto events = m_CatalogueDao.getEvents(dbFrom);

383

auto events = m_CatalogueDao.getEvents(dbFrom);

381

for (auto catalogue : catalogues) {

384

for (auto catalogue : catalogues) {

382

m_CatalogueDao.copyCatalogue(catalogue, dbTo, true);

385

m_CatalogueDao.copyCatalogue(catalogue, dbTo, true);

383

}

386

}

384

387

385

for (auto event : events) {

388

for (auto event : events) {

386

m_CatalogueDao.copyEvent(event, dbTo, true);

389

m_CatalogueDao.copyEvent(event, dbTo, true);

387

}

390

}

388

}

391

}

389

392

390

QString CatalogueController::CatalogueControllerPrivate::toWorkRepository(QString repository)

393

QString CatalogueController::CatalogueControllerPrivate::toWorkRepository(QString repository)

391

{

394

{

392

auto syncRepository = toSyncRepository(repository);

395

auto syncRepository = toSyncRepository(repository);

393

396

394

return QString("%1%2").arg(syncRepository, REPOSITORY_WORK_SUFFIX);

397

return QString("%1%2").arg(syncRepository, REPOSITORY_WORK_SUFFIX);

395

}

398

}

396

399

397

QString CatalogueController::CatalogueControllerPrivate::toSyncRepository(QString repository)

400

QString CatalogueController::CatalogueControllerPrivate::toSyncRepository(QString repository)

398

{

401

{

399

auto syncRepository = repository;

402

auto syncRepository = repository;

400

if (repository.endsWith(REPOSITORY_WORK_SUFFIX)) {

403

if (repository.endsWith(REPOSITORY_WORK_SUFFIX)) {

401

syncRepository.remove(REPOSITORY_WORK_SUFFIX);

404

syncRepository.remove(REPOSITORY_WORK_SUFFIX);

402

}

405

}

403

else if (repository.endsWith(REPOSITORY_TRASH_SUFFIX)) {

406

else if (repository.endsWith(REPOSITORY_TRASH_SUFFIX)) {

404

syncRepository.remove(REPOSITORY_TRASH_SUFFIX);

407

syncRepository.remove(REPOSITORY_TRASH_SUFFIX);

405

}

408

}

406

return syncRepository;

409

return syncRepository;

407

}

410

}

408

411

409

void CatalogueController::CatalogueControllerPrivate::savAllDB()

412

void CatalogueController::CatalogueControllerPrivate::savAllDB()

410

{

413

{

411

for (auto repository : m_RepositoryList) {

414

for (auto repository : m_RepositoryList) {

412

auto defaultRepositoryLocation

415

auto defaultRepositoryLocation

413

= QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);

416

= QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);

414

m_CatalogueDao.saveDB(defaultRepositoryLocation, repository);

417

m_CatalogueDao.saveDB(defaultRepositoryLocation, repository);

415

}

418

}

416

}

419

}

417

420

418

void CatalogueController::CatalogueControllerPrivate::saveEvent(std::shared_ptr<DBEvent> event,

421

void CatalogueController::CatalogueControllerPrivate::saveEvent(std::shared_ptr<DBEvent> event,

419

bool persist)

422

bool persist)

420

{

423

{

421

m_CatalogueDao.copyEvent(*event, toSyncRepository(event->getRepository()), true);

424

m_CatalogueDao.copyEvent(*event, toSyncRepository(event->getRepository()), true);

422

if (persist) {

425

if (persist) {

423

savAllDB();

426

savAllDB();

424

}

427

}

425

}

428

}

426

429

427

void CatalogueController::CatalogueControllerPrivate::saveCatalogue(

430

void CatalogueController::CatalogueControllerPrivate::saveCatalogue(

428

std::shared_ptr<DBCatalogue> catalogue, bool persist)

431

std::shared_ptr<DBCatalogue> catalogue, bool persist)

429

{

432

{

430

m_CatalogueDao.copyCatalogue(*catalogue, toSyncRepository(catalogue->getRepository()), true);

433

m_CatalogueDao.copyCatalogue(*catalogue, toSyncRepository(catalogue->getRepository()), true);

431

if (persist) {

434

if (persist) {

432

savAllDB();

435

savAllDB();

433

}

436

}

434

}

437

}

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages

             #include <Catalogue/CatalogueController.h>
             #include <Variable/Variable.h>
             #include <CatalogueDao.h>
             #include <ComparaisonPredicate.h>
             #include <CompoundPredicate.h>
             #include <DBCatalogue.h>
             #include <DBEvent.h>
             #include <DBEventProduct.h>
             #include <DBTag.h>
             #include <IRequestPredicate.h>
             #include <QDataStream>
             #include <QMutex>
             #include <QThread>
             #include <QDir>
             #include <QStandardPaths>
             Q_LOGGING_CATEGORY(LOG_CatalogueController, "CatalogueController")
             namespace {
             static QString REPOSITORY_WORK_SUFFIX = QString{"_work"};
             static QString REPOSITORY_TRASH_SUFFIX = QString{"_trash"};
             }
             class CatalogueController::CatalogueControllerPrivate {
             public:
                 explicit CatalogueControllerPrivate(CatalogueController *parent) : m_Q{parent} {}
                 CatalogueDao m_CatalogueDao;
                 QStringList m_RepositoryList;
                 CatalogueController *m_Q;
                 QSet<QString> m_EventKeysWithChanges;
                 QString eventUniqueKey(const std::shared_ptr<DBEvent> &event) const;
                 void copyDBtoDB(const QString &dbFrom, const QString &dbTo);
                 QString toWorkRepository(QString repository);
                 QString toSyncRepository(QString repository);
                 void savAllDB();
                 void saveEvent(std::shared_ptr<DBEvent> event, bool persist = true);
                 void saveCatalogue(std::shared_ptr<DBCatalogue> catalogue, bool persist = true);
             };
             CatalogueController::CatalogueController(QObject *parent)
                     : impl{spimpl::make_unique_impl<CatalogueControllerPrivate>(this)}
             {
                 qCDebug(LOG_CatalogueController()) << tr("CatalogueController construction")
                                                    << QThread::currentThread();
             }
             CatalogueController::~CatalogueController()
             {
                 qCDebug(LOG_CatalogueController()) << tr("CatalogueController destruction")
                                                    << QThread::currentThread();
             }
             QStringList CatalogueController::getRepositories() const
             {
                 return impl->m_RepositoryList;
             }
             void CatalogueController::addDB(const QString &dbPath)
             {
                 QDir dbDir(dbPath);
                 if (dbDir.exists()) {
                     auto dirName = dbDir.dirName();
                     if (std::find(impl->m_RepositoryList.cbegin(), impl->m_RepositoryList.cend(), dirName)
                         != impl->m_RepositoryList.cend()) {
                         qCCritical(LOG_CatalogueController())
                             << tr("Impossible to addDB that is already loaded");
                     }
                     if (!impl->m_CatalogueDao.addDB(dbPath, dirName)) {
                         qCCritical(LOG_CatalogueController())
                             << tr("Impossible to addDB %1 from %2 ").arg(dirName, dbPath);
                     }
                     else {
                         impl->m_RepositoryList << dirName;
                         impl->copyDBtoDB(dirName, impl->toWorkRepository(dirName));
                     }
                 }
                 else {
                     qCCritical(LOG_CatalogueController()) << tr("Impossible to addDB that not exists: ")
                                                           << dbPath;
                 }
             }
             void CatalogueController::saveDB(const QString &destinationPath, const QString &repository)
             {
                 if (!impl->m_CatalogueDao.saveDB(destinationPath, repository)) {
                     qCCritical(LOG_CatalogueController())
                         << tr("Impossible to saveDB %1 from %2 ").arg(repository, destinationPath);
                 }
             }
             std::list<std::shared_ptr<DBEvent> >
             CatalogueController::retrieveEvents(const QString &repository) const
             {
                 QString dbDireName = repository.isEmpty() ? REPOSITORY_DEFAULT : repository;
                 auto eventsShared = std::list<std::shared_ptr<DBEvent> >{};
                 auto events = impl->m_CatalogueDao.getEvents(impl->toWorkRepository(dbDireName));
                 for (auto event : events) {
                     eventsShared.push_back(std::make_shared<DBEvent>(event));
                 }
                 return eventsShared;
             }
             std::list<std::shared_ptr<DBEvent> > CatalogueController::retrieveAllEvents() const
             {
                 auto eventsShared = std::list<std::shared_ptr<DBEvent> >{};
                 for (auto repository : impl->m_RepositoryList) {
                     eventsShared.splice(eventsShared.end(), retrieveEvents(repository));
                 }
                 return eventsShared;
             }
             std::list<std::shared_ptr<DBEvent> >
             CatalogueController::retrieveEventsFromCatalogue(std::shared_ptr<DBCatalogue> catalogue) const
             {
                 auto eventsShared = std::list<std::shared_ptr<DBEvent> >{};
                 auto events = impl->m_CatalogueDao.getCatalogueEvents(*catalogue);
                 for (auto event : events) {
                     eventsShared.push_back(std::make_shared<DBEvent>(event));
                 }
                 return eventsShared;
             }
             void CatalogueController::updateEvent(std::shared_ptr<DBEvent> event)
             {
                 event->setRepository(impl->toWorkRepository(event->getRepository()));
                 auto uniqueId = impl->eventUniqueKey(event);
                 impl->m_EventKeysWithChanges.insert(uniqueId);
                 impl->m_CatalogueDao.updateEvent(*event);
             }
             void CatalogueController::updateEventProduct(std::shared_ptr<DBEventProduct> eventProduct)
             {
                 impl->m_CatalogueDao.updateEventProduct(*eventProduct);
             }
             void CatalogueController::removeEvent(std::shared_ptr<DBEvent> event)
             {
                 // Remove it from both repository and repository_work
                 event->setRepository(impl->toWorkRepository(event->getRepository()));
                 impl->m_CatalogueDao.removeEvent(*event);
                 event->setRepository(impl->toSyncRepository(event->getRepository()));
                 impl->m_CatalogueDao.removeEvent(*event);
                 impl->savAllDB();
             }
             void CatalogueController::addEvent(std::shared_ptr<DBEvent> event)
             {
                 event->setRepository(impl->toWorkRepository(event->getRepository()));
                 auto eventTemp = *event;
                 impl->m_CatalogueDao.addEvent(eventTemp);
                 // Call update is necessary at the creation of add Event if it has some tags or some event
                 // products
                 if (!event->getEventProducts().empty() || !event->getTags().empty()) {
                     auto eventProductsTemp = eventTemp.getEventProducts();
                     auto eventProductTempUpdated = std::list<DBEventProduct>{};
                     for (auto eventProductTemp : eventProductsTemp) {
                         eventProductTemp.setEvent(eventTemp);
                         eventProductTempUpdated.push_back(eventProductTemp);
                     }
                     eventTemp.setEventProducts(eventProductTempUpdated);
                     impl->m_CatalogueDao.updateEvent(eventTemp);
                 }
+                auto uniqueId = impl->eventUniqueKey(event);
+                impl->m_EventKeysWithChanges.insert(uniqueId);
             }
             void CatalogueController::saveEvent(std::shared_ptr<DBEvent> event)
             {
                 impl->saveEvent(event, true);
                 impl->m_EventKeysWithChanges.remove(impl->eventUniqueKey(event));
             }
             void CatalogueController::discardEvent(std::shared_ptr<DBEvent> event)
             {
                 auto uniqIdPredicate = std::make_shared<ComparaisonPredicate>(
                     QString{"uniqId"}, event->getUniqId(), ComparaisonOperation::EQUALEQUAL);
                 auto syncRepositoryPredicate = std::make_shared<ComparaisonPredicate>(
                     QString{"repository"}, impl->toSyncRepository(event->getRepository()),
                     ComparaisonOperation::EQUALEQUAL);
                 auto syncPred = std::make_shared<CompoundPredicate>(CompoundOperation::AND);
                 syncPred->AddRequestPredicate(uniqIdPredicate);
                 syncPred->AddRequestPredicate(syncRepositoryPredicate);
                 auto workRepositoryPredicate = std::make_shared<ComparaisonPredicate>(
                     QString{"repository"}, impl->toWorkRepository(event->getRepository()),
                     ComparaisonOperation::EQUALEQUAL);
                 auto workPred = std::make_shared<CompoundPredicate>(CompoundOperation::AND);
                 workPred->AddRequestPredicate(uniqIdPredicate);
                 workPred->AddRequestPredicate(workRepositoryPredicate);
                 auto syncEvent = impl->m_CatalogueDao.getEvent(syncPred);
                 impl->m_CatalogueDao.copyEvent(syncEvent, impl->toWorkRepository(event->getRepository()), true);
                 auto workEvent = impl->m_CatalogueDao.getEvent(workPred);
                 *event = workEvent;
                 impl->m_EventKeysWithChanges.remove(impl->eventUniqueKey(event));
             }
             bool CatalogueController::eventHasChanges(std::shared_ptr<DBEvent> event) const
             {
                 return impl->m_EventKeysWithChanges.contains(impl->eventUniqueKey(event));
             }
             std::list<std::shared_ptr<DBCatalogue> >
             CatalogueController::retrieveCatalogues(const QString &repository) const
             {
                 QString dbDireName = repository.isEmpty() ? REPOSITORY_DEFAULT : repository;
                 auto cataloguesShared = std::list<std::shared_ptr<DBCatalogue> >{};
                 auto catalogues = impl->m_CatalogueDao.getCatalogues(impl->toWorkRepository(dbDireName));
                 for (auto catalogue : catalogues) {
                     cataloguesShared.push_back(std::make_shared<DBCatalogue>(catalogue));
                 }
                 return cataloguesShared;
             }
             void CatalogueController::updateCatalogue(std::shared_ptr<DBCatalogue> catalogue)
             {
                 catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));
                 impl->m_CatalogueDao.updateCatalogue(*catalogue);
             }
             void CatalogueController::removeCatalogue(std::shared_ptr<DBCatalogue> catalogue)
             {
                 // Remove it from both repository and repository_work
                 catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));
                 impl->m_CatalogueDao.removeCatalogue(*catalogue);
                 catalogue->setRepository(impl->toSyncRepository(catalogue->getRepository()));
                 impl->m_CatalogueDao.removeCatalogue(*catalogue);
             }
             void CatalogueController::saveCatalogue(std::shared_ptr<DBCatalogue> catalogue)
             {
                 impl->saveCatalogue(catalogue, true);
             }
             void CatalogueController::saveAll()
             {
                 for (auto repository : impl->m_RepositoryList) {
                     // Save Event
                     auto events = this->retrieveEvents(repository);
                     for (auto event : events) {
                         impl->saveEvent(event, false);
                     }
                     // Save Catalogue
                     auto catalogues = this->retrieveCatalogues(repository);
                     for (auto catalogue : catalogues) {
                         impl->saveCatalogue(catalogue, false);
                     }
                 }
                 impl->savAllDB();
                 impl->m_EventKeysWithChanges.clear();
             }
             bool CatalogueController::hasChanges() const
             {
                 return !impl->m_EventKeysWithChanges.isEmpty(); // TODO: catalogues
             }
             QByteArray
             CatalogueController::mimeDataForEvents(const QVector<std::shared_ptr<DBEvent> > &events) const
             {
                 auto encodedData = QByteArray{};
                 QMap<QString, QVariantList> idsPerRepository;
                 for (auto event : events) {
                     idsPerRepository[event->getRepository()] << event->getUniqId();
                 }
                 QDataStream stream{&encodedData, QIODevice::WriteOnly};
                 stream << idsPerRepository;
                 return encodedData;
             }
             QVector<std::shared_ptr<DBEvent> >
             CatalogueController::eventsForMimeData(const QByteArray &mimeData) const
             {
                 auto events = QVector<std::shared_ptr<DBEvent> >{};
                 QDataStream stream{mimeData};
                 QMap<QString, QVariantList> idsPerRepository;
                 stream >> idsPerRepository;
                 for (auto it = idsPerRepository.cbegin(); it != idsPerRepository.cend(); ++it) {
                     auto repository = it.key();
                     auto allRepositoryEvent = retrieveEvents(repository);
                     for (auto uuid : it.value()) {
                         for (auto repositoryEvent : allRepositoryEvent) {
                             if (uuid.toUuid() == repositoryEvent->getUniqId()) {
                                 events << repositoryEvent;
                             }
                         }
                     }
                 }
                 return events;
             }
             void CatalogueController::initialize()
             {
                 qCDebug(LOG_CatalogueController()) << tr("CatalogueController init")
                                                    << QThread::currentThread();
                 impl->m_CatalogueDao.initialize();
                 auto defaultRepositoryLocation
                     = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
                 QDir defaultRepositoryLocationDir;
                 if (defaultRepositoryLocationDir.mkpath(defaultRepositoryLocation)) {
                     defaultRepositoryLocationDir.cd(defaultRepositoryLocation);
                     auto defaultRepository = defaultRepositoryLocationDir.absoluteFilePath(REPOSITORY_DEFAULT);
                     qCInfo(LOG_CatalogueController()) << tr("Persistant data loading from: ")
                                                       << defaultRepository;
                     QDir dbDir(defaultRepository);
                     impl->m_RepositoryList << REPOSITORY_DEFAULT;
                     if (dbDir.exists()) {
                         auto dirName = dbDir.dirName();
                         if (impl->m_CatalogueDao.addDB(defaultRepository, dirName)) {
                             impl->copyDBtoDB(dirName, impl->toWorkRepository(dirName));
                         }
                     }
                     else {
                         qCInfo(LOG_CatalogueController()) << tr("Initialisation of Default repository detected")
                                                           << defaultRepository;
                     }
                 }
                 else {
                     qCWarning(LOG_CatalogueController())
                         << tr("Cannot load the persistent default repository from ")
                         << defaultRepositoryLocation;
                 }
                 qCDebug(LOG_CatalogueController()) << tr("CatalogueController init END");
             }
             QString CatalogueController::CatalogueControllerPrivate::eventUniqueKey(
                 const std::shared_ptr<DBEvent> &event) const
             {
                 return event->getUniqId().toString().append(event->getRepository());
             }
             void CatalogueController::CatalogueControllerPrivate::copyDBtoDB(const QString &dbFrom,
                                                                              const QString &dbTo)
             {
                 //    auto cataloguesShared = std::list<std::shared_ptr<DBCatalogue> >{};
                 auto catalogues = m_CatalogueDao.getCatalogues(dbFrom);
                 auto events = m_CatalogueDao.getEvents(dbFrom);
                 for (auto catalogue : catalogues) {
                     m_CatalogueDao.copyCatalogue(catalogue, dbTo, true);
                 }
                 for (auto event : events) {
                     m_CatalogueDao.copyEvent(event, dbTo, true);
                 }
             }
             QString CatalogueController::CatalogueControllerPrivate::toWorkRepository(QString repository)
             {
                 auto syncRepository = toSyncRepository(repository);
                 return QString("%1%2").arg(syncRepository, REPOSITORY_WORK_SUFFIX);
             }
             QString CatalogueController::CatalogueControllerPrivate::toSyncRepository(QString repository)
             {
                 auto syncRepository = repository;
                 if (repository.endsWith(REPOSITORY_WORK_SUFFIX)) {
                     syncRepository.remove(REPOSITORY_WORK_SUFFIX);
                 }
                 else if (repository.endsWith(REPOSITORY_TRASH_SUFFIX)) {
                     syncRepository.remove(REPOSITORY_TRASH_SUFFIX);
                 }
                 return syncRepository;
             }
             void CatalogueController::CatalogueControllerPrivate::savAllDB()
             {
                 for (auto repository : m_RepositoryList) {
                     auto defaultRepositoryLocation
                         = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
                     m_CatalogueDao.saveDB(defaultRepositoryLocation, repository);
                 }
             }
             void CatalogueController::CatalogueControllerPrivate::saveEvent(std::shared_ptr<DBEvent> event,
                                                                             bool persist)
             {
                 m_CatalogueDao.copyEvent(*event, toSyncRepository(event->getRepository()), true);
                 if (persist) {
                     savAllDB();
                 }
             }
             void CatalogueController::CatalogueControllerPrivate::saveCatalogue(
                 std::shared_ptr<DBCatalogue> catalogue, bool persist)
             {
                 m_CatalogueDao.copyCatalogue(*catalogue, toSyncRepository(catalogue->getRepository()), true);
                 if (persist) {
                     savAllDB();
                 }
             }