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 _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')
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)
