def query(self):
"""
Returns the query instance for this widget.
:return <orb.Query> || <orb.QueryCompound>
"""
queryWidget = self.queryWidget()
# check to see if there is an active container for this widget
container = queryWidget.containerFor(self)
if container:
return container.query()
elif QueryCompound.typecheck(self._query):
return self._query
# generate a new query from the editor
column = self.uiColumnDDL.currentSchemaPath()
plugin = self.currentPlugin()
editor = self.editor()
op = self.uiOperatorDDL.currentText()
if column and plugin:
query = Query(column)
plugin.setupQuery(query, op, editor)
return query
else:
return Query()
def query(self):
"""
Builds the query for this quick filter.
:return <orb.Query>
"""
output = Query()
for column, op, plugin, editor in self._plugins:
query = Query(column)
if plugin.setupQuery(query, op, editor):
output &= query
return output
def dragQuery(self):
"""
Returns the drag query that is assigned to this record item.
:return <orb.Query>
"""
return Q.fromXmlString(self.dragData('application/x-query'))
def setQuery( self, query ):
"""
Assigns the query for this widget, loading the query builder tree with
the pertinent information.
:param query | <Query> || <QueryCompound> || None
"""
tree = self.uiQueryTREE
tree.blockSignals(True)
tree.setUpdatesEnabled(False)
tree.clear()
# assign a top level query item
if ( Q.typecheck(query) and not query.isNull() ):
XQueryItem(tree, query)
# assign a top level query group
elif ( QueryCompound.typecheck(query) and not query.isNull() ):
op_name = QueryCompound.Op[query.operatorType()].lower()
for i, sub_query in enumerate(query.queries()):
if ( i ):
XJoinItem(tree, op_name)
XQueryItem(tree, sub_query)
tree.resizeToContents()
tree.setUpdatesEnabled(True)
tree.blockSignals(False)
def applyQuery(self):
"""
Sets the query for this widget from the quick query text builder.
"""
query = Q.fromString(str(self.uiQueryTXT.text()))
self.setQuery(query)
self.uiQueryTXT.setText('')
def collect_query_info(model, request):
"""
Processes the inputed request object for search terms and parameters.
:param request | <pyramid.request.Request>
:return (<orb.LookupOptions>, <orb.DatabaseOptions>, <str> search terms, <dict> orignal options)
"""
params = collect_params(request)
# generate a simple query object
q_build = {col: params[col] for col in params if model.schema().column(col)}
if q_build:
params['where'] = Q.build(q_build)
# create the lookup information
params.setdefault('inflated', False)
if 'columns' in params:
params['columns'] = params['columns'].split(',')
terms = params.pop('terms', '')
db_options = orb.DatabaseOptions(**params)
lookup = orb.LookupOptions(**params)
# returns the lookup, database options, search terms and original options
return {'lookup': lookup, 'options': db_options, 'terms': terms}
def setQuery(self, query):
"""
Assigns the query for this widget, loading the query builder tree with
the pertinent information.
:param query | <Query> || <QueryCompound> || None
"""
tree = self.uiQueryTREE
tree.blockSignals(True)
tree.setUpdatesEnabled(False)
tree.clear()
# assign a top level query item
if (Q.typecheck(query) and not query.isNull()):
XQueryItem(tree, query)
# assign a top level query group
elif (QueryCompound.typecheck(query) and not query.isNull()):
op_name = QueryCompound.Op[query.operatorType()].lower()
for i, sub_query in enumerate(query.queries()):
if (i):
XJoinItem(tree, op_name)
XQueryItem(tree, sub_query)
tree.resizeToContents()
tree.setUpdatesEnabled(True)
tree.blockSignals(False)
def applyQuery( self ):
"""
Sets the query for this widget from the quick query text builder.
"""
query = Q.fromString(nativestring(self.uiQueryTXT.text()))
self.setQuery(query)
self.uiQueryTXT.setText('')
def dragQuery(self):
"""
Returns the drag query that is assigned to this record item.
:return <orb.Query>
"""
return Q.fromXmlString(self.dragData("application/x-query"))
def query(self):
"""
Returns the query that is defined by this current panel.
:return <orb.Query>
"""
joiner = self.currentJoiner()
query = Query()
for entry in self.entries():
if joiner == QueryCompound.Op.And:
query &= entry.query()
else:
query |= entry.query()
query.setName(self.uiNameTXT.text())
return query
def query(self):
"""
Returns the query that is defined by this current panel.
:return <orb.Query>
"""
joiner = self.currentJoiner()
query = Query()
for entry in self.entries():
if joiner == QueryCompound.Op.And:
query &= entry.query()
else:
query |= entry.query()
query.setName(self.uiNameTXT.text())
return query
def setTableType(self, tableType):
"""
Sets the table type for this instance to the given type.
:param tableType | <orb.Table>
"""
if tableType == self._tableType:
return
self._tableType = tableType
self.setQuery(Query())
def currentQuery(self):
"""
Returns the current query for the active container. This will reflect
what is currently visible to the user.
:return <orb.Query>
"""
container = self.currentContainer()
if container:
return container.query()
return Query()
def restoreXml(self, xml):
"""
Restores the settings for this edit from xml.
:param xml | <xml.etree.ElementTree>
"""
self.uiRecordTREE.restoreXml(xml.find('tree'))
# restore the query
xquery = xml.find('query')
if xquery is not None:
self.setQuery(Q.fromXml(xquery[0]))
def restoreXml(self, xml):
"""
Restores the settings for this edit from xml.
:param xml | <xml.etree.ElementTree>
"""
self.uiRecordTREE.restoreXml(xml.find('tree'))
# restore the query
xquery = xml.find('query')
if xquery is not None:
self.setQuery(Q.fromXml(xquery[0]))
def query(self):
"""
Returns the full query for this widget. This will reflect the complete
combined query for all containers within this widget.
:return <orb.Query>
"""
if self._loadQuery is not None:
return self._loadQuery
container = self.widget(0)
if container:
return container.query()
return Query()
def removeEntry(self, entry):
if not entry:
return
layout = self._entryWidget.layout()
if layout.count() == 2:
entry.setQuery(Query())
return
layout.takeAt(layout.indexOf(entry))
entry.close()
if not self.signalsBlocked():
self.entriesUpdated.emit()
def addEntry(self, query=None, entry=None):
if query is None:
query = Query()
layout = self._entryWidget.layout()
index = layout.count() - 1
if entry:
index = layout.indexOf(entry) + 1
widget = XOrbQueryEntryWidget(self, self.tableType())
layout.insertWidget(index, widget)
widget.setQuery(query)
if not self.signalsBlocked():
self.entriesUpdated.emit()
return widget
def refreshRecords(self):
"""
Refreshes the records being loaded by this browser.
"""
table_type = self.tableType()
if (not table_type):
self._records = RecordSet()
return False
search = str(self.uiSearchTXT.text())
query = self.query().copy()
terms, search_query = Q.fromSearch(search)
if (search_query):
query &= search_query
self._records = table_type.select(where=query).search(terms)
return True
def refreshRecords( self ):
"""
Refreshes the records being loaded by this browser.
"""
table_type = self.tableType()
if ( not table_type ):
self._records = RecordSet()
return False
search = str(self.uiSearchTXT.text())
query = self.query().copy()
terms, search_query = Q.fromSearch(search)
if ( search_query ):
query &= search_query
self._records = table_type.select(where = query).search(terms)
return True
def __init__(self, parent, query, preceeding=None):
if (preceeding):
super(XQueryItem, self).__init__(parent, preceeding)
else:
super(XQueryItem, self).__init__(parent)
self.setSizeHint(2, QSize(150, 20))
# create custom properties
self._value = None
# add a simple query item
if (Q.typecheck(query)):
self.setTextAlignment(1, Qt.AlignCenter)
# set the data for this item
if (not query.isNull()):
self.setColumnName(query.columnName())
self.setOperatorType(query.operatorType())
self.setValue(query.value())
else:
self.setColumnName('')
self.setOperatorType(Q.Op.Is)
self.setValue('')
# set the flags for this item
self.setFlags( Qt.ItemIsEnabled | \
Qt.ItemIsEditable | \
Qt.ItemIsSelectable )
else:
operator = QueryCompound.Op[query.operatorType()].lower()
for i, sub_query in enumerate(query.queries()):
if (i):
XJoinItem(self, operator)
XQueryItem(self, sub_query)
self.update()
def __init__( self, parent, query, preceeding = None ):
if ( preceeding ):
super(XQueryItem, self).__init__(parent, preceeding)
else:
super(XQueryItem, self).__init__(parent)
self.setSizeHint(2, QSize(150, 20))
# create custom properties
self._value = None
# add a simple query item
if ( Q.typecheck(query) ):
self.setTextAlignment(1, Qt.AlignCenter)
# set the data for this item
if ( not query.isNull() ):
self.setColumnName(query.columnName())
self.setOperatorType(query.operatorType())
self.setValue(query.value())
else:
self.setColumnName('')
self.setOperatorType(Q.Op.Is)
self.setValue('')
# set the flags for this item
self.setFlags( Qt.ItemIsEnabled | \
Qt.ItemIsEditable | \
Qt.ItemIsSelectable )
else:
operator = QueryCompound.Op[query.operatorType()].lower()
for i, sub_query in enumerate(query.queries()):
if ( i ):
XJoinItem(self, operator)
XQueryItem(self, sub_query)
self.update()
def createCompoundFromChecked(self):
"""
Creates a new compound query from the checked entry list.
:return <orb.QueryCompound>
"""
checked_entries = self.checkedEntries()
if len(checked_entries) <= 1:
return QueryCompound()
self.setUpdatesEnabled(False)
joiner = self.currentJoiner()
query = Query()
for entry in checked_entries:
if joiner == QueryCompound.Op.And:
query &= entry.query()
else:
query |= entry.query()
# clear out the existing containers
first = checked_entries[0]
first.setQuery(query)
first.setChecked(False)
layout = self._entryWidget.layout()
for i in range(len(checked_entries) - 1, 0, -1):
w = checked_entries[i]
layout.takeAt(layout.indexOf(w))
w.close()
self.refreshEntries()
self.setUpdatesEnabled(True)
if not self.signalsBlocked():
self.enterCompound(first, query)
def __init__(self, query, joiner=''):
super(XQueryItem, self).__init__()
# set the joiner
self._joiner = joiner
# update the hint
self.setText(0, joiner)
self.setSizeHint(1, QSize(80, 20))
if (Q.typecheck(query)):
op_name = Q.Op[query.operatorType()]
op_name = projex.text.joinWords(op_name, ' ').lower()
palette = QApplication.palette()
for i in range(4):
self.setBackground(i, palette.color(palette.Base))
self.setTextAlignment(0, Qt.AlignRight | Qt.AlignVCenter)
self.setText(1, query.columnName())
self.setText(2, op_name)
self.setText(3, query.valueString())
flags = self.flags()
flags |= Qt.ItemIsEditable
self.setFlags(flags)
else:
sub_joiner = QueryCompound.Op[query.operatorType()].lower()
for i, sub_query in enumerate(query.queries()):
if (i):
item = XQueryItem(sub_query, sub_joiner)
else:
item = XQueryItem(sub_query)
self.addChild(item)
def __init__( self, query, joiner = '' ):
super(XQueryItem, self).__init__()
# set the joiner
self._joiner = joiner
# update the hint
self.setText(0, joiner)
self.setSizeHint(1, QSize(80, 20))
if ( Q.typecheck(query) ):
op_name = Q.Op[query.operatorType()]
op_name = projex.text.joinWords(op_name, ' ').lower()
palette = QApplication.palette()
for i in range(4):
self.setBackground(i, palette.color(palette.Base))
self.setTextAlignment(0, Qt.AlignRight | Qt.AlignVCenter)
self.setText(1, query.columnName())
self.setText(2, op_name)
self.setText(3, query.valueString())
flags = self.flags()
flags |= Qt.ItemIsEditable
self.setFlags(flags)
else:
sub_joiner = QueryCompound.Op[query.operatorType()].lower()
for i, sub_query in enumerate(query.queries()):
if ( i ):
item = XQueryItem(sub_query, sub_joiner)
else:
item = XQueryItem(sub_query)
self.addChild(item)
def reset(self):
"""
Resets this query builder to a blank query.
"""
self.setQuery(Query())
def addQuery( self ):
"""
Sets the query for this widget from the quick query text builder.
"""
insert_item = self.uiQueryTREE.currentItem()
if ( insert_item and not insert_item.isSelected() ):
insert_item = None
# create the query
if ( self.uiQueryTXT.text() ):
query = Q.fromString(str(self.uiQueryTXT.text()))
self.uiQueryTXT.setText('')
else:
query = Q()
# determine where to create the item at
tree = self.uiQueryTREE
if ( not insert_item ):
# determine if we are already joining queries together
count = tree.topLevelItemCount()
# create the first item
if ( not count ):
XQueryItem(tree, query)
else:
if ( 1 < count ):
join = tree.topLevelItem(count - 2).text(0)
else:
join = 'and'
# create the join item & query item
XJoinItem(tree, join)
XQueryItem(tree, query)
# add a query into a group
elif ( insert_item.childCount() ):
count = insert_item.childCount()
join = insert_item.child(count - 2).text(0)
# add the query to the group
XJoinItem(insert_item, join)
XQueryItem(tree, query)
# add a query underneath another item
else:
parent_item = insert_item.parent()
# add into the tree
if ( not parent_item ):
count = tree.topLevelItemCount()
index = tree.indexOfTopLevelItem(insert_item)
# add to the end
if ( index == count - 1 ):
if ( 1 < count ):
join = tree.topLevelItem(count - 2).text(0)
else:
join = 'and'
XJoinItem(tree, join)
XQueryItem(tree, query)
# insert in the middle
else:
join_item = tree.topLevelItem(index + 1)
join = join_item.text(0)
XJoinItem(tree, join, preceeding = join_item)
XQueryItem(tree, query, preceeding = join_item)
else:
count = parent_item.childCount()
index = parent_item.indexOfChild(insert_item)
# add to the end
if ( index == count - 1 ):
if ( 1 < count ):
join = parent_item.child(count - 2).text(0)
else:
join = 'and'
XJoinItem(parent_item, join)
XQueryItem(parent_item, query)
# insert in the middle
else:
join_item = parent_item.child(index + 1)
join = join_item.text(0)
XJoinItem(parent_item, join, preceeding = join_item)
XQueryItem(parent_item, join, preceeding = join_item)
def showEvent(self, event):
if self._loadQuery is not None:
self.setQuery(self._loadQuery)
elif not self._initialized:
self.setQuery(Query())
def addQuery(self):
"""
Sets the query for this widget from the quick query text builder.
"""
insert_item = self.uiQueryTREE.currentItem()
if (insert_item and not insert_item.isSelected()):
insert_item = None
# create the query
if (self.uiQueryTXT.text()):
query = Q.fromString(nativestring(self.uiQueryTXT.text()))
self.uiQueryTXT.setText('')
else:
query = Q()
# determine where to create the item at
tree = self.uiQueryTREE
if (not insert_item):
# determine if we are already joining queries together
count = tree.topLevelItemCount()
# create the first item
if (not count):
XQueryItem(tree, query)
else:
if (1 < count):
join = tree.topLevelItem(count - 2).text(0)
else:
join = 'and'
# create the join item & query item
XJoinItem(tree, join)
XQueryItem(tree, query)
# add a query into a group
elif (insert_item.childCount()):
count = insert_item.childCount()
join = insert_item.child(count - 2).text(0)
# add the query to the group
XJoinItem(insert_item, join)
XQueryItem(tree, query)
# add a query underneath another item
else:
parent_item = insert_item.parent()
# add into the tree
if (not parent_item):
count = tree.topLevelItemCount()
index = tree.indexOfTopLevelItem(insert_item)
# add to the end
if (index == count - 1):
if (1 < count):
join = tree.topLevelItem(count - 2).text(0)
else:
join = 'and'
XJoinItem(tree, join)
XQueryItem(tree, query)
# insert in the middle
else:
join_item = tree.topLevelItem(index + 1)
join = join_item.text(0)
XJoinItem(tree, join, preceeding=join_item)
XQueryItem(tree, query, preceeding=join_item)
else:
count = parent_item.childCount()
index = parent_item.indexOfChild(insert_item)
# add to the end
if (index == count - 1):
if (1 < count):
join = parent_item.child(count - 2).text(0)
else:
join = 'and'
XJoinItem(parent_item, join)
XQueryItem(parent_item, query)
# insert in the middle
else:
join_item = parent_item.child(index + 1)
join = join_item.text(0)
XJoinItem(parent_item, join, preceeding=join_item)
XQueryItem(parent_item, join, preceeding=join_item)
