Some improvements to the CMakeLists.txt can be made:

• Setting C++ Standard Version
• Organize source files
• Enable testing
• Set build type for Debug and Release
• Code coverage
• Documentation
• CI/CD
• Installation rules
• Project and Version and Language settings
• Compile options
• Set include directories

This program runs in the bash/shell/console/terminal/tty.

I believe a good UI for this would look good if said terminal was full screen running this program/app. I tested several of my screens at roughtly 207 characters wide by 56 characters high.

Use whatever ANSI, ASCII, ISO, UTF8, Unicode characters to create a UI.

This would likely involve adding a UI library in the fugure.

• Login/Logout: This would include a exit program screen with login/logout option(s).

• Menu Options: These could include options like "Manage Students", "Manage Teachers", "Assignments", "Grades", "Reports", etc. Each of these options could lead to a separate screen.

• User Role Indicator: At the top or bottom of the screen, you could display the current user's role (Administrator, Teacher, or Student) and whether they're logged in or not.

• Current Screen Indicator: This could be a short string indicating which screen the user is currently on. For example, if the user is on the "Manage Students" screen, you could display "Students" somewhere on the screen.

• Prompt Area: This could be a small area at the bottom of the screen where you display prompts or messages to the user. For example, if the user selects the "Add New Student" option, you could display "Enter student ID:" in this area.

• Input Field: Right next to the prompt area, you could have a single-line input field where the user can enter data. This could be used for entering IDs, names, grades, etc.

• Error Messages: If the user enters invalid data or performs an invalid action, you could display an error message in the prompt area.

• Confirmation Messages: If the user performs an action that requires confirmation (like deleting a record), you could display a confirmation message in the prompt area.

• Help Option: You could include a "Help" option in the menu that displays brief instructions for each screen.

• Exit Option: Lastly, you could include an "Exit" option in the menu that logs the user out and exits the program.

It might be helpful to implement logging in our program.

I would suggest using Google's logging called glog. Shouldn't be too hard.

#include <glog/logging.h>

int main(int argc, char* argv[]) {
    google::InitGoogleLogging(argv);

    // Log messages at different severity levels
    LOG(INFO) << "This is an informational message.";
    LOG(WARNING) << "This is a warning message.";
    LOG(ERROR) << "This is an error message.";

    return 0;
}

Apparently you can then in CMakeLists.txt

Link Google Test to your executable

target_link_libraries(GradebookManagement ${GTEST_LIBRARIES} pthread)

I know it's not recommended to keep editor settings in source control, but for new people who may want to work with the project and/or don't have their environment set up yet.

I am opening this issue because I want to add:

• some general C/C++ settings
• some CMake integration settings
• some C and C++ language specific settings
• improve the file associations for IntelliSense
• more IntelliSense configuration

This potentially could have a cross platform because many different schools and districts use various technologies and we would like to make this the best experience for all of them.

There are some issues with the DataFrame class:

• Memory Leak in operator[] Overload
• The sizeRows function returns the number of columns (keys in the data map), which I think is a bit misleading.
• The load and save functions return an integer status code. I think it would be better to throw an exception
• The operator[] that returns std::vectorstd::string & does not check if the key exists in the data map and might have some potential for out of bounds access.
• print function could be a bit more efficient. The print function calculates the line width by iterating over the columnSizes vector multiple times. This could be optimized by calculating the total width in a single pass.
• std::endl probably should be \n
• the CSV load and save functions could be optimized so it would work if the CSV's are not very well formed or missing things.

Implement CRUD Operations for Gradebook Management System

Description

This issue covers the implementation of CRUD (Create, Read, Update, Delete) operations for various entities in the Gradebook Management System. These operations will be managed by different roles including Administrators, Teachers, and Students.

Tasks

• Implement CRUD operations for Administrators
• Implement CRUD operations for Students
• Implement CRUD operations for Teachers
• Implement CRUD operations for Assignments
• Implement CRUD operations for Tests
• Implement CRUD operations for Assignment Grades
• Implement CRUD operations for Test Grades
• Implement CRUD operations for Average Grades
• Implement CRUD operations for Class Reports
• Implement CRUD operations for Student Reports

Acceptance Criteria

• All CRUD operations for Students, Teachers and Administrators data are implemented

Notes

• Make sure to implement role-based access controls for each operation
• Ensure all operations return appropriate responses and error messages
• Document the purpose and expected outcome of each operation

Consider adding compiler detection, because not everyone may have GCC C++ compilers installed..

# Check for Clang compiler
if(CMAKE_CXX_COMPILER_IS_CLANG)
  message(STATUS "C++ compiler: Clang++/LLVM")
  # Set compiler specific flags here (optional)
endif()

# Check for GCC compiler
if(CMAKE_COMPILER_IS_GNU)
  message(STATUS "C++ compiler: g++")
  # Set compiler specific flags here (optional)
endif()

Also could make a toolchain file.

Use the CMAKE_TOOLCHAIN_FILE variable to specify different toolchain files for each platform (Windows, Linux, etc.) and various compilers. These files define compiler paths and flags.

The README.md for this project is rather basic.

It needs more details.

Do we create a new/separate branch for documenation?

Title: Implement Testing Phase

Description

This issue covers the implementation of the Testing Phase for the Gradebook Management System project. The Testing Phase involves creating unit tests, integration tests, and performing manual testing.

Tasks

• Write unit tests for all functions
• Automate unit tests
• Write integration tests
• Perform manual testing
• Fix identified bugs and issues
• Use Valgrind to fix/find memory leaks
• Create GitHub Actions/Workflow to build and test

Acceptance Criteria

• All functions have corresponding unit tests
• Unit tests are automated and run successfully
• Integration tests cover all main functionalities
• Manual testing is performed and all issues are fixed

Notes

• Use CTest and/or Google Test
• Ensure test coverage for all critical paths in the code
• Document the purpose and expected outcome of each test

Some possible feature(s)?

• Login/User Authentication: Implement a login system to ensure only authorized users can access the gradebook. This will also allow each user to have their own unique settings and preferences within the application. Teachers and Administration and other School Staff could possibly use this?

• Student Profiles: Each student should have a profile that includes personal details like name, grade level, and any special needs or accommodations they may have.

• Classroom Management: The ability to manage different classrooms. For example, teachers should be able to create classes, add students to them, and assign grades.

• Grade Calculation Methods: Allow the teacher to choose different methods for calculating grades, such as weighted average, standard average, or any custom method.

• Notifications: Send notifications to parents or guardians when a grade is updated or when a report card is due. Email? Letter?

• Report Generation: Generate reports for individual students or entire classrooms. These reports could include overall grades, attendance records, disciplinary incidents, report cards, progress reports, etc.

• Data Visualization: Provide visual representations of data such as graphs showing academic progress over time. This might be a bit harder, but useful? I don't know anything that would allow graphical graphing in C++?

• Error Checking Handling and Logging: Improve error handling and logging capabilities to help identify and fix issues quickly.

• Security Measures: Ensure data privacy and security by encrypting sensitive information, using secure protocols for data transfer, and regularly updating software versions. OpenSSL?