Mighty School

Introduction

Mighty School is a modern, all-in-one School Management System built with Flutter and Laravel. It is designed for schools, colleges, and educational institutions to manage daily academic and administrative activities efficiently.

The system provides student and teacher management, class and subject organization, attendance tracking, exams and results, fees management, online classes, and detailed reports — all from a single powerful platform.

📱 App Setup

Mighty School allows you to launch your own branded app easily with minimal configuration.

🌐 Set Base URL

Open the following file:

/lib/utils/app_constant.dart

Update the base URL:

static const String baseUrl = "https://domain.com";

Rebuild the app after updating.

Change App Name

1. Edit appName in /lib/utils/app_constant.dart

2. Update label in AndroidManifest.xml

3. Update app name in Info.plist

Change App Package Name

Use IDE global replace carefully. Replace the existing package name with your new one.

Change App Icon & Logo

• Generate icons from appicon.co
• Android: Replace mipmap folders in /android/app/src/main/res
• iOS: Replace Assets.xcassets in /ios/Runner
• Replace logo in /assets/image/logo.png

🔥 Firebase Configuration

Mighty LMS uses Firebase for Push Notifications (FCM) and other Firebase services. Before running the application, you must connect your Flutter project with Firebase.

Step 1: Create a Firebase Project

1. Go to the Firebase Console.
2. Click Create a project (or Add project).
3. Enter your project name (e.g., "Mighty LMS").
4. Optionally enable Google Analytics (recommended for push notification analytics).
5. Click Create Project and wait for the setup to complete.
6. Click Continue to open the project dashboard.

Step 2: Register Android App in Firebase

1. On the Firebase project overview page, click the Android icon to add an Android app.
2. Enter your Android package name (e.g., com.fuedevs.lms).
3. Optionally enter the app nickname (e.g., "Mighty LMS Android").
4. Enter your debug signing certificate SHA-1 (optional, required for Google Sign-In if used).
5. Click Register app.

Step 3: Download and Add google-services.json

1. Download the google-services.json configuration file.
2. Place it in the following location in your Flutter project:

android/app/google-services.json

Step 4: Register iOS App in Firebase

1. Back in the Firebase project overview, click the iOS icon to add an iOS app.
2. Enter your iOS bundle identifier (e.g., com.fuedevs.lms).
3. Optionally enter the app nickname and App Store ID.
4. Click Register app.

Step 5: Download and Add GoogleService-Info.plist

1. Download the GoogleService-Info.plist configuration file.
2. Place it in the following location in your Flutter project:

ios/Runner/GoogleService-Info.plist

Step 6: (Recommended) Configure Firebase Using FlutterFire CLI

The FlutterFire CLI is the recommended way to configure Firebase across all platforms. It automatically generates the firebase_options.dart file used by the app.

Install FlutterFire CLI

dart pub global activate flutterfire_cli

Log in to Firebase

firebase login

Run Firebase Configuration

flutterfire configure

This command will:

• List your Firebase projects — select the one you created in Step 1
• Detect your Android package name and iOS bundle identifier
• Generate the lib/firebase_options.dart file automatically

Step 7: Verify Firebase Initialization

In your Flutter project, Firebase is initialized in the main.dart file. Ensure it uses the generated options:

void main() async {
WidgetsFlutterBinding.ensureInitialized();
await Firebase.initializeApp(
options: DefaultFirebaseOptions.currentPlatform,
);
runApp(const MyApp());
}

If you used FlutterFire CLI (Step 6), this is set up automatically.

Step 8: Enable Firebase Cloud Messaging (FCM)

1. In the Firebase Console, go to Project Settings → Cloud Messaging.
2. Verify that FCM is enabled for your project.
3. Obtain the Server Key and Sender ID — these are needed in your Laravel backend's .env file for sending push notifications.

Add the following to your Laravel .env file:

FCM_SERVER_KEY=your_fcm_server_key_here
FCM_SENDER_ID=your_fcm_sender_id_here

Push notifications in Mighty LMS are used for:

• Course enrollment confirmations
• New lesson or course updates
• Quiz and assignment reminders
• Certificate issued notifications
• Payment and invoice notifications
• General system announcements

Step 9: Android Notification Permission (Android 13+)

Android 13 (API level 33) and newer require runtime notification permission. The Mighty LMS Flutter app already includes the flutter_local_notifications plugin with the required permission handling. Users will see a system prompt to allow notifications on first launch.

Step 10: Test Push Notifications

1. Build and install the app on a physical device (emulators may not receive FCM reliably).
2. Log in to the app.
3. In the Firebase Console, go to Cloud Messaging and click Send your first message.
4. Compose a test notification and send it to your device.
5. Verify the notification appears in the device's notification tray.

Apply Changes

flutter clean
flutter pub get
flutter run

Build for Android

Once the application setup is complete, you can generate Android build files for testing or production release using Flutter CLI commands.

Generate APK

Run the following command to generate a full release APK:

flutter build apk

This command creates a release APK that supports all major Android device architectures.

Output location:

build/app/outputs/flutter-apk

Generate Split APKs (Smaller Size)

To generate separate APK files for different CPU architectures (recommended for smaller file size), run:

flutter build apk --target-platform android-arm,android-arm64,android-x64 --split-per-abi

This command generates multiple APK files. Use the APK that matches the target device architecture.

Generate App Bundle (Google Play Store)

The Android App Bundle (.aab) is the recommended format for publishing apps on the Google Play Store.

Step 1 — Configure Signing

Open the following file:

android/app/build.gradle

Inside buildTypes > release, set:

signingConfig = signingConfigs.release

Step 2 — Generate New Keystore (JKS)

Run the following command in your terminal.

macOS / Linux:

keytool -genkey -v -keystore ~/upload-keystore.jks -keyalg RSA \
-keysize 2048 -validity 10000 -alias upload

Windows (PowerShell):

keytool -genkey -v -keystore $env:USERPROFILE\upload-keystore.jks `
-storetype JKS -keyalg RSA -keysize 2048 -validity 10000 `
-alias upload

Step 3 — Create key.properties File

Create a file named:

android/key.properties

Add the following content:

storePassword=YOUR_STORE_PASSWORD
keyPassword=YOUR_KEY_PASSWORD
keyAlias=upload
storeFile=./upload-keystore.jks

Step 4 — Build App Bundle

Run the following command:

flutter build appbundle

build/app/outputs/bundle/release/app-release.aab

This command generates the Android App Bundle (.aab), which is required for publishing apps on the Google Play Store.

Build for iOS

iOS applications cannot be installed directly on physical devices in the same way as Android APK files. Apple requires iOS apps to be distributed through official channels such as TestFlight for testing or the App Store for public release.

To install and test the app on an iPhone or iPad, you must configure your Apple Developer Account, set up code signing in Xcode, and upload the build to TestFlight or the App Store.

Certificate Signing Request (CSR) Creation and Installation Guide

Step 1: Create a Certificate Signing Request (CSR)

1. Open Keychain Access on your Mac.
2. Go to Keychain Access → Certificate Assistant → Request a Certificate from a Certificate Authority.
3. Enter your email address, CA email address, and a common name (you may use your app name).
4. Select "Save to Disk".
5. Click Continue and save the CSR file to your computer.

Step 2: Generate the .p12 Certificate

1. Go to your Apple Developer Account.
2. Navigate to Certificates, Identifiers & Profiles.
3. Click on Certificates and then click the (+) button.
4. Select "Apple Push Notification service SSL (Sandbox & Production)".
5. Select the appropriate App ID.
6. Click Continue and upload the CSR file you created.
7. Download the generated certificate.

Step 3: Install the Certificate

1. Double-click the downloaded certificate file to install it in Keychain Access.
2. Go to Keychain Access → My Certificates.
3. Locate the newly installed certificate.
4. Right-click the certificate and select Export.
5. Choose a location and export the certificate as a .p12 file.
6. Set a password for the certificate.

Note: Store the password securely. Xcode may ask for the Keychain password when running the app. If you prefer not to enter the password each time, you may leave it empty.

Open the Project in Xcode

1. Open Xcode on your Mac.
2. Select File → Open or press Command + O.
3. Navigate to your Flutter project directory.
4. Open the ios folder.
5. Select the .xcworkspace (recommended) or .xcodeproj file.

Xcode will open your Flutter project, allowing you to build, run, and configure your iOS application.

Change Bundle Name

1. Select your project in the Xcode project navigator.
2. Choose the target from the Targets section.
3. Go to the Info tab.
4. Scroll to Custom iOS Target Properties.
5. Locate Bundle Name and edit its value.
6. Save changes using Command + S.

Change Bundle Identifier

The Bundle Identifier is a unique identifier for your application on iOS and macOS. It must be unique across all apps in the App Store.

1. Select your project in Xcode.
2. Go to the General tab.
3. Under the Identity section, update the Bundle Identifier.

📖 User Guide

Mighty School is a complete School Management System. Every feature is run from the web Admin Panel (accessed from a browser at your site's domain, e.g. https://yoursite.com/sign-in), organized into the modules listed in the left sidebar. This guide covers each module in the order it appears in the sidebar.

Step 1: Login

1. Open a web browser and go to your Mighty School Admin Panel URL (e.g. https://yoursite.com/sign-in).
2. Enter your Admin Email and Password, then click Login.
3. Choose the correct Branch and academic Session from the top-right dropdowns.

Full Feature List

The Admin Panel sidebar groups every feature into the following modules:

• Dashboard — At-a-glance summary cards, charts, and recent activity for the institute.
• Students Information — Student admission, profiles, categories, and ID cards.
• Staffs Information — Teacher and staff profiles, staff attendance.
• Student Attendance — Daily attendance, exam attendance, attendance reports, absent fines.
• QR Code Attendance — Camera-based attendance scanning using student ID QR codes.
• Academic Configuration — Academic session, shift, class, sections, groups, periods, subjects, departments.
• Fees Management — Fee setup, fee collection, waivers, paid/unpaid reports.
• Accounts Management — Ledgers, payments, receipts, contra, journal, fund transfers, chart of accounts.
• Accounting Reports — Balance sheet, trial balance, cash flow, income statement, cash summary.
• Payroll Management — Salary structure, salary assignment, salary slips, dues, advances.
• Routine Management — Class routines, syllabus, assignments, exam routines, seating plans.
• Library Management — Book catalog, members, issue/return, barcode printing.
• Exam Module — Exam setup, mark entry, results, tabulation sheets, result cards, online exams.
• Layout & Certificates — Admit cards, ID cards, certificates, and other printable layouts.
• SMS Module — SMS templates and messaging to students, parents, and staff.
• Administrator — Admin user accounts and role permissions.
• System — Core system configuration and maintenance tools.
• Master Configuration — System settings, roles, users, institutes, branches, payment gateways.
• CMS Management — Website content such as pages, news, and notices for the public site.
• WhatsApp — WhatsApp messaging integration and settings.
• Hostel Management — Hostel rooms, allocation, and resident tracking.
• Transport Management — Vehicles, routes, and student transport assignment.
• Google Meet — Schedule and join online classes via Google Meet.
• AI Assistant — In-panel AI assistant for quick help and lookups.

Step 2: Students Information

Navigate to Students Information to admit new students and manage existing student records — profile details, class/section assignment, guardian information, student categories, and ID cards. This is where a student's record is created before they can appear in Attendance, Fees, or Exam screens.

Step 3: Manage Staff & Teachers

1. Navigate to Staffs Information → Teachers List (or Staffs List for non-teaching staff).
2. Browse each teacher's profile photo, phone, email, department, designation, and blood group, and toggle their status between Enable and Disable.
3. Click Add New Teacher to register a new staff member, or use the row's Actions menu to edit or remove one. Staff Attendance, in the same menu, is used to mark daily staff attendance.

Step 4: Take Student Attendance

1. Navigate to Student Attendance → Student Attendance.
2. Select the Class, Section, and Date, then click Search to load the student list.
3. Mark each student Present or Absent using the checkboxes next to their name and roll number, then save.

Exam Attendance and Exam Schedule, in the same menu, cover attendance during exams. To review daily attendance afterward, open Attendance Report, choose a class, section, and date range, and click Search to see each student's present/absent count and attendance ratio. Absent Fine lists any lab, quiz, or attendance-percentage fines generated from absences.

Step 5: QR Code Attendance

For faster check-in, Mighty School can take attendance by scanning a student's ID card QR code instead of ticking boxes manually.

1. Navigate to QR Code Attendance → QR Attendance.
2. Allow the browser to access your camera when prompted.
3. Scan the student's smart card, or type the code into Enter QR Code manually and click Submit if a scanner isn't available.

Step 6: Academic Configuration

Before working with classes, exams, or fees, set up the institute's core academic structure under the Academic Configuration menu: Academic Session, Shift, Class, Sections, Groups, Periods, Subjects, Subject Config, Departments, Student Categories, and Picklist.

1. Open Academic Configuration → Academic Session.
2. Click Add Session to create a new academic year, or use Edit to update an existing one. Only one session can be Active at a time — data entry and reports use the session selected at the top of the page.

Step 7: Collect Fees

1. Navigate to Fees Management → Smart Collection (Quick Collection).
2. Select a Class and Section and click Search to list every student, along with their group and category.
3. Click the cart icon on a student's row to open their fee items and collect payment.

The rest of the Fees Management menu handles setup and follow-up: Fees StartUp and Fees Mapping define fee heads and assign them to classes; Amount Config and Date Config set amounts and due dates; Fine Waiver and Waiver apply discounts or exemptions; and Paid Info / Unpaid Info show who has and hasn't paid.

Step 8: Accounts & Transactions

1. Navigate to Accounts Management → Payment or Receipt to record money going out or coming in.
2. Set the date and receipt type (e.g. Cash), choose a ledger under Transaction For, and enter the Amount, Fund, and an optional reference and description.
3. Click Save to post the transaction.

Contra, Journal, and Fund Transfer cover other transaction types, while Ledger, Fund, Category, Group, and Chart of Accounts let you set up the underlying accounting structure.

Step 9: Accounting Reports

1. Navigate to Accounting Reports and choose a report — Income Statement, Balance Sheet, Trial Balance, Cash Flow Statement, Cash Flow Details, Cash Book Account, Ledger Book Account, Income Statement Details, or Cash Summary.
2. Set a From and To date and click Search to generate the report for that period.

Step 10: Payroll Management

1. Set up salary structures first under Payroll Management → Payroll Start Up and Payroll Mapping.
2. Open Payroll Assign to review or adjust each staff member's Net Salary, Basic, Allowances, and deductions (Early Leave Fine, Welfare Fund, Professional Tax, and so on), then click Update.
3. Use Salary Slip, Salary, Due, Advance, and Return Advance Payment to process monthly pay, track outstanding dues, and manage salary advances. Salary Statement pulls a summary by year and month.

Step 11: Routine Management

1. Navigate to Routine Management → Class Routine.
2. Filter the list by class, then click View Routine to see a section's schedule, or Manage Routine to edit it.

3. Inside Manage Routine, each weekday is its own collapsible panel. For every subject, set the Start Time, End Time, Assign Teacher, and Room, then save.

Syllabus and Assignments, in the same menu, publish the class syllabus and homework, while Exam Routine and Admit & Seat Plan handle exam-day scheduling and seating.

Step 12: Library Management

1. Navigate to Library Management → Books and click Add New Book (or Bulk Upload for many books at once).
2. Fill in the book's Name, Code, Category, Author, Publisher, Rack No., Quantity, and Publish Year, then click Add Book.
3. Use Book Categories and Members / Library ID to manage catalog categories and library members, and Books Issue / Book Issue Search / Book Issues Report to track lending and returns. Barcode Books Print prints barcode labels for the catalog.

Step 13: Exam Module

The Exam Module covers the full exam cycle — from configuring exams to entering marks, publishing results, and generating printable result cards, tabulation sheets, and admit cards.

Set Up an Exam

1. Navigate to Exam Module → Exam StartUp.
2. Select a Class, then choose which global exam codes apply to it from the Exam Code tab (each code shows its Total Marks, Pass Marks, and Acceptance ratio). The Exam Grade and Exam Create tabs configure grading scales and create the exam itself.

If you use domain-based (cognitive/affective/psychomotor) assessment alongside written marks, configure the domains first under Assessment Domains — each domain (e.g. Cognitive, Affective, Psychomotor) has its own list of scored items such as Subject Knowledge, Discipline, or Handwriting.

Then use Domain Assessment Entry to select a class and exam, load the student list, and rate each student on every domain item with a Rating, Score, and optional Remarks.

Enter Marks & Publish Results

1. Use Mark Config and Remarks Config to define how marks map to grades and remarks, then enter written/MCQ marks under Mark Input (or print a blank Empty Mark Sheet for manual collection).
2. Open Exam Result, filter by Class, Section, and Exam/Term, and click Generate to see each student's Total, GPA, Grade, Status, and Position.
3. To notify parents and students once results are ready, set the Send Scope and delivery channel (SMS, WhatsApp, or both) under Send Result Notifications and click Queue Notifications.

Grand Final Result & Tabulation Sheet

1. Navigate to Grand Final Result to combine results across multiple exams/terms into one final result. Select the students to include and continue to generate it.

2. Open Tabulation / Broad Sheet, choose a Class, Section, Exam/Term, and Sheet Type, then click Generate to view a subject-by-subject mark sheet for the whole class. Use Print or PDF to export it.

Result Cards & Admit Cards

1. Before printing individual result cards, open Result Card Settings to choose which fields appear (photo, percentage, GPA, attendance, signatures, and more) and set the card's title, labels, and color scheme.

2. Admit cards for each student — with their photo, subject/exam-code table, and exam instructions — can be generated and printed from Layout & Certificates or Admit & Seat Plan (under Routine Management).

Online Examination

1. Navigate to Exam Module → Online Examination → Create Online Exam.
2. Enter the exam Name, and choose the linked Academic Exam, Class, and Subject. Set the Duration, Start/End window, Pass marks, Attempt limit, and marks, and toggle options like Negative Marking, Random Questions, or Random Options as needed.
3. Click Save to publish it.

Every online exam you create is listed under Online Examinations, showing its subject, class, active window, and status, with quick links to Edit, Results, and Transfer Marks (to move online scores into the regular mark sheet). Other utilities in this menu — Assessment Domains, Domain Assessment Entry, and Grand Final Result — are covered above.

Step 14: Layout & Certificates

Navigate to Layout & Certificates to design and print institute documents — student and staff ID cards, admit cards, certificates, and other layout templates — with your own branding, colors, and fields.

Step 15: SMS Module

Navigate to SMS Module to create SMS templates and send messages to students, parents, or staff — either one-off broadcasts or messages triggered by events elsewhere in the system, such as attendance or exam results.

Step 16: Administrator & System

Administrator manages admin user accounts and login access to the panel itself. System holds core system configuration and maintenance tools for the installation.

Step 17: Master Configuration

System-wide settings live under Master Configuration: System Settings, Roles and Users (admin accounts and permissions), Institutes and Branches (for multi-branch setups), and Payment Gateways, where you can enable and configure the online payment methods available for fee collection (bKash, Stripe, PayPal, SSLCommerz, RazorPay, and others). See Payment Gateway Setup for step-by-step credential configuration.

Step 18: CMS Management

Navigate to CMS Management to edit the content shown on the institute's public website — pages, news, notices, and similar content — without touching code.

Step 19: WhatsApp

Navigate to WhatsApp to configure the WhatsApp messaging integration used for notifications such as result announcements (see Send Result Notifications in the Exam Module above).

Step 20: Hostel Management

Navigate to Hostel Management to manage hostel rooms and beds, allocate students to rooms, and track hostel residents.

Step 21: Transport Management

Navigate to Transport Management to manage vehicles and routes, and assign students to a transport route/stop.

Step 22: Google Meet

Navigate to Google Meet to schedule and share online class links, letting teachers and students join live classes directly from the panel.

Step 23: AI Assistant

Navigate to AI Assistant for in-panel help — ask questions about how to use a feature or look up data without leaving the Admin Panel.

🔔 Notifications

Mighty School keeps everyone informed through the SMS Module and WhatsApp integration:

• Students & Parents: Attendance alerts, exam results, fee reminders, and admit card notices
• Staff: Payroll and duty-related updates
• Administrators: System alerts and notification delivery status

This section is intended for developers who want to integrate with the Mighty API directly, understand how data is structured in the database, extend the Laravel backend with custom functionality, manage environment configuration, or safely apply updates and migrations.

API Endpoints

The Mighty backend exposes a REST API built on Laravel, secured with Laravel Passport (OAuth2). All endpoints are versioned and served from your API subdomain, for example:

https://api.yoursite.com/api/v1

Authentication

Most endpoints require a Bearer token obtained via the login endpoint. Include the token in the Authorization header of every authenticated request:

Authorization: Bearer {access_token}
Accept: application/json

A complete, importable Postman collection is included with the download package (see Postman Collection) and documents request/response payloads, required parameters, and error formats for every endpoint.

Sample Request & Response Payloads

The examples below illustrate the shape of the JSON returned by the most commonly used endpoints. Field names, pagination metadata, and error formats follow the same structure across the rest of the API. Treat these as illustrative — always confirm exact fields against the bundled Postman collection for your installed version.

POST /auth/login

{
  "status": true,
  "message": "Login successful",
  "data": {
    "access_token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...",
    "token_type": "Bearer",
    "expires_in": 3600,
    "user": {
      "id": 102,
      "name": "Jane Cooper",
      "email": "jane.cooper@example.com",
      "role": "student",
      "branch_id": 1,
      "avatar": "https://api.yoursite.com/storage/avatars/102.png"
    }
  }
}

GET /students

{
  "status": true,
  "data": {
    "current_page": 1,
    "per_page": 10,
    "total": 512,
    "items": [
      {
        "id": 15,
        "name": "Emma Watson",
        "roll_no": "23",
        "class": "Class 8",
        "section": "A",
        "category": "General",
        "guardian_phone": "+1555000123",
        "photo": "https://api.yoursite.com/storage/students/15/photo.png",
        "status": "active"
      }
    ]
  }
}

GET /students/{id}

{
  "status": true,
  "data": {
    "id": 15,
    "name": "Emma Watson",
    "roll_no": "23",
    "class": "Class 8",
    "section": "A",
    "date_of_birth": "2012-04-09",
    "blood_group": "O+",
    "guardian": {
      "name": "Robert Watson",
      "relation": "Father",
      "phone": "+1555000123"
    },
    "category": "General",
    "admission_date": "2021-06-01"
  }
}

POST /attendance/mark

{
  "status": true,
  "message": "Attendance saved",
  "data": {
    "class_id": 8,
    "section_id": 1,
    "date": "2026-08-19",
    "marked_count": 34,
    "present_count": 31,
    "absent_count": 3
  }
}

GET /routine/{classId}

{
  "status": true,
  "data": {
    "class": "Class 8",
    "section": "A",
    "days": [
      {
        "day": "Sunday",
        "periods": [
          { "subject": "Mathematics", "teacher": "Alex Morgan", "room": "204", "start": "08:00", "end": "08:45" },
          { "subject": "English", "teacher": "Priya Nair", "room": "204", "start": "08:45", "end": "09:30" }
        ]
      }
    ]
  }
}

GET /exams/{examId}/results/{studentId}

{
  "status": true,
  "data": {
    "exam": "Half Yearly Examination",
    "student_id": 15,
    "total_marks": 500,
    "obtained_marks": 421,
    "gpa": 4.67,
    "grade": "A",
    "status": "Pass",
    "position": 6,
    "subjects": [
      { "subject": "Mathematics", "marks": 88, "grade": "A+" },
      { "subject": "English", "marks": 79, "grade": "A" }
    ]
  }
}

GET /fees/{studentId}

{
  "status": true,
  "data": {
    "student_id": 15,
    "session": "2026-2027",
    "items": [
      { "fee_head": "Tuition Fee", "amount": 150.00, "due_date": "2026-09-05", "status": "unpaid" },
      { "fee_head": "Library Fee", "amount": 20.00, "due_date": "2026-09-05", "status": "paid" }
    ],
    "total_due": 150.00
  }
}

POST /fees/{studentId}/pay

{
  "status": true,
  "message": "Payment recorded",
  "data": {
    "payment_id": 5821,
    "student_id": 15,
    "fee_head": "Tuition Fee",
    "amount": 150.00,
    "gateway": "stripe",
    "paid_at": "2026-08-19T09:15:32Z",
    "receipt_no": "RCPT-000582"
  }
}

GET /settings

{
  "status": true,
  "data": {
    "app_name": "Mighty School",
    "currency": "USD",
    "currency_symbol": "$",
    "logo_url": "https://api.yoursite.com/storage/branding/logo.png",
    "payment_gateways": {
      "stripe": true,
      "paypal": false
    },
    "maintenance_mode": false
  }
}

Error Response Format

Failed requests follow a consistent shape so client apps can handle errors generically:

{
  "status": false,
  "message": "The given data was invalid.",
  "errors": {
    "email": ["The email field is required."],
    "password": ["The password must be at least 8 characters."]
  }
}

Database Schema Overview

The backend uses a relational MySQL/MariaDB schema managed entirely through Laravel migrations located in database/migrations. Below is a high-level overview of the core tables; refer to the migration files for exact columns, indexes, and foreign keys.

To inspect the live schema on your own installation, you can generate an entity diagram or dump the structure with standard tools, for example:

php artisan schema:dump
# or, using mysqldump
mysqldump -u DB_USER -p --no-data DB_NAME > schema.sql

Extending Functionality

The backend follows standard Laravel conventions, which makes it straightforward to add custom features without modifying core files directly.

1. Add new routes. Define additional API routes in routes/api.php, grouped under your own prefix and middleware:

   Route::prefix('v1')->middleware('auth:api')->group(function () {
       Route::get('/custom-feature', [CustomFeatureController::class, 'index']);
   });

2. Create a controller. Use the Artisan generator to scaffold new controllers, models, and migrations:

   php artisan make:controller CustomFeatureController
   php artisan make:model CustomFeature -m

3. Register service providers. For larger add-ons (custom payment gateways, notification channels, third-party integrations), create a dedicated service provider in app/Providers and register it in bootstrap/providers.php (or config/app.php on older Laravel versions).
4. Extend the admin panel. Admin views and controllers live under resources/views and app/Http/Controllers/Admin. New sections can be added by following the existing module structure (route, controller, view, and, if needed, a migration for supporting data).
5. Extend the Flutter app. New screens and API bindings can be added under lib/, following the existing folder structure (models, providers/controllers, screens, and API service classes) so new features stay consistent with the rest of the app.

Environment Variables & Configuration

Application configuration is controlled through the .env file at the project root, which is read into the various files under config/. This file is not included in version control and must be configured per environment (local, staging, production).

Key variables you will typically need to review or update:

After changing any .env value, clear the configuration cache so the change takes effect:

php artisan config:clear
php artisan config:cache

System Updates & Migrations

Follow this process when applying a new version of the system to an existing installation.

1. Back up first. Take a full backup of the database and the storage directory before updating anything — see Database Backup & Restore for the exact commands:

   mysqldump -u DB_USER -p DB_NAME > backup_$(date +%F).sql

2. Enable maintenance mode so users are not affected while files are replaced:

   php artisan down

3. Replace application files with the new release, keeping your existing .env file, storage directory, and any custom code untouched.
4. Install/update dependencies:

   composer install --no-dev --optimize-autoloader

5. Run any new database migrations:

   php artisan migrate --force

   The --force flag is required to run migrations in a production environment. Review the release notes for that version to confirm whether new migrations are included.

6. Clear and rebuild caches:

   php artisan config:clear
   php artisan cache:clear
   php artisan route:clear
   php artisan view:clear
   php artisan optimize

7. Disable maintenance mode once you have verified the update:

   php artisan up

8. Rebuild the Flutter app(s) only if the update includes changes to lib/ or API contracts, following the same steps described in Build for Android, Build for iOS, and Web Setup. If the build fails after pulling new dependencies, see Flutter Build Troubleshooting.

Mighty School supports collecting fee payments online through Stripe and PayPal. Both gateways are configured in two places: your Laravel .env file (for the API keys) and the Admin Panel Master Configuration → Payment Gateways screen (to enable/disable each gateway and set the display currency).

Stripe Setup

Step 1 — Create/Access Your Stripe Account

1. Sign up or log in at https://dashboard.stripe.com/.
2. Complete Stripe's account activation (business details) before going live — test mode works without this.

Step 2 — Get Your API Keys

1. In the Stripe Dashboard, go to Developers → API keys.
2. Toggle Test mode (top-right) on while integrating.
3. Copy the Publishable key (starts with pk_) and the Secret key (starts with sk_).

Step 3 — Add Keys to Your Laravel .env File

STRIPE_KEY=pk_test_xxxxxxxxxxxxxxxxxxxxxxxx
STRIPE_SECRET=sk_test_xxxxxxxxxxxxxxxxxxxxxxxx

Step 4 — Configure a Webhook (Required)

Stripe notifies your backend when a payment succeeds via a webhook. Without this, fee payment status will not be confirmed automatically after payment.

1. In the Stripe Dashboard, go to Developers → Webhooks → Add endpoint.
2. Set the endpoint URL to:

   https://api.yoursite.com/api/v1/payments/stripe/webhook

3. Select the checkout.session.completed and payment_intent.succeeded events.
4. Copy the generated Signing secret (starts with whsec_) and add it to .env:

   STRIPE_WEBHOOK_SECRET=whsec_xxxxxxxxxxxxxxxxxxxxxxxx

Step 5 — Enable Stripe in the Admin Panel

1. Log in to the Admin Panel and navigate to Master Configuration → Payment Gateways.
2. Toggle Stripe to enabled.
3. Save changes and run php artisan config:clear on the server.

PayPal Setup

Step 1 — Create a PayPal Developer App

1. Log in at https://developer.paypal.com/dashboard/.
2. Go to Apps & Credentials.
3. Switch between the Sandbox and Live tabs depending on which credentials you need.
4. Click Create App, give it a name (e.g., "Mighty School"), and select a Sandbox business account if using test mode.

Step 2 — Get Your Client ID and Secret

1. Open the app you just created.
2. Copy the Client ID and Secret shown on the app details page.

Step 3 — Add Credentials to Your Laravel .env File

PAYPAL_MODE=sandbox
PAYPAL_CLIENT_ID=your_paypal_client_id_here
PAYPAL_CLIENT_SECRET=your_paypal_client_secret_here

Set PAYPAL_MODE=live only once you switch to your Live app credentials from the Live tab of the developer dashboard.

Step 4 — Enable PayPal in the Admin Panel

1. Navigate to Master Configuration → Payment Gateways in the Admin Panel.
2. Toggle PayPal to enabled and save.
3. Run php artisan config:clear on the server.

Step 5 — Test a Purchase

1. Use a Sandbox buyer account to complete a test fee payment from the app or web build.
2. Confirm the payment appears under the test student's Fees Management → Paid Info.
3. Confirm the corresponding row appears in the payments table.

Mighty School sends transactional emails — account confirmations, password resets, fee payment receipts, and exam result notifications — through Laravel's mail system. You must configure an SMTP provider before these emails will be delivered.

Step 1 — Choose an SMTP Provider

Any standard SMTP provider works, for example your hosting's built-in mail service, Gmail (via an app password), or a transactional provider such as Mailgun, SendGrid, Amazon SES, or Brevo. Transactional providers are recommended for production since they offer better deliverability and rate limits than a personal inbox.

Step 2 — Get Your SMTP Credentials

The exact steps vary by provider, but you will always need: an SMTP host, a port, a username, a password (or API key used as the password), and an encryption type (TLS or SSL). Example for Gmail:

1. Enable 2-Step Verification on the Google account you'll send from.
2. Go to Google Account → App Passwords and generate a new app password for "Mail".
3. Use that generated 16-character password as MAIL_PASSWORD below (not your normal Gmail password).

Step 3 — Add SMTP Settings to Your .env File

MAIL_MAILER=smtp
MAIL_HOST=smtp.yourprovider.com
MAIL_PORT=587
MAIL_USERNAME=your_smtp_username
MAIL_PASSWORD=your_smtp_password_or_api_key
MAIL_ENCRYPTION=tls
MAIL_FROM_ADDRESS="no-reply@yourdomain.com"
MAIL_FROM_NAME="${APP_NAME}"

Step 4 — Clear the Configuration Cache

php artisan config:clear
php artisan config:cache

Step 5 — Send a Test Email

From your server's terminal, run Laravel's Tinker console to send a quick test email and confirm delivery:

php artisan tinker
Mail::raw('Mighty School SMTP test', function ($msg) {
    $msg->to('you@example.com')->subject('SMTP Test');
});

Alternatively, trigger a real flow such as a new guardian registration or a password-reset request from the app, and confirm the email arrives (check spam/junk folders too).

Step 6 — Where Emails Are Triggered

• New account registration (verification/welcome email)
• Password reset requests
• Fee payment receipts
• Exam result notifications
• Admit card / certificate issued notices

Most server-side issues (blank/white screens, HTTP 500 responses, failed installs, or API calls that silently fail) leave a trace in Laravel's log files. Checking the logs first is almost always faster than guessing at a fix.

Where to Find the Logs

The default Laravel log file lives at:

storage/logs/laravel.log

By default, Laravel writes a single rolling laravel.log file. If daily log rotation is enabled in config/logging.php, you will instead see one file per day:

storage/logs/laravel-2026-07-28.log
storage/logs/laravel-2026-07-27.log

You can view the most recent entries directly from SSH/terminal:

tail -n 100 storage/logs/laravel.log

Or watch it live while reproducing an issue:

tail -f storage/logs/laravel.log

If you don't have terminal access, open storage/logs/laravel.log directly from your hosting File Manager. On shared hosting, also check your control panel's Error Log viewer (cPanel → Metrics → Errors) for lower-level PHP/webserver errors that never reach Laravel's own log.

Common Errors and How to Resolve Them

Enabling More Verbose Logging Temporarily

If the default log entries aren't enough to diagnose an issue, you can temporarily raise the log level in your .env file:

LOG_CHANNEL=stack
LOG_LEVEL=debug

Then clear the config cache so the change takes effect:

php artisan config:clear

When to Contact Support

If you've checked storage/logs/laravel.log, your hosting error log, and the table above without finding a resolution, contact support through the CodeCanyon support channel with:

• The exact error message and stack trace from storage/logs/laravel.log
• PHP version, MySQL/MariaDB version, and hosting type (shared, VPS, cloud)
• Steps to reproduce the issue
• Your purchase code

Most build-time failures in the Flutter app come from dependency version mismatches, stale caches, or a local toolchain that doesn't match the versions the project was built against. Work through the steps below in order — the first two resolve the large majority of reported build issues.

Step 1 — Clean the Project First

Before investigating anything else, always start with a full clean:

flutter clean
flutter pub get

This removes the build/ and .dart_tool/ directories and re-resolves every package, which clears out a large share of "phantom" errors caused by stale generated files.

Step 2 — Check Your Flutter & Dart SDK Versions

The project targets a specific Flutter/Dart SDK range defined in pubspec.yaml. Confirm what you have installed:

flutter --version
flutter doctor -v

If flutter doctor reports a Dart SDK outside the range declared under environment: sdk: in pubspec.yaml, switch to a matching Flutter version using a version manager such as fvm, or install the required SDK directly from Flutter's release archive.

Step 3 — Resolve Dependency Version Conflicts

If flutter pub get fails with a message such as "version solving failed" or lists two packages that require incompatible versions of the same dependency, use these commands to diagnose it:

flutter pub deps
flutter pub outdated

flutter pub outdated shows which packages have newer versions available and flags ones that are constrained by another dependency. Common fixes:

• Pin a conflicting package to the version already declared in pubspec.yaml rather than upgrading it independently — mixed manual upgrades are the most frequent cause of solver conflicts.
• If you added a new plugin, check its pubspec.yaml on pub.dev for its own SDK/dependency constraints before installing it, rather than after.
• As a last resort for a single stubborn package, override its resolved version under dependency_overrides in pubspec.yaml — use this sparingly, and remove the override once the upstream packages catch up.

Step 4 — Reset the Local Pub Cache

If pub get succeeds but the build still references outdated package code (mismatched method signatures, missing classes that exist in the changelog), the local pub cache may be corrupted:

flutter pub cache repair

Then repeat Step 1.

Step 5 — Android-Specific Build Errors

• Gradle/Kotlin version mismatch (e.g. "Could not resolve org.jetbrains.kotlin..." or "Minimum supported Gradle version..."): check the Gradle version in android/gradle/wrapper/gradle-wrapper.properties and the Android Gradle Plugin / Kotlin versions in android/settings.gradle (or android/build.gradle on older projects) match what your installed Android Studio / command-line tools expect.
• "Duplicate class" errors after adding a new plugin usually mean two dependencies bundle the same underlying library at different versions. Run ./gradlew app:dependencies from the android/ folder to see the dependency tree and identify which plugin needs to be excluded or upgraded.
• After changing any Gradle or Kotlin version, always run:

  cd android
  ./gradlew clean
  cd ..
  flutter clean
  flutter pub get

Step 6 — iOS-Specific Build Errors

• CocoaPods version conflicts (e.g. "CocoaPods could not find compatible versions for pod..."): update the local Pod repository and reinstall pods:

  cd ios
  pod repo update
  pod install --repo-update
  cd ..

• If pods remain out of sync after a dependency change, delete the generated iOS pod files and reinstall from scratch:

  cd ios
  rm -rf Pods Podfile.lock
  pod install
  cd ..

• Confirm the platform :ios version at the top of ios/Podfile meets the minimum iOS version required by any newly added plugin.

Step 7 — Still Stuck?

Run a verbose build and capture the full output before reaching out for support — the first error in a long Gradle/Xcode log is almost always the real cause, with everything after it being a downstream symptom:

flutter build apk --verbose
# or
flutter build ios --verbose

Include this output, your flutter doctor -v results, and the relevant section of pubspec.yaml when contacting support (see When to Contact Support for backend issues, or the CodeCanyon support channel for app build issues).

Your student, staff, attendance, exam, and fee data all live in the MySQL/MariaDB database. Taking regular backups — and knowing how to restore one — is one of the most important things you can set up, even if you're not familiar with server management. This section walks through both the point-and-click (phpMyAdmin) method and the command-line method.

Option A — Backup via phpMyAdmin (No Terminal Required)

1. Log in to your hosting control panel (cPanel or DirectAdmin).
2. Open phpMyAdmin from the Databases section.
3. Select your Mighty School database from the left-hand list.
4. Click the Export tab at the top.
5. Choose the Quick export method and SQL as the format — this is enough for most day-to-day backups.
6. Click Go and save the downloaded .sql file somewhere safe (a separate drive or cloud storage, not the same server).

Option B — Backup via Command Line (mysqldump)

If you have SSH access, this is the fastest and most reliable method:

mysqldump -u DB_USER -p DB_NAME > backup_$(date +%F).sql

Replace DB_USER and DB_NAME with the credentials from your .env file. You'll be prompted for the database password interactively — this avoids leaving it in your shell history. To also compress the backup:

mysqldump -u DB_USER -p DB_NAME | gzip > backup_$(date +%F).sql.gz

Option C — Automating Regular Backups (Recommended)

For production sites, don't rely on remembering to back up manually. Most hosting control panels include a built-in scheduler:

• cPanel: use the Backup Wizard or Backup tool to schedule automatic full or database-only backups, and configure a remote destination (FTP, Google Drive, Amazon S3) so backups don't live only on the same server.
• Cron job (SSH access): add a scheduled task that runs mysqldump daily and prunes old backups, for example via crontab -e. Replace the path with your own account's home directory:

  0 2 * * * mysqldump -u DB_USER -pDB_PASSWORD DB_NAME | gzip > /home/YOUR_USERNAME/backups/school_$(date +\%F).sql.gz

Also Back Up the storage Directory

Uploaded files — student photos, ID cards, certificates, and library book covers — are stored on disk under storage/app/public, not in the database. Back this folder up alongside your database export:

tar -czf storage_backup_$(date +%F).tar.gz storage/app/public

Restoring a Backup

Restore via phpMyAdmin

1. Open phpMyAdmin and select the target database (create a new empty database first if restoring to a fresh server).
2. Click the Import tab.
3. Click Choose File and select your saved .sql (or .sql.gz) backup file.
4. Click Go and wait for the import to complete — large databases can take several minutes.

Restore via Command Line

mysql -u DB_USER -p DB_NAME < backup_2026-07-15.sql

For a compressed backup:

gunzip < backup_2026-07-15.sql.gz | mysql -u DB_USER -p DB_NAME

After Restoring, Always:

1. Restore the matching storage/app/public backup so file references in the database (photos, certificates, attachments) point to files that actually exist.
2. Confirm the domain column in the shops table still matches the site you're running on — see Multi-Tenant Domain Management if it needs updating.
3. Clear the application cache:

   php artisan config:clear
   php artisan cache:clear

Changelog

This changelog documents the version history of Mighty School, including new features, improvements, and bug fixes.

Note: This changelog is updated with every new release to keep users informed about updates and changes.

Frequently Asked Questions (FAQ)