Attendance Module

[No Record] ──mark present──→ [Present]
[No Record] ──mark absent───→ [Absent]
[Present]   ──edit──────────→ [Absent | Late | Excused]
[Absent]    ──edit──────────→ [Present | Late | Excused]

GET /parent-app/attendance?roll_no=<roll_no>
  ├─ JWT → extract skole_id
  ├─ Query student_attendance WHERE skole_id = jwt.skole_id AND student_id matched from roll_no
  └─ Return records sorted by date DESC

GET /teachers-app/attendance?skole_id=&grade=&date=
POST /teachers-app/attendance { student_id, date, status, ... }
PUT  /teachers-app/attendance/:id { status, ... }

{
  "status": "success",
  "data": {
    "records": [
      {
        "id": "UUID",
        "student_id": "UUID",
        "date": "2026-03-16",
        "attendance_status": "present",
        "availability_status": "in-school",
        "checkedIn_at": "2026-03-16T09:00:00.000Z",
        "checkedOut_at": "2026-03-16T15:30:00.000Z"
      }
    ],
    "pagination": {
      "total": 45,
      "take": 20,
      "skip": 0
    },
    "statistics": {
      "present": 35,
      "absent": 5,
      "late": 4,
      "excused": 1,
      "attendance_percentage": 87.5
    }
  }
}

{
  "status": "error",
  "code": "UNAUTHORIZED",
  "message": "Invalid or expired JWT token"
}

{
  "status": "error",
  "code": "NOT_FOUND",
  "message": "Student not found or no access"
}

const getChildAttendance = async (token, filters = {}) => {
  const params = new URLSearchParams({
    take: filters.take || 20,
    skip: filters.skip || 0,
    from_date: filters.from_date || new Date(Date.now() - 30*24*60*60*1000).toISOString().split('T')[0],
    to_date: filters.to_date || new Date().toISOString().split('T')[0],
    ...filters
  });

  const response = await fetch(
    `https://api.skole.com/v1/parent-app/attendance?${params}`,
    {
      method: 'GET',
      headers: { 'Authorization': `Bearer ${token}` }
    }
  );

  const data = await response.json();
  if (data.status === 'success') {
    return data.data;
  }
  throw new Error(data.message);
};

// Usage
const records = await getChildAttendance(token, {
  from_date: '2026-03-01',
  to_date: '2026-03-31'
});

from datetime import datetime, timedelta

def get_child_attendance(token: str, student_id: str = None) -> dict:
    url = 'https://api.skole.com/v1/parent-app/attendance'
    headers = {'Authorization': f'Bearer {token}'}
    
    today = datetime.now().date()
    thirty_days_ago = today - timedelta(days=30)
    
    params = {
        'from_date': str(thirty_days_ago),
        'to_date': str(today),
        'take': 20,
        'skip': 0
    }
    
    if student_id:
        params['studentId'] = student_id
    
    response = requests.get(url, headers=headers, params=params)
    data = response.json()
    
    if data['status'] == 'success':
        return data['data']
    raise Exception(data['message'])

# Usage
records = get_child_attendance(token)

curl -X GET \
  'https://api.skole.com/v1/parent-app/attendance?from_date=2026-03-01&to_date=2026-03-31' \
  -H 'Authorization: Bearer YOUR_TOKEN_HERE'

SELECT sa.* FROM student_attendance sa
JOIN students s ON sa.student_id = s.id
WHERE s.parent_id = ? AND s.skole_id = ? 
  AND sa.date >= ? AND sa.date <= ?
  AND (? IS NULL OR sa.attendance_status = ?)
ORDER BY sa.date DESC
LIMIT ? OFFSET ?

{
  "status": "success",
  "data": {
    "id": "UUID",
    "student_id": "UUID",
    "date": "2026-03-16",
    "attendance_status": "present",
    "availability_status": "in-school",
    "checkedIn_at": "2026-03-16T09:00:00.000Z",
    "checkedOut_at": "2026-03-16T15:30:00.000Z",
    "duration_hours": 6.5,
    "notes": "Normal day",
    "created_at": "2026-03-16T09:05:00.000Z"
  }
}

{
  "status": "error",
  "code": "NOT_FOUND",
  "message": "No attendance record for this date"
}

const getChildDetailAttendance = async (token, studentId, date = null) => {
  const params = new URLSearchParams();
  if (date) params.append('date', date);

  const response = await fetch(
    `https://api.skole.com/v1/parent-app/attendance/${studentId}?${params}`,
    {
      method: 'GET',
      headers: { 'Authorization': `Bearer ${token}` }
    }
  );

  const data = await response.json();
  return data.data;
};

{
  "status": "success",
  "data": {
    "period": "2026-03",
    "total_school_days": 20,
    "present": 18,
    "absent": 2,
    "late": 0,
    "excused": 0,
    "percentage": 90,
    "trend": "improving"
  }
}

const getAttendanceSummary = async (token, month = null, year = null) => {
  const params = new URLSearchParams();
  if (month) params.append('month', month);
  if (year) params.append('year', year);

  const response = await fetch(
    `https://api.skole.com/v1/parent-app/attendance/reports/summary?${params}`,
    {
      method: 'GET',
      headers: { 'Authorization': `Bearer ${token}` }
    }
  );

  return (await response.json()).data;
};

{
  "status": "success",
  "data": {
    "month": 3,
    "year": 2026,
    "days": [
      {
        "date": "2026-03-16",
        "status": "present",
        "checkedIn": "09:00",
        "checkedOut": "15:30"
      }
    ]
  }
}

const getMonthlyReport = async (token) => {
  const response = await fetch(
    'https://api.skole.com/v1/parent-app/attendance/reports/monthly',
    {
      method: 'GET',
      headers: { 'Authorization': `Bearer ${token}` }
    }
  );

  return (await response.json()).data;
};

{
  "records": [
    {
      "student_id*": "UUID",
      "date*": "Date (ISO 8601)",
      "attendance_status*": "Enum: present, absent, late, excused",
      "checkedIn_at": "Timestamp (optional)",
      "checkedOut_at": "Timestamp (optional)",
      "notes": "String (optional)"
    }
  ]
}

{
  "status": "success",
  "message": "45 attendance records marked",
  "data": {
    "created": 45,
    "failed": 0,
    "failures": []
  }
}

{
  "status": "error",
  "code": "INVALID_STATUS",
  "message": "Status must be one of: present, absent, late, excused"
}

{
  "status": "error",
  "code": "RECORDS_EXIST",
  "message": "Some attendance records already exist for this date"
}

const markAttendance = async (token, records) => {
  const response = await fetch(
    'https://api.skole.com/v1/teachers-app/attendance',
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ records })
    }
  );

  const data = await response.json();
  console.log(`Marked ${data.data.created} students`);
  return data.data;
};

// Usage
await markAttendance(token, [
  {
    student_id: 'uuid1',
    date: '2026-03-16',
    attendance_status: 'present',
    checkedIn_at: '2026-03-16T09:00:00Z'
  },
  {
    student_id: 'uuid2',
    date: '2026-03-16',
    attendance_status: 'absent'
  }
]);

def mark_attendance(token: str, records: list) -> dict:
    url = 'https://api.skole.com/v1/teachers-app/attendance'
    headers = {
        'Authorization': f'Bearer {token}',
        'Content-Type': 'application/json'
    }
    
    response = requests.post(url, headers=headers, json={'records': records})
    data = response.json()
    
    if data['status'] == 'success':
        print(f"Marked {data['data']['created']} students")
        return data['data']
    raise Exception(data['message'])

{
  "attendance_status": "Enum",
  "checkedIn_at": "Timestamp",
  "checkedOut_at": "Timestamp",
  "notes": "String"
}

{
  "status": "success",
  "message": "Record updated",
  "data": {
    "id": "UUID",
    "updated_at": "2026-03-16T10:30:45.000Z"
  }
}

const updateAttendance = async (token, recordId, updates) => {
  const response = await fetch(
    `https://api.skole.com/v1/teachers-app/attendance/${recordId}`,
    {
      method: 'PUT',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(updates)
    }
  );

  return (await response.json()).status === 'success';
};

{
  "status": "success",
  "data": {
    "records": [
      {
        "id": "UUID",
        "student_id": "UUID",
        "student_name": "Arjun Kumar",
        "roll_no": "12",
        "date": "2026-03-16",
        "attendance_status": "present"
      }
    ],
    "summary": {
      "total_students": 45,
      "present": 43,
      "absent": 2
    }
  }
}

const getClassAttendance = async (token, date) => {
  const params = new URLSearchParams({ date });
  const response = await fetch(
    `https://api.skole.com/v1/teachers-app/attendance?${params}`,
    {
      method: 'GET',
      headers: { 'Authorization': `Bearer ${token}` }
    }
  );

  return (await response.json()).data;
};

Form Data:
- file: File (CSV/Excel)
  Columns: student_roll_no, date, status, checkedIn_time, checkedOut_time
- dry_run: Boolean (optional, validate only)

{
  "status": "success",
  "message": "45 records imported",
  "data": {
    "imported": 45,
    "failed": 0,
    "errors": []
  }
}

const bulkUploadAttendance = async (token, file) => {
  const formData = new FormData();
  formData.append('file', file);

  const response = await fetch(
    'https://api.skole.com/v1/teachers-app/attendance/bulk-upload',
    {
      method: 'POST',
      headers: { 'Authorization': `Bearer ${token}` },
      body: formData
    }
  );

  const data = await response.json();
  console.log(`Imported: ${data.data.imported}`);
  return data.data;
};

{
  "status": "success",
  "data": {
    "class_summary": {
      "total_students": 45,
      "total_present": 850,
      "attendance_percentage": 88
    },
    "top_absentees": [{"name": "...", "absences": 3}],
    "trends": {...}
  }
}

const getAttendanceReports = async (token) => {
  const response = await fetch(
    'https://api.skole.com/v1/teachers-app/attendance/reports',
    {
      method: 'GET',
      headers: { 'Authorization': `Bearer ${token}` }
    }
  );

  return (await response.json()).data;
};

{
  "student_id*": "UUID",
  "date*": "Date",
  "attendance_status*": "Enum",
  "checkedIn_at": "Timestamp",
  "checkedOut_at": "Timestamp"
}

{
  "status": "success",
  "message": "Record created",
  "data": {
    "id": "UUID"
  }
}

const createAttendanceRecord = async (token, record) => {
  const response = await fetch(
    'https://api.skole.com/v1/web-app/attendance',
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(record)
    }
  );

  return (await response.json()).data;
};

{
  "status": "success",
  "data": {
    "records": [...],
    "pagination": {
      "total": 5400,
      "take": 20,
      "pages": 270
    }
  }
}

{
  "status": "success",
  "message": "Record updated"
}

{
  "status": "success",
  "message": "5400 records imported",
  "data": {
    "imported": 5400,
    "failed": 0
  }
}

{
  "status": "success",
  "data": {
    "school_statistics": {
      "total_students": 450,
      "avg_attendance_percentage": 88
    },
    "class_analysis": [...],
    "trends": {...}
  }
}