588 lines
18 KiB
PHP
588 lines
18 KiB
PHP
<?php
|
|
|
|
namespace App\Http\Controllers;
|
|
|
|
use App\Models\Media;
|
|
use App\Models\Category;
|
|
use App\Models\Tag;
|
|
use Illuminate\Support\Facades\DB;
|
|
use Illuminate\Http\Request;
|
|
use Illuminate\Support\Facades\Storage;
|
|
|
|
class MediaController extends Controller
|
|
{
|
|
// CREATE media
|
|
public function store(Request $request)
|
|
{
|
|
$data = $request->validate([
|
|
'title' => 'required|string|max:255',
|
|
'caption' => 'nullable|string',
|
|
'type' => 'required|in:audio,video',
|
|
'category_id' => 'nullable|exists:categories,id',
|
|
'category_name' => 'nullable|string|max:255',
|
|
'image_id' => 'nullable|exists:images,id',
|
|
'duration' => 'nullable|integer',
|
|
'is_premium' => 'nullable|boolean',
|
|
'file' => 'nullable|mimes:mp3,wav,mp4,mov|max:512000',
|
|
'external_url' => 'nullable|string',
|
|
'visibility' => 'nullable|in:public,private',
|
|
|
|
'tags' => 'nullable|array',
|
|
'tags.*' => 'string',
|
|
]);
|
|
|
|
$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');
|
|
}
|
|
|
|
$media = Media::create([
|
|
'user_id' => auth()->id(),
|
|
'title' => $data['title'],
|
|
'caption' => $data['caption'] ?? null,
|
|
'type' => $data['type'],
|
|
'file_path' => $path,
|
|
'external_url' => $data['external_url'] ?? null,
|
|
'image_id' => $data['image_id'] ?? null,
|
|
'category_id' => $categoryId,
|
|
'duration' => $data['duration'] ?? null,
|
|
'visibility' => $data['visibility'] ?? 'public',
|
|
'is_premium'=> $data['is_premium'] ?? false
|
|
]);
|
|
if (!empty($data['tags'])) {
|
|
$tagIds = [];
|
|
|
|
foreach ($data['tags'] as $tagName) {
|
|
$tag = Tag::firstOrCreate(['name' => $tagName]);
|
|
$tagIds[] = $tag->id;
|
|
}
|
|
|
|
$media->tags()->sync($tagIds);
|
|
}
|
|
return response()->json([
|
|
'message' => 'Media created successfully',
|
|
'media' => $media->load(['image', 'category' , 'tags']),
|
|
]);
|
|
}
|
|
public function index(Request $request)
|
|
{
|
|
$query = Media::with(['image', 'category', 'myNote', 'tags','comments'])
|
|
->where(function ($q) {
|
|
$q->where('visibility', 'public')
|
|
->orWhere('user_id', auth()->id());
|
|
});
|
|
|
|
/*
|
|
|--------------------------------------------------------------------------
|
|
| 1️⃣ Multi Category
|
|
|--------------------------------------------------------------------------
|
|
*/
|
|
|
|
if ($request->filled('categories')) {
|
|
$categories = explode(',', $request->categories);
|
|
$query->whereIn('category_id', $categories);
|
|
}
|
|
|
|
/*
|
|
|--------------------------------------------------------------------------
|
|
| 2️⃣ Multi Duration Ranges
|
|
|--------------------------------------------------------------------------
|
|
| duration stored in minutes (integer)
|
|
|--------------------------------------------------------------------------
|
|
*/
|
|
|
|
if ($request->filled('durations')) {
|
|
|
|
$ranges = explode(',', $request->durations);
|
|
|
|
$query->where(function ($q) use ($ranges) {
|
|
|
|
foreach ($ranges as $range) {
|
|
|
|
if ($range === '1-2') {
|
|
$q->orWhereBetween('duration', [1, 2]);
|
|
}
|
|
|
|
if ($range === '2-5') {
|
|
$q->orWhereBetween('duration', [3, 5]);
|
|
}
|
|
|
|
if ($range === '5-10') {
|
|
$q->orWhereBetween('duration', [6, 10]);
|
|
}
|
|
if ($range === '10-30') {
|
|
$q->orWhereBetween('duration', [10, 30]);
|
|
}
|
|
if ($range === '30-60') {
|
|
$q->orWhereBetween('duration', [30, 60]);
|
|
}
|
|
if ($range === '60-120') {
|
|
$q->orWhereBetween('duration', [60, 120]);
|
|
}
|
|
|
|
if ($range === 'other') {
|
|
$q->orWhere('duration', '>', 120);
|
|
}
|
|
}
|
|
|
|
});
|
|
}
|
|
|
|
/*
|
|
|--------------------------------------------------------------------------
|
|
| 3️⃣ Tags
|
|
|--------------------------------------------------------------------------
|
|
*/
|
|
|
|
if ($request->filled('tags')) {
|
|
$tags = explode(',', $request->tags);
|
|
|
|
$query->whereHas('tags', function ($q) use ($tags) {
|
|
$q->whereIn('name', $tags);
|
|
});
|
|
}
|
|
|
|
/*
|
|
|--------------------------------------------------------------------------
|
|
| 4️⃣ Search
|
|
|--------------------------------------------------------------------------
|
|
*/
|
|
|
|
if ($request->filled('search')) {
|
|
|
|
$search = $request->search;
|
|
|
|
$query->where(function ($q) use ($search) {
|
|
|
|
$q->where('title', 'LIKE', "%$search%")
|
|
->orWhere('caption', 'LIKE', "%$search%")
|
|
->orWhereHas('category', function ($c) use ($search) {
|
|
$c->where('name', 'LIKE', "%$search%");
|
|
})
|
|
->orWhereHas('tags', function ($t) use ($search) {
|
|
$t->where('name', 'LIKE', "%$search%");
|
|
});
|
|
|
|
});
|
|
}
|
|
|
|
return response()->json(
|
|
$query->orderBy('created_at', 'desc')->get()
|
|
);
|
|
}
|
|
|
|
public function submitFeedback(Request $request, $mediaId)
|
|
{
|
|
$request->validate([
|
|
'stars' => 'nullable|integer|min:1|max:5',
|
|
'content' => 'nullable|string|max:2000',
|
|
]);
|
|
|
|
// حداقل یکی باید ارسال شود
|
|
if (!$request->filled('stars') && !$request->filled('content')) {
|
|
return response()->json([
|
|
'message' => 'Stars or comment is required'
|
|
], 422);
|
|
}
|
|
|
|
$media = Media::where('id', $mediaId)
|
|
->where(function ($q) {
|
|
$q->where('visibility', 'public')
|
|
->orWhere('user_id', auth()->id());
|
|
})
|
|
->firstOrFail();
|
|
|
|
DB::beginTransaction();
|
|
|
|
try {
|
|
|
|
$rating = null;
|
|
$comment = null;
|
|
|
|
/*
|
|
|--------------------------------------------------------------------------
|
|
| ⭐ Handle Rating (update or create)
|
|
|--------------------------------------------------------------------------
|
|
*/
|
|
|
|
if ($request->filled('stars')) {
|
|
$rating = $media->ratings()->updateOrCreate(
|
|
['user_id' => auth()->id()],
|
|
['stars' => $request->stars]
|
|
);
|
|
}
|
|
|
|
/*
|
|
|--------------------------------------------------------------------------
|
|
| 💬 Handle Comment (create only if exists)
|
|
|--------------------------------------------------------------------------
|
|
*/
|
|
|
|
if ($request->filled('content')) {
|
|
$comment = $media->comments()->create([
|
|
'user_id' => auth()->id(),
|
|
'content' => $request->content,
|
|
]);
|
|
}
|
|
|
|
DB::commit();
|
|
|
|
return response()->json([
|
|
'message' => 'Feedback submitted successfully',
|
|
'average_rating' => $media->fresh()->average_rating,
|
|
'your_rating' => optional($rating)->stars,
|
|
'comment' => $comment ? $comment->load('user') : null,
|
|
]);
|
|
|
|
} catch (\Exception $e) {
|
|
|
|
DB::rollBack();
|
|
|
|
return response()->json([
|
|
'message' => 'Something went wrong',
|
|
'error' => $e->getMessage()
|
|
], 500);
|
|
}
|
|
}
|
|
public function filters(Request $request)
|
|
{
|
|
$baseQuery = Media::query()
|
|
->where(function ($q) {
|
|
$q->where('visibility', 'public')
|
|
->orWhere('user_id', auth()->id());
|
|
});
|
|
|
|
/*
|
|
|--------------------------------------------------------------------------
|
|
| 1️⃣ Categories with media count
|
|
|--------------------------------------------------------------------------
|
|
*/
|
|
|
|
$categories = Category::select(
|
|
'categories.id',
|
|
'categories.name',
|
|
DB::raw('COUNT(media.id) as media_count')
|
|
)
|
|
->leftJoin('media', function ($join) {
|
|
$join->on('categories.id', '=', 'media.category_id')
|
|
->where(function ($q) {
|
|
$q->where('media.visibility', 'public')
|
|
->orWhere('media.user_id', auth()->id());
|
|
});
|
|
})
|
|
->groupBy('categories.id', 'categories.name')
|
|
->orderByDesc('media_count')
|
|
->get();
|
|
|
|
|
|
/*
|
|
|--------------------------------------------------------------------------
|
|
| 2️⃣ Duration ranges
|
|
|--------------------------------------------------------------------------
|
|
| duration is stored in seconds
|
|
|--------------------------------------------------------------------------
|
|
*/
|
|
|
|
$durations = Media::select(
|
|
DB::raw("
|
|
CASE
|
|
WHEN duration BETWEEN 1 AND 2 THEN '1-2'
|
|
WHEN duration BETWEEN 3 AND 5 THEN '2-5'
|
|
WHEN duration BETWEEN 5 AND 10 THEN '5-10'
|
|
WHEN duration BETWEEN 10 AND 20 THEN '10-20'
|
|
WHEN duration BETWEEN 20 AND 30 THEN '20-30'
|
|
WHEN duration BETWEEN 60 AND 120 THEN '60-120'
|
|
ELSE 'other'
|
|
END as duration_range
|
|
"),
|
|
DB::raw('COUNT(*) as total')
|
|
)
|
|
->whereNotNull('duration')
|
|
->where(function ($q) {
|
|
$q->where('visibility', 'public')
|
|
->orWhere('user_id', auth()->id());
|
|
})
|
|
->groupBy('duration_range')
|
|
->get();
|
|
|
|
return response()->json([
|
|
'categories' => $categories,
|
|
'durations' => $durations,
|
|
]);
|
|
}
|
|
|
|
public function show($id)
|
|
{
|
|
$media = Media::with([
|
|
'image',
|
|
'category',
|
|
'myNote',
|
|
'tags',
|
|
'comments' => function($query) {
|
|
$query->with('user')->latest()->limit(10);
|
|
},
|
|
'ratings'
|
|
])
|
|
->where('id', $id)
|
|
->where(function($query) {
|
|
$query->where('visibility', 'public')
|
|
->orWhere('user_id', auth()->id());
|
|
})
|
|
->firstOrFail();
|
|
|
|
// Get user's specific comment
|
|
$userComment = $media->userComment();
|
|
|
|
// Get paginated comments
|
|
$comments = $media->comments()
|
|
->with('user')
|
|
->latest()
|
|
->paginate(15);
|
|
|
|
return response()->json([
|
|
'id' => $media->id,
|
|
'title' => $media->title,
|
|
'caption' => $media->caption,
|
|
'type' => $media->type,
|
|
'file_path' => $media->file_path,
|
|
'external_url' => $media->external_url,
|
|
'duration' => $media->duration,
|
|
'visibility' => $media->visibility,
|
|
'created_at' => $media->created_at,
|
|
'updated_at' => $media->updated_at,
|
|
'is_premium' => $media->is_premium,
|
|
'image' => $media->image,
|
|
'category' => $media->category,
|
|
'tags' => $media->tags,
|
|
'myNote' => $media->myNote,
|
|
'is_saved' => $media->is_saved,
|
|
'statistics' => [
|
|
'average_rating' => $media->average_rating,
|
|
'total_ratings' => $media->ratings_count,
|
|
'total_comments' => $media->comments_count,
|
|
'rating_distribution' => $media->rating_distribution,
|
|
],
|
|
'user_interaction' => [
|
|
'has_rated' => $media->has_user_rated,
|
|
'user_rating' => $media->user_rating,
|
|
'has_commented' => $media->has_user_commented,
|
|
'user_comment' => $media->user_comment,
|
|
'user_comment_id' => $media->user_comment_id,
|
|
],
|
|
'comments' => $comments,
|
|
]);
|
|
}
|
|
public function rate(Request $request, $mediaId)
|
|
{
|
|
$request->validate([
|
|
'stars' => 'required|integer|min:1|max:5'
|
|
]);
|
|
|
|
$media = Media::findOrFail($mediaId);
|
|
|
|
$rating = $media->ratings()->updateOrCreate(
|
|
['user_id' => auth()->id()],
|
|
['stars' => $request->stars]
|
|
);
|
|
|
|
return response()->json([
|
|
'message' => 'Rating saved',
|
|
'average_rating' => $media->fresh()->average_rating,
|
|
'your_rating' => $rating->stars
|
|
]);
|
|
}
|
|
|
|
public function storeComment(Request $request, $mediaId)
|
|
{
|
|
$request->validate([
|
|
'content' => 'required|string|max:1000'
|
|
]);
|
|
|
|
$media = Media::findOrFail($mediaId);
|
|
|
|
$comment = $media->comments()->create([
|
|
'user_id' => auth()->id(),
|
|
'content' => $request->content
|
|
]);
|
|
|
|
return response()->json([
|
|
'message' => 'Comment added',
|
|
'comment' => $comment->load('user')
|
|
]);
|
|
}
|
|
|
|
public function getComments($mediaId)
|
|
{
|
|
$media = Media::findOrFail($mediaId);
|
|
|
|
return response()->json(
|
|
$media->comments()
|
|
->with('user')
|
|
->latest()
|
|
->paginate(10)
|
|
);
|
|
}
|
|
// UPDATE media
|
|
public function update(Request $request, $id)
|
|
{
|
|
$media = Media::where('id', $id)
|
|
->where('user_id', auth()->id())
|
|
->firstOrFail();
|
|
|
|
$data = $request->validate([
|
|
'title' => 'nullable|string',
|
|
'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',
|
|
'is_premium' => 'nullable|boolean',
|
|
'image_id' => 'nullable|exists:images,id',
|
|
'duration' => 'nullable|integer',
|
|
'file' => 'nullable|mimes:mp3,wav,mp4,mov|max:512000',
|
|
'external_url' => 'nullable|string',
|
|
'visibility' => 'nullable|in:public,private',
|
|
'tags' => 'nullable|array',
|
|
'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);
|
|
$data['file_path'] = $request->file('file')->store('media', 'public');
|
|
}
|
|
|
|
// --- Prepare update data ---
|
|
$updateData = [
|
|
'title' => $data['title'] ?? $media->title,
|
|
'caption' => $data['caption'] ?? $media->caption,
|
|
'type' => $data['type'] ?? $media->type,
|
|
'category_id' => $categoryId,
|
|
'is_premium' => $data['is_premium'] ?? $media->is_premium,
|
|
'duration' => $data['duration'] ?? $media->duration,
|
|
'external_url' => $data['external_url'] ?? $media->external_url,
|
|
'visibility' => $data['visibility'] ?? $media->visibility,
|
|
'file_path' => $data['file_path'] ?? $media->file_path,
|
|
];
|
|
|
|
// --- Handle image_id specifically ---
|
|
// If image_id is provided in request, use it (even if null to remove association)
|
|
// If not provided, keep the existing value
|
|
if (array_key_exists('image_id', $data)) {
|
|
$updateData['image_id'] = $data['image_id'];
|
|
} else {
|
|
$updateData['image_id'] = $media->image_id;
|
|
}
|
|
|
|
// --- update media ---
|
|
$media->update($updateData);
|
|
|
|
if (isset($data['tags'])) {
|
|
$tagIds = [];
|
|
|
|
foreach ($data['tags'] as $tagName) {
|
|
$tag = Tag::firstOrCreate(['name' => $tagName]);
|
|
$tagIds[] = $tag->id;
|
|
}
|
|
|
|
$media->tags()->sync($tagIds);
|
|
}
|
|
|
|
return response()->json([
|
|
'message' => 'Media updated successfully',
|
|
'media' => $media->load(['image', 'category' , 'tags']),
|
|
]);
|
|
}
|
|
|
|
|
|
public function destroy($id)
|
|
{
|
|
$media = Media::where('id', $id)
|
|
->where('user_id', auth()->id())
|
|
->firstOrFail();
|
|
|
|
Storage::disk('public')->delete($media->file_path);
|
|
|
|
$media->delete();
|
|
|
|
return response()->json(['message' => 'Media deleted']);
|
|
}
|
|
|
|
// SAVE media
|
|
public function toggleSaveMedia($id)
|
|
{
|
|
$user = auth()->user();
|
|
|
|
if ($user->savedMedia()->where('media_id', $id)->exists()) {
|
|
// already saved → unsave
|
|
$user->savedMedia()->detach($id);
|
|
return response()->json(['message' => 'Unsaved!']);
|
|
} else {
|
|
// not saved → save
|
|
$user->savedMedia()->attach($id);
|
|
return response()->json(['message' => 'Saved!']);
|
|
}
|
|
}
|
|
|
|
// GET saved
|
|
public function saved()
|
|
{
|
|
return auth()->user()->savedMedia()->with(['image','category' , 'myNote' , 'tags'])->get();
|
|
}
|
|
|
|
public function storeNote(Request $request, $mediaId)
|
|
{
|
|
$media = Media::findOrFail($mediaId);
|
|
$userId = auth()->id();
|
|
|
|
$content = $request->input('content');
|
|
|
|
// Check if note already exists for this user
|
|
$note = $media->notes()->where('user_id', $userId)->first();
|
|
|
|
if (empty($content)) {
|
|
// If content is empty, delete the note if it exists
|
|
if ($note) {
|
|
$note->delete();
|
|
return response()->json(['message' => 'Note deleted']);
|
|
}
|
|
return response()->json(['message' => 'No note to delete']);
|
|
}
|
|
|
|
if ($note) {
|
|
// Update existing note
|
|
$note->update(['content' => $content]);
|
|
} else {
|
|
// Create new note
|
|
$note = $media->notes()->create([
|
|
'user_id' => $userId,
|
|
'content' => $content,
|
|
]);
|
|
}
|
|
|
|
return response()->json([
|
|
'message' => 'Note saved successfully',
|
|
'note' => $note
|
|
]);
|
|
}
|
|
|
|
} |