1 #include "otsdaq/CoreSupervisors/ConfigurationSupervisorBase.h"
3 #include "otsdaq/TablePlugins/DesktopIconTable.h"
4 #include "otsdaq/TablePlugins/XDAQContextTable.h"
10 void ConfigurationSupervisorBase::getConfigurationStatusXML(
13 std::map<std::string , std::pair<std::string ,
TableGroupKey>>
14 activeGroupMap = cfgMgr->getActiveTableGroups();
16 for(
auto& type : activeGroupMap)
18 xmlOut.addTextElementToData(type.first +
"-ActiveGroupName", type.second.first);
19 xmlOut.addTextElementToData(type.first +
"-ActiveGroupKey",
20 type.second.second.toString());
26 xmlOut.addTextElementToData(
28 ConfigurationInterface::isVersionTrackingEnabled() ?
"ON" :
"OFF");
40 void ConfigurationSupervisorBase::handleCreateTableXML(
HttpXmlDocument& xmlOut,
42 const std::string& tableName,
45 const std::string& data,
46 const int& dataOffset,
47 const std::string& author,
48 const std::string& comment,
50 bool lookForEquivalent)
try
59 if(!version.isInvalid())
64 cfgMgr->getVersionedTableByName(tableName, version);
73 TableBase* table = cfgMgr->getTableByName(tableName);
77 if(!version.isInvalid())
81 if(table->getViewP()->getDataColumnSize() !=
82 table->getMockupViewP()->getNumberOfColumns() ||
83 table->getViewP()->getSourceColumnMismatch() != 0)
85 __COUT__ <<
"table->getViewP()->getNumberOfColumns() "
86 << table->getViewP()->getNumberOfColumns() << __E__;
87 __COUT__ <<
"table->getMockupViewP()->getNumberOfColumns() "
88 << table->getMockupViewP()->getNumberOfColumns() << __E__;
89 __COUT__ <<
"table->getViewP()->getSourceColumnMismatch() "
90 << table->getViewP()->getSourceColumnMismatch() << __E__;
92 <<
"Source view v" << version
93 <<
" has a mismatch in the number of columns, so using mockup as source."
100 TableVersion temporaryVersion = table->createTemporaryView(version);
102 __COUT__ <<
"\t\ttemporaryVersion: " << temporaryVersion << __E__;
104 TableView* cfgView = table->getTemporaryView(temporaryVersion);
110 retVal = sourceTableAsIs ? 0 : cfgView->fillFromCSV(data, dataOffset, author);
114 __COUT__ <<
"Data was the same, but columns have changed!" << __E__;
115 __COUTV__(sourceTableAsIs);
116 __COUTV__(lookForEquivalent);
119 cfgView->setURIEncodedComment(comment);
120 __COUT__ <<
"Table comment was set to:\n\t" << cfgView->getComment() << __E__;
124 __COUT__ <<
"Caught error while editing. Erasing temporary version." << __E__;
125 table->eraseView(temporaryVersion);
135 if(retVal < 0 && (!version.isTemporaryVersion() || makeTemporary) &&
136 ConfigurationInterface::isVersionTrackingEnabled())
138 if(!version.isInvalid() &&
140 !version.isScratchVersion())
143 __SS__ <<
"No rows were modified! No reason to fill a view with same content."
145 __COUT_ERR__ <<
"\n" << ss.str();
147 table->eraseView(temporaryVersion);
150 else if(version.isInvalid())
151 __COUT__ <<
"This was interpreted as an attempt to create a blank table."
153 else if(version.isScratchVersion())
154 __COUT__ <<
"This was interpreted as an attempt to make a persistent "
155 "version of the scratch table."
160 __THROW__(ss.str() +
"impossible!");
163 else if(retVal < 0 && (version.isTemporaryVersion() && !makeTemporary))
165 __COUT__ <<
"Allowing the static data because this is converting from "
166 "temporary to persistent version."
169 else if(retVal < 0 && !ConfigurationInterface::isVersionTrackingEnabled())
171 __COUT__ <<
"Allowing the static data because version tracking is OFF." << __E__;
175 __SS__ <<
"This should not be possible! Fatal error." << __E__;
177 table->eraseView(temporaryVersion);
182 ConfigurationSupervisorBase::saveModifiedVersionXML(
191 lookForEquivalent || sourceTableAsIs );
193 catch(std::runtime_error& e)
195 __COUT__ <<
"Error detected!\n\n " << e.what() << __E__;
196 xmlOut.addTextElementToData(
"Error",
197 "Error saving new view!\n " + std::string(e.what()));
201 __COUT__ <<
"Error detected!\n\n " << __E__;
202 xmlOut.addTextElementToData(
"Error",
"Error saving new view! ");
210 TableVersion ConfigurationSupervisorBase::saveModifiedVersionXML(
213 const std::string& tableName,
218 bool ignoreDuplicates,
219 bool lookForEquivalent)
221 bool needToEraseTemporarySource =
222 (originalVersion.isTemporaryVersion() && !makeTemporary);
225 if(!ignoreDuplicates)
227 __COUT__ <<
"Checking for duplicate tables..." << __E__;
236 const std::map<std::string, TableInfo>& allTableInfo =
237 cfgMgr->getAllTableInfo();
239 auto versionReverseIterator =
240 allTableInfo.at(tableName).versions_.rbegin();
241 __COUT__ <<
"Filling up cached from " << table->getNumberOfStoredViews()
242 <<
" to max count of " << table->MAX_VIEWS_IN_CACHE << __E__;
243 for(; table->getNumberOfStoredViews() < table->MAX_VIEWS_IN_CACHE &&
244 versionReverseIterator != allTableInfo.at(tableName).versions_.rend();
245 ++versionReverseIterator)
247 __COUT__ <<
"Versions in reverse order " << *versionReverseIterator
251 cfgMgr->getVersionedTableByName(
252 tableName, *versionReverseIterator);
254 catch(
const std::runtime_error& e)
256 __COUT__ <<
"Error loadiing historical version, but ignoring: "
257 << e.what() << __E__;
262 __COUT__ <<
"Checking duplicate..." << __E__;
264 duplicateVersion = table->checkForDuplicate(
265 temporaryModifiedVersion,
266 (!originalVersion.isTemporaryVersion() && !makeTemporary)
272 if(lookForEquivalent && !duplicateVersion.isInvalid())
275 __COUT__ <<
"Equivalent table found in version v" << duplicateVersion
279 if(duplicateVersion.isTemporaryVersion() && !makeTemporary)
281 __COUT__ <<
"Need persistent. Duplicate version was temporary. "
282 "Abandoning duplicate."
291 cfgMgr->eraseTemporaryVersion(tableName, temporaryModifiedVersion);
294 if(needToEraseTemporarySource)
295 cfgMgr->eraseTemporaryVersion(tableName, originalVersion);
297 xmlOut.addTextElementToData(
"savedName", tableName);
298 xmlOut.addTextElementToData(
"savedVersion", duplicateVersion.toString());
299 xmlOut.addTextElementToData(
"foundEquivalentVersion",
"1");
300 xmlOut.addTextElementToData(tableName +
"_foundEquivalentVersion",
"1");
302 __COUT__ <<
"\t\t equivalent AssignedVersion: " << duplicateVersion
305 return duplicateVersion;
309 if(!duplicateVersion.isInvalid())
311 __SS__ <<
"This version of table '" << tableName
312 <<
"' is identical to another version currently cached v"
313 << duplicateVersion <<
". No reason to save a duplicate." << __E__;
314 __COUT_ERR__ <<
"\n" << ss.str();
317 table->eraseView(temporaryModifiedVersion);
321 __COUT__ <<
"Check for duplicate tables complete." << __E__;
325 __COUT__ <<
"\t\t**************************** Save as temporary table version"
328 __COUT__ <<
"\t\t**************************** Save as new table version" << __E__;
331 cfgMgr->saveNewTable(tableName, temporaryModifiedVersion, makeTemporary);
333 if(needToEraseTemporarySource)
334 cfgMgr->eraseTemporaryVersion(tableName, originalVersion);
336 xmlOut.addTextElementToData(
"savedName", tableName);
337 xmlOut.addTextElementToData(
"savedVersion", newAssignedVersion.toString());
339 __COUT__ <<
"\t\t newAssignedVersion: " << newAssignedVersion << __E__;
340 return newAssignedVersion;
362 void ConfigurationSupervisorBase::handleCreateTableGroupXML(
365 const std::string& groupName,
366 const std::string& tableList,
367 bool allowDuplicates,
369 const std::string& groupComment,
370 bool lookForEquivalent)
try
372 __COUT__ <<
"handleCreateTableGroupXML \n";
374 xmlOut.addTextElementToData(
"AttemptedNewGroupName", groupName);
378 const std::map<std::string, TableInfo>& allTableInfo = cfgMgr->getAllTableInfo(
true);
379 cfgMgr->loadConfigurationBackbone();
381 std::map<std::string ,
383 versionAliases = cfgMgr->getVersionAliases();
390 std::map<std::string , std::string > groupAliases;
392 std::string name, versionStr, alias;
394 auto c = tableList.find(
',', 0);
397 while(c < tableList.length())
400 name = tableList.substr(i, c - i);
402 c = tableList.find(
',', i);
403 if(c == std::string::npos)
405 __SS__ <<
"Incomplete Table Name-Version pair!" << __E__;
406 __COUT_ERR__ <<
"\n" << ss.str();
407 xmlOut.addTextElementToData(
"Error", ss.str());
411 versionStr = tableList.substr(i, c - i);
413 c = tableList.find(
',', i);
419 if(versionStr.find(ConfigurationManager::ALIAS_VERSION_PREAMBLE) == 0)
422 versionStr.substr(ConfigurationManager::ALIAS_VERSION_PREAMBLE.size());
424 __COUT__ <<
"Found alias " << name <<
" " << versionStr << __E__;
427 if(versionAliases.find(name) != versionAliases.end() &&
428 versionAliases[name].find(alias) != versionAliases[name].end())
430 version = versionAliases[name][alias];
431 __COUT__ <<
"version alias '" << alias <<
"'translated to: " << version
434 groupAliases[name] = alias;
438 __SS__ <<
"version alias '"
439 << versionStr.substr(
440 ConfigurationManager::ALIAS_VERSION_PREAMBLE.size())
441 <<
"' was not found in active version aliases!" << __E__;
442 __COUT_ERR__ <<
"\n" << ss.str();
443 xmlOut.addTextElementToData(
"Error", ss.str());
450 if(version.isTemporaryVersion())
452 __SS__ <<
"Groups can not be created using temporary member tables. "
453 <<
"Table member '" << name <<
"' with temporary version '" << version
454 <<
"' is illegal." << __E__;
455 xmlOut.addTextElementToData(
"Error", ss.str());
460 if(allTableInfo.find(name) == allTableInfo.end())
462 __SS__ <<
"Groups can not be created using mock-up member tables of "
464 <<
"Table member '" << name <<
"' is not defined." << __E__;
465 xmlOut.addTextElementToData(
"Error", ss.str());
469 if(version.isMockupVersion())
472 TableBase* table = cfgMgr->getTableByName(name);
474 TableVersion temporaryVersion = table->createTemporaryView();
475 __COUT__ <<
"\t\ttemporaryVersion: " << temporaryVersion << __E__;
478 __COUT__ <<
"Creating version from mock-up for name: " << name
479 <<
" inputVersionStr: " << versionStr << __E__;
482 table->getTemporaryView(temporaryVersion)
483 ->setComment(
"Auto-generated from mock-up.");
486 version = ConfigurationSupervisorBase::saveModifiedVersionXML(
497 __COUT__ <<
"Using mockup version: " << version << __E__;
501 groupMembers[name] = version;
504 __COUTV__(StringMacros::mapToString(groupAliases));
508 __COUT__ <<
"Checking for duplicate groups..." << __E__;
510 cfgMgr->findTableGroup(groupName, groupMembers, groupAliases);
512 if(!foundKey.isInvalid())
515 xmlOut.addTextElementToData(
"TableGroupName", groupName);
516 xmlOut.addTextElementToData(
"TableGroupKey", foundKey.toString());
518 if(lookForEquivalent)
520 __COUT__ <<
"Found equivalent group key (" << foundKey <<
") for "
521 << groupName <<
"." << __E__;
523 xmlOut.addTextElementToData(
"foundEquivalentKey",
"1");
526 handleGetTableGroupXML(
527 xmlOut, cfgMgr, groupName, foundKey, ignoreWarnings);
532 __COUT__ <<
"Treating duplicate group as error." << __E__;
533 __SS__ << (
"Failed to create table group: " + groupName +
534 ". It is a duplicate of an existing group key (" +
535 foundKey.toString() +
")");
536 __COUT_ERR__ << ss.str() << __E__;
537 xmlOut.addTextElementToData(
"Error", ss.str());
542 __COUT__ <<
"Check for duplicate groups complete." << __E__;
548 cfgMgr->loadMemberMap(groupMembers);
550 std::string accumulateErrors =
"";
551 for(
auto& groupMemberPair : groupMembers)
554 cfgMgr->getTableByName(groupMemberPair.first)->getViewP();
555 if(cfgViewPtr->getDataColumnSize() != cfgViewPtr->getNumberOfColumns() ||
556 cfgViewPtr->getSourceColumnMismatch() !=
559 __SS__ <<
"\n\nThere were errors found in loading a member table "
560 << groupMemberPair.first <<
":v" << cfgViewPtr->getVersion()
561 <<
". Please see the details below:\n\n"
562 <<
"The source column size was found to be "
563 << cfgViewPtr->getDataColumnSize()
564 <<
", and the current number of columns for this table is "
565 << cfgViewPtr->getNumberOfColumns()
566 <<
". This resulted in a count of "
567 << cfgViewPtr->getSourceColumnMismatch()
568 <<
" source column mismatches, and a count of "
569 << cfgViewPtr->getSourceColumnMissing()
570 <<
" table entries missing in " << cfgViewPtr->getNumberOfRows()
571 <<
" row(s) of data." << __E__;
573 const std::set<std::string> srcColNames =
574 cfgViewPtr->getSourceColumnNames();
575 ss <<
"\n\nSource column names were as follows:\n";
577 for(
auto& srcColName : srcColNames)
578 ss <<
"\n\t" << index++ <<
". " << srcColName;
581 std::set<std::string> destColNames = cfgViewPtr->getColumnStorageNames();
582 ss <<
"\n\nCurrent table column names are as follows:\n";
584 for(
auto& destColName : destColNames)
585 ss <<
"\n\t" << index++ <<
". " << destColName;
588 __COUT_ERR__ <<
"\n" << ss.str();
589 xmlOut.addTextElementToData(
"Error", ss.str());
594 catch(std::runtime_error& e)
596 __SS__ <<
"Failed to create table group: " << groupName
597 <<
".\nThere were problems loading the chosen members:\n\n"
598 << e.what() << __E__;
599 __COUT_ERR__ <<
"\n" << ss.str();
600 xmlOut.addTextElementToData(
"Error", ss.str());
605 __SS__ <<
"Failed to create table group: " << groupName << __E__;
606 __COUT_ERR__ <<
"\n" << ss.str();
607 xmlOut.addTextElementToData(
"Error", ss.str());
612 std::string accumulateTreeErrs;
613 cfgMgr->getChildren(&groupMembers, &accumulateTreeErrs);
614 if(accumulateTreeErrs !=
"")
616 __COUT_WARN__ <<
"\n" << accumulateTreeErrs << __E__;
619 xmlOut.addTextElementToData(
"TreeErrors", accumulateTreeErrs);
627 __COUT__ <<
"Saving new group..." << __E__;
628 newKey = cfgMgr->saveNewTableGroup(
629 groupName, groupMembers, groupComment, &groupAliases);
631 catch(std::runtime_error& e)
633 __COUT_ERR__ <<
"Failed to create table group: " << groupName << __E__;
634 __COUT_ERR__ <<
"\n\n" << e.what() << __E__;
635 xmlOut.addTextElementToData(
636 "Error",
"Failed to create table group: " + groupName +
".\n\n" + e.what());
641 __COUT_ERR__ <<
"Failed to create table group: " << groupName << __E__;
642 xmlOut.addTextElementToData(
"Error",
643 "Failed to create table group: " + groupName);
648 __COUT__ <<
"Loading new table group..." << __E__;
649 handleGetTableGroupXML(xmlOut, cfgMgr, groupName, newKey, ignoreWarnings);
652 catch(std::runtime_error& e)
654 __COUT__ <<
"Error detected!\n\n " << e.what() << __E__;
655 xmlOut.addTextElementToData(
"Error",
656 "Error saving table group! " + std::string(e.what()));
660 __COUT__ <<
"Unknown Error detected!\n\n " << __E__;
661 xmlOut.addTextElementToData(
"Error",
"Error saving table group! ");
687 void ConfigurationSupervisorBase::handleGetTableGroupXML(
HttpXmlDocument& xmlOut,
689 const std::string& groupName,
691 bool ignoreWarnings)
try
694 xercesc::DOMElement *parentEl, *configEl;
717 const GroupInfo& groupInfo = cfgMgr->getGroupInfo(groupName);
718 const std::set<TableGroupKey>& sortedKeys = groupInfo.keys_;
720 if(groupKey.isInvalid() ||
721 sortedKeys.find(groupKey) == sortedKeys.end())
723 if(sortedKeys.size())
724 groupKey = *sortedKeys.rbegin();
725 __COUT__ <<
"Group key requested was invalid or not found, going with latest "
726 << groupKey << __E__;
729 xmlOut.addTextElementToData(
"TableGroupName", groupName);
730 xmlOut.addTextElementToData(
"TableGroupKey", groupKey.toString());
733 for(
auto& keyInOrder : sortedKeys)
734 xmlOut.addTextElementToData(
"HistoricalTableGroupKey", keyInOrder.toString());
736 parentEl = xmlOut.addTextElementToData(
"TableGroupMembers",
"");
740 std::map<std::string , std::string > groupMemberAliases;
742 __COUT__ <<
"groupName=" << groupName << __E__;
743 __COUT__ <<
"groupKey=" << groupKey << __E__;
745 const std::map<std::string, TableInfo>& allTableInfo = cfgMgr->getAllTableInfo();
746 std::map<std::string, TableInfo>::const_iterator it;
752 std::string groupAuthor, groupComment, groupCreationTime, groupTypeString;
753 std::string accumulateTreeErrors;
755 __COUTV__(ignoreWarnings);
756 cfgMgr->loadTableGroup(groupName,
762 &accumulateTreeErrors,
768 &groupMemberAliases);
770 if(accumulateTreeErrors !=
"")
772 __COUTV__(accumulateTreeErrors);
773 xmlOut.addTextElementToData(
"TreeErrors", accumulateTreeErrors);
776 xmlOut.addTextElementToData(
"TableGroupAuthor", groupAuthor);
777 xmlOut.addTextElementToData(
"TableGroupComment", groupComment);
778 xmlOut.addTextElementToData(
"TableGroupCreationTime", groupCreationTime);
779 xmlOut.addTextElementToData(
"TableGroupType", groupTypeString);
781 catch(
const std::runtime_error& e)
783 __SS__ <<
"Table group \"" + groupName +
"(" + groupKey.toString() +
")" +
784 "\" members can not be loaded!\n\n" + e.what()
786 __COUT_ERR__ << ss.str();
787 xmlOut.addTextElementToData(
"Error", ss.str());
792 __SS__ <<
"Table group \"" + groupName +
"(" + groupKey.toString() +
")" +
793 "\" members can not be loaded!"
795 __COUT_ERR__ << ss.str();
796 xmlOut.addTextElementToData(
"Error", ss.str());
800 __COUTV__(StringMacros::mapToString(groupMemberAliases));
802 std::map<std::string, std::map<std::string, TableVersion>> versionAliases =
803 cfgMgr->getVersionAliases();
805 __COUT__ <<
"# of table version aliases: " << versionAliases.size() << __E__;
808 for(
auto& memberPair : memberMap)
810 xmlOut.addTextElementToParent(
"MemberName", memberPair.first, parentEl);
813 if(groupMemberAliases.find(memberPair.first) != groupMemberAliases.end())
814 configEl = xmlOut.addTextElementToParent(
816 ConfigurationManager::ALIAS_VERSION_PREAMBLE +
817 groupMemberAliases[memberPair.first],
820 configEl = xmlOut.addTextElementToParent(
821 "MemberVersion", memberPair.second.toString(), parentEl);
823 it = allTableInfo.find(memberPair.first);
824 if(it == allTableInfo.end())
826 xmlOut.addTextElementToData(
827 "Error",
"Table \"" + memberPair.first +
"\" can not be retrieved!");
831 if(versionAliases.find(it->first) != versionAliases.end())
832 for(
auto& aliasVersion : versionAliases[it->first])
833 xmlOut.addTextElementToParent(
834 "TableExistingVersion",
835 ConfigurationManager::ALIAS_VERSION_PREAMBLE + aliasVersion.first,
838 for(
auto& version : it->second.versions_)
841 xmlOut.addTextElementToParent(
842 "TableExistingVersion", version.toString(), configEl);
845 for(
auto& memberPair : memberMap)
852 xmlOut.addTextElementToParent(
854 allTableInfo.at(memberPair.first).tablePtr_->getView().getComment(),
891 catch(std::runtime_error& e)
893 __SS__ << (
"Error!\n\n" + std::string(e.what())) << __E__;
894 __COUT_ERR__ <<
"\n" << ss.str();
895 xmlOut.addTextElementToData(
"Error", ss.str());
899 __SS__ << (
"Error!\n\n") << __E__;
900 __COUT_ERR__ <<
"\n" << ss.str();
901 xmlOut.addTextElementToData(
"Error", ss.str());
905 void ConfigurationSupervisorBase::handleAddDesktopIconXML(
908 const std::string& iconCaption,
909 const std::string& iconAltText,
910 const std::string& iconFolderPath,
911 const std::string& iconImageURL,
912 const std::string& iconWindowURL,
913 const std::string& iconPermissions,
914 std::string windowLinkedApp ,
915 unsigned int windowLinkedAppLID ,
916 bool enforceOneWindowInstance ,
917 const std::string& windowParameters )
try
919 cfgMgr->getAllTableInfo(
true );
921 const std::string& author = cfgMgr->getUsername();
924 __COUTV__(iconCaption);
925 __COUTV__(iconAltText);
926 __COUTV__(iconFolderPath);
927 __COUTV__(iconImageURL);
928 __COUTV__(iconWindowURL);
929 __COUTV__(iconPermissions);
930 __COUTV__(windowLinkedApp);
931 __COUTV__(windowLinkedAppLID);
932 __COUTV__(enforceOneWindowInstance);
934 __COUTV__(windowParameters);
946 cfgMgr->restoreActiveTableGroups(
true ,
952 std::map<std::string, TableVersion> contextGroupMembers;
953 std::map<std::string, TableVersion> backboneGroupMembers;
955 std::map<std::string, TableVersion> activeTables = cfgMgr->getActiveVersions();
956 for(
auto& table : cfgMgr->getContextMemberNames())
959 __COUT__ << table <<
" v" << activeTables.at(table) << __E__;
960 contextGroupMembers[table] = activeTables.at(table);
964 __SS__ <<
"Error! Could not find Context member table '" << table
965 <<
".' All Context members must be present to add a desktop icon."
969 for(
auto& table : cfgMgr->getBackboneMemberNames())
972 __COUT__ << table <<
" v" << activeTables.at(table) << __E__;
973 backboneGroupMembers[table] = activeTables.at(table);
977 __SS__ <<
"Error! Could not find Backbone member table '" << table
978 <<
".' All Backbone members must be present to add a desktop icon."
984 const std::string contextGroupName =
985 cfgMgr->getActiveGroupName(ConfigurationManager::ACTIVE_GROUP_NAME_CONTEXT);
987 cfgMgr->getActiveGroupKey(ConfigurationManager::ACTIVE_GROUP_NAME_CONTEXT);
988 const std::string backboneGroupName =
989 cfgMgr->getActiveGroupName(ConfigurationManager::ACTIVE_GROUP_NAME_BACKBONE);
991 cfgMgr->getActiveGroupKey(ConfigurationManager::ACTIVE_GROUP_NAME_BACKBONE);
993 __COUTV__(contextGroupName);
994 __COUTV__(originalContextGroupKey);
995 __COUTV__(backboneGroupName);
996 __COUTV__(originalBackboneGroupKey);
998 if(contextGroupName ==
"" || originalContextGroupKey.isInvalid())
1000 __SS__ <<
"Error! No active Context group found"
1001 "There must be an active Context group to add a Desktop Icon."
1017 TableEditStruct appTable(ConfigurationManager::XDAQ_APPLICATION_TABLE_NAME,
1024 std::string iconUID;
1027 row = iconTable.tableView_->addRow(
1028 author,
true ,
"generatedIcon");
1030 iconTable.tableView_->getDataView()[row][iconTable.tableView_->getColUID()];
1036 iconTable.tableView_->setValueAsString(
1037 "1", row, iconTable.tableView_->getColStatus());
1040 iconTable.tableView_->setURIEncodedValue(
1043 iconTable.tableView_->findCol(DesktopIconTable::COL_CAPTION));
1045 iconTable.tableView_->setURIEncodedValue(
1048 iconTable.tableView_->findCol(DesktopIconTable::COL_ALTERNATE_TEXT));
1050 iconTable.tableView_->setValueAsString(
1051 enforceOneWindowInstance ?
"1" :
"0",
1053 iconTable.tableView_->findCol(DesktopIconTable::COL_FORCE_ONLY_ONE_INSTANCE));
1055 iconTable.tableView_->setURIEncodedValue(
1058 iconTable.tableView_->findCol(DesktopIconTable::COL_PERMISSIONS));
1060 iconTable.tableView_->setURIEncodedValue(
1063 iconTable.tableView_->findCol(DesktopIconTable::COL_IMAGE_URL));
1065 iconTable.tableView_->setURIEncodedValue(
1068 iconTable.tableView_->findCol(DesktopIconTable::COL_WINDOW_CONTENT_URL));
1070 iconTable.tableView_->setURIEncodedValue(
1073 iconTable.tableView_->findCol(DesktopIconTable::COL_FOLDER_PATH));
1076 if(windowLinkedAppLID > 0)
1078 __COUTV__(windowLinkedAppLID);
1080 int appRow = appTable.tableView_->findRow(
1081 appTable.tableView_->findCol(XDAQContextTable::colApplication_.colId_),
1082 windowLinkedAppLID);
1085 ->getDataView()[appRow][appTable.tableView_->getColUID()];
1086 __COUT__ <<
"Found app by LID: " << windowLinkedApp << __E__;
1089 if(windowLinkedApp !=
"" && windowLinkedApp !=
"undefined" &&
1090 windowLinkedApp != TableViewColumnInfo::DATATYPE_STRING_DEFAULT)
1095 __COUTV__(windowLinkedApp);
1097 if(!windowLinkedAppLID)
1101 int appRow = appTable.tableView_->findRow(
1102 appTable.tableView_->getColUID(), windowLinkedApp);
1104 catch(
const std::runtime_error& e)
1109 int appRow = appTable.tableView_->findRow(
1110 appTable.tableView_->findCol(
1111 XDAQContextTable::colApplication_.colClass_),
1115 ->getDataView()[appRow][appTable.tableView_->getColUID()];
1120 __SS__ <<
"Failed to create an icon linking to app '"
1122 <<
".' The following error occurred: " << e.what()
1128 __COUTV__(windowLinkedApp);
1130 iconTable.tableView_->setValueAsString(
1131 ConfigurationManager::XDAQ_APPLICATION_TABLE_NAME,
1133 iconTable.tableView_->findCol(DesktopIconTable::COL_APP_LINK));
1134 iconTable.tableView_->setValueAsString(
1137 iconTable.tableView_->findCol(DesktopIconTable::COL_APP_LINK_UID));
1141 std::map<std::string, std::string> parameters;
1143 __COUTV__(windowParameters);
1144 StringMacros::getMapFromString(windowParameters, parameters);
1147 if(parameters.size())
1150 iconTable.tableView_->setValueAsString(
1151 DesktopIconTable::PARAMETER_TABLE,
1153 iconTable.tableView_->findCol(DesktopIconTable::COL_PARAMETER_LINK));
1155 iconTable.tableView_->setValueAsString(
1156 iconUID +
"_Parameters",
1158 iconTable.tableView_->findCol(DesktopIconTable::COL_PARAMETER_LINK_GID));
1160 __COUTV__(StringMacros::mapToString(parameters));
1162 for(
const auto& parameter : parameters)
1165 row = parameterTable.tableView_->addRow(
1166 author,
true ,
"generatedParameter");
1169 parameterTable.tableView_->setValueAsString(
1170 "1", row, parameterTable.tableView_->getColStatus());
1172 parameterTable.tableView_->setValueAsString(
1173 iconUID +
"_Parameters",
1175 parameterTable.tableView_->findCol(
1176 DesktopIconTable::COL_PARAMETER_GID));
1178 parameterTable.tableView_->setURIEncodedValue(
1181 parameterTable.tableView_->findCol(
1182 DesktopIconTable::COL_PARAMETER_KEY));
1184 parameterTable.tableView_->setURIEncodedValue(
1187 parameterTable.tableView_->findCol(
1188 DesktopIconTable::COL_PARAMETER_VALUE));
1191 std::stringstream ss;
1192 parameterTable.tableView_->print(ss);
1193 __COUT__ << ss.str();
1195 parameterTable.tableView_
1200 std::stringstream ss;
1201 iconTable.tableView_->print(ss);
1202 __COUT__ << ss.str();
1204 iconTable.tableView_->init();
1208 __COUT__ <<
"Icon table errors while saving. Erasing all newly "
1209 "created table versions."
1211 if(iconTable.createdTemporaryVersion_)
1213 __COUT__ <<
"Erasing temporary version " << iconTable.tableName_ <<
"-v"
1214 << iconTable.temporaryVersion_ << __E__;
1216 cfgMgr->eraseTemporaryVersion(iconTable.tableName_,
1217 iconTable.temporaryVersion_);
1220 if(parameterTable.createdTemporaryVersion_)
1222 __COUT__ <<
"Erasing temporary version " << parameterTable.tableName_ <<
"-v"
1223 << parameterTable.temporaryVersion_ << __E__;
1225 cfgMgr->eraseTemporaryVersion(parameterTable.tableName_,
1226 parameterTable.temporaryVersion_);
1229 if(appTable.createdTemporaryVersion_)
1231 __COUT__ <<
"Erasing temporary version " << appTable.tableName_ <<
"-v"
1232 << appTable.temporaryVersion_ << __E__;
1234 cfgMgr->eraseTemporaryVersion(appTable.tableName_,
1235 appTable.temporaryVersion_);
1241 __COUT__ <<
"Edits complete for new desktop icon, now making persistent tables."
1254 __COUT__ <<
"Original version is " << iconTable.tableName_ <<
"-v"
1255 << iconTable.originalVersion_ << __E__;
1256 __COUT__ <<
"Original version is " << parameterTable.tableName_ <<
"-v"
1257 << parameterTable.originalVersion_ << __E__;
1259 contextGroupMembers[DesktopIconTable::ICON_TABLE] =
1260 ConfigurationSupervisorBase::saveModifiedVersionXML(
1263 iconTable.tableName_,
1264 iconTable.originalVersion_,
1267 iconTable.temporaryVersion_,
1269 contextGroupMembers[DesktopIconTable::PARAMETER_TABLE] =
1270 ConfigurationSupervisorBase::saveModifiedVersionXML(
1273 parameterTable.tableName_,
1274 parameterTable.originalVersion_,
1276 parameterTable.table_,
1277 parameterTable.temporaryVersion_,
1280 __COUT__ <<
"Temporary target version is " << iconTable.tableName_ <<
"-v"
1281 << contextGroupMembers[DesktopIconTable::ICON_TABLE] <<
"-v"
1282 << iconTable.temporaryVersion_ << __E__;
1283 __COUT__ <<
"Temporary target version is " << parameterTable.tableName_ <<
"-v"
1284 << contextGroupMembers[DesktopIconTable::PARAMETER_TABLE] <<
"-v"
1285 << parameterTable.temporaryVersion_ << __E__;
1287 contextGroupMembers[DesktopIconTable::ICON_TABLE] =
1288 ConfigurationSupervisorBase::saveModifiedVersionXML(
1291 iconTable.tableName_,
1292 iconTable.originalVersion_,
1295 iconTable.temporaryVersion_,
1298 contextGroupMembers[DesktopIconTable::PARAMETER_TABLE] =
1299 ConfigurationSupervisorBase::saveModifiedVersionXML(
1302 parameterTable.tableName_,
1303 parameterTable.originalVersion_,
1305 parameterTable.table_,
1306 parameterTable.temporaryVersion_,
1310 __COUT__ <<
"Final target version is " << iconTable.tableName_ <<
"-v"
1311 << contextGroupMembers[DesktopIconTable::ICON_TABLE] << __E__;
1312 __COUT__ <<
"Final target version is " << parameterTable.tableName_ <<
"-v"
1313 << contextGroupMembers[DesktopIconTable::PARAMETER_TABLE] << __E__;
1315 for(
auto& table : contextGroupMembers)
1317 __COUT__ << table.first <<
" v" << table.second << __E__;
1320 __COUT__ <<
"Checking for duplicate Context groups..." << __E__;
1322 cfgMgr->findTableGroup(contextGroupName, contextGroupMembers);
1324 if(!newContextKey.isInvalid())
1326 __COUT__ <<
"Found equivalent group key (" << newContextKey <<
") for "
1327 << contextGroupName <<
"." << __E__;
1328 xmlOut.addTextElementToData(contextGroupName +
"_foundEquivalentKey",
1333 newContextKey = cfgMgr->saveNewTableGroup(contextGroupName, contextGroupMembers);
1334 __COUT__ <<
"Saved new Context group key (" << newContextKey <<
") for "
1335 << contextGroupName <<
"." << __E__;
1338 xmlOut.addTextElementToData(
"contextGroupName", contextGroupName);
1339 xmlOut.addTextElementToData(
"contextGroupKey", newContextKey.toString());
1343 __COUT__ <<
"Original version is " << iconTable.tableName_ <<
"-v"
1344 << iconTable.originalVersion_ << __E__;
1345 __COUT__ <<
"Original version is " << parameterTable.tableName_ <<
"-v"
1346 << parameterTable.originalVersion_ << __E__;
1348 bool groupAliasChange =
false;
1349 bool tableAliasChange =
false;
1355 cfgMgr->getTableByName(ConfigurationManager::GROUP_ALIASES_TABLE_NAME);
1357 backboneGroupMembers[ConfigurationManager::GROUP_ALIASES_TABLE_NAME];
1358 TableVersion temporaryVersion = table->createTemporaryView(originalVersion);
1359 TableView* configView = table->getTemporaryView(temporaryVersion);
1362 unsigned int row = 0;
1364 std::vector<std::pair<std::string, ConfigurationTree>> aliasNodePairs =
1365 cfgMgr->getNode(ConfigurationManager::GROUP_ALIASES_TABLE_NAME).getChildren();
1366 std::string groupName, groupKey;
1367 for(
auto& aliasNodePair : aliasNodePairs)
1369 groupName = aliasNodePair.second.getNode(
"GroupName").getValueAsString();
1370 groupKey = aliasNodePair.second.getNode(
"GroupKey").getValueAsString();
1372 __COUT__ <<
"Group Alias: " << aliasNodePair.first <<
" => " << groupName
1373 <<
"(" << groupKey <<
"); row=" << row << __E__;
1375 if(groupName == contextGroupName &&
1378 __COUT__ <<
"Found alias! Changing group key." << __E__;
1380 groupAliasChange =
true;
1382 configView->setValueAsString(
1383 newContextKey.toString(), row, configView->findCol(
"GroupKey"));
1389 if(groupAliasChange)
1391 std::stringstream ss;
1392 configView->print(ss);
1393 __COUT__ << ss.str();
1396 backboneGroupMembers[ConfigurationManager::GROUP_ALIASES_TABLE_NAME] =
1397 ConfigurationSupervisorBase::saveModifiedVersionXML(
1400 table->getTableName(),
1409 <<
"Original version is " << table->getTableName() <<
"-v"
1410 << originalVersion <<
" and new version is v"
1411 << backboneGroupMembers[ConfigurationManager::GROUP_ALIASES_TABLE_NAME]
1420 cfgMgr->getTableByName(ConfigurationManager::VERSION_ALIASES_TABLE_NAME);
1422 backboneGroupMembers[ConfigurationManager::VERSION_ALIASES_TABLE_NAME];
1423 TableVersion temporaryVersion = table->createTemporaryView(originalVersion);
1424 TableView* configView = table->getTemporaryView(temporaryVersion);
1427 unsigned int row = 0;
1429 std::vector<std::pair<std::string, ConfigurationTree>> aliasNodePairs =
1430 cfgMgr->getNode(ConfigurationManager::VERSION_ALIASES_TABLE_NAME)
1432 std::string tableName, tableVersion;
1433 for(
auto& aliasNodePair : aliasNodePairs)
1435 tableName = aliasNodePair.second.getNode(
"TableName").getValueAsString();
1437 aliasNodePair.second.getNode(
"TableVersion").getValueAsString();
1439 __COUT__ <<
"Table Alias: " << aliasNodePair.first <<
" => " << tableName
1440 <<
"-v" << tableVersion <<
"" << __E__;
1442 if(tableName == DesktopIconTable::ICON_TABLE &&
1443 TableVersion(tableVersion) == iconTable.originalVersion_)
1445 __COUT__ <<
"Found alias! Changing icon table version alias." << __E__;
1447 tableAliasChange =
true;
1449 configView->setValueAsString(
1450 contextGroupMembers[DesktopIconTable::ICON_TABLE].toString(),
1452 configView->findCol(
"TableVersion"));
1454 else if(tableName == DesktopIconTable::PARAMETER_TABLE &&
1455 TableVersion(tableVersion) == parameterTable.originalVersion_)
1457 __COUT__ <<
"Found alias! Changing icon parameter table version alias."
1460 tableAliasChange =
true;
1462 configView->setValueAsString(
1463 contextGroupMembers[DesktopIconTable::PARAMETER_TABLE].toString(),
1465 configView->findCol(
"TableVersion"));
1471 if(tableAliasChange)
1473 std::stringstream ss;
1474 configView->print(ss);
1475 __COUT__ << ss.str();
1478 backboneGroupMembers[ConfigurationManager::VERSION_ALIASES_TABLE_NAME] =
1479 ConfigurationSupervisorBase::saveModifiedVersionXML(
1482 table->getTableName(),
1491 <<
"Original version is " << table->getTableName() <<
"-v"
1492 << originalVersion <<
" and new version is v"
1493 << backboneGroupMembers[ConfigurationManager::VERSION_ALIASES_TABLE_NAME]
1500 if(groupAliasChange || tableAliasChange)
1502 for(
auto& table : backboneGroupMembers)
1504 __COUT__ << table.first <<
" v" << table.second << __E__;
1508 __COUT__ <<
"Checking for duplicate Backbone groups..." << __E__;
1510 cfgMgr->findTableGroup(backboneGroupName, backboneGroupMembers);
1512 if(!newBackboneKey.isInvalid())
1514 __COUT__ <<
"Found equivalent group key (" << newBackboneKey <<
") for "
1515 << backboneGroupName <<
"." << __E__;
1516 xmlOut.addTextElementToData(backboneGroupName +
"_foundEquivalentKey",
1522 cfgMgr->saveNewTableGroup(backboneGroupName, backboneGroupMembers);
1523 __COUT__ <<
"Saved new Backbone group key (" << newBackboneKey <<
") for "
1524 << backboneGroupName <<
"." << __E__;
1527 xmlOut.addTextElementToData(
"backboneGroupName", backboneGroupName);
1528 xmlOut.addTextElementToData(
"backboneGroupKey", newBackboneKey.toString());
1531 __COUT__ <<
"Activating Context group key (" << newContextKey <<
") for "
1532 << contextGroupName <<
"." << __E__;
1533 __COUT__ <<
"Activating Backbone group key (" << newBackboneKey <<
") for "
1534 << backboneGroupName <<
"." << __E__;
1538 cfgMgr->restoreActiveTableGroups(
false ,
1544 cfgMgr->activateTableGroup(contextGroupName, newContextKey);
1545 cfgMgr->activateTableGroup(backboneGroupName, newBackboneKey);
1548 ConfigurationSupervisorBase::getConfigurationStatusXML(xmlOut, cfgMgr);
1551 catch(std::runtime_error& e)
1553 __COUT__ <<
"Error detected!\n\n " << e.what() << __E__;
1554 xmlOut.addTextElementToData(
"Error",
1555 "Error adding Desktop Icon! " + std::string(e.what()));
1559 __COUT__ <<
"Unknown Error detected!\n\n " << __E__;
1560 xmlOut.addTextElementToData(
"Error",
"Error adding Desktop Icon! ");