DEV Community: Med Amine

The Groundbreaking Schools Attendance Records Management System (ARMS)

Med Amine — Sun, 29 Jun 2025 13:42:07 +0000

Building ARMS – A better Attendance Records (or Record) Management System

Introduction

Hello everyone! I'm Mohammed the same dev of Xuploads, I’m excited to share a project I’ve been developing for quite some time — ARMS (Attendance Record Management System). It’s a system designed to streamline the way schools handle attendance, replacing the outdated, error-prone methods with a smarter, faster, and more reliable alternative.

This post covers the purpose, features, technical architecture, and some lessons learned along the way.

Why ARMS?

In many schools, attendance tracking is still handled manually — either using paper sheets or basic spreadsheets. That leaves a lot of room for mistakes, manipulation, and lost records. I’ve personally seen how chaotic it can get, especially when multiple classes are running in parallel or when attendance data is needed for reports.

The idea behind ARMS is to provide a centralized, secure, and intelligent system that schools can use to automate attendance tracking with as little friction as possible.

System Overview

ARMS is made up of three main parts:

The ARMS API – A .NET Framework backend (ASP.NET) that handles all the logic for sessions, attendance records, authentication, logs, etc.
The Desktop Application – A Windows-based GUI app built with VB.NET (Guna2 UI), used by administrators and staff to manage data, view attendance reports, and configure the system (works under WINE) with some UI bugs.
The Attendance Devices – Can be mobile phones, Raspberry Pi, or any device capable of sending RESTful HTTP requests (via RFID, QR codes, or biometric input).

The system is multi-language (Arabic + English), internet-accessible, and multi-device-friendly.

Key Features

Here’s what ARMS currently offers:

Smart Session Handling: Teachers start class sessions, and the system marks all students absent by default. As students scan their ID (via RFID or QR), their attendance is corrected automatically.
Late Arrival Logic: Each subject has a customizable grace period. Arriving after that marks the student as late, not absent.
Role-Based Access:
- Teachers only see their own sessions and classes.
- Admins get full control over schedules, users, attendance logs, and exceptions.
Timetable Management: The school director can set schedules and assign classes and subjects to specific days and times.
Statistics & Reporting: Visual charts and detailed logs allow staff to see absence patterns and generate reports.
Parent Notification (in progress): Absence alerts will be sent to parents via email at the end of the day.
Device Management: Each attendance device can be assigned to specific classes. Devices can be enabled/disabled remotely.
Extension Support: ARMS supports an extension system using interfaces, so new features (like QR scanning, fingerprint support, etc.) can be added without changing the core logic.
Remote API: The API is secured and supports remote access, making it ideal for schools with limited local networking infrastructure.

Tech Stack

Backend: ASP.NET (.NET Framework)
Frontend (Admin): VB.NET WinForms (Guna UI 2)
Database: SQL Server (hosted locally or in the cloud)
Language Support: Arabic & English (fully switchable UI)
API Communication: JSON over HTTP (RESTful endpoints)
Architecture: Layered architecture with full async support on the API side

Under the Hood

Sessions are created by staff and linked to classes and subjects.
Attendance records are updated in real-time as students scan their RFID/QR/ID.
Every major action (session start, student scan, admin edit) is logged for audit purposes.
Extensions implement a common interface and can be loaded dynamically — for example, you could add a fingerprint scanner extension without modifying the API or desktop app.

Deployment & Updates

The Windows desktop app includes a built-in updater it called 'ARMSUpdater'. It pulls the latest version info from a server and displays changelogs before updating.
API rate limiting and logging are implemented to ensure performance and traceability.
All database operations are done asynchronously to avoid locking or bottlenecks.

Future Plans

Daily Attendance Summary Emails to parents
Student Self-Registration Mode
Third-party integrations (e.g., school management systems, Google Calendar)
Mobile Web Interface for teachers
Cloud-ready version with multitenancy support (for multiple schools on the same server)

Final Thoughts

ARMS has been a challenging but rewarding project. It's not just about tracking who showed up — it's about making school management more efficient, accountable, and modern. I've built it with real-world use in mind, based on feedback from actual school staff and administrators.

If you're working on similar systems or have ideas for improvements, I’d love to hear your thoughts!

GitHub & Demo

This is still a private project under active development, but I’m considering open-sourcing parts of it (like the extension system or attendance logic) once I clean them up.

Feel free to reach out if you're interested in contributing or testing it in a real-world environment.

Thanks for reading!

Let me know what you think in the comments.

My first project 'Xuploads'

Med Amine — Sat, 26 Oct 2024 10:28:42 +0000

This is my first project. Xuploads is a web application for uploading, downloading, and sharing files, developed using VB.NET and ASP.NET.

Xuploads: A Feature-Rich, Secure, and Flexible File Upload Platform

Xuploads is an open-source file upload and sharing platform focused on file management, security, storage flexibility, and customization.

Users do not need an account to upload files. Each upload can be managed individually through dedicated control and deletion links, while administrators can configure how files are stored, protected, processed, and shared.

Main Features

File Upload and Sharing

Upload files without requiring user accounts.
Generate individual links for uploaded files.
Upload files directly from a URL.
Configure maximum upload sizes.
Restrict file extensions and configure individual extension size limits.
Support configurable upload and sharing behavior.

File Access and Protection

Password-protected files.
One-time download links.
Multiple one-time links for the same file.
File expiration by hours or a specific date.
Freeze and unfreeze files.
Geo-restrictions.
Hotlink protection.
IP-based restrictions and banning.
Configurable download waiting/countdown behavior.

File Replacement and Management

Files can be replaced while keeping the same public link and file identity.

Other management features include:

Changing the displayed filename.
Deleting files through dedicated links.
Controlling passwords and access settings.
Freezing and unfreezing files.
Managing expiration settings.
Generating QR codes for sharing.

Storage Providers

Xuploads separates file management from the storage backend through the IStorageProvider abstraction.

Supported storage backends include:

Local filesystem
FTP
SFTP
Azure Blob Storage

StorageSelector chooses the appropriate storage provider from the configured storage path, allowing the main application to work with different storage systems without requiring separate upload and download implementations for each backend.

Encryption

Xuploads supports AES encryption for files stored at rest.

Encrypted files use the .xeff format. Large-file processing is performed through streaming operations rather than loading complete files into memory.

VirusTotal Scanning

Xuploads can use VirusTotal to scan uploaded files for malware analysis.

Scanning can be configured by file extension. Administrators can choose to scan selected extensions or use an exclusion-based configuration to avoid scanning specific types.

Image Security and Processing

Xuploads supports image watermarking and image-specific processing.

Azure AI image safety analysis can also be enabled with configurable categories and thresholds. These checks can be applied during file replacement as well as during the initial upload process.

Statistics and Administration

Xuploads provides administrators with statistics and management tools for uploaded content.

The administration system includes tools for:

File management
File replacement
Password management
Freeze/unfreeze
Statistics
Storage synchronization
Corruption handling
Configuration
Contact submissions
Maintenance and system messages

Scheduled tasks can be executed through Hangfire, with command execution logging available for background operations.

File Integrity and Recovery

Xuploads includes tools for detecting and handling inconsistent or damaged upload states.

The maintenance system can detect problems with uploaded content and metadata and can take corrective action where supported.

Failed uploads are also cleaned up so incomplete uploads do not remain as normal files.

Time Handling

Xuploads uses UTC internally for time-sensitive operations such as expiration and logging.

Administrators can configure the timezone used for displaying dates and times.

Customization

Xuploads supports a range of customization options, including:

Custom upload and download pages
Additional headers and footers
Maintenance, information, and error messages
Custom query strings for control and deletion links
Custom query strings for direct image links
OpenGraph metadata
QR code generation
Google Analytics integration
Google Translate integration

The frontend also consumes server-provided information through data attributes, allowing the interface to remain flexible while security-sensitive decisions stay on the server.

XUAPI

XUAPI (Xuploads API) allows external applications to interact with Xuploads programmatically.

Current functionality includes:

Uploading files from URLs
Uploading files through HTTP POST requests
Providing upload metadata such as expiration and descriptions
Working with Xuploads' configured storage system

Planned API functionality includes additional file-management operations.

Architecture

Xuploads is designed around separation between application logic and storage.

The IStorageProvider interface allows different storage backends to provide the operations required by Xuploads while the rest of the application can work through a common storage abstraction.

This approach allows storage-related functionality such as uploading, downloading, deleting, replacing, synchronization, and maintenance operations to work across different storage systems.

Open Source

Xuploads is an open-source project licensed under the MIT License and hosted on GitHub.

GitHub: https://github.com/NecroPC18/Xuploads

Xuploads is intended to provide a complete file upload and sharing solution with configurable security, storage, file lifecycle, administration, and integration features in a single ASP.NET application.