Master ci

esdlvalidator/api/controller/validationToMessages.py

@@ -0,0 +1,150 @@
+import json
+import uuid
+from datetime import datetime as dt
+from math import cos, sin, atan2, sqrt, radians, degrees
+
+from esdl import Notes, Line, Point, Polygon, Note
+from flask import request, Response
+from flask_restx import Resource
+
+from esdlvalidator.api import app
+from esdlvalidator.api.controller import validationService
+from esdlvalidator.core.exceptions import SchemaNotFound
+from esdlvalidator.validation.functions import utils
+
+parser = app.api.parser()
+
+
+@app.ns_validation_to_msgs.route('/')
+class ValidationToMessagesController(Resource):
+    """Validate an ESDL file and return an ESDL with notes"""
+
+    @app.ns_validation_to_msgs.doc(description="Post a new validation schema", responses={
+        200: "Ok",
+        404: "Schema not found",
+        400: "Unknown filetype, Invalid ESDL"})
+    @app.api.expect(parser, validate=True)
+    def post(self):
+        """Validate an ESDL file against one or more validation schemas"""
+
+        file = request.data.decode('utf-8')
+        if "schemas" not in request.args:
+            return "Bad Request: Required 'schemas' parameter missing", 400
+        schema_list = [id for id in request.args['schemas'].split(',')]
+        try:
+            result = validationService.validateContents(file, schema_list)
+        except SchemaNotFound as e:
+            return e.message, 400
+
+        json_result = []
+
+        if 'schemas' in result:
+            for schema in result['schemas']:
+                if 'validations' in schema:
+                    for validation in schema['validations']:
+                        if 'errors' in validation:
+                            for error in validation['errors']:
+                                if 'offending_asset' in error:
+                                    asset = error['offending_asset']
+                                    msgs = self.get_messages(json_result, asset)
+                                    msgs.append({'message': error['message'], 'severity': 'ERROR'})
+                                    json_result = self.set_messages(json_result, asset, msgs)
+                        if 'warnings' in validation:
+                            for warning in validation['warnings']:
+                                if 'offending_asset' in warning:
+                                    asset = warning['offending_asset']
+                                    msgs = self.get_messages(json_result, asset)
+                                    msgs.append({'message': warning['message'], 'severity': 'WARNING'})
+                                    json_result = self.set_messages(json_result, asset, msgs)
+
+        return Response(response=json.dumps(json_result), status=200, mimetype='text/json')
+
+    @staticmethod
+    def get_messages(result, asset):
+        for element in result:
+            if element["assetID"] == asset:
+                return element["messages"]
+        return []
+
+    @staticmethod
+    def set_messages(result, asset, msgs):
+        for element in result:
+            if element["assetID"] == asset:
+                element["messages"] = msgs
+                return result
+        result.append({"assetID": asset, "messages": msgs})
+        return result
+
+    def update_esdl(self, resource, results: dict):
+        asset_notes = {}
+        now = dt.now()
+
+        notes = Notes()
+        notes.id = str(uuid.uuid4())
+        notes.name = "Validation Notes"
+
+        for schema in results['schemas']:
+            for validation in schema['validations']:
+                if "errors" in validation:
+                    for error in validation['errors']:
+                        if isinstance(error, dict):
+                            asset_id = error["offending_asset"]
+                            message = error["message"]
+                            if asset_id in asset_notes:
+                                note = asset_notes[asset_id]
+                                note.text = note.text + "\nERROR: {}".format(message)
+                            else:
+                                asset = resource.uuid_dict[asset_id]
+                                p = self.get_center_point(asset)
+                                note = Note(id=str(uuid.uuid4()), mapLocation=p, author="ESDLValidatorService",
+                                            title=asset_id, text="ERROR: {}".format(message), date=now)
+                                asset_notes[asset_id] = note
+                if "warnings" in validation:
+                    for warning in validation['warnings']:
+                        if isinstance(warning, dict):
+                            asset_id = warning["offending_asset"]
+                            message = warning["message"]
+                            if asset_id in asset_notes:
+                                note = asset_notes[asset_id]
+                                note.text = note.text + "\nWARNING: {}".format(message)
+                            else:
+                                asset = resource.uuid_dict[asset_id]
+                                p = self.get_center_point(asset)
+                                note = Note(id=str(uuid.uuid4()), mapLocation=p, author="ESDLValidatorService",
+                                            title=asset_id, text="WARNING: {}".format(message), date=now)
+                                asset_notes[asset_id] = note
+        for n in asset_notes.values():
+            notes.note.append(n)
+
+        return notes
+
+    @staticmethod
+    def get_center_point(asset):
+        a = asset
+        while not utils.has_attribute(a, 'geometry'):
+            a = a.eContainer()
+        geometry = a.geometry
+        points = None
+        if isinstance(geometry, Polygon):
+            points = geometry.exterior[0:2]
+        elif isinstance(geometry, Line):
+            points = geometry.point[0:2]
+        elif isinstance(geometry, Point):
+            points = [geometry]
+        x = []
+        y = []
+        z = []
+        for p in points:
+            x.append(cos(radians(p.lat)) * cos(radians(p.lon)))
+            y.append(cos(radians(p.lat)) * sin(radians(p.lon)))
+            z.append(sin(radians(p.lat)))
+
+        x_avg = (sum(x) / len(x))
+        y_avg = (sum(y) / len(y))
+        z_avg = (sum(z) / len(z))
+
+        lon = atan2(y_avg, x_avg)
+        hyp = sqrt(x_avg * x_avg + y_avg * y_avg)
+        lat = atan2(z_avg, hyp)
+
+        return Point(lat=degrees(lat), lon=degrees(lon))

esdlvalidator/api/controller/validationToNotes.py

@@ -2,16 +2,13 @@
 from datetime import datetime as dt
 from math import cos, sin, atan2, sqrt, radians, degrees
 
+from esdl import Notes, Line, Point, Polygon, Note
+from esdl.esdl_handler import StringURI
 from flask import request, Response
 from flask_restx import Resource
-from pyecore.resources import ResourceSet
-from pyecore.resources.resource import HttpURI
 
 from esdlvalidator.api import app
 from esdlvalidator.api.controller import validationService
-from esdlvalidator.core.esdl import EnergySystemInformation, Notes, Line, Point, Polygon, Note
-from esdlvalidator.core.esdl.esh import StringURI
-from esdlvalidator.core.esdl.resources.xmlresource import XMLResource
 from esdlvalidator.core.exceptions import SchemaNotFound
 from esdlvalidator.validation.functions import utils
 

esdlvalidator/api/manage.py

@@ -7,6 +7,7 @@
 from esdlvalidator.api.controller.validation import app as validationApi
 from esdlvalidator.api.controller.schema import app as schemaApi
 from esdlvalidator.api.controller.validationToNotes import app as validationToNotesApi
+from esdlvalidator.api.controller.validationToMessages import app as validationToMsgsApi
 from esdlvalidator.core.exceptions import ApiException
 
 logger = logging.getLogger(__name__)

esdlvalidator/api/setup.py

@@ -50,4 +50,5 @@ def __init__(self):
         self.api = Api(self.apiBlueprint, version=self.settings.version, title=self.settings.title, description=self.settings.description)
         self.ns_validation = self.api.namespace("validation", "ESDL validation endpoint")
         self.ns_validation_to_notes = self.api.namespace("validationToNotes", "ESDL-aas validation endpoint")
+        self.ns_validation_to_msgs = self.api.namespace("validationToMessages", "ESDL-aas validation endpoint to return JSON")
         self.ns_schema = self.api.namespace("schema", "Validation schema endpoint")