def on_btnExecute_released(self, *args: Any, **kwargs: Any) -> None:
item = self.ui.listWidget.currentItem()
if not item:
return
taskID = item.task["key"]
for i in range(self.ui.horizontalLayout.count()):
if self.ui.horizontalLayout.itemAt(i).widget():
self.ui.horizontalLayout.itemAt(i).widget().close()
for i in range(self.ui.verticalLayout.count()):
if self.ui.verticalLayout.itemAt(i).widget():
self.ui.verticalLayout.itemAt(i).widget().close()
task = None
for t in self.tasks["skellist"]:
if t["key"] == taskID:
task = t
break
if not task:
return
nameLbl = QtWidgets.QLabel(task["name"], self)
self.ui.verticalLayout.addWidget(nameLbl)
descrLbl = QtWidgets.QLabel(task["descr"], self)
self.ui.verticalLayout.addWidget(descrLbl)
event.emit("stackWidget",
EditWidget("_tasks", ApplicationType.SINGLETON, taskID))
def onTabCurrentChanged(self, idx: int) -> None:
wdg = self.tabWidget.widget(idx)
for k, v in self.languageContainer.items():
if v == wdg:
event.emit("tabLanguageChanged", k)
wdg.setFocus()
return
def onBtnCancelReleased(self, *args: Any, **kwargs: Any) -> None:
logger.debug("onBtnCancelReleased")
try:
self.selection.prepareDeletion()
except AttributeError:
pass
event.emit("popWidget", self)
def openEditor(self, *args: Any, **kwargs: Any) -> None:
if isPyodide:
switchToSummernote(self.html, self.onSave)
#js.switchToEditor(self.html)
#js.document.getElementById("editorframe").style.setProperty("display", "")
#js.document.getElementById("textBone").value = "asdasdas"
return
if self.languages:
lang = self.languages[self.tabWidget.currentIndex()]
if self.plaintext:
editor = RawTextEdit(self.html[lang])
else:
if self.validHtml:
editor = TextEdit(self.html[lang], self.validHtml, lang)
else:
editor = RawTextEdit(self.html[lang])
else:
if self.plaintext:
editor = RawTextEdit(self.html)
else:
if self.validHtml:
editor = TextEdit(self.html, self.validHtml, "en")
else:
editor = RawTextEdit(self.html)
editor.onDataChanged.connect(self.onSave)
event.emit("stackWidget", editor)
def onLoginSucceeded(self) -> None:
logger.debug("onLoginSucceeded")
self.overlay.inform(
self.overlay.SUCCESS,
QtCore.QCoreApplication.translate("Login", "Login successful"))
# config.conf.loadPortalConfig(NetworkService.url, withCookies=False)
event.emit("loginSucceeded")
self.setDisabled(False)
self.hide()
def onSourceItemDoubleClicked(self, item: QtWidgets.QListWidgetItem) -> None:
"""
An item has been doubleClicked in our listWidget.
Read its properties and add them to our selection.
"""
logger.debug("RelationalEditBone.onSourceItemDoubleClicked: %r", item)
data = item
self.selectionChanged.emit([data])
event.emit("popWidget", self)
def onLoadConfig(self, request: RequestWrapper) -> None:
logger.debug("Checkpoint: onLoadConfig")
try:
conf.serverConfig = NetworkService.decode(request)
except:
self.onError(msg="Unable to parse portalconfig!")
return
event.emit("configDownloaded")
if conf.currentUserEntry is not None:
self.setup()
def onSourceItemDoubleClicked(self,
item: QtWidgets.QListWidgetItem) -> None:
"""
An item has been doubleClicked in our listWidget.
Read its properties and add them to our selection.
"""
data = item.entryData
if self.multiple:
self.selection.extend([data])
else:
self.selectionChanged.emit([data])
event.emit("popWidget", self)
def onSaveSuccess(self, editTaskID: int) -> None:
"""
Adding/editing an entry just succeeded
"""
logger.debug("onSaveSuccess: %r, %r", editTaskID, self.editTaskID)
if editTaskID != self.editTaskID: # Not our task
return
self.setDisabled(False)
logToUser(QtCore.QCoreApplication.translate("EditWidget", "Entry saved"))
#self.overlay.inform(self.overlay.SUCCESS, QtCore.QCoreApplication.translate("EditWidget", "Entry saved"))
if self.closeOnSuccess:
event.emit('popWidget', self)
else:
self.reloadData()
def timerEvent(self, e: QtCore.QTimerEvent) -> None:
total = 0
missing = 0
for modul in conf.serverConfig["modules"]:
total += 1
protoWrap = protocolWrapperInstanceSelector.select(modul)
if protoWrap is None:
continue
if protoWrap.busy:
missing += 1
if not total:
print("No Modules available!!!")
total = 1
missing = 0
self.ui.progressBar.setValue(10 + int(100.0 *
((total - missing) / total)))
#print("%s - %s" % (total, missing))
if not missing:
event.emit("preloadingFinished")
self.finished.emit()
self.killTimer(self.timerID)
self.timerID = None
def __init__(
self,
moduleName: str,
boneName: str,
multiple: bool,
toModul: str,
selection: list,
*args: Any,
**kwargs: Any):
super(RelationalBoneSelector, self).__init__(*args, **kwargs)
logger.debug("RelationalBoneSelector.init: %r, %r, %r, %r, %r", moduleName, boneName, multiple, toModul,
selection)
self.moduleName = moduleName
self.boneName = boneName
self.multiple = multiple
self.module = toModul
self.selection = selection
self.ui = Ui_relationalSelector()
self.ui.setupUi(self)
layout = QtWidgets.QHBoxLayout(self.ui.tableWidget)
self.ui.tableWidget.setLayout(layout)
self.list = self.displaySourceWidget(self.module, editOnDoubleClick=False, parent=self)
layout.addWidget(self.list)
self.list.show()
layout = QtWidgets.QHBoxLayout(self.ui.listSelected)
self.ui.listSelected.setLayout(layout)
self.selection = self.displaySelectionWidget(self.module, selection, parent=self)
layout.addWidget(self.selection)
self.selection.show()
# self.list.setSelectionMode( self.list.SingleSelection )
if not self.multiple:
self.selection.hide()
self.ui.lblSelected.hide()
self.list.itemDoubleClicked.connect(self.onSourceItemDoubleClicked)
self.list.itemClicked.connect(self.onSourceItemClicked)
self.ui.btnSelect.clicked.connect(self.onBtnSelectReleased)
self.ui.btnCancel.clicked.connect(self.onBtnCancelReleased)
event.emit('stackWidget', self)
def onHasSession(self, req):
data = NetworkService.decode(req)
if data["values"] and data["values"]["access"] and "root" in data[
"values"]["access"]:
event.emit("loginSucceeded")
self.hide()
else:
try:
userName = data["values"]["name"]
except:
userName = "******"
self.requestLogoutBox = QtWidgets.QMessageBox(
QtWidgets.QMessageBox.Question,
QtCore.QCoreApplication.translate("SimpleLogin", "Logout?"),
QtCore.QCoreApplication.translate(
"SimpleLogin",
"This user (%s) cannot be used with ViUR Admin. Do you want to log out?"
) % userName,
(QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No), self)
self.requestLogoutBox.buttonClicked.connect(self.reqLogoutCallback)
self.requestLogoutBox.open()
QtGui.QGuiApplication.processEvents()
self.requestLogoutBox.adjustSize()
def addData(self, queryKey: Any) -> None:
self.isLoading -= 1
if queryKey is not None and queryKey != self.loadingKey: # The Data is for a list we don't display anymore
return
protoWrap = protocolWrapperInstanceSelector.select(self.module)
assert protoWrap is not None
protoData = protoWrap.queryCache[queryKey]
skellist = [protoWrap.entryCache[x] for x in protoData["skelkeys"]]
cursor = protoData["cursor"]
for item in skellist: # Insert the new Data at the corresponding Position
self.dataCache.append(item)
self.cursor = cursor
self.loadingKey = None
count = len(skellist)
self.count += count
self.ui.countLabel.setText(str(self.count))
if count < 20:
self.completeList = True
self.serializeToCsv(self.dataCache, protoWrap.viewStructure)
self.model.dataCache = self.dataCache
self.model.layoutChanged.emit()
event.emit('popWidget', self)
else:
self.loadNext()
def setData(
self,
request: RequestWrapper = None,
data: Dict[str, Any] = None,
ignoreMissing: bool = False) -> None:
"""
Rebuilds the UI according to the skeleton received from server
:param request: the request to handle
:param data: The data received
:param ignoreMissing: if missing data should be reported as errors
"""
assert request or data
if request:
data = NetworkService.decode(request)
# Clear the UI
while self.ui.tabWidget.count():
item = self.ui.tabWidget.widget(0)
if item and item.widget():
if "remove" in dir(item.widget()):
item.widget().remove()
self.ui.tabWidget.removeTab(0)
self.bones = {}
self.boneToTabMap = {}
self.dataCache = data
tmpDict = {}
tabs: Dict[str, QtWidgets.QFormLayout] = dict()
tmpTabs: List[Tuple[QtWidgets.QScrollArea, str]] = list() # Sort tabs by their description
tabMaxError: Dict[str, int] = {} # Map of max-error code per tap
for key, bone in data["structure"]:
tmpDict[key] = bone
for key, bone in data["structure"]:
if not bone["visible"]:
continue
if "params" in bone and bone["params"] and "category" in bone["params"]:
tabName = bone["params"]["category"]
else:
tabName = QtCore.QCoreApplication.translate("EditWidget", "General")
if tabName not in tabs:
scrollArea = QtWidgets.QScrollArea()
outerContainer = QtWidgets.QWidget(scrollArea)
outerLayout = QtWidgets.QVBoxLayout(outerContainer)
scrollArea.setWidget(outerContainer)
containerWidget = QtWidgets.QWidget(outerContainer)
outerLayout.addWidget(containerWidget, 1)
formLayout = QtWidgets.QFormLayout(containerWidget)
formLayout.setFieldGrowthPolicy(QtWidgets.QFormLayout.AllNonFixedFieldsGrow)
formLayout.setLabelAlignment(QtCore.Qt.AlignLeft)
formLayout.setAlignment(QtCore.Qt.AlignTop)
tabs[tabName] = formLayout
containerWidget.setLayout(formLayout)
containerWidget.setSizePolicy(
QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Preferred))
tmpTabs.append((scrollArea, tabName))
outerLayout.addStretch(100)
scrollArea.setWidgetResizable(True)
for error in data["errors"]:
if error["fieldPath"] and error["fieldPath"][0] == key:
severity = error["severity"]
if severity == 2 and bone.get("required"):
severity = 3
if severity > tabMaxError.get(tabName, 0):
tabMaxError[tabName] = severity
tmpTabs.sort(key=lambda x: x[1])
for scrollArea, tabName in tmpTabs:
tabIndex = self.ui.tabWidget.addTab(scrollArea, tabName)
maxErrCode = tabMaxError.get(tabName, 0)
if maxErrCode == 1:
self.ui.tabWidget.setTabIcon(tabIndex, loadIcon("bone-invalidates-other"))
elif maxErrCode == 2:
self.ui.tabWidget.setTabIcon(tabIndex, loadIcon("bone-empty"))
elif maxErrCode == 3:
self.ui.tabWidget.setTabIcon(tabIndex, loadIcon("bone-error"))
else:
self.ui.tabWidget.setTabIcon(tabIndex, loadIcon("bone-valid"))
for key, bone in data["structure"]:
if bone["visible"] == False:
continue
if "params" in bone and bone["params"] and "category" in bone["params"]:
tabName = bone["params"]["category"]
else:
tabName = QtCore.QCoreApplication.translate("EditWidget", "General")
wdgGen = editBoneSelector.select(self.module, key, tmpDict)
widget = wdgGen.fromSkelStructure(self.module, key, tmpDict, editWidget=self)
widget.setSizePolicy(
QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding))
dataWidget = widget
# TODO: Temporary MacOS Fix
if sys.platform.startswith("darwin"):
dataWidget.setMaximumWidth(500)
dataWidget.setMinimumWidth(500)
# TODO: Temporary MacOS Fix
lblWidget = QtWidgets.QWidget(self)
layout = QtWidgets.QHBoxLayout(lblWidget)
if "params" in bone and isinstance(bone["params"], dict) and "tooltip" in bone["params"]:
lblWidget.setToolTip(self.parseHelpText(bone["params"]["tooltip"]))
descrLbl = QtWidgets.QLabel(bone["descr"], lblWidget)
descrLbl.setWordWrap(True)
if bone["required"]:
font = descrLbl.font()
font.setBold(True)
font.setUnderline(True)
descrLbl.setFont(font)
layout.addWidget(descrLbl)
tabs[tabName].addRow(lblWidget, dataWidget)
dataWidget.show()
self.bones[key] = widget
self.boneToTabMap[dataWidget] = [x[1] for x in tmpTabs].index(tabName)
self.unserialize(data["values"], data["errors"])
# self._lastData = data
# logger.debug("setData _lastData: %r", self._lastData)
event.emit("rebuildBreadCrumbs()")
def onBtnCloseReleased(
self,
*args: Any,
**kwargs: Any) -> None:
event.emit("popWidget", self)
def save(self, *args: Any, **kwargs: Any) -> None:
self.onDataChanged.emit(self.ui.textEdit.toPlainText())
event.emit('popWidget', self)
def addWidget(self, widget: Any) -> None:
assert self.stackedWidget.indexOf(widget) == -1
event.emit("addWidget", widget)
self.stackedWidget.addWidget(widget)
def onFinishSave(self, data: Dict[str, Any]) -> None:
logger.debug("onFinishSave TODO:: %r", data)
self.onDataChanged.emit(data)
event.emit('popWidget', self)
def resetLoginWindow(self) -> None:
"""
Emits QtCore.SIGNAL('resetLoginWindow()')
"""
event.emit('resetLoginWindow')
self.hide()
def setup(self) -> None:
"""
Initializes everything based on the config received from the server.
It
- Resets the ui to sane defaults.
- Selects a startPage for the application
- Selects Protocolwrapper and Module-Handler for each module
- Requests a toplevel handler for each module
- Finally emits modulHandlerInitialized and mainWindowInitialized
"""
if not self.startPage:
if "configuration" in conf.serverConfig:
if "analyticsKey" in conf.serverConfig["configuration"]:
logger.debug("setting analytics widget as startpage")
self.startPage = startpages.AnalytisWidget()
elif "startPage" in conf.serverConfig["configuration"]:
logger.debug("retrieving startpage from server")
self.startPage = startpages.WebWidget()
if not self.startPage: # Still not
logger.debug("setting default startpage")
self.startPage = DefaultWidget()
self.stackedWidget.addWidget(self.startPage)
self.treeWidget.clear()
data = conf.serverConfig
handlers = []
groupHandlers = {}
by_group: Dict[str, List[Any]] = dict()
if "configuration" in data and "moduleGroups" in data["configuration"]:
for group in data["configuration"]["moduleGroups"]:
if (self.groupWhitelist is not None and group["name"]
not in self.groupWhitelist) or not all([
x in group for x in ["name", "prefix", "icon"]
]): # Assert that all required properties are there
continue
group_handler = GroupHandler(None,
group["name"],
group["icon"],
sortIndex=group.get(
"sortIndex", 0))
group_prefix = group["prefix"]
groupHandlers[group_prefix] = group_handler
by_group[group_prefix] = list()
# self.treeWidget.addTopLevelItem(groupHandlers[group["prefix"]])
if "modules" not in conf.portal:
conf.portal["modules"] = {}
def sortItemHandlers(pair: Tuple[Any, Any]) -> Any:
return pair[1].sortIndex
groupHandlers = OrderedDict(
sorted(groupHandlers.items(), key=sortItemHandlers))
access = conf.currentUserEntry["access"]
for module, cfg in data["modules"].items():
logger.debug("starting to load module %r", module)
if (self.moduleWhitelist is not None
and cfg["name"] not in self.moduleWhitelist
) or "root" not in access and not "{0}-view".format(
module) in access:
continue
queue = RegisterQueue()
event.emit('requestModuleHandler', queue, module)
handler = queue.getBest()()
if "name" in cfg and groupHandlers:
parent = None
for groupName in groupHandlers:
if cfg["name"].startswith(groupName):
parent = groupHandlers[groupName]
break
if parent:
# parent.addChild(handler)
by_group[groupName].append(handler)
else:
self.treeWidget.addTopLevelItem(handler)
else:
self.treeWidget.addTopLevelItem(handler)
handlers.append(handler)
wrapperClass = protocolWrapperClassSelector.select(
module, data["modules"])
if wrapperClass is not None:
wrapperClass(module)
event.emit('modulHandlerInitialized', module)
def subhandlerSorter(x: Any) -> int:
return x.sortIndex
emptyGroups = list()
for group, handlers in by_group.items():
handlers.sort(key=subhandlerSorter, reverse=True)
for handler in handlers:
groupHandlers[group].addChild(handler)
if handlers:
self.treeWidget.addTopLevelItem(groupHandlers[group])
else:
emptyGroups.append((group, groupHandlers[group]))
for prefix, groupHandler in emptyGroups:
groupHandlers.pop(prefix)
del by_group[prefix]
self.treeWidget.sortItems(1, QtCore.Qt.DescendingOrder)
event.emit('mainWindowInitialized')
QtWidgets.QApplication.restoreOverrideCursor()
def onQuerySuccess(self, query: Any) -> None:
self.model().reload()
event.emit(QtCore.SIGNAL("listChanged(PyQt_PyObject,PyQt_PyObject,PyQt_PyObject)"), self, self.module, None)
self.overlay.inform(self.overlay.SUCCESS)