refactor: [#615] renamed variables to maybe_user_id

Author: mario-nt

src/services/about.rs

@@ -24,9 +24,9 @@ impl Service {
     ///
     /// * The user does not have the required permissions.
     /// * There is an error authorizing the action.
-    pub async fn get_about_page(&self, opt_user_id: Option<UserId>) -> Result<String, ServiceError> {
+    pub async fn get_about_page(&self, maybe_user_id: Option<UserId>) -> Result<String, ServiceError> {
         self.authorization_service
-            .authorize(ACTION::GetAboutPage, opt_user_id)
+            .authorize(ACTION::GetAboutPage, maybe_user_id)
             .await?;
 
         let html = r#"
@@ -58,9 +58,9 @@ impl Service {
     ///
     /// * The user does not have the required permissions.
     /// * There is an error authorizing the action.
-    pub async fn get_license_page(&self, opt_user_id: Option<UserId>) -> Result<String, ServiceError> {
+    pub async fn get_license_page(&self, maybe_user_id: Option<UserId>) -> Result<String, ServiceError> {
         self.authorization_service
-            .authorize(ACTION::GetLicensePage, opt_user_id)
+            .authorize(ACTION::GetLicensePage, maybe_user_id)
             .await?;
 
         let html = r#"

src/services/authorization.rs

@@ -74,8 +74,8 @@ impl Service {
     /// Will return an error if:
     /// - The user is not authorized to perform the action.
 
-    pub async fn authorize(&self, action: ACTION, opt_user_id: Option<UserId>) -> std::result::Result<(), ServiceError> {
-        let role = self.get_role(opt_user_id).await;
+    pub async fn authorize(&self, action: ACTION, maybe_user_id: Option<UserId>) -> std::result::Result<(), ServiceError> {
+        let role = self.get_role(maybe_user_id).await;
 
         let enforcer = self.casbin_enforcer.enforcer.read().await;
 

src/services/category.rs

@@ -87,9 +87,9 @@ impl Service {
     ///
     /// * The user does not have the required permissions.
     /// * There is a database error retrieving the categories.
-    pub async fn get_categories(&self, opt_user_id: Option<UserId>) -> Result<Vec<Category>, ServiceError> {
+    pub async fn get_categories(&self, maybe_user_id: Option<UserId>) -> Result<Vec<Category>, ServiceError> {
         self.authorization_service
-            .authorize(ACTION::GetCategories, opt_user_id)
+            .authorize(ACTION::GetCategories, maybe_user_id)
             .await?;
 
         self.category_repository

src/services/proxy.rs

@@ -39,13 +39,13 @@ impl Service {
     /// * The image is too big.
     /// * The user quota is met.
     #[allow(clippy::missing_panics_doc)]
-    pub async fn get_image_by_url(&self, url: &str, opt_user_id: Option<UserId>) -> Result<Bytes, Error> {
+    pub async fn get_image_by_url(&self, url: &str, maybe_user_id: Option<UserId>) -> Result<Bytes, Error> {
         self.authorization_service
-            .authorize(ACTION::GetImageByUrl, opt_user_id)
+            .authorize(ACTION::GetImageByUrl, maybe_user_id)
             .await
             .map_err(|_| Error::Unauthenticated)?;
 
-        // The unwrap should never panic as if the opt_user_id is none, an authorization error will be returned and handled at the method above
-        self.image_cache_service.get_image_by_url(url, opt_user_id.unwrap()).await
+        // The unwrap should never panic as if the maybe_user_id is none, an authorization error will be returned and handled at the method above
+        self.image_cache_service.get_image_by_url(url, maybe_user_id.unwrap()).await
     }
 }

src/services/settings.rs

@@ -62,9 +62,9 @@ impl Service {
     /// # Errors
     ///
     /// It returns an error if the user does not have the required permissions.
-    pub async fn get_public(&self, opt_user_id: Option<UserId>) -> Result<ConfigurationPublic, ServiceError> {
+    pub async fn get_public(&self, maybe_user_id: Option<UserId>) -> Result<ConfigurationPublic, ServiceError> {
         self.authorization_service
-            .authorize(ACTION::GetPublicSettings, opt_user_id)
+            .authorize(ACTION::GetPublicSettings, maybe_user_id)
             .await?;
 
         let settings_lock = self.configuration.get_all().await;

src/services/tag.rs

@@ -77,8 +77,8 @@ impl Service {
     ///
     /// * The user does not have the required permissions.
     /// * There is a database error retrieving the tags.
-    pub async fn get_tags(&self, opt_user_id: Option<UserId>) -> Result<Vec<TorrentTag>, ServiceError> {
-        self.authorization_service.authorize(ACTION::GetTags, opt_user_id).await?;
+    pub async fn get_tags(&self, maybe_user_id: Option<UserId>) -> Result<Vec<TorrentTag>, ServiceError> {
+        self.authorization_service.authorize(ACTION::GetTags, maybe_user_id).await?;
 
         self.tag_repository.get_all().await.map_err(|_| ServiceError::DatabaseError)
     }

src/services/torrent.rs

@@ -262,8 +262,10 @@ impl Index {
     ///
     /// This function will return an error if unable to get the torrent from the
     /// database.
-    pub async fn get_torrent(&self, info_hash: &InfoHash, opt_user_id: Option<UserId>) -> Result<Torrent, ServiceError> {
-        self.authorization_service.authorize(ACTION::GetTorrent, opt_user_id).await?;
+    pub async fn get_torrent(&self, info_hash: &InfoHash, maybe_user_id: Option<UserId>) -> Result<Torrent, ServiceError> {
+        self.authorization_service
+            .authorize(ACTION::GetTorrent, maybe_user_id)
+            .await?;
 
         let mut torrent = self.torrent_repository.get_by_info_hash(info_hash).await?;
 
@@ -275,7 +277,7 @@ impl Index {
 
         if !tracker_is_private {
             torrent.include_url_as_main_tracker(&tracker_url);
-        } else if let Some(authenticated_user_id) = opt_user_id {
+        } else if let Some(authenticated_user_id) = maybe_user_id {
             let personal_announce_url = self.tracker_service.get_personal_announce_url(authenticated_user_id).await?;
             torrent.include_url_as_main_tracker(&personal_announce_url);
         } else {
@@ -331,16 +333,16 @@ impl Index {
     pub async fn get_torrent_info(
         &self,
         info_hash: &InfoHash,
-        opt_user_id: Option<UserId>,
+        maybe_user_id: Option<UserId>,
     ) -> Result<TorrentResponse, ServiceError> {
         self.authorization_service
-            .authorize(ACTION::GetTorrentInfo, opt_user_id)
+            .authorize(ACTION::GetTorrentInfo, maybe_user_id)
             .await?;
 
         let torrent_listing = self.torrent_listing_generator.one_torrent_by_info_hash(info_hash).await?;
 
         let torrent_response = self
-            .build_full_torrent_response(torrent_listing, info_hash, opt_user_id)
+            .build_full_torrent_response(torrent_listing, info_hash, maybe_user_id)
             .await?;
 
         Ok(torrent_response)
@@ -354,10 +356,10 @@ impl Index {
     pub async fn generate_torrent_info_listing(
         &self,
         request: &ListingRequest,
-        opt_user_id: Option<UserId>,
+        maybe_user_id: Option<UserId>,
     ) -> Result<TorrentsResponse, ServiceError> {
         self.authorization_service
-            .authorize(ACTION::GenerateTorrentInfoListing, opt_user_id)
+            .authorize(ACTION::GenerateTorrentInfoListing, maybe_user_id)
             .await?;
 
         let torrent_listing_specification = self.listing_specification_from_user_request(request).await;
@@ -484,7 +486,7 @@ impl Index {
         &self,
         torrent_listing: TorrentListing,
         info_hash: &InfoHash,
-        opt_user_id: Option<UserId>,
+        maybe_user_id: Option<UserId>,
     ) -> Result<TorrentResponse, ServiceError> {
         let torrent_id: i64 = torrent_listing.torrent_id;
 
@@ -515,7 +517,7 @@ impl Index {
 
         if self.tracker_is_private().await {
             // Add main tracker URL
-            match opt_user_id {
+            match maybe_user_id {
                 Some(user_id) => {
                     let personal_announce_url = self.tracker_service.get_personal_announce_url(user_id).await?;
 
@@ -568,10 +570,10 @@ impl Index {
     pub async fn get_canonical_info_hash(
         &self,
         info_hash: &InfoHash,
-        opt_user_id: Option<UserId>,
+        maybe_user_id: Option<UserId>,
     ) -> Result<Option<InfoHash>, ServiceError> {
         self.authorization_service
-            .authorize(ACTION::GetCanonicalInfoHash, opt_user_id)
+            .authorize(ACTION::GetCanonicalInfoHash, maybe_user_id)
             .await?;
 
         self.torrent_info_hash_repository

src/web/api/server/v1/contexts/about/handlers.rs

@@ -12,9 +12,9 @@ use crate::web::api::server::v1::extractors::optional_user_id::ExtractOptionalLo
 #[allow(clippy::unused_async)]
 pub async fn about_page_handler(
     State(app_data): State<Arc<AppData>>,
-    ExtractOptionalLoggedInUser(opt_user_id): ExtractOptionalLoggedInUser,
+    ExtractOptionalLoggedInUser(maybe_user_id): ExtractOptionalLoggedInUser,
 ) -> Response {
-    match app_data.about_service.get_about_page(opt_user_id).await {
+    match app_data.about_service.get_about_page(maybe_user_id).await {
         Ok(html) => (StatusCode::OK, [(header::CONTENT_TYPE, "text/html; charset=utf-8")], html).into_response(),
         Err(error) => error.into_response(),
     }
@@ -23,9 +23,9 @@ pub async fn about_page_handler(
 #[allow(clippy::unused_async)]
 pub async fn license_page_handler(
     State(app_data): State<Arc<AppData>>,
-    ExtractOptionalLoggedInUser(opt_user_id): ExtractOptionalLoggedInUser,
+    ExtractOptionalLoggedInUser(maybe_user_id): ExtractOptionalLoggedInUser,
 ) -> Response {
-    match app_data.about_service.get_license_page(opt_user_id).await {
+    match app_data.about_service.get_license_page(maybe_user_id).await {
         Ok(html) => (StatusCode::OK, [(header::CONTENT_TYPE, "text/html; charset=utf-8")], html)
             .into_response()
             .into_response(),

src/web/api/server/v1/contexts/category/handlers.rs

@@ -28,9 +28,9 @@ use crate::web::api::server::v1::responses::{self};
 #[allow(clippy::unused_async)]
 pub async fn get_all_handler(
     State(app_data): State<Arc<AppData>>,
-    ExtractOptionalLoggedInUser(opt_user_id): ExtractOptionalLoggedInUser,
+    ExtractOptionalLoggedInUser(maybe_user_id): ExtractOptionalLoggedInUser,
 ) -> Response {
-    match app_data.category_service.get_categories(opt_user_id).await {
+    match app_data.category_service.get_categories(maybe_user_id).await {
         Ok(categories) => {
             let categories: Vec<Category> = categories.into_iter().map(Category::from).collect();
             Json(responses::OkResponseData { data: categories }).into_response()

src/web/api/server/v1/contexts/proxy/handlers.rs

@@ -14,7 +14,7 @@ use crate::web::api::server::v1::extractors::optional_user_id::ExtractOptionalLo
 #[allow(clippy::unused_async)]
 pub async fn get_proxy_image_handler(
     State(app_data): State<Arc<AppData>>,
-    ExtractOptionalLoggedInUser(opt_user_id): ExtractOptionalLoggedInUser,
+    ExtractOptionalLoggedInUser(maybe_user_id): ExtractOptionalLoggedInUser,
     Path(url): Path<String>,
 ) -> Response {
     // code-review: Handling status codes in the index-gui other tan OK is quite a pain.
@@ -27,7 +27,7 @@ pub async fn get_proxy_image_handler(
     // Get image URL from URL path parameter.
     let image_url = urlencoding::decode(&url).unwrap_or_default().into_owned();
 
-    match app_data.proxy_service.get_image_by_url(&image_url, opt_user_id).await {
+    match app_data.proxy_service.get_image_by_url(&image_url, maybe_user_id).await {
         Ok(image_bytes) => {
             // Returns the cached image.
             png_image(image_bytes)