Broken Duck Media Logo Broken Duck

About Services Products Resources

Activity Feed

Core → Silver
💰 $1000

Log of student and staff actions for transparency.

Technology iconTechnology iconTechnology icon

Overview of Activity Feed Module

Purpose

The Activity Feed module is designed to track actions taken by both students and staff within the system. Its primary goal is to enhance transparency and accountability by providing a comprehensive log of user activities. This module serves as an essential tool for monitoring interactions, ensuring that all significant actions are recorded and accessible for review.

Benefits

Usage Scenarios

  1. Academic Performance Tracking: Monitor student activities such as assignment submissions or resource accesses to gauge engagement and performance.
  2. System Health Monitoring: Track staff actions like system updates or configuration changes to ensure operational efficiency.
  3. Compliance Reporting: Generate reports for audits, ensuring adherence to institutional policies and legal requirements.
  4. Incident Investigation: Use logs to trace user activities during specific events, aiding in troubleshooting and security measures.

This module is integral for developers seeking a robust solution to enhance system transparency and accountability, offering versatile features tailored to various monitoring needs.

Activity Feed Module Features

1. Action Logging

2. Filtering Capabilities

3. Real-Time Updates

4. Integration with Core Modules

5. Security Measures

6. Data Export Functionality

7. User-Friendly Interface

8. Search Functionality

9. Scalability

10. API Support

These features ensure the Activity Feed module is robust, secure, and essential for maintaining transparency and accountability within the software system.

Activity Feed Module Documentation

Overview

The Activity Feed module provides a log of actions performed by both students and staff within the system, ensuring transparency and auditability.

Code Samples

1. FastAPI Endpoint (GET activity logs)

from fastapi import APIRouter, Depends, HTTPException
from typing import List
from datetime import date
from pydantic import BaseModel

router = APIRouter()

# Pydantic models for request/response
class Activity(BaseModel):
    id: str
    user_id: str
    action: str
    timestamp: str
    additional_info: dict | None

class User(BaseModel):
    id: str
    username: str
    role: str

@router.get("/activity_feed")
async def get_activity_feed(
    page: int = 1,
    page_size: int = 10,
    date_filter: date = None
):
    """
    Get paginated activity feed with optional date filter.
    
    Args:
        page (int): Page number for pagination. Defaults to 1.
        page_size (int): Number of items per page. Defaults to 10.
        date_filter (date): Filter activities by this date.
        
    Returns:
        List[Activity]: Paginated list of activity logs
    """
    # Example database query (replace with actual implementation)
    activities = await fetch_paginated_activities(page, page_size, date_filter)
    
    return [activity.dict() for activity in activities]

2. React UI Component (Displaying Activity Feed)

import { useState, useEffect } from 'react';

const ActivityFeed = () => {
    const [activities, setActivities] = useState([]);
    const [loading, setLoading] = useState(true);
    const [error, setError] = useState(null);

    useEffect(() => {
        const fetchActivities = async () => {
            try {
                const response = await fetch('/api/activity_feed');
                if (!response.ok) throw new Error('Failed to fetch activities');
                
                const data = await response.json();
                setActivities(data);
            } catch (err) {
                setError(err.message);
            } finally {
                setLoading(false);
            }
        };

        fetchActivities();
    }, []);

    return (
        <div>
            {loading ? (
                <p>Loading...</p>
            ) : error ? (
                <p>Error: {error}</p>
            ) : (
                <ul>
                    {activities.map((activity) => (
                        <li key={activity.id} className="activity-item">
                            <div className="user-info">
                                <span>{activity.user_id}</span>
                                <span>{activity.timestamp}</span>
                            </div>
                            <p className="action">{activity.action}</p>
                            {activity.additional_info && (
                                <div className="additional-info">
                                    {JSON.stringify(activity.additional_info)}
                                </div>
                            )}
                        </li>
                    ))}
                </ul>
            )}
        </div>
    );
};

export default ActivityFeed;

3. Pydantic Data Schema (Activity Log)

from pydantic import BaseModel
from typing import Optional, Dict, Any

class User(BaseModel):
    id: str
    username: str
    role: str

class Activity(BaseModel):
    id: str
    user_id: str
    action: str
    timestamp: str
    additional_info: Optional[Dict[str, Any]] = None
    
    @classmethod
    def from_dict(cls, d):
        return cls(**d)

Explanation

FastAPI Endpoint

React UI Component

Pydantic Schema

Activity Feed Module Documentation

Overview

The Activity Feed module is a core component designed to log student and staff actions within the system, ensuring transparency and auditability. It serves as a comprehensive tool for tracking user activities, which is essential for maintaining accountability and operational clarity.

Target Audience

The Activity Feed module interacts with several other modules to provide a seamless experience:

  1. User Management: Manages user accounts and permissions.
  2. Notifications: Handles alerts and notifications based on activity triggers.
  3. Reporting & Analytics: Provides insights and reports derived from logged activities.
  4. Search & Filters: Enables querying and filtering of activity logs.

Use Cases

  1. Logging User Actions: Records actions such as logins, content edits, or profile updates to provide a historical trail.
  2. Tracking Login Attempts: Monitors login events to identify potential security issues.
  3. Auditing Changes: Logs modifications made by users for comprehensive oversight.
  4. Automated Workflows: Triggers processes based on specific logged activities.

Integration Tips

Configuration Options

Below is a detailed table of configuration parameters for the Activity Feed module:

Parameter NameDescriptionDefault Value
enable_loggingEnables or disables activity logging across the system.true
log_retention_daysSpecifies the number of days logs are retained before being archived/removed.365
audit_levelDetermines the granularity of logged activities (e.g., basic, detailed).basic
max_log_size_per_entrySets the maximum size allowed for a single log entry to prevent data bloat.1MB
log_rotation_strategyConfigures how logs are rotated (e.g., daily, weekly, monthly).daily
anonymous_logging_enabledAllows logging of activities from anonymous users.false

Additional Notes

By following these guidelines, developers can effectively integrate the Activity Feed module into their systems, ensuring transparency and operational efficiency.