feat: add sub category for media

Reviewed-on: http://95.38.179.159:3000/Amirmahdi/back-meditation/pulls/3

app/Http/Controllers/CategoryController.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Models\Category;
+use Illuminate\Http\Request;
+
+class CategoryController extends Controller
+{
+    public function index(Request $request)
+    {
+        $query = Category::query()->withCount('subcategories');
+
+        if ($request->boolean('with_subcategories')) {
+            $query->with('subcategories');
+        }
+
+        return response()->json(
+            $query->orderBy('name')->get()
+        );
+    }
+
+    public function store(Request $request)
+    {
+        $data = $request->validate([
+            'name' => 'required|string|max:255|unique:categories,name',
+        ]);
+
+        $category = Category::create($data);
+
+        return response()->json([
+            'message' => 'Category created successfully',
+            'category' => $category,
+        ], 201);
+    }
+
+    public function show($id)
+    {
+        $category = Category::with('subcategories')->withCount('subcategories')->findOrFail($id);
+
+        return response()->json($category);
+    }
+
+    public function update(Request $request, $id)
+    {
+        $category = Category::findOrFail($id);
+
+        $data = $request->validate([
+            'name' => 'required|string|max:255|unique:categories,name,' . $category->id,
+        ]);
+
+        $category->update($data);
+
+        return response()->json([
+            'message' => 'Category updated successfully',
+            'category' => $category,
+        ]);
+    }
+
+    public function destroy($id)
+    {
+        $category = Category::findOrFail($id);
+        $category->delete();
+
+        return response()->json(['message' => 'Category deleted successfully']);
+    }
+}

app/Http/Controllers/CommentController.php

@@ -127,10 +127,11 @@ private function getModelClass($type)
         $models = [
             'music' => \App\Models\Music::class,
             'media' => \App\Models\Media::class,
+            'playlist' => \App\Models\MusicPlaylist::class, 
         ];
         
         if (!isset($models[$type])) {
-            abort(404, 'Invalid model type');
+            abort(404, 'Invalid model type. Supported types: music, media, playlist');
         }
         
         return $models[$type];

app/Http/Controllers/LikeController.php

@@ -0,0 +1,236 @@
+<?php
+
+namespace App\Http\Controllers;
+use App\Models\Like;
+use Illuminate\Http\Request;
+
+class LikeController extends Controller
+{
+     /**
+     * Like an item (music or media)
+     */
+    public function like(Request $request)
+    {
+        $request->validate([
+            'type' => 'required|string|in:music,media,playlist',
+            'id' => 'required|integer',
+        ]);
+        
+        $model = $this->getModel($request->type, $request->id);
+        
+        if (!$model) {
+            return response()->json([
+                'message' => 'Item not found'
+            ], 404);
+        }
+        
+        $result = $model->addLike();
+        
+        return response()->json([
+            'message' => 'Item liked successfully',
+            'is_liked' => true,
+            'likes_count' => $model->likes_count
+        ]);
+    }
+    
+    /**
+     * Unlike an item
+     */
+    public function unlike(Request $request)
+    {
+        $request->validate([
+            'type' => 'required|string|in:music,media,playlist',
+            'id' => 'required|integer',
+        ]);
+        
+        $model = $this->getModel($request->type, $request->id);
+        
+        if (!$model) {
+            return response()->json([
+                'message' => 'Item not found'
+            ], 404);
+        }
+        
+        $result = $model->removeLike();
+        
+        return response()->json([
+            'message' => 'Item unliked successfully',
+            'is_liked' => false,
+            'likes_count' => $model->likes_count
+        ]);
+    }
+    
+    /**
+     * Toggle like status
+     */
+    public function toggleLike(Request $request)
+    {
+        $request->validate([
+            'type' => 'required|string|in:music,media,playlist',
+            'id' => 'required|integer',
+        ]);
+        
+        $model = $this->getModel($request->type, $request->id);
+        
+        if (!$model) {
+            return response()->json([
+                'message' => 'Item not found'
+            ], 404);
+        }
+        
+        $result = $model->toggleLike();
+        
+        return response()->json([
+            'message' => $result ? 'Item liked successfully' : 'Item unliked successfully',
+            'is_liked' => $model->is_liked,
+            'likes_count' => $model->likes_count
+        ]);
+    }
+    
+    /**
+     * Get all liked items for the authenticated user
+     */
+    public function myLikedItems(Request $request)
+    {
+        $type = $request->get('type'); // Optional filter by type (music or media)
+        
+        $query = Like::with('likeable')
+            ->where('user_id', auth()->id());
+        
+        if ($type) {
+            $modelClass = $this->getModelClass($type);
+            $query->where('likeable_type', $modelClass);
+        }
+        
+        $likedItems = $query->latest()->paginate(20);
+
+          return response()->json([
+            'data' => $likedItems,
+            'total' => $likedItems->total(),
+            'types' => [
+                'music' => 'App\\Models\\Music',
+                'media' => 'App\\Models\\Media',
+                'playlist' => 'App\\Models\\MusicPlaylist',
+            ]
+        ]);
+        // Transform the response
+        // $transformedItems = $likedItems->map(function ($likeItem) {
+        //     $item = $likeItem->likeable;
+            
+        //     if (!$item) return null;
+            
+        //     $baseData = [
+        //         'like_id' => $likeItem->id,
+        //         'liked_at' => $likeItem->created_at,
+        //         'type' => class_basename($likeItem->likeable_type),
+        //         'is_liked' => true,
+        //     ];
+            
+        //     // Add type-specific data
+        //     if ($item instanceof \App\Models\Music) {
+        //         return array_merge($baseData, [
+        //             'id' => $item->id,
+        //             'title' => $item->title,
+        //             'artist' => $item->artist,
+        //             'duration' => $item->duration_formatted ?? $item->duration,
+        //             'image_url' => $item->image_url,
+        //             'likes_count' => $item->likes_count,
+        //             'type_display' => 'music'
+        //         ]);
+        //     } elseif ($item instanceof \App\Models\Media) {
+        //         return array_merge($baseData, [
+        //             'id' => $item->id,
+        //             'title' => $item->title,
+        //             'caption' => $item->caption,
+        //             'media_type' => $item->type,
+        //             'duration' => $item->duration,
+        //             'image_url' => $item->image->url ?? null,
+        //             'likes_count' => $item->likes_count,
+        //             'type_display' => 'media'
+        //         ]);
+        //     }
+            
+        //     return $baseData;
+        // })->filter();
+        
+        // return response()->json([
+        //     'data' => $transformedItems,
+        //     'total' => $likedItems->total(),
+        //     'current_page' => $likedItems->currentPage(),
+        //     'last_page' => $likedItems->lastPage(),
+        //     'per_page' => $likedItems->perPage(),
+        // ]);
+    }
+    
+    /**
+     * Check if specific item is liked by user
+     */
+    public function checkLiked(Request $request)
+    {
+        $request->validate([
+            'type' => 'required|string|in:music,media,playlist',
+            'id' => 'required|integer',
+        ]);
+        
+        $model = $this->getModel($request->type, $request->id);
+        
+        if (!$model) {
+            return response()->json([
+                'message' => 'Item not found'
+            ], 404);
+        }
+        
+        return response()->json([
+            'is_liked' => $model->is_liked,
+            'likes_count' => $model->likes_count
+        ]);
+    }
+    
+    /**
+     * Get top liked items
+     */
+    public function topLiked(Request $request)
+    {
+        $type = $request->get('type', 'music'); // Default to music
+        $limit = $request->get('limit', 10);
+        
+        $modelClass = $this->getModelClass($type);
+        
+        $items = $modelClass::with(['image'])
+            ->withCount('likes')
+            ->where(function($query) use ($modelClass) {
+                if (property_exists($modelClass, 'type')) {
+                    $query->where('type', 'public');
+                }
+                if (property_exists($modelClass, 'visibility')) {
+                    $query->where('visibility', 'public');
+                }
+            })
+            ->orderBy('likes_count', 'desc')
+            ->limit($limit)
+            ->get();
+        
+        return response()->json([
+            'data' => $items,
+            'type' => $type,
+            'total' => $items->count()
+        ]);
+    }
+    
+    private function getModel($type, $id)
+    {
+        $modelClass = $this->getModelClass($type);
+        return $modelClass::find($id);
+    }
+    
+    private function getModelClass($type)
+    {
+        $models = [
+            'music' => \App\Models\Music::class,
+            'media' => \App\Models\Media::class,
+            'playlist' => \App\Models\MusicPlaylist::class,
+        ];
+
+        return $models[$type] ?? null;
+    }
+}

app/Http/Controllers/MediaController.php

@@ -19,7 +19,7 @@ public function store(Request $request)
             'caption' => 'nullable|string',
             'type' => 'required|in:audio,video',
             'category_id' => 'nullable|exists:categories,id',
-            'category_name' => 'nullable|string|max:255',
+            'subcategory_id' => 'nullable|exists:sub_categories,id',
             'image_id' => 'nullable|exists:images,id',
             'duration' => 'nullable|integer',
             'is_premium' => 'nullable|boolean',
@@ -33,12 +33,6 @@ public function store(Request $request)
 
         $categoryId = $data['category_id'] ?? null;
 
-        if (!$categoryId && isset($data['category_name'])) {
-            $category = Category::firstOrCreate([
-                'name' => $data['category_name']
-            ]);
-            $categoryId = $category->id;
-        }
         $path = null;
         if ($request->hasFile('file')) {
             $path = $request->file('file')->store('media', 'public');
@@ -53,6 +47,7 @@ public function store(Request $request)
             'external_url' => $data['external_url'] ?? null,
             'image_id' => $data['image_id'] ?? null,
             'category_id' => $categoryId,
+            'subcategory_id' => $data['subcategory_id'] ?? null,
             'duration' => $data['duration'] ?? null,
             'visibility' => $data['visibility'] ?? 'public',
             'is_premium'=> $data['is_premium'] ?? false
@@ -69,12 +64,12 @@ public function store(Request $request)
         }
         return response()->json([
             'message' => 'Media created successfully',
-            'media' => $media->load(['image', 'category' , 'tags']),
+            'media' => $media->load(['image', 'category', 'subCategory', 'tags']),
         ]);
     }
 public function index(Request $request)
 {
-    $query = Media::with(['image', 'category', 'myNote', 'tags','comments'])
+    $query = Media::with(['image', 'category', 'subCategory', 'myNote', 'tags','comments'])
         ->where(function ($q) {
             $q->where('visibility', 'public')
               ->orWhere('user_id', auth()->id());
@@ -91,6 +86,11 @@ public function index(Request $request)
         $query->whereIn('category_id', $categories);
     }
 
+    if ($request->filled('subcategories')) {
+        $subcategories = explode(',', $request->subcategories);
+        $query->whereIn('subcategory_id', $subcategories);
+    }
+
     /*
     |--------------------------------------------------------------------------
     | 2️⃣ Multi Duration Ranges
@@ -324,6 +324,7 @@ public function show($id)
     $media = Media::with([
             'image',
             'category',
+            'subCategory',
             'myNote',
             'tags',
             'comments' => function($query) {
@@ -361,6 +362,7 @@ public function show($id)
         'is_premium' => $media->is_premium,
         'image' => $media->image,
         'category' => $media->category,
+        'sub_category' => $media->subCategory,
         'tags' => $media->tags,
         'myNote' => $media->myNote,
         'is_saved' => $media->is_saved,
@@ -442,9 +444,8 @@ public function update(Request $request, $id)
         'caption' => 'nullable|string',
         'type' => 'nullable|in:audio,video',
 
-        // support both: category_id or category_name
         'category_id' => 'nullable|exists:categories,id',
-        'category_name' => 'nullable|string|max:255',
+        'subcategory_id' => 'nullable|exists:sub_categories,id',
         'is_premium' => 'nullable|boolean',
         'image_id' => 'nullable|exists:images,id',
         'duration' => 'nullable|integer',
@@ -455,16 +456,8 @@ public function update(Request $request, $id)
         'tags.*' => 'string',
     ]);
 
-    // --- handle auto-create category ---
     $categoryId = $data['category_id'] ?? $media->category_id;
 
-    if (isset($data['category_name'])) {
-        $category = Category::firstOrCreate([
-            'name' => $data['category_name']
-        ]);
-        $categoryId = $category->id;
-    }
-
     // --- handle file replace ---
     if ($request->hasFile('file')) {
         Storage::disk('public')->delete($media->file_path);
@@ -477,6 +470,7 @@ public function update(Request $request, $id)
         'caption' => $data['caption'] ?? $media->caption,
         'type' => $data['type'] ?? $media->type,
         'category_id' => $categoryId,
+        'subcategory_id' => array_key_exists('subcategory_id', $data) ? $data['subcategory_id'] : $media->subcategory_id,
         'is_premium' => $data['is_premium'] ?? $media->is_premium,
         'duration' => $data['duration'] ?? $media->duration,
         'external_url' => $data['external_url'] ?? $media->external_url,
@@ -546,7 +540,7 @@ public function toggleSaveMedia($id)
     // GET saved
     public function saved()
     {
-        return auth()->user()->savedMedia()->with(['image','category' , 'myNote' , 'tags'])->get();
+        return auth()->user()->savedMedia()->with(['image','category', 'subCategory', 'myNote' , 'tags'])->get();
     }
 
 public function storeNote(Request $request, $mediaId)

app/Http/Controllers/MusicController.php

@@ -10,6 +10,25 @@
 class MusicController extends Controller
 {
 
+    // Add this new method to your MusicController
+    public function getAllMusic()
+    {
+        $userId = auth()->id();
+
+        $music = Music::with(['image', 'playlist'])
+            ->where('type', 'public')
+            ->orWhere(function($query) use ($userId) {
+                $query->where('type', 'private')
+                    ->where('user_id', $userId);
+            })
+            ->orderBy('created_at', 'desc')
+            ->get();
+
+        // Return as array directly (not wrapped in 'data' object)
+        // to match what your old Flutter app expects
+        return response()->json($music);
+    }
+
     public function index()
     {
         $userId = auth()->id();
@@ -104,11 +123,11 @@ public function store(Request $request)
             $data = $request->validate([
                 'title' => 'required|string|max:255',
                 'artist' => 'nullable|string|max:255',
-                'file' => 'required|mimes:mp3,wav,ogg|max:20971520',
+                'file' => 'required|mimes:mp3,wav,ogg,flac|max:20971520',
                 'type' => 'nullable|in:public,private',
                 'image_id' => 'nullable|exists:images,id',
                 'playlist_id' => 'nullable|exists:music_playlists,id',
-                'duration' => 'nullable|string|regex:/^(?:\d+:)?[0-5]?\d:[0-5]\d$/', // validates mm:ss or hh:mm:ss
+                'duration' => 'nullable|integer|min:1', // validates mm:ss or hh:mm:ss
             ]);
 
             // Handle file upload
@@ -188,10 +207,10 @@ public function update(Request $request, $id)
                 'title' => 'nullable|string|max:255',
                 'artist' => 'nullable|string|max:255',
                 'type' => 'nullable|in:public,private',
-                'file' => 'nullable|mimes:mp3,wav,ogg|max:10240',
+                'file' => 'nullable|mimes:mp3,wav,ogg,flac|max:20971520',
                 'image_id' => 'nullable|exists:images,id',
                 'playlist_id' => 'nullable|exists:music_playlists,id',
-                'duration' => 'nullable|string|regex:/^(?:\d+:)?[0-5]?\d:[0-5]\d$/',
+                'duration' => 'nullable|integer|min:1',
                 'order' => 'nullable|integer',
                 'is_active' => 'nullable|boolean',
             ]);

app/Http/Controllers/MusicPlaylistController.php

@@ -10,10 +10,14 @@ class MusicPlaylistController extends Controller
 {
    public function index(Request $request)
         {
-        $query = MusicPlaylist::with(['category', 'image']);
+            $query = MusicPlaylist::with(['category', 'subcategory', 'image']);
             
             if ($request->has('category_id')) {
-            $query->where('category_id', $request->category_id);
+                $query->where('category_id', $request->category_id)->whereNull('subcategory_id');
+            }
+            
+            if ($request->has('subcategory_id')) {
+                $query->where('subcategory_id', $request->subcategory_id);
             }
             
             $playlists = $query->where('is_active', true)->orderBy('order')->get();
@@ -22,9 +26,10 @@ public function index(Request $request)
         }
             
     public function store(Request $request)
-    {
+{
     $data = $request->validate([
-            'category_id' => 'required|exists:music_categories,id',
+        'category_id' => 'nullable|exists:music_categories,id',
+        'subcategory_id' => 'nullable|exists:music_subcategories,id',
         'name' => 'required|string|max:255',
         'description' => 'nullable|string',
         'image_id' => 'nullable|exists:images,id',
@@ -32,29 +37,62 @@ public function store(Request $request)
         'is_active' => 'nullable|boolean',
     ]);
     
+    // Ensure either category_id or subcategory_id is provided
+    if (!$data['category_id'] && !$data['subcategory_id']) {
+        return response()->json([
+            'message' => 'Either category_id or subcategory_id is required'
+        ], 422);
+    }
+    
     $data['slug'] = Str::slug($data['name']);
     
     $playlist = MusicPlaylist::create($data);
     
     return response()->json([
         'message' => 'Playlist created successfully',
-            'playlist' => $playlist->load(['category', 'image'])
+        'playlist' => $playlist->load(['category', 'subcategory', 'image'])
     ], 201);
-    }
+}
     
     public function show($id)
         {
             $playlist = MusicPlaylist::with([
                 'category', 
+                'subcategory',
                 'image',
                 'musics' => function($q) {
                     $q->where('is_active', true)
                     ->with(['image', 'tags'])
                     ->orderBy('order');
+                },
+                'comments' => function($q) { // Add comments relationship
+                    $q->with('user')->latest()->limit(10);
                 }
             ])->findOrFail($id);
+            $userComment = $playlist->userComment();
+            $comments = $playlist->comments()
+                ->with('user')
+                ->latest()
+                ->paginate(15);
             
-        return response()->json($playlist);
+            return response()->json([
+                'playlist' => $playlist,
+                'statistics' => [
+                    'total_musics' => $playlist->musics->count(),
+                    'total_duration' => $playlist->total_duration,
+                    'total_comments' => $playlist->comments_count,
+                    'total_likes' => $playlist->likes_count,
+                    'total_saves' => $playlist->saved_count,
+                ],
+                'user_interaction' => [
+                    'has_commented' => $playlist->has_user_commented,
+                    'user_comment' => $playlist->user_comment,
+                    'user_comment_id' => $playlist->user_comment_id,
+                    'has_liked' => $playlist->is_liked,
+                    'has_saved' => $playlist->is_saved,
+                ],
+                'comments' => $comments,
+            ]);
         }
     
     public function update(Request $request, $id)

app/Http/Controllers/MusicSubcategoryController.php

@@ -0,0 +1,117 @@
+<?php
+
+namespace App\Http\Controllers;
+
+
+use App\Models\MusicSubcategory;
+use App\Models\MusicCategory;
+use Illuminate\Http\Request;
+use Illuminate\Support\Str;
+
+class MusicSubcategoryController extends Controller
+{
+   public function index(Request $request)
+    {
+        $query = MusicSubcategory::with(['category', 'image', 'playlists' => function($q) {
+            $q->where('is_active', true)->orderBy('order');
+        }]);
+        
+        if ($request->has('category_id')) {
+            $query->where('category_id', $request->category_id);
+        }
+        
+        $subcategories = $query->where('is_active', true)->orderBy('order')->get();
+        
+        return response()->json($subcategories);
+    }
+    
+    public function store(Request $request)
+    {
+        try {
+            $data = $request->validate([
+                'category_id' => 'required|exists:music_categories,id',
+                'name' => 'required|string|max:255',
+                'description' => 'nullable|string',
+                'image_id' => 'nullable|exists:images,id',
+                'order' => 'nullable|integer',
+                'is_active' => 'nullable|boolean',
+            ]);
+            
+            $slug = Str::slug($data['name']);
+            
+            // Check for duplicate in same category
+            $existing = MusicSubcategory::where('category_id', $data['category_id'])
+                ->where('slug', $slug)
+                ->first();
+            
+            if ($existing) {
+                return response()->json([
+                    'message' => 'A subcategory with this name already exists in this category',
+                    'errors' => ['name' => ['The subcategory name must be unique within this category.']]
+                ], 422);
+            }
+            
+            $data['slug'] = $slug;
+            $subcategory = MusicSubcategory::create($data);
+            
+            return response()->json([
+                'message' => 'Subcategory created successfully',
+                'subcategory' => $subcategory->load(['category', 'image'])
+            ], 201);
+            
+        } catch (\Exception $e) {
+            return response()->json([
+                'message' => 'An error occurred while creating the subcategory',
+                'error' => $e->getMessage()
+            ], 500);
+        }
+    }
+    
+    public function show($id)
+    {
+        $subcategory = MusicSubcategory::with([
+            'category',
+            'image',
+            'playlists' => function($q) {
+                $q->with(['image', 'musics' => function($q2) {
+                    $q2->where('is_active', true)->with('image')->orderBy('order');
+                }])->where('is_active', true)->orderBy('order');
+            }
+        ])->findOrFail($id);
+        
+        return response()->json($subcategory);
+    }
+    
+    public function update(Request $request, $id)
+    {
+        $subcategory = MusicSubcategory::findOrFail($id);
+        
+        $data = $request->validate([
+            'category_id' => 'sometimes|exists:music_categories,id',
+            'name' => 'sometimes|string|max:255',
+            'description' => 'nullable|string',
+            'image_id' => 'nullable|exists:images,id',
+            'order' => 'nullable|integer',
+            'is_active' => 'nullable|boolean',
+        ]);
+        
+        if (isset($data['name'])) {
+            $data['slug'] = Str::slug($data['name']);
+        }
+        
+        $subcategory->update($data);
+        
+        return response()->json([
+            'message' => 'Subcategory updated successfully',
+            'subcategory' => $subcategory->load(['category', 'image'])
+        ]);
+    }
+    
+    public function destroy($id)
+    {
+        $subcategory = MusicSubcategory::findOrFail($id);
+        $subcategory->delete();
+        
+        return response()->json(['message' => 'Subcategory deleted successfully']);
+    }
+}

app/Http/Controllers/SaveController.php

@@ -0,0 +1,227 @@
+<?php
+// app/Http/Controllers/SaveController.php
+namespace App\Http\Controllers;
+
+use Illuminate\Http\Request;
+use App\Models\SavedItem;
+
+class SaveController extends Controller
+{
+    /**
+     * Save an item (music, media, breathing template, etc.)
+     */
+    public function save(Request $request)
+    {
+        $request->validate([
+            'type' => 'required|string|in:music,media,breathing-template,playlist',
+            'id' => 'required|integer',
+        ]);
+        
+        $model = $this->getModel($request->type, $request->id);
+        
+        if (!$model) {
+            return response()->json([
+                'message' => 'Item not found'
+            ], 404);
+        }
+        
+        $result = $model->addSave();
+        
+        return response()->json([
+            'message' => 'Item saved successfully',
+            'is_saved' => true,
+            'saved_count' => $model->saved_count
+        ]);
+    }
+    
+    /**
+     * Unsave an item
+     */
+    public function unsave(Request $request)
+    {
+        $request->validate([
+            'type' => 'required|string|in:music,media,breathing-template,playlist',
+            'id' => 'required|integer',
+        ]);
+        
+        $model = $this->getModel($request->type, $request->id);
+        
+        if (!$model) {
+            return response()->json([
+                'message' => 'Item not found'
+            ], 404);
+        }
+        
+        $result = $model->removeSave();
+        
+        return response()->json([
+            'message' => 'Item removed from saved',
+            'is_saved' => false,
+            'saved_count' => $model->saved_count
+        ]);
+    }
+    
+    /**
+     * Toggle save status
+     */
+    public function toggleSave(Request $request)
+    {
+        $request->validate([
+            'type' => 'required|string|in:music,media,breathing-template,playlist',
+            'id' => 'required|integer',
+        ]);
+        
+        $model = $this->getModel($request->type, $request->id);
+        
+        if (!$model) {
+            return response()->json([
+                'message' => 'Item not found'
+            ], 404);
+        }
+        
+        $result = $model->toggleSaveStatus();
+        
+        return response()->json([
+            'message' => $result ? 'Item saved successfully' : 'Item removed from saved',
+            'is_saved' => $model->is_saved,
+            'saved_count' => $model->saved_count
+        ]);
+    }
+    
+    /**
+     * Get all saved items for the authenticated user
+     */
+     public function mySavedItems(Request $request)
+    {
+        $type = $request->get('type'); // Optional filter by type
+        
+        $query = SavedItem::with('saveable')
+            ->where('user_id', auth()->id());
+        
+        if ($type) {
+            $modelClass = $this->getModelClass($type);
+            $query->where('saveable_type', $modelClass);
+        }
+        
+        $savedItems = $query->latest()->paginate(20);
+        
+        return response()->json([
+            'data' => $savedItems,
+            'total' => $savedItems->total(),
+            'types' => [
+                'music' => 'App\\Models\\Music',
+                'media' => 'App\\Models\\Media',
+                'breathing-template' => 'App\\Models\\BreathingTemplate',
+                'playlist' => 'App\\Models\\MusicPlaylist',
+            ]
+        ]);
+    }
+    /**
+     * Check if specific item is saved by user
+     */
+    public function checkSaved(Request $request)
+    {
+        $request->validate([
+            'type' => 'required|string|in:music,media,breathing-template,playlist',
+            'id' => 'required|integer',
+        ]);
+        
+        $model = $this->getModel($request->type, $request->id);
+        
+        if (!$model) {
+            return response()->json([
+                'message' => 'Item not found'
+            ], 404);
+        }
+        
+        return response()->json([
+            'is_saved' => $model->is_saved,
+            'saved_count' => $model->saved_count
+        ]);
+    }
+    
+    private function getModel($type, $id)
+    {
+        $modelClass = $this->getModelClass($type);
+        return $modelClass::find($id);
+    }
+    
+    private function getModelClass($type)
+    {
+        $models = [
+            'music' => \App\Models\Music::class,
+            'media' => \App\Models\Media::class,
+            'breathing-template' => \App\Models\BreathingTemplate::class,
+            'playlist' => \App\Models\MusicPlaylist::class,
+        ];
+
+        return $models[$type] ?? null;
+    }
+}
+
+
+
+
+
+//    public function mySavedItems(Request $request)
+//     {
+//         $type = $request->get('type');
+        
+//         $query = SavedItem::with('saveable')
+//             ->where('user_id', auth()->id());
+        
+//         if ($type) {
+//             $modelClass = $this->getModelClass($type);
+//             $query->where('saveable_type', $modelClass);
+//         }
+        
+//         $savedItems = $query->latest()->paginate(20);
+        
+//         // Transform the response to include formatted data
+//         $transformedItems = $savedItems->map(function ($savedItem) {
+//             $item = $savedItem->saveable;
+            
+//             if (!$item) return null;
+            
+//             $baseData = [
+//                 'saved_id' => $savedItem->id,
+//                 'saved_at' => $savedItem->created_at,
+//                 'type' => class_basename($savedItem->saveable_type),
+//             ];
+            
+//             // Add type-specific data
+//             if ($item instanceof \App\Models\Music) {
+//                 return array_merge($baseData, [
+//                     'id' => $item->id,
+//                     'title' => $item->title,
+//                     'artist' => $item->artist,
+//                     'duration' => $item->duration_formatted ?? $item->duration,
+//                     'image_url' => $item->image_url,
+//                     'is_saved' => true,
+//                 ]);
+//             } elseif ($item instanceof \App\Models\Media) {
+//                 return array_merge($baseData, [
+//                     'id' => $item->id,
+//                     'title' => $item->title,
+//                     'caption' => $item->caption,
+//                     'type' => $item->type,
+//                     'duration' => $item->duration,
+//                     'image_url' => $item->image->url ?? null,
+//                     'is_saved' => true,
+//                 ]);
+//             } elseif ($item instanceof \App\Models\BreathingTemplate) {
+//                 return array_merge($baseData, [
+//                     'id' => $item->id,
+//                     'name' => $item->name,
+//                     'description' => $item->description,
+//                     'duration' => $item->duration,
+//                     'inhale' => $item->inhale,
+//                     'exhale' => $item->exhale,
+//                     'breath_hold' => $item->breath_hold,
+//                     'image_url' => $item->image_url,
+//                     'is_saved' => true,
+//                 ]);
+//             }
+            
+//             return $baseData;
+//         })->filter();

app/Http/Controllers/SubCategoryController.php

@@ -0,0 +1,97 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Models\SubCategory;
+use Illuminate\Http\Request;
+
+class SubCategoryController extends Controller
+{
+    public function index(Request $request, $categoryId = null)
+    {
+        $query = SubCategory::with('category')->withCount('media');
+
+        $categoryId = $categoryId ?? $request->input('category_id');
+
+        if ($categoryId) {
+            $query->where('category_id', $categoryId);
+        }
+
+        return response()->json(
+            $query->orderBy('name')->get()
+        );
+    }
+
+    public function store(Request $request)
+    {
+        $data = $request->validate([
+            'category_id' => 'required|exists:categories,id',
+            'name' => 'required|string|max:255',
+        ]);
+
+        $existing = SubCategory::where('category_id', $data['category_id'])
+            ->where('name', $data['name'])
+            ->first();
+
+        if ($existing) {
+            return response()->json([
+                'message' => 'A subcategory with this name already exists in this category',
+                'errors' => ['name' => ['The subcategory name must be unique within this category.']],
+            ], 422);
+        }
+
+        $subCategory = SubCategory::create($data);
+
+        return response()->json([
+            'message' => 'Subcategory created successfully',
+            'sub_category' => $subCategory->load('category'),
+        ], 201);
+    }
+
+    public function show($id)
+    {
+        $subCategory = SubCategory::with('category')->withCount('media')->findOrFail($id);
+
+        return response()->json($subCategory);
+    }
+
+    public function update(Request $request, $id)
+    {
+        $subCategory = SubCategory::findOrFail($id);
+
+        $data = $request->validate([
+            'category_id' => 'sometimes|exists:categories,id',
+            'name' => 'sometimes|string|max:255',
+        ]);
+
+        $categoryId = $data['category_id'] ?? $subCategory->category_id;
+        $name = $data['name'] ?? $subCategory->name;
+
+        $existing = SubCategory::where('category_id', $categoryId)
+            ->where('name', $name)
+            ->where('id', '!=', $subCategory->id)
+            ->first();
+
+        if ($existing) {
+            return response()->json([
+                'message' => 'A subcategory with this name already exists in this category',
+                'errors' => ['name' => ['The subcategory name must be unique within this category.']],
+            ], 422);
+        }
+
+        $subCategory->update($data);
+
+        return response()->json([
+            'message' => 'Subcategory updated successfully',
+            'sub_category' => $subCategory->load('category'),
+        ]);
+    }
+
+    public function destroy($id)
+    {
+        $subCategory = SubCategory::findOrFail($id);
+        $subCategory->delete();
+
+        return response()->json(['message' => 'Subcategory deleted successfully']);
+    }
+}

app/Models/BreathingTemplate.php

@@ -3,16 +3,18 @@
 namespace App\Models;
 
 use Illuminate\Database\Eloquent\Model;
+use App\Traits\HasSaves;
 
 class BreathingTemplate extends Model
 {
+     use HasSaves;
     protected $fillable = ['user_id', 'name', 'inhale', 'exhale', 'breath_hold' , 'duration' , 'description','image_id' , 'source'];
 
     public function user()
     {
         return $this->belongsTo(User::class);
     }
-    protected $appends = ['image_url'];
+    protected $appends = ['image_url', 'is_saved','saved_count'];
 
     public function getImageUrlAttribute()
     {

app/Models/Category.php

@@ -12,5 +12,10 @@ public function questions()
     {
         return $this->hasMany(Question::class);
     }
+
+    public function subcategories()
+    {
+        return $this->hasMany(SubCategory::class);
+    }
 }
 

app/Models/Like.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\MorphTo;
+class Like extends Model
+{
+    protected $table = 'likes';
+    
+    protected $fillable = [
+        'user_id',
+        'likeable_id',
+        'likeable_type',
+    ];
+    
+    public function user(): BelongsTo
+    {
+        return $this->belongsTo(User::class);
+    }
+    
+    public function likeable(): MorphTo
+    {
+        return $this->morphTo();
+    }
+    
+    // Helper methods
+    public static function getLikedItemsForUser($userId, $type = null)
+    {
+        $query = self::with('likeable')->where('user_id', $userId);
+        
+        if ($type) {
+            $query->where('likeable_type', $type);
+        }
+        
+        return $query->latest()->get();
+    }
+    
+    public static function isLikedByUser($userId, $likeableId, $likeableType)
+    {
+        return self::where([
+            'user_id' => $userId,
+            'likeable_id' => $likeableId,
+            'likeable_type' => $likeableType,
+        ])->exists();
+    }
+    
+    public static function getLikeCount($likeableId, $likeableType)
+    {
+        return self::where([
+            'likeable_id' => $likeableId,
+            'likeable_type' => $likeableType,
+        ])->count();
+    }
+}

app/Models/Media.php

@@ -5,13 +5,16 @@
 use Illuminate\Database\Eloquent\Model;
 use App\Traits\HasRatings;
 use App\Traits\HasComments;
+use App\Traits\HasSaves;
+use App\Traits\HasLikes;
 class Media extends Model
 {
-     use HasRatings, HasComments;
+     use HasRatings, HasComments,HasSaves,HasLikes;
   protected $fillable = [
         'user_id',
         'image_id',
         'category_id',
+        'subcategory_id',
         'title',
         'caption',
         'type',
@@ -21,16 +24,22 @@ class Media extends Model
         'visibility',
         'is_premium'
     ];
-protected $appends = [
+    protected $appends = [
         'average_rating',
         'user_rating',
         'ratings_count',
         'comments_count',
-         'has_user_commented',      // Add this
-        'user_comment',            // Add this
-        'user_comment_id',         // Add this
-        'has_user_rated'           // Add this
-];
+        'has_user_commented',    
+        'user_comment',         
+        'user_comment_id',      
+        'has_user_rated',   
+        'is_saved', 
+        'saved_count',
+        'is_liked',   
+        'likes_count',
+'is_liked',
+        'likes_count', 
+    ];
     public function image()
     {
         return $this->belongsTo(Image::class);
@@ -40,6 +49,11 @@ public function category()
     {
         return $this->belongsTo(Category::class);
     }
+
+    public function subCategory()
+    {
+        return $this->belongsTo(SubCategory::class, 'subcategory_id');
+    }
     public function tags()
     {
         return $this->belongsToMany(Tag::class, 'media_tag');

app/Models/Music.php

@@ -10,10 +10,12 @@
 use Illuminate\Database\Eloquent\Relations\MorphMany;    // ← Add this
 use App\Traits\HasRatings;
 use App\Traits\HasComments;
+use App\Traits\HasSaves;
+use App\Traits\HasLikes;
 
 class Music extends Model
 {   
-     use HasFactory, HasRatings, HasComments;
+     use HasFactory, HasRatings, HasComments , HasSaves,HasLikes;
      protected $table = 'music';
     
 
@@ -22,7 +24,7 @@ class Music extends Model
         'playlist_id', 'image_id', 'duration', 'order', 'is_active'
     ];
  protected $casts = [
-        'duration' => 'string',
+        'duration' => 'integer',
         'order' => 'integer',
         'is_active' => 'boolean',
     ];
@@ -43,10 +45,19 @@ public function tags(): BelongsToMany
         return $this->belongsToMany(Tag::class, 'music_tags');
     }
     
-    protected $appends = ['url', 'image_url' , 'average_rating', 'user_rating', 'comments_count' ,     'has_user_commented',      // Add this
-    'user_comment',            // Add this
-    'user_comment_id',         // Add this
-    'has_user_rated'           // Add this];
+    protected $appends = ['url',
+    'image_url' , 
+    'average_rating',
+    'user_rating', 
+    'comments_count' , 
+    'has_user_commented',  
+    'user_comment',         
+    'user_comment_id',         
+    'has_user_rated' ,
+    'is_saved', 
+    'saved_count',
+    'is_liked',
+    'likes_count'      
     ];
 
     public function getUrlAttribute()

app/Models/MusicCategory.php

@@ -23,6 +23,21 @@ public function playlists(): HasMany
         return $this->hasMany(MusicPlaylist::class, 'category_id');
     }
 
+    public function subcategories(): HasMany
+    {
+        return $this->hasMany(MusicSubcategory::class, 'category_id');
+    }
+       // All playlists (including those in subcategories)
+    public function allPlaylists()
+    {
+        $playlists = collect($this->playlists);
+        
+        foreach ($this->subcategories as $subcategory) {
+            $playlists = $playlists->merge($subcategory->playlists);
+        }
+        
+        return $playlists;
+    }
     public function image(): BelongsTo
     {
         return $this->belongsTo(Image::class);
@@ -32,4 +47,18 @@ public function getActivePlaylistsAttribute()
     {
         return $this->playlists()->where('is_active', true)->get();
     }
+
+      // Total music count across all playlists and subcategories
+    public function getTotalMusicCountAttribute()
+    {
+        $count = $this->playlists->sum(function($playlist) {
+            return $playlist->musics->count();
+        });
+        
+        foreach ($this->subcategories as $subcategory) {
+            $count += $subcategory->total_music_count;
+        }
+        
+        return $count;
+    }
 }

app/Models/MusicPlaylist.php

@@ -5,24 +5,43 @@
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;  // ← Add this
 use Illuminate\Database\Eloquent\Relations\HasMany;    // ← Add this
+use App\Traits\HasComments; // Add this
+use App\Traits\HasLikes;
+use App\Traits\HasSaves;
 class MusicPlaylist extends Model
 {
+    use HasComments, HasLikes, HasSaves;
     protected $table = 'music_playlists';
     
     protected $fillable = [
-        'category_id', 'name', 'slug', 'description', 'image_id', 'order', 'is_active'
+        'category_id', 'subcategory_id','name', 'slug', 'description', 'image_id', 'order', 'is_active'
     ];
     
     protected $casts = [
         'is_active' => 'boolean',
         'order' => 'integer',
     ];
-    
+    protected $appends = [
+        'comments_count',
+        'has_user_commented',
+        'user_comment',
+        'user_comment_id',
+        'is_liked',
+        'likes_count',
+        'is_saved',
+        'saved_count'
+    ];
     public function category(): BelongsTo
     {
         return $this->belongsTo(MusicCategory::class, 'category_id');
     }
     
+     public function subcategory(): BelongsTo
+    {
+        return $this->belongsTo(MusicSubcategory::class, 'subcategory_id');
+    }
+    
+    
     public function musics(): HasMany
     {
         return $this->hasMany(Music::class, 'playlist_id');

app/Models/MusicSubcategory.php

@@ -0,0 +1,85 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+class MusicSubcategory extends Model
+{
+        protected $table = 'music_subcategories';
+    
+    protected $fillable = [
+        'category_id', 'name', 'slug', 'description', 'image_id', 'order', 'is_active'
+    ];
+    
+    protected $casts = [
+        'is_active' => 'boolean',
+        'order' => 'integer',
+    ];
+    
+    public function category(): BelongsTo
+    {
+        return $this->belongsTo(MusicCategory::class, 'category_id');
+    }
+    
+    public function playlists(): HasMany
+    {
+        return $this->hasMany(MusicPlaylist::class, 'subcategory_id');
+    }
+    
+    public function image(): BelongsTo
+    {
+        return $this->belongsTo(Image::class);
+    }
+    
+    public function getActivePlaylistsAttribute()
+    {
+        return $this->playlists()->where('is_active', true)->orderBy('order')->get();
+    }
+    
+    // Get total music count across all playlists in this subcategory
+    public function getTotalMusicCountAttribute()
+    {
+        return $this->playlists()
+            ->withCount('musics')
+            ->get()
+            ->sum('musics_count');
+    }
+    
+    // Get total duration across all music in this subcategory
+    public function getTotalDurationAttribute()
+    {
+        $totalSeconds = 0;
+        foreach ($this->playlists as $playlist) {
+            foreach ($playlist->musics as $music) {
+                $totalSeconds += $this->durationToSeconds($music->duration);
+            }
+        }
+        return $this->secondsToDuration($totalSeconds);
+    }
+    
+    private function durationToSeconds($duration)
+    {
+        if (!$duration) return 0;
+        $parts = explode(':', $duration);
+        if (count($parts) === 2) {
+            return (int)$parts[0] * 60 + (int)$parts[1];
+        } elseif (count($parts) === 3) {
+            return (int)$parts[0] * 3600 + (int)$parts[1] * 60 + (int)$parts[2];
+        }
+        return 0;
+    }
+    
+    private function secondsToDuration($seconds)
+    {
+        $hours = floor($seconds / 3600);
+        $minutes = floor(($seconds % 3600) / 60);
+        $secs = $seconds % 60;
+        
+        if ($hours > 0) {
+            return sprintf("%d:%02d:%02d", $hours, $minutes, $secs);
+        }
+        return sprintf("%d:%02d", $minutes, $secs);
+    }
+}

app/Models/SavedItem.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\MorphTo;
+class SavedItem extends Model
+{
+    protected $table = 'saved_items';
+    
+    protected $fillable = [
+        'user_id',
+        'saveable_id',
+        'saveable_type',
+    ];
+    
+    public function user(): BelongsTo
+    {
+        return $this->belongsTo(User::class);
+    }
+    
+    public function saveable(): MorphTo
+    {
+        return $this->morphTo();
+    }
+    
+    // Helper to get saved items by type
+    public static function getSavedItemsForUser($userId, $type = null)
+    {
+        $query = self::with('saveable')->where('user_id', $userId);
+        
+        if ($type) {
+            $query->where('saveable_type', $type);
+        }
+        
+        return $query->latest()->get();
+    }
+    
+    // Check if user has saved specific item
+    public static function isSavedByUser($userId, $saveableId, $saveableType)
+    {
+        return self::where([
+            'user_id' => $userId,
+            'saveable_id' => $saveableId,
+            'saveable_type' => $saveableType,
+        ])->exists();
+    }
+}

app/Models/SubCategory.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+
+class SubCategory extends Model
+{
+    protected $table = 'sub_categories';
+
+    protected $fillable = ['category_id', 'name'];
+
+    public function category(): BelongsTo
+    {
+        return $this->belongsTo(Category::class);
+    }
+
+    public function media(): HasMany
+    {
+        return $this->hasMany(Media::class, 'subcategory_id');
+    }
+}

app/Traits/HasLikes.php

@@ -0,0 +1,59 @@
+<?php
+// app/Traits/HasLikes.php
+namespace App\Traits;
+
+use App\Models\Like;
+use Illuminate\Database\Eloquent\Relations\MorphMany;
+
+trait HasLikes
+{
+    public function likes(): MorphMany
+    {
+        return $this->morphMany(Like::class, 'likeable');
+    }
+    
+    public function getIsLikedAttribute()
+    {
+        if (!auth()->check()) return false;
+        
+        return $this->likes()
+            ->where('user_id', auth()->id())
+            ->exists();
+    }
+    
+    public function getLikesCountAttribute()
+    {
+        return $this->likes()->count();
+    }
+    
+    public function toggleLike()
+    {
+        if ($this->getIsLikedAttribute()) {
+            return $this->removeLike();
+        } else {
+            return $this->addLike();
+        }
+    }
+    
+    public function addLike()
+    {
+        if ($this->getIsLikedAttribute()) return false;
+        
+        return Like::create([
+            'user_id' => auth()->id(),
+            'likeable_id' => $this->id,
+            'likeable_type' => get_class($this),
+        ]);
+    }
+    
+    public function removeLike()
+    {
+        if (!$this->getIsLikedAttribute()) return false;
+        
+        return Like::where([
+            'user_id' => auth()->id(),
+            'likeable_id' => $this->id,
+            'likeable_type' => get_class($this),
+        ])->delete();
+    }
+}

app/Traits/HasSaves.php

@@ -0,0 +1,59 @@
+<?php
+// app/Traits/HasSaves.php
+namespace App\Traits;
+
+use App\Models\SavedItem;
+use Illuminate\Database\Eloquent\Relations\MorphMany;
+
+trait HasSaves
+{
+    public function saves()
+    {
+        return $this->morphMany(SavedItem::class, 'saveable');
+    }
+    
+    public function getIsSavedAttribute()
+    {
+        if (!auth()->check()) return false;
+        
+        return $this->saves()
+            ->where('user_id', auth()->id())
+            ->exists();
+    }
+    
+    public function getSavedCountAttribute()
+    {
+        return $this->saves()->count();
+    }
+    
+    public function toggleSaveStatus()
+    {
+        if ($this->getIsSavedAttribute()) {
+            return $this->removeSave();
+        } else {
+            return $this->addSave();
+        }
+    }
+    
+    public function addSave()
+    {
+        if ($this->getIsSavedAttribute()) return false;
+        
+        return SavedItem::create([
+            'user_id' => auth()->id(),
+            'saveable_id' => $this->id,
+            'saveable_type' => get_class($this),
+        ]);
+    }
+    
+    public function removeSave()
+    {
+        if (!$this->getIsSavedAttribute()) return false;
+        
+        return SavedItem::where([
+            'user_id' => auth()->id(),
+            'saveable_id' => $this->id,
+            'saveable_type' => get_class($this),
+        ])->delete();
+    }
+}

database/migrations/2026_05_21_105404_create_music_subcategories_table.php

@@ -0,0 +1,36 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('music_subcategories', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('category_id')->constrained('music_categories')->onDelete('cascade');
+            $table->string('name');
+            $table->string('slug')->unique();
+            $table->text('description')->nullable();
+            $table->foreignId('image_id')->nullable()->constrained('images')->onDelete('set null');
+            $table->integer('order')->default(0);
+            $table->boolean('is_active')->default(true);
+            $table->timestamps();
+            
+            $table->index(['category_id', 'order']);
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('music_subcategories');
+    }
+};

database/migrations/2026_05_21_105523_add_subcategory_to_playlists.php

@@ -0,0 +1,33 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::table('music_playlists', function (Blueprint $table) {
+           $table->foreignId('subcategory_id')->nullable()->after('category_id')
+                  ->constrained('music_subcategories')->onDelete('cascade');
+            // Make category_id nullable since playlist can belong to subcategory
+            $table->foreignId('category_id')->nullable()->change();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('music_playlists', function (Blueprint $table) {
+           $table->dropForeign(['subcategory_id']);
+            $table->dropColumn('subcategory_id');
+            $table->foreignId('category_id')->nullable(false)->change();
+        });
+    }
+};

database/migrations/2026_05_22_175608_change_duration_to_integer_in_music_table.php

@@ -0,0 +1,55 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+use Illuminate\Support\Facades\DB;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        // Get the database driver
+        $driver = DB::connection()->getDriverName();
+        
+        if ($driver === 'pgsql') {
+            // PostgreSQL: Use raw statement with USING clause
+            DB::statement('ALTER TABLE music ALTER COLUMN duration TYPE integer USING (duration::integer)');
+            
+            Schema::table('music', function (Blueprint $table) {
+                $table->integer('duration')->nullable()->change();
+            });
+        } elseif ($driver === 'mysql') {
+            // MySQL: Can directly change column type
+            Schema::table('music', function (Blueprint $table) {
+                $table->integer('duration')->nullable()->change();
+            });
+        }
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        // Get the database driver
+        $driver = DB::connection()->getDriverName();
+        
+        if ($driver === 'pgsql') {
+            // PostgreSQL: Convert back to text
+            DB::statement('ALTER TABLE music ALTER COLUMN duration TYPE text USING (duration::text)');
+            
+            Schema::table('music', function (Blueprint $table) {
+                $table->string('duration')->nullable()->change();
+            });
+        } elseif ($driver === 'mysql') {
+            // MySQL: Change back to string
+            Schema::table('music', function (Blueprint $table) {
+                $table->string('duration')->nullable()->change();
+            });
+        }
+    }
+};

database/migrations/2026_05_22_200854_create_saved_items_table.php

@@ -0,0 +1,31 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('saved_items', function (Blueprint $table) {
+           $table->id();
+            $table->foreignId('user_id')->constrained()->onDelete('cascade');
+            $table->morphs('saveable'); // saveable_id + saveable_type
+            $table->timestamps();
+            
+            $table->unique(['user_id', 'saveable_id', 'saveable_type']);
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('saved_items');
+    }
+};

database/migrations/2026_05_24_192058_create_likes_table.php

@@ -0,0 +1,30 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('likes', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('user_id')->constrained()->onDelete('cascade');
+            $table->morphs('likeable'); 
+            $table->timestamps();
+            $table->unique(['user_id', 'likeable_id', 'likeable_type']);
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('likes');
+    }
+};

database/migrations/2026_05_30_100000_create_sub_categories_table.php

@@ -0,0 +1,31 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('sub_categories', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('category_id')->constrained('categories')->cascadeOnDelete();
+            $table->string('name');
+            $table->timestamps();
+
+            $table->unique(['category_id', 'name']);
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('sub_categories');
+    }
+};

database/migrations/2026_05_30_100100_add_subcategory_id_to_media_table.php

@@ -0,0 +1,31 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::table('media', function (Blueprint $table) {
+            $table->unsignedBigInteger('subcategory_id')->nullable()->after('category_id');
+
+            $table->foreign('subcategory_id')->references('id')->on('sub_categories')->nullOnDelete();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('media', function (Blueprint $table) {
+            $table->dropForeign(['subcategory_id']);
+            $table->dropColumn('subcategory_id');
+        });
+    }
+};

routes/api.php

@@ -15,11 +15,15 @@
 use App\Http\Controllers\ImageController;
 use App\Http\Controllers\MusicController;
 use App\Http\Controllers\MediaController;
+use App\Http\Controllers\CategoryController;
+use App\Http\Controllers\SubCategoryController;
 use App\Http\Controllers\MusicCategoryController;
 use App\Http\Controllers\MusicPlaylistController;
 use App\Http\Controllers\RatingController;
 use App\Http\Controllers\CommentController;
-
+use App\Http\Controllers\MusicSubcategoryController;
+use App\Http\Controllers\SaveController;
+use App\Http\Controllers\LikeController;
 
 Route::get('/test-hash', function() {
     $plain = 'amnk1380';
@@ -156,6 +160,13 @@
     //add note to media
     Route::post('/media/{id}/note', [MediaController::class, 'storeNote']);
 
+    // Media categories
+    Route::apiResource('categories', CategoryController::class);
+
+    // Media sub categories
+    Route::get('sub-categories/by-category/{categoryId}', [SubCategoryController::class, 'index']);
+    Route::apiResource('sub-categories', SubCategoryController::class);
+
 
 
     // Music Categories
@@ -166,6 +177,14 @@
     Route::apiResource('music-playlists', MusicPlaylistController::class);
     Route::get('playlists/by-category/{categoryId}', [MusicPlaylistController::class, 'index']);
 
+    // Subcategory routes
+    Route::apiResource('music-subcategories', MusicSubcategoryController::class);
+    Route::get('subcategories/by-category/{categoryId}', [MusicSubcategoryController::class, 'index']);
+
+
+    // Music Routes - Add this line before your other routes
+    Route::get('music/all', [MusicController::class, 'getAllMusic']); // For old app compatibility
+
     // Music
     Route::get('music/playlist/{playlistId}', [MusicController::class, 'getMusicByPlaylist']);
     Route::post('music/{musicId}/add-to-playlist', [MusicController::class, 'addToPlaylist']);
@@ -174,6 +193,7 @@
     Route::apiResource('music', MusicController::class);
 
     
+
     // Generic Rating Routes (works for both music and media)
     Route::prefix('ratings')->group(function () {
     Route::post('{type}/{id}', [RatingController::class, 'rate']);
@@ -191,4 +211,25 @@
         Route::delete('{type}/{id}/{commentId}', [CommentController::class, 'deleteComment']);
         Route::get('most/{type}', [CommentController::class, 'mostCommented']);
     });
+
+
+    // Save routes (works for all models)
+    Route::prefix('saves')->group(function () {
+        Route::post('/save', [SaveController::class, 'save']);
+        Route::post('/unsave', [SaveController::class, 'unsave']);
+        Route::post('/toggle', [SaveController::class, 'toggleSave']);
+        Route::get('/my-saved', [SaveController::class, 'mySavedItems']);
+        Route::post('/check', [SaveController::class, 'checkSaved']);
+    });
+
+
+    // Like routes (only for music and media)
+    Route::prefix('likes')->group(function () {
+        Route::post('/like', [LikeController::class, 'like']);
+        Route::post('/unlike', [LikeController::class, 'unlike']);
+        Route::post('/toggle', [LikeController::class, 'toggleLike']);
+        Route::get('/my-liked', [LikeController::class, 'myLikedItems']);
+        Route::post('/check', [LikeController::class, 'checkLiked']);
+        Route::get('/top-liked', [LikeController::class, 'topLiked']);
+    });
   });