def delete_task(task_id):
'''Delete task with given ID'''
# Read DB
db = os.environ[DB_ENV_VAR]
db_service = DatabaseService(db)
if db_service.find_task_by_id(task_id) is None:
sys.exit(NO_SUCH_TASK + str(task_id))
db_service.delete_task_by_id(task_id)
def add_task():
'''Add task to database'''
new_task = get_new_task()
# field_names = ['id', 'priority', 'state', 'subject', 'description']
db = os.environ[DB_ENV_VAR]
db_service = DatabaseService(db)
# Add task to DB
db_service.add_task(new_task)
def view_task(task_id):
'''View details about task with given ID'''
# Read DB
db = os.environ[DB_ENV_VAR]
db_service = DatabaseService(db)
task = db_service.find_task_by_id(task_id)
if task is not None:
print(task)
else:
sys.exit(NO_SUCH_TASK + str(task_id))
def edit_task(task_id):
'''Edit task with given ID'''
# Read DB
db = os.environ[DB_ENV_VAR]
db_service = DatabaseService(db)
task = db_service.find_task_by_id(task_id)
if task is None:
sys.exit(NO_SUCH_TASK + str(task_id))
modified_task = edit_temp_task(task)
modified_task.id = task.id
db_service.update_task(modified_task)
def setUp(self):
self.database_service = DatabaseService()
self.statement = "Create (n: Test)"
self.commit_body = {"statements": [{"statement": self.statement}]}
self.response_content = {
'results': [{
'data': [{
'meta': [{}]
}]
}],
'errors': []
}
self.response = Response()
self.response._content = json.dumps(
self.response_content).encode('utf-8')
def parse_args(args):
'''Parse arguments given to program and decide what to do'''
if args.init:
db = os.environ[DB_ENV_VAR]
if os.path.isfile(db):
sys.exit(FILE_ALREADY_EXISTS)
DatabaseService(db)
print('Successfully initialized database')
elif args.add:
task_service.add_task()
elif args.list:
task_service.list_tasks()
elif args.edit is not None:
task_service.edit_task(args.edit)
print('Successfully edited task with ID: ' + str(args.edit))
elif args.view is not None:
task_service.view_task(args.view)
elif args.delete is not None:
task_service.delete_task(args.delete)
print('Successfully deleted task with ID: ' + str(args.delete))
import sys
import logging
from database_service import DatabaseService
from mqtt_service import MqttService
from flask_server import WebService
def config_default_logger():
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
log_format = logging.Formatter(
'%(asctime)s * %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(log_format)
logger.addHandler(handler)
return logger
if __name__ == '__main__':
logger = config_default_logger()
db_client = DatabaseService(logger)
mqtt = MqttService(logger, db_client)
web_server = WebService(logger, db_client)
mqtt.start()
web_server.start()
class NodeService:
"""
Object to handle logic of nodes requests
Attributes:
db (DatabaseService): Handles communication with Neo4j database
"""
db: DatabaseService = DatabaseService()
def save_node(self, node: NodeIn):
"""
Send request to database by its API to create new node
Args:
node (NodeIn): Node to be added to database
Returns:
Result of request as node object
"""
response = self.db.create_node(node)
if len(response["errors"]) > 0:
result = NodeOut(errors=response["errors"])
else:
node_id = response["results"][0]["data"][0]["meta"][0]["id"]
result = NodeOut(id=node_id, labels=node.labels)
return result
def get_node(self, node_id: int):
"""
Send request to database by its API to acquire node with given id
Args:
node_id (int): Id by which it is searched for in the database
Returns:
Acquired node in NodeOut model
"""
response = self.db.get_node(node_id)
if len(response['results'][0]["data"]) == 0:
return NodeOut(errors="Node not found")
node = response['results'][0]["data"][0]
properties = [
PropertyIn(key=property[0], value=property[1])
for property in node["row"][0].items()
]
result = NodeOut(id=node_id,
properties=properties,
labels={node["row"][1][0]})
return result
def get_nodes(self, label: str):
"""
Send request to database by its API to acquire all nodes with given label
Args:
label (str): Label by which it is searched for in the database
Returns:
List of acquired nodes in NodesOut model
"""
response = self.db.get_nodes(label)
if len(response["errors"]) > 0:
return NodesOut(errors=response["errors"])
result = NodesOut(nodes=[])
for node in response["results"][0]["data"]:
properties = [
PropertyIn(key=property[0], value=property[1])
for property in node["row"][0].items()
]
result.nodes.append(
BasicNodeOut(labels={label},
id=node["meta"][0]["id"],
properties=properties))
return result
def delete_node(self, node_id: int):
"""
Send request to database by its API to delete node with given id
Args:
node_id (int): Id of node
Returns:
Deleted node
"""
node = self.get_node(node_id)
response = self.db.delete_node(node_id)
result = NodeOut(errors=response["errors"]) if len(response["errors"]) > 0 else \
NodeOut(id=node_id, labels=node.labels, properties=node.properties)
return result
def get_relationships(self, id: int):
"""
Send request to database by its API to get node's relationships
Args:
id (int): Id of the node
Returns:
Result of request as list of relationships
"""
response = self.db.get_relationships(id)
if len(response["errors"]) > 0:
result = RelationshipsOut(errors=response["errors"])
else:
response_data = response["results"][0]["data"]
relationships = [
BasicRelationshipOut(start_node=relation["row"][0],
end_node=relation["row"][1],
id=relation["row"][3],
name=relation["row"][2])
for relation in response_data
]
result = RelationshipsOut(relationships=relationships)
return result
def save_properties(self, id: int, properties: List[PropertyIn]):
"""
Send request to database by its API to create new properties
Args:
id (int): Id of the node
properties (List[PropertyIn]): List of properties for the node of given id
Returns:
Result of request as node object
"""
if self.db.node_exists(id):
response = self.db.create_node_properties(id, properties)
if len(response["errors"]) > 0:
result = NodeOut(errors=response["errors"])
else:
response_data = response["results"][0]["data"][0]["row"]
response_properties = list((map(
lambda property: PropertyIn(key=property[0],
value=property[1]),
response_data[1].items())))
result = NodeOut(labels=set(response_data[0]),
id=id,
properties=response_properties)
else:
result = NodeOut(id=id, errors={"errors": "not matching id"})
return result
def delete_node_properties(self, node_id: int):
"""
Send request to database by its API to delete properties from node with given id
Args:
node_id (int): Id of node
Returns:
Deleted node
"""
node = self.get_node(node_id)
response = self.db.delete_node_properties(node_id)
result = NodeOut(errors=response["errors"]) if len(response["errors"]) > 0 else \
NodeOut(id=node_id, labels=node.labels, properties=node.properties)
return result
class RelationshipService:
"""
Object to handle logic of relationships requests
Attributes:
db (DatabaseService): Handles communication with Neo4j database
"""
db: DatabaseService = DatabaseService()
def save_relationship(self, relationship: RelationshipIn):
"""
Send request to database by its API to create new relationship
Args:
relationship (-): Relationship to be added to database
Returns:
Result of request as relationship object
"""
if self.db.node_exists(
relationship.start_node) and self.db.node_exists(
relationship.end_node):
response = self.db.create_relationship(relationship)
if len(response["errors"]) > 0:
result = RelationshipOut(start_node=relationship.start_node,
end_node=relationship.end_node,
name=relationship.name,
errors=response["errors"])
else:
relationship_id = response["results"][0]["data"][0]["meta"][0][
"id"]
result = RelationshipOut(start_node=relationship.start_node,
end_node=relationship.end_node,
name=relationship.name,
id=relationship_id)
else:
result = RelationshipOut(start_node=relationship.start_node,
end_node=relationship.end_node,
name=relationship.name,
errors={"errors": "not matching node id"})
return result
def get_relationship(self, relationship_id: int):
"""
Send request to database by its API to acquire relationship with given id
Args:
relationship_id (int): Id by which it is searched for in the database
Returns:
Acquired relationship in RelationshipOut model
"""
response = self.db.get_relationship(relationship_id)
if len(response['results'][0]["data"]) == 0:
return RelationshipOut(errors="Relationship not found")
relationship = response['results'][0]["data"][0]
result = RelationshipOut(start_node=relationship["row"][0],
end_node=relationship["row"][1],
id=relationship["row"][3],
name=relationship["row"][2])
return result
def delete_relationship(self, relationship_id: int):
"""
Send request to database by its API to delete relationship with given id
Args:
relationship_id (int): Id of relationship
Returns:
Deleted relationship
"""
relationship = self.get_relationship(relationship_id)
response = self.db.delete_relationship(relationship_id)
if len(response["errors"]) > 0:
result = RelationshipOut(errors=response["errors"])
else:
result = RelationshipOut(id=relationship_id,
start_node=relationship.start_node,
end_node=relationship.end_node,
name=relationship.name,
properties=relationship.properties)
return result
def save_properties(self, id: int, properties: List[PropertyIn]):
"""
Send request to database by its API to create new properties
Args:
id (int): Id of the relationship
properties (List[PropertyIn]): List of properties for the relationship of given id
Returns:
Result of request as relationship object
"""
if self.db.relationship_exist(id):
response = self.db.create_relationship_properties(id, properties)
if len(response["errors"]) > 0:
result = RelationshipOut(errors=response["errors"])
else:
response_data = response["results"][0]["data"][0]["row"]
response_properties = list((map(
lambda property: PropertyIn(key=property[0],
value=property[1]),
response_data[3].items())))
result = RelationshipOut(start_node=response_data[0],
end_node=response_data[2],
name=response_data[1],
id=id,
properties=response_properties)
else:
result = RelationshipOut(id=id,
errors={"errors": "not matching id"})
return result
def initialize(config_file_path, client_tpid):
try:
stream = open(config_file_path, 'r')
config_data = json.load(stream)
except Exception:
raise Exception('Unable to process specified config file: {0}.'.format(
config_file_path))
# Initialize Log Service
log_configuration = config_data[
'log_configuration'] if 'log_configuration' in config_data else None
if log_configuration and all(k in log_configuration
for k in ('log_path', 'log_level')):
global log_service
log_service = LogService(log_path=log_configuration['log_path'],
log_level=log_configuration['log_level'],
client_tpid=client_tpid).logger
else:
raise Exception('Log configuration is missing or incomplete.')
# Retrieve Tessco Credentials
global service_provider_configuration
service_provider_configuration = config_data[
'service_provider_configuration'] if 'service_provider_configuration' in config_data else None
if not service_provider_configuration or not all(
k in service_provider_configuration
for k in ('wsdl_path', 'vendor_id', 'user_name', 'password',
'timeout', 'slack_webhook')):
raise Exception(
'Service Provider configuration is missing or incomplete')
global vendor_id
vendor_id = service_provider_configuration['vendor_id']
global user_name
user_name = str(service_provider_configuration['user_name'])
global password
password = str(service_provider_configuration['password'])
if not vendor_id or not user_name or not password:
raise Exception('IQMetrix credentials is missing or incomplete.')
# Retrieve webhook from config.
global slack
slack = slack_utility.SlackUtility(
log_service, str(service_provider_configuration['slack_webhook']))
# Initialize Database Service
database_configuration = config_data[
'database_configuration'] if 'database_configuration' in config_data else None
if not database_configuration or not all(
k in database_configuration
for k in ('host', 'username', 'password', 'db_name', 'schema',
'port')):
raise Exception('Database configuration is missing or incomplete')
global database_service
database_service = DatabaseService(database_configuration['host'],
database_configuration['username'],
database_configuration['password'],
database_configuration['db_name'],
database_configuration['schema'],
database_configuration['port'])
# Initialize iQmetrix client - pull in WSDL file
global iqmetrix_client
iqmetrix_client = Client(
service_provider_configuration['wsdl_path'],
transport=Transport(timeout=service_provider_configuration['timeout']))
def list_tasks():
'''Print list of tasks in database'''
# Read DB
db = os.environ[DB_ENV_VAR]
db_service = DatabaseService(db)
print_task_list(db_service.get_all_tasks())
class DatabaseServiceTestCase(unittest.TestCase):
def setUp(self):
self.database_service = DatabaseService()
self.statement = "Create (n: Test)"
self.commit_body = {"statements": [{"statement": self.statement}]}
self.response_content = {
'results': [{
'data': [{
'meta': [{}]
}]
}],
'errors': []
}
self.response = Response()
self.response._content = json.dumps(
self.response_content).encode('utf-8')
@mock.patch('database_service.requests')
def test_post(self, requests_mock):
requests_mock.post.return_value = self.response
result = self.database_service.post(self.commit_body)
self.assertEqual(result, self.response_content)
requests_mock.post.assert_called_with(
url=self.database_service.database_url,
json=self.commit_body,
auth=self.database_service.database_auth)
@mock.patch('database_service.requests')
def test_post_statement(self, requests_mock):
requests_mock.post.return_value = self.response
result = self.database_service.post_statement(self.statement)
self.assertEqual(result, self.response_content)
@mock.patch('database_service.requests')
def test_node_exists_with_node(self, requests_mock):
requests_mock.post.return_value = self.response
commit_body = {
"statements": [{
"statement": "MATCH (n) where id(n) =1 return n"
}]
}
node_id = 1
result = self.database_service.node_exists(node_id)
self.assertTrue(result)
requests_mock.post.assert_called_with(
url=self.database_service.database_url,
json=commit_body,
auth=self.database_service.database_auth)
@mock.patch('database_service.requests')
def test_node_exists_without_node(self, requests_mock):
response_content = {"results": [{"data": []}], "errors": []}
response = Response()
response._content = json.dumps(response_content).encode("utf-8")
requests_mock.post.return_value = response
node_id = 2
result = self.database_service.node_exists(node_id)
self.assertFalse(result)
@mock.patch('database_service.requests')
def test_create_node_with_one_label(self, requests_mock):
requests_mock.post.return_value = self.response
commit_body = {
"statements": [{
"statement": "CREATE (n:Test) RETURN n"
}]
}
node = NodeIn(labels=["Test"])
result = self.database_service.create_node(node)
self.assertEqual(result, self.response_content)
requests_mock.post.assert_called_with(
url=self.database_service.database_url,
json=commit_body,
auth=self.database_service.database_auth)
@mock.patch('database_service.requests')
def test_create_node_without_labels(self, requests_mock):
requests_mock.post.return_value = self.response
commit_body = {"statements": [{"statement": "CREATE (n:) RETURN n"}]}
node = NodeIn()
result = self.database_service.create_node(node)
self.assertEqual(result, self.response_content)
requests_mock.post.assert_called_with(
url=self.database_service.database_url,
json=commit_body,
auth=self.database_service.database_auth)
@mock.patch('database_service.requests')
def test_get_node(self, requests_mock):
requests_mock.post.return_value = self.response
commit_body = {
"statements": [{
"statement":
"MATCH (n) WHERE id(n)=5 RETURN n, labels(n)"
}]
}
node_id = 5
result = self.database_service.get_node(node_id)
self.assertEqual(result, self.response_content)
requests_mock.post.assert_called_with(
url=self.database_service.database_url,
json=commit_body,
auth=self.database_service.database_auth)
@mock.patch('database_service.requests')
def test_get_nodes(self, requests_mock):
requests_mock.post.return_value = self.response
commit_body = {
"statements": [{
"statement": "MATCH (n: Test) RETURN n"
}]
}
label = "Test"
result = self.database_service.get_nodes(label)
self.assertEqual(result, self.response_content)
requests_mock.post.assert_called_with(
url=self.database_service.database_url,
json=commit_body,
auth=self.database_service.database_auth)
@mock.patch('database_service.requests')
def test_delete_node(self, requests_mock):
requests_mock.post.return_value = self.response
commit_body = {
"statements": [{
"statement":
"MATCH (n) WHERE id(n)=5 DETACH DELETE n return n"
}]
}
node_id = 5
result = self.database_service.delete_node(node_id)
self.assertEqual(result, self.response_content)
requests_mock.post.assert_called_with(
url=self.database_service.database_url,
json=commit_body,
auth=self.database_service.database_auth)
@mock.patch('database_service.requests')
def test_relationship_exist_with_relationship(self, requests_mock):
requests_mock.post.return_value = self.response
commit_body = {
"statements": [{
"statement":
"MATCH ()-[r]->() where id(r) =1 return r"
}]
}
relation_id = 1
result = self.database_service.relationship_exist(relation_id)
self.assertTrue(result)
requests_mock.post.assert_called_with(
url=self.database_service.database_url,
json=commit_body,
auth=self.database_service.database_auth)
@mock.patch('database_service.requests')
def test_relationship_exist_without_relationship(self, requests_mock):
response_content = {'results': [{'data': []}], 'errors': []}
response = Response()
response._content = json.dumps(response_content).encode('utf-8')
requests_mock.post.return_value = response
node_id = 2
result = self.database_service.relationship_exist(node_id)
self.assertFalse(result)
@mock.patch('database_service.requests')
def test_get_relationship(self, requests_mock):
requests_mock.post.return_value = self.response
commit_body = {
"statements": [{
"statement":
"MATCH ()-[r]->() where id(r)=5 "
"return id(startNode(r)), id(endNode(r)), type(r), id(r)"
}]
}
relationship_id = 5
result = self.database_service.get_relationship(relationship_id)
self.assertEqual(result, self.response_content)
requests_mock.post.assert_called_with(
url=self.database_service.database_url,
json=commit_body,
auth=self.database_service.database_auth)
@mock.patch('database_service.requests')
def test_delete_relationship(self, requests_mock):
requests_mock.post.return_value = self.response
commit_body = {
"statements": [{
"statement":
"MATCH ()-[r]->() WHERE id(r)=5 "
"DETACH DELETE r return r"
}]
}
relationship_id = 5
result = self.database_service.delete_relationship(relationship_id)
self.assertEqual(result, self.response_content)
requests_mock.post.assert_called_with(
url=self.database_service.database_url,
json=commit_body,
auth=self.database_service.database_auth)
@mock.patch('database_service.requests')
def test_get_relationships(self, requests_mock):
requests_mock.post.return_value = self.response
commit_body = {
"statements": [{
"statement":
"MATCH (n)-[r]->(m) where id(n)=5 or id(m)=5 "
"return id(startNode(r)), id(endNode(r)), type(r), id(r)"
}]
}
node_id = 5
result = self.database_service.get_relationships(node_id)
self.assertEqual(result, self.response_content)
requests_mock.post.assert_called_with(
url=self.database_service.database_url,
json=commit_body,
auth=self.database_service.database_auth)
@mock.patch('database_service.requests')
def test_create_relationship(self, requests_mock):
requests_mock.post.return_value = self.response
commit_body = {
"statements": [{
"statement":
"MATCH (n) where id(n) =2 MATCH (m) where " +
"id(m) = 3 MERGE (n) - [r:Test] -> (m) " + "RETURN r"
}]
}
relation = RelationshipIn(start_node=2, end_node=3, name="Test")
result = self.database_service.create_relationship(relation)
self.assertEqual(result, self.response_content)
requests_mock.post.assert_called_with(
url=self.database_service.database_url,
json=commit_body,
auth=self.database_service.database_auth)
@mock.patch('database_service.requests')
def test_create_properties(self, requests_mock):
requests_mock.post.return_value = self.response
commit_body = {
"statements": [{
"statement":
'MATCH (x) where id(x)=2 SET x.key="value", ' +
'x.test="Test" return id(x), x'
}]
}
properties = [
PropertyIn(key="key", value="value"),
PropertyIn(key="test", value="Test")
]
object_id = 2
result = self.database_service.create_properties(
object_id, properties, "(x)", "id(x)")
self.assertEqual(result, self.response_content)
requests_mock.post.assert_called_with(
url=self.database_service.database_url,
json=commit_body,
auth=self.database_service.database_auth)
@mock.patch('database_service.requests')
def test_create_relationship_properties(self, requests_mock):
requests_mock.post.return_value = self.response
commit_body = {
"statements": [{
"statement":
'MATCH (n)-[x]->(m) where id(x)=2 SET x.key="value", ' +
'x.test="Test" return id(n), type(x), id(m), x'
}]
}
properties = [
PropertyIn(key="key", value="value"),
PropertyIn(key="test", value="Test")
]
object_id = 2
result = self.database_service.create_relationship_properties(
object_id, properties)
self.assertEqual(result, self.response_content)
requests_mock.post.assert_called_with(
url=self.database_service.database_url,
json=commit_body,
auth=self.database_service.database_auth)
@mock.patch('database_service.requests')
def test_create_node_properties(self, requests_mock):
requests_mock.post.return_value = self.response
commit_body = {
"statements": [{
"statement":
'MATCH (x) where id(x)=2 SET x.key="value", ' +
'x.test="Test" return labels(x), x'
}]
}
properties = [
PropertyIn(key="key", value="value"),
PropertyIn(key="test", value="Test")
]
object_id = 2
result = self.database_service.create_node_properties(
object_id, properties)
self.assertEqual(result, self.response_content)
requests_mock.post.assert_called_with(
url=self.database_service.database_url,
json=commit_body,
auth=self.database_service.database_auth)
@mock.patch('database_service.requests')
def test_delete_node_properties(self, requests_mock):
requests_mock.post.return_value = self.response
object_id = 2
commit_body = {
"statements": [{
"statement":
"MATCH (x) where id(x)=" + str(object_id) +
" SET x ={} return x"
}]
}
result = self.database_service.delete_node_properties(object_id)
self.assertEqual(result, self.response_content)
requests_mock.post.assert_called_with(
url=self.database_service.database_url,
json=commit_body,
auth=self.database_service.database_auth)