def test_link(self): """ Link to any node """ with self.app.app_context(): init_db() a_id = insert_node(name='a', value=None) b_id = insert_node(name='b', value=None) c_id = insert_node(name='c', value="c") d_id = insert_node(name='d', value="d") # a -> c, b -> c # a -> d insert_node_node(node_id=a_id, target_node_id=c_id) insert_node_node(node_id=a_id, target_node_id=d_id) insert_node_node(node_id=b_id, target_node_id=c_id) result = db.execute(text(fetch_query_string('select_link_node_from_node.sql')), node_id=a_id) result = [x['node_id'] for x in result] assert c_id in result assert d_id in result assert a_id not in result result = db.execute(text(fetch_query_string('select_link_node_from_node.sql')), node_id=b_id) result = [x['node_id'] for x in result] assert c_id in result assert d_id not in result assert a_id not in result
def test_delete_one_node(self): """ Delete a node """ with self.app.app_context(): init_db() result = db.execute(text(fetch_query_string('insert_node.sql')), name='a', value='apple') a = result.lastrowid result = db.execute(text( fetch_query_string('select_node_from_id.sql')), node_id=a).fetchall() assert len(result) == 1 r = result[0] assert a == r['node_id'] assert 'a' == r['name'] assert 'apple' == r['value'] # now delete delete_node(node_id=a) result = db.execute(text( fetch_query_string('select_node_from_id.sql')), node_id=a).fetchall() assert len(result) == 0
def test_db(self): """Check usage of db""" with self.app.app_context(): with self.app.test_client() as c: init_db() db.execute(text("""insert into Node (name, value) values (:name, :value)"""), **{"name": "bill", "value": "?"})
def test_a(self): """ """ f = open(os.path.join(self.tmp_template_dir, 'insert_llama.sql'), 'w') f.write(""" insert into Llama (llama_name, location, description) values (:llama_name, :location, :description); """) f.close() f = open(os.path.join(self.tmp_template_dir, 'select_llama.sql'), 'w') f.write(""" select * from Llama where llama_name = :llama_name; """) f.close() with self.app.app_context(): with self.app.test_client() as c: init_db() db.execute(text(""" create table Llama ( llama_name varchar(255), location varchar(255), description text ); """)) llamas_id = insert_node(name='llamas', value=None) insert_route(path='/api/llamas/', node_id=llamas_id, weight=1, method="POST") insert_query(name='insert_llama.sql', node_id=llamas_id) llama_1 = { 'llama_name': 'Rocky', 'location': 'unknown', 'description': 'first llama' } rv = c.post('/api/llamas/', data=llama_1) assert 201 == rv.status_code llama_2 = { 'llama_name': 'Nocky', 'location': 'unknown', 'description': 'second llama' } rv = c.post('/api/llamas/', data=llama_2) assert 201 == rv.status_code select_llama = insert_node(name='llamas', value=None) insert_route(path='/api/llamas/name/<llama_name>/', node_id=select_llama, weight=1) insert_query(name='select_llama.sql', node_id=select_llama) rv = c.get('/api/llamas/name/Rocky/', follow_redirects=True) rv_json = json.loads(rv.data) assert set(llama_1.keys()) == set(rv_json.keys()) assert set(llama_1.values()) == set(rv_json.values()) rv = c.get('/api/llamas/name/Nocky/', follow_redirects=True) rv_json = json.loads(rv.data) assert set(llama_2.keys()) == set(rv_json.keys()) assert set(llama_2.values()) == set(rv_json.values())
def insert_node_node(**kw): """ Link a node to another node. node_id -> target_node_id. Where `node_id` is the parent and `target_node_id` is the child. """ with current_app.app_context(): insert_query(name='select_link_node_from_node.sql', node_id=kw.get('node_id')) db.execute(text(fetch_query_string('insert_node_node.sql')), **kw)
def existing_node_input(): """ Get an existing node id by name or id. Return -1 if invalid """ input_from_user = raw_input("Existing node name or id: ") node_id = INVALID_NODE if not input_from_user: return node_id # int or str? try: parsed_input = int(input_from_user) except ValueError: parsed_input = input_from_user if isinstance(parsed_input, int): result = db.execute(text(fetch_query_string('select_node_from_id.sql')), node_id=parsed_input).fetchall() if result: node_id = int(result[0]['node_id']) else: result = db.execute(text(fetch_query_string('select_node_from_name.sql')), node_name=parsed_input).fetchall() if result: if len(result) == 1: print 'Node id: {node_id}\nNode name: {name}'.format(**result[0]) print '-------------' node_id = result[0]['node_id'] else: print 'Multiple nodes found with the name: {0}'.format(parsed_input) for item in result: print '{node_id}: {name} = {value}'.format(**item) node_selection = raw_input('Enter a node id from this list or enter "?" to render all or "?<node>" for a specific one.') if node_selection: node_selection_match = re.match(r"\?(\d)*", node_selection) if node_selection_match: if node_selection_match.groups()[0]: value = render_node(int(node_selection_match.groups()[0]), noderequest={'_no_template':True}, **result[0]) print safe_dump(value, default_flow_style=False) else: for item in result: value = render_node(item['node_id'], noderequest={'_no_template':True}, **item) print 'Node id: {0}'.format(item['node_id']) print safe_dump(value, default_flow_style=False) print '---' node_id = node_input() else: try: node_id = int(node_selection) except ValueError: node_id = INVALID_NODE print 'invalid node id: %s' % node return node_id
def add_template_for_node(name, node_id): "Set the template to use to display the node" with current_app.app_context(): db.execute(text(fetch_query_string('insert_template.sql')), name=name, node_id=node_id) result = db.execute(text(fetch_query_string('select_template.sql')), name=name, node_id=node_id).fetchall() if result: template_id = result[0]['id'] db.execute(text(fetch_query_string('update_template_node.sql')), template=template_id, node_id=node_id)
def init_db(): """Initialize a new database with the default tables for chill. Creates the following tables: Chill Node Node_Node Route Query Template """ with current_app.app_context(): for filename in CHILL_CREATE_TABLE_FILES: db.execute(text(fetch_query_string(filename)))
def test_db(self): """Check usage of db""" with self.app.app_context(): with self.app.test_client() as c: init_db() db.execute( text( """insert into Node (name, value) values (:name, :value)""" ), **{ "name": "bill", "value": "?" })
def test_insert_one_node_with_unicode(self): """ Add a node with a unicode value """ with self.app.app_context(): init_db() result = db.execute(text(fetch_query_string('insert_node.sql')), name='a', value=u'Àрpĺè') a = result.lastrowid result = db.execute(text('select * from Node where id = :id;'), id=a).fetchall() assert len(result) == 1 r = result[0] assert a == r['id'] assert 'a' == r['name'] assert u'Àрpĺè' == r['value']
def insert_route(**kw): """ `path` - '/', '/some/other/path/', '/test/<int:index>/' `node_id` `weight` - How this path is selected before other similar paths `method` - 'GET' is default. """ binding = { 'path': None, 'node_id': None, 'weight': None, 'method': "GET" } binding.update(kw) with current_app.app_context(): db.execute(text(fetch_query_string('insert_route.sql')), **binding)
def select_node(**kw): """ Select node by id. """ with current_app.app_context(): result = db.execute(text(fetch_query_string('select_node_from_id.sql')), **kw).fetchall() return result
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 uri_index(): def cleanup_url(url): url = url.strip() if url.startswith('/'): if url.endswith('/index.html'): return url elif url.endswith('/'): url = url.strip('/') if len(url) == 0: return ('public.index', {}) return ('public.uri_index', {'uri': url}) try: result = db.execute(text(fetch_query_string('select_paths_to_freeze.sql'))).fetchall() except (DatabaseError, StatementError) as err: app.logger.error("DatabaseError: %s", err) return [] urls = filter(None, map(lambda x:cleanup_url(x[0]), result)) urls_file = app.config.get('URLS_FILE', None) if urls_file: urls_file = urls_file if urls_file[0] == os.sep else os.path.join(os.getcwd(), urls_file) f = open(urls_file, 'r') urls.extend(filter(None, map(cleanup_url, f.readlines()))) f.close() return urls
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 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.execute(text(select_node_from_route), uri=uri, method=method).fetchall() except DatabaseError as err: current_app.logger.error("DatabaseError: %s", err) #current_app.logger.debug('result: "{}", {}'.format(result, len(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.execute(text(select_node_from_route), uri=rule, method=method).fetchall() 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 insert_query(**kw): """ Insert a query name for a node_id. `name` `node_id` Adds the name to the Query table if not already there. Sets the query field in Node table. """ with current_app.app_context(): result = db.execute(text(fetch_query_string('select_query_where_name.sql')), **kw).fetchall() if result: kw['query_id'] = result[0]['id'] else: result = db.execute(text(fetch_query_string('insert_query.sql')), **kw) kw['query_id'] = result.lastrowid db.execute(text(fetch_query_string('insert_query_node.sql')), **kw)
def test_a(self): """ """ f = open(os.path.join(self.tmp_template_dir, 'delete_llama.sql'), 'w') f.write(""" Delete from Llama where llama_name = :llama_name; """) f.close() f = open(os.path.join(self.tmp_template_dir, 'select_llama.sql'), 'w') f.write(""" select * from Llama where llama_name = :llama_name; """) f.close() with self.app.app_context(): with self.app.test_client() as c: init_db() db.execute(text(""" create table Llama ( llama_name varchar(255), location varchar(255), description text ); """)) db.execute(text(""" insert into Llama (llama_name, location, description) values ('Docky', 'somewhere', 'damaged'); """)) select_llama = insert_node(name='llamas', value=None) insert_route(path='/api/llamas/name/<llama_name>/', node_id=select_llama, weight=1) insert_query(name='select_llama.sql', node_id=select_llama) llamas_id = insert_node(name='llamas', value=None) insert_route(path='/api/llamas/name/<llama_name>/', node_id=llamas_id, weight=1, method="DELETE") insert_query(name='delete_llama.sql', node_id=llamas_id) rv = c.get('/api/llamas/name/Docky/', follow_redirects=True) assert 200 == rv.status_code rv = c.delete('/api/llamas/name/Docky/') assert 204 == rv.status_code rv = c.get('/api/llamas/name/Docky/', follow_redirects=True) assert 404 == rv.status_code
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 test_template(self): with self.app.app_context(): init_db() a = insert_node(name='a', value=None) add_template_for_node('template_a.html', a) aa = insert_node(name='aa', value=None) add_template_for_node('template_a.html', aa) b = insert_node(name='b', value=None) add_template_for_node('template_b.html', b) c = insert_node(name='c', value=None) add_template_for_node('template_c.html', c) result = db.execute(text( fetch_query_string('select_template_from_node.sql')), node_id=a) result = [x['name'] for x in result] assert len(result) == 1 assert result[0] == 'template_a.html' # another node that uses the same template result = db.execute(text( fetch_query_string('select_template_from_node.sql')), node_id=aa) result = [x['name'] for x in result] assert len(result) == 1 assert result[0] == 'template_a.html' # can overwrite what node is tied to what template add_template_for_node('template_over_a.html', a) result = db.execute(text( fetch_query_string('select_template_from_node.sql')), node_id=a) result = [x['name'] for x in result] assert len(result) == 1 assert result[0] == 'template_over_a.html' # this one still uses the other template result = db.execute(text( fetch_query_string('select_template_from_node.sql')), node_id=aa) result = [x['name'] for x in result] assert len(result) == 1 assert result[0] == 'template_a.html'
def insert_node(**kw): "Insert a node with a name and optional value. Return the node id." with current_app.app_context(): result = db.execute(text(fetch_query_string('insert_node.sql')), **kw) # TODO: support for postgres may require using a RETURNING id; sql # statement and using the inserted_primary_key? #node_id = result.inserted_primary_key node_id = result.lastrowid return node_id
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.execute(text(select_node_from_route), uri=uri, method=method).fetchall() except DatabaseError as err: current_app.logger.error("DatabaseError: %s", err) #current_app.logger.debug('result: "{}", {}'.format(result, len(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.execute(text(select_node_from_route), uri=rule, method=method).fetchall() 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 test_delete_one_node(self): """ Delete a node """ with self.app.app_context(): init_db() result = db.execute(text(fetch_query_string('insert_node.sql')), name='a', value='apple') a = result.lastrowid result = db.execute(text(fetch_query_string('select_node_from_id.sql')), node_id=a).fetchall() assert len(result) == 1 r = result[0] assert a == r['node_id'] assert 'a' == r['name'] assert 'apple' == r['value'] # now delete delete_node(node_id=a) result = db.execute(text(fetch_query_string('select_node_from_id.sql')), node_id=a).fetchall() assert len(result) == 0
def test_template(self): with self.app.app_context(): init_db() a = insert_node(name='a', value=None) add_template_for_node('template_a.html', a) aa = insert_node(name='aa', value=None) add_template_for_node('template_a.html', aa) b = insert_node(name='b', value=None) add_template_for_node('template_b.html', b) c = insert_node(name='c', value=None) add_template_for_node('template_c.html', c) result = db.execute(text(fetch_query_string('select_template_from_node.sql')), node_id=a) result = [x['name'] for x in result] assert len(result) == 1 assert result[0] == 'template_a.html' # another node that uses the same template result = db.execute(text(fetch_query_string('select_template_from_node.sql')), node_id=aa) result = [x['name'] for x in result] assert len(result) == 1 assert result[0] == 'template_a.html' # can overwrite what node is tied to what template add_template_for_node('template_over_a.html', a) result = db.execute(text(fetch_query_string('select_template_from_node.sql')), node_id=a) result = [x['name'] for x in result] assert len(result) == 1 assert result[0] == 'template_over_a.html' # this one still uses the other template result = db.execute(text(fetch_query_string('select_template_from_node.sql')), node_id=aa) result = [x['name'] for x in result] assert len(result) == 1 assert result[0] == 'template_a.html'
def test_delete_node_with_link(self): """ Delete a node also will delete from link """ with self.app.app_context(): init_db() a_id = insert_node(name='a', value=None) b_id = insert_node(name='b', value=None) c_id = insert_node(name='c', value="c") d_id = insert_node(name='d', value="d") # a -> c, b -> c # a -> d insert_node_node(node_id=a_id, target_node_id=c_id) insert_node_node(node_id=a_id, target_node_id=d_id) insert_node_node(node_id=b_id, target_node_id=c_id) result = db.execute(text( fetch_query_string('select_link_node_from_node.sql')), node_id=a_id) result = [x['node_id'] for x in result] assert c_id in result assert d_id in result assert a_id not in result result = db.execute(text( fetch_query_string('select_link_node_from_node.sql')), node_id=b_id) result = [x['node_id'] for x in result] assert c_id in result assert d_id not in result assert a_id not in result # now delete (should use the 'on delete cascade' sql bit) db.execute(text(fetch_query_string('delete_node_for_id.sql')), node_id=a_id) result = db.execute(text( fetch_query_string('select_node_from_id.sql')), node_id=a_id).fetchall() assert len(result) == 0 result = db.execute(text( fetch_query_string('select_link_node_from_node.sql')), node_id=a_id).fetchall() assert len(result) == 0 result = db.execute(text( fetch_query_string('select_node_node_from_node_id.sql')), node_id=a_id).fetchall() assert len(result) == 0
def render_value_for_node(node_id): """ Wrap render_node for usage in operate scripts. Returns without template rendered. """ value = None result = [] try: result = db.execute(text(fetch_query_string('select_node_from_id.sql')), node_id=node_id).fetchall() except DatabaseError as err: current_app.logger.error("DatabaseError: %s", err) if result: kw = dict(zip(result[0].keys(), result[0].values())) value = render_node(node_id, noderequest={'_no_template':True}, **kw) 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.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 test_delete_node_with_link(self): """ Delete a node also will delete from link """ with self.app.app_context(): init_db() a_id = insert_node(name='a', value=None) b_id = insert_node(name='b', value=None) c_id = insert_node(name='c', value="c") d_id = insert_node(name='d', value="d") # a -> c, b -> c # a -> d insert_node_node(node_id=a_id, target_node_id=c_id) insert_node_node(node_id=a_id, target_node_id=d_id) insert_node_node(node_id=b_id, target_node_id=c_id) result = db.execute(text(fetch_query_string('select_link_node_from_node.sql')), node_id=a_id) result = [x['node_id'] for x in result] assert c_id in result assert d_id in result assert a_id not in result result = db.execute(text(fetch_query_string('select_link_node_from_node.sql')), node_id=b_id) result = [x['node_id'] for x in result] assert c_id in result assert d_id not in result assert a_id not in result # now delete (should use the 'on delete cascade' sql bit) db.execute(text(fetch_query_string('delete_node_for_id.sql')), node_id=a_id) result = db.execute(text(fetch_query_string('select_node_from_id.sql')), node_id=a_id).fetchall() assert len(result) == 0 result = db.execute(text(fetch_query_string('select_link_node_from_node.sql')), node_id=a_id).fetchall() assert len(result) == 0 result = db.execute(text(fetch_query_string('select_node_node_from_node_id.sql')), node_id=a_id).fetchall() assert len(result) == 0
def operate_menu(): "Select between these operations on the database" selection = True while selection: print globals()['operate_menu'].__doc__ selection = select([ 'chill.database functions', 'execute sql file', 'render_node', 'New collection', 'Manage collection', 'Add document for node', 'help', ]) if selection == 'chill.database functions': mode_database_functions() elif selection == 'execute sql file': print "View the sql file and show a fill in the blanks interface with raw_input" sqlfile = choose_query_file() if not sqlfile: # return to the menu choices if not file picked selection = True else: sql_named_placeholders_re = re.compile(r":(\w+)") sql = fetch_query_string(sqlfile) placeholders = set(sql_named_placeholders_re.findall(sql)) print sql data = {} for placeholder in placeholders: value = raw_input(placeholder + ': ') data[placeholder] = value result = [] try: result = db.execute(text(sql), data) except DatabaseError as err: current_app.logger.error("DatabaseError: %s", err) if result and result.returns_rows: result = result.fetchall() print result if not result: print 'No results.' else: kw = result[0] if 'node_id' in kw: print 'render node %s' % kw['node_id'] value = render_node(kw['node_id'], **kw) print safe_dump(value, default_flow_style=False) else: #print safe_dump(rowify(result, [(x, None) for x in result[0].keys()]), default_flow_style=False) print safe_dump([dict(zip(x.keys(), x.values())) for x in result], default_flow_style=False) elif selection == 'render_node': print globals()['render_node'].__doc__ node_id = existing_node_input() value = render_value_for_node(node_id) print safe_dump(value, default_flow_style=False) elif selection == 'New collection': mode_new_collection() elif selection == 'Manage collection': mode_collection() elif selection == 'Add document for node': folder = current_app.config.get('DOCUMENT_FOLDER') if not folder: print "No DOCUMENT_FOLDER configured for the application." else: choices = map(os.path.basename, glob(os.path.join(folder, '*')) ) choices.sort() if len(choices) == 0: print "No files found in DOCUMENT_FOLDER." else: filename = select(choices) if filename: defaultname = os.path.splitext(filename)[0] nodename = raw_input("Enter name for node [{0}]: ".format(defaultname)) or defaultname node = insert_node(name=nodename, value=filename) print "Added document '%s' to node '%s' with id: %s" % (filename, nodename, node) elif selection == 'help': print "------" print __doc__ print "------" else: print 'Done'
def delete_node(**kw): """ Delete a node by id. """ with current_app.app_context(): db.execute(text(fetch_query_string('delete_node_for_id.sql')), **kw)
def test_rules(self): f = open(os.path.join(self.tmp_template_dir, 'insert_promoattr.sql'), 'w') f.write(""" insert into PromoAttr (node_id, title, description) values (:node_id, :title, :description); """) f.close() f = open(os.path.join(self.tmp_template_dir, 'select_promoattr.sql'), 'w') f.write(""" select * from PromoAttr where node_id = :node_id; """) f.close() f = open(os.path.join(self.tmp_template_dir, 'select_promos.sql'), 'w') f.write(""" select id as node_id, * from Node where name = 'promo' order by id limit 2 offset 13; """) f.close() f = open(os.path.join(self.tmp_template_dir, 'select_mainmenu.sql'), 'w') f.write(""" select name as link from Node where name like 'page_' order by link; """) f.close() f = open(os.path.join(self.tmp_template_dir, 'select_pageattr.sql'), 'w') f.write(""" select 'example title' as title, 'a description of the page' as description; """) f.close() expected = { "mainmenu": [ { "link": "page1" }, { "link": "page2" }, { "link": "page3" } ], "pageattr": { "description": "a description of the page", "title": "example title" }, "promos": [ { "promo": { "description": "aaaaaaaaaaaaa", "node_id": 20, "title": "promo 13" } }, { "promo": { "description": "aaaaaaaaaaaaaa", "node_id": 21, "title": "promo 14" } } ] } with self.app.app_context(): with self.app.test_client() as c: init_db() db.execute(text(""" create table PromoAttr ( node_id integer, abc integer, title varchar(255), description text ); """)) page_id = insert_node(name='page1', value=None) insert_route(path='/page1/', node_id=page_id) pageattr_id = insert_node(name='pageattr', value=None) insert_node_node(node_id=page_id, target_node_id=pageattr_id) insert_query(name='select_pageattr.sql', node_id=pageattr_id) mainmenu_id = insert_node(name='mainmenu', value=None) insert_node_node(node_id=page_id, target_node_id=mainmenu_id) insert_query(name='select_mainmenu.sql', node_id=mainmenu_id) # Add some other pages that will be shown in menu as just links insert_node(name='page2', value=None) insert_node(name='page3', value=None) promos_id = insert_node(name='promos', value=None) insert_node_node(node_id=page_id, target_node_id=promos_id) insert_query(name='select_promos.sql', node_id=promos_id) for a in range(0,100): a_id = insert_node(name='promo', value=None) db.execute(text(fetch_query_string('insert_promoattr.sql')), **{'node_id':a_id, 'title':'promo %i' % a, 'description': 'a'*a}) # wire the promo to it's attr insert_query(name='select_promoattr.sql', node_id=a_id) rv = c.get('/page1', follow_redirects=True) assert 200 == rv.status_code rv_json = json.loads(rv.data) assert set(expected.keys()) == set(rv_json.keys()) assert set(expected['pageattr'].keys()) == set(rv_json['pageattr'].keys())