def getProposalsListWithStatus(self, proposalStatus=None):
self.ProposalsLayer = self.tableNames.setLayer("Proposals")
query = ''
if proposalStatus is not None:
query = ("\"ProposalStatusID\" = {proposalStatus}").format(
proposalStatus=str(proposalStatus))
TOMsMessageLog.logMessage("In __getProposalsListWithStatus. query: " +
str(query),
level=Qgis.Info)
request = QgsFeatureRequest().setFilterExpression(query)
proposalsList = []
for proposalDetails in self.ProposalsLayer.getFeatures(request):
proposalsList.append([
proposalDetails["ProposalID"],
proposalDetails["ProposalTitle"],
proposalDetails["ProposalStatusID"],
proposalDetails["ProposalOpenDate"], proposalDetails
])
return proposalsList
def prepareLayerSet(self):
# Function to create group of layers to be in Transaction for changing proposal
# self.tableNames = TOMSLayers(self.iface)
# self.tableNames.getLayers()
TOMsMessageLog.logMessage("In TOMsTransaction. prepareLayerSet: ",
level=Qgis.Info)
# idxRestrictionsLayerName = self.tableNames.RESTRICTIONLAYERS.fields().indexFromName("RestrictionLayerName")
# self.setTransactionGroup = [self.tableNames.PROPOSALS]
# self.setTransactionGroup.append(self.tableNames.RESTRICTIONS_IN_PROPOSALS)
# self.setTransactionGroup.append(self.tableNames.MAP_GRID)
# self.setTransactionGroup.append(self.tableNames.TILES_IN_ACCEPTED_PROPOSALS)
for layer in self.TOMsTransactionList:
# currRestrictionLayerName = layer[idxRestrictionsLayerName]
# restrictionLayer = QgsProject.instance().mapLayersByName(currRestrictionLayerName)[0]
self.setTransactionGroup.append(self.tableNames.setLayer(layer))
TOMsMessageLog.logMessage(
"In TOMsTransaction.prepareLayerSet. Adding " + layer,
level=Qgis.Info)
def takePhoto(self, path_absolute):
TOMsMessageLog.logMessage("In cvCamera::takePhoto ... ",
level=Qgis.Info)
# Save frame to file
fileName = 'Photo_{}.png'.format(
datetime.datetime.now().strftime('%Y%m%d_%H%M%S%z'))
newPhotoFileName = os.path.join(path_absolute, fileName)
TOMsMessageLog.logMessage("Saving photo: file: " + newPhotoFileName,
level=Qgis.Info)
writeStatus = cv2.imwrite(newPhotoFileName, self.frame)
if writeStatus is True:
reply = QMessageBox.information(None, "Information",
"Photo captured.", QMessageBox.Ok)
self.photoTaken.emit(newPhotoFileName)
else:
reply = QMessageBox.information(None, "Information",
"Problem taking photo.",
QMessageBox.Ok)
self.photoTaken.emit()
# Now stop camera (and display image)
self.cap.release()
"""def fps(self):
def __init__(self, iface, TOMsToolBar):
#def __init__(self, iface, TOMsMenu, proposalsManager):
# Save reference to the QGIS interface
self.iface = iface
self.canvas = self.iface.mapCanvas()
self.TOMsToolBar = TOMsToolBar
self.actionProposalsPanel = QAction(
QIcon(":/plugins/TOMs/resources/TOMsStart.png"),
QCoreApplication.translate("MyPlugin", "Start TOMs"),
self.iface.mainWindow())
self.actionProposalsPanel.setCheckable(True)
self.TOMsToolBar.addAction(self.actionProposalsPanel)
self.actionProposalsPanel.triggered.connect(self.onInitProposalsPanel)
self.newProposalRequired = False
self.proposalsManager = TOMsProposalsManager(self.iface)
self.tableNames = self.proposalsManager.tableNames
# Now set up the toolbar
self.RestrictionTools = manageRestrictionDetails(
self.iface, self.TOMsToolBar, self.proposalsManager)
self.RestrictionTools.disableTOMsToolbarItems()
self.searchBar = searchBar(self.iface, self.TOMsToolBar,
self.proposalsManager)
self.searchBar.disableSearchBar()
TOMsMessageLog.logMessage("Finished proposalsPanel init ...",
level=Qgis.Warning)
def displayPixmapUpdated(self, FIELD, pixmap):
TOMsMessageLog.logMessage("In utils::displayPixmapUpdated ... ",
level=Qgis.Info)
FIELD.setPixmap(pixmap)
FIELD.setScaledContents(True)
QApplication.processEvents(
) # processes the event queue - https://stackoverflow.com/questions/43094589/opencv-imshow-prevents-qt-python-crashing
def __init__(self, proposalsManager, layerID, restriction, restrictionID):
#def __init__(self, proposalsManager, layerID=None, restriction=None, restrictionID=None):
super().__init__()
TOMsMessageLog.logMessage(
"In TOMsProposalElement.init. Creating Proposal Element ... " +
str(layerID) + ";" + str(restriction),
level=Qgis.Info)
self.proposalsManager = proposalsManager
self.currProposal = self.proposalsManager.currentProposalObject()
self.tableNames = self.proposalsManager.tableNames
self.layerID = layerID
self.setThisLayer()
if restriction is not None:
self.thisElement = restriction
self.thisRestrictionID = restrictionID
elif restrictionID is not None:
self.setElement(restrictionID)
TOMsMessageLog.logMessage(
"In factory. Creating Proposal Element ... " +
str(self.thisElement),
level=Qgis.Info)
def closeTOMsTools(self):
# actions when the Proposals Panel is closed or the toolbar "start" is toggled
TOMsMessageLog.logMessage("In closeTOMsTools. Deactivating ...",
level=Qgis.Info)
# TODO: Delete any objects that are no longer needed
self.proposalTransaction.rollBackTransactionGroup()
del self.proposalTransaction # There is another call to this function from the dock.close()
# Now disable the items from the Toolbar
self.RestrictionTools.disableTOMsToolbarItems()
self.searchBar.disableSearchBar()
self.actionProposalsPanel.setChecked(False)
# Now close the proposals panel
self.dock.close()
# Now clear the filters
self.proposalsManager.clearRestrictionFilters()
pass
def setupCompleter(self):
# set up string list for completer
TOMsMessageLog.logMessage("In setupCompleter:", level=Qgis.Info)
lookupStringSet = set()
# https://gis.stackexchange.com/questions/155805/qstringlist-error-in-plugin-of-qgis-2-10
self.GazetteerLayer = QgsProject.instance().mapLayersByName("StreetGazetteerRecords")[0]
for row in self.GazetteerLayer.getFeatures():
streetName = row.attribute("Descriptor_")
locality = row.attribute("Locality")
nameString = streetName
if locality:
nameString = nameString + ", " + locality
if nameString:
TOMsMessageLog.logMessage("In setupCompleter: nameString: " + nameString, level=Qgis.Info)
lookupStringSet.add(nameString)
# self.gazetteerStringList.append((nameString))
completer = QCompleter()
completer.setCaseSensitivity(Qt.CaseInsensitive)
completer.setFilterMode(Qt.MatchContains)
self.searchTextbox.setCompleter(completer)
model = QStringListModel()
completer.setModel(model)
model.setStringList(self.gazetteerStringList)
model.setStringList(sorted(lookupStringSet))
def initSearchBar(self):
TOMsMessageLog.logMessage("In initSearchBox:", level=Qgis.Info)
self.initialPass = True
self.gazetteerStringList = []
# Create & add a textbox
self.searchTextbox = QLineEdit(self.iface.mainWindow())
# Set width
self.searchTextbox.setFixedWidth(250)
# Add textbox to toolbar
self.txtEntry = self.TOMsSearchBar.addWidget(self.searchTextbox)
#self.txtEntry.setToolTip(self.tr(u'Enter Street Name'))
self.searchTextbox.textChanged.connect(self.doLookupItem)
self.actionGoToItem = QAction(QIcon(":/plugins/TOMs/resources/magnifyingGlass.png"),
QCoreApplication.translate("MyPlugin", "Start TOMs"), self.iface.mainWindow())
self.TOMsSearchBar.addAction(self.actionGoToItem)
self.actionGoToItem.triggered.connect(self.doGoToItem)
self.actionGoToItem.setCheckable(True)
# Add in details of the Instant Print plugin
self.toolButton = QToolButton(self.iface.mainWindow())
self.toolButton.setIcon(QIcon(":/plugins/TOMs/InstantPrint/icons/icon.png"))
#self.toolButton.setToolTip(self.tr("Instant Print"))
self.toolButton.setCheckable(True)
self.printButtonAction = self.TOMsSearchBar.addWidget(self.toolButton)
"""self.actionInstantPrint = QAction(QIcon(":/plugins/TOMs/InstantPrint/icons/icon.png"),
QCoreApplication.translate("Print", "Print"), self.iface.mainWindow())"""
self.toolButton.toggled.connect(self.__enablePrintTool)
self.iface.mapCanvas().mapToolSet.connect(self.__onPrintToolSet)
def copyRestriction(self, currFeature, newFeature):
TOMsMessageLog.logMessage("In TOMsNodeTool:copyRestriction",
level=Qgis.Info)
newFeatureFieldMap = newFeature.fields()
currFeatureFieldMap = currFeature.fields()
for field in newFeature.fields():
fieldName = field.name()
idx_newFeature = newFeatureFieldMap.indexFromName(field.name())
# see if can find same field name ... adn set
idx_currFeature = currFeatureFieldMap.indexFromName(fieldName)
if idx_currFeature >= 0:
if not newFeature.setAttribute(
idx_newFeature,
currFeature.attribute(idx_currFeature)):
reply = QMessageBox.information(
None, "Information",
"Problem adding: {}".format(field.name()),
QMessageBox.Ok)
return None
# set new restriction id and geometry id
newRestrictionID = str(uuid.uuid4())
idxRestrictionID = newFeature.fields().indexFromName("RestrictionID")
newFeature[idxRestrictionID] = newRestrictionID
idxGeometryID = newFeature.fields().indexFromName("GeometryID")
newFeature[idxGeometryID] = None
# copy geometry ...
newFeature.setGeometry(QgsGeometry(currFeature.geometry()))
return newFeature
def disableSearchBar(self):
TOMsMessageLog.logMessage("In disableSearchBar", level=Qgis.Info)
self.initialPass = True
self.actionGoToItem.setEnabled(False)
self.toolButton.setEnabled(False)
self.searchTextbox.textChanged.disconnect(self.doLookupItem)
def changeLayerForFeature(self, currLayer, currFeature):
status = False
sameGeomTypeLayerList = self.getSameGeomTypeLayerList(
currLayer, currFeature)
TOMsMessageLog.logMessage(
"In setNewLayerForFeature: sameGeomTypeLayerList: {}".format(
sameGeomTypeLayerList),
level=Qgis.Info)
surveyDialog = QInputDialog()
surveyDialog.setLabelText("Please confirm new layer for this feature ")
surveyDialog.setComboBoxItems(sameGeomTypeLayerList)
surveyDialog.setTextValue(currLayer.name())
if surveyDialog.exec_() == QDialog.Accepted:
newLayerName = surveyDialog.textValue()
TOMsMessageLog.logMessage(
"In setNewLayerForFeature: {}".format(newLayerName),
level=Qgis.Info)
if currLayer.name() != newLayerName:
newLayer = QgsProject.instance().mapLayersByName(
newLayerName)[0]
reply = QMessageBox.information(
None, "Information", "Setting {} to layer {}".format(
currFeature.attribute("GeometryID"), newLayer.name()),
QMessageBox.Ok)
status = self.moveFeatureToNewLayer(currLayer, currFeature,
newLayer)
return status
def getLoadingRestrictionLabelText(feature, parent):
# Returns the text to label the feature
#TOMsMessageLog.logMessage("In getLoadingRestrictionLabelText:", level=Qgis.Info)
try:
waitingText, loadingText = generateGeometryUtils.getWaitingLoadingRestrictionLabelText(
feature)
except:
TOMsMessageLog.logMessage('getLoadingRestrictionLabelText',
level=Qgis.Info)
exc_type, exc_value, exc_traceback = sys.exc_info()
TOMsMessageLog.logMessage(
'getLoadingRestrictionLabelText: error in expression function: ' +
str(repr(traceback.extract_tb(exc_traceback))),
level=Qgis.Info)
"""TOMsMessageLog.logMessage(
"In getLoadingRestrictionLabelText ****:" + " Waiting: " + str(waitingText) + " Loading: " + str(loadingText),
level=Qgis.Info)"""
if loadingText:
#labelText = "No Loading: " + loadingText
labelText = loadingText
#TOMsMessageLog.logMessage("In getLoadingRestrictionLabelText: passing " + str(labelText), level=Qgis.Info)
return labelText
return None
def pointInPoly(layerName, refColumn, defaultValue, geom, feature, parent):
# attempt to make a generic point in poly function ...
TOMsMessageLog.logMessage("In pointInPoly", level=Qgis.Warning)
# Get the reference layer
try:
refLayer = QgsProject.instance().mapLayersByName(layerName)[0]
except Exception as e:
refLayer = None
if refLayer:
TOMsMessageLog.logMessage("In pointInPoly. ref layer found ... ",
level=Qgis.Warning)
# TODO: ensure refLayer is polygon
# TODO: deal with different geom types for the incoming geom. For the moment assume a point
for poly in refLayer.getFeatures():
if poly.geometry().intersects(
geom): # take the first intersecting poly
#TOMsMessageLog.logMessage("In getPolygonForRestriction. feature found", level=Qgis.Info)
return poly.attribute(refColumn)
return defaultValue
def __getRestrictionsInProposalForLayerForAction(self,
layerID,
actionOnAcceptance=None):
# Will return a list of restrictions within a Proposal subject to actionOnAcceptance
self.RestrictionsInProposalsLayer = self.tableNames.setLayer(
"RestrictionsInProposals")
query = (
"\"ProposalID\" = {proposalID} AND \"RestrictionTableID\" = {layerID}"
).format(proposalID=str(self.thisProposalNr), layerID=str(layerID))
if actionOnAcceptance is not None:
query = (
"{query} AND \"ActionOnProposalAcceptance\" = {actionOnAcceptance}"
).format(query=query, actionOnAcceptance=str(actionOnAcceptance))
TOMsMessageLog.logMessage(
"In __getRestrictionsInProposalForLayerForAction. query: " +
str(query),
level=Qgis.Info)
request = QgsFeatureRequest().setFilterExpression(query)
restrictionList = []
for restrictionInProposalDetails in self.RestrictionsInProposalsLayer.getFeatures(
request):
restrictionList.append([
restrictionInProposalDetails["RestrictionID"],
restrictionInProposalDetails
])
return restrictionList
def showRestrictionDetails(self, closestLayer, closestFeature):
TOMsMessageLog.logMessage("In showRestrictionDetails ... Layer: " +
str(closestLayer.name()),
level=Qgis.Info)
#self.showRestrictionMapTool.notifyFeatureFound.disconnect(self.showRestrictionDetails)
# TODO: could improve ... basically check to see if transaction in progress ...
if closestLayer.isEditable() == True:
if closestLayer.commitChanges() == False:
reply = QMessageBox.information(
None, "Information", "Problem committing changes" +
str(closestLayer.commitErrors()), QMessageBox.Ok)
else:
TOMsMessageLog.logMessage(
"In showRestrictionDetails: changes committed",
level=Qgis.Info)
status = self.iface.activeLayer().startEditing()
dialog = self.iface.getFeatureForm(closestLayer, closestFeature)
#self.TOMsUtils.setupRestrictionDialog(self.dialog, closestLayer, closestFeature)
self.setupFieldRestrictionDialog(dialog, closestLayer, closestFeature)
dialog.show()
def setRevisionNr(self, value):
TOMsMessageLog.logMessage("In TOMsTile:setRevisionNr newRevisionNr: " +
str(value),
level=Qgis.Info)
#self.thisTile[self.idxRevisionNr] = value
self.tilesLayer.changeAttributeValue(self.thisTile.id(),
self.idxRevisionNr, value)
def enableTOMsToolbarItems(self, restrictionTransaction):
TOMsMessageLog.logMessage("In enableTOMsToolbarItems", level=Qgis.Info)
self.actionSelectRestriction.setEnabled(True)
self.actionRestrictionDetails.setEnabled(True)
self.actionCreateBayRestriction.setEnabled(True)
self.actionCreateLineRestriction.setEnabled(True)
self.actionCreatePolygonRestriction.setEnabled(True)
self.actionCreateSignRestriction.setEnabled(True)
self.actionRemoveRestriction.setEnabled(True)
self.actionEditRestriction.setEnabled(True)
self.actionSplitRestriction.setEnabled(True)
self.actionCreateConstructionLine.setEnabled(True)
# set up a Transaction object
# self.tableNames = TOMSLayers(self.iface)
# self.tableNames.getLayers()
self.restrictionTransaction = restrictionTransaction
"""self.proposalsManager.TOMsToolChanged.connect(
functools.partial(self.restrictionTransaction.commitTransactionGroup, self.tableNames.PROPOSALS))"""
#self.iface.mapCanvas().mapToolSet.connect(self.unCheckNodeTool)
pass
def initialiseProposal(self):
self.thisProposal = QgsFeature(self.proposalsLayer.fields())
self.thisProposal.setGeometry(QgsGeometry())
#self.proposalsLayer.addFeature(self.thisProposal) # TH (added for v3)
"""self.setProposalTitle('') #str(uuid.uuid4())
self.setProposalOpenDate = self.proposalsManager.date()
self.setProposalCreateDate = self.proposalsManager.date()
self.setProposalStatusID = ProposalStatus.IN_PREPARATION"""
self.thisProposal[self.idxProposalTitle] = '' #str(uuid.uuid4())
self.thisProposal[self.idxCreateDate] = self.proposalsManager.date()
self.thisProposal[self.idxOpenDate] = self.proposalsManager.date()
self.thisProposal[
self.idxProposalStatusID] = ProposalStatus.IN_PREPARATION
self.proposalsLayer.addFeature(self.thisProposal) # TH (added for v3)
TOMsMessageLog.logMessage(
"In TOMsProposal:createProposal - attributes: (fid=" +
str(self.thisProposal.id()) + ") " +
str(self.thisProposal.attributes()),
level=Qgis.Info)
return self
def doAddGPSLocation(self):
# need to have a addPointFromGPS function within each tool
TOMsMessageLog.logMessage("In doAddGPSLocation", level=Qgis.Info)
if self.gpsConnection:
if self.curr_gps_location:
try:
status = self.createRestrictionMapTool.addPointFromGPS(
self.curr_gps_location, self.curr_gps_info)
except Exception as e:
TOMsMessageLog.logMessage(
"In doAddGPSLocation: Problem adding gnss location: {}"
.format(e),
level=Qgis.Warning)
reply = QMessageBox.information(
self.iface.mainWindow(), "Error",
"Problem adding gnss location ... ", QMessageBox.Ok)
else:
reply = QMessageBox.information(self.iface.mainWindow(),
"Information",
"No position found ...",
QMessageBox.Ok)
else:
reply = QMessageBox.information(
self.iface.mainWindow(), "Information",
"You need to activate the tool first ...", QMessageBox.Ok)
def onDateChanged(self):
TOMsMessageLog.logMessage("In onDateChanged.", level=Qgis.Info)
date = self.proposalsManager.date()
self.dock.filterDate.setDate(date)
""" onChangeProposalStatus(self):
TOMsMessageLog.logMessage("In onChangeProposalStatus. Proposed status: " + str(self.Proposals.fields().indexFromName("ProposalStatusID")), level=Qgis.Info)
# check to see if the proposal is "Accepted"
acceptProposal = False
newProposalStatus = int(self.Proposals.fields().indexFromName("ProposalStatusID"))
if newProposalStatus == 1: # should be 2 but with list ...
# if so, check to see if this was intended
reply = QMessageBox.question(self.iface.mainWindow(), 'Confirm changes to Proposal',
'Are you you want to accept this proposal?. Accepting will make all the proposed changes permanent.', QMessageBox.Yes, QMessageBox.No)
if reply == QMessageBox.Yes:
# make the changes permanent
acceptProposal = True
# bring the Proposals dislog back to the front
self.dlg.activateWindow()
return acceptProposal"""
"""def getRestrictionLayerTableID(self, currRestLayer):
def gpsErrorEncountered(self, e):
TOMsMessageLog.logMessage(
"In enableTools - GPS connection has error {}".format(e),
level=Qgis.Warning)
"""self.actionCreateRestriction.setEnabled(False)
self.actionAddGPSLocation.setEnabled(False)"""
self.disableGnssToolbarItem()
def onAttributeChangedClass2_local(self, currFeature, layer, fieldName,
value):
#self.TOMsUtils.onAttributeChangedClass2(currFeature, layer, fieldName, value)
TOMsMessageLog.logMessage(
"In field:FormOpen:onAttributeChangedClass 2 - layer: " +
str(layer.name()) + " (" + fieldName + "): " + str(value),
level=Qgis.Info)
# self.currRestriction.setAttribute(fieldName, value)
try:
currFeature[layer.fields().indexFromName(fieldName)] = value
#currFeature.setAttribute(layer.fields().indexFromName(fieldName), value)
except Exception as e:
reply = QMessageBox.information(
None, "Error",
"onAttributeChangedClass2. Update failed for: " +
str(layer.name()) + " (" + fieldName + "): " + str(value),
QMessageBox.Ok) # rollback all changes
self.storeLastUsedDetails(layer.name(), fieldName, value)
return
def __init__(self, iface, layer):
TOMsMessageLog.logMessage(("In CreatePointTool - init."), level=Qgis.Info)
if layer.geometryType() == 0: # PointGeometry:
captureMode = (CreateRestrictionTool.CapturePoint)
else:
TOMsMessageLog.logMessage(("In CreateRestrictionTool - No geometry type found. EXITING ...."), level=Qgis.Warning)
return
QgsMapToolCapture.__init__(self, iface.mapCanvas(), iface.cadDockWidget(), captureMode)
FieldRestrictionTypeUtilsMixin.__init__(self, iface)
# TODO: change pointer type so that know in this tool
self.iface = iface
self.canvas = iface.mapCanvas()
self.currLayer = layer
self.lastPoint = None
self.setAutoSnapEnabled(True)
self.tableNames = TOMsLayers(self.iface)
self.TOMsConfigFileObject = TOMsConfigFile()
self.TOMsConfigFileObject.initialiseTOMsConfigFile()
self.tableNames.getLayers(self.TOMsConfigFileObject)
def getLine(self, AzimuthToCentreLine=None):
TOMsMessageLog.logMessage("In getLine ... ", level=Qgis.Info)
if AzimuthToCentreLine is None:
AzimuthToCentreLine = self.currAzimuthToCentreLine
return self.getShape(self.BayOffsetFromKerb, AzimuthToCentreLine)
def errorInTransaction(self, errorMsg):
reply = QMessageBox.information(
None, "Error",
"TOMsTransaction:Proposal changes failed: " + errorMsg,
QMessageBox.Ok)
TOMsMessageLog.logMessage("In errorInTransaction: " + errorMsg,
level=Qgis.Warning)
def getFrame(self):
""" Camera code """
# TOMsMessageLog.logMessage("In cvCamera::getFrame ... ", level=Qgis.Info)
ret, self.frame = self.cap.read(
) # return a single frame in variable `frame`
if ret == True:
# Need to change from BRG (cv::mat) to RGB image
cvRGBImg = cv2.cvtColor(self.frame, cv2.COLOR_BGR2RGB)
qimg = QImage(cvRGBImg.data, cvRGBImg.shape[1], cvRGBImg.shape[0],
QImage.Format_RGB888)
# Now display ...
pixmap = QPixmap.fromImage(qimg)
self.changePixmap.emit(pixmap)
else:
TOMsMessageLog.logMessage(
"In cvCamera::useCamera: frame not returned ... ",
level=Qgis.Info)
self.closeCamera.emit()
def getProposalElement(proposalsManager, proposalElementType, restriction,
RestrictionID):
TOMsMessageLog.logMessage("In factory. getProposalElement ... " +
str(proposalElementType) + ";" +
str(restriction),
level=Qgis.Info)
try:
if proposalElementType == RestrictionLayers.BAYS:
return Bay(proposalsManager, proposalElementType, restriction,
RestrictionID)
elif proposalElementType == RestrictionLayers.LINES:
return Line(proposalsManager, proposalElementType, restriction,
RestrictionID)
elif proposalElementType == RestrictionLayers.SIGNS:
return Sign(proposalsManager, proposalElementType, restriction,
RestrictionID)
elif proposalElementType == RestrictionLayers.RESTRICTION_POLYGONS:
return Sign(proposalsManager, proposalElementType, restriction,
RestrictionID)
# return RestrictionPolygonFactory.getProposalElement(proposalElementType, restrictionLayer, RestrictionID)
elif proposalElementType == RestrictionLayers.CPZS:
return CPZ(proposalsManager, proposalElementType, restriction,
RestrictionID)
elif proposalElementType == RestrictionLayers.PTAS:
return PTA(proposalsManager, proposalElementType, restriction,
RestrictionID)
raise AssertionError("Restriction Type NOT found")
except AssertionError as _e:
TOMsMessageLog.logMessage(
"In ProposalElementFactory. TYPE not found or something else ... ",
level=Qgis.Info)
def useCamera(self, START_CAMERA_BUTTON, TAKE_PHOTO_BUTTON, FIELD):
TOMsMessageLog.logMessage("In formCamera::useCamera ... ",
level=Qgis.Info)
self.START_CAMERA_BUTTON = START_CAMERA_BUTTON
self.TAKE_PHOTO_BUTTON = TAKE_PHOTO_BUTTON
self.FIELD = FIELD
self.START_CAMERA_BUTTON.clicked.disconnect()
self.currButtonColour = self.START_CAMERA_BUTTON.palette().button(
).color()
self.START_CAMERA_BUTTON.setStyleSheet('QPushButton {color: red;}')
self.START_CAMERA_BUTTON.setText('Close Camera')
self.START_CAMERA_BUTTON.clicked.connect(self.endCamera)
""" Camera code """
self.camera.changePixmap.connect(self.displayFrame)
self.camera.closeCamera.connect(self.endCamera)
self.TAKE_PHOTO_BUTTON.setEnabled(True)
self.TAKE_PHOTO_BUTTON.clicked.connect(
functools.partial(self.camera.takePhoto, self.path_absolute))
self.camera.photoTaken.connect(self.checkPhotoTaken)
self.photoTaken = False
TOMsMessageLog.logMessage(
"In formCamera::useCamera: starting camera ... ", level=Qgis.Info)
self.camera.startCamera()
def getCurrentRestrictionsForLayerAtDate(self, layerID, dateString=None):
if not dateString:
dateString = self.date()
dateString = self.__date.toString('yyyy-MM-dd')
dateChoosenFormatted = "'{dateString}'".format(dateString=dateString)
filterString = u'"OpenDate" \u003C\u003D to_date({dateChoosenFormatted}) AND (("CloseDate" \u003E to_date({dateChoosenFormatted}) OR "CloseDate" IS NULL))'.format(
dateChoosenFormatted=dateChoosenFormatted)
thisLayer = self.getRestrictionLayerFromID(layerID)
request = QgsFeatureRequest().setFilterExpression(filterString)
TOMsMessageLog.logMessage(
"In ProposalsManager:getCurrentRestrictionsForLayerAtDate. Layer: "
+ thisLayer.name() + " Filter: " + filterString,
level=Qgis.Info)
restrictionList = []
for currentRestrictionDetails in thisLayer.getFeatures(request):
TOMsMessageLog.logMessage(
"In ProposalsManager:getCurrentRestrictionsForLayerAtDate. Layer: "
+ thisLayer.name() + " restrictionID: " +
str(currentRestrictionDetails["RestrictionID"]),
level=Qgis.Info)
currRestriction = ProposalElementFactory.getProposalElement(
self, layerID, currentRestrictionDetails,
currentRestrictionDetails["RestrictionID"])
restrictionList.append(
[currentRestrictionDetails["RestrictionID"], currRestriction])
return restrictionList
