def __init__(self, parent=None, schemaModel = None, model = None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
super(ProjectHTMLDlg, self).__init__(parent)
self.setupUi(self)
self.settings = QSettings()
self.schemaModel = schemaModel
self.model = model
self.projectData = model.modelData
self.helper = Helper()
# initialize the header area
dir = self.projectData["GenToDir"]
self.lblOutputDir.setText(dir)
self.lblOutputDir.setToolTip(dir)
# initialize the report generation fields
self.txtTitle.setText(self.projectData["HeaderTitle"])
self.txtHomeTitle.setText(self.projectData["HomePageTitle"])
self.txtAuthor.setText(self.projectData["Author"])
self.txtFooter.setText(self.projectData["FooterTitle"])
self.txtImageFile.setText(self.projectData["IconFile"])
if len(self.projectData.get("IconFile", "")) > 0:
self.loadImage()
def __init__(self,
parent=None,
mode=None,
objectDict=None,
designModel=None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
super(LabelPropertyBox, self).__init__(parent)
self.helper = Helper()
self.setupUi(self)
self.designModel = designModel
self.modelData = self.designModel.modelData
self.objectDict = objectDict
self.mode = mode
#populate ui data from object
self.populateUIfromObject()
if self.mode == "NEW":
# set focus to name
pass
else:
# disable name entry and set focus to description
self.editName.setEnabled(False)
self.editDescription.setFocus()
def __init__(self, parent=None, diagramInstance=None, model=None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
super(IRPropertyBox, self).__init__(parent)
self.appStartup = True
self.mergeTemplate = False
self.parent = parent
self.schemaModel = self.parent.schemaObject
self.helper = Helper()
# this is the RelationInstance object - called generically diagramInstance.
self.diagramInstance = diagramInstance
self.diagramInstance.reloadDictValues()
self.model = model
self.modelData = self.model.modelData
self.rel = None
self.setupUi(self)
# self.appSetToTemplate = False
# self.appSetFromTemplate = False
self.initUI()
self.populateUIfromObject()
self.appStartup = False
self.msg = ""
def __init__(self, parent=None, diagramInstance=None, model=None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
super(INPropertyBox, self).__init__(parent)
self.startUp = True
self.parent = parent
self.schemaModel = self.parent.schemaObject
self.helper = Helper()
self.diagramInstance = diagramInstance
# reload the NodeInstance dictionary values in case they've been changed on another diagram
self.diagramInstance.reloadDictValues()
self.model = model
self.modelData = self.model.modelData
self.node = None
# self.rc = None
self.msg = None
self.formatChanged = False
self.setupUi(self)
self.initUI()
self.populateUIfromObject()
self.loadTemplateDropdown()
self.startUp = False
def __init__(self, parent=None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
super(EditRelDlg, self).__init__(parent)
self.setupUi(self)
self.parent = parent
self.designModel = self.parent.designModel
self.templateDict = self.parent.templateDict
self.neoCon = self.parent.neoCon
self.helper = Helper()
self.rel = None
self.neoID = None
# add edit relationship widet
self.editRel = EditRelWidget(self, templateDict=self.templateDict)
self.editRelLayout = QVBoxLayout(self.frameBody)
self.editRelLayout.setObjectName("editRelLayout")
self.editRelLayout.addWidget(self.editRel)
# finish UI setup
self.txtTitle.setText("Add New Relationship")
self.lastAddNeoID = None
def __init__(self,
parent=None,
mode=None,
objectDict=None,
designModel=None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
super(TPPropertyBox, self).__init__(parent)
self.setupUi(self)
self.parent = parent
self.schemaModel = self.parent.schemaObject
self.settings = QSettings()
self.helper = Helper()
self.designModel = designModel
self.modelData = self.designModel.modelData
if objectDict is None:
self.objectDict = self.designModel.newPathTemplateDict()
else:
self.objectDict = objectDict
self.mode = mode
# get the class that controls the data grid for relationship templates
self.CypherGenPath = CypherGenPath(parent=self,
templateDict=self.objectDict)
# get neocon object for this project page
self.neoCon = NeoDriver(name=self.parent.pageItem.neoConName,
promptPW=self.parent.pageItem.promptPW)
# path treeview setup
self.tvPath.setContextMenuPolicy(Qt.CustomContextMenu)
self.tvPath.customContextMenuRequested.connect(self.openMenu)
self.tvPath.setDragDropMode(QAbstractItemView.DragOnly)
# add the data grid widget.
self.nodeGrid = DataGridWidget(self,
neoCon=self.neoCon,
genCypher=self.CypherGenPath)
self.nodeGridLayout = QVBoxLayout(self.dataTabFrame)
self.nodeGridLayout.setObjectName("nodeGridLayout")
self.nodeGridLayout.addWidget(self.nodeGrid)
self.populatingMetaBox = False
#populate ui data from object
self.populateUIfromObject()
if self.mode == "NEW":
self.txtPathTemplateName.setFocus()
else:
# disable definition fields
self.txtPathTemplateName.setEnabled(False)
def __init__(self, parent=None, curVal=None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
super(FrmPropList, self).__init__(parent)
self.setupUi(self)
self.helper = Helper()
self.curVal = curVal
def __init__(self, parent, relationInstanceDict=None, startNode=None, endNode=None, model=None):
self.helper = Helper()
self.neoTypeFunc = NeoTypeFunc()
self.diagramType = "Instance Relationship"
self.logMsg = None
self.relationInstanceDict = relationInstanceDict
self.parent = parent
self.model = model
self.neoCon = self.model.modelNeoCon
self.relationship = None
# set local variables to what is in the dictionary
if self.relationInstanceDict:
self.relTemplate = self.relationInstanceDict.get("relTemplate", None)
self.relName = self.relationInstanceDict.get("relName", "NoRelationshipName")
self.propList = self.relationInstanceDict.get("properties", [])
self.startNZID = self.relationInstanceDict.get("startNZID", None)
self.endNZID = self.relationInstanceDict.get("endNZID", None)
self.startNode = None
self.endNode = None
if self.relationInstanceDict.get("NZID", None) == None:
self.NZID = str(uuid.uuid4())
else:
self.NZID = self.relationInstanceDict["NZID"]
self.neoID=self.relationInstanceDict.get("neoID", None)
# if no dictionary passed then set defaults
else:
self.relName = "NoRelationshipName"
self.relTemplate = None
self.propList = []
self.NZID = str(uuid.uuid4())
self.neoID=None
self.startNZID = None
self.endNZID = None
self.startNode = None
self.endNode = None
# get start and end node item objects
if not startNode is None:
self.startNode = startNode
self.startNZID = self.startNode.NZID
if not endNode is None:
self.endNode = endNode
self.endNZID = self.endNode.NZID
self.getFormat()
if not self.relationInstanceDict:
self.relationInstanceDict = self.getObjectDict()
def __init__(self, parent=None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
super(ConstraintNodePropUniqueDlg, self).__init__(parent)
self.setupUi(self)
self.parent = parent
self.schemaModel = self.parent.schemaModel
self.helper = Helper()
self.initUi()
def __init__(self, parent=None, parms=None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
super(CypherParmEntryDlg, self).__init__(parent)
self.parent = parent
self.parms = parms
self.helper = Helper()
self.neoTypeFunc = NeoTypeFunc()
self.parmDict = None
self.setupUi(self)
self.initUI()
#load Property grid
for parm in self.parms:
# generate datatype from parm name if possible
try:
if 'pointc' in parm.lower():
dataType = DataType.POINTCARTESIAN.value
elif 'pointg' in parm.lower():
dataType = DataType.POINTWGS84.value
elif 'int' in parm.lower():
dataType = DataType.INT.value
elif 'float' in parm.lower():
dataType = DataType.FLOAT.value
elif 'bool' in parm.lower():
dataType = DataType.BOOLEAN.value
elif 'localdatetime' in parm.lower():
dataType = DataType.LOCALDATETIME.value
elif 'datetime' in parm.lower():
dataType = DataType.DATETIME.value
elif 'date' in parm.lower():
dataType = DataType.DATE.value
elif 'localtime' in parm.lower():
dataType = DataType.LOCALTIME.value
elif 'time' in parm.lower():
dataType = DataType.TIME.value
elif 'pointc' in parm.lower():
dataType = DataType.POINTCARTESIAN.value
elif 'pointg' in parm.lower():
dataType = DataType.POINTWGS84.value
else:
dataType = 'String'
except BaseException as e:
dataType = 'String'
finally:
self.addParm(self.gridParms.model(), parm, dataType, "")
def __init__(self, parent=None, mode=None, roleName=None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
super(EditRoleDlg, self).__init__(parent)
self.setupUi(self)
self.parent = parent
self.roleName = roleName
self.mode = mode
self.helper = Helper()
self.initUI()
def __init__(self, parent=None, fileName=None, fileText=None, mode=None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
super(CypherEditGridWidget, self).__init__(parent)
self.setupUi(self)
self.parent = parent
self.settings = QSettings()
self.initUI()
self.initScintilla()
self.helper = Helper()
self.mode = mode
self.tabType = "CYPHER"
self.tabName = fileName
self.tabIndex = None # this is the index into the tabWidget of the tab this widget is on
self.fileName = fileName
self.fileText = fileText
self.resultSet = None
# create a neocon object for this file tab
self.neoDriver = NeoDriver(name=self.parent.pageItem.neoConName,
promptPW=self.parent.pageItem.promptPW)
# add the data grid widget.
self.dataGridGeneric = DataGridGeneric()
self.dataGrid = DataGridWidget(self,
neoCon=self.neoDriver,
genCypher=self.dataGridGeneric)
self.nodeGridLayout = QVBoxLayout(self.frmDataGrid)
self.nodeGridLayout.setObjectName("nodeGridLayout")
self.nodeGridLayout.setContentsMargins(1, 1, 1, 1)
self.nodeGridLayout.setSpacing(1)
self.nodeGridLayout.addWidget(self.dataGrid)
if self.mode == MODENEW:
if not self.fileText is None:
self.loadText()
if self.mode == MODEEDIT:
self.loadFile()
# position the splitter
self.show(
) # you have to do this to force all the widgets sizes to update
half = int((self.frmEditnGrid.height() / 2))
self.splitter.setSizes([half, half])
def __init__(self, parent=None, mode=None, objectDict=None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
super(NeoConPropertyBox, self).__init__(parent)
self.parent = parent
self.mode = mode
self.objectDict = objectDict
self.helper = Helper()
self.setupUi(self)
self.chkSecureCon.setTristate(False)
self.populateUIfromObject()
def __init__(self, parent=None, objectType=None, objectName=None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
super(DropObjectDlg, self).__init__(parent)
self.setupUi(self)
self.parent = parent
self.objectType = objectType
self.objectName = objectName
self.schemaModel = self.parent.schemaModel
self.helper = Helper()
self.initUi()
def __init__(self, parent=None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
super(ChangeUserPW, self).__init__(parent)
self.setupUi(self)
self.helper = Helper()
self.settings = QSettings()
self.parent = parent
self.editPW.setEchoMode(QLineEdit.Password)
self.editNewPW.setEchoMode(QLineEdit.Password)
self.editRepeatPW.setEchoMode(QLineEdit.Password)
def __init__(self,
neoConName=None,
actionButton=None,
pageWidget=None,
pageWidgetIndex=None):
self.settings = QSettings()
self.helper = Helper()
# the name of the neocon for this page
self.neoConName = neoConName
# see if we need to prompt for the password
self.promptPW = None
self.checkPW()
# the qaction on the menubar
self.actionButton = actionButton
self.pageWidget = pageWidget
self.pageWidgetIndex = pageWidgetIndex
return
def __init__(self, parent=None, mode=None, objectDict = None, designModel = None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
super(FormPropertyBox, self).__init__(parent)
self.setupUi(self)
self.parent = parent
self.schemaModel = self.parent.schemaObject
self.settings = QSettings()
self.helper = Helper()
self.designModel = designModel
self.modelData = self.designModel.modelData
if objectDict is None:
self.objectDict = self.designModel.newFormDict()
else:
self.objectDict = objectDict
self.mode = mode
# path treeview setup
self.tvOutline.setContextMenuPolicy(Qt.CustomContextMenu)
self.tvOutline.customContextMenuRequested.connect(self.openMenu)
self.tvOutline.setDragDropMode(QAbstractItemView.DragOnly)
# add preview widget
self.formPreview = FormMain(self.frmPreview )
self.formPreviewLayout = QVBoxLayout(self.frmPreview)
self.formPreviewLayout.setObjectName("MainFormLayout")
self.formPreviewLayout.addWidget(self.formPreview)
self.populatingMetaBox = False
# position the splitter
self.show() # you have to do this to force all the widgets sizes to update
third = int((self.width() / 3))
self.vSplitter.setSizes([third*2, third])
half = int((self.height() / 2))
self.hSplitter.setSizes([half, half])
#populate ui data from object
self.populateUIfromObject()
def __init__(self, parent=None, neoDriver=None):
super(SchemaModel, self).__init__()
self.settings = QSettings()
self.modelNeoDriver = neoDriver
self.parent = parent
self.helper = Helper()
# model defaults
self.updateTreeView = None
def __init__(self, parent=None, rightClickPos=None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
super(CopyNodeToDiagramDlg, self).__init__(parent)
self.setupUi(self)
self.parent = parent
self.settings = QSettings()
self.rightClickPos = rightClickPos
self.designModel = self.parent.model
self.syncNeoCon = self.designModel.modelNeoCon
self.itemDict = self.parent.itemDict
self.helper = Helper()
self.neoTypeFunc = NeoTypeFunc()
self.nodeGrid = None
# header area
self.txtDiagramName.setText(self.parent.diagramName)
self.txtNeoCon.setText("{} - {}".format(
self.syncNeoCon.name, self.syncNeoCon.neoDict["URL"]))
# load node template dropdown and disable it
dropdownList = []
dropdownList.append("No Template Selected")
dropdownList.extend(
sorted(self.designModel.instanceList("Node Template")))
self.cboNodeTemplates.addItems(dropdownList)
self.rbFilterTemplate.setChecked(True)
# get neocon object for this project page
self.neoCon = NeoDriver(name=self.parent.parent.pageItem.neoConName,
promptPW=self.parent.parent.pageItem.promptPW)
# add the data grid widget.
self.addNodeCypher = AddNodeCypher()
self.nodeGrid = DataGridWidget(self,
neoCon=self.neoCon,
genCypher=self.addNodeCypher)
self.nodeGridLayout = QVBoxLayout(self.frmDataGrid)
self.nodeGridLayout.setObjectName("nodeGridLayout")
self.nodeGridLayout.addWidget(self.nodeGrid)
def __init__(self, parent=None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
super(SyncToDBDlg, self).__init__(parent)
self.setupUi(self)
self.parent = parent
self.objectName = self.parent.diagramName
self.designModel = self.parent.model
self.syncNeoCon = self.designModel.modelNeoCon
self.itemDict = self.parent.itemDict
self.helper = Helper()
self.initPage()
#populate ui data from object
self.populateUIfromObject()
def __init__(self, parent=None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
super(DlgExportCSV, self).__init__(parent)
self.setupUi(self)
self.parent = parent
self.settings = parent.parent.settings
self.helper = Helper()
# add the CSV File widget.
self.CSVWriterWidget = CSVWriterWidget(parent=self)
self.CSVLayout = QVBoxLayout(self.frmCSVWidget)
self.CSVLayout.setObjectName("CSVLayout")
self.CSVLayout.addWidget(self.CSVWriterWidget)
def my_excepthook(type, value, tback):
'''
catch any exception not otherwise handled by the application and show it to the user without crashing the program.
'''
msg = "### {}--{}--{} ###".format(type, value, tback.tb_frame)
clipboard = QApplication.clipboard()
clipboard.setText(msg)
# display error message to the user
helper = Helper()
helper.displayErrMsg(
"Unexpected Error", """
An unexpected error has occured.
Please paste this error message into an email to [email protected] (it's already in the clipboard)
{}
""".format(msg))
# log the error
if logging:
logging.info("An unexpected error has occured. \n {}".format(msg))
def __init__(self, parent=None, pageItem=None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
super(CypherPageWidget, self).__init__(parent)
self.pageType = "CYPHER"
self.settings = QSettings()
self.parent = parent
self.pageItem = pageItem
self.setupUi(self)
self.initUI()
self.helper = Helper()
self.treeViewUpdate.connect(self.populateTree)
########################################################################
# Schema editor setup
########################################################################
self.schemaNeoDriver = NeoDriver(name=self.pageItem.neoConName,
promptPW=self.pageItem.promptPW)
self.schemaModel = SchemaModel(self, neoDriver=self.schemaNeoDriver)
self.refreshSchemaModel()
self.schemaModel.setUpdateTreeViewMethod(
method=self.on_btnRefresh_clicked)
self.tvSchema.setContextMenuPolicy(Qt.CustomContextMenu)
self.tvSchema.customContextMenuRequested.connect(self.openMenu)
self.clearTree()
self.populateTree()
# display a default cypher tab
self.on_btnNew_clicked()
# display an error message if the schema connection doesn't work
rc, msg = self.schemaModel.testSchemaConnection()
if rc == False:
self.helper.displayErrMsg("Connect Schema",
"The Connection Failed: {}".format(msg))
class PageItem():
def __init__(self,
neoConName=None,
actionButton=None,
pageWidget=None,
pageWidgetIndex=None):
self.settings = QSettings()
self.helper = Helper()
# the name of the neocon for this page
self.neoConName = neoConName
# see if we need to prompt for the password
self.promptPW = None
self.checkPW()
# the qaction on the menubar
self.actionButton = actionButton
self.pageWidget = pageWidget
self.pageWidgetIndex = pageWidgetIndex
return
def checkPW(self, ):
'''If the connection is prompt for password, then prompt until the user enters something.
'''
# get the neocon dictionary
neoDict = self.settings.value("NeoCon/connection/{}".format(
self.neoConName))
if not neoDict is None:
if neoDict["prompt"] == "True":
# prompt for a password if needed and save what the user enters
pw = ''
while len(pw) < 1:
pw = self.helper.passwordPrompt(conName=self.neoConName,
conURL=neoDict["URL"])
if not pw is None:
if len(pw) > 0:
# save the encrypted password in the page item so it's ready to be used by any function
self.promptPW = self.helper.putText(pw)
else:
self.helper.displayErrMsg(
"Prompt Password",
"You must enter a password.")
def __init__(self,
parent=None,
schemaModel=None,
model=None,
settings=None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
super(dlgReverseEngineer, self).__init__(parent)
self.parent = parent
self.schemaModel = schemaModel
self.echo = True
self.settings = settings
self.model = model
self.helper = Helper()
self.neoTypeFunc = NeoTypeFunc()
self.myNeoCon = self.model.modelNeoCon
self.setupUi(self)
self.initPage()
def __init__(self, name=None, promptPW=None):
self.name = name
self.settings = QSettings()
self.neoDict = None
self.helper = Helper()
# setup the dictionary that defines this neo4j connection
self.getSavedConnection()
# if we prompted the user for a password, save it in the neocon dictionary
if not promptPW is None:
self.neoDict["password"] = promptPW
# driver used by this NeoDriver object
self.myDriver = None
# session used for unmanaged transaction
self.session = None
# transaction used for unmanaged transaction
self.tx = None
# result object used while consuming query results and saving them to self.resultSet
self.result = None
# persistent result set and summary
self.resultSet = None
self.resultSummary = None
# manage chunking your way thru a result set
self.cursorChunk = None
self.chunkStart = 0 # this is the record number of the first record in the chunk
self.chunkEnd = 0 # this is the record number of the last record in the chunk
self.chunkSize = 10 # some day we'll make this a parameter setting
self.curRecord = 0 # this is the last record retrieved
self.endReached = False
# track query statistics
self.stats = None
# default to true
self.autoCommit = True
# dictionary that gathers up facts about an individual cypher execution.
self.cypherLogDict = {}
def __init__(self, parent=None, neoCon=None, genCypher=None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
super(DataGridWidget, self).__init__(parent)
self.setupUi(self)
self.helper = Helper()
self.neoTypeFunc = NeoTypeFunc()
self.resultSet = None
self.cypher = None
self.parmData = None
self.editParmDict = None
self.genCypher = genCypher
self.templateDict = self.genCypher.templateDict
# the parent widget must supply a neoCon
# this is the NeoDriver instance, but we still use the older neocon variable at this level in the code
self.neoCon = neoCon
self.parent = parent
try:
self.designModel = parent.designModel
except:
self.designModel = None
self.neoCon.setAutoCommit(True)
self.initUI()
# data grid scrolling
self.topRow = 1
# data grid cell selection variables
self.saveIndex = None
self.prevIndex = None
self.saveData = None
def __init__(self, parent=None, templateDict=None):
self.parent = parent
self.templateDict = templateDict
self.type = "Path"
self.helper = Helper()
self.designModel= self.parent.designModel
def __init__(self, parent=None, templateDict=None):
self.parent = parent
self.templateDict = templateDict
self.type = "Relationship"
self.helper = Helper()
class RelTemplateCypher():
def __init__(self, parent=None, templateDict=None):
self.parent = parent
self.templateDict = templateDict
self.type = "Relationship"
self.helper = Helper()
# this determines if the DataGridWidget should call genMatch on a grid refresh or should it suppy it's own cypher
def isGeneric(self, ):
return False
# set which button driven functionality will be enabled
def refreshOK(self, ):
return True
def exportOK(self, ):
return True
def newOK(self, ):
return True
def deleteOK(self, ):
return True
def rowSelect(self, ):
return False
def setNullOK(self, ):
return True
def genDeleteDetach(self, row=None, dataGrid=None):
model = dataGrid.model()
# get the relID
self.relID = None
for header in range(model.columnCount()):
if model.headerData(header, Qt.Horizontal,
Qt.DisplayRole) == "rel_id":
self.relID = model.item(row, header).data(Qt.EditRole)
if not self.relID is None:
p1 = self.relID
cypher = " ".join(
["match (f)-[r]->(t) \n", "where id(r) = {} \n",
"delete r"]).format(p1)
return cypher
def genUpdateProp(self, updateIndex=None, dataGrid=None):
cypher = ""
rc = True
model = dataGrid.model()
# get the RELATIONSHIP ID
self.relID = None
for header in range(model.columnCount()):
if model.headerData(header, Qt.Horizontal,
Qt.DisplayRole) == "rel_id":
self.relID = model.item(updateIndex.row(),
header).data(Qt.EditRole)
if self.relID is None:
return False, "Relationship ID not found."
try:
self.updateData = model.item(
updateIndex.row(), updateIndex.column()).data(Qt.EditRole)
self.updateProp = model.headerData(updateIndex.column(),
Qt.Horizontal, Qt.DisplayRole)
# get the correct neo4j type
neoType = model.item(updateIndex.row(),
updateIndex.column()).data(Qt.UserRole + 1)
# if the datatype comes back unknown then generate cypher comment
if neoType == 'Unknown':
cypher = "Can't update unknown datatype, correct datatype in relationship template."
rc = False
else:
# generate the correct syntax that you set the property equal to
self.setEqualTo = self.helper.genPropEqualTo(
dataValue=self.updateData, neoType=neoType)
p1 = self.relID
p2 = self.updateProp
p3 = self.setEqualTo
cypher = " ".join([
"match (f)-[r]->(t) \n", "where id(r) = {} \n",
"set r.{} = {}"
]).format(p1, p2, p3)
rc = True
except BaseException as e:
# something went wrong
cypher = "Error generating cypher: {}".format(repr(e))
rc = False
finally:
return rc, cypher
def genRemoveProp(self, updateIndex=None, dataGrid=None):
model = dataGrid.model()
cypher = None
self.relID = None
# get the relID
for header in range(model.columnCount()):
if model.headerData(header, Qt.Horizontal,
Qt.DisplayRole) == "rel_id":
self.relID = model.item(updateIndex.row(),
header).data(Qt.EditRole)
if self.relID is None:
return cypher
# get the property name
self.updateProp = model.headerData(updateIndex.column(), Qt.Horizontal,
Qt.DisplayRole)
# MAKE SURE IT ISN'T A REQUIRED PROPERTY
for prop in self.templateDict["properties"]:
if prop[PROPERTY] == self.updateProp:
if prop[PROPREQ] != Qt.Checked:
p1 = self.relID
p2 = self.updateProp
cypher = "match (f)-[r]->(t) \n where id(r) = {} \n remove r.{} ".format(
p1, p2)
else:
self.helper.displayErrMsg(
"Set Null",
"Property {} is required by the Relationship Template. Cannot remove this property."
.format(self.updateProp))
return cypher
def genMatch(self):
'''
Generate the match cypher statement that the data grid will use to refresh the grid.
Generate the editParmDict dictionary that tells the data grid how to handle each column in the result set
'''
# fromNodeVar = "f"
# toNodeVar = "t"
relVar = "r"
p1 = self.templateDict["relname"]
p3 = self.genReturnPropList(relVar)
if len(p3) > 1:
p2 = ","
else:
p2 = ""
cypher = " ".join([
"match (f)-[r]->(t) \n",
"where type(r) = '{}' \n",
"return id(f) as From_NodeID, \n",
"id(t) as To_NodeID, \n",
"id(r) as rel_id, \n",
"type(r) as rel_name {} \n",
"{} \n",
]).format(p1, p2, p3)
#PROP, REQLBL, OPTLBL, NODEID, RELID, NODE, RELATIONSHIP, RELNAME
editParmDict = []
editParmDict.append([NODEID, False])
editParmDict.append([NODEID, False])
editParmDict.append([RELID, False])
editParmDict.append([RELNAME, False])
for prop in self.templateDict["properties"]:
editParmDict.append([PROP, True])
return cypher, editParmDict
def genReturnPropList(self, nodeName):
'return all properties in the template'
propList = ""
propList = ",".join(nodeName + "." + x[PROPERTY] + " as " +
x[PROPERTY] + " \n"
for x in self.templateDict["properties"])
return propList
def genSetPropList(self, nodeName):
'return a set statement for each property that has a default value (i.e. required)'
setPropList = []
if not self.templateDict is None:
for prop in self.templateDict["properties"]:
# if the property has a default value then generate the set statement.
if prop[PROPDEF] != "":
# generate the correct syntax that you set the property equal to
setEqualTo = self.helper.genPropEqualTo(
dataValue=prop[PROPDEF], neoType=prop[DATATYPE])
setPropList.append("set {}.{} = {}".format(
nodeName, prop[PROPERTY], setEqualTo))
setProps = " \n ".join(setProp for setProp in setPropList)
return setProps
