HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1268:acc828493557

Add Catalogue methods

mperrinel -

r1268:acc828493557

parent child

Context file:

r1268:acc828493557

Collapse all files

core/include/Catalogue/CatalogueController.h +1 -1

                  // Catalogue
                  std::list<std::shared_ptr<DBEvent> >
                  retrieveEventsFromCatalogue(std::shared_ptr<DBCatalogue> catalogue) const;
-                 //    bool createCatalogue(const QString &name, QVector<QUuid> eventList);
                  /// retrieveEvents with empty repository retrieve them from the default repository
                  std::list<std::shared_ptr<DBCatalogue> > retrieveCatalogues(const QString &repository
                                                                              = QString()) const;
+                 void addCatalogue(std::shared_ptr<DBCatalogue> catalogue);
                  void updateCatalogue(std::shared_ptr<DBCatalogue> catalogue);
                  void removeCatalogue(std::shared_ptr<DBCatalogue> catalogue);
                  void saveCatalogue(std::shared_ptr<DBCatalogue> catalogue);

core/src/Catalogue/CatalogueController.cpp +59 -20

              static QString REPOSITORY_TRASH_SUFFIX = QString{"_trash"};
              }
+             /**
+              * Possible types of an repository
+              */
+             enum class DBType { SYNC, WORK, TRASH};
              class CatalogueController::CatalogueControllerPrivate {
              public:
                  void saveEvent(std::shared_ptr<DBEvent> event, bool persist = true);
                  void saveCatalogue(std::shared_ptr<DBCatalogue> catalogue, bool persist = true);
+                 std::shared_ptr<IRequestPredicate> createFinder(const QUuid& uniqId, const QString & repository, DBType type);
              };
              CatalogueController::CatalogueController(QObject *parent)
              void CatalogueController::discardEvent(std::shared_ptr<DBEvent> event, bool &removed)
              {
-                 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 syncPred = impl->createFinder(event->getUniqId(), event->getRepository(), DBType::SYNC);
+                 auto workPred = impl->createFinder(event->getUniqId(), event->getRepository(), DBType::WORK);
                  auto syncEvent = impl->m_CatalogueDao.getEvent(syncPred);
                  if (!syncEvent.getUniqId().isNull()) {
                  return cataloguesShared;
              }
+             void CatalogueController::addCatalogue(std::shared_ptr<DBCatalogue> catalogue)
+             {
+                 catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));
+                 auto catalogueTemp = *catalogue;
+                 impl->m_CatalogueDao.addCatalogue(catalogueTemp);
+                 auto workPred = impl->createFinder(catalogue->getUniqId(), catalogue->getRepository(), DBType::WORK);
+                 auto workCatalogue = impl->m_CatalogueDao.getCatalogue(workPred);
+                 *catalogue = workCatalogue;
+             //    auto uniqueId = impl->eventUniqueKey(catalogue);
+             //    impl->m_EventKeysWithChanges.insert(uniqueId);
+             }
              void CatalogueController::updateCatalogue(std::shared_ptr<DBCatalogue> catalogue)
              {
                  catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));
+             //    auto uniqueId = impl->eventUniqueKey(event);
+             //    impl->m_EventKeysWithChanges.insert(uniqueId);
                  impl->m_CatalogueDao.updateCatalogue(*catalogue);
              }
                  impl->m_CatalogueDao.removeCatalogue(*catalogue);
                  catalogue->setRepository(impl->toSyncRepository(catalogue->getRepository()));
                  impl->m_CatalogueDao.removeCatalogue(*catalogue);
+                 impl->savAllDB();
              }
              void CatalogueController::saveCatalogue(std::shared_ptr<DBCatalogue> catalogue)
              {
                  impl->saveCatalogue(catalogue, true);
+             //    impl->m_EventKeysWithChanges.remove(impl->eventUniqueKey(event));
              }
              void CatalogueController::saveAll()
                      savAllDB();
                  }
              }
+             std::shared_ptr<IRequestPredicate> CatalogueController::CatalogueControllerPrivate::createFinder(const QUuid &uniqId, const QString &repository, DBType type)
+             {
+                 // update catalogue parameter
+                 auto uniqIdPredicate = std::make_shared<ComparaisonPredicate>(
+                     QString{"uniqId"}, uniqId, ComparaisonOperation::EQUALEQUAL);
+                 auto repositoryType = repository;
+                 switch (type) {
+                 case DBType::SYNC:
+                     repositoryType = toSyncRepository(repositoryType);
+                     break;
+                 case DBType::WORK:
+                     repositoryType =toWorkRepository(repositoryType);
+                     break;
+                 case DBType::TRASH:
+                 default:
+                     break;
+                 }
+                 auto repositoryPredicate = std::make_shared<ComparaisonPredicate>(
+                     QString{"repository"}, repositoryType,
+                     ComparaisonOperation::EQUALEQUAL);
+                 auto finderPred = std::make_shared<CompoundPredicate>(CompoundOperation::AND);
+                 finderPred->AddRequestPredicate(uniqIdPredicate);
+                 finderPred->AddRequestPredicate(repositoryPredicate);
+                 return finderPred;
+             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	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