4fd110a33d
Symmetric relationship types (isdirectional flag, migration 7d19) show
one entry per peer on the relationships card - a Dualpath pair no
longer lists its partner twice - and directional types read naturally
instead of Outgoing/Incoming. Deleting a collapsed entry removes every
underlying direction row.
Propagation is now real (migration 7d20): relationship types declare
propagation-through pairs in relationshiptypepropagations (M:N,
replacing the never-consumed single column); creating a controls link
on either bay of a Dualpath pair auto-creates it on the partner,
mirrored across both endpoints because live data stores controls as
bay -> PC. flask relationships propagate backfills existing data (29
rows fanned out on the WJ dataset, idempotent).
This also completes the tree that commit 1d21bf0 accidentally split
(core/models/__init__ imported RelationshipTypePropagation ahead of the
file that defines it), returning CI to green.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
488 lines
19 KiB
Python
488 lines
19 KiB
Python
"""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')
|
|
|
|
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
|
|
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))
|
|
|
|
# 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."""
|
|
from shopdb.extensions import db
|
|
from shopdb.core.models import User, Role
|
|
from werkzeug.security import generate_password_hash
|
|
|
|
# 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'))
|