CatalogueController.cpp
800 lines
| 24.1 KiB
| text/x-c
|
CppLexer
r0 | #include <Catalogue/CatalogueController.h> | |||
r53 | #include <CatalogueIO.hpp> | |||
#include <Common/containers.h> | ||||
#include <Common/debug.h> | ||||
r0 | #include <QDataStream> | |||
#include <QDir> | ||||
r53 | #include <QMutex> | |||
r0 | #include <QStandardPaths> | |||
r53 | #include <QThread> | |||
r0 | ||||
r53 | using namespace SciQLop::containers; | |||
r0 | ||||
r53 | // class CatalogueController::CatalogueControllerPrivate | |||
//{ | ||||
r0 | ||||
r53 | // public: | |||
// explicit CatalogueControllerPrivate(CatalogueController* parent) : m_Q { | ||||
// parent } {} | ||||
r0 | ||||
r53 | // CatalogueDao m_CatalogueDao; | |||
r0 | ||||
r53 | // QStringList m_RepositoryList; | |||
// CatalogueController* m_Q; | ||||
r0 | ||||
r53 | // QSet<QString> m_KeysWithChanges; | |||
r0 | ||||
r53 | // QString eventUniqueKey(const std::shared_ptr<DBEvent>& event) const; | |||
// QString catalogueUniqueKey(const std::shared_ptr<DBCatalogue>& catalogue) | ||||
// const; | ||||
r0 | ||||
r53 | // void copyDBtoDB(const QString& dbFrom, const QString& dbTo); | |||
// QString toWorkRepository(QString repository); | ||||
// QString toSyncRepository(QString repository); | ||||
// void savAllDB(); | ||||
r0 | ||||
r53 | // void saveEvent(std::shared_ptr<DBEvent> event, bool persist = true); | |||
// void saveCatalogue(std::shared_ptr<DBCatalogue> catalogue, bool persist = | ||||
// true); | ||||
r0 | ||||
r53 | // std::shared_ptr<IRequestPredicate> createFinder( | |||
// const QUuid& uniqId, const QString& repository, DBType type); | ||||
//}; | ||||
r0 | ||||
r53 | CatalogueController::CatalogueController(QObject* parent) | |||
//: impl { spimpl::make_unique_impl<CatalogueControllerPrivate>(this) } | ||||
{} | ||||
r0 | ||||
r53 | CatalogueController::~CatalogueController() {} | |||
r0 | ||||
r54 | QStringList CatalogueController::repositories() const | |||
r0 | { | |||
r53 | QStringList repos; | |||
std::transform(std::begin(_currentRepos), std::end(_currentRepos), | ||||
std::back_inserter(repos), | ||||
[](auto& pair) { return pair.first; }); | ||||
return repos; | ||||
r0 | } | |||
r53 | void CatalogueController::loadRepository(const QString& path, | |||
const QString& name) | ||||
r0 | { | |||
r53 | if(QFile::exists(path)) | |||
{ | ||||
auto repo = CatalogiCpp::load_repository<time_t>(path.toStdString()); | ||||
_lastSavedRepos[name] = repo; | ||||
_currentRepos[name] = repo; | ||||
} | ||||
r0 | } | |||
r53 | void CatalogueController::saveRepository(const QString& path, | |||
const QString& name) | ||||
r0 | { | |||
r53 | if(contains(_currentRepos, name)) | |||
{ | ||||
CatalogiCpp::save_repository(_currentRepos[name], path.toStdString()); | ||||
_lastSavedRepos[name] = _currentRepos[name]; | ||||
} | ||||
r0 | } | |||
r53 | std::vector<CatalogueController::Event_ptr> CatalogueController::events() | |||
r0 | { | |||
r53 | std::vector<CatalogueController::Event_ptr> e_list; | |||
for(auto& [_, repo] : _currentRepos) | ||||
{ | ||||
for(auto& [_, event] : repo.events()) | ||||
e_list.push_back(event); | ||||
} | ||||
return e_list; | ||||
r0 | } | |||
r55 | std::vector<CatalogueController::Event_ptr> | |||
CatalogueController::events(const CatalogueController::Catalogue_ptr& catalogue) | ||||
{ | ||||
std::vector<CatalogueController::Event_ptr> e_list; | ||||
for(auto& [_, event] : catalogue->events()) | ||||
e_list.push_back(event); | ||||
return e_list; | ||||
} | ||||
r53 | std::vector<std::shared_ptr<CatalogueController::Event_t>> | |||
CatalogueController::events(const QString& repository) | ||||
r0 | { | |||
r53 | std::vector<std::shared_ptr<CatalogueController::Event_t>> e_list; | |||
if(contains(_currentRepos, repository)) | ||||
{ | ||||
auto repo = _currentRepos[repository]; | ||||
for(auto& [_, event] : repo.events()) | ||||
e_list.push_back(event); | ||||
} | ||||
return e_list; | ||||
r0 | } | |||
r53 | std::vector<CatalogueController::Catalogue_ptr> | |||
CatalogueController::catalogues() | ||||
r0 | { | |||
r53 | std::vector<CatalogueController::Catalogue_ptr> c_list; | |||
for(auto& [_, repo] : _currentRepos) | ||||
{ | ||||
for(auto& [_, catalogue] : repo.catalogues()) | ||||
c_list.push_back(catalogue); | ||||
} | ||||
return c_list; | ||||
r0 | } | |||
r53 | std::vector<CatalogueController::Catalogue_ptr> | |||
CatalogueController::catalogues(const QString& repository) | ||||
r0 | { | |||
r53 | std::vector<CatalogueController::Catalogue_ptr> c_list; | |||
if(contains(_currentRepos, repository)) | ||||
{ | ||||
auto repo = _currentRepos[repository]; | ||||
for(auto& [_, catalogue] : repo.catalogues()) | ||||
c_list.push_back(catalogue); | ||||
} | ||||
return c_list; | ||||
r0 | } | |||
r53 | bool CatalogueController::hasUnsavedChanges( | |||
CatalogueController::Event_ptr event) | ||||
r0 | { | |||
r53 | if(auto repo = repository(event)) | |||
{ | ||||
if(contains(_lastSavedRepos, *repo)) | ||||
{ return *event != *(_lastSavedRepos[*repo].event(event->uuid)); } | ||||
} | ||||
return true; | ||||
r0 | } | |||
r53 | std::optional<QString> | |||
CatalogueController::repository(CatalogueController::Event_ptr event) | ||||
r0 | { | |||
r53 | for(auto& [repoName, repo] : _currentRepos) | |||
{ | ||||
if(repo.event(event->uuid)) return repoName; | ||||
} | ||||
return std::nullopt; | ||||
r0 | } | |||
r53 | std::optional<QString> | |||
CatalogueController::repository(CatalogueController::Catalogue_ptr catalogue) | ||||
r0 | { | |||
r53 | for(auto& [repoName, repo] : _currentRepos) | |||
{ | ||||
if(repo.catalogue(catalogue->uuid)) return repoName; | ||||
} | ||||
return std::nullopt; | ||||
r0 | } | |||
r53 | void CatalogueController::save(CatalogueController::Event_ptr event) | |||
r0 | { | |||
r53 | auto repo_name = repository(event); | |||
if(repo_name && contains(_lastSavedRepos, *repo_name)) | ||||
{ | ||||
auto repo = _lastSavedRepos[*repo_name]; | ||||
if(contains(repo.events(), event->uuid)) | ||||
{ | ||||
auto saved_evemt = _lastSavedRepos[*repo_name].event(event->uuid); | ||||
*saved_evemt = *event; | ||||
r0 | } | |||
r53 | else | |||
{ | ||||
// TODO/Question should we also take care of which catalogue has it? | ||||
// if an event is created and added to a catalogue, what should we do if | ||||
// the user clicks the event save button? | ||||
// - Only save event value in all events list? | ||||
// - Also save the fact that this event is added to a catalogue and save | ||||
// the catalogue? | ||||
repo.add(event); | ||||
r0 | } | |||
r53 | } | |||
r0 | } | |||
r53 | void CatalogueController::save(CatalogueController::Catalogue_ptr catalogue) | |||
r0 | { | |||
r53 | auto repo_name = repository(catalogue); | |||
if(repo_name && contains(_lastSavedRepos, *repo_name)) | ||||
{ | ||||
auto repo = _lastSavedRepos[*repo_name]; | ||||
if(contains(repo.catalogues(), catalogue->uuid)) | ||||
{ | ||||
auto saved_catalogue = repo.catalogue(catalogue->uuid); | ||||
*saved_catalogue = *catalogue; | ||||
r0 | } | |||
r53 | else | |||
{ | ||||
repo.add(catalogue); | ||||
r0 | } | |||
r53 | } | |||
} | ||||
void CatalogueController::save(const QString& repository) | ||||
{ | ||||
if(contains(_currentRepos, repository)) | ||||
{ _lastSavedRepos[repository] = _currentRepos[repository]; } | ||||
else | ||||
{ | ||||
SCIQLOP_ERROR(CatalogueController, "Trying to save an unknown repository"); | ||||
} | ||||
} | ||||
r54 | void CatalogueController::add(const QString& repository) | |||
{ | ||||
if(!contains(_currentRepos, repository)) | ||||
r55 | { | |||
_currentRepos[repository] = Repository_t{}; | ||||
emit repositoryAdded(repository); | ||||
} | ||||
r54 | } | |||
r55 | CatalogueController::Catalogue_ptr | |||
CatalogueController::add(const QString& catalogue, const QString& repository) | ||||
r54 | { | |||
r55 | if(!contains(_currentRepos, repository)) { add(repository); } | |||
r54 | auto new_catalogue = make_catalogue_ptr(); | |||
new_catalogue->name = catalogue.toStdString(); | ||||
r55 | _currentRepos[repository].add(new_catalogue); | |||
emit catalogueAdded(new_catalogue, repository); | ||||
return new_catalogue; | ||||
} | ||||
void CatalogueController::add(CatalogueController::Event_ptr event, | ||||
CatalogueController::Catalogue_ptr catalogue) | ||||
{ | ||||
catalogue->add(event); | ||||
emit this->catalogueChanged(catalogue); | ||||
r54 | } | |||
void CatalogueController::add(CatalogueController::Event_ptr event, | ||||
const QString& repository) | ||||
{} | ||||
r53 | // void CatalogueController::saveDB(const QString& destinationPath, const | |||
// QString& repositoryName) | ||||
//{ | ||||
// if (!impl->m_CatalogueDao.saveDB(destinationPath, repositoryName)) | ||||
// { | ||||
// qCCritical(LOG_CatalogueController()) | ||||
// << tr("Impossible to saveDB %1 from %2 ").arg(repositoryName, | ||||
// 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_KeysWithChanges.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 workPred = impl->createFinder(event->getUniqId(), | ||||
// event->getRepository(), DBType::WORK); | ||||
// auto workEvent = impl->m_CatalogueDao.getEvent(workPred); | ||||
// *event = workEvent; | ||||
// auto uniqueId = impl->eventUniqueKey(event); | ||||
// impl->m_KeysWithChanges.insert(uniqueId); | ||||
//} | ||||
// void CatalogueController::saveEvent(std::shared_ptr<DBEvent> event) | ||||
//{ | ||||
// impl->saveEvent(event, true); | ||||
// impl->m_KeysWithChanges.remove(impl->eventUniqueKey(event)); | ||||
//} | ||||
// void CatalogueController::discardEvent(std::shared_ptr<DBEvent> event, bool& | ||||
// removed) | ||||
//{ | ||||
// 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()) | ||||
// { | ||||
// removed = false; | ||||
// impl->m_CatalogueDao.copyEvent( | ||||
// syncEvent, impl->toWorkRepository(event->getRepository()), true); | ||||
// auto workEvent = impl->m_CatalogueDao.getEvent(workPred); | ||||
// *event = workEvent; | ||||
// impl->m_KeysWithChanges.remove(impl->eventUniqueKey(event)); | ||||
// } | ||||
// else | ||||
// { | ||||
// removed = true; | ||||
// // Since the element wasn't in sync repository. Discard it means | ||||
// remove it | ||||
// event->setRepository(impl->toWorkRepository(event->getRepository())); | ||||
// impl->m_CatalogueDao.removeEvent(*event); | ||||
// } | ||||
//} | ||||
// bool CatalogueController::eventHasChanges(std::shared_ptr<DBEvent> event) | ||||
// const | ||||
//{ | ||||
// return impl->m_KeysWithChanges.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::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->catalogueUniqueKey(catalogue); | ||||
// impl->m_KeysWithChanges.insert(uniqueId); | ||||
//} | ||||
// void CatalogueController::updateCatalogue(std::shared_ptr<DBCatalogue> | ||||
// catalogue) | ||||
//{ | ||||
// catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository())); | ||||
// auto uniqueId = impl->catalogueUniqueKey(catalogue); | ||||
// impl->m_KeysWithChanges.insert(uniqueId); | ||||
// 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); | ||||
// impl->savAllDB(); | ||||
//} | ||||
// void CatalogueController::saveCatalogue(std::shared_ptr<DBCatalogue> | ||||
// catalogue) | ||||
//{ | ||||
// impl->saveCatalogue(catalogue, true); | ||||
// impl->m_KeysWithChanges.remove(impl->catalogueUniqueKey(catalogue)); | ||||
// // remove key of events of the catalogue | ||||
// if (catalogue->getType() == CatalogueType::STATIC) | ||||
// { | ||||
// auto events = this->retrieveEventsFromCatalogue(catalogue); | ||||
// for (auto event : events) | ||||
// { | ||||
// impl->m_KeysWithChanges.remove(impl->eventUniqueKey(event)); | ||||
// } | ||||
// } | ||||
//} | ||||
// void CatalogueController::discardCatalogue(std::shared_ptr<DBCatalogue> | ||||
// catalogue, bool& removed) | ||||
//{ | ||||
// auto syncPred | ||||
// = impl->createFinder(catalogue->getUniqId(), | ||||
// catalogue->getRepository(), DBType::SYNC); | ||||
// auto workPred | ||||
// = impl->createFinder(catalogue->getUniqId(), | ||||
// catalogue->getRepository(), DBType::WORK); | ||||
// auto syncCatalogue = impl->m_CatalogueDao.getCatalogue(syncPred); | ||||
// if (!syncCatalogue.getUniqId().isNull()) | ||||
// { | ||||
// removed = false; | ||||
// impl->m_CatalogueDao.copyCatalogue( | ||||
// syncCatalogue, impl->toWorkRepository(catalogue->getRepository()), | ||||
// true); | ||||
// auto workCatalogue = impl->m_CatalogueDao.getCatalogue(workPred); | ||||
// *catalogue = workCatalogue; | ||||
// impl->m_KeysWithChanges.remove(impl->catalogueUniqueKey(catalogue)); | ||||
// } | ||||
// else | ||||
// { | ||||
// removed = true; | ||||
// // Since the element wasn't in sync repository. Discard it means | ||||
// remove it | ||||
// catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository())); | ||||
// impl->m_CatalogueDao.removeCatalogue(*catalogue); | ||||
// } | ||||
//} | ||||
// 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_KeysWithChanges.clear(); | ||||
//} | ||||
// bool CatalogueController::hasChanges() const | ||||
//{ | ||||
// return !impl->m_KeysWithChanges.isEmpty(); | ||||
//} | ||||
// 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; | ||||
//} | ||||
// QByteArray CatalogueController::mimeDataForCatalogues( | ||||
// const QVector<std::shared_ptr<DBCatalogue>>& catalogues) const | ||||
//{ | ||||
// auto encodedData = QByteArray {}; | ||||
// QMap<QString, QVariantList> idsPerRepository; | ||||
// for (auto catalogue : catalogues) | ||||
// { | ||||
// idsPerRepository[catalogue->getRepository()] << | ||||
// catalogue->getUniqId(); | ||||
// } | ||||
// QDataStream stream { &encodedData, QIODevice::WriteOnly }; | ||||
// stream << idsPerRepository; | ||||
// return encodedData; | ||||
//} | ||||
// QVector<std::shared_ptr<DBCatalogue>> | ||||
// CatalogueController::cataloguesForMimeData( | ||||
// const QByteArray& mimeData) const | ||||
//{ | ||||
// auto catalogues = QVector<std::shared_ptr<DBCatalogue>> {}; | ||||
// QDataStream stream { mimeData }; | ||||
// QMap<QString, QVariantList> idsPerRepository; | ||||
// stream >> idsPerRepository; | ||||
// for (auto it = idsPerRepository.cbegin(); it != idsPerRepository.cend(); | ||||
// ++it) | ||||
// { | ||||
// auto repository = it.key(); | ||||
// auto allRepositoryCatalogues = retrieveCatalogues(repository); | ||||
// for (auto uuid : it.value()) | ||||
// { | ||||
// for (auto repositoryCatalogues : allRepositoryCatalogues) | ||||
// { | ||||
// if (uuid.toUuid() == repositoryCatalogues->getUniqId()) | ||||
// { | ||||
// catalogues << repositoryCatalogues; | ||||
// } | ||||
// } | ||||
// } | ||||
// } | ||||
// return catalogues; | ||||
//} | ||||
// 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()); | ||||
//} | ||||
// QString CatalogueController::CatalogueControllerPrivate::catalogueUniqueKey( | ||||
// const std::shared_ptr<DBCatalogue>& catalogue) const | ||||
//{ | ||||
// return | ||||
// catalogue->getUniqId().toString().append(catalogue->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(); | ||||
// } | ||||
//} | ||||
// 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; | ||||
//} | ||||