How to return files from routes?

[jsoneaday]

I have this route handler that take a Vec from Sqlx and returns web::Bytes, but my client cannot read it for some reason. Am I doing the route correctly?

pub async fn get_message_image<T: QueryMessageImageFn>(app_data: web::Data<AppState<T>>, path: Path<MessageQuery>) -> actix_web::Result<actix_web::HttpResponse> {
    let message_result = app_data.db_repo.query_message_image(path.id).await;

    match message_result {
        Ok(option_image) => {
            match option_image {
                Some(msg_image) => {
                    let file_bytes: Bytes = Bytes::from(msg_image.image);

                    // Return the file as a response
                    Ok(HttpResponse::Ok()
                        .content_type("image/jpeg") // Set the appropriate content type for your file
                        .body(file_bytes))
                },
                None => Ok(HttpResponse::NotFound().body("File not found"))
            }
        },
        Err(e) => Ok(HttpResponse::NotFound().body("File not found"))
    }
}

[robjtede]

There's nothing obviously wrong with this.

How are you testing it? curl / browser / other ?

[jsoneaday]

Hey Rob. I'm calling this from a react native app, which uses js for its language

[robjtede]

Okay, can you test using curl to eliminate UI-specific concerns like CORS.

[jsoneaday]

Thanks Rob. Yes getting it with curl retrieves a file with the same garbled image. Is it possible then that my upload is breaking the file format? I receive the file as a multipart object called MessageCreateMultipart, which does an impl on FromRequest. Here's my code.

#[serde(rename_all = "camelCase")]
pub struct MessageCreateMultipart {
    pub user_id: i64,
    pub body: String,
    pub group_type: MessageGroupTypes,
    pub broadcasting_msg_id: Option<i64>,
    pub image: Option<Vec<u8>>,
}

impl MessageCreateMultipart {
    async fn from_multipart(
        mut multipart: Multipart
    ) -> Result<Self, <Self as FromRequest>::Error> {
        println!("start MessageCreateMultipart");
        let mut user_id: Option<i64> = None;
        let mut body: Option<String> = None;
        let mut group_type: Option<i32> = None;
        let mut broadcasting_msg_id: Option<i64> = None;
        let mut image: Option<Bytes> = None;
        
        let mut find_fields_loop_count = 0;
        while let Some(field_result) = multipart.next().await {
            find_fields_loop_count += 1;
            info!("find_fields_loop_count {}", find_fields_loop_count);
            if let Err(e) = field_result {
                println!("error {}", e);
                break;
            }

            let mut field = field_result.unwrap();
            let content_disposition = field.content_disposition();
            let field_name = content_disposition.get_name().unwrap();
            println!("field_name {}", field_name);
            match field_name {
                "userId" | "user_id" => {
                    user_id = read_i64(&mut field).await;
                }
                "body" => {
                    body = read_string(&mut field).await;
                }
                "groupType" | "group_type" => {
                    group_type = read_i32(&mut field).await;
                }
                "broadcastingMsgId" | "broadcasting_msg_id" => {
                    broadcasting_msg_id = read_i64(&mut field).await;
                }
                "image" => {
                    if let Ok(Some(bytes)) = field.try_next().await {
                        println!("image found");
                        image = Some(bytes);
                    }
                }
                _ => (),
            }
            if find_fields_loop_count > 6 {
                println!("looping count for finding multipart message fields has exceeded max {}", find_fields_loop_count);
                break;
            }
        }

        if user_id.is_some() && body.is_some() && group_type.is_some() {
            let result = Self {
                user_id: user_id.unwrap(),
                body: body.unwrap(),
                group_type: match group_type.unwrap() {
                    1 => MessageGroupTypes::Public,
                    2 => MessageGroupTypes::Circle,
                    _ => MessageGroupTypes::Public
                },
                broadcasting_msg_id,
                image: if let Some(img) = image {
                    Some(img.to_vec())
                } else {
                    None
                }
            };
            Ok(result)
        } else {
            Err(TwitterResponseError.into())
        }
    }
}

impl FromRequest for MessageCreateMultipart {
    type Error = actix_web::Error;
    type Future = Pin<Box<dyn Future<Output = Result<Self, Self::Error>>>>;

    fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future {
        let multipart_future = Multipart::from_request(req, payload);

        let future = async {
            let multipart = multipart_future.await?;

            Self::from_multipart(multipart).await
        };

        Box::pin(future)
    }
}```

[robjtede]

if let Ok(Some(bytes)) = field.try_next().await {
  println!("image found");
  image = Some(bytes);
}

This is incorrect. bytes here is actually a chunk, not a complete file, so you need to append each chunk uploaded to a buffer before it is a complete image

[jsoneaday]

I think I had started with that but I may have been confused as initially I thought the issue was on the client or the file get route. Let me try it again now. Thanks.

[jsoneaday]

Love it. That did it thank you.

Also thank you and team for the work you're doing on actix web.