data_storage.py

import os
import json
import time
import uuid
import logging

class DataStorage:
    """
    Custom data storage class for managing student and attendance data
    without using SQL databases. Uses JSON files for persistence.
    """
    
    def __init__(self):
        """Initialize data storage with paths to data files."""
        self.students_file = "data/students.json"
        self.attendance_file = "data/attendance.json"
        self.logger = logging.getLogger(__name__)
        
        # Ensure data files exist
        self._ensure_data_files()
    
    def _ensure_data_files(self):
        """Create data files if they don't exist."""
        if not os.path.exists('data'):
            os.makedirs('data')
        
        # Initialize students file
        if not os.path.exists(self.students_file):
            with open(self.students_file, 'w') as f:
                json.dump([], f)
        
        # Initialize attendance file
        if not os.path.exists(self.attendance_file):
            with open(self.attendance_file, 'w') as f:
                json.dump([], f)
    
    def _read_data(self, file_path):
        """Read data from a JSON file."""
        try:
            with open(file_path, 'r') as f:
                return json.load(f)
        except json.JSONDecodeError:
            self.logger.error(f"Error decoding JSON from {file_path}, returning empty list")
            return []
        except FileNotFoundError:
            self.logger.error(f"File not found: {file_path}, returning empty list")
            return []
    
    def _write_data(self, file_path, data):
        """Write data to a JSON file."""
        try:
            with open(file_path, 'w') as f:
                json.dump(data, f, indent=2)
            return True
        except Exception as e:
            self.logger.error(f"Error writing to {file_path}: {str(e)}")
            return False
    
    # Student management methods
    def get_all_students(self):
        """Get all students from the database."""
        return self._read_data(self.students_file)
    
    def get_student(self, student_id):
        """Get a specific student by ID."""
        students = self.get_all_students()
        for student in students:
            if student.get('id') == student_id:
                return student
        return None
    
    def add_student(self, student_data):
        """
        Add a new student to the database.
        
        Args:
            student_data (dict): Student information including name, country, gender
        
        Returns:
            str: The ID of the newly created student
        """
        students = self.get_all_students()
        
        # Generate a unique ID for the student
        student_id = str(uuid.uuid4())
        
        # Add the ID and timestamp to the student data
        student_data['id'] = student_id
        student_data['created_at'] = time.strftime("%Y-%m-%d %H:%M:%S")
        
        # Add the student to the list
        students.append(student_data)
        
        # Save the updated list
        if self._write_data(self.students_file, students):
            return student_id
        return None
    
    def update_student(self, student_id, updated_data):
        """
        Update a student's information.
        
        Args:
            student_id (str): The ID of the student to update
            updated_data (dict): The updated student information
        
        Returns:
            bool: True if successful, False otherwise
        """
        students = self.get_all_students()
        
        for i, student in enumerate(students):
            if student.get('id') == student_id:
                # Preserve the ID and created_at timestamp
                updated_data['id'] = student_id
                updated_data['created_at'] = student.get('created_at')
                updated_data['updated_at'] = time.strftime("%Y-%m-%d %H:%M:%S")
                
                # Update the student
                students[i] = updated_data
                return self._write_data(self.students_file, students)
        
        return False
    
    def delete_student(self, student_id):
        """
        Delete a student from the database.
        
        Args:
            student_id (str): The ID of the student to delete
        
        Returns:
            bool: True if successful, False otherwise
        """
        students = self.get_all_students()
        
        # Find the student with the given ID
        for i, student in enumerate(students):
            if student.get('id') == student_id:
                # Remove the student
                students.pop(i)
                return self._write_data(self.students_file, students)
        
        return False
    
    # Attendance management methods
    def get_all_attendance(self):
        """Get all attendance records."""
        return self._read_data(self.attendance_file)
    
    def get_attendance_by_student(self, student_id):
        """
        Get attendance records for a specific student.
        
        Args:
            student_id (str): The ID of the student
        
        Returns:
            list: List of attendance records for the student
        """
        attendance_records = self.get_all_attendance()
        return [record for record in attendance_records if record.get('student_id') == student_id]
    
    def get_attendance_by_date(self, date):
        """
        Get attendance records for a specific date.
        
        Args:
            date (str): The date in format YYYY-MM-DD
        
        Returns:
            list: List of attendance records for the date
        """
        attendance_records = self.get_all_attendance()
        return [record for record in attendance_records if record.get('date') == date]
    
    def mark_attendance(self, attendance_data):
        """
        Mark attendance for a student.
        
        Args:
            attendance_data (dict): Attendance information including student_id, date, status
        
        Returns:
            str: The ID of the newly created attendance record
        """
        attendance_records = self.get_all_attendance()
        
        # Generate a unique ID for the attendance record
        attendance_id = str(uuid.uuid4())
        
        # Add the ID and timestamp to the attendance data
        attendance_data['id'] = attendance_id
        attendance_data['created_at'] = time.strftime("%Y-%m-%d %H:%M:%S")
        
        # Check if attendance already exists for this student on this date
        for i, record in enumerate(attendance_records):
            if (record.get('student_id') == attendance_data.get('student_id') and 
                record.get('date') == attendance_data.get('date')):
                # Update existing record
                attendance_records[i] = attendance_data
                if self._write_data(self.attendance_file, attendance_records):
                    return attendance_id
                return None
        
        # Add the attendance record to the list
        attendance_records.append(attendance_data)
        
        # Save the updated list
        if self._write_data(self.attendance_file, attendance_records):
            return attendance_id
        return None
    
    def delete_attendance(self, attendance_id):
        """
        Delete an attendance record.
        
        Args:
            attendance_id (str): The ID of the attendance record to delete
        
        Returns:
            bool: True if successful, False otherwise
        """
        attendance_records = self.get_all_attendance()
        
        # Find the attendance record with the given ID
        for i, record in enumerate(attendance_records):
            if record.get('id') == attendance_id:
                # Remove the record
                attendance_records.pop(i)
                return self._write_data(self.attendance_file, attendance_records)
        
        return False
    
    def get_attendance_report(self, start_date=None, end_date=None, student_id=None):
        """
        Get a report of attendance within a date range and/or for a specific student.
        
        Args:
            start_date (str, optional): Start date in format YYYY-MM-DD
            end_date (str, optional): End date in format YYYY-MM-DD
            student_id (str, optional): Student ID to filter by
        
        Returns:
            list: Filtered attendance records
        """
        attendance_records = self.get_all_attendance()
        filtered_records = attendance_records.copy()
        
        # Apply date filters
        if start_date:
            filtered_records = [r for r in filtered_records if r.get('date', '') >= start_date]
        
        if end_date:
            filtered_records = [r for r in filtered_records if r.get('date', '') <= end_date]
        
        # Apply student filter
        if student_id:
            filtered_records = [r for r in filtered_records if r.get('student_id') == student_id]
        
        return filtered_records