";
str += "Table: ";
str += "";
}
@@ -10274,7 +10454,8 @@
((el.offsetWidth > 150 ? el.offsetWidth : 150) - 6) + "px; height:" + (el.offsetHeight - 8) + "px' value='";
str += encodeHTML(_editingCellElOldValue); //replace single quotes since within html
str += "' onmousedown='_mouseIsSelecting = true; Debug.log(_mouseIsSelecting);' " +
- "onmouseup='_mouseIsSelecting = false; Debug.log(_mouseIsSelecting);' " +
+ "onmouseup='_mouseIsSelecting = false; Debug.log(_mouseIsSelecting); event.stopPropagation();' " +
+ "onclick='event.stopPropagation();' " +
">";
}
@@ -10533,6 +10714,7 @@
for (var i = selectedRows.length - 1; i >= 0; i--) {
let rowIndex = Number(selectedRows[i].cells[0].textContent.trim().match(/\d+/)[0]);
tableCopyOrMoveRow(0, rowIndex, true);
+ registerOnClickActions(); //re-register onclick actions after copy since table is redrawn
}
} //end copyAndPasteBlockRows()
@@ -10549,6 +10731,7 @@
if (!deleteBtn) return null;
deleteBtn.onclick();
Debug.log("Successfully deleted row" + rowIndex);
+ registerOnClickActions(); //re-register onclick actions after deletion since table is redrawn
}
catch
{
@@ -15832,6 +16015,109 @@
el.style.display = "block";
} //end popUpClearVersionsPrompt()
+ //==============================================================================
+ //popUpSearchFieldPrompt
+ function popUpSearchFieldPrompt(tableName) {
+ console.log("CfgGUI popUpSearchFieldPrompt");
+ console.log("TableName " + tableName);
+
+ var el = document.getElementById("searchTextInAllTableVersions");
+ var searchText = el ? el.value : "";
+ Debug.log("Search field value: " + searchText);
+
+ var el = document.getElementById("activeOnlyFilter");
+ var activeOnlyFilter = el.checked;
+ console.log("activeOnlyFilter " + activeOnlyFilter);
+
+ var el = document.getElementById("searchMinThreshold");
+ var searchMinThreshold = el ? el.value : 1;
+ Debug.log("Search field value: " + searchMinThreshold);
+
+ var el = document.getElementById("searchVersionToCheck");
+ var searchVersionToCheck = el ? el.value : "";
+ Debug.log("Search field value: " + searchVersionToCheck);
+
+ DesktopContent.XMLHttpRequest("Request?RequestType=SearchFieldInTableVersions" +
+ "&searchText=" + searchText +
+ "&tableName=" + tableName +
+ "&searchVersionToCheck=" + searchVersionToCheck +
+ "&activeOnly=" + activeOnlyFilter,
+ "",
+ function(req){
+ var req = arguments[0];
+ var errStr = arguments[2];
+ if (errStr) {
+ Debug.err(errStr);
+ return;
+ }
+
+ var results = req.responseXML.getElementsByTagName("Match");
+ if(results.length == 0)
+ {
+ Debug.info(DesktopContent.tooltipConditionString("Search Results For: " + searchText + " " + column + " , Count: " + count + " " +
+ "Table " + tableName + "-v" + prevVersion + " " + column + " , Count: " + count + " " +
+ "Table " + tableName + "-v" + prevVersion + " " + searchText + " optionGroupsList =
+ StringMacros::getVectorFromString(optionGroups, {','});
+
+ const std::map& allGroupInfo = cfgMgr->getAllGroupInfo();
+
+ int searchMinThreshold = 0;
+ int searchMaxThreshold = 0;
+ size_t dashPos = -1;
+
+ // Parse versionsToCheck for version range
+ if(versionsToCheck.empty())
+ {
+ searchMaxThreshold = INT_MAX;
+ }
+ else if(versionsToCheck.find('-') != std::string::npos)
+ {
+ __COUT__ << "Parsing versionsToCheck for range: " << versionsToCheck << __E__;
+ dashPos = versionsToCheck.find('-');
+
+ if(dashPos != 0)
+ {
+ // Format: "N-M" means version N to version M
+ std::string minStr = versionsToCheck.substr(0, dashPos);
+ std::string maxStr = versionsToCheck.substr(dashPos + 1);
+
+ searchMinThreshold = atoi(minStr.c_str());
+ searchMaxThreshold = atoi(maxStr.c_str());
+ }
+ }
+ else if(versionsToCheck != "")
+ {
+ // Single version specified
+ searchMinThreshold = atoi(versionsToCheck.c_str());
+ searchMaxThreshold = INT_MAX; // effectively no upper limit
+ }
+ else
+ {
+ __COUT__ << "Unable to set min and max thresholds for versionsToCheck: "
+ << versionsToCheck << __E__;
+ xmlOut.addTextElementToData(
+ "Error",
+ "Unable to set min and max thresholds for versionsToCheck: " +
+ versionsToCheck);
+ }
+ __SUP_COUT__ << "versionsToCheck range: " << searchMinThreshold << " to "
+ << searchMaxThreshold << __E__;
+
+ auto parentEl = xmlOut.addTextElementToData("SearchResults", "");
+
+ for(auto& groupInfo : allGroupInfo)
+ {
+ __COUT__ << "Checking group: " << groupInfo.first
+ << " group type : " << groupInfo.second.getLatestKeyGroupTypeString()
+ << __E__;
+
+ if(groupInfo.second.getLatestKeyGroupTypeString() != groupType)
+ continue;
+
+ // Check if groupInfo.first is in optionGroups
+ if(!searchAllGroups &&
+ std::find(optionGroupsList.begin(), optionGroupsList.end(), groupInfo.first) ==
+ optionGroupsList.end())
+ {
+ __COUT__ << "\tSkipping group not in optionGroups list." << __E__;
+ continue; // skip this group
+ }
+
+ std::set groupKeysVec(allGroupKeys.begin(), allGroupKeys.end());
+ // convert vector to string for output
+ std::string groupKeysStr = StringMacros::vectorToString(groupKeysVec, {','});
+ __COUT__ << "Group keys:" << groupKeysStr << __E__;
+
+ // Dash is first position: "-N" means (maxVersion - N) to maxVersion
+ if(dashPos == 0)
+ {
+ std::string offsetStr = versionsToCheck.substr(1);
+ int offset =
+ atoi(offsetStr.c_str()) - 1; // -1 to include the max version itself
+
+ __SUP_COUT__ << "versionsToCheck offset from end: " << offset << __E__;
+
+ // Find the max version from this group
+ if(groupKeysVec.size() > 0)
+ {
+ TableGroupKey maxVersion = groupKeysVec.at(
+ groupKeysVec.size() - 1); // get the last (max) version
+ int maxVersionNum = std::stoi(maxVersion.toString());
+ int minVersionNum = std::max(0, maxVersionNum - offset);
+
+ searchMinThreshold = minVersionNum;
+ searchMaxThreshold = maxVersionNum;
+
+ __SUP_COUT__ << "Version range: " << searchMinThreshold << " to "
+ << searchMaxThreshold << __E__;
+ }
+ }
+
+ std::set singleKeySet;
+ singleKeySet.insert(groupInfo.second.getLatestKey());
+ groupKeys = std::move(singleKeySet);
+ }
+ else
+ groupKeys = std::move(allGroupKeys);
+
+ for(const auto& groupKey : groupKeys)
+ {
+ __COUT__ << "\tProcessing group: " << groupInfo.first << " v" << groupKey
+ << __E__;
+
+ if(!activeGroupsOnly &&
+ (std::stoi(groupKey.toString()) < searchMinThreshold ||
+ std::stoi(groupKey.toString()) > searchMaxThreshold))
+ {
+ __COUT__ << "\tSkipping group version outside of versionsToCheck range."
+ << __E__;
+ continue; // skip this group version
+ }
+
+ // Get the member map for this group
+ std::map& allTableInfo = cfgMgr->getAllTableInfo();
+ std::map allActivePairs = cfgMgr->getActiveVersions();
+
+ int searchMinThreshold = 0;
+ int searchMaxThreshold = 0;
+
+ // Parse searchVersionToCheck for version range
+ if(searchVersionToCheck.empty())
+ {
+ searchMaxThreshold = INT_MAX;
+ }
+ else if(searchVersionToCheck.find('-') != std::string::npos)
+ {
+ size_t dashPos = searchVersionToCheck.find('-');
+
+ if(dashPos == 0)
+ {
+ // Dash is first position: "-N" means (maxVersion - N) to maxVersion
+ std::string offsetStr = searchVersionToCheck.substr(1);
+ int offset =
+ atoi(offsetStr.c_str()) - 1; // -1 to include the max version itself
+
+ __SUP_COUT__ << "searchVersionToCheck offset from end: " << offset << __E__;
+
+ // Find the max version from allTableInfo
+ if(allTableInfo.find(tableName) != allTableInfo.end())
+ {
+ const TableInfo& tableInfo = allTableInfo.at(tableName);
+ if(tableInfo.versions_.size() > 0)
+ {
+ auto maxVersionIter = tableInfo.versions_.rbegin();
+ int maxVersionNum = maxVersionIter->version();
+ int minVersionNum = std::max(0, maxVersionNum - offset);
+
+ searchMinThreshold = minVersionNum;
+ searchMaxThreshold = maxVersionNum;
+
+ __SUP_COUT__ << "Version range: " << searchMinThreshold << " to "
+ << searchMaxThreshold << __E__;
+ }
+ }
+ }
+ else
+ {
+ // Format: "N-M" means version N to version M
+ std::string minStr = searchVersionToCheck.substr(0, dashPos);
+ std::string maxStr = searchVersionToCheck.substr(dashPos + 1);
+
+ searchMinThreshold = atoi(minStr.c_str());
+ searchMaxThreshold = atoi(maxStr.c_str());
+ }
+ }
+ else if(searchVersionToCheck != "")
+ {
+ // Single version specified
+ searchMinThreshold = atoi(searchVersionToCheck.c_str());
+ searchMaxThreshold = INT_MAX; // effectively no upper limit
+ }
+ else
+ {
+ __COUT__ << "Unable to set min and max thresholds for searchVersionToCheck: "
+ << searchVersionToCheck << __E__;
+ xmlOut.addTextElementToData(
+ "Error",
+ "Unable to set min and max thresholds for searchVersionToCheck: " +
+ searchVersionToCheck);
+ }
+ __SUP_COUT__ << "searchVersionToCheck range: " << searchMinThreshold << " to "
+ << searchMaxThreshold << __E__;
+
+ try
+ {
+ if(allTableInfo.find(tableName) == allTableInfo.end())
+ {
+ __SUP_SS__ << "Table '" << tableName << "' not found." << __E__;
+ xmlOut.addTextElementToData("Error", ss.str());
+ return;
+ }
+
+ const TableInfo& tableInfo = allTableInfo.at(tableName);
+ __COUT__ << "tableInfo versions length " << tableInfo.versions_.size() << __E__;
+
+ unsigned int matchCount = 0;
+ bool allowIllegalColumns = true;
+ bool getRawData = true;
+ // Create a parent element for search results
+ auto parentEl = xmlOut.addTextElementToData("SearchResults", "");
+
+ // Loop through all versions of the table
+ for(const auto& version : tableInfo.versions_)
+ {
+ try
+ {
+ auto activeIt = allActivePairs.find(tableName);
+ bool isActiveVersion =
+ (activeIt != allActivePairs.end() && activeIt->second == version);
+ __COUT__ << "Active check for " << tableName << " v" << version << " => "
+ << (isActiveVersion ? "active" : "inactive") << __E__;
+ if(!isActiveVersion && activeTablesOnly)
+ continue; // Skip versions that are not active
+
+ if((std::stoi(version.toString()) < searchMinThreshold ||
+ std::stoi(version.toString()) > searchMaxThreshold) &&
+ activeTablesOnly == false /*ignore version threshold if active only*/)
+ {
+ __COUT__ << "Skipping version " << version << " out of range "
+ << searchMinThreshold << " to " << searchMaxThreshold
+ << __E__;
+ continue;
+ }
+ TableBase* table = cfgMgr->getTableByName(tableName);
+
+ // get view pointer
+ TableView* tableViewPtr;
+ if(version.isInvalid()) // use mock-up
+ {
+ __COUT__ << "Using mock-up for table " << tableName << " version "
+ << version << __E__;
+ tableViewPtr = table->getMockupViewP();
+ }
+ else // use view version
+ {
+ try
+ {
+ // locally accumulate 'manageable' errors getting the version to avoid
+ // reverting to mockup
+ std::string localAccumulatedErrors = "";
+ tableViewPtr =
+ cfgMgr
+ ->getVersionedTableByName(
+ tableName,
+ version,
+ allowIllegalColumns /*looseColumnMatching*/,
+ &localAccumulatedErrors,
+ getRawData)
+ ->getViewP();
+
+ if(getRawData)
+ {
+ __COUT__ << "Adding raw data for table " << tableName
+ << " version " << version << __E__;
+
+ const std::set& srcColNames =
+ tableViewPtr->getSourceColumnNames();
+ for(auto& srcColName : srcColNames)
+ xmlOut.addTextElementToData("ColumnHeader", srcColName);
+
+ if(!version.isTemporaryVersion())
+ {
+ __COUT__ << "Table is temporary, reloading view to "
+ "clear raw data"
+ << __E__;
+ // if version is temporary, view is already ok
+ table->eraseView(
+ version); // clear so that the next get will fill the table
+ tableViewPtr =
+ cfgMgr
+ ->getVersionedTableByName(
+ tableName,
+ version,
+ allowIllegalColumns /*looseColumnMatching*/
+ ,
+ &localAccumulatedErrors,
+ false /* getRawData */)
+ ->getViewP();
+ }
+ } // end rawData handling
+
+ if(localAccumulatedErrors != "")
+ xmlOut.addTextElementToData("Error", localAccumulatedErrors);
+ }
+ catch(const std::runtime_error& e)
+ {
+ __COUT__ << "Error loading version " << version << " for table "
+ << tableName << ": " << e.what() << __E__;
+ __SUP_COUT_WARN__ << "Could not load version " << version
+ << " for table " << tableName << ": "
+ << e.what() << __E__;
+ // fallback to mockup
+ tableViewPtr = table->getMockupViewP();
+ }
+ }
+
+ __COUT__ << "Getting table " << tableName << " version " << version
+ << __E__;
+
+ // Search through all rows and columns
+ for(unsigned int row = 0; row < tableViewPtr->getNumberOfRows(); ++row)
+ {
+ for(unsigned int col = 0; col < tableViewPtr->getNumberOfColumns();
+ ++col)
+ {
+ const std::string& cellValue =
+ tableViewPtr->getDataView()[row][col];
+ // Check if searchText is found in cell value
+ if(cellValue.find(searchText) != std::string::npos)
+ {
+ __COUT__ << "Match found in row " << row << " column " << col
+ << " value: " << cellValue << __E__;
+ auto matchEl = xmlOut.addTextElementToParent(
+ "Match", cellValue, parentEl);
+ xmlOut.addTextElementToParent(
+ "MatchVersion", version.toString(), matchEl);
+ xmlOut.addTextElementToParent(
+ "MatchRow", std::to_string(row), matchEl);
+ xmlOut.addTextElementToParent(
+ "MatchColumn",
+ tableViewPtr->getColumnInfo(col).getName(),
+ matchEl);
+
+ ++matchCount;
+ }
+ }
+ } // end for rows and columns
+ }
+ catch(const std::runtime_error& e)
+ {
+ __COUT__ << "Error searching in version " << version << " for table "
+ << tableName << ": " << e.what() << __E__;
+ __SUP_COUT_WARN__ << "Could not load version " << version << " for table "
+ << tableName << ": " << e.what() << __E__;
+ }
+ } //emd for version loop
+
+ xmlOut.addTextElementToData("MatchCount", std::to_string(matchCount));
+ }
+ catch(std::runtime_error& e)
+ {
+ __SUP_SS__ << "Error searching in table '" << tableName << "'!\n\n " << e.what()
+ << __E__;
+ __SUP_COUT_ERR__ << ss.str();
+ xmlOut.addTextElementToData("Error", ss.str());
+ }
+ catch(...)
+ {
+ __SUP_SS__ << "Error searching in table '" << tableName << "'!\n\n " << __E__;
+ try
+ {
+ throw;
+ }
+ catch(const std::exception& e)
+ {
+ ss << "Exception message: " << e.what();
+ }
+ catch(...)
+ {
+ }
+ __SUP_COUT_ERR__ << ss.str();
+ xmlOut.addTextElementToData("Error", ss.str());
+ }
+} // end handleSearchFieldInTableXML()
+
//==============================================================================
/// handleGroupDiff
void ConfigurationGUISupervisor::handleGroupDiff(
diff --git a/otsdaq-utilities/ConfigurationGUI/ConfigurationGUISupervisor.h b/otsdaq-utilities/ConfigurationGUI/ConfigurationGUISupervisor.h
index 517843737..2a93f643d 100644
--- a/otsdaq-utilities/ConfigurationGUI/ConfigurationGUISupervisor.h
+++ b/otsdaq-utilities/ConfigurationGUI/ConfigurationGUISupervisor.h
@@ -248,8 +248,19 @@ class ConfigurationGUISupervisor : public CoreSupervisorBase
const std::string& tableName,
const TableVersion& vA,
const TableVersion& vB);
-
-
+ void handleSearchFieldInGroupXML (HttpXmlDocument& xmlOut,
+ ConfigurationManagerRW* cfgMgr,
+ const std::string& searchText,
+ const bool activeGroupsOnly,
+ const std::string& groupType,
+ const std::string& optionGroups,
+ std::string& versionsToCheck);
+ void handleSearchFieldInTableXML( HttpXmlDocument& xmlOut,
+ ConfigurationManagerRW* cfgMgr,
+ const std::string& searchText,
+ const std::string& tableName,
+ const std::string& searchVersionToCheck,
+ bool activeTablesOnly);
void testXDAQContext (void);