System Overview & Installation

Prerequisites

Detailed Server Requirements

The RAM and disk figures are advisory sizing guidance for a growing catalogue. The only figure the installer actually enforces is 500 MB of free disk space, checked before it downloads the application packages.

Verify your PHP version:

php -v

Installation

How to Purchase a MyntCart License

MyntCart itself is sold in two places, and the installer asks which one you used. The add-on modules are sold only through the CodeMynt licence portal.

Route A — Direct from CodeMynt

Route B — From CodeCanyon (Envato)

Pre-Installation — Upload Files to Server

# WAMP
C:\wamp64\www\myntcart\

# XAMPP
C:\xampp\htdocs\myntcart\

# Laragon
C:\laragon\www\myntcart\

Create Database & Configure .env

Before running the installer wizard, create the database and configure the environment file.

-- Login to MySQL
mysql -u root -p

-- Create database
CREATE DATABASE myntcart CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

-- Create user (production only)
CREATE USER 'myntcart_user'@'localhost' IDENTIFIED BY 'your_strong_password';
GRANT ALL PRIVILEGES ON myntcart.* TO 'myntcart_user'@'localhost';
FLUSH PRIVILEGES;

# Application
APP_NAME="MyntCart"
APP_ENV=local                    # Change to 'production' on live server
APP_DEBUG=true                   # Change to 'false' on live server
APP_URL=http://localhost/myntcart # Your domain on live server

# Database — match the credentials you just created
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=myntcart
DB_USERNAME=root               # Your DB username
DB_PASSWORD=                    # Your DB password (empty for localhost)

# Leave APP_KEY empty — MyntCart writes one into this file the first time the installer is opened
APP_KEY=

# Licence signing key — already filled in, in the .env.example you copied.
# Leave this line exactly as it came: do not clear it and do not type another value.
HMAC_SIGNING_KEY=(as it came in .env.example)

# Set to false when you are running on plain http:// (localhost)
SESSION_SECURE_COOKIE=false

# License — optional here; the installer asks for these on the License step
PURCHASE_CODE=your_purchase_code
BUYER_USERNAME=your@email.com

# Localhost
http://localhost/myntcart/secure-install

# Live server
https://yourdomain.com/secure-install

Secure Installation Wizard (Step-by-Step)

The installer opens on a welcome page and then takes you through 6 steps, each on one screen, with the steps listed down the side. Do not close your browser during any step.

Post-Installation

Complete these steps after the wizard finishes. The cron job and the queue worker matter on every install, not only on live servers.

# cPanel → Cron Jobs (every minute)
* * * * * /usr/local/bin/php /home/username/public_html/artisan schedule:run >> /dev/null 2>&1

# VPS / dedicated server (crontab -e)
* * * * * cd /path/to/myntcart && php artisan schedule:run >> /dev/null 2>&1

What runs from it. Jobs for an add-on module are only scheduled when that module is installed:

php artisan queue:work --tries=3

Environment Settings

The .env file holds the settings the application needs before it can reach the database — the ones below, plus your licence signing key, the storefront theme and the operating mode. Everything else (payment gateway credentials, maps, reCAPTCHA, Firebase, SMS, WhatsApp) is configured from the admin panel and is not kept in .env at all. Copy from .env.example and update each section.

Database Configuration

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=myntcart
DB_USERNAME=your_username
DB_PASSWORD=your_password

Application Configuration

APP_NAME="MyntCart"
APP_ENV=local
APP_KEY=                        # leave empty — the installer generates it
APP_DEBUG=true
APP_URL=http://localhost
APP_MODE=live                   # 'demo' makes the admin panel read-only
WEB_THEME=classic               # classic, modern or semi-classic
DEFAULT_PAYMENT_GATEWAY=stripe      # optional — used when no default is chosen under Business Setup → Payment Options

Licence & Session

HMAC_SIGNING_KEY=(as it came in .env.example)  # required — signs every licence call; leave it as it came
LICENSE_GRACE_DAYS=7                    # 1–30; how long the store keeps
                                        # working if the licence server is unreachable
SESSION_SECURE_COOKIE=true            # false on plain-http localhost

Mail Configuration

MAIL_MAILER=smtp
MAIL_HOST=smtp.gmail.com
MAIL_PORT=587
MAIL_USERNAME=your_email@gmail.com
MAIL_PASSWORD=your_app_password
MAIL_ENCRYPTION=tls
MAIL_FROM_ADDRESS=your_email@gmail.com
MAIL_FROM_NAME="MyntCart"

File & Folder Permissions

# Set permissions (Linux)
chmod -R 775 storage bootstrap/cache
chmod 644 .env
chmod 755 artisan

# Set ownership for Apache
sudo chown -R www-data:www-data storage bootstrap/cache .env

Google Maps API Setup (Complete Guide)

Google Maps powers the store locator, delivery tracking, the live map, address autocomplete and delivery distance and time estimates across the MyntCart website and the Flutter apps. Distance-based shipping rates on the website are worked out from the stored coordinates without calling Google, so they keep working even if a map fails to load.

1. Create a Google Cloud Project

2. Enable Required APIs

Go to APIs & Services → Library in the left sidebar. Search for and enable each of these APIs one by one:

3. Create an API Key

4. Restrict the API Key (Important for Security)

https://yourdomain.com/*
http://localhost/*

Create a second key for the server key — the one MyntCart itself uses for geocoding, address lookups and distance calculations. Restrict that one by IP address (your server's outgoing IP), not by referrer: a referrer restriction will reject every call your server makes.

5. Enable Billing

6. Configure in MyntCart

Website (Admin Panel)

Google Maps is configured entirely in the admin panel — there is nothing to add to .env. Go to Admin Panel → System Settings → 3rd Party & Other Configs → Google Map APIs and fill in:

Then toggle the status to Active and click Save.

Flutter Apps (Android)

The key is not typed into the manifest. Add one line to android/local.properties in each app that has a map (customer, vendor, delivery); Gradle puts it into the manifest when it builds:

# myntcartapp (customer)
MAPS_API_KEY=YOUR_ANDROID_MAPS_API_KEY

# myntcart_vendor and myntcart_delivery
GOOGLE_MAPS_API_KEY=YOUR_ANDROID_MAPS_API_KEY

Flutter Apps (iOS)

Copy ios/Flutter/Secrets.example.xcconfig to ios/Flutter/Secrets.xcconfig in each of the same three apps and set the key there; AppDelegate.swift reads it and needs no edit:

# myntcartapp (customer)
MAPS_API_KEY=YOUR_IOS_MAPS_API_KEY

# myntcart_vendor and myntcart_delivery
GOOGLE_MAPS_API_KEY=YOUR_IOS_MAPS_API_KEY

Google Maps Config Summary

reCAPTCHA Setup (Complete Guide)

Google reCAPTCHA protects login, registration, contact, and checkout forms from spam bots.

1. Go to reCAPTCHA Console

2. Create a New Site

yourdomain.com
www.yourdomain.com
localhost
staging.yourdomain.com

3. Copy Your Keys

After submission, Google shows two keys:

4. Configure in MyntCart

Enable in Admin Panel

Both keys are entered in the admin panel. Nothing goes into .env.

1. Go to Admin Panel → System Settings → 3rd Party & Other Configs → Recaptcha
2. Enter Site Key and Secret Key
3. Select status: Active
4. Click Save

5. Manage & Monitor

Go back to reCAPTCHA Admin Console anytime to:

• View request statistics (pass/fail rates, suspicious traffic)
• Add or remove domains
• Regenerate keys if compromised

Firebase Setup (Complete Guide)

Firebase powers push notifications, OTP phone authentication and Google sign-in in MyntCart. You need one Firebase project for the website and all Flutter apps. Everything on the web side is entered in the admin panel — no Firebase value belongs in .env, and no file is uploaded to the server.

1. Create Firebase Project

2. Add a Web App (for MyntCart Backend)

3. Where to Find Each Config Value

Every Firebase config value has a specific location in the Firebase Console. Here's exactly where to find each one. All of them are fields on the Push Notifications Setup screen in the admin panel:

4. Enter the Config in the Admin Panel

Go to Admin Panel → System Settings → 3rd Party & Other Configs → Push Notifications Setup and paste each value into the matching field. There is no Firebase block in .env — if you add one, nothing reads it.

5. Cloud Messaging (FCM) — Push Notifications

FCM sends push notifications to all MyntCart Flutter apps (Customer, Vendor, Store, Delivery). MyntCart uses the current Firebase Cloud Messaging API, which authenticates with a service account. There is no server key to copy and nothing to enable under "Cloud Messaging API (Legacy)".

6. Authentication — Enable Sign-in Methods

Navigate to Build → Authentication → Sign-in method in Firebase Console. Enable each method MyntCart needs:

7. Phone OTP — Firebase Auth

OTP login is switched on separately, on its own screen. Go to Admin Panel → System Settings → 3rd Party & Other Configs → Firebase Auth. This screen holds exactly two things:

• Status — turns Firebase OTP verification on or off
• Web API Key — the same apiKey value from Project Settings → General → Your apps

Click Save. The rest of the Firebase web config (auth domain, project ID, sender ID and so on) belongs on the Push Notifications Setup screen, not here.

8. Register Flutter Apps in Firebase Console

Each Flutter app needs its own Android + iOS registration inside the same Firebase project. Repeat these steps for every app:

Register Android App

Register iOS App

Config File Placement (per app)

# Customer App
myntcartapp/android/app/google-services.json
myntcartapp/ios/GoogleService-Info.plist

# Vendor App
myntcart_vendor/android/app/google-services.json
myntcart_vendor/ios/GoogleService-Info.plist

# Store App: none -- it carries no Firebase package

# Delivery App
myntcart_delivery/android/app/google-services.json
myntcart_delivery/ios/Runner/GoogleService-Info.plist

9. SHA-1 Key (for Google Sign-In on Android)

Google Sign-In requires your app's SHA-1 fingerprint registered in Firebase. Get it with this command:

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

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

# For release builds (Play Store), use your release keystore:
keytool -list -v -keystore /path/to/your-release-key.jks -alias your-key-alias

1. Copy the SHA1 fingerprint from the output (format: XX:XX:XX:...:XX)
2. Go to Firebase Console → Project Settings → Your apps → select the Android app
3. Click "Add fingerprint" → Paste the SHA-1 → Save
4. For Play Store release, add the release keystore SHA-1 too
5. After adding SHA-1, re-download google-services.json — it now includes the fingerprint data

10. Where to Configure Firebase in MyntCart Web Admin

The Firebase values go in two places on the web side, and both of them are admin screens:

Firebase Configuration Summary

SMS API Setup

Configure SMS providers for OTP delivery and order notifications. MyntCart ships with 20 SMS gateways built in, each with its own credential fields.

Go to Admin Panel → System Settings → 3rd Party & Other Configs → SMS API Config. Every gateway has its own panel on that screen — fill in the credentials for the one you use, set it Active, and save. Only one gateway is active at a time.

Related SMS Screens

Three more screens sit alongside SMS API Config under 3rd Party & Other Configs:

• SMS Order Notifications — choose which order events send an SMS, and to whom
• SMS Templates — the message wording for each event
• Advanced SMS Templates — richer per-gateway templates, with import and export

WhatsApp Integration via Twilio (Complete Guide)

MyntCart uses Twilio's WhatsApp Business API to send order updates, bulk store notifications, delivery alerts, invoice sharing, and customer communication directly via WhatsApp.

1. Create a Twilio Account

2. Enable WhatsApp Sandbox (for Testing)

3. Get a WhatsApp Business Number (for Production)

4. Configure in MyntCart

5. Configure Store-Level WhatsApp Numbers

Each store branch can have its own WhatsApp number for receiving orders and customer messages.

1. Go to Admin Panel → Store Management → Store Settings (or select a specific store)
2. Find the WhatsApp Number field
3. Enter the store's WhatsApp number with country code (e.g. +919876543210)
4. Click Save

6. Test WhatsApp Messaging

1. Go to Admin Panel → Store Management → Bulk WhatsApp
2. Select a store with a configured WhatsApp number
3. Enter a test message
4. Click Preview to see the formatted WhatsApp message
5. Click Send. The result is reported per store: sent where Twilio accepted the message, or link ready where Twilio is off and you get a click-to-chat link to open yourself.

WhatsApp Features in MyntCart

Twilio Pricing

Payment Gateways & UPI

Payment credentials are entered in the admin panel, never in .env. MyntCart has 14 gateways built in — Stripe, Razorpay, PayPal, PhonePe, Paytm, Paystack, senangPay, Flutterwave, PayTabs, LiqPay, Mercado Pago, Paymob Accept, Cashfree and Instamojo — and six more in the Global Payment Gateways module. UPI to your own UPI ID needs no gateway at all.

Configure a Gateway

1. Go to Admin Panel → System Settings → Payment Methods → Digital Payment Methods
2. Fill in the gateway's credentials and choose the Mode: Test while you try it, Live for real payments
3. Switch the gateway on and click Save

A gateway that is switched on but has no credentials is marked Not configured and hidden from checkout. Before switching one on, check under System Setup → Currency that your currency is one the gateway accepts. The gateway chosen under Business Setup → Payment Options → Default payment gateway at checkout is offered first, on the storefront and in the customer app; the rest keep the order they were set up in. With none chosen, DEFAULT_PAYMENT_GATEWAY in .env (see Environment Settings) still counts.

PhonePe (Standard Checkout v2)

PhonePe runs on its Standard Checkout v2 API through PhonePe's official SDK — on the web checkout, in the customer app (PhonePe's native SDK) and at the tills. The older v1 credentials (merchant ID plus salt key) are not used; you need PhonePe's v2 client credentials. PhonePe takes payments in Indian rupees only.

Give PhonePe this webhook URL:

https://yourdomain.com/api/v1/phonepe/webhook

An order is marked paid only when PhonePe's Order Status API confirms it — the customer arriving back on your site proves nothing — and the webhook records payments that complete after the customer has left.

UPI Payments (Pay to Your UPI ID)

Customers pay from any UPI app straight into your bank account, and someone at the store confirms each payment. There is no gateway and no webhook. One UPI account serves the whole platform — storefront, customer app and every till.

Set it up

1. Go to Admin Panel → System Settings → Payment Methods → UPI Payments
2. Enter your UPI ID (a business UPI ID, not a personal one), the Payee name shown in the customer's UPI app and, optionally, a Note shown to customers
3. Switch on Show Pay with UPI at checkout and click Save

How customers pay

• Storefront (all three themes) — signed-in customers choose Pay with UPI. The order is placed unpaid and a payment page shows a QR code for the exact amount (and a link that opens a UPI app on phones). After paying, the customer enters the UTR / transaction reference from their UPI app and can attach a screenshot (JPG, PNG or WEBP, up to 4 MB). Submissions are rate-limited, and a UTR already offered for another order is refused.
• Customer app — the same flow: place the order by UPI, pay as shown, submit the UTR. It uses the same service as the web checkout, so both accept and refuse the same proofs.

Verify or reject

Payments waiting to be checked are listed on the same UPI Payments screen, and its menu item shows a red badge with how many there are. Find the UTR and amount in your bank account, then press Verify — the order is marked paid and the customer is e-mailed — or Reject, which leaves the order unpaid so the customer can submit a corrected UTR from the same payment page. Two admins pressing Verify at once settle it only once.

UPI at the tills

Wherever a UTR is entered — at checkout or at a till — it has to look like one: 10 to 24 letters and digits with at least 8 digits, never a UPI ID with "@". At a till the UTR is optional; when none is typed, the QR's own reference (starting POS) is kept on the order so the sale can be found on the bank statement.

Shipping Auto-Calculation

MyntCart features a smart shipping calculation engine that automatically determines shipping costs using a priority-based adapter system. Instead of manual rate entry, the system tries each enabled shipping provider in priority order and uses the first successful result.

How It Works

• Priority-Based Adapters — Each shipping provider (Shiprocket, Shiprocket Local Quick, Easyship, ShipEngine, Shadowfax Courier, Shadowfax Hyperlocal, Manual) is an adapter with a configurable priority (1–100)
• Automatic Fallback — If the highest-priority adapter fails, the system automatically tries the next adapter
• Manual Fallback — Manual shipping is always available as the last-resort fallback adapter
• Multi-Option Display — Show customers multiple shipping options from different providers so they can choose
• Category-wise Shipping — Set different shipping costs per product category
• Order-wise Shipping — Flat shipping rate per order

Configure Shipping Calculator

Courier Hand-off, Tracking & Cancellation

The calculator decides what the customer is charged. What happens to the parcel afterwards is set under Admin Panel → Order Management → Shipping Providers:

• Trigger status — under Trigger Status Settings → Order Status Trigger, pick Confirmed, Processing, Shipped (the default) or Out for Delivery. When an order reaches that status it is handed to its courier. The store app's shipping settings change the same value.
• Which courier — each order goes to the courier checkout priced it with. Only orders priced by Manual rates go to the Active Provider chosen on the same screen.
• Couriers that start at checkout — Shiprocket creates its order straight after checkout (Ship Now later assigns the AWB and books the pickup), and Shadowfax, Courier or Hyperlocal, takes cash-on-delivery and already-paid orders then; for both, the trigger status hands over whatever did not go at checkout. Shiprocket Local Quick always hands over at placement and ignores the trigger status, booking the rider at once only for cash-on-delivery or already-paid orders.
• Status updates move forward only — Shiprocket, Shiprocket Local Quick, Shadowfax, Easyship and ShipEngine advance the order (shipped → out for delivery → delivered, or returned / failed), never backwards and never out of a finished state. Shipped orders have their own tab in the order lists and count as ongoing, not completed.
• Cancellations reach the courier — an order cancelled anywhere (admin, vendor, customer or store app) is cancelled at Shiprocket, Shiprocket Local Quick, Shadowfax or Easyship as well.
• One tracking timeline — every courier feeds the same order-tracking timeline on every storefront theme and in the customer app, with the carrier's details and the courier's own tracking link.
• What a vendor may set — with admin shipping, a vendor can set an order to pending, confirmed or processing; with seller-wise shipping, also shipped, out for delivery, delivered, returned, failed or canceled. The vendor panel and the vendor app enforce the same list.

Courier Webhook URLs

Couriers report status changes to these addresses. Replace yourdomain.com with your live domain — a courier cannot reach localhost or a LAN address, however correct the rest of the setup is.

The scheduled jobs under Post-Installation catch up what webhooks miss — Shadowfax, Easyship and Shiprocket Local Quick shipments are re-read from the courier, and Shiprocket updates that arrived but could not be applied are retried — so the cron entry matters here too.

Flutter Apps — Complete Setup Guide

MyntCart ships with four Flutter mobile applications. This guide covers everything from installing Flutter to building a release APK — nothing left out.

Required Versions

The vendor and store apps start at Android 8.0 because Stripe Terminal, which takes card payments at the point of sale, needs it. All four apps compile against and target Android 17.

Install Flutter (Windows)

# Extract to C:\flutter (or your preferred path)
# Then add to System PATH:
C:\flutter\bin

# Set JAVA_HOME (System Variable)
JAVA_HOME = C:\Program Files\Java\jdk-17

# Add to PATH (System Variable)
%JAVA_HOME%\bin

# Verify Flutter
flutter --version
# Flutter 3.47.x with Dart 3.13.x

# Verify Java
java -version
# 17.x.x

# Check everything at once
flutter doctor
# Fix any ✗ issues it reports

Install Flutter (macOS)

# Add Flutter to PATH
export PATH="$HOME/flutter/bin:$PATH"

# Set Java 17
export JAVA_HOME=$(/usr/libexec/java_home -v 17)

# Android SDK
export ANDROID_HOME="$HOME/Library/Android/sdk"
export PATH="$ANDROID_HOME/platform-tools:$PATH"

# Set Xcode command line tools path
sudo xcode-select --switch /Applications/Xcode.app/Contents/Developer

# Accept license from terminal (if not done in GUI)
sudo xcodebuild -license accept

# Install CocoaPods (iOS dependency manager)
sudo gem install cocoapods

# If gem install fails on Apple Silicon (M1/M2/M3), use:
brew install cocoapods

# Setup CocoaPods master repo
pod setup

# Check Xcode version
xcodebuild -version
# Should show: Xcode 15.x or higher

# Check CocoaPods version
pod --version
# Should show: 1.x.x

Import Project into Android Studio

App Configuration — Step by Step

Step 1 — Install Dependencies and Create env.json

Open the app directory in your terminal and install all Dart packages.

# Navigate to app directory
cd myntcartapp

# Install dependencies
flutter pub get

# Customer, vendor and delivery apps: your values come from env.json (below)
flutter run --dart-define-from-file=env.json

# Store app: pass your backend on the command line, or put BASE_URL in its own env.json
flutter run --dart-define=BASE_URL=https://yourdomain.com

The customer, vendor and delivery apps read their settings from one file, env.json, in the app's root folder. It is not part of the download — it holds your keys, so you create it. The vendor and delivery apps ship env.example.json to copy; the customer app lists the Firebase and Maps names in .env.example, to which you add BASE_URL. The store app needs one value only, BASE_URL: pass it on the command line as above, or copy its env.example.json to env.json and run with --dart-define-from-file=env.json.

{
  "BASE_URL": "https://yourdomain.com",
  "FIREBASE_API_KEY": "your-api-key",
  "FIREBASE_PROJECT_ID": "your-project-id",
  "FIREBASE_MESSAGING_SENDER_ID": "your-sender-id",
  "FIREBASE_APP_ID": "your-app-id",
  "MAPS_API_KEY": "your-maps-key"
}

The vendor app takes the same file without the MAPS_API_KEY line; the delivery app names that line GOOGLE_MAPS_API_KEY. The four Firebase values come from Step 6, the Maps key from Step 7. Keep env.json out of version control.

Step 2 — Configure App Constants

Every app has one constants file that carries its name, version and the backend URL it talks to. The file is not in the same place in all four, so start from this table.

In all four apps the backend URL is read from the build first and falls back to a built-in address:

class AppConstants {
  static const String appName    = 'MyntCart';      // Display name shown in app
  static const String slogan     = 'E-Commerce';    // Tagline on splash screen
  static const String appVersion = '1.0.1';         // App version number
  static const String baseUrl =
      String.fromEnvironment('BASE_URL', defaultValue: '...development address...');
}

So there are two ways to point an app at your site, and you must use one of them:

• Replace the defaultValue with your own URL (no trailing slash), or
• Leave the file alone and give the app its address at build time: BASE_URL in env.json for the customer, vendor and delivery apps, --dart-define=BASE_URL=https://yourdomain.com (or BASE_URL in its own env.json) for the store app, on every flutter run and flutter build.

Step 3 — Change Logo & Assets

In the customer, vendor and delivery apps every image is named once in lib/utill/images.dart and the files live in assets/images/. The store app has no such file — its screens reference assets/images/… directly. The table below lists the customer app's main images. The other three share the logo.png name but differ elsewhere — the vendor and delivery apps use placeholder.jpg for the placeholder, the store app ships no placeholder picture at all, and their onboarding images are named differently again — so check the app's own assets/images/ folder before replacing files.

To replace: simply overwrite the files in assets/images/ with your own images, keeping the exact same file names. If you want to use different file names, update the paths in lib/utill/images.dart (or, in the store app, in the screen that references the image).

App Launcher Icon (Home Screen Icon)

The launcher icon is separate from the in-app logo. You need one high-resolution PNG (1024x1024px, no transparency for iOS) and it must be exported in multiple sizes for each platform.

How to Generate App Icons

# From the downloaded zip → android/ folder
# Copy each ic_launcher.png into the matching mipmap folder:

android/app/src/main/res/mipmap-mdpi/ic_launcher.png       # 48x48
android/app/src/main/res/mipmap-hdpi/ic_launcher.png       # 72x72
android/app/src/main/res/mipmap-xhdpi/ic_launcher.png      # 96x96
android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png     # 144x144
android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png    # 192x192

# From the downloaded zip → ios/ folder
# Replace the entire AppIcon.appiconset folder:

ios/Runner/Assets.xcassets/AppIcon.appiconset/

# This folder contains all required sizes (20x20 to 1024x1024)
# plus the Contents.json manifest file

Step 4 — Change App Name

The app name displayed on the device home screen is set in platform-specific config files (not in Dart code).

Android

Edit android/app/src/main/AndroidManifest.xml — find the android:label attribute. The vendor app is the exception: its manifest holds a placeholder, and the name is set in android/local.properties (see the table below).

<application
    android:label="Your App Name"   <!-- Change this -->
    ...
>

iOS

Edit ios/Runner/Info.plist — find CFBundleDisplayName (or CFBundleName):

<key>CFBundleDisplayName</key>
<string>Your App Name</string>

The names the apps ship with, so you know what you are replacing:

Step 5 — Change Package Name (Bundle ID)

The package name uniquely identifies your app on Play Store / App Store. You must change it from the default before publishing.

Android — the app's Gradle file

Three apps use android/app/build.gradle; the store app uses the Kotlin form, android/app/build.gradle.kts. In either file, change both the namespace and the applicationId — they must match.

namespace = "com.yourcompany.yourapp"
applicationId = "com.yourcompany.yourapp"   // must match namespace

The package names the apps ship with:

Then rename the folder structure inside android/app/src/main/kotlin/ (or java/) to match your new package path. For example: com/yourcompany/yourapp/MainActivity.kt

iOS — Xcode

Open ios/Runner.xcworkspace in Xcode → Select Runner target → General tab → Change Bundle Identifier to com.yourcompany.yourapp. An iOS identifier cannot contain an underscore, which is why three of the shipped ones differ from the Android package name.

Step 6 — Firebase Configuration (Complete Guide)

Firebase powers push notifications, phone OTP verification and Google sign-in in the customer, vendor and delivery apps. You need one Firebase project, with those three apps registered in it.

6.1 — Create a Google Account / Login

1. You need a Google account (Gmail). If you don't have one, create at accounts.google.com/signup
2. Go to console.firebase.google.com
3. Sign in with your Google account

6.2 — Create a Firebase Project

6.3 — Register MyntCart Apps in Firebase

Register the three Firebase apps (or whichever ones you're deploying) in the same Firebase project — both Android and iOS versions. Register the package name you set in Step 5; the shipped defaults are below, and registering anything else gives you the silent failure described at the end of this step.

For each app, repeat these steps:

Register Android App

Register iOS App

6.4 — Enable Required Firebase Services

In your Firebase project, enable these services (left sidebar menu):

Enable Authentication Methods

1. Go to Build → Authentication → Sign-in method
2. Enable Phone — required for OTP login in all apps
3. Enable Google — for Google sign-in on customer app
4. Enable Email/Password — for email-based login
5. Click Save for each

Get the service account for push notifications

1. Go to Project Settings (gear icon) → Service accounts tab
2. Click Generate new private key and download the JSON file
3. Paste the whole JSON into MyntCart Admin → System Settings → 3rd Party → Push Notifications Setup (Service Account Content). MyntCart sends through the current FCM API with this account; there is no legacy server key and no VAPID key to enter.

Get SHA-1 Key (for Google Sign-In)

Google Sign-In requires your app's SHA-1 fingerprint registered in Firebase.

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

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

1. Copy the SHA1 fingerprint from the output
2. Go to Firebase Console → Project Settings → Your Android app → Add fingerprint
3. Paste the SHA-1 and save
4. For release builds, use your release keystore SHA-1 instead

6.5 — Place Firebase Config Files in Flutter Project

myntcartapp/android/app/google-services.json

Open the file and verify package_name matches your applicationId from build.gradle:

{
  "project_info": {
    "project_id": "your-firebase-project-id",
    "storage_bucket": "your-project.firebasestorage.app"
  },
  "client": [{
    "client_info": {
      "android_client_info": {
        "package_name": "com.yourcompany.yourapp"  ← must match applicationId
      }
    },
    "api_key": [{ "current_key": "AIza..." }]
  }]
}

myntcartapp/ios/GoogleService-Info.plist
myntcart_vendor/ios/GoogleService-Info.plist
myntcart_delivery/ios/Runner/GoogleService-Info.plist

The BUNDLE_ID inside this plist must match your iOS Bundle Identifier set in Xcode.

6.6 — Firebase values in env.json (customer, vendor and delivery apps)

The customer, vendor and delivery apps start Firebase from the four FIREBASE_… values in env.json when the build carries them, and from the platform file — google-services.json on Android, GoogleService-Info.plist on iOS — when it does not. Put both in place: the platform file is what the native side reads in any case. All four values come from Firebase Console → Project Settings → General → Your apps, and must belong to the same Firebase project as the platform file.

# env.json holds BASE_URL and the four FIREBASE_ values (Step 1)
flutter build apk --release --dart-define-from-file=env.json

Step 7 — Google Maps in Flutter

Maps are used by the customer, vendor and delivery apps (the store app has none). In all three the key is not typed into the manifest — the manifest holds a placeholder that Gradle fills from a properties file, so the key stays out of your source. Create the file if it does not exist; it is one line.

# myntcartapp (customer)
MAPS_API_KEY=your-android-maps-key

# myntcart_vendor and myntcart_delivery
GOOGLE_MAPS_API_KEY=your-android-maps-key

# myntcartapp (customer)
MAPS_API_KEY=your-ios-maps-key

# myntcart_vendor and myntcart_delivery
GOOGLE_MAPS_API_KEY=your-ios-maps-key

Step 8 — Update Version

Edit pubspec.yaml in the root of the app directory:

name: flutter_codemynt_myntcart
version: 1.0.1+2   # format: version_name+build_number

The version before + is the display version. The number after + is the build number — increment it on every Play Store / App Store upload. The shipped values are 1.0.1+2 (customer), 1.0.2+2 (vendor), 1.0.0+1 (store) and 1.0.0+1 (delivery). Keep the appVersion constant from Step 2 in step with whatever you set here. In all four apps the iOS version and build number come from this line too, so there is nothing to change in Xcode.

Step 9 — Build & Release

# Build Android APK (direct install)
flutter build apk --release --dart-define-from-file=env.json

# Build Android App Bundle (Play Store upload)
flutter build appbundle --release --dart-define-from-file=env.json

# Build iOS for the App Store (requires macOS + Xcode)
flutter build ipa --dart-define-from-file=env.json

flutter build apk --release --dart-define=BASE_URL=https://yourdomain.com
flutter build appbundle --release --dart-define=BASE_URL=https://yourdomain.com
flutter build ios --release --dart-define=BASE_URL=https://yourdomain.com

Sign the Android release

All four apps read the release signing key from android/key.properties, which is not in the download. Create a keystore once (keytool -genkey -v -keystore upload-keystore.jks -keyalg RSA -keysize 2048 -validity 10000 -alias upload), keep it safe, and point the file at it:

storeFile=C:/keys/upload-keystore.jks
storePassword=your-keystore-password
keyAlias=upload
keyPassword=your-key-password

Without this file all four apps sign the release with the debug key — it installs on your own phone, but Google Play rejects it. Use the same keystore for every later update of the app.

First iOS build

On the Mac, run flutter pub get, then cd ios && pod install --repo-update && cd .., then the build command above. The store app has no Podfile — its plugins come as Swift packages, which Xcode fetches during the build — so skip the pod install step for it. Set your Apple Developer team in Xcode (Runner → Signing & Capabilities) before you archive. Each of the four apps carries a step-by-step guide for this first build, including what to check on a device: docs/IOS_BUILD.md in the app folder. The iOS projects of the vendor, store and delivery apps were prepared on Windows and have not been compiled on a Mac yet; their guides list what to check.

Configuration Summary per File

App-Specific Notes

Add-on Modules

MyntCart supports premium add-on modules that extend the platform with additional shipping providers, payment gateways, tax systems, and store management capabilities. Each module requires a license key for activation.

Available Modules

There are eight add-on modules. Each is bought separately and only appears in your admin panel once it is installed.

Courier Modules — What to Set Up

Every courier module follows the hand-off, forward-only status and cancellation rules in Shipping, and its webhook address is listed under Courier Webhook URLs. Each module's settings belong to the store — they are not on the vendor panel. Per module:

Shiprocket

• Orders are sent as Shiprocket's API documents them: a per-unit price with tax included, the weight of the cart items as checkout quoted it, and the box size and fallback pickup address from Shiprocket Settings.
• Ship Now assigns the AWB and books the pickup; labels, manifests and invoices are printed from the module.
• Only signed webhook events count, mapped by Shiprocket's status id. Cancelling an order or a single item cancels it in Shiprocket, and item refunds go to the right customer.
• php artisan shiprocket:cancel-orphans lists Shiprocket orders whose order here was deleted; add --cancel to cancel them in Shiprocket.
• Vendors see their own orders, store staff their store's.

Shiprocket Local Quick

• Shares one order, pickup and status core with Shiprocket, and sends the order from the pickup it was quoted from.
• A failed delivery fails the order; a cancelled order or item is cancelled in Shiprocket and refunded.
• Store staff see their own store's orders only.

Shadowfax — Courier and Hyperlocal

• Courier uses the Shadowfax Unified API: an AWB per parcel, priced at checkout from the zone rate card under Shadowfax Settings.
• Hyperlocal sends a rider from the pickup straight to the customer, priced per trip by Shadowfax from the map coordinates — or at a Flat Hyperlocal fee you set. It is a separate Shadowfax API: under Shadowfax Management → Shadowfax Settings, enter for each environment the Client code and either a Token or an OAuth client id and secret (Shadowfax issues them when it onboards you for Hyperlocal, and whitelists your server's IP address), save the pickup's Latitude and Longitude (orders filed under a store use that store's position), and switch on Offer Shadowfax Hyperlocal at checkout. Test Hyperlocal connection checks the credentials.
• Both follow the one Environment switch (staging or production), and nothing is sent unless Push orders to Shadowfax is on — on production every push spends Shadowfax credit.
• A cancellation is sent to Shadowfax, and queued if the parcel is already moving. No token or callback key is shown again once saved, and every one of them — courier and Hyperlocal — is stored encrypted. The settings are for the super admin only; staff see their own store.

Easyship

• Handing an order over creates the Easyship shipment with the courier checkout charged for — the cheapest of the couriers you selected.
• The label spends Easyship credit, so by default it is bought by hand: Buy label on Easyship Management → Easyship Orders, then Label to print it. To buy it automatically on hand-over, switch on Buy the label when an order is handed over under Easyship Settings → Default Settings (off by default).
• Cancelling deletes the shipment before a label is bought and cancels it after; once the parcel has left, Easyship refuses.
• Webhooks: Register Endpoint on Easyship Management → Webhooks registers the shipment events, switches the webhook on and saves its signing secret (stored encrypted). Shipments are also re-read every 30 minutes.
• Item values are declared, and quotes asked, in the store's currency; one box per parcel (the fallback box is entered in kg/cm or lb/in and converted); quotes are cached for 10 minutes. The access token is write-only and stored encrypted.
• Account screens (settings, couriers, webhooks, pickup addresses, reconciliation) are for the super admin only; staff see their store's orders and vendors their own shipments.

ShipEngine

• Checkout quotes with ShipEngine's rate estimates, from the warehouse the order will ship from, and charges the cheapest of your selected carriers — the full price, in the store's currency.
• Handing an order over creates the ShipEngine shipment with the carrier and service checkout charged for.
• The label charges your carrier account, so by default it is bought by hand: Buy label on ShipEngine Management → ShipEngine Orders, then Label to print it. To buy it automatically on hand-over, switch on Buy the label when an order is handed over under ShipEngine Settings → Default Shipping Options (off by default).
• Cancelling voids the label (asking the carrier for a refund) and cancels the shipment; once the carrier has the parcel, neither is possible. An order cancelled in MyntCart is withdrawn from ShipEngine too.
• Tracking webhooks — register the Tracking event on ShipEngine Management → Webhooks — move the order forward, out for delivery and returned or lost parcels included. Shipments are also re-read every 30 minutes.
• Shipments are sent in kilograms and centimetres (the fallback box is entered in either unit and converted). The API key is write-only and stored encrypted.
• Account screens (settings, carriers, webhooks, warehouses, reconciliation) are for the super admin only; staff see their store's orders and vendors their own.

How to Install a Module (from Addons Page)

Modules are installed via the Addons page in the admin panel — not by manually copying files. Uploading, publishing and removing a module are for the super admin only.

After installation, the module files are placed at:

myntcart/
├── Modules/
│   ├── Shiprocket/
│   ├── ShiprocketLocalQuick/
│   ├── Shadowfax/
│   ├── Easyship/
│   ├── ShipEngine/
│   ├── StoreManagement/
│   ├── GlobalPaymentGateways/
│   ├── CommercialTax/
│   └── modules_statuses.json   # which modules are switched on

How to Activate a Module License

Installing a module and activating its license are two separate steps. Installation makes the module available; license activation unlocks its features.

Option A — From the MyntCart Modules Page

Option B — From the Module's Own Sidebar Section

Every installed module also has its own Module Activation menu item inside its sidebar section. For example:

• Store Management section → first item is "Module Activation" — if not licensed, it shows a yellow Required badge. All other items (Dashboard, Branch Management, etc.) show License Required and are locked.
• Commercial Tax Management section → first item is "Module Activation" — sub-items like Tax Dashboard, Tax Classes show locked until licensed.
• Shiprocket Management section → "Module Activation" with green ✓ (if active) or yellow warning (if not).

Click the Module Activation item → enter your CodeMynt licence key → same activation flow as above.

How to Deactivate a Module License

How to Delete / Remove a Module

Option A — From Addons Page (Recommended)

Option B — Manual Deletion (Server Access)

# Example: remove Easyship module
rm -rf Modules/Easyship

# Clear what the framework had cached of it
php artisan optimize:clear

Also open Modules/modules_statuses.json and remove that module's line, so the file stops listing a module that is no longer there.

Production Deployment Checklist

• Set APP_ENV=production and APP_DEBUG=false
• Set APP_URL to your live address — module licences bind to this value, not to the address you browse
• Configure SSL certificate (HTTPS required)
• Change all default passwords (admin, database)
• Set proper file permissions (644 for files, 755 for directories)
• Add the one-minute scheduler cron — * * * * * cd /path/to/myntcart && php artisan schedule:run >> /dev/null 2>&1. Licence re-checks, POS online-payment settlement, courier status sync, the sitemap and exchange rates all run from it (the full list is under Post-Installation)
• Turn on two-factor authentication for the main admin account and set the login lockout under System Setup → Login Settings → OTP & Login Attempts (see Secure the Sign-ins)
• Set up backup procedures
• Enable proper error logging (disable display_errors)
• Confirm the installer is locked — /secure-install must return an error once installation is complete
• Configure payment gateway live keys and switch each gateway's mode to Live — PhonePe needs its Standard Checkout v2 credentials and webhook (see PhonePe)
• If you take UPI, set your business UPI ID under Payment Methods → UPI Payments and make sure someone checks the payments queue
• Set the courier hand-off trigger status (Order Management → Shipping Providers) and register each courier's webhook against your live domain (see Courier Webhook URLs)
• Test all SMS and email notifications
• Rebuild each mobile app with your own backend URL, Firebase values and Google Maps key — a release build made without them points at the wrong site
• Verify Firebase push notifications on the customer, vendor and delivery apps
• Test Google Maps in the apps that use it and in the admin panel

Update Guide (Version Upgrade)

How to safely update MyntCart from one version to the next without losing data, settings, or customizations.

# Backup database
mysqldump -u root -p myntcart > myntcart_backup_$(date +%Y%m%d).sql

# Backup files
tar -czf myntcart_files_backup_$(date +%Y%m%d).tar.gz /path/to/myntcart/

1. Verifies the licence you type with the licence server.
2. Fetches what the package does not carry — the new version's database migrations, its schema file and its Composer files — from the licence server, for that licence. They are released to a verified licence only, which is why no package holds them.
3. Unpacks the package over your installation.
4. Runs the migrations and clears the caches.

If the second step cannot be done — your server has no outbound access to license.codemynt.in, or the licence is refused — the update is refused with the licence server's own reason and nothing is changed, so you can put it right and try again.

What the package does and does not replace:

• .env — not in the package; your environment configuration stays as it is
• Modules/ — not in the package; your installed add-on modules stay as they are
• storage/ — the package carries only the demo shop's own pictures there. Your uploaded product images and files are not in it and are left alone
• Everything else is the product's own code and is replaced, public/assets/ included — keep a copy of any shipped file you changed yourself

Using the Software Update page

The form asks for four things before it will accept a package:

The page also checks two PHP limits and will not let you submit until both pass — it shows your current values next to the requirement:

• upload_max_filesize — 180M or more
• post_max_size — 200M or more

Update history

The Software Update page keeps the last 20 attempts — successful and refused alike — with the version it moved from and to, the package name, the files it extracted and the migrations it ran. Expand an entry to see the detail. It is the quickest way to answer "did that update actually apply?" and worth reading before contacting support.

php artisan route:cache

License Information

Regular License

• Use for a single end product (one website/domain)
• A lifetime license — it does not expire
• End product is free for end users (no paid access/subscription)
• Includes all source code, Flutter apps, and documentation
• Includes 6 months of support from CodeMynt, by e-mail or support ticket
• Lifetime updates for the purchased version

Extended License

• Use for a single end product where end users are charged (SaaS, subscription, paid marketplace)
• Everything in Regular License, plus:
• Permission to charge end users for access to the product

What's Included

Support Policy

What's Included in Support

• Bug fixes and troubleshooting for the product as-is
• Help with installation and configuration issues
• Guidance on product features and built-in functionality
• Assistance with updating to the latest version
• Module activation and license issues

What's NOT Included in Support

• Custom feature development or modifications
• Third-party plugin/service integration beyond what's built-in
• Server setup, hosting configuration, or domain management
• Design customization (CSS, theme modifications, custom layouts)
• Data migration from non-WooCommerce platforms
• Issues caused by modifying the source code

How to Get Support

Demo Access

Frequently Asked Questions