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)