def addData(self, queryKey: str) -> None:
self.isLoading -= 1
if queryKey is not None and queryKey != self.loadingKey: # The Data is for a list we dont display anymore
return
protoWrap = protocolWrapperInstanceSelector.select(self.module)
assert protoWrap is not None
#cacheTime, skellist, cursor = protoWrap.dataCache[queryKey]
skellist = [protoWrap.entryCache[x] for x in protoWrap.queryCache[queryKey]["skelkeys"]]
cursor = protoWrap.queryCache[queryKey]["cursor"]
# Rebuild our local cache of valid fields
if not self.bones:
for key, bone in protoWrap.viewStructure.items():
self.bones[key] = bone
self._validFields = [x for x in self.fields if x in self.bones]
self.fields = [x for x in self.fields if x in self._validFields]
if not self.fields: # Select the 10 first bones that do exist to prevent an empty table
# Don't show these bones by default in the table
systemBones = {"key","creationdate", "changedate", "viurCurrentSeoKeys"}
self.fields = [x for x in self.bones if x not in systemBones][:10]
self._validFields = self.fields[:]
self.rebuildDelegates.emit(protoWrap.viewStructure)
self.repaint()
self.beginInsertRows(QtCore.QModelIndex(), len(self.dataCache), len(self.dataCache) + len(skellist) - 1)
self.dataCache.extend(skellist)
self.endInsertRows()
if not cursor:
self.beginRemoveRows(QtCore.QModelIndex(), len(self.dataCache), len(self.dataCache))
self.completeList = True
self.endRemoveRows()
self.cursor = cursor
self.loadingKey = None
if protoWrap.queryCache[queryKey].get("failed"):
QtWidgets.QMessageBox.warning(self.parent(), "Failed", "A Network-Request failed")
def __init__(self, parent: QtWidgets.QWidget, module: str, rootNode: Union[str, None] = None, *args: Any, **kwargs: Any):
""" CTOR
:param parent: Parent widget
:param module: Name of the module to show the elements for
:param rootNode: Key of the rootNode which data should be displayed. If None, this widget tries to choose
one.
"""
super(HierarchyTreeWidget, self).__init__(parent=parent)
self.module = module
self.rootNode = rootNode
self.loadingKey = None
self.overlay = Overlay(self)
self.expandList: List[str] = list()
self.setHeaderHidden(True)
self.setAcceptDrops(True)
self.setDragDropMode(self.DragDrop)
self.rootNodes = None
protoWrap = protocolWrapperInstanceSelector.select(self.module)
assert protoWrap is not None
if not self.rootNode:
if protoWrap.rootNodes:
self.rootNode = protoWrap.rootNodes[0]["key"]
protoWrap.entitiesChanged.connect(self.onHierarchyChanged)
protoWrap.childrenAvailable.connect(self.setData)
# self.connect( protoWrap, QtCore.SIGNAL("entitiesChanged()"), self.onHierarchyChanged )
# self.connect( self, QtCore.SIGNAL("itemExpanded(QTreeWidgetItem *)"), self.onItemExpanded )
self.itemExpanded.connect(self.onItemExpanded)
if self.rootNode:
self.loadData()
protoWrap.busyStateChanged.connect(self.onBusyStateChanged)
def save(self, data: dict) -> None:
protoWrap = protocolWrapperInstanceSelector.select(self.module)
assert protoWrap is not None
if self.module == "_tasks":
self.editTaskID = protoWrap.edit(self.key, **data)
# request = NetworkService.request("/%s/execute/%s" % ( self.module, self.id ), data, secure=True,
# successHandler=self.onSaveResult )
elif self.applicationType == ApplicationType.LIST: # Application: List
if self.key and (not self.clone or not data):
self.editTaskID = protoWrap.edit(self.key, **data)
else:
self.editTaskID = protoWrap.add(**data)
elif self.applicationType == ApplicationType.HIERARCHY: # Application: Hierarchy
if self.key and (not self.clone or not data):
self.editTaskID = protoWrap.edit(self.key, **data)
else:
self.editTaskID = protoWrap.add(self.node, **data)
elif self.applicationType == ApplicationType.TREE: # Application: Tree
if self.key and not self.clone:
self.editTaskID = protoWrap.edit(self.key, self.skelType, **data)
else:
self.editTaskID = protoWrap.add(self.node, self.skelType, **data)
elif self.applicationType == ApplicationType.SINGLETON: # Application: Singleton
self.editTaskID = protoWrap.edit(**data)
else:
raise NotImplementedError() # Should never reach this
self.setDisabled(True)
def loadNext(self, forceLoading: bool = False) -> None:
if self.isLoading and not forceLoading:
return
self.isLoading += 1
rawFilter = self.filter.copy() or {}
if self.cursor:
rawFilter["cursor"] = self.cursor
if self.currentSortBone:
boneName, descending = self.currentSortBone
rawFilter["orderby"] = boneName
rawFilter["orderdir"] = "1" if descending else "0"
#elif self.dataCache: # FIXME(): Is this still a thing?
# invertedOrderDir = False
# if "orderdir" in rawFilter and str(rawFilter["orderdir"]) == "1":
# invertedOrderDir = True
# if "orderby" in rawFilter and rawFilter["orderby"] in self.dataCache[-1]:
# if invertedOrderDir:
# rawFilter[rawFilter["orderby"] + "$lt"] = self.dataCache[-1][rawFilter["orderby"]]
# else:
# rawFilter[rawFilter["orderby"] + "$gt"] = self.dataCache[-1][rawFilter["orderby"]]
protoWrap = protocolWrapperInstanceSelector.select(self.module)
assert protoWrap is not None
# logger.debug("loadNext.chunk: %r, %r, %r", rawFilter, type(rawFilter), self._chunkSize)
rawFilter["limit"] = self._chunkSize
self.loadingKey = protoWrap.queryData(**rawFilter)
def htmlDropEvent(self, fileList): if fileList: self.setDisabled(True) fileList = [fileList[0]] # Crop to first file protoWrap = protocolWrapperInstanceSelector.select(self.toModule) uploader = protoWrap.upload(fileList, None) uploader.finished.connect(self.htmlUploadFinished)
def getBreadCrumb(self) -> Tuple[Union[str, None], QtGui.QIcon]:
protoWrap = protocolWrapperInstanceSelector.select(self.moduleName)
assert protoWrap is not None
# FIXME: Bad hack to get the editWidget we belong to
skel: Union[Dict[str, Any], None] = None
for widget in WidgetHandler.mainWindow.handlerForWidget(self).widgets:
if isinstance(widget, EditWidget):
if (not widget.key) or widget.clone: # We're adding a new entry
if widget.skelType == "leaf":
skel = protoWrap.addLeafStructure
elif widget.skelType == "node":
skel = protoWrap.addNodeStructure
else:
skel = protoWrap.addStructure
else:
if widget.skelType == "leaf":
skel = protoWrap.editLeafStructure
elif widget.skelType == "node":
skel = protoWrap.editNodeStructure
else:
skel = protoWrap.editStructure
assert skel is not None
assert self.boneName in skel
return QtCore.QCoreApplication.translate("ExtendedRelationalBoneSelector", "Select %s") % skel[self.boneName][
"descr"], loadIcon("select")
def onTriggered(self) -> None:
reqWrap = protocolWrapperInstanceSelector.select(self.realModule)
assert reqWrap is not None
node = reqWrap.getNode(self.parent().getNode())
if node:
if node["parententry"]:
self.parent().setNode(node["parententry"], isInitialCall=True)
def updateVisiblePreview(self) -> None:
protoWrap = protocolWrapperInstanceSelector.select(self.toModule)
assert protoWrap is not None, "Module %s has no protoWrap" % self.toModule
structure = None
if self.skelType is None:
structure = protoWrap.viewStructure
elif self.skelType == "leaf":
structure = protoWrap.viewLeafStructure
elif self.skelType == "node":
structure = protoWrap.viewNodeStructure
if structure is None:
return
if self.selection:
logger.debug("selection: %r", self.selection)
if self.selection["dest"]["mimetype"].startswith("image/") and not isPyodide:
RemoteFile(self.selection["dest"]["dlkey"], successHandler=self.loadIconFromRequest)
try:
value = self.safeEval.execute(self.ast, {
"value": self.selection,
"structure": structure,
"language": config.conf.adminConfig.get("language", "en")
})
except Exception as e:
logger.exception(e)
value = "(invalid format string)"
self.entry.setText(value)
else:
self.entry.setText("")
def addItem(self, item: Union[Dict[str, Any], str]) -> None:
"""
Adds an item to the model.
The only relevant information is item["key"], the rest is freshly fetched from the server.
@param item: The new item
@type item: Dict or String
"""
protoWrap = protocolWrapperInstanceSelector.select(self.realModule)
assert protoWrap is not None
if not item:
return
if isinstance(item, dict):
if "dest" in item:
key = item["dest"]["key"]
elif "key" in item:
key = item["key"]
else:
raise NotImplementedError("Unknown item format: %s" % item)
if "_type" in item:
self.entryFetches.append(protoWrap.queryEntry(key, item["_type"]))
else:
if self.skelType:
self.entryFetches.append(protoWrap.queryEntry(key, self.skelType))
else:
self.entryFetches.append(protoWrap.queryEntry(key))
elif isinstance(item, str):
if self.skelType is not None:
self.entryFetches.append(protoWrap.queryEntry(item, self.skelType))
else:
self.entryFetches.append(protoWrap.queryEntry(item))
else:
logger.debug("SelectedEntities.addItem: unhandled instance type: %r", item, type(item))
raise NotImplementedError()
def __init__(
self,
parent: QtWidgets.QWidget,
module: str,
selection: List[Dict[str, Any]],
skelType: str = None,
*args: Any,
**kwargs: Any):
"""
:param parent: Our parent widget.
:param module: Name of the module which items were going to display.
:param selection: Currently selected items.
"""
super(SelectedEntitiesTableModel, self).__init__(parent, *args, **kwargs)
logger.debug("SelectedEntitiesTableModel.init: %r, %r, %r, %r", parent, module, selection, skelType)
self.module = self.realModule = module
if module.endswith("_rootNode"):
self.realModule = module[:-9]
self.dataCache: List[Any] = []
self.fields = ["name", "foo"]
self.headers: List[Any] = []
self.skelType = skelType
self.entryFetches: List[Any] = [] # List of fetch-Tasks we issued
protoWrap = protocolWrapperInstanceSelector.select(self.realModule)
assert protoWrap is not None
structureCache = protoWrap.editStructure
# print("model init structure", structureCache)
protoWrap.entityAvailable.connect(self.onItemDataAvailable)
for item in (selection or []):
self.addItem(item)
def rebuildDelegates(self) -> None:
"""(Re)Attach the view delegates to the table.
"""
logger.debug("SelectedEntitiesWidget.rebuildDelegates - start:")
protoWrap = protocolWrapperInstanceSelector.select(self.realModule)
assert protoWrap is not None
self.delegates = list()
if self.skelType is None:
structureCache = protoWrap.viewStructure
elif self.skelType == "node":
structureCache = protoWrap.viewNodeStructure
elif self.skelType == "leaf":
structureCache = protoWrap.viewLeafStructure
else:
structureCache = dict()
self.model().headers = []
colum = 0
fields = [x for x in self.model().fields if x in structureCache]
for field in fields:
self.model().headers.append(structureCache[field]["descr"])
# Locate the best ViewDeleate for this colum
delegateFactory = viewDelegateSelector.select(self.realModule, field, structureCache)
delegate = delegateFactory(self.realModule, field, structureCache)
self.setItemDelegateForColumn(colum, delegate)
self.delegates.append(delegate)
delegate.request_repaint.connect(self.repaint)
colum += 1
def reqDeleteCallback(self, clickedBtn, *args, **kwargs): if clickedBtn == self.requestDeleteBox.button(self.requestDeleteBox.Yes): protoWrap = protocolWrapperInstanceSelector.select(self.module) assert protoWrap is not None self.setDisabled(True) protoWrap.delete(self.requestDeleteBox.deleteList) self.requestDeleteBox = None
def commitDataCb(self, editor):
protoWrap = protocolWrapperInstanceSelector.select(self.moduleName)
assert protoWrap is not None
self.editTaskID = protoWrap.edit(
self.editingItem["key"],
**{self.boneName: editor.serializeForPost()})
self.editingModel = None
self.editingIndex = None
def commitDataCb(self, editor):
print("IN COMMIT DATA CB")
protoWrap = protocolWrapperInstanceSelector.select(self.moduleName)
assert protoWrap is not None
self.editTaskID = protoWrap.edit(self.editingItem["key"], **{self.boneName: editor.serializeForPost()})
#self.editingModel.dataCache[self.editingIndex.row()][self.boneName] = "-Lade-"
self.editingModel = None
self.editingIndex = None
def onNodeChanged(self, node: str) -> None:
reqWrap = protocolWrapperInstanceSelector.select(self.realModule)
assert reqWrap is not None
node = reqWrap.getNode(self.parent().getNode())
if not node["parententry"]:
self.setEnabled(False)
else:
self.setEnabled(True)
def dropEvent(self, event: QtGui.QDropEvent) -> None:
dataDict = json.loads(
event.mimeData().data("viur/treeDragData").data().decode("UTF-8"))
protoWrap = protocolWrapperInstanceSelector.select(self.realModule)
assert protoWrap is not None
destItem = self.itemAt(event.pos())
protoWrap.move(dataDict["nodes"], dataDict["leafs"],
destItem.entryData["key"])
def reqDeleteCallback(self, clickedBtn, *args, **kwargs):
if clickedBtn == self.requestDeleteBox.button(
self.requestDeleteBox.Yes):
protoWrap = protocolWrapperInstanceSelector.select(self.realModule)
assert protoWrap is not None
protoWrap.deleteEntities(self.requestDeleteBox.deleteNode,
self.requestDeleteBox.deleteLeafs)
self.requestDeleteBox = None
return True
def onCustomQueryFinished(self, queryKey: str) -> None:
print("onCustomQueryFinished", queryKey)
self.clear()
if queryKey != self.customQueryKey:
return
protoWrap = protocolWrapperInstanceSelector.select(self.realModule)
assert protoWrap is not None
print("pppp1")
self.setDisplayData(protoWrap.getNodesForCustomQuery(queryKey))
def loadData(self) -> None:
logger.debug("loadData")
try:
self.itemCache.clear()
except:
pass
self.clear()
protoWrap = protocolWrapperInstanceSelector.select(self.realModule)
protoWrap.queryData(self.node)
def onTriggered(self) -> None:
# self.overlay = Overlay(self)
# self.overlay.inform(self.overlay.BUSY)
path = self.ui.filenameName.text()
logger.debug("path: %r", path)
if not path:
return
protoWrap = protocolWrapperInstanceSelector.select(self.module)
assert protoWrap is not None
protoWrap.queryResultAvailable.connect(self.addData)
self.loadNext()
def createEditor(self, parent, option, index):
protoWrap = protocolWrapperInstanceSelector.select(self.moduleName)
assert protoWrap is not None
skelStructure = protoWrap.editStructure
wdgGen = editBoneSelector.select(self.moduleName, self.boneName, skelStructure)
widget = wdgGen.fromSkelStructure(self.moduleName, self.boneName, skelStructure, editWidget=parent)
widget.unserialize(self.editingItem.get(self.boneName), {})
widget.setParent(parent)
widget.layout().setSpacing(0)
widget.layout().setContentsMargins(0, 0, 0, 0)
QtCore.QTimer.singleShot(1, lambda: widget.lineEdit.setFocus())
return widget
def setRepos(self) -> None:
"""
Called if preloading has finished.
Check if there is more than one repository avaiable
for us.
"""
protoWrap = protocolWrapperInstanceSelector.select(self.module)
assert protoWrap is not None
if len(protoWrap.rootNodes) > 1:
for repo in protoWrap.rootNodes:
d = FileRepoHandler(self.module, repo)
self.addChild(d)
def dropEvent(self, event: QtGui.QDropEvent) -> None:
logger.debug("TreeListWidget.dropEvent")
dataDict = json.loads(
event.mimeData().data("viur/treeDragData").data().decode("UTF-8"))
protoWrap = protocolWrapperInstanceSelector.select(self.realModule)
assert protoWrap is not None
destItem = self.itemAt(event.pos())
if not isinstance(destItem, self.nodeItem):
# Entries have no childs, only nodeItems can have children
return
protoWrap.move(dataDict["nodes"], dataDict["leafs"],
destItem.entryData["key"])
def doDownload(self, targetDir: str, files: List[str],
dirs: List[str]) -> None:
"""Download a list of files and/or directories from the server to the local file-system.
:param targetDir: Local, existing and absolute path
:param files: List of files in this directory which should be downloaded
:param dirs: List of directories (in the directory specified by rootNode+path) which should be downloaded
"""
protoWrap = protocolWrapperInstanceSelector.select(self.getModul())
downloader = protoWrap.download(targetDir, files, dirs)
self.parent().layout().addWidget(DownloadStatusWidget(downloader))
def onInputDialogFinished(self, result): if not result: self.inputDialog = None return protpWrap = protocolWrapperInstanceSelector.select(self.parent().module) assert protpWrap is not None data = self.inputDialog.entry.entryData.copy() data["name"] = result key = data["key"] del data["key"] protpWrap.edit(key, "node", **data) self.inputDialog = None
def onItemDataAvailable(self, item: Dict[str, Any]) -> None: """ Fetching the updated information from the server finished. Start displaying that item. """ protoWrap = protocolWrapperInstanceSelector.select(self.realModule) assert protoWrap is not None if item is None or not item["key"] in self.entryFetches: return self.entryFetches.remove(item["key"]) self.layoutAboutToBeChanged.emit() self.dataCache.append(item) self.layoutChanged.emit()
def onTreeChanged(self, node: str) -> None:
logger.debug("onTreeChanged: %r", node)
if not node:
self.loadData()
if node != self.node: # Not our part of that tree
return
if self.customQueryKey is not None: # We currently display a searchresult:
return
protoWrap = protocolWrapperInstanceSelector.select(self.realModule)
assert protoWrap is not None
res = protoWrap.childrenForNode(self.node)
raise NotImplementedError("check this out again!!!")
self.setDisplayData(res)
def doUpload(self, files: List[str], node: str) -> None:
"""Uploads a list of files to the Server and adds them to the given path on the server.
:param files: List of local filenames including their full, absolute path
:param node: the rootNode which will receive the uploads
"""
logger.debug("doUpload: %r, %r", files, node)
if not files:
return
uploadStatusWidget = UploadStatusWidget()
self.parent().layout().addWidget(uploadStatusWidget)
protoWrap = protocolWrapperInstanceSelector.select(self.getModul())
uploader = protoWrap.upload(files, node)
uploadStatusWidget.setUploader(uploader)
def __init__(self,
module: str,
rootNode: Union[str, None] = None,
node: Union[str, None] = None,
*args: Any,
**kwargs: Any):
"""
@param module: Name of the module to show the elements for
@type module: str
@param rootNode: key of the rootNode which data should be displayed. If None, this widget tries to choose
one.
@type rootNode: str | None
@param path: If given, displaying starts in this path
@type path: String or None
"""
super(TreeListView, self).__init__(*args, **kwargs)
self.module = self.realModule = module
if module.endswith("_rootNode"):
self.realModule = module[:-9]
self.rootNode = rootNode
self.node = node or rootNode
self.customQueryKey = None # As loading is performed in background, they might return results for a dataset
# which isnt displayed anymore
protoWrap = protocolWrapperInstanceSelector.select(self.realModule)
assert protoWrap is not None
protoWrap.entitiesChanged.connect(self.onTreeChanged)
protoWrap.customQueryFinished.connect(self.onCustomQueryFinished)
protoWrap.entitiesChanged.connect(self.onTreeChanged)
protoWrap.entitiesAppended.connect(self.onAppendedData)
self.itemDoubleClicked.connect(self.onItemDoubleClicked)
self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.customContextMenuRequested.connect(
self.onCustomContextMenuRequested)
self.setDragEnabled(True)
self.setAcceptDrops(True)
self.setSortingEnabled(False)
self.setIconSize(QtCore.QSize(*[x - 24 for x in self.gridSizeIcon]))
self.setGridSize(QtCore.QSize(*self.gridSizeIcon))
self.setSelectionMode(self.ExtendedSelection)
if self.rootNode is not None:
self.loadData()
sizePol = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Expanding)
self.setSizePolicy(sizePol)
self.setResizeMode(QtWidgets.QListWidget.Adjust)
self.setViewMode(0)
self.setViewMode(1)
self.itemCache: Dict[str, Any] = dict()
def rebuild(self) -> None:
protoWrap = protocolWrapperInstanceSelector.select(self.realModule)
assert protoWrap is not None
self.clear()
node = self.node
revList = []
while node:
if node not in protoWrap.dataCache:
protoWrap.queryData(node)
return
node = protoWrap.dataCache[node].copy()
revList.append(node)
node = node["parententry"]
for node in revList[::-1]:
aitem = NodeItem(node, self)
self.addItem(aitem)
