def _query(_node_id, value=None, **kw):
"Look up value by using Query table"
query_result = []
try:
query_result = db.query(
fetch_query_string('select_query_from_node.sql'),
fetchall=True,
**kw)
except DatabaseError as err:
current_app.logger.error("DatabaseError: %s, %s", err, kw)
return value
#current_app.logger.debug("queries kw: %s", kw)
#current_app.logger.debug("queries value: %s", value)
#current_app.logger.debug("queries: %s", query_result)
if query_result:
values = []
for query_name in [x.get('name', None) for x in query_result]:
if query_name:
result = []
try:
result = db.query(fetch_query_string(query_name), **kw)
if len(result) == 0:
values.append(([], []))
else:
# There may be more results, but only interested in the
# first one
values.append((result.as_dict(), result[0].keys()))
except (DatabaseError, StatementError) as err:
current_app.logger.error("DatabaseError (%s) %s: %s",
query_name, kw, err)
value = values
#current_app.logger.debug("value: %s", value)
return value
def check_map(uri, url_root):
"""
return a tuple of the rule and kw.
"""
# TODO: Building the Map each time this is called seems like it could be more effiecent.
c = db.cursor()
try:
c.execute(fetch_query_string('select_route_where_dynamic.sql'))
except sqlite3.OperationalError as err:
current_app.logger.error("OperationalError: %s", err)
return (None, None)
result = c.fetchall()
if result:
(routes, col_names) = rowify(result, c.description)
#current_app.logger.debug( [x['rule'] for x in routes] )
rules = map( lambda r: Rule(r['rule'], endpoint='dynamic'), routes )
d_map = Map( rules )
map_adapter = d_map.bind(url_root)
#current_app.logger.debug(uri)
try:
(rule, rule_kw) = map_adapter.match(path_info=uri, return_rule=True)
#current_app.logger.debug(rule)
return (str(rule), rule_kw)
except HTTPException:
pass
return (None, {})
def check_map(uri, url_root):
"""
return a tuple of the rule and kw.
"""
# TODO: Building the Map each time this is called seems like it could be more effiecent.
result = []
try:
result = db.execute(
text(fetch_query_string(
'select_route_where_dynamic.sql'))).fetchall()
except OperationalError as err:
current_app.logger.error("OperationalError: %s", err)
return (None, None)
if result:
#routes = result.as_dict()
#(routes, col_names) = rowify(result, c.description)
#current_app.logger.debug( [x['rule'] for x in routes] )
rules = map(lambda r: Rule(r['rule'], endpoint='dynamic'), result)
d_map = Map(rules)
map_adapter = d_map.bind(url_root)
#current_app.logger.debug(uri)
try:
(rule, rule_kw) = map_adapter.match(path_info=uri,
return_rule=True)
#current_app.logger.debug(rule)
return (str(rule), rule_kw)
except HTTPException:
pass
return (None, {})
def _query(_node_id, value=None, **kw):
"Look up value by using Query table"
query_result = []
try:
query_result = db.execute(text(fetch_query_string('select_query_from_node.sql')), **kw).fetchall()
except DatabaseError as err:
current_app.logger.error("DatabaseError: %s, %s", err, kw)
return value
#current_app.logger.debug("queries kw: %s", kw)
#current_app.logger.debug("queries value: %s", value)
current_app.logger.debug("queries: %s", query_result)
if query_result:
values = []
for query_name in [x['name'] for x in query_result]:
if query_name:
result = []
try:
current_app.logger.debug("query_name: %s", query_name)
#current_app.logger.debug("kw: %s", kw)
# Query string can be insert or select here
#statement = text(fetch_query_string(query_name))
#params = [x.key for x in statement.params().get_children()]
#skw = {key: kw[key] for key in params}
#result = db.execute(statement, **skw)
result = db.execute(text(fetch_query_string(query_name)), **kw)
current_app.logger.debug("result query: %s", result.keys())
except (DatabaseError, StatementError) as err:
current_app.logger.error("DatabaseError (%s) %s: %s", query_name, kw, err)
if result and result.returns_rows:
result = result.fetchall()
#values.append(([[dict(zip(result.keys(), x)) for x in result]], result.keys()))
#values.append((result.fetchall(), result.keys()))
#current_app.logger.debug("fetchall: %s", values)
if len(result) == 0:
values.append(([], []))
else:
current_app.logger.debug("result: %s", result)
# There may be more results, but only interested in the
# first one. Use the older rowify method for now.
# TODO: use case for rowify?
values.append(rowify(result, [(x, None) for x in result[0].keys()]))
#current_app.logger.debug("fetchone: %s", values)
value = values
#current_app.logger.debug("value: %s", value)
return value
def node_from_uri(uri, method="GET"):
# check if page exists in data_path
# a//b == a/b/ == a/./b == a/foo/../b
# '' == '.'
# Prepend the uri with '/' and normalize
uri = os.path.normpath(os.path.join('/', uri))
uri, ext = os.path.splitext(uri)
if not uri.endswith('/'):
uri = ''.join((uri, '/'))
#current_app.logger.debug('uri: "%s"' % uri)
rule_kw = {}
select_node_from_route = fetch_query_string('select_node_from_route.sql')
result = []
try:
result = db.query(select_node_from_route,
fetchall=True,
**{
'uri': uri,
'method': method
})
except DatabaseError as err:
current_app.logger.error("DatabaseError: %s", err)
#current_app.logger.debug('result: "%s"' % result)
if not result or len(result) == 0:
# See if the uri matches any dynamic rules
(rule, rule_kw) = check_map(uri, request.url_root)
#current_app.logger.debug(rule)
#current_app.logger.debug('rule: "%s"' % rule or '')
if rule:
try:
result = db.query(select_node_from_route,
fetchall=True,
**{
'uri': rule,
'method': method
})
except DatabaseError as err:
current_app.logger.error("DatabaseError: %s", err)
if result:
result = result.as_dict()
#(result, col_names) = rowify(result, c.description)
# Only one result for a getting a node from a unique path.
return (result[0], rule_kw)
return (None, rule_kw)
def _link(node_id):
"Add the value for a linked node"
c = db.cursor()
linked_value = c.execute(
fetch_query_string('select_link_node_from_node.sql'), {
'node_id': node_id
}).fetchall()
if linked_value:
if len(linked_value) > 1:
list = []
for v in linked_value:
list.append({v[1]: render_node(v[2], None, v[1])})
linked_value = list
else:
linked_value = render_node(linked_value[0][0]) #TODO
return linked_value
def node_from_uri(uri, method="GET"):
# check if page exists in data_path
# a//b == a/b/ == a/./b == a/foo/../b
# '' == '.'
# Prepend the uri with '/' and normalize
uri = os.path.normpath(os.path.join('/', uri))
uri, ext = os.path.splitext(uri)
if not uri.endswith('/'):
uri = ''.join((uri, '/'))
#current_app.logger.debug('uri: "%s"' % uri)
rule_kw = {}
select_node_from_route = fetch_query_string('select_node_from_route.sql')
c = db.cursor()
try:
c.execute(select_node_from_route, {'uri':uri, 'method':method})
except sqlite3.DatabaseError as err:
current_app.logger.error("DatabaseError: %s", err)
result = c.fetchall()
#current_app.logger.debug('result: "%s"' % result)
if not result or len(result) == 0:
# See if the uri matches any dynamic rules
(rule, rule_kw) = check_map(uri, request.url_root)
#current_app.logger.debug(rule)
#current_app.logger.debug('rule: "%s"' % rule or '')
if rule:
try:
c.execute(select_node_from_route, {'uri':rule, 'method':method})
result = c.fetchall()
except sqlite3.DatabaseError as err:
current_app.logger.error("DatabaseError: %s", err)
if result:
(result, col_names) = rowify(result, c.description)
# Only one result for a getting a node from a unique path.
return (result[0], rule_kw)
return (None, rule_kw)
def _template(node_id, value=None):
"Check if a template is assigned to it and render that with the value"
result = []
select_template_from_node = fetch_query_string('select_template_from_node.sql')
try:
result = db.execute(text(select_template_from_node), node_id=node_id)
template_result = result.fetchone()
result.close()
if template_result and template_result['name']:
template = template_result['name']
if isinstance(value, dict):
return render_template(template, **value)
else:
return render_template(template, value=value)
except DatabaseError as err:
current_app.logger.error("DatabaseError: %s", err)
# No template assigned to this node so just return the value
return value
def _template(node_id, value=None):
"Check if a template is assigned to it and render that with the value"
result = []
select_template_from_node = fetch_query_string(
'select_template_from_node.sql')
try:
result = db.query(select_template_from_node, **{'node_id': node_id})
template_result = result.first()
if template_result and template_result.get('name'):
template = template_result.get('name')
if isinstance(value, dict):
return render_template(template, **value)
else:
return render_template(template, value=value)
except DatabaseError as err:
current_app.logger.error("DatabaseError: %s", err)
# No template assigned to this node so just return the value
return value
