push for this OD month

Author: Dario0731

contracts/course/course_access/src/functions/config.rs

@@ -10,27 +10,12 @@ use crate::schema::{KEY_COURSE_REG_ADDR, KEY_USER_MGMT_ADDR};
 const INIT_EVENT: Symbol = symbol_short!("initialz");
 const UPDATE_ADDRESS_EVENT: Symbol = symbol_short!("updAddr");
 
-/// Storage key for initialization flag
+
 const KEY_INIT: &str = "init";
 
-/// Storage key for contract owner address
 const KEY_OWNER: &str = "owner";
 
-/// One-time constructor that sets owner and external contract addresses.
-///
-/// This function initializes the contract with the necessary configuration
-/// and can only be called once during the contract's lifetime.
-///
-/// # Arguments
-///
-/// * `env` - The Soroban environment
-/// * `caller` - The address of the contract deployer who becomes the owner
-/// * `user_mgmt_addr` - Address of the user management contract
-/// * `course_registry_addr` - Address of the course registry contract
-///
-/// # Panics
-///
-/// Panics if the contract has already been initialized.
+
 pub fn initialize(
     env: Env,
     caller: Address,
@@ -59,22 +44,7 @@ pub fn initialize(
         .publish((INIT_EVENT,), (caller, user_mgmt_addr, course_registry_addr));
 }
 
-/// Update external contract addresses.
-///
-/// This function allows the contract owner to update the addresses of external
-/// contracts that this contract depends on for authentication and authorization.
-/// Only the stored owner can perform this operation.
-///
-/// # Arguments
-///
-/// * `env` - The Soroban environment
-/// * `caller` - The address of the user attempting to update the configuration
-/// * `user_mgmt_addr` - New address of the user management contract
-/// * `course_registry_addr` - New address of the course registry contract
-///
-/// # Panics
-///
-/// Panics if the contract is not initialized or if the caller is not the owner.
+
 pub fn set_contract_addrs(
     env: Env,
     caller: Address,
@@ -93,7 +63,7 @@ pub fn set_contract_addrs(
         panic!("not initialized");
     }
 
-    // Only owner may update
+
     let owner: Address = env
         .storage()
         .instance()

contracts/course/course_access/src/functions/contract_versioning.rs

@@ -22,11 +22,11 @@ pub enum VersioningError {
     MigrationFailed = 6,
 }
 
-/// Storage keys for versioning data
+
 const VERSION_HISTORY_KEY: &str = "version_history";
 const MIGRATION_STATUS_KEY: &str = "migration_status";
 
-/// Get the version history of the contract
+
 pub fn get_version_history(env: &Env) -> Vec<String> {
     let key = String::from_str(env, VERSION_HISTORY_KEY);
     env.storage()
@@ -35,7 +35,6 @@ pub fn get_version_history(env: &Env) -> Vec<String> {
         .unwrap_or_else(|| vec![env])
 }
 
-/// Store a new version in the history
 fn store_version_in_history(env: &Env, version: String) {
     let mut history: Vec<String> = get_version_history(env);
     history.push_back(version.clone());
@@ -44,7 +43,7 @@ fn store_version_in_history(env: &Env, version: String) {
     env.storage().instance().set(&key, &history);
 }
 
-/// Check if a version exists in the history
+
 fn version_exists_in_history(env: &Env, version: &String) -> bool {
     let history: Vec<String> = get_version_history(env);
     for v in history.iter() {
@@ -55,7 +54,7 @@ fn version_exists_in_history(env: &Env, version: &String) -> bool {
     false
 }
 
-/// Get migration status information
+
 pub fn get_migration_status(env: &Env) -> String {
     let key: String = String::from_str(env, MIGRATION_STATUS_KEY);
     env.storage()
@@ -64,22 +63,20 @@ pub fn get_migration_status(env: &Env) -> String {
         .unwrap_or_else(|| String::from_str(env, "No migrations pending"))
 }
 
-/// Set migration status
+
 fn set_migration_status(env: &Env, status: String) {
     let key = String::from_str(env, MIGRATION_STATUS_KEY);
     env.storage().instance().set(&key, &status);
 }
 
-/// Check compatibility between two versions
+
 pub fn is_version_compatible(_env: &Env, _from_version: String, _to_version: String) -> bool {
     // Simple compatibility check - for now, assume all versions are compatible
     // In a real implementation, you would parse semantic versions properly
     true
 }
 
-/// Check if the caller is authorized to perform migration
-/// For course access, we'll allow any authenticated user for now
-/// In a production environment, this should check for admin privileges
+
 fn is_authorized_for_migration(_env: &Env, _caller: Address) -> bool {
     // For now, we'll allow any authenticated user
     // In a real implementation, you would check against user management contract
@@ -93,32 +90,31 @@ fn is_authorized_for_migration(_env: &Env, _caller: Address) -> bool {
     true // Placeholder - allow all authenticated users
 }
 
-/// Migrate access data between contract versions
 pub fn migrate_access_data(
     env: &Env,
     caller: Address,
     from_version: String,
     to_version: String,
 ) -> bool {
-    // Check if caller is authorized
+
     if !is_authorized_for_migration(env, caller.clone()) {
         set_migration_status(env, String::from_str(env, "Migration failed: Unauthorized"));
         return false;
     }
 
-    // Validate versions exist in history
+
     if !version_exists_in_history(env, &from_version) {
         set_migration_status(env, String::from_str(env, "Migration failed: Source version not found"));
         return false;
     }
 
-    // Check compatibility
+
     if !is_version_compatible(env, from_version.clone(), to_version.clone()) {
         set_migration_status(env, String::from_str(env, "Migration failed: Versions not compatible"));
         return false;
     }
 
-    // Perform migration based on version differences
+
     let migration_result: bool = perform_access_data_migration(env, &from_version, &to_version);
 
     if migration_result {

contracts/course/course_access/src/functions/list_user_courses.rs

@@ -5,22 +5,7 @@ use soroban_sdk::{Address, Env, Vec};
 
 use crate::schema::{DataKey, UserCourses};
 
-/// List all courses that a specific user has access to.
-///
-/// This function retrieves all courses that the specified user is enrolled in
-/// or has been granted access to. If the user has no courses, it returns
-/// an empty UserCourses struct.
-///
-/// # Arguments
-///
-/// * `env` - The Soroban environment
-/// * `user` - The address of the user to query courses for
-///
-/// # Returns
-///
-/// Returns a `UserCourses` struct containing the user's address and a list
-/// of course IDs they have access to. If no courses are found, returns
-/// an empty list.
+
 pub fn list_user_courses(env: Env, user: Address) -> UserCourses {
     let key: DataKey = DataKey::UserCourses(user.clone());
     let res: UserCourses = env.storage().persistent().get(&key).unwrap_or(UserCourses {

contracts/course/course_access/src/functions/revoke_all_access.rs

@@ -15,35 +15,7 @@ const COURSES_KEY: Symbol = symbol_short!("courses");
 /// Event symbol for revoke all access operations
 const REVOKE_ALL_EVENT: Symbol = symbol_short!("revokeAll");
 
-/// Revoke access for all users from a specific course.
-///
-/// This function removes access for all users from the specified course and
-/// updates all related storage structures. Only admin users or course creators
-/// are authorized to perform this operation.
-///
-/// # Arguments
-///
-/// * `env` - The Soroban environment
-/// * `caller` - The address of the user requesting the operation
-/// * `course_id` - The unique identifier of the course to revoke all access from
-///
-/// # Returns
-///
-/// Returns the number of users whose access was revoked.
-///
-/// # Authorization
-///
-/// The caller must be either:
-/// - An admin user (verified via user management contract)
-/// - The creator of the course (verified via course registry contract)
-///
-/// # Events
-///
-/// Emits a `revokeall` event with the course ID and number of affected users.
-///
-/// # Panics
-///
-/// Panics with `Error::Unauthorized` if the caller is not authorized to perform this operation.
+
 pub fn revoke_all_access(env: Env, caller: Address, course_id: String) -> u32 {
     caller.require_auth();
 

contracts/course/course_access/src/functions/save_profile.rs

@@ -8,28 +8,7 @@ use crate::schema::{DataKey, UserProfile};
 
 const SAVE_USER_PROFILE_EVENT: Symbol = symbol_short!("saveUsPrl");
 
-/// Save or update a user's profile information on-chain.
-///
-/// This function stores user profile data in persistent storage, including
-/// personal and professional information. It validates required fields
-/// before saving the profile.
-///
-/// # Arguments
-///
-/// * `env` - The Soroban environment
-/// * `name` - The user's full name (required)
-/// * `email` - The user's email address (required)
-/// * `profession` - Optional profession or job title
-/// * `goals` - Optional learning goals or objectives
-/// * `country` - The user's country of residence (required)
-/// * `user` - The address of the user whose profile is being saved
-///
-/// # Panics
-///
-/// Panics with appropriate error if any required field is empty:
-/// - `Error::NameRequired` if name is empty
-/// - `Error::EmailRequired` if email is empty
-/// - `Error::CountryRequired` if country is empty
+
 pub fn save_user_profile(
     env: Env,
     name: String,

contracts/course/course_access/src/functions/utils/storage_utils.rs

@@ -9,7 +9,7 @@ use crate::functions::config::{TTL_BUMP, TTL_TTL};
 
 const TEMP_TTL: u32 = 900; // 15 minutes
 
-/// Efficiently get or create UserCourses record
+
 pub fn get_or_create_user_courses(
     env: &Env,
     user: &Address,
@@ -37,7 +37,7 @@ pub fn get_or_create_user_courses(
     user_courses
 }
 
-/// Efficiently get or create CourseUsers record
+
 pub fn get_or_create_course_users(
     env: &Env,
     course_id: &String,
@@ -58,14 +58,14 @@ pub fn get_or_create_course_users(
             users: Vec::new(env),
         });
 
-    // Cache result
+
     env.storage().temporary().set(&temp_key, &course_users);
     env.storage().temporary().extend_ttl(&temp_key, 0, TEMP_TTL);
 
     course_users
 }
 
-/// Update both user courses and course users in a single atomic operation
+
 pub fn update_access_mappings(
     env: &Env,
     course_id: &String,
@@ -105,7 +105,7 @@ pub fn update_access_mappings(
     env.storage().temporary().set(&temp_course_key, &course_users);
 }
 
-/// Check if a user has access to a course with caching
+
 pub fn has_course_access(
     env: &Env,
     course_id: &String,
@@ -134,7 +134,7 @@ pub fn has_course_access(
     has_access
 }
 
-/// Clear access-related caches for a course
+
 pub fn invalidate_course_access_cache(
     env: &Env,
     course_id: &String,
@@ -143,7 +143,6 @@ pub fn invalidate_course_access_cache(
     env.storage().temporary().remove(&temp_users_key);
 }
 
-/// Clear access-related caches for a user
 pub fn invalidate_user_access_cache(
     env: &Env,
     user: &Address,

contracts/user_management/src/functions/delete_user.rs

@@ -9,24 +9,7 @@ use soroban_sdk::{symbol_short, Address, Env, Symbol};
 // Event symbol for user deactivation
 const USER_DEACTIVATED_EVENT: Symbol = symbol_short!("usrDeact");
 
-/// Delete (deactivate) a user account
-///
-/// This function performs a soft delete by marking the user as inactive instead of
-/// permanently removing their data. Only admins or the user themselves can trigger deletion.
-///
-/// # Arguments
-/// * `env` - Soroban environment
-/// * `caller` - Address performing the deletion (must be admin or the user themselves)
-/// * `user_id` - Address of the user to be deactivated
-///
-/// # Panics
-/// * If caller authentication fails
-/// * If user doesn't exist
-/// * If caller is neither admin nor the user themselves
-/// * If user is already inactive
-///
-/// # Events
-/// Emits a user deactivation event upon successful deletion
+
 pub fn delete_user(env: Env, caller: Address, user_id: Address) {
     // Require authentication for the caller
     caller.require_auth();

contracts/user_management/src/functions/edit_user_profile.rs

@@ -36,30 +36,6 @@ fn check_edit_permission(env: &Env, caller: &Address, user_id: &Address) -> bool
     is_admin(env.clone(), caller.clone())
 }
 
-/// Edit an existing user profile
-///
-/// Updates an existing user profile with new values for allowed fields.
-/// Only the user themselves or administrators can perform updates.
-/// Email and role fields cannot be updated through this function.
-///
-/// # Arguments
-/// * `env` - Soroban environment
-/// * `caller` - Address of the user performing the update
-/// * `user_id` - Address of the user whose profile is being updated
-/// * `updates` - ProfileUpdateParams containing fields to update
-///
-/// # Returns
-/// * `UserProfile` - The updated user profile
-///
-/// # Panics
-/// * If caller authentication fails
-/// * If user profile doesn't exist
-/// * If caller lacks permission to edit
-/// * If any field validation fails
-/// * If user is inactive
-///
-/// # Events
-/// Emits a user update event upon successful profile update
 pub fn edit_user_profile(
     env: Env,
     caller: Address,

contracts/user_management/src/functions/get_user_by_id.rs

@@ -7,9 +7,7 @@ use crate::error::{handle_error, Error};
 use crate::schema::{DataKey, UserProfile};
 use core::iter::Iterator;
 
-/// Get User by ID
-/// - Only the profile owner or an admin can access it.
-/// - Returns the full profile (assuming no sensitive data like passwords are stored in UserProfile).
+
 pub fn get_user_by_id(env: Env, requester: Address, user_id: Address) -> UserProfile {
     // Require authentication for the requester
     requester.require_auth();