ParkEZ Documentation

About ParkEZ

ParkEZ is a complete smart parking management ecosystem that connects drivers searching for parking, owners listing their parking spaces, watchmen managing on-ground operations, and administrators overseeing the entire platform. Built with Flutter and Firebase, it ships as four tightly integrated apps that share a single backend.

Key Features

What's Included

• Customer App — Flutter mobile app (Android & iOS) for end users to find, book, and pay for parking.
• Owner App — Flutter mobile app for parking owners to list spaces, manage bookings, and view earnings.
• Watchman App — Flutter mobile app for on-site staff to verify vehicles, check-in/check-out, and resolve disputes.
• Admin Panel — Flutter web dashboard for platform administrators.
• Database Files — Pre-built Firestore collections for quick setup.
• Firestore Indexes — Optimized composite indexes for fast queries.
• Documentation — This comprehensive setup guide.

Before starting the setup, make sure you have the following tools and accounts ready.

Required Software

Required Accounts

• Google Account — For Firebase Console & Google Cloud.
• Firebase Account — Project hosting, Firestore, Authentication, and Storage.
• Google Cloud Console — For Google Maps API keys.
• Apple Developer Account (optional) — Required for iOS deployment & Apple Sign-In.
• Google Play Console (optional) — For publishing the three mobile apps to Google Play Store.

The ParkEZ package ships as a single repository containing four Flutter projects and a shared documentation folder.

Repository Layout

ParkEZ/
+-- admin_panel/        # Flutter Web - Admin Dashboard
+-- customer/           # Flutter Mobile - Customer App
+-- owner/              # Flutter Mobile - Owner App
+-- watchman/           # Flutter Mobile - Watchman App
+-- android/            # Shared Android scripts (if any)
+-- cloud_functions/    # Firebase Cloud Functions - server-side payment operations
+-- documentation/      # This documentation
+-- database/           # Firestore collection import / export scripts
+-- firestore_index/    # firestore.indexes.json + rules
+-- README.md

New to Flutter or Firebase? Don't worry. This page explains the whole setup in plain words. Follow the steps from top to bottom — each one links to a detailed page with exact commands, screenshots, and copy buttons on every command.

Quick Start Video

Prefer to watch instead of read? This short walkthrough shows the complete setup from start to finish — downloading the package, creating the Firebase project, importing the database, connecting the Admin Panel, and running the mobile apps.

What is in this package?

• Customer App — drivers use it to find, book, and pay for parking.
• Owner App — parking owners manage their parkings, slots, and earnings.
• Watchman App — gate staff scan booking QR codes at entry/exit.
• Admin Panel (website) — you control everything: users, payments, settings.
• Landing Page (website) — a ready marketing page for your business.

What do you need before starting?

• A computer (Windows or macOS — this guide covers both step by step; Linux also works for Android builds via Flutter's official install guide). A Mac is only needed if you want to build the iPhone versions.
• A free Google account — used to create your Firebase backend (your database).
• A Google Maps key (created from the same Google account — we show you how).
• Around 2–3 hours of time. You do NOT need to write any code.

This is the complete, ordered installation walkthrough. Each step links to the detailed section covering it — do them in this order; later steps depend on earlier ones.

Phase 1 — Environment

1. Install the Flutter SDK and add it to your PATH — Setting Up Flutter.
2. Install Android Studio (with an emulator) and, on macOS, Xcode + CocoaPods for iOS builds.
3. Run flutter doctor and resolve every reported issue before continuing.
4. Unzip the package. You will see customer/, owner/, watchman/, admin_panel/, landing_page/, cloud_functions/ and documentation/.

Phase 2 — Firebase Project

1. Create a Firebase project at console.firebase.google.com.
2. Register all four apps (three mobile + admin web) — Firebase Setup (CLI) or manual setup.
3. Enable sign-in providers (Email, Phone, Google, Apple) — Enabling Authentication.
4. Create the Firestore database and import the starter collections — Firestore Import.
5. Deploy the Firestore indexes — Indexing Import.
6. Enable Firebase Storage and apply the rules + CORS config — Storage Setup and CORS.
7. Deploy the Cloud Functions and Firestore security rules (required for payments, wallets & security) — Cloud Functions.

Phase 3 — API Keys & Signing

1. Create a Google Maps API key and add it to Android/iOS — Google Maps API.
2. Generate SHA-1 / SHA-256 keys and add them to Firebase — Generate SHA Keys.
3. Configure push notifications (FCM; APNS key on iOS) — Notification Setup.

Phase 4 — Run & Deploy

1. Run each mobile app: flutter pub get then flutter run inside customer/, owner/, watchman/ — Run Flutter App.
2. Set up and deploy the Admin Panel — Admin Panel Setup, then Deploy on Server or Deploy on Firebase.
3. Map your domain and enable SSL — Production Deployment.
4. Log in to the Admin Panel and complete in-app configuration — see the Configuration Guide.

ParkEZ targets Flutter stable. Follow the steps below for your operating system.

Setting Up Flutter on Windows

System Requirements

• Operating System: Windows 10 or later (64-bit).
• Disk Space: At least 2.8 GB (excluding IDE and tools).
• Required Tool: Git for Windows.

Download Flutter SDK

• Visit the official Flutter installation page.
• Download the latest stable version of the Flutter SDK (ZIP file).
• Extract the ZIP and move the flutter folder to a preferred location, e.g., C:\src\flutter.

Add Flutter to System Path

• Open the Start Menu, search for "Environment Variables", and click "Edit the system environment variables".
• In the System Properties window, click Environment Variables.
• Under User variables, locate the Path variable.
• If it exists, click Edit and append the path to flutter\bin (e.g., C:\src\flutter\bin).
• If it doesn't exist, click New, name it Path, and enter the path to flutter\bin.

Verify Installation

• Open Command Prompt and run:

flutter doctor

• This will analyze your environment and report any missing dependencies.

Install Android Studio

• Download Android Studio from developer.android.com.
• Launch the installer and complete the setup wizard, which installs:
• Android SDK
• Android SDK Command-line Tools
• Android SDK Build-Tools
• Go to Android Studio > Settings > Plugins and install both Flutter and Dart plugins.

Set Up an Android Emulator

• Open Android Studio.
• Go to Tools > AVD Manager.
• Follow the prompts to create a new Android Virtual Device (AVD).

Final Setup Check

flutter doctor

• Resolve any remaining issues shown in the output.

Setting Up Flutter on macOS

System Requirements

• Operating System: macOS 10.15 (Catalina) or later.
• Disk Space: At least 2.8 GB.
• Required Tools: Git, Xcode (for iOS development).

Download Flutter SDK

• Visit the official Flutter installation page for macOS.
• Download and extract the Flutter SDK to a preferred location, e.g., ~/development/flutter.

Add Flutter to PATH

• Open your shell profile file (.zshrc or .bashrc) and add:

export PATH="$PATH:$HOME/development/flutter/bin"

• Then run source ~/.zshrc (or restart your terminal).

Install Xcode

• Install Xcode from the Mac App Store.
• After installation, run the following commands to configure Xcode CLI tools:

sudo xcode-select --switch /Applications/Xcode.app/Contents/Developer
sudo xcodebuild -runFirstLaunch

Install CocoaPods

• CocoaPods is required for iOS dependency management:

sudo gem install cocoapods

Verify Installation

flutter doctor

• Resolve any issues reported by Flutter Doctor before proceeding.

ParkEZ supports three authentication methods used across the Customer, Owner, and Watchman apps. Enable each one in the Firebase Console.

1. Enable Phone Authentication

• Go to the Firebase Console.
• Select your ParkEZ project from the dashboard.
• In the left sidebar, click on "Authentication".
• Navigate to the "Sign-in method" tab.
• Locate "Phone" and click the edit icon.
• Toggle the switch to Enable phone authentication.
• Click Save.

2. Enable Google Sign-In

• Open the Firebase Console and select your ParkEZ project.
• Go to the Authentication section.
• Under the "Sign-in method" tab, find "Google" and click the edit icon.
• Toggle the Enable switch.
• If prompted, configure the OAuth consent screen by providing:
• App name (e.g., ParkEZ)
• Support email
• Developer contact details
• Save your changes.

3. Enable Apple Sign-In

• Visit the Firebase Console and select your project.
• Go to Authentication > Sign-in method.
• Scroll to Apple and click the edit icon.
• Enable the provider and provide the required Apple Developer credentials:
• Team ID (from your Apple Developer account)
• Service ID
• Key ID
• Private Key (.p8 file)
• Save your configuration.

Import the pre-built ParkEZ Firestore collections (users, owners, watchmen, parkings, bookings, transactions, settings, etc.) to populate your database with the required structure.

1. Create the Firestore Database

1. Open the Firebase Console and select your project.
2. In the left menu go to Build → Firestore Database.
3. Click Create database.
4. Pick the location closest to your users (e.g. asia-south1 for India). This cannot be changed later.
5. Choose a starting mode — either is fine, because you will set the rules yourself in the next step:
   • Start in production mode → rules begin as allow read, write: if false; — everything is blocked, so the apps will show no data until you update the rules.
   • Start in test mode → rules begin open but expire after 30 days, after which everything is blocked automatically.
6. Click Create and wait for the database to be provisioned.

2. Set the Firestore Security Rules

ParkEZ ships with production-grade security rules (cloud_functions/firestore.rules, also included in firestore_index.zip). They scope every collection: customers only manage their own profile, wallet history, and bookings; owners only their own parkings and staff; watchmen only their assigned parking; admins manage everything. Wallet balances and payment secrets are locked so they can only be touched by the Cloud Functions (Admin SDK) and the Admin Panel — never directly by an app user.

Option A (recommended): the rules deploy automatically together with the Cloud Functions in the Cloud Functions step (firebase deploy --only functions,firestore) — nothing to do here.

Option B (manual): in Firestore Database → Rules, delete everything in the editor, paste the following, and click Publish:

rules_version = '2';

// ParkEZ production security rules.
//
// Highlights:
//  - Nothing is writable without authentication; most reads require sign-in.
//  - Wallet balances (walletAmount) can NEVER be changed from a client app:
//    all balance mutations go through the Cloud Functions (Admin SDK).
//  - wallet_transaction documents are read-only for their owner and can only
//    be created by the Cloud Functions / admin panel.
//  - Payment gateway secret keys live in settings/payment_secrets, which only
//    admins can read; the apps read only the sanitized settings/payment doc.
//  - Users/owners/watchmen only see and manage what belongs to them; the
//    admin panel (users present in the `admin` collection) manages everything.

service cloud.firestore {
  match /databases/{database}/documents {

    function isAuthed() {
      return request.auth != null;
    }

    function isSelf(id) {
      return isAuthed() && request.auth.uid == id;
    }

    function isAdmin() {
      return isAuthed() && exists(/databases/$(database)/documents/admin/$(request.auth.uid));
    }

    // The client may not change the wallet balance of an existing document.
    function walletUntouched() {
      return !request.resource.data.diff(resource.data).affectedKeys().hasAny(['walletAmount']);
    }

    // New profile documents must start with an empty wallet.
    function walletStartsEmpty() {
      return !('walletAmount' in request.resource.data)
        || request.resource.data.walletAmount in ['0', '0.0', 0, 0.0];
    }

    function isWatchmanFor(parkingId) {
      return isAuthed()
        && exists(/databases/$(database)/documents/watchman/$(request.auth.uid))
        && get(/databases/$(database)/documents/watchman/$(request.auth.uid)).data.assignedParkingId == parkingId;
    }

    // ── Admin panel users ────────────────────────────────────────────────
    match /admin/{adminId} {
      allow read, write: if isAdmin();
    }

    // ── Profiles (wallet balance locked for clients) ─────────────────────
    match /customers/{userId} {
      allow read: if isAuthed();
      allow create: if isAdmin() || (isSelf(userId) && walletStartsEmpty());
      allow update: if isAdmin() || (isSelf(userId) && walletUntouched());
      allow delete: if isAdmin() || isSelf(userId);

      match /{subCollection}/{docId} {
        allow read: if isAuthed();
        allow write: if isAdmin() || isSelf(userId);
      }
    }

    match /owners/{ownerId} {
      allow read: if isAuthed();
      allow create: if isAdmin() || (isSelf(ownerId) && walletStartsEmpty());
      allow update: if isAdmin() || (isSelf(ownerId) && walletUntouched());
      allow delete: if isAdmin() || isSelf(ownerId);

      match /{subCollection}/{docId} {
        allow read: if isAuthed();
        allow write: if isAdmin() || isSelf(ownerId);
      }
    }

    match /watchman/{watchmanId} {
      allow read: if isAuthed();
      // A watchman edits their own profile; the owner who employs them (and
      // admins) manage the account.
      allow create: if isAdmin() || (isAuthed() && request.resource.data.ownerId == request.auth.uid);
      allow update: if isAdmin() || isSelf(watchmanId)
        || (isAuthed() && resource.data.ownerId == request.auth.uid);
      allow delete: if isAdmin() || (isAuthed() && resource.data.ownerId == request.auth.uid);
    }

    // ── Parking & slots ──────────────────────────────────────────────────
    match /parking/{parkingId} {
      allow read: if true; // public listings (browse before login)
      allow create: if isAdmin() || (isAuthed() && request.resource.data.ownerId == request.auth.uid);
      allow update: if isAdmin()
        || (isAuthed() && resource.data.ownerId == request.auth.uid)
        || isWatchmanFor(parkingId)
        // customers may only bump the review counters after rating
        || (isAuthed() && request.resource.data.diff(resource.data).affectedKeys().hasOnly(['reviewSum', 'reviewCount']));
      allow delete: if isAdmin() || (isAuthed() && resource.data.ownerId == request.auth.uid);

      match /{subCollection}/{docId} {
        allow read: if true;
        // slot status changes during booking / check-in / check-out
        allow write: if isAuthed();
      }
    }

    // ── Bookings (participants only) ─────────────────────────────────────
    match /bookings/{bookingId} {
      allow read: if isAdmin()
        || (isAuthed() && (resource.data.userId == request.auth.uid || resource.data.ownerId == request.auth.uid))
        || isWatchmanFor(resource.data.parkingId);
      allow create: if isAdmin() || (isAuthed() && request.resource.data.userId == request.auth.uid);
      allow update: if isAdmin()
        || (isAuthed() && (resource.data.userId == request.auth.uid || resource.data.ownerId == request.auth.uid))
        || isWatchmanFor(resource.data.parkingId);
      allow delete: if isAdmin();
    }

    // ── Money (Cloud Functions / Admin SDK only) ─────────────────────────
    match /wallet_transaction/{txnId} {
      allow read: if isAdmin() || (isAuthed() && resource.data.userId == request.auth.uid);
      allow write: if isAdmin(); // apps never write these; Cloud Functions bypass rules
    }

    match /transaction_log/{logId} {
      allow read: if isAdmin() || (isAuthed() && resource.data.userId == request.auth.uid);
      allow create: if isAdmin() || (isAuthed() && request.resource.data.userId == request.auth.uid);
      allow update, delete: if isAdmin();
    }

    // ── Settings ─────────────────────────────────────────────────────────
    // Gateway secret keys: admins only. The apps and Cloud Functions never
    // need to read this document from the client side.
    match /settings/payment_secrets {
      allow read, write: if isAdmin();
    }

    match /settings/{settingId} {
      // Everything except the secrets document is public app config
      // (branding, landing page content, sanitized payment config, …).
      allow read: if settingId != 'payment_secrets';
      allow write: if isAdmin();
    }

    // ── Admin-managed content (public read) ──────────────────────────────
    match /currencies/{docId} { allow read: if true; allow write: if isAdmin(); }
    match /languages/{docId} { allow read: if true; allow write: if isAdmin(); }
    match /country_tax/{docId} { allow read: if true; allow write: if isAdmin(); }
    match /onboarding_screen/{docId} { allow read: if true; allow write: if isAdmin(); }
    match /parking_facilities/{docId} { allow read: if true; allow write: if isAdmin(); }
    match /coupons/{docId} { allow read: if isAuthed(); allow write: if isAdmin(); }
    match /email_template/{docId} { allow read: if isAuthed(); allow write: if isAdmin(); }
    match /documents/{docId} { allow read: if isAuthed(); allow write: if isAdmin(); }
    match /role_permissions/{docId} { allow read: if isAdmin(); allow write: if isAdmin(); }
    match /broadcast_notifications/{docId} { allow read: if isAuthed(); allow write: if isAdmin(); }

    // ── Reviews ──────────────────────────────────────────────────────────
    match /review_customer/{reviewId} {
      allow read: if true;
      allow create: if isAuthed();
      allow update, delete: if isAdmin() || (isAuthed() && resource.data.customerId == request.auth.uid);
    }

    // ── Notifications & chat ─────────────────────────────────────────────
    // A notification's recipient is identified by the role-specific id field
    // (customerId / ownerId / watchmanId). Only the recipient — and admins —
    // can read, update (e.g. mark as read), or delete it. Any signed-in user
    // may create one (apps notify counterparties about booking events).
    match /notification/{notificationId} {
      function isRecipient() {
        return isAuthed()
          && (resource.data.get('customerId', '') == request.auth.uid
            || resource.data.get('ownerId', '') == request.auth.uid
            || resource.data.get('watchmanId', '') == request.auth.uid);
      }
      allow read: if isAdmin() || isRecipient();
      allow create: if isAuthed();
      allow update, delete: if isAdmin() || isRecipient();
    }

    // Chat rooms are private to their participants: every room document must
    // store a `participants` array of user ids. Only those users — and
    // admins — can read or write the room and its messages, and a message
    // can only be created or edited by its own author (senderId).
    match /chat_rooms/{roomId} {
      function isRoomParticipant() {
        return isAuthed() && request.auth.uid in resource.data.get('participants', []);
      }
      allow read: if isAdmin() || isRoomParticipant();
      allow create: if isAdmin()
        || (isAuthed() && request.auth.uid in request.resource.data.get('participants', []));
      allow update: if isAdmin()
        || (isRoomParticipant()
          && request.resource.data.get('participants', []) == resource.data.get('participants', []));
      allow delete: if isAdmin();

      match /messages/{messageId} {
        function isParticipant() {
          return isAuthed()
            && request.auth.uid in get(/databases/$(database)/documents/chat_rooms/$(roomId)).data.get('participants', []);
        }
        allow read: if isAdmin() || isParticipant();
        allow create: if isAdmin()
          || (isParticipant() && request.resource.data.get('senderId', '') == request.auth.uid);
        allow update, delete: if isAdmin()
          || (isParticipant() && resource.data.get('senderId', '') == request.auth.uid);
      }
    }

    // ── Everything else: admins only ─────────────────────────────────────
    match /{document=**} {
      allow read, write: if isAdmin();
    }
  }
}

3. Install Node.js and npm

• Visit the official Node.js website: https://nodejs.org
• Download and install the LTS version.
• Verify the installation:

node -v
npm -v

4. Extract Database Files

• Locate database.zip from your ParkEZ project package.
• Extract its contents into a folder on your computer.

5. Open Terminal

• Navigate into the extracted folder:

cd path/to/extracted/folder

6. Generate Firebase Service Account Key

• Go to the Firebase Console.
• Select your ParkEZ project. Click the gear icon (⚙) next to "Project Overview".
• Select "Project settings".
• Click the "Service accounts" tab.
• Ensure "Node.js" is selected as the platform.
• Click Generate new private key.
• Click "Generate key" in the confirmation dialog.
• A JSON key file will be downloaded.
• Replace the existing config.json in your project folder with this file (rename to config.json).

7. Run Import Command

• Inside the extracted database folder, run:

npm install firestore-export-import

node import

1. Navigate to firestore_index Folder

cd path/to/firestore_index

Step A: Run firebase init

firebase init

You're about to initialize a Firebase project in this directory:
  C:\path\to\your\firestore_index

? Are you ready to proceed? (Y/n)

• Type y and press Enter.

Step B: Select Firebase Features

(*) Firestore: Configure security rules and indexes files for Firestore

Step C: Choose Firebase Project

• Select Use an existing project.
• Pick your ParkEZ project from the list and press Enter.

Step D: Set Up Firestore Rules and Indexes

• Accept the default firestore.rules. Type y to overwrite if asked.
• Accept the default firestore.indexes.json. Overwrite if asked.
• You will see: Firebase initialization complete!

Step E: Deploy Firestore Indexes

firebase deploy --only firestore:indexes

Deployment Complete

=== Deploying to 'parkez-xxxxx'...

i  firestore: reading indexes from firestore.indexes.json...
i  cloud.firestore: checking firestore.rules for compilation errors...
+  cloud.firestore: rules file firestore.rules compiled successfully
i  firestore: deploying indexes...
+  firestore: deployed indexes in firestore.indexes.json successfully

+  Deploy complete!

Project Console: https://console.firebase.google.com/project/parkez-xxxxx/overview

ParkEZ uses Firebase Storage to host parking photos, profile pictures, owner KYC documents, and watchman ID proofs.

1. Enable Storage

• Open the Firebase Console and select your ParkEZ project.
• From the left sidebar, click "Storage".
• Click Get started → choose Start in production mode → pick the closest Cloud Storage location → click Done.

2. Apply Storage Rules

• Open the "Rules" tab inside Storage.
• Replace the contents with the rules below (allowing authenticated users to read public parking media and only the resource owner to write):

rules_version = '2';
service firebase.storage {
  match /b/{bucket}/o {
    match /parkings/{parkingId}/{allFiles=**} {
      allow read: if true;
      allow write: if request.auth != null;
    }
    match /users/{userId}/{allFiles=**} {
      allow read: if request.auth != null;
      allow write: if request.auth != null && request.auth.uid == userId;
    }
  }
}

• Click Publish.

3. Configure CORS on the Storage Bucket (required for web)

Browsers block the Admin Panel and Landing Page from loading Storage images unless the bucket sends CORS headers — without this step, images upload fine from mobile but appear broken/blank on the web.

1. Open Google Cloud Console → select your Firebase project → click the Cloud Shell icon (top right).
2. Create the CORS config file:

echo '[{ "origin": ["*"], "method": ["GET"], "maxAgeSeconds": 3600, "responseHeader": ["Content-Type"] }]' > cors-config.json

3. Apply it to your bucket (find the bucket name on the Storage page, e.g. your-project.firebasestorage.app):

gsutil cors set cors-config.json gs://YOUR_BUCKET_NAME

CORS (Cross-Origin Resource Sharing) must be configured on your Firebase Storage bucket so the Admin Panel can load parking images and uploaded documents.

1. Open the Google Cloud Console

• Go to Google Cloud Console.

2. Select Your Project

• At the top-left, click your project name to ensure you are in the correct ParkEZ project.

3. Activate Google Cloud Shell

• In the top-right corner, click the Activate Cloud Shell icon (□>_).
• A Cloud Shell terminal window will open. Wait for it to initialize.

Welcome to Cloud Shell! Type "help" to get started.
Your Cloud Platform project in this session is set to parkez-xxxxx.

4. Create a CORS Configuration File

echo '[{ "origin": ["*"], "method": ["GET"], "maxAgeSeconds": 3600, "responseHeader": ["Content-Type"] }]' > cors-config.json

5. Get Your Storage Bucket Name

• Go to Firebase Console → Storage.
• At the top of the page, you will see your bucket URL (e.g., gs://parkez-xxxxx.appspot.com). Copy the bucket name.

6. Apply the CORS Configuration

gsutil cors set cors-config.json gs://YOUR_BUCKET_NAME

• Replace YOUR_BUCKET_NAME with your actual bucket name (e.g., parkez-xxxxx.appspot.com).
• Press Enter to apply.

All secret-key payment operations — Stripe, PayPal, Flutterwave, Paystack, Xendit, Midtrans, Mercado Pago, and PayFast — are processed server-side by Firebase Cloud Functions included in the cloud_functions/ folder of the package. The mobile apps call these functions instead of contacting the gateways directly, so the gateway secret keys never leave your server and are never shipped inside the APK / IPA. Deploying them is a one-time step — these gateways will not work until you do. (Razorpay needs no function: its checkout uses only the public key id.)

The functions deployed are: stripeCreatePaymentIntent, paypalCreateOrder, paypalAuthorizeOrder, flutterwaveInitiatePayment, flutterwaveVerifyTransaction, paystackInitializeTransaction, paystackVerifyTransaction, xenditCreateInvoice, xenditCheckInvoice, midtransCreatePaymentLink, mercadopagoCreatePreference, and payfastGetPaymentHtml. They read the gateway keys from the settings/payment Firestore document — the same one managed from Admin Panel → Settings → Payment Settings — so after deployment there is no extra configuration: whatever keys you save in the Admin Panel are used automatically.

Prerequisites

• Node.js 20 or newer installed on your machine (nodejs.org).
• Your Firebase project upgraded to the Blaze (pay-as-you-go) plan — Cloud Functions are not available on the free Spark plan. The Blaze free allowance is generous; typical usage of these payment functions costs nothing or close to nothing.

Deploy Steps

1. Install the Firebase CLI (skip if already installed):

   npm install -g firebase-tools

2. Sign in with the Google account that owns your Firebase project:

   firebase login

3. Open a terminal in the cloud_functions/ folder of the package and link it to your Firebase project (pick your project when prompted and give it any alias, e.g. default):

   cd cloud_functions
   firebase use --add

4. Install the function dependencies:

   cd functions
   npm install
   cd ..

5. Deploy the functions and the Firestore security rules & indexes together:

   firebase deploy --only functions,firestore

6. Open Admin Panel → Settings → Payment Settings and press Save once. This migrates your gateway secret keys into the admin-only settings/payment_secrets document — the apps can only read the sanitized settings/payment document, which contains no secrets.

When the command finishes with Deploy complete!, all functions are live. You can verify them under Firebase Console → Build → Functions. The mobile apps discover them automatically through their Firebase configuration (google-services.json / GoogleService-Info.plist) — nothing to change in the app code.

Security model

• Firestore security rules (cloud_functions/firestore.rules, also included in firestore_index.zip) scope every collection: customers only manage their own profile, wallet history, and bookings; owners only their own parkings and staff; watchmen only their assigned parking; admins (users in the admin collection) manage everything from the Admin Panel.
• Wallet balances can never be changed from a device. The walletAmount field and the wallet_transaction collection are locked by the rules; all credits, debits, and refunds go through the walletTopUp, walletPayOwner, creditOwnerPayment, and refundBookingToWallet Cloud Functions, which re-verify the payment with the gateway and mutate balances with the Admin SDK.
• Gateway secret keys are never client-readable. They are stored in settings/payment_secrets, which only admins and the Cloud Functions (Admin SDK) can access.

The ParkEZ Admin Panel is a Flutter Web application located in /admin_panel. The sections below walk through configuring and deploying it.

Update HTML Title

• Open: admin_panel/web/index.html
• Inside the <head> section, update the content of the <title> tag:

<head>
  ...
  <title>ParkEZ Admin</title>
  ...
</head>

Update Manifest

• Open: admin_panel/web/manifest.json
• Update name and short_name:

{
  "name": "ParkEZ Admin",
  "short_name": "ParkEZ Admin",
  ...
}

1. Install Firebase CLI Tools

npm install -g firebase-tools

2. Authenticate Firebase CLI

firebase login

• A browser window will open to complete authentication with your Google account.

3. Create a Firebase Project

firebase projects:create

OR

• Create one via the Firebase Console.
• Enter a name (e.g., ParkEZ) and press Continue.

$ dart pub global activate flutterfire_cli

$ flutterfire configure --project=YOUR_PROJECT_ID

4. Initialize Firebase in the Admin Panel

• Open Android Studio (or VS Code) and switch to the admin_panel/ directory.
• Run:

dart pub global activate flutterfire_cli

flutterfire configure --project=YOUR_PROJECT_ID

? Which platforms should your configuration support?
  ( ) android
  ( ) ios
  ( ) macos
  (*) web        <-- Select ONLY this
  ( ) windows

• When asked "firebase_options.dart already exists. Do you want to override it?", type yes.
• Setup is complete when you see: Firebase configuration file lib/firebase_options.dart generated successfully.

Update the Web Config Files (index.html & Service Worker)

flutterfire configure only generates lib/firebase_options.dart. Two web files also contain a firebaseConfig object that must point to your Firebase project (used for web push notifications):

1. Open Firebase Console → ⚙ Project settings → General → Your apps → Web app and copy the firebaseConfig object.
2. Open admin_panel/web/index.html, find window.firebaseConfig = { ... }, and replace the placeholder values (YOUR_FIREBASE_API_KEY, YOUR_PROJECT_ID, …) with your own.
3. Do the same in admin_panel/web/firebase-messaging-sw.js (the push-notification service worker).
4. Rebuild the panel: flutter build web.

1. Generate a Google Maps API Key

• Go to the Google Cloud Console.
• Create a new project or select an existing one (same project as Firebase is fine).
• Enable these APIs:
• Maps JavaScript API
• Places API
• Geocoding API
• Go to APIs & Services > Credentials.
• Click "Create Credentials" > "API key".
• Copy the newly generated API key.

2. Add API Key to Flutter Web

• Open: admin_panel/web/index.html
• Inside the <head> section, add:

<script src="https://maps.googleapis.com/maps/api/js?key=YOUR_API_KEY&libraries=places"></script>

Admin Panel (Flutter Web)

The favicon represents the Admin Panel in the browser tab.

Replace Favicon:

• Design your favicon (typically favicon.png, 32x32 or 16x16 pixels).
• Go to admin_panel/web/.
• Replace the existing favicon.png with your own file using the same filename.
• Also replace icons in admin_panel/web/icons/ (Icon-192.png, Icon-512.png).

ParkEZ is designed so you can rebrand the entire platform without touching any code. Log in to the Admin Panel and open Settings → App Settings — the name, colors, and every logo/icon for all four apps are managed from this one screen. Click Save at the bottom to apply. (See the annotated App Settings screenshot.)

1. Brand Name

• App Name — the name shown throughout the apps.
• Browser Tab Title — the title shown on the Admin Panel browser tab.
• Country Code and Default Currency are set here too.

2. Color Scheme (per app)

App Settings has a dedicated primary color field for each app — enter a HEX code (e.g. #5D54F2) or use the color swatch, then press Change:

• Admin Panel Color
• Customer App Color
• Owner App Color
• Watchman App Color

The new color is stored in Firebase and each app applies it on next launch — no rebuild required. Light and dark mode are handled automatically from your chosen color.

3. Logos & Icons

Every image is uploaded from the same screen using its Change / Upload button (PNG or JPG, square recommended):

4. Other App Settings

• Customer / Owner / Watchman App Min Version — force-update users below this version.
• Owner Document Verification — toggle the owner KYC / document requirement on or off.

1. Create the Build for Server Upload

flutter clean

flutter pub get

flutter build web --release

Compiling lib/main.dart for the Web...
✓ Built build\web                                          24.7s

• The optimized build is generated in:

admin_panel/build/web/

• Upload the contents of build/web/ to your server (via FTP, cPanel, or SSH).
• Point your domain (e.g., admin.parkez.com) to that directory.

1. Build and Deploy Using Firebase Hosting

npm install -g firebase-tools

firebase login

firebase init

? Are you ready to proceed? (Y/n) y

? Which Firebase features do you want to set up?
  (*) Hosting: Configure files for Firebase Hosting

=== Project Setup
? Please select an option: Use an existing project
i  Using project parkez-xxxxx

=== Hosting Setup
? What do you want to use as your public directory? build/web
? Configure as a single-page app (rewrite all urls to /index.html)? Yes
? Set up automatic builds and deploys with GitHub? No

• You should see: + Firebase initialization complete!

• Now build the release version:

flutter build web --release

• Then deploy:

firebase deploy --only hosting

=== Deploying to 'parkez-xxxxx'...

i  deploying hosting
i  hosting[parkez-xxxxx]: beginning deploy...
i  hosting[parkez-xxxxx]: found 489 files in build/web
+  hosting[parkez-xxxxx]: file upload complete
+  hosting[parkez-xxxxx]: version finalized
+  hosting[parkez-xxxxx]: release complete

+  Deploy complete!

Project Console: https://console.firebase.google.com/project/parkez-xxxxx/overview
Hosting URL: https://parkez-xxxxx.web.app

After the Admin Panel build is uploaded (see Deploy on Server or Deploy on Firebase), map your domain to it and secure it with HTTPS. Follow the path that matches your hosting.

1. Domain Mapping

A. Firebase Hosting — custom domain

1. Open Firebase Console → Hosting → Add custom domain.
2. Enter your domain (e.g. admin.yourdomain.com) and continue.
3. Add the TXT record Firebase shows to your DNS to verify ownership.
4. Then add the provided A records at your DNS provider.
5. Wait for DNS propagation — Firebase provisions the SSL certificate automatically.

B. VPS / dedicated server — DNS

• At your DNS provider, create an A record pointing the domain to your server's public IP:

Type: A     Host: admin (or @)     Value: 203.0.113.10     TTL: 3600

• Point the site's document root at the uploaded build/web/ folder.

C. cPanel / shared hosting

1. Domains → Create A New Domain (or Subdomain), e.g. admin.yourdomain.com.
2. Set its Document Root to the folder where you uploaded build/web/.
3. Upload the contents of build/web/ into that document root via File Manager or FTP.

2. SSL / HTTPS Configuration

cPanel — AutoSSL (free)

1. Go to Security → SSL/TLS Status.
2. Select your domain and click Run AutoSSL — a free Let's Encrypt certificate is issued and auto-renews.

Nginx + Certbot (Let's Encrypt)

sudo apt install certbot python3-certbot-nginx
sudo certbot --nginx -d admin.yourdomain.com

server {
    listen 80;
    server_name admin.yourdomain.com;
    return 301 https://$host$request_uri;   # force HTTPS
}

server {
    listen 443 ssl;
    server_name admin.yourdomain.com;

    ssl_certificate     /etc/letsencrypt/live/admin.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/admin.yourdomain.com/privkey.pem;

    root /var/www/parkez-admin;   # your build/web folder
    index index.html;

    location / {
        try_files $uri $uri/ /index.html;   # SPA fallback
    }
}

Apache + Certbot

sudo apt install certbot python3-certbot-apache
sudo certbot --apache -d admin.yourdomain.com

RewriteEngine On

# Force HTTPS
RewriteCond %{HTTPS} off
RewriteRule ^(.*)$ https://%{HTTP_HOST}%{REQUEST_URI} [L,R=301]

# SPA fallback (all routes -> index.html)
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^ index.html [L]

3. Landing Page — Custom Domain

The landing page is a lightweight static site (plain HTML/JS in landing_page/) — it can be hosted anywhere. Typical setup with the Admin Panel on a subdomain:

1. At your DNS provider, point the root domain to your host: an A record (@ → your server IP) for a VPS/cPanel, or the records your static host provides (Firebase Hosting, Netlify, etc.).
2. Upload the landing_page/ files (index.html, app.js, legal.js, assets) to that site's document root. No build step is needed.
3. Enable SSL for the root domain the same way as the Admin Panel (AutoSSL / Certbot — see the section above). No SPA rewrite is required for the landing page.
4. Make sure the landing page's firebaseConfig (in app.js / legal.js) points to your Firebase project, and add yourdomain.com to Firebase → Authentication → Authorized domains.
5. Its content (hero text, steps, links, logo) is edited from Admin Panel → Landing Page — changes appear without redeploying.

4. Post-Deployment Checklist

• Open https://admin.yourdomain.com — confirm the padlock (valid SSL) and that the panel loads.
• Confirm plain http:// redirects to https://.
• Re-check CORS configuration on your Firebase Storage bucket so uploads work from the live domain.
• Add the production domain under Firebase Console → Authentication → Settings → Authorized domains so Google / Apple sign-in works.
• Hard-refresh (Ctrl/Cmd + Shift + R) to clear any cached old build.

The steps below apply to all three mobile apps shipped with ParkEZ: customer/, owner/, and watchman/. Repeat each step for each app folder, using a different package name / bundle ID per app.

Run these steps separately for each mobile app folder (customer/, owner/, watchman/).

Android

Update the applicationId in build.gradle:

• Open: android/app/build.gradle
• Inside the defaultConfig block, replace the applicationId:

defaultConfig {
    applicationId "com.parkez.customer"
}

Rename Java Package Directories:

• Go to: android/app/src/main/java/
• Rename the directory folders to match your new package (e.g., com/parkez/customer).

Update AndroidManifest.xml:

• Open: android/app/src/main/AndroidManifest.xml
• Update the package attribute:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.parkez.customer">
</manifest>

Update Other Manifest Files:

• Also update the package attribute in:
• android/app/src/debug/AndroidManifest.xml
• android/app/src/profile/AndroidManifest.xml

iOS

Update PRODUCT_BUNDLE_IDENTIFIER in Xcode:

• Open: ios/Runner.xcworkspace
• Select the Runner target → Build Settings tab.
• Search for PRODUCT_BUNDLE_IDENTIFIER.
• Replace with your new bundle ID (e.g., com.parkez.customer).

Update Bundle Identifier in Info.plist:

• Open: ios/Runner/Info.plist
• Locate the CFBundleIdentifier key and update its value.

Android

Update AndroidManifest.xml:

• Open: android/app/src/main/AndroidManifest.xml
• Modify the android:label attribute on the application tag:

<application
    android:name="${applicationName}"
    android:icon="@mipmap/ic_launcher"
    android:label="ParkEZ"
    ...>
</application>

Update strings.xml:

• Open: android/app/src/main/res/values/strings.xml
• Update the app_name string:

<string name="app_name">ParkEZ</string>

iOS

Update Info.plist:

• Go to: ios/Runner/Info.plist
• Locate CFBundleName / CFBundleDisplayName and update:

<key>CFBundleDisplayName</key>
<string>ParkEZ</string>

Update Display Name in Xcode:

• Open your project in Xcode: ios/Runner.xcworkspace
• Select the Runner target → General tab.
• Update the Display Name field (e.g., ParkEZ, ParkEZ Owner, ParkEZ Watchman).

Android

Replace Default Icons:

• Navigate to: android/app/src/main/res/
• Replace ic_launcher.png in each of these folders with your custom ParkEZ icon:
• mipmap-mdpi (48x48 px)
• mipmap-hdpi (72x72 px)
• mipmap-xhdpi (96x96 px)
• mipmap-xxhdpi (144x144 px)
• mipmap-xxxhdpi (192x192 px)

Update Icon Reference in AndroidManifest.xml:

<application
    android:icon="@mipmap/ic_launcher"
    ...>
</application>

iOS

Replace AppIcon Set:

• Prepare your custom icons in iOS-specific sizes.
• Replace the contents of: ios/Runner/Assets.xcassets/AppIcon.appiconset/

Splash Screen / In-App Logo

• Replace assets/images/logo.png (or the equivalent asset path) inside each app folder.
• Re-run flutter pub get after changing assets.

1. Install Firebase CLI Tools

npm install -g firebase-tools

2. Authenticate Firebase CLI

firebase login

3. Configure FlutterFire

$ dart pub global activate flutterfire_cli
$ flutterfire configure --project=YOUR_PROJECT_ID

4. Initialize Firebase in Each App

cd customer
dart pub global activate flutterfire_cli
flutterfire configure --project=YOUR_PROJECT_ID

? Which platforms should your configuration support?
  (*) android    <-- Select this
  (*) ios        <-- Select this
  ( ) macos
  ( ) web
  ( ) windows

• If prompted "firebase_options.dart already exists. Do you want to override it?", type yes.
• Repeat the same steps inside the owner/ and watchman/ folders.

1. Create a Firebase Project

• Go to the Firebase Console.
• Click "Add project" and follow the guided steps.

2. Add Each App to Firebase

Android Setup (repeat for Customer / Owner / Watchman):

• Click the Android icon to register an Android app.
• Enter the Android package name for the app you're registering (e.g., com.parkez.customer).
• Download the google-services.json file.
• Place it in that app's android/app/ folder.

iOS Setup (repeat for Customer / Owner / Watchman):

• Click the iOS icon to register your iOS app.
• Enter the iOS bundle ID (e.g., com.parkez.customer).
• Download the GoogleService-Info.plist file.
• In Xcode, open ios/Runner.xcworkspace and drag the GoogleService-Info.plist into the Runner project (check "Copy items if needed").

3. Add Firebase Packages

• The required packages are already included in each pubspec.yaml. Just run:

flutter pub get

4. Configure DefaultFirebaseOptions

flutterfire configure

5. Initialize Firebase in main.dart

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

1. Generate a Google Maps API Key

• Go to the Google Cloud Console.
• Create a new project or select an existing one (same as Firebase).
• Enable these APIs:
• Maps SDK for Android
• Maps SDK for iOS
• Maps JavaScript API
• Places API
• Geocoding API
• Directions API
• Go to APIs & Services > Credentials.
• Click "Create Credentials" > "API key".
• Copy the generated API key.

2. Add API Key - Android (each app)

• Open: android/app/src/main/AndroidManifest.xml
• Inside the <application> tag, add:

<meta-data
    android:name="com.google.android.geo.API_KEY"
    android:value="YOUR_API_KEY"/>

3. Add API Key - iOS (each app)

• Open: ios/Runner/AppDelegate.swift
• In the application(_:didFinishLaunchingWithOptions:) method, add:

import GoogleMaps
GMSServices.provideAPIKey("YOUR_API_KEY")

SHA keys are required for Firebase services like Google Sign-In and Phone Authentication on Android. Generate and register keys for each of the three mobile apps (customer, owner, watchman).

1. Generate SHA Keys

For Windows (Debug Keystore):

keytool -list -v -keystore "%USERPROFILE%\.android\debug.keystore" -alias androiddebugkey -storepass android -keypass android

For macOS/Linux (Debug Keystore):

keytool -list -v -keystore ~/.android/debug.keystore -alias androiddebugkey -storepass android -keypass android

• Look for the SHA1 and SHA256 values in the output and copy them.

2. Add SHA Keys to Firebase Console

• Open the Firebase Console → select your ParkEZ project.
• Click the gear icon (⚙) → Project settings.
• Under "Your apps", find each Android app (Customer / Owner / Watchman).
• Click "Add Fingerprint".
• Paste the SHA-1 key → select SHA1 → click Save.
• Repeat for the SHA-256 key.
• Repeat the full process for each of the three Android apps.

A JKS (Java KeyStore) holds the private key that signs Android release builds. Google Play requires every APK/AAB to be signed with the same key for every update — create it once for each ParkEZ app and keep it safe.

1. Generate the Keystore with keytool

Run this in the terminal to create the JKS for Android signing only. Replace (Project_name) with the app name (e.g. parkez-customer) — the file lands in the current folder.

keytool -genkey -v -keystore (Project_name).jks -keyalg RSA -keysize 2048 -validity 10000 -alias (Project_name)

• -keystore (Project_name).jks — output filename.
• -alias (Project_name) — key alias inside the keystore (remember it).
• -validity 10000 — validity in days (~27 years; Play wants a long validity).

2. Answer the Prompts

• Set and confirm a keystore password.
• Fill in name/org/city/state/country (or leave blank with Enter).
• At "Is CN=... correct?", type yes.
• Press Enter to reuse the same password for the key.

Enter keystore password:  ********
Re-enter new password:    ********
What is your first and last name?
  [Unknown]:  Your Name
What is the name of your organizational unit?
  [Unknown]:  ParkEZ
...
Is CN=Your Name, OU=ParkEZ, ... correct?
  [no]:  yes

Enter key password for <(Project_name)>
        (RETURN if same as keystore password):

• Done — the keystore (e.g. (Project_name).jks) lands in the current folder.

3. Move the Keystore into Your Project

• Copy the .jks into android/app/(Project_name).jks of the corresponding ParkEZ app (e.g. customer/android/app/).

4. Create a key.properties File

• Create android/key.properties in the same app folder:

# android/key.properties
storePassword=YOUR_KEYSTORE_PASSWORD
keyPassword=YOUR_KEY_PASSWORD
keyAlias=(Project_name)
storeFile=(Project_name).jks

• storeFile is relative to android/app/.
• Add key.properties to .gitignore too.

5. Reference the Keystore in build.gradle

• Open android/app/build.gradle.
• Above android { }, load the properties:

def keystoreProperties = new Properties()
def keystorePropertiesFile = rootProject.file('key.properties')
if (keystorePropertiesFile.exists()) {
    keystoreProperties.load(new FileInputStream(keystorePropertiesFile))
}

• Inside android { }, add a signingConfigs block and wire it into release:

android {
    signingConfigs {
        release {
            keyAlias keystoreProperties['keyAlias']
            keyPassword keystoreProperties['keyPassword']
            storeFile keystoreProperties['storeFile'] ? file(keystoreProperties['storeFile']) : null
            storePassword keystoreProperties['storePassword']
        }
    }
    buildTypes {
        release {
            signingConfig signingConfigs.release
        }
    }
}

6. Build the Signed Release

• Build — it's auto-signed by your JKS:

flutter build apk --release
# or
flutter build appbundle --release

1. Generate APK (for direct installation)

flutter clean

flutter pub get

flutter build apk --release

• The release APK will be generated at:

build/app/outputs/flutter-apk/app-release.apk

2. Generate AAB (for Google Play Store)

flutter clean

flutter pub get

flutter build appbundle --release

• The release AAB will be generated at:

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

Using Command-Line Interface (CLI)

Open Terminal and navigate to the specific app:

cd path/to/ParkEZ/customer   # or owner, watchman, admin_panel

Run the Flutter App:

flutter run

Using Android Studio

• Launch Android Studio and open the specific app folder (e.g., customer/).
• Click the green Run button in the toolbar.
• Choose your emulator or physical device.

Using Visual Studio Code

• Launch VS Code → File > Open Folder → pick the app folder.
• Press Ctrl + Shift + P (or Cmd + Shift + P on macOS).
• Search for and select Flutter: Run.
• Choose your device.

Everything needed to run and publish the Customer, Owner, and Watchman apps on iOS. Repeat the steps for each app folder. A Mac with Xcode 15+ and an Apple Developer account ($99/year) are required.

1. Prerequisites & CocoaPods

1. Install CocoaPods: sudo gem install cocoapods.
2. The Podfile platform is already set to platform :ios, '15.0' (required by the current Maps and Firebase pods).
3. In each app: cd ios && pod install && cd ... Always open ios/Runner.xcworkspace (not .xcodeproj).

2. Bundle ID & Signing Team

1. Open ios/Runner.xcworkspace in Xcode → select Runner → Signing & Capabilities.
2. Set your own Bundle Identifier per app (e.g. com.yourbrand.customer / .owner / .watchman) and select your Team.
3. Register the same three App IDs in the Apple Developer portal.

3. Capabilities (already wired in code)

Each app ships with ios/Runner/Runner.entitlements pre-configured for Push Notifications (aps-environment) and Sign in with Apple. You only need to enable both capabilities on each App ID in the Apple Developer portal, then refresh provisioning profiles in Xcode.

4. Firebase & Google Sign-In Files

1. Download each app's GoogleService-Info.plist from Firebase and replace the placeholder file in ios/Runner/.
2. In ios/Runner/Info.plist, set the CFBundleURLSchemes entry to your file's REVERSED_CLIENT_ID — Google Sign-In will not return to the app without it.
3. Customer & Owner only: put your Maps key in ios/Runner/AppDelegate.swift → GMSServices.provideAPIKey("…").

5. Info.plist Permissions

Usage descriptions are already included per app — camera & photo library (all apps), location (Customer, Owner, Watchman), plus background remote-notification mode. Edit the strings in Info.plist if you want your own wording; App Review reads them.

6. APNS for Push Notifications

1. Developer portal → Keys → create an APNs Auth Key (.p8) and download it once.
2. Firebase → Project Settings → Cloud Messaging → Apple app configuration → upload the .p8 with its Key ID and Team ID (for each iOS app).
3. Test on a real device — the iOS Simulator cannot receive push notifications.

7. Build & Archive

flutter build ipa --release

Or archive from Xcode: Product → Archive. When distributing, you may see “Upload Symbols Failed — dSYM for RazorpayStandard.framework” — this is a harmless Razorpay limitation; untick “Upload your app's symbols” in the distribute dialog (see Troubleshooting).

8. TestFlight & App Store

1. Create the three apps in App Store Connect with matching bundle ids.
2. Upload the build (Xcode Organizer or flutter build ipa + Transporter), add internal testers in TestFlight.
3. For review: provide demo logins, screenshots, and privacy details (camera, photos, location, notifications usage).

ParkEZ uses Firebase Cloud Messaging (FCM) to deliver booking, check-in, and admin notifications across all four apps.

1. Get Notification Sender ID

• Open the Firebase Console.
• Click the gear icon (⚙) → "Project settings".
• Click the "Cloud Messaging" tab at the top.
• Under "Firebase Cloud Messaging API (V1)" (should be Enabled), copy the Sender ID.

2. Get Web Client ID (for Google Sign-In)

• In the Firebase Console sidebar, go to Authentication.
• Click "Sign-in method".
• Find "Google" → click the edit (pencil) icon.
• Expand "Web SDK configuration".
• Copy the Web client ID.

3. Get Firebase Service Account JSON File

• Go to Project Settings (⚙) → "Service accounts" tab.
• Click Generate new private key.
• A JSON file will download — keep it safe; you will upload it to the Admin Panel.

4. Add All Keys in the ParkEZ Admin Panel

• Open your ParkEZ Admin Panel (deployed web app).
• Sidebar → Settings → "General Settings" or "Notification Settings".

• Fill all fields & upload the JSON file.
• Click Save.

The Landing Page is a standalone marketing site under landing_page/. Edit all copy and images from the admin panel (Settings → Landing Page). Content loads from Firestore at runtime — no redeploy needed.

Folder Structure

landing_page/
  index.html              Main marketing page
  privacy-policy.html     Privacy Policy (reads settings/constant.privacyPolicy)
  terms.html              Terms & Conditions (reads settings/constant.termsAndConditions)
  app.js                  Hydrates index.html from Firestore
  legal.js                Hydrates both legal pages from Firestore
  styles.css              Shared stylesheet (indigo / lavender theme)
  assets/                 Logo, illustrations, step images and feature SVGs
  README.md               Quick start notes

1. Update Firebase Credentials

• Open landing_page/app.js and landing_page/legal.js.
• Near the top of each, find the firebaseConfig object:

const firebaseConfig = {
  apiKey: "YOUR_API_KEY",
  authDomain: "YOUR_AUTH_DOMAIN",
  projectId: "YOUR_PROJECT_ID",
  storageBucket: "YOUR_STORAGE_BUCKET",
  messagingSenderId: "YOUR_MESSAGING_SENDER_ID",
  appId: "YOUR_APP_ID",
  measurementId: "YOUR_MEASUREMENT_ID"
};

• Replace the placeholders with your Web SDK config (same one the admin panel and customer web app use).
• Note: These files use the Firebase compat SDK via plain <script> tags — not modules. This lets the page work when opened from disk (file://) and over HTTP.

2. Get Firebase Credentials

• Open the Firebase Console and select your project.
• Click the gear icon (⚙) → "Project settings" → "General" tab.
• Scroll to "Your apps" → Web apps and copy the firebaseConfig object.
• Paste it into app.js and legal.js, then save.

3. Edit Content from Admin Panel

Open the admin panel → Settings → Landing Page. You can edit:

• Brand: Brand name, tagline, logo (image upload), favicon (image upload).
• Hero: Eyebrow chip, title, subtitle, primary & secondary CTA text / links.
• Hero benefit chips: Repeatable — icon key (pin, clock, qr, wallet, shield, support, nav, car, alert) or an emoji, label.
• Stats Strip: Repeatable cells (value, optional brand-coloured suffix, caption).
• Audience Tiles: Repeatable — theme (customer / owner / watchman), tag, title, description, bullet list, CTA text/link.
• Featured Parking Spots: Repeatable — name, area, price & unit, rating, open-spot count, art theme, badge label, amenity chips.
• About / Why Choose: Title + text + dynamic feature cards (icon key + title + description).
• How it works: Repeatable steps with title, description, optional image.
• Testimonials: Repeatable — name, role, initials, avatar image, star rating, quote.
• FAQ: Repeatable Q/A accordion entries plus section title, subtitle and "talk to us" link.
• App download: Section title / text, Play Store URL, App Store URL.
• Contact & Footer: Email, phone, address, social URLs, footer copyright text.
• Publish toggle: When off, you can use the flag in your hosting layer to redirect visitors to a maintenance page.

Click Save. Changes show on the next page load — no deploy needed.

4. Privacy Policy & Terms & Conditions

privacy-policy.html and terms.html read from settings/constant — the same document the mobile apps use. Edit them in the admin's Settings → Policy Settings screen.

• Privacy Policy text → settings/constant.privacyPolicy
• Terms & Conditions text → settings/constant.termsAndConditions

One source of truth — the apps and website always show the same legal text.

5. Running Locally

Two ways to preview the page:

1. Double-click index.html. The browser opens it via file://. The compat SDK still loads. If your browser blocks network requests from file://, the page falls back to built-in copy.
2. Serve it over HTTP (recommended):

   cd landing_page
   python -m http.server 8000
   # or
   npx serve .

   Then open http://localhost:8000/.

Open DevTools → Console. A [ParkEZ] Loaded document log lists every field that was read — use it to verify your Firestore data loaded.

6. Firestore Read Rules

The landing page only reads from Firestore, so add these rules so visitors can see it without signing in:

match /settings/landing_page { allow read: if true; }
match /settings/constant     { allow read: if true; }

Writes are still gated behind the Admin Panel's auth-required rules — the landing page never writes anything.

7. Deploying to Production

It's a plain static site. Deploy to any static host:

Option A — Firebase Hosting (recommended)

npm install -g firebase-tools
cd landing_page
firebase login
firebase init hosting
# - Use existing project → your Firebase project
# - Public directory: .  (this current folder)
# - Configure as SPA? → No
# - Set up automatic builds? → No
# - Overwrite index.html? → No

firebase deploy --only hosting

You'll get a live URL like https://your-project.web.app.

Option B — Any other static host

Upload the whole landing_page/ folder to Netlify, Vercel, GitHub Pages, AWS S3 + CloudFront, or your own server. No build step needed.

8. Troubleshooting

Footer or contact info shows default values instead of mine

• Open DevTools Console and check the first indigo [ParkEZ] line.
• If you see "settings/landing_page does NOT exist", open the admin's Landing Page screen, fill the form, and save.
• Otherwise it's a browser cache — hard refresh with Ctrl + Shift + R.

Image uploads show "Upload failed"

• The admin's toast shows the Firebase error code (e.g. storage/unauthorized) — use it to find the cause.
• Check you're still logged in — expired sessions also break uploads.

Logo looks too small or duplicated in the header

• Upload a wordmark logo (logo + brand text in one image). The page then hides the brand-name text so it's not duplicated.
• For an icon-plus-text look, upload an icon-only logo.

Multi-language support spans the whole system. The Admin Panel is where you register languages, and the mobile apps (Customer, Owner, Watchman) show their UI in whichever language the user picks. It uses GetX and has three pieces that must stay in sync:

• Admin Panel — under Languages, add / edit / enable each language as metadata (name + code + active + default). Saved to the Firestore languages collection. This makes the language show up as an option in the apps.
  Note: the Admin Panel is itself multi-language — its own translations live in lib/app/lang/.
• App strings files — each app's lib/lang/ holds the actual translated strings (one map per language). This is what makes UI text actually change.
• App locale switch — each app reads the language list from Firestore, lets the user pick one, and applies it at runtime via GetX.

1. Add a Language in the Admin Panel

• Open the Admin Panel → Settings → Languages.
• Click + Add Language. The dialog has these fields:

• Turn on Active and click Save.
• This writes a document to the Firestore languages collection:

// Firestore: languages/{autoId}
{
  "id":              "LzSABjMohyW3MA0CaxVH",
  "name":            "English",
  "code":            "en",
  "active":          true,
  "defaultLanguage": true
}

• Admin Panel fetches all languages (active + inactive).
• User apps fetch only active == true languages.
• Only one language can be default. You can't delete the default without setting another one first.

2. App-Side Files You Need

Every app keeps its translations under a lang/ folder and registers them in LocalizationService. The structure is the same across all apps:

customer/   (also owner/, watchman/)
  lib/
    lang/
      app_en.dart                  English strings     -> const Map enUS
      app_hi.dart                  Hindi strings       -> const Map hiIN
      app_ar.dart                  Arabic strings      -> const Map lnAr
      app_fr.dart                  French strings      -> const Map frFR
      app_pt.dart                  Portuguese strings  -> const Map ptBR
    services/
      localization_service.dart    Registers the maps with GetX

admin_panel/  (note the different path)
  lib/
    app/
      lang/
        app_en.dart, app_ar.dart, app_hi.dart, app_fr.dart, app_pt.dart
      services/
        localization_service.dart

• To add a new language, create one file per app (e.g. app_de.dart for German) and register it — see Step 4.
• admin_panel uses lib/app/lang/ (extra app folder). All other apps use lib/lang/.
• For RTL scripts (Arabic, Hebrew, Urdu) the app's MaterialApp flips its textDirection automatically when the locale code resolves to an RTL language — no extra wiring needed.

3. How Strings Are Stored in Those Files

Each file is a Dart const Map<String, String> of key → translated value. The key is the English text; the value is the translation.

// lib/lang/app_en.dart
const Map<String, String> enUS = {
  "Skip"           : "Skip",
  "Welcome"        : "Welcome",
  "Home"           : "Home",
  "Bookings"       : "Bookings",
  "Wallet"         : "Wallet",
  "Profile"        : "Profile",
  "Search a place or address" : "Search a place or address",
  "Book This Spot" : "Book This Spot",
  "Spot Reserved"  : "Spot Reserved",
  // ... hundreds more key-value pairs
};

// lib/lang/app_ar.dart  -> SAME keys, translated values
const Map<String, String> lnAr = {
  "Skip"           : "تخطي",
  "Welcome"        : "أهلاً",
  "Home"           : "الرئيسية",
  "Bookings"       : "الحجوزات",
  "Wallet"         : "المحفظة",
  "Profile"        : "الملف الشخصي",
  "Book This Spot" : "احجز هذا الموقع",
  // ... same keys, Arabic translations
};

Variable naming convention across all apps:

4. Register the Maps in LocalizationService

lib/services/localization_service.dart extends GetX's Translations class and maps each code to its strings map. The code here must match the Code from the Admin Panel (Step 1).

// lib/services/localization_service.dart
import 'package:get/get.dart';
import 'package:flutter/material.dart';
import '../lang/app_en.dart';
import '../lang/app_hi.dart';
import '../lang/app_ar.dart';
import '../lang/app_fr.dart';
import '../lang/app_pt.dart';

class LocalizationService extends Translations {
  static const locale = Locale('en', 'US');      // default locale
  static final locales = [
    const Locale('en'),
    const Locale('hi'),
    const Locale('ar'),
    const Locale('fr'),
    const Locale('pt'),
  ];

  @override
  Map<String, Map<String, String>> get keys => {
    'en': enUS,   // from app_en.dart
    'hi': hiIN,   // from app_hi.dart
    'ar': lnAr,   // from app_ar.dart
    'fr': frFR,   // from app_fr.dart
    'pt': ptBR,   // from app_pt.dart
  };

  void changeLocale(String lang) {
    Get.updateLocale(Locale(lang));  // switches the active language at runtime
  }
}

This file exists in all four apps:

• admin_panel/lib/app/services/localization_service.dart
• customer/lib/services/localization_service.dart
• owner/lib/services/localization_service.dart
• watchman/lib/services/localization_service.dart

• To add German: create app_de.dart with the same keys, import it, add const Locale('de') to locales, and add 'de': deDE to keys.

5. Wire It Into the App (main.dart)

In each app's main.dart, pass the translations and default/fallback locale to GetMaterialApp:

GetMaterialApp(
  translations: LocalizationService(),         // the maps from Step 4
  locale: LocalizationService.locale,          // Locale('en', 'US')
  fallbackLocale: LocalizationService.locale,  // used if a key/locale is missing
  // ...
);

6. Using a String in the UI

Call .tr on the key anywhere. GetX looks it up in the active language map and returns the translation.

// Simple string
Text("Home".tr)
AppButton(text: "Book This Spot".tr)

// Parameterized string -> .trParams replaces @placeholders
Text("spots_open".trParams({ "count": "12" }))
// active locale = ar  ->  resolves against lnAr map

• The string you pass to .tr is the key — it must exist in the maps. This project uses the English text as the key (e.g. "Book This Spot".tr).
• .trParams({...}) replaces each @name placeholder in the translated value.

7. How the User Selects a Language

• The Language screen calls FireStoreUtils.getLanguage(), which reads active == true languages from Firestore — the same list you manage in the Admin Panel.
• The default language appears first.
• First-time users get the Firestore default pre-selected.
• The user picks a language and taps Continue. The app then:

// 1) switch the active language immediately
LocalizationService().changeLocale(selectedLanguage.code);   // Get.updateLocale(...)

// 2) remember the choice for next launch (SharedPreferences)
Preferences.setString(
  Preferences.languageCodeKey,        // key: "languageCodeKey"
  jsonEncode(selectedLanguage.toJson()),  // value: full LanguageModel as JSON
);

• On the next launch, the Splash Screen reads languageCodeKey and re-applies that locale automatically:

// SplashScreenController
Future<void> redirectScreen() async {
  final savedLang = Preferences.getString(Preferences.languageCodeKey);
  if (savedLang == "null" || savedLang.isEmpty) {
    Get.offAll(() => const LanguageScreenView(isFirstTime: true));
    return;
  } else {
    final lang = LanguageModel.fromJson(jsonDecode(savedLang));
    LocalizationService().changeLocale(lang.code ?? "en");
  }
  // ... continue to main screen
}

Controller & preference file locations:

The Complete Flow (Admin → App UI)

This chapter collects everything you can customize in ParkEZ in one place — what can be changed from the Admin Panel with no code at all, and what is changed in the source with a simple find-and-edit. Each topic links to its detailed step-by-step section.

1. App Name, Package ID, Logo & Icons

2. Color Schemes

• No-code (per app, from the Admin Panel): Settings → App Settings → Color Scheme sets the brand color of each app (Customer, Owner, Watchman, Admin) at runtime — see Admin Panel Customization — Branding, Colors & Logo.
• Code-level (full theme): every color used by an app is defined in one file — lib/app/utils/app_colors.dart (same path in all four apps). It contains the complete palette (primary300 is the main brand color, primary4 the accent, plus grey scales and success / warning / danger colors). Change the hex values and rebuild — no other file needs editing.
• Dark mode: the apps ship with light & dark themes; both derive from the same app_colors.dart palette.

3. Fonts

All apps use the bundled Figtree font family. To swap in your own font:

1. Copy your .ttf files into assets/fonts/ in each app (keep one file per weight: Regular, Medium, SemiBold, Bold…).
2. In pubspec.yaml, update the fonts: block — each family: entry points to one asset file. Keep the family names or rename them consistently.
3. If you renamed the families, update the constants in lib/app/utils/font_family.dart (the single place the font names are referenced).
4. Run flutter pub get and rebuild.

4. Core Configuration Settings

• Runtime settings (no rebuild): currency (symbol, position, decimals), taxes, payment gateways (enable/disable, sandbox/live, keys), Google Maps key, notification credentials, SMTP email + templates, onboarding slides, policies — all managed from the Admin Panel. The Configuration Guide table maps every setting to its exact screen.
• Build-time values: Firebase config files, Maps API keys in the manifests, release signing — the same Configuration Guide lists each file and what goes in it.
• Languages: 14 languages included; enable/disable or add your own — Localization (Multi-Language).
• Extending features: for new fields, collections, or modules see the Developer Guide ("Adding a New Field or Collection").

A visual reference for every screen across the ParkEZ apps — these are actual, high-quality screenshots captured from the running Customer, Owner, Watchman, and Admin applications. Click any image to view it full-screen.

Customer App

Onboarding & Sign In

Find & Book

Bookings & Tickets

Penalties

Wallet & Account

Owner App

Onboarding & Sign In

Parking Management

Team & Documents

Bookings & Verification

Wallet & Account

Watchman App

Onboarding & Sign In

Operations

Parking Details

Account

Admin Panel

Overview

Management

Content

Admin Panel Settings — Annotated Screenshots

Every configuration screen in the Admin Panel, with a numbered legend explaining each control. The numbers read top-to-bottom against the screenshot.

App Settings

1. Country Code — default phone country code applied to new users.
2. Default Currency — currency used across bookings, wallet and payouts.
3. App Name — the name displayed throughout all apps.
4. Browser Tab Title — title shown on the admin browser tab.
5. Favicon & App Icons (Light / Dark) — upload branding images, then Save.

Map Settings

1. Google Map Key — API key that powers maps in the Customer & Owner apps.
2. Map Type — choose the map provider / style (e.g. Google Map).
3. Save — pushes the map config to all apps.

Payment Settings

1. Cash On Delivery — enable/disable and set its display name.
2. Wallet — enable in-app wallet payments.
3. Stripe / Razorpay / PayPal — toggle each gateway, switch Sandbox vs Live, and enter API keys.
4. Save — publishes the enabled payment options to the apps.

Notification Settings

1. Notification Sender Key — FCM server/sender key used for push delivery.
2. Client Id For Google Login — OAuth client id used for Google Sign-In.
3. Upload JSON File — Firebase service-account JSON for server-side notifications.

SMTP / Email Settings

1. SMTP Host & Port — your mail server address and port.
2. User Name & Password — SMTP credentials (app password recommended).
3. Encryption Type — SSL / TLS.
4. Save — enables transactional email sending.

Email Templates

1. Template list — Booking Cancelled, Completed, Confirmation, and more (cannot be deleted).
2. Subject & body — edit the content sent to users per template.
3. Merge variables — {{name}}, {{booking_id}}, {{amount}}… injected into the message.
4. Toggle / preview / edit — enable a template or open the editor.

Currency

1. Currency rows — Name, Symbol, Code and Decimals.
2. Symbol At Right — place the symbol before or after the amount.
3. Status — enable/disable a currency.
4. + Add Currency / edit / delete.

Tax

1. Tax rows — Name and Amount (percentage).
2. Status — enable/disable each tax.
3. + Add Tax / edit / delete — applied at checkout.

Policy Settings

1. Tabs — About App, Privacy Policy, Terms & Conditions.
2. Rich-text editor — format the content shown inside the apps.
3. Save — publishes the policy content to all apps.

Broadcast Notifications

1. Filter / search — by type or by title / message.
2. History table — Type, target Users, Title, Message, Sent By / At.
3. Resend — re-push a previous notification.
4. + Send Notification — compose and push to an audience (Customers / Owners / Watchmen).

ParkEZ is serverless: there is no custom REST API to host. All four apps talk directly to Firebase — Firestore for data, Firebase Auth for identity, Storage for images and Cloud Messaging for push. This section explains how the backend is structured and how to extend it.

Architecture Overview

Customer / Owner / Watchman (Flutter)          Admin Panel (Flutter Web)
        |            |            |                       |
        +------------+------------+-----------+-----------+
                                   |
                          Firebase Auth  (identity: email, phone, Google, Apple)
                          Cloud Firestore (all application data)
                          Firebase Storage (profile images, parking photos, documents)
                          Cloud Messaging  (push notifications)

Firestore Collections

Data-Access Layer

• Each app keeps all Firestore reads/writes in one service class: lib/app/utils/fire_store_utils.dart.
• Collection names are centralised in lib/app/constant/collection_name.dart — never hard-code a collection string.
• Every collection has a typed model in lib/app/models/ with fromJson / toJson.

Adding a New Field or Collection

1. Add the field to the model class (lib/app/models/…) in every app that uses it — include it in fromJson/toJson with a safe default.
2. Add read/write methods to fire_store_utils.dart (copy an existing method as a template).
3. If you add a new collection, register its name in collection_name.dart in each app.
4. If admins must manage it, add a module under admin_panel/lib/app/modules/ (view + controller, GetX pattern).
5. If queries filter on multiple fields, add a composite index (Firestore will print a direct index-creation link in the console error).

Push Notification Flow

1. On login/signup each app stores its FCM token on the user document (fcmToken).
2. When an event happens (new booking, wallet credit), the initiating app sends an FCM message to the receiver's token using the server credentials configured in the Admin Panel → Notification Settings.
3. lib/app/utils/notifications/notification_service.dart handles permission, foreground display and tap-routing in each app.

Flutter has no .env file by default — configuration lives in a few well-defined places. This table is the single reference for every value you must supply and exactly where it goes.

Build-Time Configuration (files in the source)

Runtime Configuration (Firestore settings collection, managed in Admin Panel)

See the annotated screenshots of every settings screen for a field-by-field walkthrough.

Cloud Functions (payments, wallets & security)

All secret-key payment operations and every wallet/balance mutation run in Firebase Cloud Functions — the secret keys and wallet writes never happen on a device. The functions read the gateway keys from the admin-only settings/payment_secrets Firestore document, which the Admin Panel maintains automatically: whatever you save in Admin Panel → Settings → Payment Settings is picked up by the functions, while the apps only see the sanitized settings/payment document. See Cloud Functions for the one-time deployment steps — online payments will not work until the functions and security rules are deployed.

Solutions to common issues you might hit while setting up ParkEZ.

Flutter Issues

"flutter" is not recognized as a command

• Ensure Flutter is added to your system PATH. Restart your terminal after changes.
• On Windows, verify via System Properties > Environment Variables.
• On macOS/Linux, check .zshrc or .bashrc.

flutter doctor shows issues

• Run flutter doctor -v for detailed output.
• Install missing components as indicated.
• Accept Android licenses with: flutter doctor --android-licenses

GetX / Routing Issues

"GetX controller not found" exception at runtime

• Ensure the controller is registered through its Binding in lib/app/routes/app_pages.dart for the route you are navigating to.
• If using a non-permanent controller, avoid calling Get.find<X>() outside the page that registers it.

Firebase Issues

Firebase CLI not found

• Install globally: npm install -g firebase-tools
• Verify: firebase --version

Permission denied during firebase deploy

• Ensure you're logged in: firebase login
• Verify Editor / Owner role on the Firebase project.

Firestore "Missing or insufficient permissions" / [cloud_firestore/permission-denied]

• Your Firestore Security Rules are blocking access. Open Firestore Database → Rules, apply the rules from Step 2 of the database setup, and click Publish.
• Common causes: the database was created in production mode (rules default to if false — everything blocked), or test mode rules expired after 30 days.
• Confirm the logged-in user has the correct role document in the customers / owners / watchman collection.

"No matching client found for package name" (Android build fails)

• This means android/app/google-services.json was generated for a different package name than your app's applicationId — it happens after changing the package name.
• Fix: in Firebase Console → Project settings → Your apps, add (or edit) the Android app so its package name matches your new applicationId, then re-download google-services.json and replace the one in android/app/.
• On iOS, do the same for the bundle id and replace GoogleService-Info.plist.

"flutterfire: command not found"

• The Dart global bin folder is not on your PATH. Add it, then re-open the terminal:

export PATH="$PATH":"$HOME/.pub-cache/bin"

• On Windows, add %LOCALAPPDATA%\Pub\Cache\bin to your PATH environment variable.
• Then re-run dart pub global activate flutterfire_cli and flutterfire configure.

Firestore "The query requires an index" / [cloud_firestore/failed-precondition]

• A composite index is missing. Deploy the shipped indexes from the package: firebase deploy --only firestore:indexes (see Firestore Indexes).
• Alternatively, open the link printed inside the error message — the Firebase Console pre-fills the exact index; click Create and wait a few minutes for it to build.

Google Maps Issues

Map shows grey / blank

• Verify the API key is correct and not restricted to the wrong app.
• Ensure the required Maps APIs are enabled in the Google Cloud Console.
• Check that billing is enabled on your Google Cloud project.

Dependency & iOS Issues

Build Issues

Gradle errors on Android

• Run flutter clean then flutter pub get.
• Check that minSdkVersion in android/app/build.gradle is compatible with all dependencies (ParkEZ requires minSdkVersion 21 or higher).

iOS build fails

• Run cd ios && pod install && cd .. in each app folder.
• Open ios/Runner.xcworkspace in Xcode and check signing & provisioning.

Admin Panel images do not load

• Re-check CORS configuration on the Storage bucket (see CORS Configuration).
• Confirm Storage rules allow public read on /parkings/{parkingId}/**.

Authentication Issues

Google Sign-In fails / immediately closes (Android)

• The most common cause is a missing SHA-1 / SHA-256 fingerprint. Generate them (see Generate SHA Keys) and add them to Firebase Console → Project settings → your Android app.
• After adding, re-download google-services.json and replace it in android/app/.
• Make sure Google is enabled under Authentication → Sign-in method.

Google / Apple Sign-In fails on iOS

• Confirm the REVERSED_CLIENT_ID URL scheme is present in ios/Runner/Info.plist (see Configuration Guide).
• For Apple Sign-In, enable the Sign in with Apple capability on the App ID in the Apple Developer portal and in Firebase Authentication.

Phone OTP not received

• Phone authentication requires the Firebase Blaze plan.
• Add your test device / SHA keys and ensure Phone is enabled under Authentication.
• On real devices, SafetyNet/Play Integrity must pass — test with a real SIM, not an emulator.
• Check the Firebase authorized domains include your admin domain for web OTP.

No Data / Empty Screens

Apps open but show no parkings, settings, or content

• Confirm you imported the starter database (see Firestore Import) — empty collections mean empty screens.
• Check your Firestore Security Rules are published (see Step 2 of the database setup); a permission-denied log means the rules are blocking reads.
• Verify firebase_options.dart and google-services.json / GoogleService-Info.plist point to the same Firebase project.

Notification Issues

Push notifications not received

• Add the FCM server / sender credentials in Admin Panel → Settings → Notification Settings.
• iOS: upload an APNs Auth Key (.p8) to Firebase → Cloud Messaging and enable the Push Notifications capability — and test on a real device (the simulator cannot receive push).
• Confirm the app requested notification permission and that a valid fcmToken is saved on the user document.

Payment Gateway Issues

Payment fails or gateway not showing

• Enable the gateway and enter its keys in Admin Panel → Settings → Payment Settings.
• For Stripe, PayPal, and Flutterwave, make sure the Cloud Functions are deployed — these gateways run their secret-key operations server-side and fail without the functions.
• Use test/sandbox keys while developing and switch to live keys before launch — mixing them causes failures.
• Each gateway requires your own approved merchant account; unapproved accounts reject live transactions.

Admin Panel Deployment Issues

Blank white page after deploying the Admin Panel

• Almost always a missing SPA rewrite — all routes must fall back to index.html (see Production Deployment for Nginx / Apache / .htaccess rules).
• Hard-refresh (Ctrl/Cmd + Shift + R) to clear a cached old build.
• Confirm you uploaded the contents of build/web/ (not the folder itself) to the document root.

Admin login fails / "no admin found"

• Ensure the admin collection was imported and contains your admin user, and that the email/password matches an entry under Authentication.
• Add your live domain to Firebase → Authentication → Settings → Authorized domains.

Localization Issues

A new language does not appear or does not translate

• Confirm the language file was added under lib/app/lang/, registered, and enabled from Admin Panel → Languages (see Localization).
• Every UI key must exist in the new map — missing keys fall back to the key text.

Q: Do I really need four separate apps?

Yes. ParkEZ is intentionally split so each role (Customer, Owner, Watchman, Admin) ships as a focused product, can be branded / priced independently, and can be released to stores on its own schedule. All four share one Firebase backend.

Q: Do I need a Mac to build the iOS apps?

Yes. Xcode is required for building iOS apps and runs only on macOS. You can develop and test the Android and Web (Admin Panel) versions on Windows or Linux without a Mac.

Q: Which Firebase plan do I need?

The free Spark plan is enough to get started. If you plan to use Phone OTP authentication heavily or expect large Storage usage, upgrade to the Blaze plan (pay-as-you-go); Blaze still includes a generous free usage tier.

Q: Can I use my own backend instead of Firebase?

ParkEZ is built around Firebase (Firestore, Auth, Storage, and FCM). Switching to a custom backend is possible but requires significant changes — mainly replacing the repository / service layer in each app.

Q: How do I update the apps after making changes?

Rebuild the modified app with flutter build apk, flutter build appbundle, or flutter build web and redeploy / upload to the relevant store or hosting target.

Q: An app crashes on startup. What should I check?

• Ensure google-services.json (Android) and GoogleService-Info.plist (iOS) are correctly placed in the right app folder.
• Verify Firebase is initialized in main.dart.
• Check console logs with flutter run --verbose.

Q: How are commissions calculated?

The Admin Panel → Settings → General Settings screen lets you set a platform commission percent. The Customer and Owner apps read this value when settling each booking and split the amount between the platform wallet and the owner wallet via secure Firestore transactions.

Q: How do owners get paid?

Owners accumulate balance in the in-app wallet. They can submit a Withdraw Request from the Owner App; admins approve / reject it from the Admin Panel, then mark it as paid after the bank transfer.

Q: What ongoing / external costs should I expect?

The item price covers the source code only. Firebase and Google Maps Platform are external Google services billed to your own account once you exceed their free tiers; payment gateways charge per-transaction fees; and app store accounts (Google Play one-time, Apple Developer yearly) are separate. See the cost warning in Prerequisites.

Q: Can I rebrand / white-label the apps?

Yes. Changing the app name, package / bundle id, logo, colours, and default currency is covered step-by-step in Mobile Apps Setup and Admin Panel → App Settings. No code restructuring is required.

Q: How do I add another language?

Add a new language map file in each app's lib/app/lang/, register it, and enable the language from the Admin Panel. The full walkthrough is in Localization (Multi-Language).

Q: Which payment methods are supported out of the box?

Stripe, Razorpay, PayPal, in-app Wallet, and Cash on Delivery. Each gateway is toggled and configured (keys, sandbox/live) from Admin Panel → Payment Settings — no rebuild needed.

Q: Is the source code readable and customisable?

Yes — the package ships full, unobfuscated Dart source for all four apps using a consistent GetX module structure (view / controller / binding per screen), a central data layer, and typed models. See the Developer Guide for how to extend it.

Q: How do I contact support?

Refer to the support details provided with your ParkEZ purchase (email / WhatsApp on the product page).

Want to pull future ParkEZ releases into your customised project without losing your changes? Keep the project in Git and merge each release in as a branch. Below are the prep notes and the limits of our support.

Upgrade via GitHub Desktop — Step by Step

GitHub Desktop lets you keep your customisations on a private branch and merge each release in. Follow the steps in order.

Step 1 — Download and install GitHub Desktop

1. Open https://github.com/apps/desktop and download the installer for your OS (Windows or macOS).
2. Run the installer and complete the standard setup.
3. Launch GitHub Desktop.

Step 2 — Sign in to GitHub

1. On first launch GitHub Desktop prompts you to sign in. Click Sign in to GitHub.com.
2. Complete the browser-based sign-in flow and return to GitHub Desktop. Confirm your name and email on the configure-git screen and click Finish.

Step 3 — Open the “Add” menu

1. Click the Current repository dropdown at the top-left.
2. In the panel that opens, click the Add dropdown at the top-right.

Step 4 — Create a new repository

1. From the Add dropdown, choose Create new repository…

Step 5 — Fill in the repository form

1. Name: e.g. parkez-customised.
2. Local path: browse to the folder that contains your existing ParkEZ project.
3. Leave the other options at their defaults and click Create repository.

Step 6 — Commit your existing project as the baseline

1. GitHub Desktop lists every file in your project under Changes.
2. Type a commit summary — for example Initial commit — my customised v1.0 build.
3. Click Commit to main.

Step 7 — Publish the repository to GitHub

1. Click Publish repository at the top of the window.
2. Tick Keep this code private.
3. Click Publish Repository.

Step 8 — Create a v1.1 branch

1. Click Current branch → New branch.
2. Name it v1.1 and click Create branch.
3. Confirm you are now on the v1.1 branch (shown in the top bar).

Step 9 — Download the latest ParkEZ release

Step 10 — Replace the code folders on the v1.1 branch

1. Make sure the v1.1 branch is still active in GitHub Desktop.
2. From the extracted v1.1 package, copy these folders into your project, replacing the existing ones:
   • customer/lib/
   • owner/lib/
   • watchman/lib/
   • admin_panel/lib/
   • landing_page/ (only if you haven't customised it)
3. Leave everything else untouched — branding, Firebase config files, signing keystore, and platform projects.

Step 11 — Commit the v1.1 changes

1. Switch back to GitHub Desktop — the updated files appear under Changes.
2. Enter the commit summary Upgrade to v1.1.
3. Click Commit to v1.1.

Step 12 — Push the v1.1 branch to GitHub

1. Click Push origin at the top of the window.
2. Wait for the push to complete.

Step 13 — Merge v1.1 into main

1. Switch Current branch back to main.
2. From the top menu choose Branch → Merge into current branch…
3. Select v1.1 and click Create a merge commit.

Step 14 — Resolve conflicts (if any)

1. If GitHub Desktop reports conflicts, click Open in your editor.
2. In each conflicted file, look for the markers <<<<<<<, =======, >>>>>>> and keep the correct lines.
3. Save each file and return to GitHub Desktop — the conflict count drops as files are resolved.
4. When the count reaches zero, click Continue merge, then Push origin.

Step 15 — Apply the changes to your real project

Manual Upgrade — Replace the lib Folder

To skip Git, replace each app's lib/ folder with the one from the new release. Faster, but any custom code inside lib/ is lost — diff before overwriting.

1. Back up the whole project (zip it).
2. Download the latest package from CodeCanyon Downloads and extract it to a temp folder — not over your project.
3. Locate the lib/ folder in each app:
   • customer/lib/
   • owner/lib/
   • watchman/lib/
   • admin_panel/lib/
4. Back up your existing lib/firebase_options.dart, then delete the old lib/.
5. Copy the new lib/ from the package into the same spot.
6. Restore your lib/firebase_options.dart. flutterfire configure generates this against your Firebase project; the package ships a sample that would point you at the wrong project.
7. Re-apply any other custom edits you made inside lib/ on top of the new files.
8. Compare each pubspec.yaml with the new release and add any new dependencies.
9. Refresh deps per app:

   flutter clean
   flutter pub get

   On macOS, also run pod install --repo-update inside customer/ios (and the other iOS app folders).
10. Build and run each app to verify.

Item Support — What's Covered

Support follows the Envato Item Support Policy:

Reporting a Bug — What to Include

1. The app (Customer / Owner / Watchman / Admin) and screen where it happens.
2. Steps to reproduce, expected vs actual behaviour.
3. Platform + version (Android / iOS / browser) and Flutter version (flutter --version).
4. The console output — run with flutter run --verbose and copy the error.
5. Screenshots or a short screen recording if visual.

License

• Regular License — one end product for you or one client; the end product is free to use.
• Extended License — required if end users are charged for the product itself.
• Full terms: CodeCanyon License FAQ.

Credits

• Flutter & Firebase — framework and backend platform.
• GetX — state management, routing and dependency injection.
• Google Maps Platform — maps, places and geocoding.
• Open-source Flutter packages listed in each app's pubspec.yaml.
• Documentation template based on Documenter by revaxarts.