much work done

src/resources.py

@@ -1,15 +1,17 @@
 #!/usr/bin/env python3
-from uuid import uuid4
+from uuid import UUID
 import datetime
 
-from flask_jwt_extended import create_access_token, jwt_required
+from flask_jwt_extended import create_access_token, jwt_required, get_jwt_identity
 from flask_restful import Resource
 from flask import request, current_app, abort
 
 from db import db
-from models import User
-from schemas import UserSchema, UserMetadataSchema
+from models import VideonUser, StreamResource, StreamResourceTypeEnum, OutputUrls
+from schemas import UserSchema, UserMetadataSchema, StreamResourceSchema, IngestInputSchema, EncodeInputSchema, \
+    RestreamInputSchema
 from config import REGISTER_DISABLED
+import listdiffer
 
 """
 Flask Restful endpoints
@@ -20,6 +22,9 @@ __copyright__ = "Copyright 2020, videON Team"
 __module_name__ = "resources"
 __version__text__ = "1"
 
+INVALID_JSON_SCHEMA_MSG = "invalid json schema"
+DB_ERROR_MSG = "db session error"
+
 
 class SignupApi(Resource):
     """
@@ -39,18 +44,17 @@ class SignupApi(Resource):
             userobj = self.userschema.load(body)
         except Exception as e:
             current_app.logger.warning(e)
-            abort(417, "invalid json schema")
+            abort(417, INVALID_JSON_SCHEMA_MSG)
 
-        user = User(name=userobj['name'], password=userobj['password'])
+        user = VideonUser(name=userobj['name'], password=userobj['password'])
         try:
             user.hash_password()
             db.session.add(user)
-            db.session.commit()
         except Exception as e:
-            db.session.rollback()
             current_app.logger.warning(e)
             abort(503, "user already exists")
 
+        db.session.commit()
         return self.usermetadataschema.dump(user), 200
 
 
@@ -69,9 +73,9 @@ class LoginApi(Resource):
             userobj = self.userschema.load(body)
         except Exception as e:
             current_app.logger.warning(e)
-            abort(417, "invalid json schema")
+            abort(417, INVALID_JSON_SCHEMA_MSG)
 
-        user = User.query.filter_by(name=userobj['name']).first_or_404()
+        user = VideonUser.query.filter_by(name=userobj['name']).first_or_404()
         authorized = user.check_password(userobj['password'])
         if not authorized:
             abort(401, "username or password incorrect")
@@ -79,14 +83,13 @@ class LoginApi(Resource):
         try:
             user.last_logon = datetime.datetime.now()
             db.session.add(user)
-            db.session.commit()
         except Exception as e:
-            db.session.rollback()
             current_app.logger.exception(e)
-            abort(503, "db session error")
+            abort(503, DB_ERROR_MSG)
 
         expires = datetime.timedelta(days=7)
         access_token = create_access_token(identity=str(user.name), expires_delta=expires)
+        db.session.commit()
         return {'token': access_token}, 200
 
 
@@ -97,7 +100,7 @@ class UsersApi(Resource):
     usermetadataschema = UserMetadataSchema(many=True)
 
     def get(self):
-        users = User.query.all()
+        users = VideonUser.query.all()
         return self.usermetadataschema.dump(users), 200
 
 
@@ -111,7 +114,7 @@ class UserParameterApi(Resource):
         :param username: Username of user (url parameter)
         :return:
         """
-        user = User.query.filter_by(name=username).first_or_404()
+        user = VideonUser.query.filter_by(name=username).first_or_404()
         return self.usermetadataschema.dump(user), 200
 
     def delete(self, username: str):
@@ -120,16 +123,15 @@ class UserParameterApi(Resource):
         :param username: Username of user (url parameter)
         :return:
         """
-        user = User.query.filter_by(name=username).first_or_404()
+        user = VideonUser.query.filter_by(name=username).first_or_404()
 
         try:
             db.session.delete(user)
-            db.session.commit()
         except Exception as e:
-            db.session.rollback()
             current_app.logger.exception(e)
-            abort(503, "db session error")
+            abort(503, DB_ERROR_MSG)
 
+        db.session.commit()
         return self.usermetadataschema.dump(user), 200
 
     def put(self, username: str):
@@ -139,22 +141,21 @@ class UserParameterApi(Resource):
         :return:
         """
         body = request.get_json()
-        user = User.query.filter_by(name=username).first_or_404()
+        user = VideonUser.query.filter_by(name=username).first_or_404()
         try:
             userobj = self.userschema.load(body)
         except Exception as e:
             current_app.logger.warning(e)
-            abort(417, "invalid json schema")
+            abort(417, INVALID_JSON_SCHEMA_MSG)
 
         try:
             user.password = userobj['password']
             user.hash_password()
-            db.session.commit()
         except Exception as e:
-            db.session.rollback()
             current_app.logger.exception(e)
-            abort(503, "db session error")
+            abort(503, DB_ERROR_MSG)
 
+        db.session.commit()
         return self.usermetadataschema.dump(user), 200
 
 
@@ -162,71 +163,352 @@ class CreateIngestResource(Resource):
     """
     See: https://swagger.kmlabz.com/?urls.primaryName=videON%20Backend#/backend/createIngest
     """
+    ingestinputschema = IngestInputSchema(many=False)
+    streamresourceschema = StreamResourceSchema(many=False)
+
     def post(self):
-        pass
+        body = request.get_json()
+
+        try:
+            ingestobj = self.ingestinputschema.load(body)
+        except Exception as e:
+            current_app.logger.warning(e)
+            abort(417, INVALID_JSON_SCHEMA_MSG)
+
+        ingest = StreamResource(resource_type=StreamResourceTypeEnum['INGEST'],
+                                url="rtmp://zelenka.tormakristof.eu:6969/origin/asdasd", x=ingestobj['x'],y=ingestobj['y'])
+
+        # username = get_jwt_identity()
+        username = "jozska"
+        user = VideonUser.query.filter_by(name=username).first_or_404()
+        ingest.owner_id = user.id
+        try:
+            db.session.add(ingest)
+        except Exception as e:
+            current_app.logger.warning(e)
+            abort(503, "object already exists")
+
+        if 'outputNeighbours' in ingestobj:
+            for neighbour in ingestobj['outputNeighbours']:
+                neighbourobj = StreamResource.query.filter_by(id=neighbour).first_or_404()
+                if neighbourobj.resource_type == StreamResourceTypeEnum.INGEST:
+                    abort(400, "ingest cannot be a downstream component")
+                try:
+                    neighbourobj.parent_id = ingest.id
+                except Exception as e:
+                    current_app.logger.warning(e)
+                    abort(503, "could not set neighbourhood")
+
+        db.session.commit()
+        return self.streamresourceschema.dump(ingest), 200
 
 
 class CreateRestreamResource(Resource):
     """
     See: https://swagger.kmlabz.com/?urls.primaryName=videON%20Backend#/backend/createRestream
     """
+    restreaminputschema = RestreamInputSchema(many=False)
+    streamresourceschema = StreamResourceSchema(many=False)
+
     def post(self):
-        pass
+        body = request.get_json()
+
+        try:
+            restreamobj = self.restreaminputschema.load(body)
+        except Exception as e:
+            current_app.logger.warning(e)
+            abort(417, INVALID_JSON_SCHEMA_MSG)
+
+        restream = StreamResource(resource_type=StreamResourceTypeEnum['RESTREAM'],
+                                  url="rtmp://zelenka.tormakristof.eu:6969/origin/asdasd",x=restreamobj['x'],y=restreamobj['y'])
+
+        # username = get_jwt_identity()
+        username = "jozska"
+        user = VideonUser.query.filter_by(name=username).first_or_404()
+        restream.owner_id = user.id
+        if 'inputNeighbour' in restreamobj:
+            restream.parent_id = restreamobj['inputNeighbour']
+        try:
+            db.session.add(restream)
+            db.session.commit()
+        except Exception as e:
+            current_app.logger.warning(e)
+            abort(503, "object already exists")
+        for url in restreamobj['outputURLs']:
+            try:
+                outputurl = OutputUrls(output_url=url, streamresource_id=restream.id)
+                db.session.add(outputurl)
+            except Exception as e:
+                current_app.logger.warning(e)
+                abort(503, "could not add all outputurls")
+
+        db.session.commit()
+        return self.streamresourceschema.dump(restream), 200
 
 
 class CreateEncodeResource(Resource):
     """
     See: https://swagger.kmlabz.com/?urls.primaryName=videON%20Backend#/backend/createEncode
     """
+    encodeinputschema = EncodeInputSchema(many=False)
+    streamresourceschema = StreamResourceSchema(many=False)
+
     def post(self):
-        pass
+        body = request.get_json()
+
+        try:
+            encoderobj = self.encodeinputschema.load(body)
+        except Exception as e:
+            current_app.logger.warning(e)
+            abort(417, INVALID_JSON_SCHEMA_MSG)
+
+        encoder = StreamResource(resource_type=StreamResourceTypeEnum['ENCODE'],
+                                 url="rtmp://zelenka.tormakristof.eu:6969/origin/asdasd",x=encoderobj['x'],y=encoderobj['y'])
+
+        # username = get_jwt_identity()
+        username = "jozska"
+        user = VideonUser.query.filter_by(name=username).first_or_404()
+        encoder.owner_id = user.id
+
+        if 'inputNeighbour' in encoderobj:
+            encoder.parent_id = encoderobj['inputNeighbour']
+
+        if 'bitrate' in encoderobj:
+            encoder.bitrate = encoderobj['bitrate']
+
+        if 'width' in encoderobj:
+            encoder.bitrate = encoderobj['width']
+
+        if 'height' in encoderobj:
+            encoder.bitrate = encoderobj['height']
+
+        try:
+            db.session.add(encoder)
+        except Exception as e:
+            current_app.logger.warning(e)
+            abort(503, "object already exists")
+
+        for neighbour in encoderobj['outputNeighbours']:
+            neighbour = StreamResource.query.filter_by(id=neighbour).first_or_404()
+            if neighbour.resource_type == StreamResourceTypeEnum.INGEST:
+                abort(400, "ingest cannot be a downstream component")
+            try:
+                neighbour.parent_id = encoder.id
+            except Exception as e:
+                current_app.logger.warning(e)
+                abort(503, "could not add all neighbours")
+
+        db.session.commit()
+        return self.streamresourceschema.dump(encoder), 200
 
 
 class GetAllStreamResources(Resource):
     """
     See: https://swagger.kmlabz.com/?urls.primaryName=videON%20Backend#/backend/getResource
     """
+
+    streamresourceschema = StreamResourceSchema(many=True)
+
     def get(self):
-        pass
+        streamreousrces = StreamResource.query.all()
+        return self.streamresourceschema.dump(streamreousrces), 200
 
 
 class ManipulateStreamResource(Resource):
-    def get(self, resourceid: uuid4):
+    streamresourceschema = StreamResourceSchema(many=False)
+
+    def get(self, resourceid: str):
         """
         See: https://swagger.kmlabz.com/?urls.primaryName=videON%20Backend#/backend/getAResource
         :param resourceid:
         :return:
         """
-        pass
+        streamreousrce = StreamResource.query.filter_by(id=UUID(resourceid)).first_or_404()
+        return self.streamresourceschema.dump(streamreousrce), 200
 
-    def delete(self, resourceid: uuid4):
+    def delete(self, resourceid: str):
         """
         See: https://swagger.kmlabz.com/?urls.primaryName=videON%20Backend#/backend/deleteResource
         :param resourceid:
         :return:
         """
-        pass
+        streamreousrce = StreamResource.query.filter_by(id=UUID(resourceid)).first_or_404()
+
+        try:
+            db.session.delete(streamreousrce)
+        except Exception as e:
+            current_app.logger.exception(e)
+            abort(503, DB_ERROR_MSG)
+
+        db.session.commit()
+        return self.streamresourceschema.dump(streamreousrce), 200
 
 
 class ModifyIngressResource(Resource):
     """
     See: https://swagger.kmlabz.com/?urls.primaryName=videON%20Backend#/backend/editIngress
     """
-    def put(self, resourceid: uuid4):
-        pass
+    ingestinputschema = IngestInputSchema(many=False)
+    streamresourceschema = StreamResourceSchema(many=False)
+
+    def put(self, resourceid: str):
+        body = request.get_json()
+
+        try:
+            ingestobj = self.ingestinputschema.load(body)
+        except Exception as e:
+            current_app.logger.warning(e)
+            abort(417, INVALID_JSON_SCHEMA_MSG)
+
+        ingest = StreamResource.query.filter_by(id=resourceid).first_or_404()
+        ingest.x = ingestobj['x']
+        ingest.y = ingestobj['y']
+
+        currentoutputneighbours = ingest.children
+        currentoutputneighboursids = [outputneighbour.id for outputneighbour in currentoutputneighbours]
+
+        if 'outputNeighbours' in ingestobj:
+            for removeneighbours in listdiffer.elementsinfirstlistbutnotinsecond(currentoutputneighboursids,
+                                                                                 ingestobj['outputNeighbours']):
+                neighbourobj = StreamResource.query.filter_by(id=removeneighbours).first_or_404()
+                try:
+                    neighbourobj.parent_id = None
+                except Exception as e:
+                    current_app.logger.warning(e)
+                    abort(503, "could not remove neighbourhood")
+
+            for addneighbours in listdiffer.elementsinsecondlistbutnotinfirst(currentoutputneighboursids,
+                                                                              ingestobj['outputNeighbours']):
+                neighbourobj = StreamResource.query.filter_by(id=addneighbours).first_or_404()
+                if neighbourobj.resource_type == StreamResourceTypeEnum.INGEST:
+                    abort(400, "ingest cannot be a downstream component")
+                try:
+                    neighbourobj.parent_id = ingest.id
+                except Exception as e:
+                    current_app.logger.warning(e)
+                    abort(503, "could not remove neighbourhood")
+        else:
+            if currentoutputneighbours:
+                for currentneighbour in currentoutputneighbours:
+                    try:
+                        currentneighbour.parent_id = None
+                    except Exception as e:
+                        current_app.logger.warning(e)
+                        abort(503, "could not remove neighbourhood")
+
+        db.session.commit()
+        return self.streamresourceschema.dump(ingest), 200
 
 
 class ModifyRestreamResource(Resource):
     """
     See: https://swagger.kmlabz.com/?urls.primaryName=videON%20Backend#/backend/editRestream
     """
-    def put(self, resourceid: uuid4):
-        pass
+    restreaminputschema = RestreamInputSchema(many=False)
+    streamresourceschema = StreamResourceSchema(many=False)
+
+    def put(self, resourceid: str):
+        body = request.get_json()
+
+        try:
+            restreamobj = self.restreaminputschema.load(body)
+        except Exception as e:
+            current_app.logger.warning(e)
+            abort(417, INVALID_JSON_SCHEMA_MSG)
+
+        restream = StreamResource.query.filter_by(id=resourceid).first_or_404()
+        restream.x = restreamobj['x']
+        restream.y = restreamobj['y']
+
+        if 'inputNeighbour' in restreamobj:
+            try:
+                restream.parent_id = restreamobj['inputNeighbour']
+            except Exception as e:
+                current_app.logger.warning(e)
+                abort(503, "could not set parent id")
+
+        currentoutputurls = OutputUrls.query.filter_by(streamresource_id=restream.id).all()
+        currentoutputurlurls = [currentoutputurl.output_url for currentoutputurl in currentoutputurls]
+
+        for deleteoutputurl in listdiffer.elementsinfirstlistbutnotinsecond(currentoutputurlurls,
+                                                                            restreamobj['outputURLs']):
+            elementtodelete = OutputUrls.query.filter_by(output_url=deleteoutputurl,
+                                                         streamresource_id=restream.id).first_or_404()
+            try:
+                db.session.delete(elementtodelete)
+            except Exception as e:
+                current_app.logger.warning(e)
+                abort(503, "could not delete url")
+        for addoutputurl in listdiffer.elementsinsecondlistbutnotinfirst(currentoutputurlurls,
+                                                                         restreamobj['outputURLs']):
+            elementtoadd = OutputUrls(output_url=addoutputurl, streamresource_id=restream.id)
+            try:
+                db.session.add(elementtoadd)
+            except Exception as e:
+                current_app.logger.warning(e)
+                abort(503, "object already exists")
+
+        db.session.commit()
+        return self.streamresourceschema.dump(restream), 200
 
 
 class ModifyEncodeResource(Resource):
     """
     See: https://swagger.kmlabz.com/?urls.primaryName=videON%20Backend#/backend/editEncode
     """
-    def put(self, resourceid: uuid4):
-        pass
+    encodeinputschema = EncodeInputSchema(many=False)
+    streamresourceschema = StreamResourceSchema(many=False)
+
+    def put(self, resourceid: str):
+        body = request.get_json()
+
+        try:
+            encodeobj = self.encodeinputschema.load(body)
+        except Exception as e:
+            current_app.logger.warning(e)
+            abort(417, INVALID_JSON_SCHEMA_MSG)
+
+        encode = StreamResource.query.filter_by(id=resourceid).first_or_404()
+        encode.x = encodeobj['x']
+        encode.y = encodeobj['y']
+
+        if 'inputNeighbour' in encodeobj:
+            encode.parent_id = encodeobj['inputNeighbour']
+
+        if 'bitrate' in encodeobj:
+            encode.bitrate = encodeobj['bitrate']
+
+        if 'width' in encodeobj:
+            encode.bitrate = encodeobj['width']
+
+        if 'height' in encodeobj:
+            encode.bitrate = encodeobj['height']
+
+        currentoutputneighbours = encode.children
+        currentoutputneighboursids = []
+        for outputneighbour in currentoutputneighbours:
+            currentoutputneighboursids.append(outputneighbour.id)
+
+        if 'outputNeighbours' in encodeobj:
+            for removeneighbours in listdiffer.elementsinfirstlistbutnotinsecond(currentoutputneighbours,
+                                                                                 encodeobj['outputNeighbours']):
+                neighbourobj = StreamResource.query.filter_by(id=removeneighbours).first_or_404()
+                neighbourobj.parent_id = None
+
+            for addneighbours in listdiffer.elementsinsecondlistbutnotinfirst(currentoutputneighbours,
+                                                                              encodeobj['outputNeighbours']):
+                neighbourobj = StreamResource.query.filter_by(id=addneighbours).first_or_404()
+                if neighbourobj.resource_type == StreamResourceTypeEnum.INGEST:
+                    abort(400, "ingest cannot be a downstream component")
+                neighbourobj.parent_id = encode.id
+        else:
+            if currentoutputneighbours:
+                for currentneighbour in currentoutputneighbours:
+                    try:
+                        currentneighbour.parent_id = None
+                    except Exception as e:
+                        current_app.logger.warning(e)
+                        abort(503, "could not remove neighbourhood")
+
+        db.session.commit()
+        return self.streamresourceschema.dump(encode), 200