Added documentation.

Author: Viraj5903

.gitignore

@@ -0,0 +1,2 @@
+# Ignore Python bytecode cache directories recursively
+**/__pycache__/

README.md

@@ -1,10 +1,10 @@
 # TaskOps API
 
 ## Overview
-TaskOps (Task Operations) API is a RESTful backend API built with Flask and MongoDB, designed to streamline task management operations. It provides endpoints for user registration and authentication, as well as creating, retrieving, updating, and deleting tasks. The API ensures secure authentication and authorization using JWT tokens, serving various web and mobile applications requiring efficient and easy task management capabilities.
+TaskOps (Task Operations) API is a RESTful backend API built with Flask and MongoDB, using Python programming language. It is designed to streamline task management operations for various web and mobile applications. The API provides endpoints for user registration and authentication, as well as creating, retrieving, updating, and deleting tasks. The API ensures secure authentication and authorization using JWT tokens, serving as an efficient and easy task management solution.
 
 ## Description
-TaskOps API offers a comprehensive solution for efficient and easy task management, focusing on user account management and secure operations. Leveraging Flask for its lightweight and flexible framework and MongoDB for its scalable NoSQL database capabilities, the API ensures seamless user registration and authentication, as well as CRUD (Create, Read, Update, Delete) operations for tasks. Authentication and authorization are handled securely using JWT tokens, ensuring that only authorized users can access and manipulate task data.
+TaskOps API offers a comprehensive solution for efficient and easy task management, focusing on user account management and secure operations. Utilizing Flask for its lightweight and flexible framework and MongoDB for its scalable NoSQL database capabilities, the API, developed with Python, ensures seamless user registration and authentication, as well as CRUD (Create, Read, Update, Delete) operations for tasks. Authentication and authorization are handled securely using JWT tokens, ensuring that only authorized users can access and manipulate task data.
 
 The API adheres to RESTful principles, employing HTTP methods for predictable and intuitive endpoint design. It supports functionalities such as:
 - User registration and authentication: Enables users to create accounts and securely authenticate using their credentials to access the task management features.

controllers/task_controller.py

@@ -1,101 +1,179 @@
+# Import the necessary modules.
+
 from models.task_model import Task
 from database.__init__ import conn
 from bson.objectid import ObjectId
 import app_config as config
 
-# TODO: Manpreet Kaur
 def create_task(task_info):
+    """
+    Create a new task in the database.
+
+    Args:
+        task_info (dict): A dictionary containing the task information.
+            Required keys:
+                - 'created_by_uid': The ID of the user who created the task.
+                - 'assigned_to_uid': The ID of the user to whom the task is assigned.
+                - 'description': The description of the task.
+
+    Returns:
+        pymongo.results.InsertOneResult: The result of the insert operation.
+
+    Raises:
+        ValueError: If the user information is invalid.
+    """
     try:
-        # Access the database to get user information
-        created_by_user = conn.database[config.CONST_USER_COLLECTION].find_one({'_id': ObjectId(task_info['created_by_uid'])})
-        assigned_to_user = conn.database[config.CONST_USER_COLLECTION].find_one({'_id': ObjectId(task_info['assigned_to_uid'])})
-        
-        # print("created_by_user", created_by_user)
-        # print("assigned_to_user", assigned_to_user)
+        # Find the users by their IDs
+        created_by_user = conn.database[config.CONST_USER_COLLECTION].find_one(
+            {'_id': ObjectId(task_info['created_by_uid'])})
+        assigned_to_user = conn.database[config.CONST_USER_COLLECTION].find_one(
+            {'_id': ObjectId(task_info['assigned_to_uid'])})
 
+        # Check if the user information is valid
         if not created_by_user or not assigned_to_user:
             raise ValueError('Invalid user information')
 
         # Create a new task object
         new_task = Task()
-        new_task.createdByUid = task_info['created_by_uid']
-        new_task.createdByName = created_by_user['name']
-        new_task.assignedToUid = task_info['assigned_to_uid']
-        new_task.assignedToName = assigned_to_user['name']
-        new_task.description = task_info['description']
+        new_task.createdByUid = task_info['created_by_uid']  # Set the created by user ID
+        new_task.createdByName = created_by_user['name']  # Set the created by user name
+        new_task.assignedToUid = task_info['assigned_to_uid']  # Set the assigned to user ID
+        new_task.assignedToName = assigned_to_user['name']  # Set the assigned to user name
+        new_task.description = task_info['description']  # Set the description of the task
 
         # Save the task to the database
         created_task = conn.database[config.CONST_TASK_COLLECTION].insert_one(new_task.__dict__)
 
         return created_task
 
-    except ValueError as err:
+    except ValueError as err:  # If there is an invalid user information, raise a ValueError
         raise ValueError(str(err))
-    except Exception as err:
+    except Exception as err:  # If there is any other exception, raise a ValueError
         raise ValueError(str(err))
 
-# TODO: Dil Raval
 def get_task_created_by_user(user_id):
+    """
+    Get tasks created by the user.
+
+    This function retrieves tasks created by the user with the given user ID.
+
+    Args:
+        user_id (str): The ID of the user.
+
+    Returns:
+        list: A list of tasks created by the user, with each task's '_id' field converted to a string.
+
+    Raises:
+        ValueError: If there is an error in fetching the tasks.
+    """
     try:
-        
+        # Connect to the tasks collection of the database.
         task_collection = conn.database.get_collection(config.CONST_TASK_COLLECTION)
 
+        # Retrieve tasks created by the user.
+        # Find tasks where the 'createdByUid' field matches the given user ID.
         task_list = list(task_collection.find({"createdByUid": user_id}))
-        # print(task_list)
 
+        # Convert the '_id' field of each task to a string.
+        # This is done to ensure that the '_id' field is serialized as a string when returned.
         for task in task_list:
             task["_id"] = str(task["_id"])
 
-        return task_list
+        return task_list  # Return the list of tasks created by the user
 
     except Exception as error:
+        # Raise a ValueError with an appropriate error message if there is an error in fetching the tasks.
         raise ValueError("Error on trying to fetch tasks created by user.", error)
 
-# TODO: Aryan Handa
 def get_tasks_assigned_to_user(assignedToUid):
+    """
+    Get tasks assigned to the user.
+
+    This function retrieves tasks assigned to the user with the given assignedToUid.
+
+    Args:
+        assignedToUid (str): The ID of the user.
+
+    Returns:
+        list: A list of tasks assigned to the user, with each task's '_id' field converted to a string.
+
+    Raises:
+        ValueError: If there is an error in fetching the tasks.
+    """
     try:
-        
         # Retrieve tasks assigned to the user
-        tasks = conn.database[config.CONST_TASK_COLLECTION].find({"assignedToUid": assignedToUid})
+        tasks = conn.database[config.CONST_TASK_COLLECTION].find(
+            {"assignedToUid": assignedToUid})  # Find tasks assigned to the user
 
+        # Convert the tasks to a list
         user_tasks = list(tasks)
 
+        # Convert the '_id' field of each task to a string
         for task in user_tasks:
-            task["_id"] = str(task["_id"]) 
+            task["_id"] = str(task["_id"])  # Convert task ID to string
 
-        return user_tasks
+        return user_tasks  # Return the list of tasks assigned to the user
 
     except Exception as err:
+        # Raise a ValueError with an appropriate error message if there is an error in fetching the tasks.
         raise ValueError("Error fetching tasks assigned to user: ", err)
 
-# TODO: Payal Rangra
-def update_task(user_info, task_id, done ):
-    
+def update_task(user_info, task_id, done):
+    """
+    Update the status of a task in the database.
+
+    Args:
+        user_info (dict): A dictionary containing user-related information retrieved from the token, including the user's ID.
+        task_id (str): The ID of the task to be updated.
+        done (bool): The new status of the task.
+
+    Returns:
+        pymongo.results.UpdateResult: The result of the update operation.
+
+    Raises:
+        ValueError: If the task is not found or the user is not authorized to update the task.
+    """
     try:
+        # Connect to the tasks collection of the database.
         task_collection = conn.database[config.CONST_TASK_COLLECTION]
-        
-        current_task = task_collection.find_one({"_id":ObjectId(task_id)})
-        
-        if(current_task == None):  
+
+        # Find the task with _id = task_id.
+        current_task = task_collection.find_one({"_id": ObjectId(task_id)})
+
+        # Check if the task exists.
+        if current_task is None:
             raise ValueError('Task not found')
-        
+
+        # Check if the user is authorized to update the task.
         if str(current_task['assignedToUid']) != str(user_info["id"]):
             raise ValueError('Users can only change status when task is assigned to them.')
-        
-        updated_result = task_collection.update_one({"_id":ObjectId(task_id)}, {"$set": {"done": done}})
-        
+
+        # Update the 'done' field of the task with _id = task_id to the new status.
+        # The $set operator is used to update the value of the 'done' field.
+        updated_result = task_collection.update_one(
+            {"_id": ObjectId(task_id)},  # Query to find the task
+            {"$set": {"done": done}}  # Update operation to set the 'done' field
+        )
+
+        # Return the result of the update operation.
         return updated_result
-    
+
     except Exception as err:
+        # Raise a ValueError with an appropriate error message if there is an error in updating the task.
         raise ValueError('Error on updating task: ' f'{err}')
 
-# TODO: Viraj Patel
 def delete_task(user_information, task_id):
     """Delete a task from the database.
 
     Args:
         user_information (dict): A dictionary containing user-related information retrieved from the token, including the user's ID.
         task_id (str): The ID of the task to be deleted.
+
+    Returns:
+        pymongo.results.DeleteResult: The result of the delete operation.
+
+    Raises:
+        ValueError: If the task is not found or the user is not authorized to delete the task.
     """
     try: 
 

controllers/user_controller.py

@@ -6,75 +6,149 @@
 import jwt # pip install pyjwt
 
 def generate_hash_password(password):
+    """
+    Generate a hashed password using bcrypt.
+
+    Args:
+        password (str): The password to be hashed.
+
+    Returns:
+        bytes: The hashed password.
+    """
+    # Generate a salt for hashing the password
     salt = bcrypt.gensalt()
+
+    # Hash the password using the generated salt
     hashed_password = bcrypt.hashpw(password.encode("utf-8"), salt)
+
+    # Return the hashed password
     return hashed_password
 
 def create_user(user_information):
+    """
+    Create a new user in the database.
+
+    Args:
+        user_information (dict): A dictionary containing user information.
+            Required keys:
+                - 'name': The name of the user.
+                - 'email': The email of the user.
+                - 'password': The password of the user.
+
+    Returns:
+        pymongo.results.InsertOneResult: The result of the insert operation.
+
+    Raises:
+        ValueError: If there is an error creating the user.
+    """
     try:
+        # Create a new User object
         new_user = User()
+
+        # Set the user's name, email, and hashed password
         new_user.name = user_information["name"]
         new_user.email = user_information["email"]
         new_user.password = generate_hash_password(user_information["password"])
 
+        # Connect to the user collection of the database
         db_collection = conn.database[config.CONST_USER_COLLECTION]
 
+        # Check if a user with the same email already exists
         if db_collection.find_one({'email': new_user.email}):
             return 'Duplicated User'
 
+        # Insert the new user into the database
         created_user = db_collection.insert_one(new_user.__dict__)
 
+        # Return the result of the insert operation
         return created_user
+
     except Exception as err:
+        # If there is an error creating the user, raise a ValueError
         raise ValueError("Error on creating user.", err)
 
 def login_user(user_information):
+    """
+    Handles the user login process by checking the provided credentials against the database.
+
+    Args:
+        user_information (dict): A dictionary containing user information.
+            Required keys:
+                - 'email': The email of the user.
+                - 'password': The password of the user.
+
+    Returns:
+        dict: A dictionary containing the JWT token, expiration time, and logged user information.
+    """
     try:
+        # Extract user information from the request
         email = user_information["email"]
         password = user_information["password"].encode('utf-8')
 
+        # Connect to the user collection of the database
         db_collection = conn.database[config.CONST_USER_COLLECTION]
 
+        # Find the user with the provided email
         current_user = db_collection.find_one({'email': email})
 
+        # Check if the user exists
         if not current_user:
             return "Invalid Email"
 
+        # Check if the provided password matches the hashed password in the database
         if not bcrypt.checkpw(password, current_user["password"]):
             return "Invalid Password"
 
+        # Create a dictionary with the logged user information
         logged_user = {}
         logged_user['id'] = str(current_user['_id'])
         logged_user['email'] = current_user['email']
         logged_user['name'] = current_user['name']
 
+        # Calculate the expiration time for the JWT token
         expiration = datetime.utcnow() + timedelta(seconds = config.JWT_EXPIRATION)
 
+        # Create the JWT token data
         jwt_data = {'email': logged_user['email'], 'id': logged_user['id'], 'exp': expiration}
 
-        jwt_to_return = jwt.encode(payload = jwt_data, key = config.TOKEN_SECRET)
+        # Encode the JWT token with the secret key
+        jwt_to_return = jwt.encode(payload=jwt_data, key=config.TOKEN_SECRET)
 
-        #print(jwt_to_return)
-        
+        # Return the JWT token, expiration time, and logged user information
         return {'token': jwt_to_return, 'expiration': config.JWT_EXPIRATION, 'logged_user': logged_user}
 
     except Exception as err:
+        # If there is an error logging in the user, raise a ValueError with the error message
         raise ValueError("Error on trying to login.", err)
 
 
 def fetch_all_users():
+    """
+    Fetches all users from the database and returns them as a list of dictionaries.
+
+    Returns:
+        List[Dict[str, str]]: A list of dictionaries representing the users. Each dictionary contains the user's ID, email, and name.
+
+    Raises:
+        ValueError: If there is an error fetching the users.
+    """
     try:
+        # Connect to the user collection of the database
         db_collection = conn.database[config.CONST_USER_COLLECTION]
         users = []
 
+        # Iterate over each user in the database, create a dictionary with their ID, email, and name,
+        # and add it to the list of users
         for user in db_collection.find():
             current_user = {}
             current_user["id"] = str(user["_id"])
             current_user["email"] = user["email"]
             current_user["name"] = user["name"]
             users.append(current_user)
 
+        # Return the fetch users.
         return users
 
     except Exception as err:
-        raise ValueError("Error on trying to fetch users.", err)
+        # If there is an error fetching the users, raise a ValueError with the error message
+        raise ValueError("Error on trying to fetch users.", err)