shopdb-flask/shopdb/cli/__init__.py

"""Flask CLI commands."""

import click
from flask.cli import with_appcontext


@click.group('db-utils')
def db_cli():
    """Database utility commands."""
    pass


@db_cli.command('create-all')
@with_appcontext
def create_all():
    """Create all database tables."""
    from shopdb.extensions import db

    db.create_all()
    click.echo(click.style("All tables created.", fg='green'))


@db_cli.command('preflight')
@with_appcontext
def preflight():
    """Check install prerequisites before `flask db upgrade`.

    Reports what must be fixed/installed (Python, required env, DB connectivity,
    and the MySQL 5.6 utf8mb4 index flags). Exits non-zero if anything blocks.
    """
    import sys
    import os
    from sqlalchemy import text
    from flask import current_app
    from shopdb.extensions import db

    failures = []
    warnings = []

    def ok(msg):
        click.echo(click.style('  PASS ', fg='green') + msg)

    def fail(msg, fix):
        failures.append((msg, fix))
        click.echo(click.style('  FAIL ', fg='red') + msg)
        click.echo(click.style('       fix: ', fg='red') + fix)

    def warn(msg, fix):
        warnings.append((msg, fix))
        click.echo(click.style('  WARN ', fg='yellow') + msg)
        click.echo(click.style('       ', fg='yellow') + fix)

    click.echo(click.style('ShopDB preflight', bold=True))

    # Python
    py = sys.version_info
    if py >= (3, 9):
        ok(f'Python {py.major}.{py.minor}.{py.micro}')
    else:
        fail(f'Python {py.major}.{py.minor} is too old',
             'Install Python 3.9 or newer.')

    # Required config
    for key in ('SECRET_KEY', 'JWT_SECRET_KEY', 'DATABASE_URL'):
        value = current_app.config.get(key) or os.environ.get(key)
        if value and 'change' not in str(value).lower() and 'dev-' not in str(value).lower():
            ok(f'{key} is set')
        else:
            fail(f'{key} is missing or a dev default',
                 f'Set {key} in .env (64+ random chars for the secrets).')

    # DB connectivity + MySQL index prerequisites
    try:
        version = db.session.execute(text('SELECT VERSION()')).scalar()
        ok(f'Database reachable (MySQL {version})')
    except Exception as exc:
        fail('Cannot connect to the database', f'Check DATABASE_URL / server. ({exc})')
        version = ''

    if version and version.startswith('5.6'):
        variables = {}
        for name in ('innodb_large_prefix', 'innodb_file_format', 'innodb_file_per_table'):
            try:
                row = db.session.execute(text(f"SHOW VARIABLES LIKE '{name}'")).fetchone()
                variables[name] = row[1] if row else None
            except Exception:
                variables[name] = None
        needed = {'innodb_large_prefix': 'ON', 'innodb_file_format': 'Barracuda',
                  'innodb_file_per_table': 'ON'}
        bad = [n for n, want in needed.items() if str(variables.get(n)).lower() != want.lower()]
        if bad:
            fail('MySQL 5.6 index flags not set: ' + ', '.join(bad),
                 'Add to my.cnf [mysqld]: innodb_file_per_table=1, '
                 'innodb_file_format=Barracuda, innodb_large_prefix=1 (then restart). '
                 'Otherwise `flask db upgrade` fails with error 1071.')
        else:
            ok('MySQL 5.6 index flags OK (Barracuda + large_prefix)')
    elif version:
        ok('MySQL 5.7+/8.0 - no extra index flags needed')

    # The database's own default charset. Tables are forced to utf8mb4 by the
    # compiler hook (shopdb/utils/mysql_charset.py), so a latin1 default does not
    # break the schema - but anything created OUTSIDE that path inherits it, and
    # a database created without an explicit CHARSET is the usual cause. Cheap to
    # check here, invisible until characters come back mangled.
    if version:
        try:
            row = db.session.execute(text(
                'SELECT DEFAULT_CHARACTER_SET_NAME FROM information_schema.SCHEMATA '
                'WHERE SCHEMA_NAME = DATABASE()')).fetchone()
            charset = row[0] if row else None
            if charset is None:
                warn('Could not read the database default charset',
                     'Not fatal - tables are forced to utf8mb4 regardless.')
            elif str(charset).lower() == 'utf8mb4':
                ok('Database default charset is utf8mb4')
            else:
                warn(f'Database default charset is {charset}, not utf8mb4',
                     'Tables this application creates are forced to utf8mb4, so the '
                     'schema is correct. Fix the default so anything created outside '
                     'the migrations matches: ALTER DATABASE <name> CHARACTER SET '
                     'utf8mb4 COLLATE utf8mb4_unicode_ci;')
        except Exception as exc:
            warn('Could not read the database default charset', f'({exc})')

    click.echo('')
    if failures:
        click.echo(click.style(f'{len(failures)} blocker(s). Fix them before installing.', fg='red', bold=True))
        raise SystemExit(1)
    click.echo(click.style('All prerequisites met.' + (f' ({len(warnings)} warning(s))' if warnings else ''), fg='green', bold=True))


@db_cli.command('drop-all')
@click.confirmation_option(prompt='This will delete ALL data. Are you sure?')
@with_appcontext
def drop_all():
    """Drop all database tables."""
    from shopdb.extensions import db

    db.drop_all()
    click.echo(click.style("All tables dropped.", fg='yellow'))


@click.group('seed')
def seed_cli():
    """Database seeding commands."""
    pass


@seed_cli.command('reference-data')
@with_appcontext
def seed_reference_data():
    """Seed reference data (model types, statuses, etc.)."""
    from shopdb.extensions import db
    from shopdb.core.models import (ModelType, OperatingSystem, AssetStatus,
                                     LocationType, CommunicationType)
    from shopdb.core.models.relationship import RelationshipType

    # Model types (type the vendor models catalog)
    model_types = [
        {'modeltype': 'CNC Mill', 'category': 'Equipment', 'description': 'CNC Milling Machine'},
        {'modeltype': 'CNC Lathe', 'category': 'Equipment', 'description': 'CNC Lathe'},
        {'modeltype': 'CMM', 'category': 'Equipment', 'description': 'Coordinate Measuring Machine'},
        {'modeltype': 'EDM', 'category': 'Equipment', 'description': 'Electrical Discharge Machine'},
        {'modeltype': 'Grinder', 'category': 'Equipment', 'description': 'Grinding Machine'},
        {'modeltype': 'Inspection Station', 'category': 'Equipment', 'description': 'Inspection Station'},
        {'modeltype': 'Desktop PC', 'category': 'PC', 'description': 'Desktop Computer'},
        {'modeltype': 'Laptop', 'category': 'PC', 'description': 'Laptop Computer'},
        {'modeltype': 'Shopfloor PC', 'category': 'PC', 'description': 'Shopfloor Computer'},
        {'modeltype': 'Server', 'category': 'Network', 'description': 'Server'},
        {'modeltype': 'Switch', 'category': 'Network', 'description': 'Network Switch'},
        {'modeltype': 'Access Point', 'category': 'Network', 'description': 'Wireless Access Point'},
    ]

    for mt_data in model_types:
        existing = ModelType.query.filter_by(modeltype=mt_data['modeltype']).first()
        if not existing:
            mt = ModelType(**mt_data)
            db.session.add(mt)

    # Asset statuses (canonical set - the asset model is the contract)
    asset_statuses = [
        {'status': 'In Use', 'description': 'Currently in use', 'color': '#28a745'},
        {'status': 'Inventory', 'description': 'In inventory', 'color': '#17a2b8'},
        {'status': 'In Repair', 'description': 'Being repaired', 'color': '#ffc107'},
        {'status': 'Retired', 'description': 'No longer in use', 'color': '#6c757d'},
        {'status': 'Returned', 'description': 'Returned to vendor or owner', 'color': '#fd7e14'},
        {'status': 'Warrantied', 'description': 'Under warranty service', 'color': '#20c997'},
        {'status': 'Lost', 'description': 'Lost or missing', 'color': '#dc3545'},
    ]

    for s_data in asset_statuses:
        existing = AssetStatus.query.filter_by(status=s_data['status']).first()
        if not existing:
            db.session.add(AssetStatus(isactive=True, **s_data))
        elif existing.isactive is not True:
            existing.isactive = True

    # Location types (ADR-001)
    location_types = ['section', 'cell', 'subcell', 'operation', 'meetingroom',
                      'lab', 'office', 'storage', 'hallway', 'networkcloset',
                      'building']
    for lt in location_types:
        if not LocationType.query.filter_by(locationtype=lt).first():
            db.session.add(LocationType(locationtype=lt, isactive=True))

    # Communication types (how an asset is reached / its interfaces). The IP
    # type is what the printer + network create routes attach an ipaddress to,
    # so it must exist before any asset import.
    comm_types = [
        ('IP', 'IP address / network reachable'),
        ('Serial', 'Serial (RS-232) connection'),
        ('Network_Interface', 'Physical network interface (MAC/port)'),
        ('USB', 'USB connection'),
        ('Parallel', 'Parallel port connection'),
        ('VNC', 'VNC remote access'),
        ('FTP', 'FTP file transfer'),
        ('DNC', 'Direct numerical control link'),
    ]
    for comtype, description in comm_types:
        if not CommunicationType.query.filter_by(comtype=comtype).first():
            db.session.add(CommunicationType(comtype=comtype, description=description))

    # Operating systems
    os_list = [
        {'osname': 'Windows 10', 'osversion': '10.0'},
        {'osname': 'Windows 11', 'osversion': '11.0'},
        {'osname': 'Windows Server 2019', 'osversion': '2019'},
        {'osname': 'Windows Server 2022', 'osversion': '2022'},
        {'osname': 'Linux', 'osversion': 'Various'},
    ]

    for os_data in os_list:
        existing = OperatingSystem.query.filter_by(osname=os_data['osname']).first()
        if not existing:
            os_obj = OperatingSystem(**os_data)
            db.session.add(os_obj)

    # Connection types (pre-1.0 legacy; kept for backward compat with
    # existing relationship rows. New ADR-001 code reasons about the three
    # canonical types below via free-text label.)
    # all symmetric physical/network links -> isdirectional=False so the
    # relationships card shows one direction-blind "connected" entry per peer.
    connection_types = [
        {'relationshiptype': 'Serial Cable', 'description': 'RS-232 or similar serial connection', 'isdirectional': False},
        {'relationshiptype': 'Direct Ethernet', 'description': 'Direct network cable (airgapped)', 'isdirectional': False},
        {'relationshiptype': 'USB', 'description': 'USB connection', 'isdirectional': False},
        {'relationshiptype': 'WiFi', 'description': 'Wireless network connection', 'isdirectional': False},
        {'relationshiptype': 'Dualpath', 'description': 'Redundant/failover network path', 'isdirectional': False},
    ]

    for ct_data in connection_types:
        existing = RelationshipType.query.filter_by(relationshiptype=ct_data['relationshiptype']).first()
        if not existing:
            ct = RelationshipType(**ct_data)
            db.session.add(ct)

    # ADR-001 canonical relationship types. Created first, then their
    # propagation rails are seeded as relationshiptypepropagations rows (M:N).
    # All idempotent.
    #
    # MySQL collation is case-insensitive by default, which would let a
    # legacy capitalized row (e.g. "Controls") match the lowercase
    # "controls" check and skip the insert. Force binary comparison via
    # collate so the three ADR-001 types stay distinct from any legacy
    # rows with the same spelling but different case.
    from sqlalchemy import func, literal
    def _lookup_binary(name):
        dialect = db.engine.dialect.name
        if dialect == 'mysql':
            return RelationshipType.query.filter(
                func.binary(RelationshipType.relationshiptype) == literal(name)
            ).first()
        return RelationshipType.query.filter_by(relationshiptype=name).first()

    adr_types = [
        {'relationshiptype': 'partof', 'description': 'Composition / sub-assembly (ADR-001)', 'isdirectional': True},
        {'relationshiptype': 'controls', 'description': 'Operational authority over another asset (ADR-001)', 'isdirectional': True},
        {'relationshiptype': 'connectedto', 'description': 'Network or data link without authority (ADR-001)', 'isdirectional': False},
    ]
    for at in adr_types:
        if not _lookup_binary(at['relationshiptype']):
            db.session.add(RelationshipType(**at))
    db.session.flush()

    # Seed `controls` propagation rails as M:N rows. controls -> partof
    # (declared; directional rail, not consumed yet) and controls -> Dualpath
    # (consumed; a dual-bay pair shares one controller so both bays carry
    # controls). Idempotent, resolved by name, skipped if a type is missing.
    from shopdb.core.models.relationship import RelationshipTypePropagation

    def _seed_propagation(sourcename, throughname):
        source = _lookup_binary(sourcename)
        through = _lookup_binary(throughname)
        if not source or not through:
            return
        exists = RelationshipTypePropagation.query.filter_by(
            relationshiptypeid=source.relationshiptypeid,
            throughtypeid=through.relationshiptypeid,
        ).first()
        if not exists:
            db.session.add(RelationshipTypePropagation(
                relationshiptypeid=source.relationshiptypeid,
                throughtypeid=through.relationshiptypeid,
            ))

    _seed_propagation('controls', 'partof')
    _seed_propagation('controls', 'Dualpath')

    # Default-printer link: a PC asset -> its default printer asset. Read by the
    # printer-installer endpoint (parity with classic apipcdefaultprinter.asp).
    # Attribute-style edge, not a position rail, so no propagation.
    if not _lookup_binary('defaultprinter'):
        db.session.add(RelationshipType(
            relationshiptype='defaultprinter',
            description='PC to its default printer (installer preselect, ADR-001)'
        ))

    db.session.commit()
    click.echo(click.style("Reference data seeded.", fg='green'))


@seed_cli.command('test-user')
@with_appcontext
def seed_test_user():
    """Create a test admin user (admin / admin123). DEV ONLY."""
    from flask import current_app
    from shopdb.extensions import db
    from shopdb.core.models import User, Role
    from werkzeug.security import generate_password_hash

    # Refuse in production: this seeds a well-known credential. Sites bootstrap
    # a real admin with `flask seed admin` (generated password) or the wizard.
    if not (current_app.config.get('DEBUG') or current_app.config.get('TESTING')):
        raise click.ClickException(
            'seed test-user is dev-only (creates admin/admin123). '
            'Use `flask seed admin` to create a production admin.')

    # Create admin role if not exists
    admin_role = Role.query.filter_by(rolename='admin').first()
    if not admin_role:
        admin_role = Role(rolename='admin', description='Administrator')
        db.session.add(admin_role)

    # Create test user
    test_user = User.query.filter_by(username='admin').first()
    if not test_user:
        test_user = User(
            username='admin',
            email='admin@localhost',
            passwordhash=generate_password_hash('admin123'),
            isactive=True
        )
        test_user.roles.append(admin_role)
        db.session.add(test_user)
        db.session.commit()
        click.echo(click.style("Test user created: admin / admin123", fg='green'))
    else:
        click.echo(click.style("Test user already exists", fg='yellow'))


@seed_cli.command('admin')
@click.option('--username', required=True, help='Admin login username')
@click.option('--email', required=True, help='Admin email address')
@click.option('--password', default=None,
              help='Admin password. Omit to generate a strong one and print it once.')
@with_appcontext
def seed_admin(username, email, password):
    """Create the first admin user for a new site.

    Password is generated and printed ONCE if not supplied. Store it safely.
    """
    import secrets
    from shopdb.extensions import db
    from shopdb.core.models import User, Role
    from werkzeug.security import generate_password_hash

    if User.query.filter_by(username=username).first():
        click.echo(click.style(f'User "{username}" already exists.', fg='yellow'))
        return

    admin_role = Role.query.filter_by(rolename='admin').first()
    if not admin_role:
        admin_role = Role(rolename='admin', description='Administrator')
        db.session.add(admin_role)

    generated = password is None
    if generated:
        password = secrets.token_urlsafe(12)

    user = User(username=username, email=email,
                passwordhash=generate_password_hash(password), isactive=True)
    user.roles.append(admin_role)
    db.session.add(user)
    db.session.commit()

    click.echo(click.style(f'Admin "{username}" created.', fg='green'))
    if generated:
        click.echo(click.style('=' * 52, fg='cyan'))
        click.echo(click.style(f'  Password: {password}', fg='cyan', bold=True))
        click.echo(click.style('  Store this now - it will not be shown again.', fg='cyan'))
        click.echo(click.style('=' * 52, fg='cyan'))


@click.group('relationships')
def relationships_cli():
    """Asset-relationship maintenance commands."""
    pass


@relationships_cli.command('propagate')
@with_appcontext
def propagate_relationships():
    """Backfill propagated relationship rows across symmetric rails.

    Scans every existing relationship of a type that propagates through a
    symmetric through-type (e.g. controls through Dualpath) and creates the
    missing fanned-out rows. Idempotent. Also serves the legacy-import flow:
    the import creates controls links on primary bays, this fans them out to
    the Dualpath partner bays.
    """
    from shopdb.extensions import db
    from shopdb.core.models.relationship import RelationshipType, AssetRelationship
    from shopdb.core.api.assets import propagate_relationship

    # types that actually propagate through at least one symmetric through-type
    propagating_ids = [
        t.relationshiptypeid for t in RelationshipType.query.all()
        if any(not through.isdirectional for through in t.propagatesthrough)
    ]

    total = 0
    if propagating_ids:
        rels = AssetRelationship.query.filter(
            AssetRelationship.relationshiptypeid.in_(propagating_ids),
            AssetRelationship.isactive == True,
        ).all()
        for rel in rels:
            total += len(propagate_relationship(rel))
        db.session.commit()

    click.echo(click.style(f"Propagated {total} relationship row(s).", fg='green'))


@relationships_cli.command('fix-controls-direction')
@with_appcontext
def fix_controls_direction():
    """Flip reversed legacy controls rows to PC -> machine.

    Legacy import stores controls as machine -> PC, which reads as the machine
    having authority over the PC. In reality the PC is the controller (it
    sends programs to the machine and receives logs), so per ADR-001 the PC
    must be the source. Flips every active controls row whose source is a
    machine asset and target is a computer asset. If the flipped row already
    exists, the reversed duplicate is deactivated instead. Idempotent.
    """
    from sqlalchemy.orm import aliased
    from shopdb.extensions import db
    from shopdb.core.models import Asset, AssetType
    from shopdb.core.models.relationship import RelationshipType, AssetRelationship

    controls = RelationshipType.query.filter_by(relationshiptype='controls').first()
    if not controls:
        click.echo(click.style("No 'controls' relationship type; nothing to do.", fg='yellow'))
        return

    sourceasset = aliased(Asset)
    targetasset = aliased(Asset)
    sourcetype = aliased(AssetType)
    targettype = aliased(AssetType)

    reversed_rows = (
        AssetRelationship.query
        .join(sourceasset, AssetRelationship.sourceassetid == sourceasset.assetid)
        .join(targetasset, AssetRelationship.targetassetid == targetasset.assetid)
        .join(sourcetype, sourceasset.assettypeid == sourcetype.assettypeid)
        .join(targettype, targetasset.assettypeid == targettype.assettypeid)
        .filter(
            AssetRelationship.relationshiptypeid == controls.relationshiptypeid,
            AssetRelationship.isactive == True,
            sourcetype.assettype == 'machine',
            targettype.assettype == 'computer',
        )
        .all()
    )

    flipped = 0
    deactivated = 0
    for row in reversed_rows:
        duplicate = AssetRelationship.query.filter_by(
            sourceassetid=row.targetassetid,
            targetassetid=row.sourceassetid,
            relationshiptypeid=controls.relationshiptypeid,
        ).first()
        if duplicate:
            row.isactive = False  # flipped row already exists, retire this one
            deactivated += 1
        else:
            row.sourceassetid, row.targetassetid = row.targetassetid, row.sourceassetid
            flipped += 1
    db.session.commit()

    click.echo(click.style(
        f"Flipped {flipped} controls row(s) to PC -> machine"
        f" ({deactivated} reversed duplicate(s) deactivated).", fg='green'))


@seed_cli.command('permissions')
@with_appcontext
def seed_permissions():
    """Seed predefined permissions."""
    from shopdb.extensions import db
    from shopdb.core.models import Permission

    created = Permission.seed()
    db.session.commit()
    click.echo(click.style(f"{created} permissions created.", fg='green'))


@seed_cli.command('settings')
@with_appcontext
def seed_settings():
    """Seed default system settings."""
    from shopdb.extensions import db
    from shopdb.core.models import Setting
    from shopdb.core.api.settings import build_default_settings

    defaults = build_default_settings()

    created = 0
    for d in defaults:
        if not Setting.query.filter_by(key=d['key']).first():
            setting = Setting(**d)
            db.session.add(setting)
            created += 1

    db.session.commit()
    click.echo(click.style(f"{created} default settings created.", fg='green'))


# Demo assets carry this assetnumber prefix so a re-run skips what it made and
# an operator can bulk-delete them without touching imported/real rows.
DEMO_PREFIX = 'DEMO-'


@seed_cli.command('demo')
@click.option('--force', is_flag=True,
              help='Add demo rows even if DEMO- assets already exist.')
@with_appcontext
def seed_demo(force):
    """Seed a small, broad sample dataset for a dev/eval site.

    Populates a handful of rows across every asset-based plugin (machines,
    computers, printers, network devices, measuring tools) plus 3D-printed
    parts, with supporting vendors/business-units/locations and a few
    relationships, so every screen has something to show. Run AFTER
    `flask seed reference-data` and after the plugins are installed. Idempotent:
    all rows are keyed on the DEMO- prefix and skipped if already present.

    Not for production. Remove later with:
      flask seed demo-clear
    """
    from shopdb.extensions import db
    from shopdb.core.models import (Asset, AssetType, AssetStatus, Location,
                                    BusinessUnit, Vendor)

    existing = Asset.query.filter(
        Asset.assetnumber.like(f'{DEMO_PREFIX}%')).count()
    if existing and not force:
        click.echo(click.style(
            f"{existing} demo assets already present - nothing to do "
            f"(use --force to add more, or `flask seed demo-clear` to reset).",
            fg='yellow'))
        return

    def status_id(name, fallback=1):
        # resolve status by name, fall back to whatever id 1 is
        s = AssetStatus.query.filter_by(status=name).first()
        return s.statusid if s else fallback

    def get_or_make(model, defaults=None, **lookup):
        # tiny idempotent upsert keyed on lookup fields
        row = model.query.filter_by(**lookup).first()
        if row:
            return row
        row = model(**lookup, **(defaults or {}))
        db.session.add(row)
        db.session.flush()
        return row

    # Supporting reference rows (shared across the asset types below).
    vendors = {v: get_or_make(Vendor, vendor=v) for v in
               ('Haas Automation', 'DMG Mori', 'Dell', 'Zeiss', 'Cisco',
                'Brother')}
    units = {u: get_or_make(BusinessUnit, businessunit=u) for u in
             ('Machining', 'Inspection', 'IT')}
    locations = {loc: get_or_make(Location, locationname=loc) for loc in
                 ('Cell A', 'Cell B', 'QA Lab', 'Server Room', 'Front Office')}

    made = {'assets': 0, 'skipped': 0}

    def make_asset(assettype_name, number, name, subtype_model,
                   status='In Use', location=None, unit=None, vendor=None,
                   serialnumber=None, subtype_kwargs=None):
        # create one Asset + its plugin subtype row, idempotent on assetnumber.
        # returns the Asset, or None when the plugin type is not installed.
        if subtype_model is None:
            return None  # plugin absent on a lean build - skip its demo rows
        atype = AssetType.query.filter_by(assettype=assettype_name).first()
        if not atype:
            return None
        assetnumber = f'{DEMO_PREFIX}{number}'
        if Asset.query.filter_by(assetnumber=assetnumber).first():
            made['skipped'] += 1
            return None
        asset = Asset(
            assetnumber=assetnumber,
            name=name,
            assettypeid=atype.assettypeid,
            statusid=status_id(status),
            serialnumber=serialnumber,
            locationid=locations[location].locationid if location else None,
            businessunitid=units[unit].businessunitid if unit else None,
        )
        db.session.add(asset)
        db.session.flush()
        sub = subtype_model(assetid=asset.assetid, **(subtype_kwargs or {}))
        db.session.add(sub)
        made['assets'] += 1
        return asset

    # Guarded so demo seeding still works on a lean build that omits any of
    # these plugins (ADR-013 Phase 5): a missing model just skips its section.
    def _subtype_model(modulename, classname):
        try:
            module = __import__(f'plugins.{modulename}.models',
                                fromlist=[classname])
            return getattr(module, classname)
        except ImportError:
            return None

    Machine = _subtype_model('machines', 'Machine')
    Computer = _subtype_model('computers', 'Computer')
    Printer = _subtype_model('printers', 'Printer')
    NetworkDevice = _subtype_model('network', 'NetworkDevice')
    MeasuringTool = _subtype_model('measuringtools', 'MeasuringTool')

    machines = [
        ('MILL-01', 'Haas VF-2 Mill', 'In Use', 'Cell A', 'Machining'),
        ('MILL-02', 'Haas VF-4 Mill', 'In Use', 'Cell A', 'Machining'),
        ('LATHE-01', 'DMG Mori NLX Lathe', 'In Use', 'Cell B', 'Machining'),
        ('LATHE-02', 'DMG Mori CLX Lathe', 'In Repair', 'Cell B', 'Machining'),
        ('EDM-01', 'Wire EDM', 'Inventory', 'Cell B', 'Machining'),
        ('GRIND-01', 'Surface Grinder', 'In Use', 'Cell A', 'Machining'),
    ]
    for num, name, st, loc, unit in machines:
        make_asset('machine', num, name, Machine, status=st,
                   location=loc, unit=unit, serialnumber=f'SN-{num}')

    computers = [
        ('PC-01', 'Shopfloor PC - Cell A', 'In Use', 'Cell A'),
        ('PC-02', 'Shopfloor PC - Cell B', 'In Use', 'Cell B'),
        ('PC-03', 'QA Workstation', 'In Use', 'QA Lab'),
        ('PC-04', 'Engineering Laptop', 'In Use', 'Front Office'),
        ('PC-05', 'Spare Desktop', 'Inventory', 'Front Office'),
        ('PC-06', 'Retired Tower', 'Retired', 'Front Office'),
    ]
    for num, name, st, loc in computers:
        make_asset('computer', num, name, Computer, status=st,
                   location=loc, unit='IT', serialnumber=f'SN-{num}')

    printers = [
        ('PRN-01', 'Cell A Label Printer', 'In Use', 'Cell A'),
        ('PRN-02', 'QA Report Printer', 'In Use', 'QA Lab'),
        ('PRN-03', 'Office MFP', 'In Use', 'Front Office'),
        ('PRN-04', 'Spare Printer', 'Inventory', 'Front Office'),
    ]
    for num, name, st, loc in printers:
        make_asset('printer', num, name, Printer, status=st,
                   location=loc, unit='IT')

    network = [
        ('NET-01', 'Cell A Switch', 'In Use', 'Cell A'),
        ('NET-02', 'Cell B Switch', 'In Use', 'Cell B'),
        ('NET-03', 'Core Switch', 'In Use', 'Server Room'),
        ('NET-04', 'Shop Access Point', 'In Use', 'Cell A'),
    ]
    for num, name, st, loc in network:
        make_asset('network_device', num, name, NetworkDevice, status=st,
                   location=loc, unit='IT')

    tools = [
        ('CMM-01', 'Zeiss CMM', 'In Use', 'QA Lab'),
        ('GAGE-01', 'Height Gage', 'In Use', 'QA Lab'),
        ('GAGE-02', 'Bore Gage', 'In Use', 'QA Lab'),
        ('MIC-01', 'Digital Micrometer', 'In Use', 'Cell A'),
        ('CAL-01', 'Digital Caliper', 'Inventory', 'QA Lab'),
    ]
    for num, name, st, loc in tools:
        make_asset('measuring_tool', num, name, MeasuringTool, status=st,
                   location=loc, unit='Inspection')

    # 3D-printed parts are not assets - own table. A couple sit below their
    # low-stock threshold on purpose so the low-stock alert has something to fire.
    printedparts_made = 0
    try:
        from plugins.printedparts.models import PrintedItem
        parts = [
            # itemname, itemcode, gagelabtag, qty, threshold, bin
            ('Fixture Bracket', 'PP0001', 'WJRP10021', 12, 4, 'A1'),
            ('Gage Holder', 'PP0002', 'WJRP10022', 3, 5, 'A2'),
            ('Cable Clip', 'PP0003', None, 40, 10, 'B1'),
            ('Sensor Mount', 'PP0004', 'WJRP10023', 2, 6, 'B2'),
            ('Label Guide', 'PP0005', None, 25, 8, 'C1'),
            ('Knob Cover', 'PP0006', None, 0, 3, 'C2'),
        ]
        for name, code, tag, qty, thr, binloc in parts:
            if PrintedItem.query.filter_by(itemcode=code).first():
                continue
            db.session.add(PrintedItem(
                itemname=name, itemcode=code, gagelabtag=tag,
                quantityonhand=qty, lowstockthreshold=thr, binlocation=binloc,
                itemdescription=f'Sample 3D-printed part: {name}.'))
            printedparts_made += 1
    except ImportError:
        pass  # printedparts plugin not installed - skip

    db.session.flush()

    # A few relationships so the map + relationship cards are not empty.
    rels_made = 0
    try:
        from shopdb.core.models.relationship import (RelationshipType,
                                                     AssetRelationship)

        def asset_by(number):
            return Asset.query.filter_by(
                assetnumber=f'{DEMO_PREFIX}{number}').first()

        def link(source_num, target_num, typename):
            nonlocal rels_made
            rt = RelationshipType.query.filter_by(
                relationshiptype=typename).first()
            s, t = asset_by(source_num), asset_by(target_num)
            if not (rt and s and t):
                return
            exists = AssetRelationship.query.filter_by(
                sourceassetid=s.assetid, targetassetid=t.assetid,
                relationshiptypeid=rt.relationshiptypeid).first()
            if exists:
                return
            db.session.add(AssetRelationship(
                sourceassetid=s.assetid, targetassetid=t.assetid,
                relationshiptypeid=rt.relationshiptypeid))
            rels_made += 1

        link('PC-01', 'MILL-01', 'controls')       # cell PC drives the mill
        link('PC-02', 'LATHE-01', 'controls')
        link('PC-01', 'PRN-01', 'defaultprinter')  # PC to its default printer
        link('MILL-01', 'NET-01', 'connectedto')   # machine on the cell switch
        link('NET-01', 'NET-03', 'connectedto')    # cell switch to core
    except Exception:
        pass  # relationship model surface changed - skip, assets still seeded

    db.session.commit()
    click.echo(click.style(
        f"Demo data seeded: {made['assets']} assets, "
        f"{printedparts_made} printed parts, {rels_made} relationships "
        f"({made['skipped']} already existed).", fg='green'))
    click.echo("Remove later with: flask seed demo-clear")


@seed_cli.command('demo-clear')
@click.option('--yes', is_flag=True, help='Skip the confirmation prompt.')
@with_appcontext
def seed_demo_clear(yes):
    """Delete everything `flask seed demo` created (DEMO- assets + sample parts).

    Only touches rows the demo seeder made: assets with the DEMO- prefix (their
    plugin subtype rows cascade) and the PP000x sample printed parts. Leaves
    reference data, settings, users, and any real/imported rows alone.
    """
    from shopdb.extensions import db
    from shopdb.core.models import Asset

    demo_ids = [a.assetid for a in Asset.query.filter(
        Asset.assetnumber.like(f'{DEMO_PREFIX}%')).all()]
    try:
        from plugins.printedparts.models import PrintedItem
        parts_count = PrintedItem.query.filter(
            PrintedItem.itemcode.like('PP000%')).count()
    except ImportError:
        parts_count = 0

    if not demo_ids and not parts_count:
        click.echo(click.style("No demo data found.", fg='yellow'))
        return
    if not yes:
        click.confirm(
            f"Delete {len(demo_ids)} demo assets and "
            f"{parts_count} sample parts?", abort=True)

    if demo_ids:
        # Drop the demo relationships first - assetrelationships has no cascade
        # to assets, so a leftover edge would block the asset delete.
        from shopdb.core.models.relationship import AssetRelationship
        AssetRelationship.query.filter(
            db.or_(AssetRelationship.sourceassetid.in_(demo_ids),
                   AssetRelationship.targetassetid.in_(demo_ids))
        ).delete(synchronize_session=False)
        # Bulk hard-delete via a single DELETE statement so the DB-level
        # ON DELETE CASCADE removes each plugin subtype row. Per-object
        # ORM delete would instead try to NULL the child assetid (NOT NULL)
        # and fail.
        Asset.query.filter(Asset.assetid.in_(demo_ids)).delete(
            synchronize_session=False)

    parts_deleted = 0
    if parts_count:
        parts_deleted = PrintedItem.query.filter(
            PrintedItem.itemcode.like('PP000%')).delete(
            synchronize_session=False)

    db.session.commit()
    click.echo(click.style(
        f"Removed {len(demo_ids)} demo assets and "
        f"{parts_deleted} sample parts.", fg='green'))