update

etc.jl

@@ -1,15 +1,172 @@
-the user will provide data in this form: [("dataname1", data1, "datatype1"), ("dataname2", data2, "datatype2"), ...]
-For example:
-[
-  ("name", "ton", "text"), 
-  ("age", 15, "Integer"), 
-  ("school_info", Dict("schoolname"=> "Bodin", "classmates_number"=> 52), "dictionary"), 
-  ("classmate_names", Dataframe_data, "table"), 
-  ("ton_image", image_data, "image"),
-  ("ton_audio", audio_data, "audio"),
-  ("ton_birthday_video", video_data, "video"),
-  ("achievement.zip", file_data, "binary"),
-]
+
+
+using Revise
+using NATS, JSON, UUIDs, Dates
+using HTTP
+
+
+# workdir = 
+
+# Include the bridge module
+include("./src/NATSBridge.jl")
+using .NATSBridge
+
+# Configuration
+const SUBJECT = "/NATSBridge_test"
+const NATS_URL = "nats.yiem.cc"
+const FILESERVER_URL = "http://192.168.88.104:8080"
+
+# Create correlation ID for tracing
+correlation_id = string(uuid4())
+
+
+# ------------------------------------------------------------------------------------------------ #
+#                                        test file transfer                                        #
+# ------------------------------------------------------------------------------------------------ #
+
+# File path for large binary payload test
+const FILE_PATH = "./testFile_small.zip"
+const filename = basename(FILE_PATH)
+
+# Helper: Log with correlation ID
+function log_trace(message)
+    timestamp = Dates.now()
+    println("[$timestamp] [Correlation: $correlation_id] $message")
+end
+
+
+function _serialize_data(data::Any, type::String)
+    if type == "text"  # Text data - convert to UTF-8 bytes
+        if isa(data, String)
+            return bytes(data)  # Convert string to UTF-8 bytes
+        else
+            error("Text data must be a String")
+        end
+    elseif type == "dictionary"  # JSON data - serialize directly
+        json_str = JSON.json(data)  # Convert Julia data to JSON string
+        return bytes(json_str)  # Convert JSON string to bytes
+    elseif type == "table"  # Table data - convert to Arrow IPC stream
+        io = IOBuffer()  # Create in-memory buffer
+        Arrow.write(io, data)  # Write data as Arrow IPC stream to buffer
+        return take!(io)  # Return the buffer contents as bytes
+    elseif type == "image"  # Image data - treat as binary
+        if isa(data, Vector{UInt8})
+            return data  # Return binary data directly
+        else
+            error("Image data must be Vector{UInt8}")
+        end
+    elseif type == "audio"  # Audio data - treat as binary
+        if isa(data, Vector{UInt8})
+            return data  # Return binary data directly
+        else
+            error("Audio data must be Vector{UInt8}")
+        end
+    elseif type == "video"  # Video data - treat as binary
+        if isa(data, Vector{UInt8})
+            return data  # Return binary data directly
+        else
+            error("Video data must be Vector{UInt8}")
+        end
+    elseif type == "binary"  # Binary data - treat as binary
+        if isa(data, IOBuffer)  # Check if data is an IOBuffer
+            return take!(data)  # Return buffer contents as bytes
+        elseif isa(data, Vector{UInt8})  # Check if data is already binary
+            return data  # Return binary data directly
+        else  # Unsupported binary data type
+            error("Binary data must be binary (Vector{UInt8} or IOBuffer)")
+        end
+    else  # Unknown type
+        error("Unknown type: $type")
+    end
+end
+
+
+# File upload handler for plik server
+function plik_upload_handler(fileserver_url::String, dataname::String, data::Vector{UInt8})::Dict{String, Any}
+    # Get upload ID
+    url_getUploadID = "$fileserver_url/upload"
+    headers = ["Content-Type" => "application/json"]
+    body = """{ "OneShot" : true }"""
+    httpResponse = HTTP.request("POST", url_getUploadID, headers, body; body_is_form=false)
+    responseJson = JSON.parse(String(httpResponse.body))
+    uploadid = responseJson["id"]
+    uploadtoken = responseJson["uploadToken"]
+    
+    # Upload file
+    file_multipart = HTTP.Multipart(dataname, IOBuffer(data), "application/octet-stream")
+    url_upload = "$fileserver_url/file/$uploadid"
+    headers = ["X-UploadToken" => uploadtoken]
+    
+    form = HTTP.Form(Dict("file" => file_multipart))
+    httpResponse = HTTP.post(url_upload, headers, form)
+    responseJson = JSON.parse(String(httpResponse.body))
+    
+    fileid = responseJson["id"]
+    url = "$fileserver_url/file/$uploadid/$fileid/$dataname"
+    
+    return Dict("status" => httpResponse.status, "uploadid" => uploadid, "fileid" => fileid, "url" => url)
+end
+
+function log_trace(correlation_id::String, message::String)
+    timestamp = Dates.now()  # Get current timestamp
+    @info "[$timestamp] [Correlation: $correlation_id] $message"  # Log formatted message
+end
+
+file_data = read(FILE_PATH)
+file_size = length(file_data)
+
+
+subject::String=SUBJECT
+data::AbstractArray{Tuple{String, Array{UInt8, 1}, String}, 1}=[(filename, file_data, "binary")]
+nats_url::String=DEFAULT_NATS_URL
+fileserver_url::String=DEFAULT_FILESERVER_URL
+fileserverUploadHandler::Function=plik_upload_handler
+size_threshold::Int=1_000_000
+correlation_id::Union{String, Nothing}=correlation_id
+msg_purpose::String="chat"
+sender_name::String="sender"
+receiver_name::String="receiver_name"
+receiver_id::String="receiver_id"
+reply_to::String="reply_to"
+reply_to_msg_id::String="reply_to_msg_id"
+
+
+
+(dataname, payload_data, payload_type) = data[1]
+payload_bytes = _serialize_data(payload_data, payload_type)
+      
+      payload_size = length(payload_bytes)  # Calculate payload size in bytes
+      log_trace(cid, "Serialized payload '$dataname' (type: $payload_type) size: $payload_size bytes")  # Log payload size
+
+payload_b64 = Base64.base64encode(payload_bytes)  # Encode bytes as base64 string
+log_trace(cid, "Using direct transport for $payload_size bytes")
+
+payload = msgPayload_v1(
+              id = string(uuid4()),
+              dataname = dataname,
+              type = payload_type,
+              transport = "direct",
+              encoding = "base64",
+              size = payload_size,
+              data = payload_b64,
+              metadata = Dict("payload_bytes" => payload_size)
+          )
+
+push!(payloads, payload)
+
+
+
+
+
+
+
+
+
+
+
+
+
+