[FEATURE] Import max size fixed.

Author: Rafael24595

Cargo.toml

@@ -5,6 +5,12 @@ edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[profile.dev]
+opt-level = 3
+
+[profile.release]
+opt-level = 3
+
 [dependencies]
 tokio = { version = "1", features = ["full"] }
 lazy_static = "1.4.0"

src/infrastructure/controller_collection.rs

@@ -1,5 +1,5 @@
 use axum::{
-    extract::Path,
+    extract::{DefaultBodyLimit, Path},
     http::StatusCode,
     middleware,
     response::IntoResponse,
@@ -10,7 +10,7 @@ use rust_db_manager_core::{
     commons::configuration::configuration::Configuration,
     domain::{
         collection::generate_collection_query::GenerateCollectionQuery,
-        filter::{collection_query::CollectionQuery, data_base_query::DataBaseQuery, document_query::DocumentQuery},
+        filter::{collection_query::CollectionQuery, data_base_query::DataBaseQuery},
     },
 };
 
@@ -30,14 +30,15 @@ impl ControllerCollection {
 
     pub fn route(router: Router) -> Router {
         router
+            .route("/api/v1/service/:service/data-base/:data_base/collection/:collection/import", post(Self::import))
+            .layer(DefaultBodyLimit::max(52428800 ))
             .route("/api/v1/service/:service/data-base/:data_base/collection", get(Self::find_all))
             .route("/api/v1/service/:service/data-base/:data_base/collection", post(Self::insert))
             .route("/api/v1/service/:service/data-base/:data_base/collection/:collection", delete(Self::delete))
             .route("/api/v1/service/:service/data-base/:data_base/collection/:collection/metadata", get(Self::metadata))
             .route("/api/v1/service/:service/data-base/:data_base/collection/:collection/schema", get(Self::schema))
             .route("/api/v1/service/:service/data-base/:data_base/collection/:collection/rename", post(Self::rename))
             .route("/api/v1/service/:service/data-base/:data_base/collection/:collection/export", get(Self::export))
-            .route("/api/v1/service/:service/data-base/:data_base/collection/:collection/import", post(Self::import))
             .route_layer(middleware::from_fn(handler::autentication_handler))
     }
 

src/infrastructure/pagination.rs

@@ -6,48 +6,48 @@ impl Pagination {
 
     pub fn paginate<T: Clone>(params: DTOQueryPagination, collection: Vec<T>) -> DTOPaginatedCollection<T> {
         let size = collection.len();
-        let offset = params.offset;
         let limit = params.limit;
+        let offset = params.offset;
 
-        if offset >= size {
-            let previous = Pagination::calculate_previous(size, offset, limit);
+        if limit >= size {
+            let previous = Pagination::calculate_previous(size, limit, offset);
             return DTOPaginatedCollection::new(size, previous, size, Vec::new());
         }
 
-        if size == 0 || limit == 0 {
-            return DTOPaginatedCollection::new(size, offset, offset, Vec::new());
+        if size == 0 || offset == 0 {
+            return DTOPaginatedCollection::new(size, limit, limit, Vec::new());
         }
 
-        let mut limit_fixed = limit;
-        if offset + limit >= size {
-            limit_fixed = size - offset;
+        let mut offset_fixed = offset;
+        if limit + offset >= size {
+            offset_fixed = size - limit;
         }
 
-        let cursor = offset + limit_fixed;
+        let cursor = limit + offset_fixed;
 
-        let next = Pagination::calculate_next(size, cursor, limit);
-        let previous = Pagination::calculate_previous(size, cursor, limit);
+        let next = Pagination::calculate_next(size, cursor, offset);
+        let previous = Pagination::calculate_previous(size, cursor, offset);
 
-        let slice = collection[offset..=cursor-1].to_vec();
+        let slice = collection[limit..=cursor-1].to_vec();
 
         return DTOPaginatedCollection::new(size, previous, next, slice);
     }
 
-    fn calculate_next(size: usize, cursor: usize, limit: usize) -> usize {
-        let next = cursor + limit;
+    fn calculate_next(size: usize, cursor: usize, offset: usize) -> usize {
+        let next = cursor + offset;
         if next >= size {
             return size;
         }
         return next;
     }
 
-    fn calculate_previous(size: usize, cursor: usize, limit: usize) -> usize {
-        if cursor.checked_sub(limit).is_none() {
+    fn calculate_previous(size: usize, cursor: usize, offset: usize) -> usize {
+        if cursor.checked_sub(offset).is_none() {
             return 0;
         }
-        let previous = cursor - limit;
+        let previous = cursor - offset;
         if previous > size {
-            return Pagination::calculate_previous(size, size, limit);
+            return Pagination::calculate_previous(size, size, offset);
         }
         return previous;
     }