1806 lines
111 KiB
Python
1806 lines
111 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
IfixKart demo-data seeder (2026-11-16).
|
|
|
|
Seeds >=100 rows into every admin-panel data module across the three schemas
|
|
(ifixkartecommerceadmin / ifixkartcrm / ifixkartecommerce) reached through the
|
|
SSH tunnel on 127.0.0.1:3306.
|
|
|
|
- FK-safe ordering, schema-introspected inserts (fails loudly on missing NOT NULL cols)
|
|
- ULID ids (26-char) matching app conventions
|
|
- Status/stage values copied from the backend service code
|
|
- All demo rows tagged "[SEED-DEMO-20261116]" in notes columns where possible
|
|
- Refuses to run if CRM data already looks seeded, unless --force
|
|
|
|
Run: cd Backend && ./venv/bin/python scripts/seed_demo_data.py
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import random
|
|
import string
|
|
import sys
|
|
import time
|
|
from datetime import datetime, timedelta
|
|
|
|
import pymysql
|
|
|
|
DB_A = "ifixkartecommerceadmin"
|
|
DB_C = "ifixkartcrm"
|
|
DB_E = "ifixkartecommerce"
|
|
TENANT = "tenant_default"
|
|
TAG = "[SEED-DEMO-20261116]"
|
|
STAFF_PASSWORD = "Demo@Staff2026"
|
|
CUSTOMER_PASSWORD = "Demo@Cust2026"
|
|
|
|
random.seed(20261116)
|
|
|
|
# --------------------------------------------------------------------------- #
|
|
# ULID (Crockford base32, 26 chars) — matches python-ulid output format
|
|
# --------------------------------------------------------------------------- #
|
|
_B32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ"
|
|
_last_ulid_ts = [0]
|
|
|
|
|
|
def new_ulid() -> str:
|
|
ts_ms = int(time.time() * 1000)
|
|
if ts_ms <= _last_ulid_ts[0]:
|
|
ts_ms = _last_ulid_ts[0] + 1
|
|
_last_ulid_ts[0] = ts_ms
|
|
out = []
|
|
for i in range(9, -1, -1): # 48-bit time -> 10 chars
|
|
out.append(_B32[(ts_ms >> (5 * i)) & 31])
|
|
rnd = random.getrandbits(80)
|
|
for i in range(15, -1, -1): # 80-bit random -> 16 chars
|
|
out.append(_B32[(rnd >> (5 * i)) & 31])
|
|
return "".join(out)
|
|
|
|
|
|
def now() -> datetime:
|
|
return datetime.now()
|
|
|
|
|
|
def days_ago(n: int, hour=None, minute=None) -> datetime:
|
|
d = now() - timedelta(days=n)
|
|
if hour is not None:
|
|
d = d.replace(hour=hour % 24, minute=(minute or 0) % 60,
|
|
second=random.randint(0, 59), microsecond=0)
|
|
return d
|
|
|
|
|
|
def in_days(n: int) -> datetime:
|
|
return now() + timedelta(days=n)
|
|
|
|
|
|
def j(v) -> str:
|
|
return json.dumps(v, ensure_ascii=False)
|
|
|
|
|
|
# --------------------------------------------------------------------------- #
|
|
# Data pools
|
|
# --------------------------------------------------------------------------- #
|
|
FIRST = ["Adithiyan","Arun","Priya","Divya","Karthik","Vijay","Sneha","Rahul","Ananya","Harish",
|
|
"Meena","Sathish","Kavya","Deepak","Lakshmi","Manoj","Nithya","Praveen","Ramya","Sanjay",
|
|
"Geetha","Vignesh","Swathi","Ramesh","Bhavani","Kiran","Megha","Suresh","Pooja","Aruna",
|
|
"Vikram","Shalini","Naveen","Priyanka","Gokul","Revathi","Dinesh","Keerthi","Ashok","Banu"]
|
|
LAST = ["Kumar","Raj","Sharma","Patel","Iyer","Nair","Reddy","Rao","Singh","Das","Pillai","Verma",
|
|
"Naidu","Chauhan","Menon","Gupta","Joshi","Bose","Chandra","Mohan","Krishnan","Bala","Sekar",
|
|
"Rangan","Murugan","Pandian","Thevar","Vanniar"]
|
|
CITIES = [("Chennai","Tamil Nadu","600"),("Coimbatore","Tamil Nadu","641"),("Madurai","Tamil Nadu","625"),
|
|
("Trichy","Tamil Nadu","620"),("Salem","Tamil Nadu","636"),("Bengaluru","Karnataka","560"),
|
|
("Hyderabad","Telangana","500"),("Mumbai","Maharashtra","400"),("Pune","Maharashtra","411"),
|
|
("Delhi","Delhi","110"),("Kolkata","West Bengal","700"),("Ahmedabad","Gujarat","380"),
|
|
("Vellore","Tamil Nadu","632"),("Erode","Tamil Nadu","638"),("Thanjavur","Tamil Nadu","613")]
|
|
STREETS = ["Anna Nagar","T Nagar","Adyar","Velachery","Mugappair","Kodambakkam","Porur","Guindy",
|
|
"K K Nagar","Ashok Nagar","Perungudi","Sholinganallur","Vadapalani","Nungambakkam","Mylapore"]
|
|
DEVICES = [("Apple","iPhone 13","mobile"),("Apple","iPhone 14 Pro","mobile"),("Apple","iPhone 12","mobile"),
|
|
("Samsung","Galaxy S22","mobile"),("Samsung","Galaxy S21 FE","mobile"),("Samsung","Galaxy M33","mobile"),
|
|
("OnePlus","Nord CE 3","mobile"),("OnePlus","11R","mobile"),
|
|
("Xiaomi","Redmi Note 12","mobile"),("Xiaomi","Redmi 12C","mobile"),
|
|
("Vivo","V27","mobile"),("Oppo","Reno 10","mobile"),("Realme","Narzo 60","mobile"),
|
|
("Motorola","Moto G84","mobile"),("Google","Pixel 7a","mobile"),("Nothing","Phone (2)","mobile"),
|
|
("Apple","MacBook Air M2","laptop"),("Dell","Inspiron 15","laptop"),("HP","Pavilion 14","laptop"),
|
|
("Lenovo","ThinkPad E14","laptop"),("Asus","VivoBook 15","laptop"),
|
|
("Samsung","Galaxy Tab S8","tablet"),("Apple","iPad Air 5","tablet")]
|
|
ISSUES = ["Screen cracked after drop","Battery drains within 3 hours","Charging port loose / not charging",
|
|
"Water damage - device not powering on","Speaker sound muffled","Rear camera blurry / shaky",
|
|
"Device overheating while gaming","Motherboard dead - no display","Software hanging / boot loop",
|
|
"Fingerprint sensor not working","Microphone not audible on calls","Network signal dropping"]
|
|
COMPANIES = ["Sri Balaji Mobiles","Chennai Mobile Spares","Ganesh Communications","Sunrise Telecom",
|
|
"Vasan Electronics","Mobile Point India","SK Telecom Traders","Prime Parts Hub",
|
|
"National Mobile Mart","Deccan Spares","Metro Gadget Supply","Coastal Communications"]
|
|
BRAND_POOL = ["Honor","iQoo","Tecno","Infinix","Lava","Micromax","Nokia","Sony","Nubia","Asus ROG"]
|
|
ATTR_POOL = [("water_resistance_rating","Water Resistance Rating",["IP67","IP68","IP54","None"]),
|
|
("refresh_rate_hz","Refresh Rate (Hz)",["60","90","120","144"]),
|
|
("screen_size_inch","Screen Size (inch)",["6.1","6.5","6.7","13.3","14.0","15.6"]),
|
|
("ram_type","RAM Type",["LPDDR4X","LPDDR5","DDR4","DDR5"]),
|
|
("port_type","Port Type",["USB-C","Lightning","Micro USB","USB-A"]),
|
|
("weight_grams","Weight (grams)",["160","180","200","1200","1400"]),
|
|
("battery_capacity_mah","Battery Capacity (mAh)",["4000","4500","5000","5500"]),
|
|
("charger_wattage","Charger Wattage (W)",["18","25","33","65","120"]),
|
|
("front_camera_mp","Front Camera (MP)",["8","12","16","32"]),
|
|
("rear_camera_mp","Rear Camera (MP)",["12","48","50","64","108"]),
|
|
("processor_core","Processor Core",["Octa Core","Hexa Core","Deca Core"]),
|
|
("os_version","OS Version",["Android 13","Android 14","iOS 16","iOS 17","Windows 11"]),
|
|
("sim_slots","SIM Slots",["Single","Dual"]),
|
|
("network_band","Network Band",["4G","5G"]),
|
|
("material_grade","Material Grade",["OEM","A+","A","Compatible"]),
|
|
("panel_type","Panel Type",["AMOLED","OLED","TFT","IPS LCD"]),
|
|
("warranty_period","Warranty Period",["3 Months","6 Months","12 Months"]),
|
|
("connector_pitch","Connector Pitch",["0.25mm","0.3mm","0.5mm"]),
|
|
("flex_cable_type","Flex Cable Type",["Standard","Reinforced"]),
|
|
("color_variant","Color Variant",["Black","White","Blue","Silver"]),
|
|
("storage_capacity","Storage Capacity",["64GB","128GB","256GB","512GB"]),
|
|
("keyboard_layout","Keyboard Layout",["QWERTY","AZERTY"]),
|
|
("audio_jack","Audio Jack",["3.5mm","Type-C","None"]),
|
|
("fingerprint_type","Fingerprint Type",["In-display","Side-mounted","Rear","None"]),
|
|
("fast_charging","Fast Charging",["Yes","No"]),
|
|
("wireless_charging","Wireless Charging",["Yes","No"]),
|
|
("tcon_board","TCON Board",["Included","Not Included"]),
|
|
("frame_included","Frame Included",["With Frame","Without Frame"]),
|
|
("ic_chips","IC Chips",["Original IC","Copy IC"]),
|
|
("tempered_grade","Tempered Grade",["Tempered","Non-Tempered"]),
|
|
("screen_resolution","Screen Resolution",["HD+","FHD+","2K","4K"]),
|
|
("battery_cycle_count","Battery Cycle Count",["<300","300-500","500+"]),
|
|
("hinge_type","Hinge Type",["Standard","360°","Dual Hinge"]),
|
|
("touch_ic_model","Touch IC Model",["Generic","OEM Matched"]),
|
|
("backlight_type","Backlight Type",["LED","Mini-LED","None"]),
|
|
("screw_kit","Screw Kit",["Included","Not Included"]),
|
|
("voltage_rating","Voltage Rating",["3.7V","3.8V","7.6V","11.4V"]),
|
|
("region_code","Region Code",["IND","GULF","US","EU"])]
|
|
NOTE_PREFIXES = ["Walk-in enquiry","Follow-up pending","Discussed pricing over call","Repeat customer",
|
|
"Referred by existing client","Quotation shared on WhatsApp","Awaiting approval",
|
|
"Bulk order possibility","Warranty claim discussion","Priority handling requested"]
|
|
|
|
_used_phones: set[str] = set()
|
|
_used_emails: set[str] = set()
|
|
|
|
|
|
def phone() -> str:
|
|
while True:
|
|
p = "9" + "".join(random.choice(string.digits) for _ in range(9))
|
|
if p not in _used_phones:
|
|
_used_phones.add(p)
|
|
return p
|
|
|
|
|
|
def slug_email(fn: str, ln: str, domain="ifixkart-demo.com") -> str:
|
|
while True:
|
|
e = f"{fn.lower()}.{ln.lower()}{random.randint(100, 999)}@{domain}"
|
|
if e not in _used_emails:
|
|
_used_emails.add(e)
|
|
return e
|
|
|
|
|
|
def person():
|
|
fn, ln = random.choice(FIRST), random.choice(LAST)
|
|
return fn, ln, slug_email(fn, ln), phone()
|
|
|
|
|
|
def addr(city_idx=None):
|
|
ci = city_idx if city_idx is not None else random.randrange(len(CITIES))
|
|
city, state, pin = CITIES[ci]
|
|
return {"full_name": "", "phone": "", "street_address": f"{random.randint(1, 250)}, {random.choice(STREETS)} Street",
|
|
"city": city, "state": state, "pincode": f"{pin}{random.randint(100, 999)}",
|
|
"address_type": "SHIPPING"}
|
|
|
|
|
|
# --------------------------------------------------------------------------- #
|
|
# Generic insert helper with schema validation
|
|
# --------------------------------------------------------------------------- #
|
|
class Seeder:
|
|
def __init__(self):
|
|
self.conn = pymysql.connect(host="127.0.0.1", port=3306, user="Adithiyan",
|
|
password="Adithiyan$2025Mysql", charset="utf8mb4",
|
|
autocommit=False, connect_timeout=15)
|
|
self.conn.cursor().execute("SET SESSION sql_mode='STRICT_TRANS_TABLES'")
|
|
self._cols: dict[tuple, dict] = {}
|
|
|
|
def cols(self, db: str, table: str) -> dict:
|
|
key = (db, table)
|
|
if key not in self._cols:
|
|
cur = self.conn.cursor()
|
|
cur.execute(
|
|
"SELECT column_name, is_nullable, column_default, extra "
|
|
"FROM information_schema.columns WHERE table_schema=%s AND table_name=%s",
|
|
(db, table))
|
|
self._cols[key] = {r[0]: (r[1], r[2], r[3]) for r in cur.fetchall()}
|
|
return self._cols[key]
|
|
|
|
def insert(self, db: str, table: str, rows: list[dict], label="") -> int:
|
|
if not rows:
|
|
return 0
|
|
schema = self.cols(db, table)
|
|
missing = [k for k in rows[0] if k not in schema]
|
|
if missing:
|
|
raise RuntimeError(f"{db}.{table}: unknown columns {missing}")
|
|
required = [c for c, (nul, dflt, _x) in schema.items()
|
|
if nul == "NO" and dflt is None and "GENERATED" not in c]
|
|
absent = [c for c in required if c not in rows[0]]
|
|
if absent:
|
|
raise RuntimeError(f"{db}.{table}: NOT NULL without default not provided: {absent}")
|
|
use_cols = []
|
|
seen = set()
|
|
for r in rows:
|
|
for c in r:
|
|
if c not in seen:
|
|
seen.add(c)
|
|
use_cols.append(c)
|
|
sql = (f"INSERT INTO `{db}`.`{table}` (" + ",".join(f"`{c}`" for c in use_cols) + ") VALUES ("
|
|
+ ",".join(["%s"] * len(use_cols)) + ")")
|
|
cur = self.conn.cursor()
|
|
try:
|
|
cur.executemany(sql, [[r.get(c) for c in use_cols] for r in rows])
|
|
except Exception as e:
|
|
self.conn.rollback()
|
|
raise RuntimeError(f"{db}.{table} insert failed: {e}") from e
|
|
self.conn.commit()
|
|
print(f" {db}.{table:<38} +{cur.rowcount:>5} {label}")
|
|
return cur.rowcount
|
|
|
|
def fetch(self, sql, args=None):
|
|
cur = self.conn.cursor()
|
|
cur.execute(sql, args or ())
|
|
return cur.fetchall()
|
|
|
|
def scalar(self, sql, args=None):
|
|
cur = self.conn.cursor()
|
|
cur.execute(sql, args or ())
|
|
r = cur.fetchone()
|
|
return r[0] if r else None
|
|
|
|
|
|
S = Seeder()
|
|
|
|
|
|
def count(db, table) -> int:
|
|
return int(S.scalar(f"SELECT COUNT(*) FROM `{db}`.`{table}`") or 0)
|
|
|
|
|
|
def audit_fields(i=0):
|
|
return {"created_by": "seed-script", "updated_by": "seed-script", "version": 1}
|
|
|
|
|
|
# =========================================================================== #
|
|
# STAGE 1 — admin DB: roles, departments, designations, users
|
|
# =========================================================================== #
|
|
def stage_admin_staff():
|
|
print("STAGE 1: admin staff & org")
|
|
existing_roles = {r[0] for r in S.fetch(f"SELECT role_name FROM {DB_A}.roles")}
|
|
role_rows = []
|
|
for name, prefix, desc in [
|
|
("Admin", "ADMI", "Full admin access"), ("Store Manager", "SMGR", "Store operations"),
|
|
("Sales Executive", "SLEX", "Frontline sales"), ("CRM Executive", "CRMX", "CRM & pipeline"),
|
|
("Service Advisor", "SVAD", "Service counter"), ("Technician", "TECH", "Repairs"),
|
|
("Warehouse Executive", "WHSE", "Stock & dispatch"),
|
|
("Accountant", "ACCT", "Billing & GST"), ("Support Agent", "SUPT", "Customer support")]:
|
|
if name not in existing_roles:
|
|
role_rows.append({"role_id": new_ulid(), "role_name": name, "role_prefix": prefix,
|
|
"description": f"{desc} {TAG}", "is_system": 0, "is_active": 1})
|
|
# pad to >=100 with zone variants so the roles page has real list depth
|
|
if len(role_rows) < 100:
|
|
bases = ["Technician", "Sales Executive", "Support Agent", "Warehouse Executive",
|
|
"Service Advisor", "CRM Executive", "Store Manager", "Accountant"]
|
|
zone_idx = 0
|
|
for ci, (city, _st, _p) in enumerate(CITIES):
|
|
for bi, base in enumerate(bases):
|
|
zone_idx += 1
|
|
name = f"{base} - {city} Zone {ci % 3 + 1}.{bi + 1}"[:50]
|
|
if name in existing_roles:
|
|
continue
|
|
existing_roles.add(name)
|
|
role_rows.append({"role_id": new_ulid(), "role_name": name,
|
|
"role_prefix": f"Z{zone_idx:04d}"[:10],
|
|
"description": f"Zone-scoped {base.lower()} role {TAG}",
|
|
"is_system": 0, "is_active": 1})
|
|
if len(role_rows) >= 100:
|
|
break
|
|
if len(role_rows) >= 100:
|
|
break
|
|
S.insert(DB_A, "roles", role_rows)
|
|
|
|
existing_dep = {r[0] for r in S.fetch(f"SELECT name FROM {DB_A}.departments")}
|
|
dep_rows = [{"department_id": new_ulid(), "name": n, "description": f"{n} department {TAG}", "is_active": 1}
|
|
for n in ["Sales", "Service & Repair", "Warehouse & Logistics", "Finance & Accounts",
|
|
"Customer Support", "Marketing", "Human Resources"] if n not in existing_dep]
|
|
if len(dep_rows) < 100:
|
|
base_deps = ["Sales", "Service & Repair", "Warehouse & Logistics", "Finance & Accounts",
|
|
"Customer Support", "Marketing"]
|
|
dep_idx = 0
|
|
for suffix in ("", " East", " West"):
|
|
for ci, (city, _st, _p) in enumerate(CITIES):
|
|
for bd in base_deps:
|
|
dep_idx += 1
|
|
name = f"{bd} - {city}{suffix}"[:100]
|
|
if name in existing_dep:
|
|
continue
|
|
existing_dep.add(name)
|
|
dep_rows.append({"department_id": new_ulid(), "name": name,
|
|
"description": f"{bd} operations at {city} {TAG}", "is_active": 1})
|
|
if len(dep_rows) >= 100:
|
|
break
|
|
if len(dep_rows) >= 100:
|
|
break
|
|
if len(dep_rows) >= 100:
|
|
break
|
|
S.insert(DB_A, "departments", dep_rows)
|
|
|
|
existing_des = {r[0] for r in S.fetch(f"SELECT name FROM {DB_A}.designations")}
|
|
des_rows = [{"designation_id": new_ulid(), "name": n, "description": f"{n} {TAG}", "is_active": 1}
|
|
for n in ["Store Manager", "Sales Executive", "Senior Sales Executive", "CRM Executive",
|
|
"Service Center Manager", "Senior Technician", "Technician", "Junior Technician",
|
|
"Warehouse Executive", "Accountant", "Support Agent"] if n not in existing_des]
|
|
if len(des_rows) < 100:
|
|
base_des = ["Sales Executive", "Technician", "Support Agent", "Warehouse Executive"]
|
|
des_idx = 0
|
|
for grade in range(1, 30):
|
|
for bd in base_des:
|
|
des_idx += 1
|
|
name = f"{bd} - Grade {grade}"[:100]
|
|
if name in existing_des:
|
|
continue
|
|
existing_des.add(name)
|
|
des_rows.append({"designation_id": new_ulid(), "name": name,
|
|
"description": f"{bd} pay grade {grade} {TAG}", "is_active": 1})
|
|
if len(des_rows) >= 100:
|
|
break
|
|
if len(des_rows) >= 100:
|
|
break
|
|
S.insert(DB_A, "designations", des_rows)
|
|
|
|
roles = {r[1]: r[0] for r in S.fetch(f"SELECT role_id, role_name FROM {DB_A}.roles")}
|
|
deps = {r[1]: r[0] for r in S.fetch(f"SELECT department_id, name FROM {DB_A}.departments")}
|
|
dess = {r[1]: r[0] for r in S.fetch(f"SELECT designation_id, name FROM {DB_A}.designations")}
|
|
admin_id = S.scalar(f"SELECT user_id FROM {DB_A}.users WHERE email='admin@ifixkart.com'")
|
|
|
|
import passlib.context # noqa
|
|
from passlib.context import CryptContext
|
|
ctx = CryptContext(schemes=["argon2"], deprecated="auto")
|
|
staff_hash = ctx.hash(STAFF_PASSWORD)
|
|
|
|
role_plan = (["Technician"] * 100 + ["Sales Executive"] * 16 + ["Service Advisor"] * 8 +
|
|
["Store Manager"] * 6 + ["CRM Executive"] * 6 + ["Warehouse Executive"] * 4 +
|
|
["Support Agent"] * 4 + ["Accountant"] * 2 + ["Admin"] * 2)
|
|
random.shuffle(role_plan)
|
|
dept_map = {"Technician": "Service & Repair", "Sales Executive": "Sales",
|
|
"Service Advisor": "Service & Repair", "Store Manager": "Sales",
|
|
"CRM Executive": "Sales", "Warehouse Executive": "Warehouse & Logistics",
|
|
"Support Agent": "Customer Support", "Accountant": "Finance & Accounts",
|
|
"Admin": "Human Resources"}
|
|
desig_map = {"Technician": ["Technician", "Senior Technician", "Junior Technician"],
|
|
"Sales Executive": ["Sales Executive", "Senior Sales Executive"],
|
|
"Service Advisor": ["Service Center Manager"], "Store Manager": ["Store Manager"],
|
|
"CRM Executive": ["CRM Executive"], "Warehouse Executive": ["Warehouse Executive"],
|
|
"Support Agent": ["Support Agent"], "Accountant": ["Accountant"], "Admin": ["Store Manager"]}
|
|
start = int(S.scalar(
|
|
"SELECT COALESCE(MAX(CAST(SUBSTRING(employee_code, 4) AS UNSIGNED)), 0) "
|
|
f"FROM {DB_A}.users") or 0) + 1
|
|
users, tech_user_ids, sales_user_ids = [], [], []
|
|
for i, role in enumerate(role_plan):
|
|
fn, ln, email, ph = person()
|
|
uid = new_ulid()
|
|
desig = random.choice(desig_map[role])
|
|
users.append({"user_id": uid, "employee_code": f"ADM{start + i:04d}",
|
|
"first_name": fn, "last_name": ln, "display_name": f"{fn} {ln}",
|
|
"email": email, "phone": ph, "password_hash": staff_hash,
|
|
"gender": random.choice(["Male", "Female", None]),
|
|
"dob": days_ago(random.randint(9000, 13000)).date(),
|
|
"department_id": deps[dept_map[role]], "designation_id": dess[desig],
|
|
"role_id": roles[role], "manager_id": admin_id,
|
|
"is_active": 1, "email_verified": 1, "phone_verified": 1,
|
|
"failed_login_attempts": 0, "is_locked": 0})
|
|
(tech_user_ids if role == "Technician" else sales_user_ids).append(uid)
|
|
# a few managers without manager
|
|
for u in users[:6]:
|
|
u["manager_id"] = None
|
|
S.insert(DB_A, "users", users, "staff")
|
|
return {"users": users, "tech_user_ids": tech_user_ids, "sales_ids": sales_user_ids,
|
|
"roles": roles}
|
|
|
|
|
|
# =========================================================================== #
|
|
# STAGE 2 — locations, warehouses, suppliers, terminals, coupons, service types, parts
|
|
# =========================================================================== #
|
|
def stage_reference():
|
|
print("STAGE 2: reference data")
|
|
locs, whs, sups = [], [], []
|
|
for i in range(1, 101):
|
|
city, state, pin = CITIES[i % len(CITIES)]
|
|
lid = new_ulid()
|
|
locs.append({"location_id": lid, "tenant_id": TENANT, "code": f"LOC{i:03d}",
|
|
"name": f"iFixKart {city} Store {i:02d}",
|
|
"address": f"{random.randint(1, 200)}, {random.choice(STREETS)}, {city}",
|
|
"city": city, "state": state, "pincode": f"{pin}{random.randint(100, 999)}",
|
|
"phone": phone(), "email": f"store{i:02d}@ifixkart-demo.com",
|
|
"is_active": 1, "is_primary": 1 if i == 1 else 0,
|
|
"is_central_warehouse": 1 if i == 1 else 0,
|
|
"created_by": "seed-script", "updated_by": "seed-script", "version": 1})
|
|
wid = new_ulid()
|
|
whs.append({"warehouse_id": wid, "tenant_id": TENANT, "code": f"WH{i:03d}",
|
|
"name": f"{city} Warehouse {i:02d}",
|
|
"address": f"Industrial Estate Phase {random.randint(1, 3)}, {city}",
|
|
"city": city, "state": state, "is_primary": 1 if i == 1 else 0,
|
|
"created_by": "seed-script", "updated_by": "seed-script", "version": 1})
|
|
fn, ln = random.choice(FIRST), random.choice(LAST)
|
|
sups.append({"supplier_id": new_ulid(), "tenant_id": TENANT,
|
|
"company_name": f"{COMPANIES[i % len(COMPANIES)]} {('Pvt Ltd') if i % 2 else ('& Sons')} #{i:03d}",
|
|
"contact_name": f"{fn} {ln}", "phone": phone(),
|
|
"email": f"sales{i:03d}@supplier-demo.com",
|
|
"gstin": f"33AABC{random.randint(1000, 9999)}D1Z{random.randint(1, 9)}",
|
|
"address": f"{random.randint(1, 99)}, Wholesale Market, {city}",
|
|
"created_by": "seed-script", "updated_by": "seed-script", "version": 1})
|
|
S.insert(DB_E, "crm_locations", locs)
|
|
S.insert(DB_E, "crm_warehouses", whs)
|
|
S.insert(DB_E, "crm_suppliers", sups)
|
|
|
|
terms = [{"terminal_id": new_ulid(), "tenant_id": TENANT, "location_id": locs[i % 10]["location_id"],
|
|
"code": f"LOC{i % 10 + 1:03d}-T{i:03d}", "name": f"POS Terminal {i:03d}",
|
|
"is_active": 1 if i % 7 else 0,
|
|
"created_by": "seed-script", "updated_by": "seed-script", "version": 1}
|
|
for i in range(1, 101)]
|
|
S.insert(DB_E, "pos_terminals", terms)
|
|
|
|
sync_terms = [{"terminal_id": f"TERM-{i:05d}", "store_name": locs[i % 20]["name"],
|
|
"status": random.choice(["ONLINE", "ONLINE", "ONLINE", "OFFLINE", "SYNCING"]),
|
|
"ip_address": f"192.168.{random.randint(1, 8)}.{random.randint(2, 250)}",
|
|
"last_heartbeat": days_ago(0, random.randint(8, 20)),
|
|
"synced_today": random.randint(0, 40), "pending_queue": random.choice([0, 0, 0, 1, 2, 5]),
|
|
"created_at": days_ago(60), "updated_at": days_ago(0)}
|
|
for i in range(1, 101)]
|
|
S.insert(DB_E, "pos_sync_terminals", sync_terms)
|
|
|
|
coupons = []
|
|
curated = [("FEST10", "Festival 10% Off", "PERCENTAGE", 10), ("IFK100", "Flat Rs.100 Off", "FIXED", 100),
|
|
("NEWUSER50", "New User 50% Off", "PERCENTAGE", 50), ("SCREEN15", "Screen Combo 15% Off", "PERCENTAGE", 15),
|
|
("BATTERY20", "Battery 20% Off", "PERCENTAGE", 20), ("MONSOON25", "Monsoon 25% Off", "PERCENTAGE", 25),
|
|
("COMBO500", "Combo Rs.500 Off", "FIXED", 500), ("GSTSAVE5", "GST Saver 5%", "PERCENTAGE", 5),
|
|
("VIPFREE", "VIP Free Shipping", "FREE_SHIPPING", 0), ("FIRSTFIX", "First Repair 10% Off", "PERCENTAGE", 10),
|
|
("DIWALI30", "Diwali 30% Off", "PERCENTAGE", 30), ("REPAIR10", "Repair 10% Off", "PERCENTAGE", 10)]
|
|
rows = curated + [(f"IFK{i:03d}OFF", f"Promo Rs.{i * 10} Off", "FIXED", i * 10) for i in range(1, 99)]
|
|
for i, (code, title, dt, dv) in enumerate(rows[:110]):
|
|
active = i % 6 != 5
|
|
coupons.append({"coupon_id": new_ulid(), "code": code, "title": title,
|
|
"description": f"Demo coupon {code} {TAG}",
|
|
"discount_type": dt, "discount_value": dv,
|
|
"max_discount_cap": dv * 5 if dt == "PERCENTAGE" else None,
|
|
"min_order_amount": random.choice([0, 499, 999, 1999]),
|
|
"max_order_amount": None, "first_order_only": 1 if i % 4 == 0 else 0,
|
|
"channel_scope": random.choice(["ONLINE_ONLY", "POS_ONLY", "OMNICHANNEL"]),
|
|
"exclude_already_discounted": i % 3 == 0,
|
|
"valid_from": days_ago(30), "valid_to": in_days(60),
|
|
"usage_limit_total": random.choice([100, 500, 1000, None]),
|
|
"usage_limit_per_customer": random.choice([1, 1, 2]),
|
|
"times_used": 0 if not active else random.randint(0, 80),
|
|
"is_active": 1 if active else 0})
|
|
S.insert(DB_E, "coupons", coupons)
|
|
|
|
# CRM DB: service types +95, parts 110, contacts 110
|
|
existing_st = {r[0] for r in S.fetch(f"SELECT name FROM {DB_C}.service_types")}
|
|
svc_bases = ["Data Recovery", "Water Damage Treatment", "Motherboard Chip-Level Repair",
|
|
"Micro Soldering Service", "Screen Calibration", "Battery Health Restoration",
|
|
"Camera Module Calibration", "Speaker Diagnostics", "Charging Port Deep Cleaning",
|
|
"Software Reflash", "IMEI Correction Service", "Network Unlock"]
|
|
grades = ["Basic", "Standard", "Advanced", "Premium"]
|
|
kinds = ["Mobile", "Laptop", "Tablet", "Smartwatch", "TWS Earbuds", "Gaming Console", "Drone", "Camera"]
|
|
st_rows = []
|
|
for b in svc_bases:
|
|
for g in grades:
|
|
for k in kinds:
|
|
if len(st_rows) >= 95:
|
|
break
|
|
name = f"{b} - {g} ({k})"
|
|
if name in existing_st:
|
|
continue
|
|
existing_st.add(name)
|
|
st_rows.append({"service_type_id": new_ulid(), "name": name,
|
|
"slug": name.lower().replace(" ", "-").replace("(", "").replace(")", ""),
|
|
"description": f"{g} tier {b.lower()} for {k.lower()} devices. {TAG}",
|
|
"is_active": 1})
|
|
if len(st_rows) >= 95:
|
|
break
|
|
S.insert(DB_C, "service_types", st_rows)
|
|
all_st = [r[0] for r in S.fetch(f"SELECT service_type_id FROM {DB_C}.service_types")]
|
|
tag_st = [r[0] for r in S.fetch(
|
|
f"SELECT service_type_id FROM {DB_C}.service_types WHERE description LIKE %s", (f"%{TAG}%",))]
|
|
|
|
parts = []
|
|
part_names = ["Display Combo", "Battery", "Charging Flex", "Back Glass", "Camera Module",
|
|
"Speaker Set", "Motherboard", "Power Button Flex", "Volume Flex", "Front Camera",
|
|
"Earpiece Speaker", "Loud Speaker", "Vibration Motor", "SIM Tray", "Mic Flex",
|
|
"Proximity Sensor", "Home Button", "Fingerprint Flex", "NFC Antenna", "Wireless Coil"]
|
|
for i in range(1, 111):
|
|
dev = random.choice(DEVICES)
|
|
pn = random.choice(part_names)
|
|
parts.append({"part_id": new_ulid(), "sku": f"PART-{i:04d}-{random.randint(100, 999)}",
|
|
"name": f"{pn} for {dev[0]} {dev[1]}",
|
|
"cost_price": round(random.uniform(150, 9500), 2),
|
|
"low_stock_alert": 5, "supplier": sups[i % 100]["company_name"],
|
|
"barcode": f"8900001{i:05d}", "is_active": 1 if i % 9 else 0})
|
|
S.insert(DB_C, "parts", parts)
|
|
|
|
contacts, caddrs = [], []
|
|
for i in range(1, 111):
|
|
fn, ln, email, ph = person()
|
|
cid = new_ulid()
|
|
contacts.append({"contact_id": cid, "first_name": fn, "last_name": ln, "email": email,
|
|
"phone": ph, "gender": random.choice(["Male", "Female"]),
|
|
"dob": days_ago(random.randint(8000, 15000)).date(),
|
|
"created_at": days_ago(random.randint(1, 90))})
|
|
city, state, pin = CITIES[i % len(CITIES)]
|
|
caddrs.append({"address_id": new_ulid(), "contact_id": cid, "type": random.choice(["BILLING", "SHIPPING"]),
|
|
"address_line1": f"{random.randint(1, 300)}, {random.choice(STREETS)}",
|
|
"city": city, "state": state, "country": "India",
|
|
"postal_code": f"{pin}{random.randint(100, 999)}", "is_default": 1})
|
|
S.insert(DB_C, "contacts", contacts)
|
|
S.insert(DB_C, "contact_addresses", caddrs)
|
|
return {"locations": locs, "warehouses": whs, "suppliers": sups, "terminals": terms,
|
|
"sync_terms": sync_terms, "coupons": coupons, "service_types": all_st,
|
|
"tag_service_types": tag_st,
|
|
"parts": parts, "staff_contacts": contacts}
|
|
|
|
|
|
# =========================================================================== #
|
|
# STAGE 3 — customers (ecom + crm), addresses, devices
|
|
# =========================================================================== #
|
|
def stage_customers():
|
|
print("STAGE 3: customers & devices")
|
|
from passlib.context import CryptContext
|
|
ctx = CryptContext(schemes=["argon2"], deprecated="auto")
|
|
cust_hash = ctx.hash(CUSTOMER_PASSWORD)
|
|
|
|
ecoms, eadds, edevs = [], [], []
|
|
ecom_ids = []
|
|
for i in range(1, 120):
|
|
fn, ln = random.choice(FIRST), random.choice(LAST)
|
|
email = slug_email(fn, ln)
|
|
cid = new_ulid()
|
|
ecom_ids.append(cid)
|
|
ecoms.append({"customer_id": cid, "email": email, "password_hash": cust_hash,
|
|
"first_name": fn, "last_name": ln, "phone": phone(),
|
|
"is_active": 1, "email_verified": 1, "phone_verified": 1,
|
|
"failed_login_attempts": 0, "is_locked": 0,
|
|
"last_login": days_ago(random.randint(0, 30), random.randint(9, 21)),
|
|
"created_at": days_ago(random.randint(5, 200)), "updated_at": days_ago(0)})
|
|
n_addr = random.choice([1, 1, 1, 2])
|
|
for a in range(n_addr):
|
|
ad = addr()
|
|
ad.update({"address_id": new_ulid(), "customer_id": cid,
|
|
"address_type": "SHIPPING" if a == 0 else random.choice(["SHIPPING", "BILLING"]),
|
|
"full_name": f"{fn} {ln}", "phone": phone(),
|
|
"is_default": 1 if a == 0 else 0, "created_at": days_ago(random.randint(1, 100))})
|
|
eadds.append(ad)
|
|
if i <= 130:
|
|
dev = random.choice(DEVICES)
|
|
edevs.append({"device_id": new_ulid(), "customer_id": cid, "brand": dev[0],
|
|
"model": dev[1], "model_number": f"SM-{random.randint(10000, 99999)}",
|
|
"imei_primary": "".join(random.choice(string.digits) for _ in range(15)),
|
|
"color": random.choice(["Black", "White", "Blue", "Silver", "Gold"]),
|
|
"device_condition": random.choice(["Good", "Fair", "Cracked back", "Scratched body"]),
|
|
"device_type": dev[2],
|
|
"storage_capacity": random.choice(["64GB", "128GB", "256GB"]),
|
|
"created_at": days_ago(random.randint(1, 120)), "updated_at": days_ago(0)})
|
|
S.insert(DB_E, "ecom_customers", ecoms, "storefront customers")
|
|
S.insert(DB_E, "customer_addresses", eadds)
|
|
S.insert(DB_E, "customer_devices", edevs)
|
|
|
|
# CRM customers (36-char ULIDs per schema; keep same generator output)
|
|
crm_c, crm_devs, crm_conts = [], [], []
|
|
crm_ids = []
|
|
for i in range(1, 121):
|
|
fn, ln, email, ph = person()
|
|
cid = new_ulid()
|
|
crm_ids.append(cid)
|
|
ltv = round(random.choice([random.uniform(500, 9000), random.uniform(10000, 45000),
|
|
random.uniform(50000, 95000), random.uniform(100000, 300000)]), 2)
|
|
o_count = random.randint(0, 12) if ltv > 5000 else random.randint(0, 2)
|
|
r_count = random.randint(0, 10) if ltv > 3000 else random.randint(0, 2)
|
|
crm_c.append({"customer_id": cid, "tenant_id": TENANT, "name": f"{fn} {ln}",
|
|
"email": email, "phone": ph,
|
|
"sales_tier": ("PLATINUM" if ltv >= 100000 else "GOLD" if ltv >= 50000
|
|
else "SILVER" if ltv >= 10000 else "BRONZE"),
|
|
"service_tier": random.choice(["STANDARD"] * 7 + ["PRIORITY"] * 2 + ["VIP"]),
|
|
"total_orders_count": o_count, "total_repairs_count": r_count,
|
|
"total_lifetime_value_inr": ltv, "is_dual_customer": 1 if (o_count and r_count) else 0,
|
|
"notes": f"{random.choice(NOTE_PREFIXES)} {TAG}",
|
|
"created_by": "seed-script", "updated_by": "seed-script", "version": 1})
|
|
city, state, pin = CITIES[i % len(CITIES)]
|
|
crm_conts.append({"contact_id": new_ulid(), "tenant_id": TENANT, "customer_id": cid,
|
|
"address": f"{random.randint(1, 300)}, {random.choice(STREETS)}",
|
|
"city": city, "state": state, "pincode": f"{pin}{random.randint(100, 999)}",
|
|
"alternate_phone": phone(),
|
|
"created_by": "seed-script", "updated_by": "seed-script", "version": 1})
|
|
for d in range(random.choice([1, 1, 1, 2])):
|
|
dev = random.choice(DEVICES)
|
|
crm_devs.append({"device_id": new_ulid(), "tenant_id": TENANT, "customer_id": cid,
|
|
"brand": dev[0], "model_name": dev[1],
|
|
"color": random.choice(["Black", "White", "Blue", "Silver"]),
|
|
"imei_serial": "".join(random.choice(string.digits) for _ in range(15)),
|
|
"cosmetic_condition": random.choice(["Good", "Fair", "Poor"]),
|
|
"notes": f"Registered at store. {TAG}",
|
|
"created_by": "seed-script", "updated_by": "seed-script", "version": 1})
|
|
S.insert(DB_E, "crm_customers", crm_c, "crm customers")
|
|
S.insert(DB_E, "crm_contacts", crm_conts)
|
|
S.insert(DB_E, "crm_customer_devices", crm_devs)
|
|
return {"ecom_ids": ecom_ids, "crm_ids": crm_ids, "crm_devs": crm_devs, "edevs": edevs}
|
|
|
|
|
|
# =========================================================================== #
|
|
# STAGE 4 — CRM pipeline: leads, deals, tasks, calendar, quotations, GST invoices
|
|
# =========================================================================== #
|
|
def stage_pipeline(staff, refs, custs):
|
|
print("STAGE 4: CRM pipeline")
|
|
sales_ids = staff["sales_ids"] or [staff["users"][0]["user_id"]]
|
|
crm_ids = custs["crm_ids"]
|
|
variants = [(r[0], r[1], float(r[2]), r[3], r[4]) for r in S.fetch(
|
|
f"SELECT v.variant_id, v.sku, v.price, p.name, p.product_id "
|
|
f"FROM {DB_E}.product_variants v JOIN {DB_E}.products p ON p.product_id=v.product_id "
|
|
f"WHERE v.status='active' LIMIT 1500")]
|
|
|
|
leads = []
|
|
for i in range(1, 121):
|
|
fn, ln, email, ph = person()
|
|
dev = random.choice(DEVICES)
|
|
status = random.choice(["NEW"] * 3 + ["CONTACTED"] * 3 + ["QUALIFIED"] * 2 +
|
|
["QUOTE_DRAFT"] + ["QUOTE_SENT"] * 2 + ["CONVERTED"] * 2 + ["LOST"])
|
|
lid = new_ulid()
|
|
row = {"lead_id": lid, "tenant_id": TENANT,
|
|
"customer_id": random.choice(crm_ids) if i % 3 == 0 else None,
|
|
"title": f"{dev[0]} {dev[1]} - {random.choice(ISSUES)}",
|
|
"phone": ph, "email": email, "first_name": fn, "last_name": ln,
|
|
"source": random.choice(["STOREFRONT", "WHATSAPP", "WALK_IN", "PHONE", "SOCIAL"]),
|
|
"status": status, "score": random.randint(10, 95),
|
|
"assigned_user_id": random.choice(sales_ids),
|
|
"notes": f"{random.choice(NOTE_PREFIXES)} {TAG}",
|
|
"created_by": "seed-script", "updated_by": "seed-script", "version": 1}
|
|
if status in ("QUOTE_DRAFT", "QUOTE_SENT", "CONVERTED"):
|
|
amt = round(random.uniform(1200, 25000), 2)
|
|
row.update({"quote_amount": amt,
|
|
"quote_title": f"{dev[1]} repair & spares quote",
|
|
"quote_terms": "50% advance, balance on delivery. 6-month service warranty.",
|
|
"quote_sent_at": days_ago(random.randint(1, 20)),
|
|
"quote_sent_by": random.choice(sales_ids)})
|
|
leads.append(row)
|
|
S.insert(DB_E, "crm_leads", leads)
|
|
|
|
deals = []
|
|
stage_prob = {"NEW": 15, "CONTACTED": 30, "REQUIREMENT_AUDIT": 40, "PROPOSAL_SENT": 55,
|
|
"NEGOTIATION": 65, "BULK_QUOTE_SENT": 60, "CLOSED_WON": 100, "CLOSED_LOST": 0,
|
|
"WON": 100, "LOST": 0}
|
|
stages = (["NEW"] * 14 + ["CONTACTED"] * 16 + ["REQUIREMENT_AUDIT"] * 12 +
|
|
["PROPOSAL_SENT"] * 14 + ["NEGOTIATION"] * 12 + ["BULK_QUOTE_SENT"] * 10 +
|
|
["CLOSED_WON"] * 16 + ["CLOSED_LOST"] * 16)
|
|
random.shuffle(stages)
|
|
for i, st in enumerate(stages[:110]):
|
|
deals.append({"deal_id": new_ulid(), "tenant_id": TENANT,
|
|
"lead_id": leads[i % 120]["lead_id"] if i < 90 else None,
|
|
"customer_id": random.choice(crm_ids) if i % 2 else None,
|
|
"title": f"{random.choice(DEVICES)[1]} bulk supply / repair deal {i + 1:03d}",
|
|
"stage": st, "estimated_value": round(random.uniform(3000, 150000), 2),
|
|
"probability_percent": stage_prob[st],
|
|
"assigned_user_id": random.choice(sales_ids),
|
|
"notes": f"{random.choice(NOTE_PREFIXES)} {TAG}",
|
|
"created_by": "seed-script", "updated_by": "seed-script", "version": 1})
|
|
S.insert(DB_E, "crm_deals", deals)
|
|
|
|
tasks = []
|
|
for i in range(1, 111):
|
|
etype = random.choice(["LEAD", "DEAL", "REPAIR_TICKET", "CUSTOMER", "ORDER", "QUOTATION"])
|
|
eid = {"LEAD": lambda: random.choice(leads)["lead_id"], "DEAL": lambda: random.choice(deals)["deal_id"],
|
|
"CUSTOMER": lambda: random.choice(crm_ids)}.get(etype, lambda: new_ulid())()
|
|
done = i % 3 == 0
|
|
tasks.append({"task_id": new_ulid(), "tenant_id": TENANT,
|
|
"location_id": random.choice(refs["locations"][:10])["location_id"],
|
|
"title": random.choice(["Follow up call", "Send revised quotation", "Collect device from customer",
|
|
"Prepare GST invoice", "Stock count for spares", "Technician handover",
|
|
"Customer feedback call", "Payment reminder call"]),
|
|
"description": f"Auto-generated follow-up task {TAG}",
|
|
"assignee_id": random.choice(sales_ids),
|
|
"entity_type": etype, "entity_id": eid,
|
|
"priority": random.choice(["HIGH"] * 2 + ["MEDIUM"] * 5 + ["LOW"] * 2),
|
|
"status": "COMPLETED" if done else "PENDING",
|
|
"due_at": in_days(random.randint(-10, 14)) if not done else days_ago(random.randint(1, 10)),
|
|
"completed_at": days_ago(random.randint(1, 9)) if done else None,
|
|
"created_by": "seed-script", "updated_by": "seed-script", "version": 1})
|
|
S.insert(DB_E, "crm_tasks", tasks)
|
|
|
|
events = []
|
|
for i in range(1, 111):
|
|
start = now() + timedelta(days=random.randint(-20, 20), hours=random.randint(9, 17), minutes=random.choice([0, 30]))
|
|
linked = i % 4 == 0
|
|
st = "SCHEDULED" if start > now() else random.choice(["COMPLETED"] * 3 + ["CANCELLED"])
|
|
events.append({"event_id": new_ulid(), "tenant_id": TENANT,
|
|
"location_id": random.choice(refs["locations"][:10])["location_id"],
|
|
"task_id": random.choice(tasks)["task_id"] if i % 5 == 0 else None,
|
|
"title": random.choice(["Customer visit", "Device pickup", "Quotation review meeting",
|
|
"Vendor meeting", "Store audit", "Technician briefing",
|
|
"Delivery coordination", "Bulk client demo"]),
|
|
"description": f"Calendar demo event {TAG}",
|
|
"source_type": "REPAIR_TICKET" if linked else "MANUAL",
|
|
"source_id": new_ulid() if linked else None,
|
|
"start_time": start, "end_time": start + timedelta(minutes=random.choice([30, 45, 60, 90])),
|
|
"is_all_day": 0, "status": st,
|
|
"created_by": "seed-script", "updated_by": "seed-script", "version": 1})
|
|
S.insert(DB_E, "crm_calendar_events", events)
|
|
|
|
quotes, qitems = [], []
|
|
used_qn = set()
|
|
for i in range(1, 111):
|
|
qid = new_ulid()
|
|
while True:
|
|
qn = f"IFK-QT-2026-{random.randint(100, 999)}"
|
|
if qn not in used_qn:
|
|
used_qn.add(qn)
|
|
break
|
|
gross = 0.0
|
|
taxable_sum, tax_sum = 0.0, 0.0
|
|
items = []
|
|
for k in range(random.randint(1, 4)):
|
|
_v, sku, price, name, _p = random.choice(variants)
|
|
qty = random.randint(1, 10)
|
|
tp = round(price * qty, 2)
|
|
tax_pct = random.choice([18, 18, 18, 12, 28])
|
|
taxable = round(tp / (1 + tax_pct / 100), 2)
|
|
gross += tp
|
|
taxable_sum += taxable
|
|
tax_sum += (tp - taxable)
|
|
items.append({"item_id": new_ulid(), "quote_id": qid, "sku": sku,
|
|
"description": name[:250], "quantity": qty,
|
|
"unit_price": price, "tax_percent": tax_pct, "total_price": tp,
|
|
"created_by": "seed-script", "updated_by": "seed-script", "version": 1})
|
|
discount = round(random.choice([0, 0, 0, gross * 0.05]), 2)
|
|
grand = round(taxable_sum + tax_sum - discount, 2)
|
|
status = random.choice(["DRAFT"] * 3 + ["SENT"] * 4 + ["ACCEPTED"] * 2 + ["CONVERTED"] * 2 + ["EXPIRED"])
|
|
quotes.append({"quote_id": qid, "quote_number": qn, "tenant_id": TENANT,
|
|
"customer_id": random.choice(crm_ids), "status": status,
|
|
"valid_until": in_days(random.choice([7, 15, 30])),
|
|
"subtotal": round(taxable_sum, 2), "discount_amount": discount,
|
|
"tax_amount": round(tax_sum, 2), "grand_total": grand,
|
|
"notes": f"Bulk quotation demo {TAG}",
|
|
"created_by": "seed-script", "updated_by": "seed-script", "version": 1})
|
|
qitems.extend(items)
|
|
S.insert(DB_E, "crm_bulk_quotations", quotes)
|
|
S.insert(DB_E, "crm_bulk_quotation_items", qitems)
|
|
|
|
ginv, gitems = [], []
|
|
used_inv = set()
|
|
for i in range(1, 111):
|
|
iid = new_ulid()
|
|
while True:
|
|
ino = f"IFK-INV-2026-{random.randint(1000, 9999)}"
|
|
if ino not in used_inv:
|
|
used_inv.add(ino)
|
|
break
|
|
itype = random.choice(["RETAIL"] * 6 + ["B2B"] * 3 + ["PROFORMA"])
|
|
gross = 0.0
|
|
taxable_sum, tax_sum = 0.0, 0.0
|
|
items = []
|
|
for k in range(random.randint(1, 4)):
|
|
_v, sku, price, name, _p = random.choice(variants)
|
|
qty = random.randint(1, 8)
|
|
tp = round(price * qty, 2)
|
|
tax_pct = random.choice([18, 18, 12, 28])
|
|
taxable = round(tp / (1 + tax_pct / 100), 2)
|
|
gross += tp
|
|
taxable_sum += taxable
|
|
tax_sum += (tp - taxable)
|
|
items.append({"item_id": new_ulid(), "invoice_id": iid, "sku": sku,
|
|
"description": name[:250], "hsn_sac_code": random.choice(["8517", "8471", "8544", "8507"]),
|
|
"imei_serial": "".join(random.choice(string.digits) for _ in range(15)) if itype == "RETAIL" else None,
|
|
"quantity": qty, "unit_price": price, "tax_percent": tax_pct,
|
|
"warranty_months": random.choice([3, 6, 12]), "total_price": tp,
|
|
"created_by": "seed-script", "updated_by": "seed-script", "version": 1})
|
|
discount = round(random.choice([0, 0, gross * 0.03]), 2)
|
|
grand = round(taxable_sum + tax_sum - discount, 2)
|
|
pay_status = random.choice(["PAID"] * 5 + ["UNPAID"] * 3 + ["PARTIAL"] * 2)
|
|
paid = {"PAID": grand, "PARTIAL": round(grand * 0.5, 2), "UNPAID": 0.0}[pay_status]
|
|
tax_h = round(tax_sum / 2, 2)
|
|
ginv.append({"invoice_id": iid, "invoice_number": ino, "tenant_id": TENANT,
|
|
"customer_id": random.choice(crm_ids), "invoice_type": itype,
|
|
"subtotal": round(taxable_sum, 2), "discount_amount": discount,
|
|
"cgst_amount": tax_h, "sgst_amount": tax_h, "igst_amount": 0.0,
|
|
"grand_total": grand, "payment_status": pay_status, "paid_amount": paid,
|
|
"notes": f"GST invoice demo {TAG}",
|
|
"created_by": "seed-script", "updated_by": "seed-script", "version": 1})
|
|
gitems.extend(items)
|
|
S.insert(DB_E, "crm_gst_invoices", ginv)
|
|
S.insert(DB_E, "crm_invoice_items", gitems)
|
|
return {"leads": leads, "deals": deals, "variants": variants}
|
|
|
|
|
|
# =========================================================================== #
|
|
# STAGE 5 — orders, items, history, invoices, payments, wallets
|
|
# =========================================================================== #
|
|
def stage_orders(refs, custs, staff):
|
|
print("STAGE 5: orders & billing")
|
|
ecom_ids = custs["ecom_ids"]
|
|
eaddr = {r[1]: r for r in S.fetch(
|
|
f"SELECT address_id, customer_id, full_name, phone, street_address, city, state, pincode "
|
|
f"FROM {DB_E}.customer_addresses WHERE is_default=1")}
|
|
variants = [(r[0], r[1], float(r[2]), r[3], r[4]) for r in S.fetch(
|
|
f"SELECT v.variant_id, v.sku, v.price, p.name, p.product_id "
|
|
f"FROM {DB_E}.product_variants v JOIN {DB_E}.products p ON p.product_id=v.product_id "
|
|
f"WHERE v.status='active' LIMIT 1500")]
|
|
coupons_active = [c for c in refs["coupons"] if c["is_active"]]
|
|
used_inv_nos = set()
|
|
used_ord = {r[0] for r in S.fetch(f"SELECT order_no FROM {DB_E}.orders")}
|
|
day_seq: dict[str, int] = {}
|
|
|
|
def next_order_no(d: datetime) -> str:
|
|
key = d.strftime("%Y%m%d")
|
|
while True:
|
|
day_seq[key] = day_seq.get(key, 100 if key == "20261115" else 0) + 1
|
|
no = f"ORD-{key}-{day_seq[key]:04d}"
|
|
if no not in used_ord:
|
|
used_ord.add(no)
|
|
return no
|
|
|
|
orders, items, hist, invs, pays, usages = [], [], [], [], [], []
|
|
inv_seq = 10
|
|
for i in range(1, 121):
|
|
days_back = int((i / 121) ** 1.2 * 62)
|
|
created = days_ago(days_back, random.randint(9, 21), random.randint(0, 59))
|
|
cust_id = random.choice(ecom_ids)
|
|
n_items = random.choice([1, 1, 2, 2, 3])
|
|
subtotal, its = 0.0, []
|
|
picked = random.sample(variants, n_items)
|
|
for v_id, sku, price, name, p_id in picked:
|
|
qty = random.randint(1, 2) if random.random() < 0.25 else 1
|
|
tp = round(price * qty, 2)
|
|
subtotal += tp
|
|
its.append({"item_id": new_ulid(), "product_id": p_id, "variant_id": v_id,
|
|
"product_name": name[:250], "sku": sku, "unit_price": price,
|
|
"quantity": qty, "total_price": tp, "part_numbers": None})
|
|
tax = round(subtotal - subtotal / 1.18, 2)
|
|
coupon = random.choice(coupons_active) if random.random() < 0.15 else None
|
|
discount = 0.0
|
|
if coupon:
|
|
discount = (round(subtotal * coupon["discount_value"] / 100, 2)
|
|
if coupon["discount_type"] == "PERCENTAGE" else float(coupon["discount_value"]))
|
|
discount = min(discount, subtotal)
|
|
shipping = 99.0
|
|
final_amt = round(subtotal + shipping - discount, 2)
|
|
age = (now() - created).days
|
|
if age < 2:
|
|
st = random.choice(["ORDER_CREATED", "ORDER_CONFIRMED", "PROCESSING"])
|
|
elif age < 5:
|
|
st = random.choice(["PROCESSING", "PACKED", "SHIPPED", "OUT_FOR_DELIVERY", "DELIVERED"])
|
|
else:
|
|
st = random.choice(["DELIVERED"] * 6 + ["SHIPPED"] + ["CANCELLED"] * 2 + ["DELIVERED"])
|
|
pay_st = ("PAYMENT_PENDING" if st in ("ORDER_CREATED", "ORDER_CONFIRMED")
|
|
else "PAYMENT_FAILED" if st == "CANCELLED" and random.random() < 0.6
|
|
else "PAYMENT_CAPTURED")
|
|
oid = new_ulid()
|
|
ad = eaddr.get(cust_id)
|
|
if not ad:
|
|
ad_rows = S.fetch(
|
|
f"SELECT full_name, phone, street_address, city, state, pincode "
|
|
f"FROM {DB_E}.customer_addresses WHERE customer_id=%s LIMIT 1", (cust_id,))
|
|
ad = ad_rows[0] if ad_rows else None
|
|
addr_j = j({"full_name": ad[0], "phone": ad[1], "street_address": ad[2],
|
|
"city": ad[3], "state": ad[4], "pincode": ad[5], "address_type": "SHIPPING"}) if ad else \
|
|
j({"full_name": "Demo Customer", "phone": "9000000000", "street_address": "Demo Street",
|
|
"city": "Chennai", "state": "Tamil Nadu", "pincode": "600001", "address_type": "SHIPPING"})
|
|
shipped = st in ("SHIPPED", "OUT_FOR_DELIVERY", "DELIVERED")
|
|
orders.append({"order_id": oid, "order_no": next_order_no(created), "customer_id": cust_id,
|
|
"total_amount": round(subtotal, 2), "discount_amount": round(discount, 2),
|
|
"tax_amount": tax, "shipping_cost": shipping, "final_amount": final_amt,
|
|
"status": st, "payment_status": pay_st,
|
|
"fulfillment_status": "FULFILLED" if st == "DELIVERED" else
|
|
("READY_FOR_DELIVERY" if st == "OUT_FOR_DELIVERY" else "UNFULFILLED"),
|
|
"shipping_address_json": addr_j, "billing_address_json": addr_j,
|
|
"tracking_number": f"SR{random.randint(10 ** 11, 10 ** 12)}" if shipped else None,
|
|
"courier_name": random.choice(["Delhivery", "Blue Dart", "DTDC"]) if shipped else None,
|
|
"logistics_provider": "SHIPROCKET", "pickup_scheduled": 0,
|
|
"last_logistics_status": "DELIVERED" if st == "DELIVERED" else None,
|
|
"created_at": created, "updated_at": min(created + timedelta(hours=48), now()),
|
|
"coupon_id": coupon["coupon_id"] if coupon else None,
|
|
"coupon_code": coupon["code"] if coupon else None,
|
|
"discount_type": "FIXED", "discount_reason": None,
|
|
"is_discounted": 1 if coupon else 0})
|
|
for it in its:
|
|
it["order_id"] = oid
|
|
items.extend(its)
|
|
# status history
|
|
path = {"DELIVERED": ["ORDER_CREATED", "ORDER_CONFIRMED", "PROCESSING", "PACKED", "SHIPPED", "OUT_FOR_DELIVERY", "DELIVERED"],
|
|
"OUT_FOR_DELIVERY": ["ORDER_CREATED", "ORDER_CONFIRMED", "PROCESSING", "PACKED", "SHIPPED", "OUT_FOR_DELIVERY"],
|
|
"SHIPPED": ["ORDER_CREATED", "ORDER_CONFIRMED", "PROCESSING", "PACKED", "SHIPPED"],
|
|
"PACKED": ["ORDER_CREATED", "ORDER_CONFIRMED", "PROCESSING", "PACKED"],
|
|
"PROCESSING": ["ORDER_CREATED", "ORDER_CONFIRMED", "PROCESSING"],
|
|
"ORDER_CONFIRMED": ["ORDER_CREATED", "ORDER_CONFIRMED"],
|
|
"ORDER_CREATED": ["ORDER_CREATED"],
|
|
"CANCELLED": ["ORDER_CREATED", "ORDER_CONFIRMED", "CANCELLED"]}[st]
|
|
prev = "NEW"
|
|
for k, s in enumerate(path):
|
|
hist.append({"history_id": new_ulid(), "order_id": oid, "previous_status": prev,
|
|
"new_status": s, "changed_by": "SYSTEM" if k else "customer",
|
|
"reason": "Demo seed history", "created_at": created + timedelta(hours=k * 14)})
|
|
prev = s
|
|
if pay_st in ("PAYMENT_CAPTURED", "PAYMENT_PENDING", "PAYMENT_FAILED"):
|
|
pays.append({"payment_id": new_ulid(), "order_id": oid,
|
|
"provider": "RAZORPAY" if random.random() < 0.8 else "CASH",
|
|
"transaction_ref": f"pay_demo{random.randint(10 ** 10, 10 ** 11)}" if pay_st != "PAYMENT_PENDING" else None,
|
|
"razorpay_order_id": f"order_demo{random.randint(10 ** 10, 10 ** 11)}" if pay_st != "PAYMENT_PENDING" else None,
|
|
"razorpay_signature": None, "amount": final_amt, "currency": "INR",
|
|
"status": "CAPTURED" if pay_st == "PAYMENT_CAPTURED" else
|
|
("FAILED" if pay_st == "PAYMENT_FAILED" else "PENDING"),
|
|
"raw_response_json": j({"demo": True, TAG: True}),
|
|
"created_at": created})
|
|
if pay_st == "PAYMENT_CAPTURED" and inv_seq < 100 + 10:
|
|
inv_seq += 1
|
|
ino = f"C1P1-26-{inv_seq:06d}"
|
|
used_inv_nos.add(ino)
|
|
invs.append({"invoice_id": new_ulid(), "invoice_no": ino, "order_id": oid,
|
|
"pos_transaction_id": None, "customer_id": cust_id,
|
|
"subtotal": round(subtotal, 2), "discount_amount": round(discount, 2),
|
|
"cgst": round(tax / 2, 2), "sgst": round(tax / 2, 2), "igst": 0.0,
|
|
"total_amount": final_amt, "pdf_path": None, "status": "GENERATED",
|
|
"created_at": created + timedelta(hours=1)})
|
|
if coupon:
|
|
usages.append({"usage_id": new_ulid(), "coupon_id": coupon["coupon_id"],
|
|
"customer_id": cust_id, "order_id": oid,
|
|
"discount_amount": round(discount, 2), "used_at": created})
|
|
# pad usage history so the coupon module shows a healthy ledger
|
|
active_coupons = [c for c in refs["coupons"] if c["is_active"]]
|
|
while len(usages) < 110:
|
|
o = random.choice(orders)
|
|
c = random.choice(active_coupons)
|
|
usages.append({"usage_id": new_ulid(), "coupon_id": c["coupon_id"],
|
|
"customer_id": o["customer_id"], "order_id": o["order_id"],
|
|
"discount_amount": round(random.uniform(20, 900), 2),
|
|
"used_at": o["created_at"]})
|
|
S.insert(DB_E, "orders", orders)
|
|
S.insert(DB_E, "order_items", items)
|
|
S.insert(DB_E, "order_status_history", hist)
|
|
S.insert(DB_E, "invoices", invs, f"{len(invs)} for captured")
|
|
S.insert(DB_E, "payment_ledger", pays)
|
|
S.insert(DB_E, "coupon_usages", usages)
|
|
|
|
# keep the pre-existing coupon usage counters plausible
|
|
for c in refs["coupons"]:
|
|
c["times_used"] = c["times_used"]
|
|
S.insert(DB_E, "customer_wallets", [
|
|
{"wallet_id": new_ulid(), "customer_id": cid, "active_balance": round(random.uniform(0, 1500), 2),
|
|
"pending_balance": round(random.uniform(0, 500), 2),
|
|
"lifetime_earned": round(random.uniform(100, 5000), 2),
|
|
"lifetime_redeemed": round(random.uniform(0, 2000), 2), "currency": "INR", "is_locked": 0,
|
|
"created_at": days_ago(random.randint(10, 120)), "updated_at": days_ago(0)}
|
|
for cid in ecom_ids[:100]])
|
|
wts = S.fetch(f"SELECT wallet_id, customer_id FROM {DB_E}.customer_wallets LIMIT 100")
|
|
S.insert(DB_E, "wallet_transactions", [
|
|
{"transaction_id": new_ulid(), "wallet_id": w[0], "customer_id": w[1],
|
|
"transaction_type": random.choice(["CASHBACK", "REFERRAL_BONUS", "SERVICE_CREDIT", "REFUND"]),
|
|
"reference_type": "ORDER", "reference_id": random.choice(orders)["order_id"],
|
|
"reference_no": random.choice(orders)["order_no"],
|
|
"base_amount": round(random.uniform(200, 5000), 2), "percentage_applied": random.choice([2.0, 5.0, None]),
|
|
"credit_amount": round(random.uniform(50, 800), 2),
|
|
"status": random.choice(["MATURED"] * 6 + ["PENDING_MATURITY"] * 2 + ["VOIDED"]),
|
|
"matures_at": in_days(random.randint(-20, 30)), "matured_at": days_ago(random.randint(0, 20)),
|
|
"voided_at": None, "void_reason": None,
|
|
"description": f"Wallet demo credit {TAG}", "created_at": days_ago(random.randint(1, 40)),
|
|
"updated_at": days_ago(0)} for w in wts])
|
|
return {"orders": orders}
|
|
|
|
|
|
# =========================================================================== #
|
|
# STAGE 6 — technicians + service engine
|
|
# =========================================================================== #
|
|
def stage_services(staff, custs, refs):
|
|
print("STAGE 6: technicians & service engine")
|
|
tech_users = staff["tech_user_ids"][:100]
|
|
ecom_ids = custs["ecom_ids"]
|
|
edevs = custs["edevs"]
|
|
st_ids = refs["service_types"]
|
|
tag_st_ids = refs["tag_service_types"]
|
|
|
|
profiles = [{"technician_id": new_ulid(), "user_id": uid, "active": 1 if i % 10 else 0}
|
|
for i, uid in enumerate(tech_users)]
|
|
S.insert(DB_E, "technician_profiles", profiles)
|
|
skills, skill_seen = [], set()
|
|
for p in profiles:
|
|
n = random.randint(2, 3)
|
|
picked = random.sample(tag_st_ids, min(n, len(tag_st_ids)))
|
|
for st in picked:
|
|
key = (p["technician_id"], st)
|
|
if key in skill_seen:
|
|
continue
|
|
skill_seen.add(key)
|
|
skills.append({"technician_id": p["technician_id"], "service_type_id": st,
|
|
"skill_level": random.randint(1, 5)})
|
|
S.insert(DB_E, "technician_skills", skills)
|
|
# NOTE: technician_skills FK → crm.service_types via seeded (tagged) ids only
|
|
S.insert(DB_E, "technician_working_hours", [
|
|
{"working_hour_id": new_ulid(), "technician_id": p["technician_id"],
|
|
"day_of_week": d, "start_time": "09:00", "end_time": "18:00"}
|
|
for p in profiles for d in range(6)])
|
|
leaves = []
|
|
for i in range(1, 111):
|
|
p = random.choice(profiles)
|
|
s = now() + timedelta(days=random.randint(-15, 30))
|
|
leaves.append({"leave_id": new_ulid(), "technician_id": p["technician_id"],
|
|
"start_datetime": s, "end_datetime": s + timedelta(days=random.choice([1, 1, 2, 3])),
|
|
"reason": random.choice(["Casual Leave", "Sick Leave", "Personal Work", "Training"])})
|
|
S.insert(DB_E, "technician_leaves", leaves)
|
|
|
|
# service catalog from the 95 new service types (service_id = service_type_id)
|
|
catalog = [{"service_id": st, "name": n, "description": f"Catalog service {TAG}",
|
|
"base_price": round(random.uniform(299, 7500), 2),
|
|
"estimated_duration_minutes": random.choice([60, 90, 120, 180, 240]),
|
|
"workflow_type": random.choice(["FIXED_SERVICE", "INSPECTION_REQUIRED", "REPAIR_QUOTE"]),
|
|
"active": 1}
|
|
for st, n in zip(tag_st_ids, tag_st_ids)]
|
|
cat_names = {r[0]: r[1] for r in S.fetch(f"SELECT service_type_id, name FROM {DB_C}.service_types")}
|
|
for c in catalog:
|
|
c["name"] = cat_names.get(c["service_id"], c["name"])
|
|
S.insert(DB_E, "service_catalog", catalog)
|
|
|
|
brand_ids = {r[0]: r[1] for r in S.fetch(f"SELECT name, brand_id FROM {DB_E}.brands")}
|
|
model_ids = {r[0]: r[1] for r in S.fetch(f"SELECT name, model_id FROM {DB_E}.device_models")}
|
|
series_ids = {r[0]: r[1] for r in S.fetch(f"SELECT name, series_id FROM {DB_E}.device_series")}
|
|
|
|
jobs, appts, intakes, assigns, insp, quotes, pays, events = [], [], [], [], [], [], [], []
|
|
used_job = set()
|
|
for i in range(1, 141):
|
|
days_back = int((i / 141) ** 1.2 * 55)
|
|
created = days_ago(days_back, random.randint(9, 19))
|
|
dev = random.choice(edevs)
|
|
cat = random.choice(catalog)
|
|
while True:
|
|
job_no = f"SRV-{int(created.timestamp())}-{random.choice(string.ascii_uppercase)}{random.choice(string.ascii_uppercase)}{random.randint(10, 99)}X"
|
|
if job_no not in used_job:
|
|
used_job.add(job_no)
|
|
break
|
|
age = (now() - created).days
|
|
if age < 1:
|
|
st = random.choice(["BOOKING_PENDING", "BOOKED"])
|
|
elif age < 3:
|
|
st = random.choice(["DEVICE_INTAKE", "INSPECTION_COMPLETED", "QUOTE_SENT", "QUOTE_ACCEPTED"])
|
|
elif age < 7:
|
|
st = random.choice(["QUOTE_ACCEPTED", "READY_FOR_DELIVERY", "DELIVERED", "CUSTOMER_REJECTED"])
|
|
else:
|
|
st = random.choice(["DELIVERED"] * 4 + ["COMPLETED"] * 4 + ["CLOSED"] * 3 + ["CANCELLED"])
|
|
jid = new_ulid()
|
|
fulfillment = random.choice(["WALK_IN"] * 5 + ["COURIER"] * 2 + ["DOORSTEP_PICKUP"])
|
|
jobs.append({"job_id": jid, "job_no": job_no, "customer_id": dev["customer_id"],
|
|
"device_id": dev["device_id"], "source": random.choice(["ONLINE"] * 6 + ["WALK_IN"]),
|
|
"service_id": cat["service_id"], "status": st,
|
|
"custom_service_name": cat["name"],
|
|
"replaced_part_numbers": j([f"PRT-{random.randint(1000, 9999)}"]) if st in ("DELIVERED", "COMPLETED", "CLOSED") else None,
|
|
"device_type": dev.get("device_type") or "mobile",
|
|
"brand_id": brand_ids.get(dev["brand"]) or random.choice(list(brand_ids.values())),
|
|
"series_id": series_ids.get(dev["model"]) or random.choice(list(series_ids.values())),
|
|
"model_id": model_ids.get(dev["model"]) or random.choice(list(model_ids.values())),
|
|
"service_type_id": None, "repair_service_id": None, "repair_variant_id": None,
|
|
"currency": "INR", "service_name_snapshot": cat["name"],
|
|
"variant_name_snapshot": None,
|
|
"base_price_snapshot": cat["base_price"],
|
|
"duration_snapshot": cat["estimated_duration_minutes"],
|
|
"warranty_snapshot": 90, "inspection_fee_snapshot": 199.0,
|
|
"queue_number": f"W-{created.year}-{i:03d}", "queue_date": created.date(),
|
|
"priority": random.choice(["NORMAL"] * 7 + ["HIGH"] * 2 + ["URGENT"]),
|
|
"fulfillment_type": fulfillment,
|
|
"fulfillment_fee": 0.0 if fulfillment == "WALK_IN" else round(random.uniform(99, 299), 2),
|
|
"alt_phone": None, "is_whatsapp_alt": 0,
|
|
"delivery_address": f"{random.randint(1, 200)}, {random.choice(STREETS)}, Chennai" if fulfillment != "WALK_IN" else None,
|
|
"pre_dispatch_video_id": None,
|
|
"courier_name": "DTDC" if fulfillment == "COURIER" else None,
|
|
"awb_number": f"AWB{random.randint(10 ** 9, 10 ** 10)}" if fulfillment == "COURIER" else None,
|
|
"pickup_status": "PICKUP_SCHEDULED" if fulfillment == "COURIER" else None,
|
|
"lock_type": random.choice(["NONE", "PIN", "PATTERN", "PASSWORD"]),
|
|
"lock_credential_encrypted": None, "lock_credential_created_at": None,
|
|
"lock_credential_accessed_at": None, "lock_credential_accessed_by": None,
|
|
"lock_credential_deleted_at": None,
|
|
"created_at": created, "updated_at": min(created + timedelta(days=3), now())})
|
|
appts.append({"appointment_id": new_ulid(), "service_job_id": jid,
|
|
"scheduled_start": created + timedelta(days=1, hours=2),
|
|
"scheduled_end": created + timedelta(days=1, hours=5),
|
|
"status": "COMPLETED" if age >= 1 else "SCHEDULED",
|
|
"hold_expires_at": None, "created_at": created,
|
|
"confirmed_at": created + timedelta(hours=1), "cancelled_at": None,
|
|
"reminder_sent": 1, "reminder_sent_at": created + timedelta(hours=2)})
|
|
if st not in ("BOOKING_PENDING", "BOOKED", "CANCELLED"):
|
|
intakes.append({"intake_id": new_ulid(), "service_job_id": jid,
|
|
"received_by": random.choice(staff["tech_user_ids"]),
|
|
"received_at": created + timedelta(days=1),
|
|
"power_status": random.choice(["Booting OK", "Not powering on", "Boots, random shutdown"]),
|
|
"screen_condition": random.choice(["Cracked", "Intact", "Dead pixels", "Touch not working"]),
|
|
"body_condition": random.choice(["Good", "Dented corners", "Bent frame"]),
|
|
"back_condition": random.choice(["Cracked", "Scratched", "Intact"]),
|
|
"camera_condition": random.choice(["OK", "Blurry", "Glass cracked"]),
|
|
"accessories": random.choice(["Charger + cable", "Device only", "Box + charger"]),
|
|
"customer_notes": f"{random.choice(ISSUES)}. {TAG}",
|
|
"technician_notes": "Checked on bench, condition noted."})
|
|
tech = random.choice(profiles)["technician_id"]
|
|
if st in ("INSPECTION_COMPLETED", "QUOTE_SENT", "QUOTE_ACCEPTED", "READY_FOR_DELIVERY",
|
|
"DELIVERED", "COMPLETED", "CLOSED", "CUSTOMER_REJECTED"):
|
|
assigns.append({"assignment_id": new_ulid(), "service_job_id": jid,
|
|
"appointment_id": appts[-1]["appointment_id"],
|
|
"technician_id": tech, "assigned_at": created + timedelta(days=1, hours=3),
|
|
"assigned_by": "seed-script", "unassigned_at": None,
|
|
"reason": "Assigned via Service Management"})
|
|
result = random.choice(["CUSTOMER_REPORT_CONFIRMED"] * 5 +
|
|
["CUSTOMER_REPORT_PARTIALLY_CONFIRMED"] * 2 +
|
|
["ADDITIONAL_DAMAGE_FOUND"])
|
|
insp.append({"inspection_id": new_ulid(), "service_job_id": jid, "technician_id": tech,
|
|
"result": result,
|
|
"customer_report": random.choice(ISSUES),
|
|
"confirmed_damage": random.choice(ISSUES),
|
|
"additional_damage": "Water marks on logic board" if result == "ADDITIONAL_DAMAGE_FOUND" else None,
|
|
"notes": f"Bench inspection {TAG}",
|
|
"created_at": created + timedelta(days=2)})
|
|
if st in ("QUOTE_SENT", "QUOTE_ACCEPTED", "READY_FOR_DELIVERY", "DELIVERED", "COMPLETED", "CLOSED", "CUSTOMER_REJECTED"):
|
|
sub = round(random.uniform(800, 12000), 2)
|
|
tax = round(sub * 0.18, 2)
|
|
qstat = ("ACCEPTED" if st in ("QUOTE_ACCEPTED", "READY_FOR_DELIVERY", "DELIVERED", "COMPLETED", "CLOSED")
|
|
else "REJECTED" if st == "CUSTOMER_REJECTED" else "PENDING_CUSTOMER")
|
|
qid = new_ulid()
|
|
quotes.append({"quote_id": qid, "service_job_id": jid, "version": 1,
|
|
"subtotal": sub, "tax": tax, "additional_damage_amount": 0.0,
|
|
"total": round(sub + tax, 2), "status": qstat,
|
|
"reason": None if qstat != "REJECTED" else "Customer chose replacement device",
|
|
"expires_at": created + timedelta(days=4),
|
|
"accepted_at": created + timedelta(days=2) if qstat == "ACCEPTED" else None,
|
|
"rejected_at": created + timedelta(days=2) if qstat == "REJECTED" else None,
|
|
"created_by": "seed-script", "created_at": created + timedelta(days=2)})
|
|
if qstat == "ACCEPTED":
|
|
pays.append({"payment_id": new_ulid(), "service_job_id": jid, "quote_id": qid,
|
|
"payment_type": "ADVANCE", "amount": round(sub * 0.3, 2),
|
|
"status": "CAPTURED", "provider": random.choice(["RAZORPAY", "UPI", "CASH"]),
|
|
"provider_order_id": None,
|
|
"provider_payment_id": f"pay_srv{random.randint(10 ** 10, 10 ** 11)}",
|
|
"provider_signature": None, "transaction_reference": None,
|
|
"provider_refund_id": None, "refund_reason": None, "refunded_at": None,
|
|
"created_at": created + timedelta(days=2), "paid_at": created + timedelta(days=2)})
|
|
if st in ("DELIVERED", "COMPLETED", "CLOSED"):
|
|
pays.append({"payment_id": new_ulid(), "service_job_id": jid, "quote_id": qid,
|
|
"payment_type": "FINAL", "amount": round(sub * 0.7 + tax, 2),
|
|
"status": "CAPTURED", "provider": random.choice(["RAZORPAY", "UPI", "CASH"]),
|
|
"provider_order_id": None,
|
|
"provider_payment_id": f"pay_srv{random.randint(10 ** 10, 10 ** 11)}",
|
|
"provider_signature": None, "transaction_reference": None,
|
|
"provider_refund_id": None, "refund_reason": None, "refunded_at": None,
|
|
"created_at": created + timedelta(days=4), "paid_at": created + timedelta(days=4)})
|
|
for k, (et, note) in enumerate([("JOB_CREATED", "Booking created"),
|
|
("STATUS_CHANGED", f"Status -> {st}"),
|
|
("TECHNICIAN_ASSIGNED", "Assigned on bench")][:3 if age >= 3 else 1]):
|
|
events.append({"event_id": new_ulid(), "job_id": jid, "event_type": et,
|
|
"performed_by": "seed-script", "timestamp": created + timedelta(hours=k * 5),
|
|
"notes": note + f" {TAG}"})
|
|
S.insert(DB_E, "service_jobs", jobs)
|
|
S.insert(DB_E, "service_appointments", appts)
|
|
S.insert(DB_E, "service_job_intakes", intakes)
|
|
S.insert(DB_E, "service_job_assignments", assigns)
|
|
S.insert(DB_E, "service_job_inspections", insp)
|
|
S.insert(DB_E, "service_job_quotes", quotes)
|
|
S.insert(DB_E, "service_payments", pays)
|
|
S.insert(DB_E, "service_job_events", events)
|
|
return {"jobs": jobs, "profiles": profiles}
|
|
|
|
|
|
# =========================================================================== #
|
|
# STAGE 7 — repair tickets, POS sessions
|
|
# =========================================================================== #
|
|
def stage_repair_pos(refs, custs, staff, svc):
|
|
print("STAGE 7: repair tickets & POS")
|
|
crm_ids = custs["crm_ids"]
|
|
crm_devs = custs["crm_devs"]
|
|
tech_ids = [p["technician_id"] for p in svc["profiles"]]
|
|
tickets = []
|
|
used_tn = set()
|
|
stages_all = ["RECEIVED", "DIAGNOSING", "PART_PENDING", "UNDER_REPAIR", "QC_TESTING",
|
|
"READY_FOR_DELIVERY", "CLOSED", "CANCELLED"]
|
|
stages = stages_all[:6] * 16 + ["CLOSED"] * 12 + ["CANCELLED"] * 2
|
|
random.shuffle(stages)
|
|
for i, stage in enumerate(stages[:110]):
|
|
while True:
|
|
tn = f"IFK-REP-{random.randint(1000, 9999)}"
|
|
if tn not in used_tn:
|
|
used_tn.add(tn)
|
|
break
|
|
created = days_ago(random.randint(0, 50), random.randint(9, 19))
|
|
cust = random.choice(crm_ids)
|
|
dev = random.choice([d for d in crm_devs]) if crm_devs else None
|
|
if not dev:
|
|
continue
|
|
done = stage in ("CLOSED", "CANCELLED")
|
|
tickets.append({"ticket_id": new_ulid(), "ticket_number": tn, "tenant_id": TENANT,
|
|
"customer_id": cust, "device_id": dev["device_id"],
|
|
"assigned_technician_id": random.choice(tech_ids) if stage != "RECEIVED" else None,
|
|
"stage": stage,
|
|
"issue_description": f"{random.choice(ISSUES)}. {TAG}",
|
|
"diagnostic_checklist_json": j({"power": random.choice(["OK", "NO"]),
|
|
"screen": random.choice(["cracked", "ok", "dead"]),
|
|
"water": random.choice(["no", "yes"]),
|
|
"boot": random.choice(["normal", "hang", "none"])}) if stage not in ("RECEIVED", "DIAGNOSING") else None,
|
|
"qc_checklist_json": j({"touch": "pass", "color": "pass", "speaker": "pass",
|
|
"camera": "pass", "final": "pass"}) if stage in ("QC_TESTING", "READY_FOR_DELIVERY", "CLOSED") else None,
|
|
"estimate_amount": round(random.uniform(500, 15000), 2),
|
|
"estimate_approved_by_customer": 1 if stage not in ("RECEIVED", "DIAGNOSING") else 0,
|
|
"is_warranty_claim": 1 if i % 11 == 0 else 0,
|
|
"notes": f"{random.choice(NOTE_PREFIXES)} {TAG}",
|
|
"created_by": "seed-script", "updated_by": "seed-script", "version": 1})
|
|
S.insert(DB_E, "crm_repair_tickets", tickets)
|
|
|
|
sessions = []
|
|
for i in range(1, 101):
|
|
opened = days_ago(random.randint(0, 29), random.randint(9, 10))
|
|
closed_day = random.random() < 0.95
|
|
opening = random.choice([2000.0, 3000.0, 5000.0])
|
|
cash = round(random.uniform(500, 9000), 2) if closed_day else 0.0
|
|
upi = round(random.uniform(1000, 25000), 2)
|
|
card = round(random.uniform(0, 8000), 2)
|
|
other = round(random.uniform(0, 1500), 2)
|
|
ecom_n = random.randint(0, 12)
|
|
ecom_a = round(random.uniform(0, 40000), 2) if ecom_n else 0.0
|
|
svc_n = random.randint(0, 8)
|
|
svc_a = round(random.uniform(0, 25000), 2) if svc_n else 0.0
|
|
dur = random.randint(480, 600)
|
|
expected = round(opening + cash, 2)
|
|
closing = round(expected + random.choice([0, 0, 0, 50, -50, 100]), 2) if closed_day else None
|
|
sessions.append({"pos_session_id": new_ulid(), "tenant_id": TENANT,
|
|
"location_id": random.choice(refs["locations"][:8])["location_id"],
|
|
"terminal_id": random.choice(refs["terminals"])["terminal_id"],
|
|
"warehouse_id": random.choice(refs["warehouses"][:3])["warehouse_id"],
|
|
"user_id": random.choice(staff["users"])["user_id"],
|
|
"opened_by_user_id": random.choice(staff["users"])["user_id"],
|
|
"opening_cash": opening,
|
|
"closing_cash": closing, "expected_cash": expected if closed_day else None,
|
|
"cash_variance": round((closing or 0) - expected, 2) if closed_day else None,
|
|
"ecom_sales_count": ecom_n, "ecom_sales_amount": ecom_a,
|
|
"service_sales_count": svc_n, "service_sales_amount": svc_a,
|
|
"courier_charges": round(random.uniform(0, 300), 2),
|
|
"cash_sales": cash, "upi_sales": upi, "card_sales": card,
|
|
"other_sales": other,
|
|
"status": "OPEN" if not closed_day else "CLOSED",
|
|
"opened_at": opened, "session_duration_minutes": dur,
|
|
"expires_at": opened + timedelta(minutes=600),
|
|
"closed_at": opened + timedelta(minutes=dur) if closed_day else None,
|
|
"notes": f"End-of-day POS session {TAG}",
|
|
"created_by": "seed-script", "updated_by": "seed-script", "version": 1})
|
|
S.insert(DB_E, "crm_pos_sessions", sessions)
|
|
S.insert(DB_E, "crm_pos_session_extensions", [
|
|
{"id": new_ulid(), "session_id": random.choice(sessions)["pos_session_id"],
|
|
"extension_minutes": random.choice([15, 30, 60]),
|
|
"extended_by": random.choice(staff["users"])["user_id"],
|
|
"reason": "Heavy evening rush, closing delayed",
|
|
"created_at": days_ago(random.randint(0, 25)), "created_by": "seed-script",
|
|
"updated_by": "seed-script", "version": 1}
|
|
for _ in range(110)])
|
|
|
|
logs = []
|
|
for i in range(1, 121):
|
|
ok = random.random() < 0.85
|
|
logs.append({"sync_id": f"SYNC-{i:06d}-{new_ulid()[:10]}",
|
|
"terminal_id": random.choice(refs["sync_terms"])["terminal_id"],
|
|
"invoice_no": f"POS-INV-{random.randint(20260000, 20269999)}",
|
|
"pos_transaction_id": f"POSTX-{random.randint(100000, 999999)}",
|
|
"items_count": random.randint(1, 8),
|
|
"total_amount": round(random.uniform(199, 45000), 2),
|
|
"status": "SYNCED" if ok else random.choice(["FAILED", "PENDING"]),
|
|
"error_detail": None if ok else "Terminal clock drift, retry queued",
|
|
"created_at": days_ago(random.randint(0, 20), random.randint(9, 20))})
|
|
S.insert(DB_E, "pos_transaction_logs", logs)
|
|
return {"tickets": tickets, "sessions": sessions}
|
|
|
|
|
|
# =========================================================================== #
|
|
# STAGE 8 — purchases & inventory
|
|
# =========================================================================== #
|
|
def stage_purchase_inventory(refs):
|
|
print("STAGE 8: purchases & inventory")
|
|
parts = refs["parts"]
|
|
sups = refs["suppliers"]
|
|
pos, pois, moves = [], [], []
|
|
used_po = set()
|
|
statuses = ["DRAFT"] * 3 + ["SENT"] * 4 + ["PARTIALLY_RECEIVED"] * 2 + ["RECEIVED"] * 8 + ["CANCELLED"]
|
|
for i in range(1, 111):
|
|
while True:
|
|
po_no = f"PO-2026-{i:04d}"
|
|
if po_no not in used_po:
|
|
used_po.add(po_no)
|
|
break
|
|
st = statuses[i % len(statuses)]
|
|
created = days_ago(random.randint(0, 55))
|
|
items = []
|
|
total = 0.0
|
|
for k in range(random.randint(1, 4)):
|
|
part = random.choice(parts)
|
|
q = random.randint(5, 60)
|
|
up = round(float(part["cost_price"]), 2)
|
|
total += q * up
|
|
items.append({"id": new_ulid(), "purchase_order_id": None, "part_id": part["part_id"],
|
|
"quantity_ordered": q,
|
|
"quantity_received": q if st == "RECEIVED" else (q // 2 if st == "PARTIALLY_RECEIVED" else 0),
|
|
"unit_price": up})
|
|
pid = new_ulid()
|
|
for it in items:
|
|
it["purchase_order_id"] = pid
|
|
pos.append({"purchase_order_id": pid, "po_number": po_no,
|
|
"supplier_name": random.choice(sups)["company_name"], "status": st,
|
|
"total_amount": round(total, 2), "created_at": created})
|
|
pois.extend(items)
|
|
S.insert(DB_C, "purchase_orders", pos)
|
|
S.insert(DB_C, "purchase_order_items", pois)
|
|
for i in range(1, 111):
|
|
po = random.choice(pos)
|
|
part = random.choice(parts)
|
|
moves.append({"movement_id": new_ulid(), "entity_type": "PART", "entity_id": part["part_id"],
|
|
"movement_type": random.choice(["PURCHASE_IN", "PURCHASE_IN", "SALE_OUT", "ADJUSTMENT", "DAMAGE_WRITE_OFF"]),
|
|
"quantity": random.randint(1, 40),
|
|
"reference_type": "PURCHASE_ORDER", "reference_id": po["purchase_order_id"],
|
|
"created_at": days_ago(random.randint(0, 50))})
|
|
S.insert(DB_C, "stock_movements", moves)
|
|
|
|
skus = [r[0] for r in S.fetch(
|
|
f"SELECT sku FROM {DB_E}.product_variants WHERE status='active' LIMIT 300")]
|
|
stocks = []
|
|
seen = set()
|
|
for w in refs["warehouses"][:5]:
|
|
for sku in random.sample(skus, 30):
|
|
key = (w["warehouse_id"], sku)
|
|
if key in seen:
|
|
continue
|
|
seen.add(key)
|
|
q = random.randint(0, 120)
|
|
stocks.append({"stock_id": new_ulid(), "tenant_id": TENANT,
|
|
"warehouse_id": w["warehouse_id"], "sku": sku,
|
|
"quantity_on_hand": q, "quantity_reserved": random.randint(0, max(q, 1) // 4),
|
|
"reorder_threshold": random.choice([5, 10, 15]),
|
|
"created_by": "seed-script", "updated_by": "seed-script", "version": 1})
|
|
S.insert(DB_E, "crm_inventory_stocks", stocks)
|
|
return {"pos": pos}
|
|
|
|
|
|
# =========================================================================== #
|
|
# STAGE 9 — refunds, warranties, reviews, feedback
|
|
# =========================================================================== #
|
|
def stage_postsales(refs, custs, staff, svc, orders):
|
|
print("STAGE 9: refunds, warranties, reviews")
|
|
staff_ids = [u["user_id"] for u in staff["users"]]
|
|
refunds, wties, crev, prev, pimgs, fb = [], [], [], [], [], []
|
|
delivered = [o for o in orders if o["status"] in ("DELIVERED", "SHIPPED", "OUT_FOR_DELIVERY")]
|
|
oitems = [dict(zip(("item_id", "order_id", "product_id", "product_name", "sku"), r))
|
|
for r in S.fetch(
|
|
f"SELECT item_id, order_id, product_id, product_name, sku FROM {DB_E}.order_items LIMIT 400")]
|
|
for i in range(1, 111):
|
|
created = days_ago(random.randint(0, 40), random.randint(9, 20))
|
|
if i % 3 == 0 and svc["jobs"]:
|
|
job = random.choice(svc["jobs"])
|
|
etype, eid = "SERVICE", job["job_id"]
|
|
amt = round(float(job["base_price_snapshot"] or 1999) * 0.3, 2)
|
|
else:
|
|
o = random.choice(orders)
|
|
etype, eid = "SALES", o["order_id"]
|
|
amt = round(float(o["final_amount"]) * random.choice([0.2, 0.5, 1.0]), 2)
|
|
st = random.choice(["PENDING"] * 3 + ["APPROVED"] * 3 + ["PROCESSING"] * 2 + ["REFUNDED"] * 3 + ["REJECTED"] * 2)
|
|
req_by = random.choice(staff_ids)
|
|
appr = random.choice(staff_ids) if st in ("APPROVED", "PROCESSING", "REFUNDED") else None
|
|
rej = random.choice(staff_ids) if st == "REJECTED" else None
|
|
refunds.append({"refund_id": new_ulid(), "tenant_id": TENANT,
|
|
"location_id": random.choice(refs["locations"][:10])["location_id"],
|
|
"entity_type": etype, "entity_id": eid,
|
|
"amount": amt, "payment_method": random.choice(["CASH", "ONLINE"]),
|
|
"status": st,
|
|
"reason": random.choice(["Part not compatible", "Customer changed mind",
|
|
"Damaged in transit", "Wrong item delivered",
|
|
"Repair not satisfactory"]),
|
|
"part_number_verification": f"PN-{random.randint(10000, 99999)}",
|
|
"razorpay_refund_id": f"rfnd_demo{random.randint(10 ** 9, 10 ** 10)}" if st == "REFUNDED" and random.random() < 0.5 else None,
|
|
"razorpay_refund_status": "processed" if st == "REFUNDED" else None,
|
|
"requested_by": req_by, "approved_by": appr, "rejected_by": rej,
|
|
"requested_at": created,
|
|
"approved_at": created + timedelta(hours=6) if appr else None,
|
|
"rejected_at": created + timedelta(hours=6) if rej else None,
|
|
"refunded_at": created + timedelta(days=1) if st == "REFUNDED" else None,
|
|
"rejection_reason": "Part used, non-resalable" if rej else None,
|
|
"admin_notes": f"Demo refund {TAG}",
|
|
"created_by": "seed-script", "updated_by": "seed-script", "version": 1})
|
|
if i <= 40:
|
|
refunds_media_ref = refunds[-1]["refund_id"]
|
|
fb_media = {"id": new_ulid(), "refund_id": refunds_media_ref,
|
|
"file_url": f"/uploads/refunds/demo-{i}.jpg", "file_type": "image/jpeg",
|
|
"media_filename": f"demo-{i}.jpg", "uploaded_by": req_by,
|
|
"uploaded_at": created, "created_by": "seed-script",
|
|
"updated_by": "seed-script", "version": 1}
|
|
# note: refund_media requires uploaded_by NOT NULL etc. Build separately:
|
|
S.insert(DB_E, "refund_requests", refunds)
|
|
S.insert(DB_E, "refund_media", [
|
|
{"id": new_ulid(), "refund_id": r["refund_id"], "file_url": f"/uploads/refunds/demo-{k + 1}.jpg",
|
|
"file_type": "image/jpeg", "media_filename": f"demo-{k + 1}.jpg",
|
|
"uploaded_by": r["requested_by"], "uploaded_at": r["requested_at"],
|
|
"created_by": "seed-script", "updated_by": "seed-script", "version": 1}
|
|
for k, r in enumerate(refunds)])
|
|
|
|
for i in range(1, 111):
|
|
if i % 2 == 0 and oitems:
|
|
it = random.choice(oitems)
|
|
start = days_ago(random.randint(1, 300))
|
|
end = start + timedelta(days=365)
|
|
wties.append({"warranty_id": new_ulid(), "tenant_id": TENANT,
|
|
"customer_id": custs["ecom_ids"][i % len(custs["ecom_ids"])],
|
|
"reference_type": "ORDER", "reference_id": it["order_id"],
|
|
"product_id": it["product_id"], "order_item_id": it["item_id"],
|
|
"service_job_id": None, "serial_no_imei": "".join(random.choice(string.digits) for _ in range(15)),
|
|
"start_date": start, "end_date": end,
|
|
"status": "ACTIVE" if end > now() else "EXPIRED",
|
|
"warranty_type": "PRODUCT",
|
|
"terms": "12 months manufacturing defect warranty. Physical damage void.",
|
|
"void_reason": None, "expiry_notification_sent": 0,
|
|
"created_at": start, "updated_at": start})
|
|
else:
|
|
job = random.choice(svc["jobs"])
|
|
start = days_ago(random.randint(1, 200))
|
|
end = start + timedelta(days=90)
|
|
wties.append({"warranty_id": new_ulid(), "tenant_id": TENANT,
|
|
"customer_id": custs["ecom_ids"][i % len(custs["ecom_ids"])],
|
|
"reference_type": "SERVICE", "reference_id": job["job_id"],
|
|
"product_id": None, "order_item_id": None,
|
|
"service_job_id": job["job_id"],
|
|
"serial_no_imei": "".join(random.choice(string.digits) for _ in range(15)),
|
|
"start_date": start, "end_date": end,
|
|
"status": "ACTIVE" if end > now() else "EXPIRED",
|
|
"warranty_type": "SERVICE",
|
|
"terms": "90 days repair warranty on replaced part.",
|
|
"void_reason": None, "expiry_notification_sent": 0,
|
|
"created_at": start, "updated_at": start})
|
|
S.insert(DB_E, "warranties", wties)
|
|
|
|
products = [r[0] for r in S.fetch(f"SELECT product_id FROM {DB_E}.products LIMIT 400")]
|
|
tech_ids = [p["technician_id"] for p in svc["profiles"]]
|
|
rev_texts = ["Excellent service, very quick turnaround.", "Genuine part, packaging was good.",
|
|
"Technician was professional and explained everything.", "Fixed my phone in 2 hours!",
|
|
"Price was slightly high but quality is great.", "Average experience, took longer than promised.",
|
|
"Part failed within a month, support helpful though.", "Great follow-up and warranty support.",
|
|
"Store staff was courteous, repair perfect.", "Fast courier delivery, well packed."]
|
|
for i in range(1, 111):
|
|
rating = random.choice([5, 5, 5, 4, 4, 3, 2, 1])
|
|
mod = random.choice(["APPROVED"] * 6 + ["PENDING_MODERATION"] * 2 + ["REJECTED"] + ["FLAGGED"])
|
|
tt = random.choice(["PRODUCT"] * 6 + ["TECHNICIAN"] * 2 + ["STORE"] * 2)
|
|
tid = {"PRODUCT": lambda: random.choice(products),
|
|
"TECHNICIAN": lambda: random.choice(tech_ids),
|
|
"STORE": lambda: random.choice(refs["locations"])["location_id"]}[tt]()
|
|
crev.append({"review_id": new_ulid(), "tenant_id": TENANT,
|
|
"customer_id": custs["ecom_ids"][i % len(custs["ecom_ids"])],
|
|
"target_type": tt, "target_id": tid,
|
|
"order_id": None, "repair_ticket_id": None,
|
|
"rating": rating, "title": random.choice(["Great service", "Good quality", "Okay experience",
|
|
"Poor experience", "Highly recommend"]),
|
|
"comment": random.choice(rev_texts) + f" {TAG}",
|
|
"moderation_status": mod,
|
|
"moderation_reason": "Spam suspicion" if mod == "REJECTED" else None,
|
|
"is_verified_buyer": 1 if i % 3 else 0,
|
|
"is_published": 1 if mod == "APPROVED" else 0,
|
|
"csat_score": rating * 20,
|
|
"moderated_by": random.choice(staff_ids) if mod in ("APPROVED", "REJECTED") else None,
|
|
"moderated_at": days_ago(random.randint(0, 5)) if mod in ("APPROVED", "REJECTED") else None,
|
|
"created_by": "seed-script", "updated_by": "seed-script", "version": 1})
|
|
S.insert(DB_E, "customer_reviews", crev)
|
|
|
|
for i in range(1, 111):
|
|
rating = random.choice([5, 5, 4, 4, 3, 2, 1])
|
|
rid = new_ulid()
|
|
approved = i % 8 != 7
|
|
prev.append({"review_id": rid, "product_id": random.choice(products),
|
|
"user_id": None, "author_name": f"{random.choice(FIRST)} {random.choice(LAST)}",
|
|
"author_email": slug_email(random.choice(FIRST), random.choice(LAST)),
|
|
"rating": rating,
|
|
"title": random.choice(["Works perfectly", "Good spare part", "As described",
|
|
"Not original but decent", "Poor fit"]),
|
|
"comment": random.choice(rev_texts),
|
|
"verified_purchase": 1 if i % 2 else 0, "is_approved": 1 if approved else 0,
|
|
"helpful_count": random.randint(0, 25),
|
|
"admin_reply": "Thanks for your feedback!" if i % 5 == 0 else None,
|
|
"created_at": days_ago(random.randint(1, 120)), "updated_at": days_ago(0),
|
|
"created_by": "seed-script", "updated_by": "seed-script", "version": 1})
|
|
pimgs.append({"image_id": new_ulid(), "review_id": rid,
|
|
"image_url": f"/uploads/reviews/demo-{i}.jpg", "caption": "Installed part photo",
|
|
"display_order": 1, "is_approved": 1 if approved else 0,
|
|
"created_by": "seed-script", "updated_by": "seed-script", "version": 1})
|
|
S.insert(DB_E, "product_reviews", prev)
|
|
S.insert(DB_E, "product_review_images", pimgs)
|
|
|
|
for i in range(1, 111):
|
|
fn, ln = random.choice(FIRST), random.choice(LAST)
|
|
fb.append({"feedback_id": new_ulid(), "name": f"{fn} {ln}",
|
|
"email": slug_email(fn, ln),
|
|
"topic": random.choice(["general", "order", "service", "website", "complaint"]),
|
|
"order_no": random.choice(orders)["order_no"] if i % 4 == 0 else None,
|
|
"rating": random.choice([5, 4, 4, 3, 2, 1]),
|
|
"message": random.choice(["Website is easy to use.", "Order arrived quickly, thanks!",
|
|
"Repair service could be faster on weekends.",
|
|
"Loved the WhatsApp updates.", "Add more laptop spare categories.",
|
|
"Coupon code did not apply at checkout.", "Great support on call."]) + f" {TAG}",
|
|
"status": random.choice(["NEW"] * 4 + ["REVIEWED"] * 3 + ["RESOLVED"] * 3),
|
|
"created_at": days_ago(random.randint(0, 60), random.randint(8, 22))})
|
|
S.insert(DB_E, "customer_feedbacks", fb)
|
|
|
|
|
|
# =========================================================================== #
|
|
# STAGE 10 — notifications, templates, attributes, brands, categories
|
|
# =========================================================================== #
|
|
def stage_comms_catalog(refs, custs, staff, orders, svc):
|
|
print("STAGE 10: notifications, templates, catalog extras")
|
|
from passlib.context import CryptContext # noqa (already imported earlier)
|
|
|
|
templates = []
|
|
registry = [("ORDER_CREATED", "Order Confirmation"), ("NEW_ORDER_ALERT", "New Order Alert"),
|
|
("SERVICE_BOOKED", "Service Booked"), ("SERVICE_READY", "Service Ready"),
|
|
("ORDER_STATUS_CHANGED", "Order Status Update"), ("SERVICE_BOOKED_INTERNAL", "Internal Service Alert"),
|
|
("SERVICE_STATUS_CHANGED", "Service Status Update"), ("INVENTORY_LOW_STOCK", "Low Stock Alert"),
|
|
("REFUND_TRIGGERED", "Refund Triggered"), ("END_OF_DAY_REPORT", "End of Day Report"),
|
|
("REPAIR_SLA_BREACH", "Repair SLA Breach"), ("WARRANTY_EXPIRING_SOON", "Warranty Expiring")]
|
|
common_vars = [{"name": "customer_name", "description": "Customer full name", "example": "Priya Kumar"},
|
|
{"name": "order_no", "description": "Order number", "example": "ORD-20261116-0001"},
|
|
{"name": "job_no", "description": "Service job number", "example": "SRV-1731772800-A1B2"}]
|
|
for ev, nm in registry:
|
|
for ch in ("WHATSAPP", "EMAIL"):
|
|
templates.append({"template_id": new_ulid(), "tenant_id": TENANT, "event_key": ev,
|
|
"name": f"{nm} ({ch})", "channel": ch,
|
|
"subject": f"iFixKart - {nm}" if ch == "EMAIL" else None,
|
|
"body_content": ("Hi {{ customer_name }}, your order {{ order_no }} update from iFixKart."
|
|
if "ORDER" in ev else
|
|
"Hi {{ customer_name }}, update on your service {{ job_no }} from iFixKart."),
|
|
"variables": j(common_vars), "is_active": 1,
|
|
"created_by": "seed-script", "updated_by": "seed-script", "version": 1})
|
|
S.insert(DB_E, "notification_templates", templates)
|
|
tmpl_ids = {r[0]: r[1] for r in S.fetch(
|
|
f"SELECT event_key, template_id FROM {DB_E}.notification_templates")}
|
|
|
|
cust_emails = [r[0] for r in S.fetch(
|
|
f"SELECT email FROM {DB_E}.ecom_customers ORDER BY created_at DESC LIMIT 60")]
|
|
notif_types = ["ORDER", "INVOICE", "SERVICE_BOOKED", "SERVICE_READY", "SERVICE_STATUS_CHANGED",
|
|
"QUOTATION", "REPAIR_TICKET", "LEAD_QUALIFIED", "ORDER_STATUS_CHANGED"]
|
|
chans = ["WHATSAPP", "EMAIL", "WHATSAPP", "WEB_PUSH"]
|
|
stat_mix = ["DELIVERED"] * 6 + ["SENT"] * 2 + ["QUEUED"] + ["FAILED"] + ["SENDING"]
|
|
|
|
def notif_rows(n, emails, tag):
|
|
rows = []
|
|
for i in range(1, n + 1):
|
|
ev = random.choice(notif_types)
|
|
status = random.choice(stat_mix)
|
|
created = days_ago(random.randint(0, 30), random.randint(8, 22))
|
|
rows.append({"notification_id": new_ulid(), "tenant_id": TENANT,
|
|
"event_id": None, "notification_type": ev,
|
|
"entity_id": random.choice(orders)["order_id"],
|
|
"idempotency_key": f"seed:{new_ulid()}",
|
|
"recipient": random.choice(emails),
|
|
"channel": random.choice(chans),
|
|
"template_id": tmpl_ids.get(ev.split("_ALERT")[0].split("_INTERNAL")[0]),
|
|
"status": status,
|
|
"subject": f"iFixKart {ev.replace('_', ' ').title()}" if random.random() < 0.5 else None,
|
|
"message_body": f"Demo {ev.lower()} notification for storefront customer. {tag}",
|
|
"attempt_count": 1 if status in ("DELIVERED", "SENT", "FAILED") else 0,
|
|
"last_attempt_at": created + timedelta(minutes=1) if status != "QUEUED" else None,
|
|
"next_retry_at": created + timedelta(hours=1) if status == "FAILED" else None,
|
|
"last_error": "Provider timeout" if status == "FAILED" else None,
|
|
"provider_response": j({"ok": status == "DELIVERED"}),
|
|
"completed_at": created + timedelta(minutes=2) if status in ("DELIVERED", "SENT") else None,
|
|
"created_by": "seed-script", "updated_by": "seed-script", "version": 1})
|
|
return rows
|
|
S.insert(DB_E, "notifications", notif_rows(120, cust_emails or ["demo@ifixkart-demo.com"], TAG))
|
|
S.insert(DB_A, "notifications", notif_rows(110, [u["email"] for u in staff["users"]], TAG))
|
|
|
|
existing_attr = {r[0] for r in S.fetch(f"SELECT code FROM {DB_E}.attribute_types")}
|
|
attrs = []
|
|
for code, name, presets in ATTR_POOL:
|
|
if code in existing_attr or len(attrs) >= 40:
|
|
continue
|
|
existing_attr.add(code)
|
|
attrs.append({"attribute_id": new_ulid(), "name": name, "code": code,
|
|
"status": "active", "preset_values": j(presets)})
|
|
S.insert(DB_E, "attribute_types", attrs, "extras")
|
|
|
|
existing_brands = {r[0] for r in S.fetch(f"SELECT name FROM {DB_E}.brands")}
|
|
brands = []
|
|
for b in BRAND_POOL:
|
|
if b in existing_brands or len(brands) >= 10:
|
|
continue
|
|
existing_brands.add(b)
|
|
brands.append({"brand_id": new_ulid(), "name": b,
|
|
"slug": b.lower().replace(" ", "-"), "logo_url": None,
|
|
"is_active": 1, "created_at": days_ago(1), "updated_at": days_ago(1)})
|
|
S.insert(DB_E, "brands", brands, "extras")
|
|
|
|
parents = [r[0] for r in S.fetch(
|
|
f"SELECT category_id FROM {DB_E}.categories WHERE parent_category_id IS NULL LIMIT 10")]
|
|
existing_cats = {r[0] for r in S.fetch(f"SELECT slug FROM {DB_E}.categories")}
|
|
cats = []
|
|
series_names = [r[0] for r in S.fetch(f"SELECT name FROM {DB_E}.device_series LIMIT 60")]
|
|
for i, sn in enumerate(series_names[:45]):
|
|
slug = (sn.lower().replace(" ", "-").replace("(", "").replace(")", "") + "-spares")[:100]
|
|
if slug in existing_cats:
|
|
continue
|
|
existing_cats.add(slug)
|
|
cats.append({"category_id": new_ulid(), "parent_category_id": random.choice(parents) if parents else None,
|
|
"name": f"{sn} Spares", "slug": slug,
|
|
"description": f"Spare parts & accessories for {sn}. {TAG}",
|
|
"image_url": None, "sort_order": str(100 + i), "is_parent_feature": 0,
|
|
"is_active": 1, "show_in_sidebar": 0, "mega_group": None, "badge": None,
|
|
"created_at": days_ago(1), "updated_at": days_ago(1)})
|
|
S.insert(DB_E, "categories", cats, "extras")
|
|
|
|
|
|
# =========================================================================== #
|
|
def reset_seed():
|
|
"""Delete every row created by this seeder (FK-safe order)."""
|
|
print("RESET: deleting all seed-tagged rows")
|
|
cur = S.conn.cursor()
|
|
demo = "%@ifixkart-demo.com"
|
|
stmts = [
|
|
# admin db
|
|
(DB_A, "DELETE FROM user_sessions WHERE user_id IN (SELECT user_id FROM users WHERE email LIKE %s)", (demo,)),
|
|
(DB_A, "DELETE FROM notifications WHERE created_by='seed-script'", ()),
|
|
(DB_A, "DELETE FROM users WHERE email LIKE %s", (demo,)),
|
|
(DB_A, "DELETE FROM roles WHERE role_prefix IN ('ADMI','SMGR','SLEX','CRMX','SVAD','TECH','WHSE','ACCT','SUPT') OR description LIKE %s", (f"%{TAG}%",)),
|
|
(DB_A, "DELETE FROM departments WHERE description LIKE %s OR name IN ('Sales','Service & Repair','Warehouse & Logistics','Finance & Accounts','Customer Support','Marketing','Human Resources')", (f"%{TAG}%",)),
|
|
(DB_A, "DELETE FROM designations WHERE description LIKE %s OR name IN ('Store Manager','Sales Executive','Senior Sales Executive','CRM Executive','Service Center Manager','Senior Technician','Technician','Junior Technician','Warehouse Executive','Accountant','Support Agent')", (f"%{TAG}%",)),
|
|
# commerce: service engine
|
|
(DB_E, "DELETE FROM service_job_events WHERE job_id IN (SELECT job_id FROM service_jobs WHERE job_no LIKE 'SRV-%')", ()),
|
|
(DB_E, "DELETE FROM service_payments WHERE service_job_id IN (SELECT job_id FROM service_jobs WHERE job_no LIKE 'SRV-%')", ()),
|
|
(DB_E, "DELETE FROM service_job_quotes WHERE service_job_id IN (SELECT job_id FROM service_jobs WHERE job_no LIKE 'SRV-%')", ()),
|
|
(DB_E, "DELETE FROM service_job_inspections WHERE service_job_id IN (SELECT job_id FROM service_jobs WHERE job_no LIKE 'SRV-%')", ()),
|
|
(DB_E, "DELETE FROM service_job_assignments WHERE service_job_id IN (SELECT job_id FROM service_jobs WHERE job_no LIKE 'SRV-%')", ()),
|
|
(DB_E, "DELETE FROM service_job_intakes WHERE service_job_id IN (SELECT job_id FROM service_jobs WHERE job_no LIKE 'SRV-%')", ()),
|
|
(DB_E, "DELETE FROM service_appointments WHERE service_job_id IN (SELECT job_id FROM service_jobs WHERE job_no LIKE 'SRV-%')", ()),
|
|
(DB_E, "DELETE FROM service_jobs WHERE job_no LIKE 'SRV-%'", ()),
|
|
(DB_E, "DELETE FROM service_catalog WHERE service_id IN (SELECT service_type_id FROM ifixkartcrm.service_types WHERE description LIKE %s)", (f"%{TAG}%",)),
|
|
(DB_E, "DELETE FROM technician_leaves", ()),
|
|
(DB_E, "DELETE FROM technician_working_hours", ()),
|
|
(DB_E, "DELETE FROM technician_skills", ()),
|
|
(DB_E, "DELETE FROM technician_profiles", ()),
|
|
# commerce: orders & billing
|
|
(DB_E, "DELETE FROM order_status_history WHERE order_id IN (SELECT order_id FROM orders o JOIN ecom_customers c ON c.customer_id=o.customer_id WHERE c.email LIKE %s) OR order_id IN (SELECT order_id FROM orders WHERE customer_id IS NULL)", (demo,)),
|
|
(DB_E, "DELETE FROM order_items WHERE order_id IN (SELECT order_id FROM orders o JOIN ecom_customers c ON c.customer_id=o.customer_id WHERE c.email LIKE %s) OR order_id IN (SELECT order_id FROM orders WHERE customer_id IS NULL)", (demo,)),
|
|
(DB_E, "DELETE FROM invoices", ()),
|
|
(DB_E, "DELETE FROM payment_ledger WHERE raw_response_json LIKE %s", (f"%{TAG}%",)),
|
|
(DB_E, "DELETE FROM coupon_usages", ()),
|
|
(DB_E, "DELETE FROM wallet_transactions", ()),
|
|
(DB_E, "DELETE FROM orders WHERE customer_id IN (SELECT customer_id FROM ecom_customers WHERE email LIKE %s) OR customer_id IS NULL", (demo,)),
|
|
# commerce: post-sales
|
|
(DB_E, "DELETE FROM refund_media WHERE refund_id IN (SELECT refund_id FROM refund_requests WHERE created_by='seed-script')", ()),
|
|
(DB_E, "DELETE FROM refund_requests WHERE created_by='seed-script'", ()),
|
|
(DB_E, "DELETE FROM warranties WHERE customer_id IN (SELECT customer_id FROM ecom_customers WHERE email LIKE %s)", (demo,)),
|
|
(DB_E, "DELETE FROM product_review_images", ()),
|
|
(DB_E, "DELETE FROM product_reviews", ()),
|
|
(DB_E, "DELETE FROM customer_reviews WHERE created_by='seed-script'", ()),
|
|
(DB_E, "DELETE FROM customer_feedbacks WHERE message LIKE %s", (f"%{TAG}%",)),
|
|
# commerce: comms
|
|
(DB_E, "DELETE FROM notifications WHERE created_by='seed-script'", ()),
|
|
(DB_E, "DELETE FROM notification_templates WHERE created_by='seed-script'", ()),
|
|
# commerce: POS & repair & inventory
|
|
(DB_E, "DELETE FROM crm_pos_session_extensions WHERE created_by='seed-script'", ()),
|
|
(DB_E, "DELETE FROM crm_pos_sessions WHERE created_by='seed-script'", ()),
|
|
(DB_E, "DELETE FROM pos_transaction_logs WHERE sync_id LIKE 'SYNC-%'", ()),
|
|
(DB_E, "DELETE FROM pos_sync_terminals WHERE terminal_id LIKE 'TERM-%'", ()),
|
|
(DB_E, "DELETE FROM pos_terminals WHERE created_by='seed-script'", ()),
|
|
(DB_E, "DELETE FROM crm_warehouses WHERE created_by='seed-script'", ()),
|
|
(DB_E, "DELETE FROM crm_suppliers WHERE created_by='seed-script'", ()),
|
|
(DB_E, "DELETE FROM crm_repair_tickets WHERE created_by='seed-script'", ()),
|
|
(DB_E, "DELETE FROM crm_inventory_stocks WHERE created_by='seed-script'", ()),
|
|
# crm db
|
|
(DB_C, "DELETE FROM stock_movements", ()),
|
|
(DB_C, "DELETE FROM purchase_order_items", ()),
|
|
(DB_C, "DELETE FROM purchase_orders", ()),
|
|
(DB_C, "DELETE FROM parts WHERE barcode LIKE '8900001%%'", ()),
|
|
(DB_C, "DELETE FROM contact_addresses WHERE contact_id IN (SELECT contact_id FROM contacts WHERE email LIKE %s)", (demo,)),
|
|
(DB_C, "DELETE FROM contacts WHERE email LIKE %s", (demo,)),
|
|
(DB_C, "DELETE FROM service_types WHERE description LIKE %s", (f"%{TAG}%",)),
|
|
# commerce: CRM pipeline & customers (children first)
|
|
(DB_E, "DELETE FROM crm_bulk_quotation_items WHERE quote_id IN (SELECT quote_id FROM crm_bulk_quotations WHERE created_by='seed-script')", ()),
|
|
(DB_E, "DELETE FROM crm_bulk_quotations WHERE created_by='seed-script'", ()),
|
|
(DB_E, "DELETE FROM crm_invoice_items WHERE invoice_id IN (SELECT invoice_id FROM crm_gst_invoices WHERE created_by='seed-script')", ()),
|
|
(DB_E, "DELETE FROM crm_gst_invoices WHERE created_by='seed-script'", ()),
|
|
(DB_E, "DELETE FROM crm_tasks WHERE created_by='seed-script'", ()),
|
|
(DB_E, "DELETE FROM crm_calendar_events WHERE created_by='seed-script'", ()),
|
|
(DB_E, "DELETE FROM crm_deals WHERE created_by='seed-script'", ()),
|
|
(DB_E, "DELETE FROM crm_leads WHERE created_by='seed-script'", ()),
|
|
(DB_E, "DELETE FROM crm_contacts WHERE created_by='seed-script'", ()),
|
|
(DB_E, "DELETE FROM crm_customer_devices WHERE created_by='seed-script'", ()),
|
|
(DB_E, "DELETE FROM crm_customers WHERE created_by='seed-script'", ()),
|
|
# locations last (referenced by tasks/calendar/pos sessions above)
|
|
(DB_E, "DELETE FROM crm_locations WHERE created_by='seed-script'", ()),
|
|
# commerce: catalog extras
|
|
(DB_E, "DELETE FROM brands WHERE name IN ('Honor','iQoo','Tecno','Infinix','Lava','Micromax','Nokia','Sony','Nubia','Asus ROG') AND brand_id NOT IN (SELECT brand_id FROM device_models WHERE brand_id IS NOT NULL)", ()),
|
|
(DB_E, "DELETE FROM categories WHERE name LIKE '% Spares' AND slug LIKE '%-spares'", ()),
|
|
(DB_E, "DELETE FROM attribute_types WHERE code IN ('water_resistance_rating','refresh_rate_hz','screen_size_inch','ram_type','port_type','weight_grams','battery_capacity_mah','charger_wattage','front_camera_mp','rear_camera_mp','processor_core','os_version','sim_slots','network_band','material_grade','panel_type','warranty_period','connector_pitch','flex_cable_type','color_variant','storage_capacity','keyboard_layout','audio_jack','fingerprint_type','fast_charging','wireless_charging','tcon_board','frame_included','ic_chips','tempered_grade')", ()),
|
|
(DB_E, "DELETE FROM coupons", ()),
|
|
# commerce: storefront customers LAST (cascades wallets/addresses)
|
|
(DB_E, "DELETE FROM customer_devices WHERE customer_id NOT IN (SELECT customer_id FROM ecom_customers)", ()),
|
|
(DB_E, "DELETE FROM ecom_customers WHERE email LIKE %s", (demo,)),
|
|
]
|
|
for db, sql, args in stmts:
|
|
try:
|
|
cur.execute(f"USE `{db}`")
|
|
n = cur.execute(sql, args or None) if args else cur.execute(sql)
|
|
if n:
|
|
print(f" {db}: -{n}")
|
|
except pymysql.err.IntegrityError as e:
|
|
print(f" SKIP ({e})")
|
|
S.conn.commit()
|
|
|
|
|
|
def looks_seeded() -> bool:
|
|
demo = "%@ifixkart-demo.com"
|
|
checks = [
|
|
(DB_A, "users", "email LIKE %s", (demo,)),
|
|
(DB_E, "crm_leads", "created_by='seed-script'", ()),
|
|
(DB_E, "crm_locations", "created_by='seed-script'", ()),
|
|
(DB_E, "coupons", "code LIKE 'IFK%%OFF'", ()),
|
|
]
|
|
for db, t, cond, args in checks:
|
|
if int(S.scalar(f"SELECT COUNT(*) FROM `{db}`.`{t}` WHERE {cond}", args) or 0) > 0:
|
|
return True
|
|
return False
|
|
|
|
|
|
def main():
|
|
force = "--force" in sys.argv
|
|
if "--reset" in sys.argv:
|
|
reset_seed()
|
|
print("Reset complete.\n")
|
|
if looks_seeded() and not force:
|
|
print("Seed data already present — run with --reset to clear it, or --force to append.")
|
|
sys.exit(1)
|
|
t0 = time.time()
|
|
staff = stage_admin_staff()
|
|
refs = stage_reference()
|
|
custs = stage_customers()
|
|
pipeline = stage_pipeline(staff, refs, custs)
|
|
orders_res = stage_orders(refs, custs, staff)
|
|
svc = stage_services(staff, custs, refs)
|
|
repair_pos = stage_repair_pos(refs, custs, staff, svc)
|
|
stage_purchase_inventory(refs)
|
|
stage_postsales(refs, custs, staff, svc, orders_res["orders"])
|
|
stage_comms_catalog(refs, custs, staff, orders_res["orders"], svc)
|
|
|
|
print("\n=== FINAL COUNTS (per admin module) ===")
|
|
modules = [
|
|
("users (staff-directory)", DB_A, "users"), ("roles", DB_A, "roles"),
|
|
("departments", DB_A, "departments"), ("designations", DB_A, "designations"),
|
|
("notifications (admin)", DB_A, "notifications"), ("audit_logs", DB_A, "audit_logs"),
|
|
("crm_customers", DB_E, "crm_customers"), ("crm_contacts", DB_E, "crm_contacts"),
|
|
("crm_leads", DB_E, "crm_leads"), ("crm_deals", DB_E, "crm_deals"),
|
|
("crm_tasks", DB_E, "crm_tasks"), ("crm_calendar_events", DB_E, "crm_calendar_events"),
|
|
("crm_bulk_quotations", DB_E, "crm_bulk_quotations"), ("crm_bulk_quotation_items", DB_E, "crm_bulk_quotation_items"),
|
|
("crm_gst_invoices", DB_E, "crm_gst_invoices"), ("crm_invoice_items", DB_E, "crm_invoice_items"),
|
|
("crm_repair_tickets", DB_E, "crm_repair_tickets"), ("crm_pos_sessions", DB_E, "crm_pos_sessions"),
|
|
("crm_pos_session_extensions", DB_E, "crm_pos_session_extensions"),
|
|
("crm_suppliers", DB_E, "crm_suppliers"), ("crm_warehouses", DB_E, "crm_warehouses"),
|
|
("crm_locations", DB_E, "crm_locations"), ("crm_inventory_stocks", DB_E, "crm_inventory_stocks"),
|
|
("pos_terminals", DB_E, "pos_terminals"), ("pos_sync_terminals", DB_E, "pos_sync_terminals"),
|
|
("pos_transaction_logs", DB_E, "pos_transaction_logs"),
|
|
("ecom_customers", DB_E, "ecom_customers"), ("customer_addresses", DB_E, "customer_addresses"),
|
|
("customer_devices", DB_E, "customer_devices"), ("orders", DB_E, "orders"),
|
|
("order_items", DB_E, "order_items"), ("order_status_history", DB_E, "order_status_history"),
|
|
("invoices", DB_E, "invoices"), ("payment_ledger", DB_E, "payment_ledger"),
|
|
("coupons", DB_E, "coupons"), ("coupon_usages", DB_E, "coupon_usages"),
|
|
("customer_wallets", DB_E, "customer_wallets"), ("wallet_transactions", DB_E, "wallet_transactions"),
|
|
("service_catalog", DB_E, "service_catalog"), ("service_jobs", DB_E, "service_jobs"),
|
|
("service_appointments", DB_E, "service_appointments"), ("service_job_intakes", DB_E, "service_job_intakes"),
|
|
("service_job_assignments", DB_E, "service_job_assignments"),
|
|
("service_job_inspections", DB_E, "service_job_inspections"),
|
|
("service_job_quotes", DB_E, "service_job_quotes"), ("service_payments", DB_E, "service_payments"),
|
|
("service_job_events", DB_E, "service_job_events"),
|
|
("technician_profiles", DB_E, "technician_profiles"), ("technician_skills", DB_E, "technician_skills"),
|
|
("technician_leaves", DB_E, "technician_leaves"), ("technician_working_hours", DB_E, "technician_working_hours"),
|
|
("refund_requests", DB_E, "refund_requests"), ("refund_media", DB_E, "refund_media"),
|
|
("warranties", DB_E, "warranties"), ("customer_reviews", DB_E, "customer_reviews"),
|
|
("product_reviews", DB_E, "product_reviews"), ("product_review_images", DB_E, "product_review_images"),
|
|
("customer_feedbacks", DB_E, "customer_feedbacks"),
|
|
("notifications (commerce)", DB_E, "notifications"), ("notification_templates", DB_E, "notification_templates"),
|
|
("brands", DB_E, "brands"), ("categories", DB_E, "categories"), ("attribute_types", DB_E, "attribute_types"),
|
|
("service_types (crm)", DB_C, "service_types"), ("parts (crm)", DB_C, "parts"),
|
|
("contacts (crm)", DB_C, "contacts"), ("purchase_orders (crm)", DB_C, "purchase_orders"),
|
|
("purchase_order_items (crm)", DB_C, "purchase_order_items"), ("stock_movements (crm)", DB_C, "stock_movements"),
|
|
]
|
|
ok = True
|
|
for label, db, t in modules:
|
|
n = count(db, t)
|
|
flag = "" if n >= 100 else " <-- BELOW 100"
|
|
if n < 100:
|
|
ok = False
|
|
print(f"{label:<38} {n:>6}{flag}")
|
|
print(f"\nDone in {time.time() - t0:.1f}s. All modules >= 100: {ok}")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|