New Endpoint for device sharing

Author: fes7713

Network/Lambda/Database/Data/Hardware.py

@@ -28,7 +28,9 @@ class Hardware(Data):
     """Specifies the playback_url attribute column name"""
     S3_RECORDING_PREFIX = "s3_recording_prefix"
     """Specifies the s3_recording_prefix attribute column name"""
-    COLUMNS = [ID, RESOLUTION_NAME, CHANNEL_NAME, DEVICE_ID, NAME, ARN, STREAM_KEY, INGEST_ENDPOINT, PLAYBACK_URL, S3_RECORDING_PREFIX]
+    CODE = "code"
+    """Specifies the code attribute column name"""
+    COLUMNS = [ID, RESOLUTION_NAME, CHANNEL_NAME, DEVICE_ID, NAME, ARN, STREAM_KEY, INGEST_ENDPOINT, PLAYBACK_URL, S3_RECORDING_PREFIX, CODE]
     """organizes the name, id, account id, and resolution name into an array"""
     EXPLICIT_ID = f"{TABLE}.{ID}"
     """Creates an explicit version of the id variable column name"""
@@ -52,15 +54,17 @@ class Hardware(Data):
     """Creates an explicit version of the playback_url name variable column name"""
     EXPLICIT_S3_RECORDING_PREFIX = f"{TABLE}.{S3_RECORDING_PREFIX}"
     """Creates an explicit version of the s3_recording_prefix name variable column name"""
+    EXPLICIT_CODE = f"{TABLE}.{CODE}"
+    """Creates an explicit version of the code name variable column name"""
     EXPLICIT_COLUMNS = [EXPLICIT_ID, EXPLICIT_RESOLUTION_NAME, EXPLICIT_CHANNEL_NAME, EXPLICIT_DEVICE_ID, EXPLICIT_NAME, EXPLICIT_ARN,
                         EXPLICIT_STREAM_KEY, EXPLICIT_INGEST_ENDPOINT, EXPLICIT_PLAYBACK_URL,
-                        EXPLICIT_S3_RECORDING_PREFIX]
+                        EXPLICIT_S3_RECORDING_PREFIX, EXPLICIT_CODE]
     """Organizes the explicit versions of the variables above into an array"""
 
     def __init__(self, device_name: str, max_resolution: str, channel_name: str,
                  arn: str, stream_key: str, ingest_endpoint: str,
                  playback_url: str, device_id: str = "md5(ROUND(UNIX_TIMESTAMP(CURTIME(4)) * 1000))",
-                 s3_recording_prefix: str = None, hardware_id: int = None):
+                 s3_recording_prefix: str = None, code: str = None, hardware_id: int = None):
         """Initializes the name, max resolution, hardware id, and account id variables"""
         self.channel_name = channel_name
         """channel_name     : string<   Store the channel_name of the hardware"""
@@ -80,6 +84,8 @@ def __init__(self, device_name: str, max_resolution: str, channel_name: str,
         """playback_url     : string<   Store the playback_url of the hardware"""
         self.s3_recording_prefix = str(s3_recording_prefix)
         """s3_recording_prefix  : string<   Store the s3_recording_prefix of the hardware"""
+        self.code = str(code)
+        """code             : string<   Store the code of the hardware"""
         self.hardware_id = int(hardware_id) if hardware_id is not None else None
         """hardware_id  : int<      Specify the hardware_id of the hardware (Optional)."""
 
@@ -88,9 +94,9 @@ def __str__(self):
         return "[Hardware    ]              :MAX_RESOLUTION: {:<12} HARDWARE_ID:{:<12} " \
                "CHANNEL_NAME: {:<12} DEVICE_NAME:{:<12} DEVICE_ID:{:<12} " \
                "ARN:{:<12} STREAM_KEY:{:<12} INGEST_ENDPOINT:{:<12} PLAYBACK_URL:{:<12} " \
-               "S3_RECORDING_PREFIX:{:<12}".format(
+               "S3_RECORDING_PREFIX:{:<12} CODE:{:<12}".format(
             self.max_resolution, str(self.hardware_id), self.channel_name, self.device_name, self.device_id, self.arn,
-            self.stream_key, self.ingest_endpoint, self.playback_url, self.s3_recording_prefix
+            self.stream_key, self.ingest_endpoint, self.playback_url, self.s3_recording_prefix, self.code
         )
 
     @staticmethod
@@ -113,11 +119,13 @@ def dict_to_object(payload: dict, explicit=False) -> "Hardware":
                             payload[Hardware.EXPLICIT_CHANNEL_NAME], payload[Hardware.EXPLICIT_ARN],
                             payload[Hardware.EXPLICIT_STREAM_KEY], payload[Hardware.EXPLICIT_INGEST_ENDPOINT],
                             payload[Hardware.EXPLICIT_PLAYBACK_URL], payload[Hardware.EXPLICIT_DEVICE_ID],
-                            payload[Hardware.EXPLICIT_S3_RECORDING_PREFIX], payload[Hardware.EXPLICIT_ID])
+                            payload[Hardware.EXPLICIT_S3_RECORDING_PREFIX], payload[Hardware.EXPLICIT_CODE],
+                            payload[Hardware.EXPLICIT_ID])
         else:
             return Hardware(payload[Hardware.NAME], payload[Hardware.RESOLUTION_NAME],
                             payload[Hardware.CHANNEL_NAME], payload[Hardware.ARN],
                             payload[Hardware.STREAM_KEY], payload[Hardware.INGEST_ENDPOINT],
                             payload[Hardware.PLAYBACK_URL], payload[Hardware.DEVICE_ID],
-                            payload[Hardware.S3_RECORDING_PREFIX], payload[Hardware.ID])
+                            payload[Hardware.S3_RECORDING_PREFIX], payload[Hardware.CODE],
+                            payload[Hardware.ID])
 

Network/Lambda/Database/MPCDatabase.py

@@ -886,49 +886,12 @@ def varidate_timestamp(self, table_name, field: str, value: str) -> bool:
                          "sk_us-east-1_DdqDOfelQCU9_ofTx6s4yekNFgesMT8eLdWIS9k8zLV",
                          "rtmps://1958e2d97d88.global-contribute.live-video.net:443/app/",
                          "https://1958e2d97d88.us-east-1.playback.live-video.net/api/video/v1/us-east-1.052524269538.channel.HCBh4loJzOvw.m3u8")
-    hardware2 = Hardware("Hardware-2", "1080p", "test-ivs",
-                         "arn:aws:ivs:us-east-1:052524269538:channel/HCBh4loJzOvw",
-                         "sk_us-east-1_DdqDOfelQCU9_ofTx6s4yekNFgesMT8eLdWIS9k8zLV",
-                         "rtmps://1958e2d97d88.global-contribute.live-video.net:443/app/",
-                         "https://1958e2d97d88.us-east-1.playback.live-video.net/api/video/v1/us-east-1.052524269538.channel.HCBh4loJzOvw.m3u8")
-    hardware3 = Hardware("Hardware-3", "1080p", "test-ivs",
-                         "arn:aws:ivs:us-east-1:052524269538:channel/HCBh4loJzOvw",
-                         "sk_us-east-1_DdqDOfelQCU9_ofTx6s4yekNFgesMT8eLdWIS9k8zLV",
-                         "rtmps://1958e2d97d88.global-contribute.live-video.net:443/app/",
-                         "https://1958e2d97d88.us-east-1.playback.live-video.net/api/video/v1/us-east-1.052524269538.channel.HCBh4loJzOvw.m3u8")
-    hardware4 = Hardware("Hardware-4", "1080p", "test-ivs",
-                         "arn:aws:ivs:us-east-1:052524269538:channel/HCBh4loJzOvw",
-                         "sk_us-east-1_DdqDOfelQCU9_ofTx6s4yekNFgesMT8eLdWIS9k8zLV",
-                         "rtmps://1958e2d97d88.global-contribute.live-video.net:443/app/",
-                         "https://1958e2d97d88.us-east-1.playback.live-video.net/api/video/v1/us-east-1.052524269538.channel.HCBh4loJzOvw.m3u8")
-    hardware5 = Hardware("Hardware-5", "720p", "test-ivs",
-                         "arn:aws:ivs:us-east-1:052524269538:channel/HCBh4loJzOvw",
-                         "sk_us-east-1_DdqDOfelQCU9_ofTx6s4yekNFgesMT8eLdWIS9k8zLV",
-                         "rtmps://1958e2d97d88.global-contribute.live-video.net:443/app/",
-                         "https://1958e2d97d88.us-east-1.playback.live-video.net/api/video/v1/us-east-1.052524269538.channel.HCBh4loJzOvw.m3u8")
-    hardware6 = Hardware("Hardware-6", "720p", "test-ivs",
-                         "arn:aws:ivs:us-east-1:052524269538:channel/HCBh4loJzOvw",
-                         "sk_us-east-1_DdqDOfelQCU9_ofTx6s4yekNFgesMT8eLdWIS9k8zLV",
-                         "rtmps://1958e2d97d88.global-contribute.live-video.net:443/app/",
-                         "https://1958e2d97d88.us-east-1.playback.live-video.net/api/video/v1/us-east-1.052524269538.channel.HCBh4loJzOvw.m3u8")
-    hardware7 = Hardware("Hardware-7", "720p", "test-ivs",
-                         "arn:aws:ivs:us-east-1:052524269538:channel/HCBh4loJzOvw",
-                         "sk_us-east-1_DdqDOfelQCU9_ofTx6s4yekNFgesMT8eLdWIS9k8zLV",
-                         "rtmps://1958e2d97d88.global-contribute.live-video.net:443/app/",
-                         "https://1958e2d97d88.us-east-1.playback.live-video.net/api/video/v1/us-east-1.052524269538.channel.HCBh4loJzOvw.m3u8")
-
-    for h in [hardware1, hardware2, hardware3, hardware4, hardware5, hardware6, hardware7]:
+    for h in [hardware1]:
         database.insert(h, ignore=True)
 
     account_hardware_map = {
         id_a: {
-            hardware1, hardware2, hardware3
-        },
-        id_a1: {
-            hardware4, hardware5
-        },
-        id_a2: {
-            hardware6, hardware7
+            hardware1
         }
     }
 
@@ -938,12 +901,12 @@ def varidate_timestamp(self, table_name, field: str, value: str) -> bool:
                                                Hardware.NAME, hardware.device_name)
             database.insert(Account_has_Hardware(id, id_h), True)
 
-    id_a_h = database.get_fields_by_field(Account_has_Hardware, Account_has_Hardware.HARDWARE_ID,
-                                          Account_has_Hardware.ACCOUNT_ID, str(id_a))
-    id_a1_h = database.get_fields_by_field(Account_has_Hardware, Account_has_Hardware.HARDWARE_ID,
-                                           Account_has_Hardware.ACCOUNT_ID, str(id_a1))
-    id_a2_h = database.get_fields_by_field(Account_has_Hardware, Account_has_Hardware.HARDWARE_ID,
-                                           Account_has_Hardware.ACCOUNT_ID, str(id_a2))
+    # id_a_h = database.get_fields_by_field(Account_has_Hardware, Account_has_Hardware.HARDWARE_ID,
+    #                                       Account_has_Hardware.ACCOUNT_ID, str(id_a))
+    # id_a1_h = database.get_fields_by_field(Account_has_Hardware, Account_has_Hardware.HARDWARE_ID,
+    #                                        Account_has_Hardware.ACCOUNT_ID, str(id_a1))
+    # id_a2_h = database.get_fields_by_field(Account_has_Hardware, Account_has_Hardware.HARDWARE_ID,
+    #                                        Account_has_Hardware.ACCOUNT_ID, str(id_a2))
 
     data = database.get_all(Hardware)
     for d in data:
@@ -968,7 +931,7 @@ def varidate_timestamp(self, table_name, field: str, value: str) -> bool:
     for d in data:
         print(str(d))
 
-    print(id_a_h)
+    # print(id_a_h)
     # recording1 = Recording("_import_616e5dcf2a2362.07330217_preview.mp4", "CURDATE()", "NOW()", account_id=id_a,
     #                        hardware_id=random.choice(id_a_h))
     # recording2 = Recording("_import_616e710b7f2ff0.35776522_preview.mp4", "CURDATE()", "NOW()", account_id=id_a,
@@ -987,22 +950,5 @@ def varidate_timestamp(self, table_name, field: str, value: str) -> bool:
     #     print(str(d))
 
     a = Account("Keita Nakashima", "Password", "tun05036@temple.edu")
-    database.insert(a, ignore=True)
-
-    database.update(Account, MatchItem(Account.ID, 4),
-                    [MatchItem(Account.TOKEN, "md5(ROUND(UNIX_TIMESTAMP(CURTIME(4)) * 1000))")])
-    a = database.get_by_name(Account, "Keita Nakashima")
-    print(a)
-    max = database.get_max_id(Account)
-    print(database.get_field_by_name(Account, Account.TOKEN, "Keita Nakashima"))
-    print(max)
-
-    database.delete(Account, [MatchItem(Account.NAME, "username")])
-    print("Value" + str(database.get_field_by_name(Account, Account.ID, "username")))
-
-    print(database.get_field_by_field(Account, Account.NAME, Account.EMAIL, "username1@email.com"))
-    print(MatchItem("Key", "NONE").value)
-    print(database.varidate_timestamp(Account, Account.NAME, "username1"))
-
 
     database.close()

Network/Lambda/lambda_function.py

@@ -554,6 +554,53 @@ def hardware_newname(event, pathPara, queryPara):
     return json_payload({"name": f"{prefix} {max(prefixed_numbers) + 1}"})
 
 
+@api.handle("/hardware/share", httpMethod=MPC_API.POST)
+def hardware_newname(event, pathPara, queryPara):
+    """Inserts new rows into the hardware table based on account id"""
+    body = event["body"]
+    if not database.verify_fields_by_joins(
+            Account,
+           [(Account_has_Hardware, Account_has_Hardware.EXPLICIT_ACCOUNT_ID,
+             Account.EXPLICIT_ID),
+            (Hardware, Hardware.EXPLICIT_HARDWARE_ID,
+             Account_has_Hardware.EXPLICIT_HARDWARE_ID)],
+           [(Account.TOKEN, body[Account.TOKEN]),
+            (Hardware.EXPLICIT_DEVICE_ID, body[Hardware.DEVICE_ID])]):
+        return json_payload({"message": Error.DEVICE_NOT_FOUND}, True)
+
+    code = random.randint(0, 999999)
+    code_zero = str(code).zfill(6)
+    if database.verify_field(Hardware, Hardware.CODE, code_zero):
+        return json_payload({"message": "Failed to generate code"}, True)
+
+    database.update_fields(Hardware, (Hardware.DEVICE_ID, body[Hardware.DEVICE_ID]), [(Hardware.CODE, code_zero)])
+
+    result_code = database.get_field_by_field(Hardware, Hardware.CODE, Hardware.DEVICE_ID, body[Hardware.DEVICE_ID])
+
+    return json_payload({"code": result_code})
+
+
+@api.handle("/hardware/code", httpMethod=MPC_API.POST)
+def hardware_newname(event, pathPara, queryPara):
+    """Inserts new rows into the hardware table based on account id"""
+    body = event["body"]
+
+    id_a = database.get_field_by_field(Account, Account.ID, Account.TOKEN, body[Account.TOKEN])
+    id_h = database.get_field_by_field(Hardware, Hardware.ID, Hardware.CODE, body[Hardware.CODE])
+
+    if id_a is None:
+        return json_payload({"message": Error.UNKNOWN_ACCOUNT}, True)
+
+    if id_h is None:
+        return json_payload({"message": Error.DEVICE_NOT_FOUND}, True)
+
+    database.update_fields(Hardware, (Hardware.CODE, body[Hardware.CODE]), [(Hardware.CODE, None)])
+
+    database.insert(Account_has_Hardware(id_a, id_h))
+
+    return json_payload({"message": "Successfully connected account to device"})
+
+
 @api.handle("/hardware/{id}")
 def hardware_request_by_id(event, pathPara, queryPara):
     """Gets information from the hardware table based on specified id"""
@@ -915,7 +962,7 @@ def send_email(event, pathPara, queryPara):
 def file_all(event, pathPara, queryPara):
     token = event["body"]["token"]
     if not database.verify_field(Account, Account.TOKEN, token):
-        return json_payload({"message": "Account does not exist"})
+        return json_payload({"message": Error.UNKNOWN_ACCOUNT}, True)
 
     records = database.query(
         f"""Select distinct arn From Account 
@@ -951,7 +998,7 @@ def file_all(event, pathPara, queryPara):
 def file_delete(event, pathPara, queryPara):
     token = event["body"]["token"]
     if not database.verify_field(Account, Account.TOKEN, token):
-        return json_payload({"message": "Account does not exist"})
+        return json_payload({"message": Error.UNKNOWN_ACCOUNT}, True)
 
     # channelId/year-month-date-hour-minute-id
     file_name = event["body"][Recording.NAME]
@@ -969,14 +1016,14 @@ def file_delete(event, pathPara, queryPara):
 
 if __name__ == "__main__":
     event = {
-        "resource": "/hardware/delete",
+        "resource": "/hardware/all",
         "httpMethod": MPC_API.POST,
         "body": """{
             "username": "John Smith",
             "password": "Password",
             "email": "default@temple.edu",
             "code": "658186",
-            "token": "f7af2efa2a0e81263b136664ca61e0d9",
+            "token": "afd39d162160bf1e0ef609efd8dc3530",
             "file_name": "vIvvphhE1OJL/2023-4-27-17-35-t0QjMMgqDKRm",
             "device_id": "5f2a07aa327872954a00d28027549a94567b5b76dfefed03b9c9bc77"
         }"""