Add controllers for models

- Add REST API controllers for all models
- Controllers use Microdot subroutes
- Support CRUD operations via HTTP endpoints
- Controllers: preset, profile, group, sequence, tab, palette

src/controllers/group.py

@@ -0,0 +1,50 @@
+from microdot import Microdot
+from models.group import Group
+import json
+
+controller = Microdot()
+groups = Group()
+
+@controller.get('')
+async def list_groups(request):
+    """List all groups."""
+    return json.dumps(groups), 200, {'Content-Type': 'application/json'}
+
+@controller.get('/<id>')
+async def get_group(request, id):
+    """Get a specific group by ID."""
+    group = groups.read(id)
+    if group:
+        return json.dumps(group), 200, {'Content-Type': 'application/json'}
+    return json.dumps({"error": "Group not found"}), 404
+
+@controller.post('')
+async def create_group(request):
+    """Create a new group."""
+    try:
+        data = request.json or {}
+        name = data.get("name", "")
+        group_id = groups.create(name)
+        if data:
+            groups.update(group_id, data)
+        return json.dumps(groups.read(group_id)), 201, {'Content-Type': 'application/json'}
+    except Exception as e:
+        return json.dumps({"error": str(e)}), 400
+
+@controller.put('/<id>')
+async def update_group(request, id):
+    """Update an existing group."""
+    try:
+        data = request.json
+        if groups.update(id, data):
+            return json.dumps(groups.read(id)), 200, {'Content-Type': 'application/json'}
+        return json.dumps({"error": "Group not found"}), 404
+    except Exception as e:
+        return json.dumps({"error": str(e)}), 400
+
+@controller.delete('/<id>')
+async def delete_group(request, id):
+    """Delete a group."""
+    if groups.delete(id):
+        return json.dumps({"message": "Group deleted successfully"}), 200
+    return json.dumps({"error": "Group not found"}), 404

src/controllers/palette.py

@@ -0,0 +1,51 @@
+from microdot import Microdot
+from models.pallet import Palette
+import json
+
+controller = Microdot()
+palettes = Palette()
+
+@controller.get('')
+async def list_palettes(request):
+    """List all palettes."""
+    return json.dumps(palettes), 200, {'Content-Type': 'application/json'}
+
+@controller.get('/<id>')
+async def get_palette(request, id):
+    """Get a specific palette by ID."""
+    palette = palettes.read(id)
+    if palette:
+        return json.dumps(palette), 200, {'Content-Type': 'application/json'}
+    return json.dumps({"error": "Palette not found"}), 404
+
+@controller.post('')
+async def create_palette(request):
+    """Create a new palette."""
+    try:
+        data = request.json or {}
+        name = data.get("name", "")
+        colors = data.get("colors", None)
+        palette_id = palettes.create(name, colors)
+        if data:
+            palettes.update(palette_id, data)
+        return json.dumps(palettes.read(palette_id)), 201, {'Content-Type': 'application/json'}
+    except Exception as e:
+        return json.dumps({"error": str(e)}), 400
+
+@controller.put('/<id>')
+async def update_palette(request, id):
+    """Update an existing palette."""
+    try:
+        data = request.json
+        if palettes.update(id, data):
+            return json.dumps(palettes.read(id)), 200, {'Content-Type': 'application/json'}
+        return json.dumps({"error": "Palette not found"}), 404
+    except Exception as e:
+        return json.dumps({"error": str(e)}), 400
+
+@controller.delete('/<id>')
+async def delete_palette(request, id):
+    """Delete a palette."""
+    if palettes.delete(id):
+        return json.dumps({"message": "Palette deleted successfully"}), 200
+    return json.dumps({"error": "Palette not found"}), 404

src/controllers/preset.py

@@ -0,0 +1,49 @@
+from microdot import Microdot
+from models.preset import Preset
+import json
+
+controller = Microdot()
+presets = Preset()
+
+@controller.get('')
+async def list_presets(request):
+    """List all presets."""
+    return json.dumps(presets), 200, {'Content-Type': 'application/json'}
+
+@controller.get('/<id>')
+async def get_preset(request, id):
+    """Get a specific preset by ID."""
+    preset = presets.read(id)
+    if preset:
+        return json.dumps(preset), 200, {'Content-Type': 'application/json'}
+    return json.dumps({"error": "Preset not found"}), 404
+
+@controller.post('')
+async def create_preset(request):
+    """Create a new preset."""
+    try:
+        data = request.json
+        preset_id = presets.create()
+        if presets.update(preset_id, data):
+            return json.dumps(presets.read(preset_id)), 201, {'Content-Type': 'application/json'}
+        return json.dumps({"error": "Failed to create preset"}), 400
+    except Exception as e:
+        return json.dumps({"error": str(e)}), 400
+
+@controller.put('/<id>')
+async def update_preset(request, id):
+    """Update an existing preset."""
+    try:
+        data = request.json
+        if presets.update(id, data):
+            return json.dumps(presets.read(id)), 200, {'Content-Type': 'application/json'}
+        return json.dumps({"error": "Preset not found"}), 404
+    except Exception as e:
+        return json.dumps({"error": str(e)}), 400
+
+@controller.delete('/<id>')
+async def delete_preset(request, id):
+    """Delete a preset."""
+    if presets.delete(id):
+        return json.dumps({"message": "Preset deleted successfully"}), 200
+    return json.dumps({"error": "Preset not found"}), 404

src/controllers/profile.py

@@ -0,0 +1,50 @@
+from microdot import Microdot
+from models.profile import Profile
+import json
+
+controller = Microdot()
+profiles = Profile()
+
+@controller.get('')
+async def list_profiles(request):
+    """List all profiles."""
+    return json.dumps(profiles), 200, {'Content-Type': 'application/json'}
+
+@controller.get('/<id>')
+async def get_profile(request, id):
+    """Get a specific profile by ID."""
+    profile = profiles.read(id)
+    if profile:
+        return json.dumps(profile), 200, {'Content-Type': 'application/json'}
+    return json.dumps({"error": "Profile not found"}), 404
+
+@controller.post('')
+async def create_profile(request):
+    """Create a new profile."""
+    try:
+        data = request.json or {}
+        name = data.get("name", "")
+        profile_id = profiles.create(name)
+        if data:
+            profiles.update(profile_id, data)
+        return json.dumps(profiles.read(profile_id)), 201, {'Content-Type': 'application/json'}
+    except Exception as e:
+        return json.dumps({"error": str(e)}), 400
+
+@controller.put('/<id>')
+async def update_profile(request, id):
+    """Update an existing profile."""
+    try:
+        data = request.json
+        if profiles.update(id, data):
+            return json.dumps(profiles.read(id)), 200, {'Content-Type': 'application/json'}
+        return json.dumps({"error": "Profile not found"}), 404
+    except Exception as e:
+        return json.dumps({"error": str(e)}), 400
+
+@controller.delete('/<id>')
+async def delete_profile(request, id):
+    """Delete a profile."""
+    if profiles.delete(id):
+        return json.dumps({"message": "Profile deleted successfully"}), 200
+    return json.dumps({"error": "Profile not found"}), 404

src/controllers/sequence.py

@@ -0,0 +1,51 @@
+from microdot import Microdot
+from models.squence import Sequence
+import json
+
+controller = Microdot()
+sequences = Sequence()
+
+@controller.get('')
+async def list_sequences(request):
+    """List all sequences."""
+    return json.dumps(sequences), 200, {'Content-Type': 'application/json'}
+
+@controller.get('/<id>')
+async def get_sequence(request, id):
+    """Get a specific sequence by ID."""
+    sequence = sequences.read(id)
+    if sequence:
+        return json.dumps(sequence), 200, {'Content-Type': 'application/json'}
+    return json.dumps({"error": "Sequence not found"}), 404
+
+@controller.post('')
+async def create_sequence(request):
+    """Create a new sequence."""
+    try:
+        data = request.json or {}
+        group_name = data.get("group_name", "")
+        preset_names = data.get("presets", None)
+        sequence_id = sequences.create(group_name, preset_names)
+        if data:
+            sequences.update(sequence_id, data)
+        return json.dumps(sequences.read(sequence_id)), 201, {'Content-Type': 'application/json'}
+    except Exception as e:
+        return json.dumps({"error": str(e)}), 400
+
+@controller.put('/<id>')
+async def update_sequence(request, id):
+    """Update an existing sequence."""
+    try:
+        data = request.json
+        if sequences.update(id, data):
+            return json.dumps(sequences.read(id)), 200, {'Content-Type': 'application/json'}
+        return json.dumps({"error": "Sequence not found"}), 404
+    except Exception as e:
+        return json.dumps({"error": str(e)}), 400
+
+@controller.delete('/<id>')
+async def delete_sequence(request, id):
+    """Delete a sequence."""
+    if sequences.delete(id):
+        return json.dumps({"message": "Sequence deleted successfully"}), 200
+    return json.dumps({"error": "Sequence not found"}), 404

src/controllers/tab.py

@@ -0,0 +1,52 @@
+from microdot import Microdot
+from models.tab import Tab
+import json
+
+controller = Microdot()
+tabs = Tab()
+
+@controller.get('')
+async def list_tabs(request):
+    """List all tabs."""
+    return json.dumps(tabs), 200, {'Content-Type': 'application/json'}
+
+@controller.get('/<id>')
+async def get_tab(request, id):
+    """Get a specific tab by ID."""
+    tab = tabs.read(id)
+    if tab:
+        return json.dumps(tab), 200, {'Content-Type': 'application/json'}
+    return json.dumps({"error": "Tab not found"}), 404
+
+@controller.post('')
+async def create_tab(request):
+    """Create a new tab."""
+    try:
+        data = request.json or {}
+        name = data.get("name", "")
+        names = data.get("names", None)
+        preset_ids = data.get("presets", None)
+        tab_id = tabs.create(name, names, preset_ids)
+        if data:
+            tabs.update(tab_id, data)
+        return json.dumps(tabs.read(tab_id)), 201, {'Content-Type': 'application/json'}
+    except Exception as e:
+        return json.dumps({"error": str(e)}), 400
+
+@controller.put('/<id>')
+async def update_tab(request, id):
+    """Update an existing tab."""
+    try:
+        data = request.json
+        if tabs.update(id, data):
+            return json.dumps(tabs.read(id)), 200, {'Content-Type': 'application/json'}
+        return json.dumps({"error": "Tab not found"}), 404
+    except Exception as e:
+        return json.dumps({"error": str(e)}), 400
+
+@controller.delete('/<id>')
+async def delete_tab(request, id):
+    """Delete a tab."""
+    if tabs.delete(id):
+        return json.dumps({"message": "Tab deleted successfully"}), 200
+    return json.dumps({"error": "Tab not found"}), 404